9:05 a.m.
This is a parser for the WFA OWE Transition element. For now the
optional band/channel bytes will not be parsed as hostapd does not
yet support these and would also require the 802.11 appendix E-1
to be added to IWD. Because of this OWE Transition networks are
assumed to be on the same channel as their open counterpart.
---
src/ie.c | 44 ++++++++++++++++++++++++++++++++++++++++++++
src/ie.h | 4 ++++
2 files changed, 48 insertions(+)
v2:
* Changed to [static #] to enforce length
diff --git a/src/ie.c b/src/ie.c
index 1ce1d8a5..7f5b33e5 100644
--- a/src/ie.c
+++ b/src/ie.c
@@ -1343,6 +1343,8 @@ bool is_ie_wfa_ie(const uint8_t *data, uint8_t len, uint8_t
oi_type)
return false;
else if (oi_type == IE_WFA_OI_HS20_INDICATION && len != 5 && len != 7)
return false;
+ else if (oi_type == IE_WFA_OI_OWE_TRANSITION && len < 12)
+ return false;
else if (len < 4) /* OI not handled, but at least check length */
return false;
@@ -2492,3 +2494,45 @@ int ie_parse_network_cost(const void *data, size_t len,
*flags = l_get_le16(ie + 8);
return 0;
}
+
+int ie_parse_owe_transition(const void *data, size_t len,
+ uint8_t bssid[static 6],
+ char ssid[static 33])
+{
+ const uint8_t *ie = data;
+ size_t slen;
+
+ if (len < 14 || ie[0] != IE_TYPE_VENDOR_SPECIFIC)
+ return -ENOMSG;
+
+ if (!is_ie_wfa_ie(ie + 2, len - 2, IE_WFA_OI_OWE_TRANSITION))
+ return -ENOMSG;
+
+ slen = l_get_u8(ie + 12);
+ if (slen > 32)
+ return -ENOMSG;
+
+ /*
+ * WFA OWE Specification 2.3.1
+ *
+ * "Band Info and Channel Info are optional fields. If configured,
+ * both fields shall be included in an OWE Transition Mode element"
+ *
+ * TODO: Support Band/Channel bytes:
+ * For the time being the OWE transition AP is assumed to be on the same
+ * channel as the open AP. This means there should be no band/channel
+ * bytes at the end of the IE. Currently hostapd has no support for this
+ * so it can be skipped. In addition 802.11 Appendix E-1 needs to be
+ * encoded as a table to map Country/operating class to channels to make
+ * any sense of it.
+ */
+ if (len != slen + 13)
+ return -ENOMSG;
+
+ memcpy(bssid, ie + 6, 6);
+
+ memcpy(ssid, ie + 13, slen);
+ ssid[slen] = '\0';
+
+ return 0;
+}
diff --git a/src/ie.h b/src/ie.h
index 4e1c5433..830d6de0 100644
--- a/src/ie.h
+++ b/src/ie.h
@@ -630,3 +630,7 @@ void ie_build_fils_ip_addr_response(
int ie_parse_network_cost(const void *data, size_t len,
uint16_t *flags, uint16_t *level);
+
+int ie_parse_owe_transition(const void *data, size_t len,
+ uint8_t bssid[static 6],
+ char ssid[static 33]);
--
2.31.1
9:05 a.m.
New subject: [PATCH v2 2/7] scan: keep track of OWE Transition element
---
src/scan.c | 6 ++++++
src/scan.h | 2 ++
2 files changed, 8 insertions(+)
diff --git a/src/scan.c b/src/scan.c
index cdc14dbd..5e31c308 100644
--- a/src/scan.c
+++ b/src/scan.c
@@ -936,6 +936,12 @@ static void scan_parse_vendor_specific(struct scan_bss *bss, const
void *data,
return;
}
+ if (is_ie_wfa_ie(data, len, IE_WFA_OI_OWE_TRANSITION)) {
+ ie_parse_owe_transition(data - 2, len + 2, bss->owe_trans_bssid,
+ bss->owe_trans_ssid);
+ return;
+ }
+
if (!ie_parse_network_cost(data, len, &cost_level, &cost_flags)) {
bss->cost_level = cost_level;
bss->cost_flags = cost_flags;
diff --git a/src/scan.h b/src/scan.h
index be8912e6..23de472b 100644
--- a/src/scan.h
+++ b/src/scan.h
@@ -76,6 +76,8 @@ struct scan_bss {
uint64_t parent_tsf;
uint8_t *wfd; /* Concatenated WFD IEs */
ssize_t wfd_size; /* Size of Concatenated WFD IEs */
+ char owe_trans_ssid[33];
+ uint8_t owe_trans_bssid[6];
bool mde_present : 1;
bool cc_present : 1;
bool cap_rm_neighbor_report : 1;
--
2.31.1
9:05 a.m.
New subject: [PATCH v2 3/7] monitor: parse WFA OWE Transition IE
---
monitor/nlmon.c | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/monitor/nlmon.c b/monitor/nlmon.c
index 1a26f553..177147c4 100644
--- a/monitor/nlmon.c
+++ b/monitor/nlmon.c
@@ -1009,6 +1009,21 @@ static void print_ipv4(unsigned int level, const char *label,
addr[0], addr[1], addr[2], addr[3]);
}
+static void print_ie_wfa_owe_transition(unsigned int level, const char *label,
+ const void *data, uint16_t size)
+{
+ uint8_t bssid[6];
+ char ssid[33];
+
+ if (ie_parse_owe_transition(data, size, bssid, ssid) < 0) {
+ print_attr(level + 1, "Error parsing");
+ return;
+ }
+
+ print_attr(level + 1, "BSSID: "MAC, MAC_STR(bssid));
+ print_attr(level + 1, "SSID: %s", ssid);
+}
+
static void print_ie_vendor(unsigned int level, const char *label,
const void *data, uint16_t size)
{
@@ -1054,6 +1069,10 @@ static void print_ie_vendor(unsigned int level, const char *label,
case 0x12:
print_ie_rsn_suites(level + 1, label, data, size);
return;
+ case 0x1c:
+ print_ie_wfa_owe_transition(level + 1, label,
+ data - 6, size + 6);
+ return;
default:
return;
}
--
2.31.1
9:05 a.m.
New subject: [PATCH v2 4/7] network: fix pending hidden OWE scan logic
This was actually broken if triggered because __network_connect
checks if network->connect_after_owe_hidden is set and returns
already in progress. We want to keep this behavior though for
obvious reasons.
To fix this station_connect_network can be called directly which
bypasses the check. This is essentially how ANQP avoids this
problem as well.
---
src/network.c | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
diff --git a/src/network.c b/src/network.c
index 48314a05..4768b872 100644
--- a/src/network.c
+++ b/src/network.c
@@ -1955,11 +1955,9 @@ static void event_watch_changed(enum station_event state,
if (!network->connect_after_owe_hidden)
return;
- reply = __network_connect(network,
+ station_connect_network(network->station, network,
network_bss_select(network, true),
network->connect_after_owe_hidden);
- if (reply)
- l_dbus_send(dbus_get_bus(), reply);
l_dbus_message_unref(network->connect_after_owe_hidden);
network->connect_after_owe_hidden = NULL;
--
2.31.1
2:11 a.m.
New subject: [PATCH v2 4/7] network: fix pending hidden OWE scan logic
Hi James,
On 9/15/21 6:05 PM, James Prestwood wrote:
This was actually broken if triggered because __network_connect
checks if network->connect_after_owe_hidden is set and returns
already in progress. We want to keep this behavior though for
obvious reasons.
To fix this station_connect_network can be called directly which
bypasses the check. This is essentially how ANQP avoids this
problem as well.
---
src/network.c | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
Applied, thanks.
Regards,
-Denis
9:05 a.m.
New subject: [PATCH v2 5/7] station: handle OWE Transition procedure
OWE Transition is described in the WiFi Alliance OWE Specification
version 1.1. The idea behind it is to support both legacy devices
without any concept of OWE as well as modern ones which support the
OWE protocol.
OWE is a somewhat special type of network. Where it advertises an
RSN element but is still "open". This apparently confuses older
devices so the OWE transition procedure was created.
The idea is simple: have two BSS's, one open, and one as a hidden
OWE network. Each network advertises a vendor IE which points to the
other. A device sees the open network and can connect (legacy) or
parse the IE, scan for the hidden OWE network, and connect to that
instead.
Care was taken to handle connections to hidden networks directly.
The policy is being set that any hidden network with the WFA OWE IE
is not connectable via ConnectHiddenNetwork(). These networks are
special, and can only be connected to via the network object for
the paired open network.
When scan results come in from any source (DBus, quick, autoconnect)
each BSS is checked for the OWE Transition IE. A few paths can be
taken here when the IE is found:
1. The BSS is open. The BSSID in the IE is checked against the
current scan results (excluding hidden networks). If a match is
found we should already have the hidden OWE BSS and nothing
else needs to be done (3).
2. The BSS is open. The BSSID in the IE is not found in the
current scan results, and the open network also has no OWE BSS
in it. Add this network to a list to scan for the hidden OWE
BSS.
3. The BSS is not open and contains the OWE IE. This BSS will
automatically get added to the network object and nothing else
needs to be done.
After processing and networks added to this hidden OWE scan list
are processed. Each network should contain a single open BSS with
the OWE IE. The SSID from the IEs are added to the scan parameters
and the scan is started.
The scan results should contain only the (previously hidden) OWE
BSS's. These BSS's should contain the OWE IE which is used to look
up the original open networks. If found the OWE BSS's are added to
their respective networks.
From here network.c can detect that this is an OWE transition
network and connect to the OWE BSS rather than the open one.
---
src/station.c | 248 +++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 245 insertions(+), 3 deletions(-)
v2:
* Changed to use individual scans, this simplifies things and
removes a bunch of lookup logic.
diff --git a/src/station.c b/src/station.c
index 6de5fd4a..dfdd2e9b 100644
--- a/src/station.c
+++ b/src/station.c
@@ -87,6 +87,8 @@ struct station {
uint32_t dbus_scan_id;
uint32_t quick_scan_id;
uint32_t hidden_network_scan_id;
+ uint32_t owe_transition_scan_id;
+ struct l_queue* owe_network_list;
/* Roaming related members */
struct timespec roam_min_time;
@@ -361,6 +363,35 @@ static struct network *station_add_seen_bss(struct station *station,
if (station_parse_bss_security(station, bss, &security) < 0)
return NULL;
+ /* Hidden OWE transition network */
+ if (security == SECURITY_NONE && bss->rsne &&
+ !l_memeqzero(bss->owe_trans_bssid, 6)) {
+ /*
+ * WiFi Alliance OWE Specification v1.1 - Section 2.2.1:
+ *
+ * "2. An OWE AP shall use two different SSIDs, one for OWE
+ * and one for Open"
+ *
+ * "4. The OWE BSS shall include the OWE Transition Mode element
+ * in all Beacon and Probe Response frames to encapsulate
+ * the BSSID and SSID of the Open BSS"
+ *
+ * Meaning the hidden SSID should not match the SSID in the
+ * hidden network's OWE IE. Might as well restrict BSSID as well
+ * to be safe.
+ */
+ if (!memcmp(bss->owe_trans_ssid, bss->ssid, bss->ssid_len))
+ return NULL;
+
+ if (!memcmp(bss->owe_trans_bssid, bss->addr, 6))
+ return NULL;
+
+ memcpy(ssid, bss->owe_trans_ssid, sizeof(bss->owe_trans_ssid));
+
+ l_debug("Found hidden OWE network, using %s for network lookup",
+ ssid);
+ }
+
path = iwd_network_get_path(station, ssid, security);
network = l_hashmap_lookup(station->networks, path);
@@ -625,6 +656,112 @@ static bool station_start_anqp(struct station *station, struct
network *network,
return true;
}
+static unsigned int station_owe_scan(struct station *station,
+ struct network *network);
+
+static bool station_owe_transition_results(int err, struct l_queue *bss_list,
+ const struct scan_freq_set *freqs,
+ void *userdata)
+{
+ struct station *station = userdata;
+ struct network *network = l_queue_peek_head(station->owe_network_list);
+ struct scan_bss *bss;
+
+ station->owe_transition_scan_id = 0;
+
+ station_property_set_scanning(station, false);
+
+ if (err)
+ return err == 0;
+
+ /*
+ * Insert all BSS's into station/network BSS list but don't create a
+ * network for them. The idea here is for the user to connect to the
+ * open network and IWD will transition them to the OWE network
+ * automatically.
+ */
+ while ((bss = l_queue_pop_head(bss_list))) {
+ struct scan_bss *open;
+
+ /*
+ * Don't parse the open BSS, hidden BSS, or BSS with
+ * no OWE Transition IE
+ */
+ if (!bss->rsne || l_memeqzero(bss->owe_trans_bssid, 6) ||
+ util_ssid_is_hidden(bss->ssid_len, bss->ssid))
+ goto free;
+
+ /* Check if the Open network IE matches the BSS we have */
+ open = network_bss_find_by_addr(network, bss->owe_trans_bssid);
+ if (!open)
+ goto free;
+
+ if (memcmp(open->owe_trans_bssid, bss->addr, 6)) {
+ l_warn("BSS in results did not match Open OWE IE!");
+ goto free;
+ }
+
+ l_debug("Adding OWE transition network "MAC" to %s",
+ MAC_STR(bss->addr), network_get_ssid(network));
+
+ l_queue_push_tail(station->bss_list, bss);
+ network_bss_add(network, bss);
+
+ continue;
+
+free:
+ scan_bss_free(bss);
+ }
+
+ l_queue_destroy(bss_list, NULL);
+
+ return true;
+}
+
+static void station_owe_transition_triggered(int err, void *user_data)
+{
+ struct station *station = user_data;
+
+ if (err < 0) {
+ l_debug("OWE transition scan trigger failed: %i", err);
+ return;
+ }
+
+ l_debug("OWE transition scan triggered");
+
+ station_property_set_scanning(station, true);
+}
+
+static void station_owe_transition_destroy(void *userdata)
+{
+ struct station *station = userdata;
+ struct network *network = l_queue_pop_head(station->owe_network_list);
+
+ WATCHLIST_NOTIFY(&event_watches, station_event_watch_func_t,
+ STATION_EVENT_OWE_HIDDEN_FINISHED, network);
+
+ network = l_queue_peek_head(station->owe_network_list);
+ if (network)
+ station->owe_transition_scan_id = station_owe_scan(station,
+ network);
+
+ /* More ongoing scans */
+ if (station->owe_transition_scan_id)
+ return;
+
+ /*
+ * Must resume autoconnect here regardless of an error since this logic
+ * was bypassed in station_set_scan_results
+ */
+ l_queue_destroy(station->autoconnect_list, NULL);
+ station->autoconnect_list = l_queue_new();
+
+ if (station_is_autoconnecting(station)) {
+ station_network_foreach(station, network_add_foreach, station);
+ station_autoconnect_next(station);
+ }
+}
+
static bool bss_free_if_ssid_not_utf8(void *data, void *user_data)
{
struct scan_bss *bss = data;
@@ -641,6 +778,98 @@ static bool bss_free_if_ssid_not_utf8(void *data, void *user_data)
return true;
}
+static bool match_bssid_not_hidden(const void *a, const void *b)
+{
+ const struct scan_bss *bss = a;
+ const uint8_t *bssid = b;
+
+ if (util_ssid_is_hidden(bss->ssid_len, bss->ssid))
+ return false;
+
+ return !memcmp(bss->addr, bssid, sizeof(bss->addr));
+}
+
+static unsigned int station_owe_scan(struct station *station,
+ struct network *network)
+{
+ unsigned int id;
+ struct scan_freq_set *freqs = NULL;
+ struct scan_parameters params = {
+ .flush = true,
+ .randomize_mac_addr_hint = false,
+ };
+ /*
+ * Should be ok doing this as this network will only have a single open
+ * BSS. This is ensured by the checks in station_start_owe_scan()
+ */
+ struct scan_bss *open = network_bss_select(network, true);
+
+ freqs = scan_freq_set_new();
+ /* TODO: Add support for different channel/band info */
+ scan_freq_set_add(freqs, open->frequency);
+
+ params.freqs = freqs;
+ params.ssid = open->owe_trans_ssid;
+
+ id = scan_active_full(netdev_get_wdev_id(station->netdev),
+ ¶ms, station_owe_transition_triggered,
+ station_owe_transition_results, station,
+ station_owe_transition_destroy);
+
+ scan_freq_set_free(freqs);
+
+ return id;
+}
+
+static bool station_start_owe_scan(struct station *station,
+ struct l_queue *bss_list,
+ struct scan_bss *bss,
+ struct network *network)
+{
+ if (l_memeqzero(bss->owe_trans_bssid, 6))
+ return false;
+
+ /* only want the open networks with WFA OWE IE */
+ if (bss->rsne)
+ return false;
+
+ /* BSS already in network object */
+ if (network_bss_find_by_addr(network, bss->owe_trans_bssid))
+ return false;
+
+ /*
+ * If the BSSID of the Open OWE IE is in the results we
+ * are done. station_add_seen_bss will add this to the
+ * network object.
+ *
+ * This is required if the Open BSS appears first in the
+ * new_bss_list and the OWE network hasn't had a chance
+ * to get added to the network.
+ */
+ if (l_queue_find(bss_list, match_bssid_not_hidden,
+ bss->owe_trans_bssid))
+ return false;
+
+ if (!station->owe_transition_scan_id)
+ station->owe_transition_scan_id = station_owe_scan(station,
+ network);
+ if (!station->owe_transition_scan_id) {
+ l_error("Could not scan for hidden OWE network %s",
+ bss->owe_trans_ssid);
+ return false;
+ }
+
+ WATCHLIST_NOTIFY(&event_watches, station_event_watch_func_t,
+ STATION_EVENT_OWE_HIDDEN_STARTED, network);
+
+ if (!station->owe_network_list)
+ station->owe_network_list = l_queue_new();
+
+ l_queue_push_tail(station->owe_network_list, network);
+
+ return true;
+}
+
/*
* Used when scan results were obtained; either from scan running
* inside station module or scans running in other state machines, e.g. wsc
@@ -652,7 +881,7 @@ void station_set_scan_results(struct station *station,
{
const struct l_queue_entry *bss_entry;
struct network *network;
- bool wait_for_anqp = false;
+ bool wait = false;
l_queue_foreach_remove(new_bss_list, bss_free_if_ssid_not_utf8, NULL);
@@ -700,14 +929,17 @@ void station_set_scan_results(struct station *station,
continue;
if (station_start_anqp(station, network, bss))
- wait_for_anqp = true;
+ wait = true;
+
+ if (station_start_owe_scan(station, new_bss_list, bss, network))
+ wait = true;
}
station->bss_list = new_bss_list;
l_hashmap_foreach_remove(station->networks, process_network, station);
- if (!wait_for_anqp && add_to_autoconnect) {
+ if (!wait && add_to_autoconnect) {
station_network_foreach(station, network_add_foreach, station);
station_autoconnect_next(station);
}
@@ -2902,6 +3134,10 @@ static struct l_dbus_message *station_dbus_connect_hidden_network(
l_queue_get_entries(station->hidden_bss_list_sorted);
struct scan_bss *target = network_bss_select(network, true);
+ /* Treat OWE transition networks special */
+ if (!l_memeqzero(target->owe_trans_bssid, 6))
+ goto not_hidden;
+
for (; entry; entry = entry->next) {
struct scan_bss *bss = entry->data;
@@ -2913,6 +3149,7 @@ static struct l_dbus_message *station_dbus_connect_hidden_network(
message);
}
+not_hidden:
return dbus_error_not_hidden(message);
}
@@ -3673,9 +3910,14 @@ static void station_free(struct station *station)
scan_cancel(netdev_get_wdev_id(station->netdev),
station->hidden_network_scan_id);
+ if (station->owe_transition_scan_id)
+ scan_cancel(netdev_get_wdev_id(station->netdev),
+ station->owe_transition_scan_id);
+
station_roam_state_clear(station);
l_queue_destroy(station->networks_sorted, NULL);
+ l_queue_destroy(station->owe_network_list, NULL);
l_hashmap_destroy(station->networks, network_free);
l_queue_destroy(station->bss_list, bss_free);
l_queue_destroy(station->hidden_bss_list_sorted, NULL);
--
2.31.1
9:05 a.m.
New subject: [PATCH v2 6/7] network: prefer OWE transition BSS over open
There isn't much control station has with how BSS's are inserted to
a network object. The rank algorithm makes that decision. Because of
this we could end up in a situation where the Open BSS is preferred
over the OWE transition BSS.
In attempt to better handle this any Open BSS in this type of network
will not be chosen unless its the only candidate (e.g. no other BSSs,
inability to connect with OWE, or an improperly configured network).
---
src/network.c | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
v2:
* Set candidate if it is not already OWE
diff --git a/src/network.c b/src/network.c
index 4768b872..bc35ddea 100644
--- a/src/network.c
+++ b/src/network.c
@@ -1105,6 +1105,11 @@ const struct l_queue_entry *network_bss_list_get_entries(
return l_queue_get_entries(network->bss_list);
}
+static bool bss_is_owe(struct scan_bss *bss)
+{
+ return !l_memeqzero(bss->owe_trans_bssid, 6) && bss->rsne;
+}
+
struct scan_bss *network_bss_select(struct network *network,
bool fallback_to_blacklist)
{
@@ -1130,6 +1135,17 @@ struct scan_bss *network_bss_select(struct network *network,
if (!candidate)
candidate = bss;
+ /* OWE Transition BSS */
+ if (!l_memeqzero(bss->owe_trans_bssid, 6)) {
+ /* Don't want to connect to the Open BSS if possible */
+ if (!bss->rsne)
+ continue;
+
+ /* Candidate is not OWE, set this as new candidate */
+ if (!bss_is_owe(candidate))
+ candidate = bss;
+ }
+
/* check if temporarily blacklisted */
if (l_queue_find(network->blacklist, match_bss, bss))
continue;
--
2.31.1
9:05 a.m.
New subject: [PATCH v2 7/7] auto-t: add testOWE-transition
This adds several tests for OWE transition networks. Hostapd
does have special options for these networks but currently their
implementation is incorrect as the IE is not ever added to the
OWE BSS. Besides that using vendor_elements provides a much easier
way to create invalid IEs to test.
---
.../testOWE-transition/connection_test.py | 156 ++++++++++++++++++
autotests/testOWE-transition/hw.conf | 10 ++
autotests/testOWE-transition/main.conf | 2 +
autotests/testOWE-transition/ssidOWE.conf | 14 ++
autotests/testOWE-transition/ssidOpen.conf | 8 +
autotests/testOWE-transition/transition.open | 0
6 files changed, 190 insertions(+)
create mode 100644 autotests/testOWE-transition/connection_test.py
create mode 100644 autotests/testOWE-transition/hw.conf
create mode 100644 autotests/testOWE-transition/main.conf
create mode 100644 autotests/testOWE-transition/ssidOWE.conf
create mode 100644 autotests/testOWE-transition/ssidOpen.conf
create mode 100644 autotests/testOWE-transition/transition.open
diff --git a/autotests/testOWE-transition/connection_test.py
b/autotests/testOWE-transition/connection_test.py
new file mode 100644
index 00000000..b85ea3c9
--- /dev/null
+++ b/autotests/testOWE-transition/connection_test.py
@@ -0,0 +1,156 @@
+#!/usr/bin/python3
+
+import unittest
+import sys
+
+sys.path.append('../util')
+import iwd
+from iwd import IWD
+from iwd import NetworkType
+from hostapd import HostapdCLI
+import testutil
+
+class Test(unittest.TestCase):
+
+ def validate(self, wd, target, autoconnect=False, connect_hidden=False):
+ devices = wd.list_devices(1)
+ device = devices[0]
+ device.autoconnect = autoconnect
+
+ if not autoconnect:
+ if not connect_hidden:
+ condition = 'not obj.scanning'
+ wd.wait_for_object_condition(device, condition)
+
+ device.scan()
+
+ condition = 'obj.scanning'
+ wd.wait_for_object_condition(device, condition)
+
+ condition = 'not obj.scanning'
+ wd.wait_for_object_condition(device, condition)
+
+ network = device.get_ordered_network('transition',
scan_if_needed=False)
+
+ network.network_object.connect()
+ else:
+ device.connect_hidden_network('owe-hidden')
+
+ condition = 'obj.state == DeviceState.connected'
+ wd.wait_for_object_condition(device, condition)
+
+ testutil.test_iface_operstate()
+ testutil.test_ifaces_connected(device.name, target.ifname)
+
+ self.assertIn(device.address, target.list_sta())
+
+ device.disconnect()
+
+ # Normal success case
+ def test_owe_transition(self):
+ self.hapd_open.set_value('vendor_elements',
'dd15506f9a1c02000000f1000a6f77652d68696464656e')
+ self.hapd_open.reload()
+ self.hapd_owe.set_value('vendor_elements',
'dd15506f9a1c02000000f0000a7472616e736974696f6e')
+ self.hapd_owe.reload()
+ self.validate(self.wd, self.hapd_owe)
+
+ # Normal success case
+ def test_owe_transition_multi_network(self):
+ self.hapd_open.set_value('vendor_elements',
'dd15506f9a1c02000000f1000a6f77652d68696464656e')
+ self.hapd_open.reload()
+ self.hapd_owe.set_value('vendor_elements',
'dd15506f9a1c02000000f0000a7472616e736974696f6e')
+ self.hapd_owe.reload()
+
+ self.hapd_open2.set_value('vendor_elements',
'dd17506f9a1c02000000f1000c6f77652d68696464656e2d32')
+ self.hapd_open2.reload()
+ self.hapd_owe2.set_value('vendor_elements',
'dd17506f9a1c02000000f0000c7472616e736974696f6e2d32')
+ self.hapd_owe2.reload()
+
+ self.validate(self.wd, self.hapd_owe)
+
+ # Normal success autoconnect case
+ def test_owe_transition_autoconnect(self):
+ self.hapd_open.set_value('vendor_elements',
'dd15506f9a1c02000000f1000a6f77652d68696464656e')
+ self.hapd_open.reload()
+ self.hapd_owe.set_value('vendor_elements',
'dd15506f9a1c02000000f0000a7472616e736974696f6e')
+ self.hapd_owe.reload()
+ IWD.copy_to_storage('transition.open')
+
+ self.validate(self.wd, self.hapd_owe, autoconnect=True)
+
+ # Open BSS has invalid BSSID in OWE transition element
+ # Expected connection to Open BSS
+ def test_owe_transition_invalid_open_bssid(self):
+ self.hapd_open.set_value('vendor_elements',
'dd15506f9a1c02000000ff000a6f77652d68696464656e')
+ self.hapd_open.reload()
+ self.hapd_owe.set_value('vendor_elements',
'dd15506f9a1c02000000f0000a7472616e736974696f6e')
+ self.hapd_owe.reload()
+
+ self.validate(self.wd, self.hapd_open)
+
+ # OWE BSS has invalid BSSID in OWE transition element
+ # Expected connection to Open BSS
+ def test_owe_transition_invalid_owe_bssid(self):
+ self.hapd_open.set_value('vendor_elements',
'dd15506f9a1c02000000f1000a6f77652d68696464656e')
+ self.hapd_open.reload()
+ self.hapd_owe.set_value('vendor_elements',
'dd15506f9a1c02000000ff000a7472616e736974696f6e')
+ self.hapd_owe.reload()
+
+ self.validate(self.wd, self.hapd_open)
+
+ # No OWE hidden network exists
+ # Expected connection to Open BSS
+ def test_owe_transition_no_hidden_found(self):
+ self.hapd_open.set_value('vendor_elements',
'dd15506f9a1c02000000f1000a6f77652d68696464656e')
+ self.hapd_open.reload()
+ self.hapd_owe.disable()
+
+ self.validate(self.wd, self.hapd_open)
+
+ # Directly connect to valid OWE hidden network
+ # Expected connection failure
+ def test_owe_transition_connect_hidden_valid(self):
+ self.hapd_open.set_value('vendor_elements',
'dd15506f9a1c02000000f1000a6f77652d68696464656e')
+ self.hapd_open.reload()
+ self.hapd_owe.set_value('vendor_elements',
'dd15506f9a1c02000000f0000a7472616e736974696f6e')
+ self.hapd_owe.reload()
+
+ with self.assertRaises(iwd.NotFoundEx):
+ self.validate(self.wd, self.hapd_owe, connect_hidden=True)
+
+ # Directly connect to invalid OWE hidden network. The SSID in the OWE BSS
+ # IE points to itself. And the Open BSS IE points to a non-existent SSID.
+ # Expected connection failure
+ def test_owe_transition_connect_hidden_invalid(self):
+ self.hapd_open.set_value('vendor_elements',
'dd18506f9a1c02000000f1000d6e6f2d6f77652d68696464656e')
+ self.hapd_open.reload()
+ self.hapd_owe.set_value('vendor_elements',
'dd15506f9a1c02000000f0000a6f77652d68696464656e')
+ self.hapd_owe.reload()
+
+ with self.assertRaises(iwd.NotFoundEx):
+ self.validate(self.wd, self.hapd_owe, connect_hidden=True)
+
+ def setUp(self):
+ self.wd = IWD(True)
+ self.hapd_owe = HostapdCLI(config='ssidOWE.conf')
+ self.hapd_open = HostapdCLI(config='ssidOpen.conf')
+ self.hapd_owe2 = HostapdCLI(config='ssidOWE-2.conf')
+ self.hapd_open2 = HostapdCLI(config='ssidOpen-2.conf')
+
+ def tearDown(self):
+ IWD.clear_storage()
+
+ self.wd = None
+ self.hapd_open = None
+ self.hapd_owe = None
+
+ @classmethod
+ def setUpClass(cls):
+ pass
+
+ @classmethod
+ def tearDownClass(cls):
+ IWD.clear_storage()
+
+if __name__ == '__main__':
+ unittest.main(exit=True)
diff --git a/autotests/testOWE-transition/hw.conf b/autotests/testOWE-transition/hw.conf
new file mode 100644
index 00000000..dbd70597
--- /dev/null
+++ b/autotests/testOWE-transition/hw.conf
@@ -0,0 +1,10 @@
+[SETUP]
+num_radios=5
+hwsim_medium=yes
+start_iwd=0
+
+[HOSTAPD]
+rad0=ssidOpen.conf
+rad1=ssidOWE.conf
+rad2=ssidOpen-2.conf
+rad3=ssidOWE-2.conf
diff --git a/autotests/testOWE-transition/main.conf
b/autotests/testOWE-transition/main.conf
new file mode 100644
index 00000000..9452fb6b
--- /dev/null
+++ b/autotests/testOWE-transition/main.conf
@@ -0,0 +1,2 @@
+[Scan]
+DisableMacAddressRandomization=true
diff --git a/autotests/testOWE-transition/ssidOWE.conf
b/autotests/testOWE-transition/ssidOWE.conf
new file mode 100644
index 00000000..c54309ae
--- /dev/null
+++ b/autotests/testOWE-transition/ssidOWE.conf
@@ -0,0 +1,14 @@
+ssid=owe-hidden
+bssid=02:00:00:00:f1:00
+channel=1
+ignore_broadcast_ssid=1
+ieee80211w=1
+
+wpa=2
+wpa_key_mgmt=OWE
+rsn_pairwise=CCMP
+
+# You would conventionally use these options but hostapd does not include an
+# IE for the OWE network, hence vendor_elements must be used directly
+#owe_transition_ssid="transition"
+#owe_transition_bssid=02:00:00:00:f0:00
diff --git a/autotests/testOWE-transition/ssidOpen.conf
b/autotests/testOWE-transition/ssidOpen.conf
new file mode 100644
index 00000000..4fc68430
--- /dev/null
+++ b/autotests/testOWE-transition/ssidOpen.conf
@@ -0,0 +1,8 @@
+channel=1
+ssid=transition
+bssid=02:00:00:00:f0:00
+
+# You would conventionally use these options but hostapd does not include an
+# IE for the OWE network, hence vendor_elements must be used directly
+#owe_transition_ssid="owe-hidden"
+#owe_transition_bssid=02:00:00:00:f1:00
diff --git a/autotests/testOWE-transition/transition.open
b/autotests/testOWE-transition/transition.open
new file mode 100644
index 00000000..e69de29b
--
2.31.1
367
days inactive
368
days old
7 comments
2 participants
participants (2)
-
Denis Kenzior -
James Prestwood