5:39 a.m.
Specifically OWE networks with multiple open/hidden BSS's are troublesome
to scan for with the current APIs. The scan parameters are limited to a
single SSID and even if that was changed we have the potential of hitting
the max SSID's per scan limit. In all, it puts the burden onto the caller
to sort out the SSIDs/frequencies to scan for.
Rather than requiring station to handle this a new scan API was added,
scan_owe_hidden() which takes a list of open BSS's and will automatically
scan for the SSIDs in the OWE transition IE for each.
It is slightly optimized to first check if all the hidden SSID's are the
same. This is the most likely case (e.g. single pair or single network)
and a single scan command can be used. Otherwise individual scan commands
are queued for each SSID/frequency combo.
---
src/scan.c | 139 ++++++++++++++++++++++++++++++++++++++++++++++++++---
src/scan.h | 3 ++
2 files changed, 134 insertions(+), 8 deletions(-)
diff --git a/src/scan.c b/src/scan.c
index b2f199e5..b9978a7c 100644
--- a/src/scan.c
+++ b/src/scan.c
@@ -583,6 +583,27 @@ static const struct wiphy_radio_work_item_ops work_ops = {
.destroy = scan_request_free,
};
+static struct scan_request *scan_request_new(struct scan_context *sc,
+ bool passive,
+ scan_trigger_func_t trigger,
+ scan_notify_func_t notify,
+ void *userdata,
+ scan_destroy_func_t destroy)
+{
+ struct scan_request *sr;
+
+ sr = l_new(struct scan_request, 1);
+ sr->sc = sc;
+ sr->trigger = trigger;
+ sr->callback = notify;
+ sr->userdata = userdata;
+ sr->destroy = destroy;
+ sr->passive = passive;
+ sr->cmds = l_queue_new();
+
+ return sr;
+}
+
static uint32_t scan_common(uint64_t wdev_id, bool passive,
const struct scan_parameters *params,
scan_trigger_func_t trigger,
@@ -597,14 +618,7 @@ static uint32_t scan_common(uint64_t wdev_id, bool passive,
if (!sc)
return 0;
- sr = l_new(struct scan_request, 1);
- sr->sc = sc;
- sr->trigger = trigger;
- sr->callback = notify;
- sr->userdata = userdata;
- sr->destroy = destroy;
- sr->passive = passive;
- sr->cmds = l_queue_new();
+ sr = scan_request_new(sc, passive, trigger, notify, userdata, destroy);
scan_cmds_add(sr->cmds, sc, passive, params);
@@ -656,6 +670,115 @@ uint32_t scan_active_full(uint64_t wdev_id,
trigger, notify, userdata, destroy);
}
+static void add_owe_scan_cmd(struct scan_context *sc, struct scan_request *sr,
+ bool ignore_flush,
+ struct scan_freq_set *freqs,
+ const struct scan_bss *bss)
+{
+ struct l_genl_msg *cmd;
+ struct scan_parameters params = {};
+ struct scan_freq_set *tmp;
+
+ if (!freqs) {
+ tmp = scan_freq_set_new();
+ scan_freq_set_add(tmp, bss->frequency);
+ params.freqs = tmp;
+ } else
+ params.freqs = freqs;
+
+ params.ssid = bss->owe_trans_ssid;
+ params.ssid_len = bss->owe_trans_ssid_len;
+ params.flush = true;
+
+ cmd = scan_build_cmd(sc, ignore_flush, false, ¶ms);
+
+ l_genl_msg_enter_nested(cmd, NL80211_ATTR_SCAN_SSIDS);
+ l_genl_msg_append_attr(cmd, 0, params.ssid_len, params.ssid);
+ l_genl_msg_leave_nested(cmd);
+
+ l_queue_push_tail(sr->cmds, cmd);
+
+ if (!freqs)
+ scan_freq_set_free(tmp);
+}
+
+uint32_t scan_owe_hidden(uint64_t wdev_id, struct l_queue *list,
+ scan_trigger_func_t trigger, scan_notify_func_t notify,
+ void *userdata, scan_destroy_func_t destroy)
+{
+ struct scan_context *sc;
+ struct scan_request *sr;
+ struct scan_freq_set *freqs;
+ const struct l_queue_entry *entry;
+ const uint8_t *ssid = NULL;
+ size_t ssid_len;
+ bool same_ssid = true;
+ const struct scan_bss *bss;
+ bool ignore_flush = false;
+
+ sc = l_queue_find(scan_contexts, scan_context_match, &wdev_id);
+
+ if (!sc)
+ return 0;
+
+ sr = scan_request_new(sc, false, trigger, notify, userdata, destroy);
+
+ freqs = scan_freq_set_new();
+
+ /*
+ * Start building up a frequency list if all SSIDs are the same. This
+ * is hopefully the common case and will allow a single scan command.
+ */
+ for (entry = l_queue_get_entries(list); entry; entry = entry->next) {
+ struct scan_bss *bss = entry->data;
+
+ scan_freq_set_add(freqs, bss->frequency);
+
+ /* First */
+ if (!ssid) {
+ ssid = bss->owe_trans_ssid;
+ ssid_len = bss->owe_trans_ssid_len;
+ continue;
+ }
+
+ if (ssid_len == bss->owe_trans_ssid_len &&
+ !memcmp(ssid, bss->owe_trans_ssid,
+ bss->owe_trans_ssid_len))
+ continue;
+
+ same_ssid = false;
+ break;
+ }
+
+ if (same_ssid) {
+ bss = l_queue_peek_head(list);
+
+ add_owe_scan_cmd(sc, sr, ignore_flush, freqs, bss);
+
+ scan_freq_set_free(freqs);
+
+ goto done;
+ }
+
+ scan_freq_set_free(freqs);
+
+ /* SSIDs differed, use separate scan commands. */
+ for (entry = l_queue_get_entries(list); entry; entry = entry->next) {
+ struct scan_bss *bss = entry->data;
+
+ add_owe_scan_cmd(sc, sr, ignore_flush, NULL, bss);
+
+ /* Ignore flush on all subsequent commands */
+ if (!ignore_flush)
+ ignore_flush = true;
+ }
+
+done:
+ l_queue_push_tail(sc->requests, sr);
+
+ return wiphy_radio_work_insert(sc->wiphy, &sr->work, 2, &work_ops);
+}
+
bool scan_cancel(uint64_t wdev_id, uint32_t id)
{
struct scan_context *sc;
diff --git a/src/scan.h b/src/scan.h
index 99c66bb8..8f481f10 100644
--- a/src/scan.h
+++ b/src/scan.h
@@ -147,6 +147,9 @@ uint32_t scan_active_full(uint64_t wdev_id,
const struct scan_parameters *params,
scan_trigger_func_t trigger, scan_notify_func_t notify,
void *userdata, scan_destroy_func_t destroy);
+uint32_t scan_owe_hidden(uint64_t wdev_id, struct l_queue *list,
+ scan_trigger_func_t trigger, scan_notify_func_t notify,
+ void *userdata, scan_destroy_func_t destroy);
bool scan_cancel(uint64_t wdev_id, uint32_t id);
void scan_periodic_start(uint64_t wdev_id, scan_trigger_func_t trigger,
--
2.31.1
5:39 a.m.
New subject: [PATCH v5 2/4] 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 BSS 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.
The populated BSS list is passed to scan_owe_hidden. The 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, and network is notified.
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 | 264 ++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 264 insertions(+)
v5:
* Changed logic to use new scan_owe_hidden API. This takes the
burden off station to sort out SSID's/frequencies, as well as
consolidates all scan results into a single callback which is
much easier to process.
diff --git a/src/station.c b/src/station.c
index e9bc7e65..29523795 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_scan_list;
/* Roaming related members */
struct timespec roam_min_time;
@@ -254,6 +256,9 @@ static void station_autoconnect_start(struct station *station)
if (!l_queue_isempty(station->anqp_pending))
return;
+ if (station->owe_transition_scan_id)
+ return;
+
if (L_WARN_ON(station->autoconnect_list))
l_queue_destroy(station->autoconnect_list, NULL);
@@ -395,6 +400,44 @@ 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.
+ *
+ * In addition this SSID must be a valid utf8 string otherwise
+ * we could not look up the network. Note that this is not true
+ * for the open BSS IE, it can be non-utf8.
+ */
+ if (!util_ssid_is_utf8(bss->owe_trans_ssid_len,
+ bss->owe_trans_ssid))
+ return NULL;
+
+ 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));
+ ssid[bss->owe_trans_ssid_len] = '\0';
+
+ 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);
@@ -645,6 +688,139 @@ static bool station_start_anqp(struct station *station, struct
network *network,
return true;
}
+static bool owe_open_bss_match(const void *a, const void *b)
+{
+ const struct scan_bss *open = a;
+ const struct scan_bss *owe = b;
+
+ /*
+ * Check if this is an Open/Hidden pair:
+ *
+ * Open SSID equals the SSID in OWE IE
+ * Open BSSID equals the BSSID in OWE IE
+ *
+ * OWE SSID equals the SSID in Open IE
+ * OWE BSSID equals the BSSID in Open IE
+ */
+ return open->ssid_len == owe->owe_trans_ssid_len &&
+ open->owe_trans_ssid_len == owe->ssid_len &&
+ !memcmp(open->ssid, owe->owe_trans_ssid, open->ssid_len) &&
+ !memcmp(open->owe_trans_ssid, owe->ssid, owe->ssid_len) &&
+ !memcmp(open->addr, owe->owe_trans_bssid, 6) &&
+ !memcmp(open->owe_trans_bssid, owe->addr, 6);
+}
+
+static bool bss_match_ssid(const void *a, const void *b)
+{
+ const struct scan_bss *bss = a;
+ const struct scan_bss *bss_new = b;
+
+ return bss->ssid_len == bss_new->ssid_len &&
+ !memcmp(bss->ssid, bss_new->ssid, bss->ssid_len);
+}
+
+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;
+ struct scan_bss *bss;
+
+ station->owe_transition_scan_id = 0;
+
+ station_property_set_scanning(station, false);
+
+ if (err)
+ return err == 0;
+
+ while ((bss = l_queue_pop_head(bss_list))) {
+ struct scan_bss *open;
+
+ /*
+ * Don't handle the open BSS, hidden BSS, BSS with no OWE
+ * Transition IE, or an IE with a non-utf8 SSID
+ */
+ if (!bss->rsne || l_memeqzero(bss->owe_trans_bssid, 6) ||
+ util_ssid_is_hidden(bss->ssid_len, bss->ssid) ||
+ !util_ssid_is_utf8(bss->owe_trans_ssid_len,
+ bss->owe_trans_ssid))
+ goto free;
+
+ /* Check if we have an open BSS that matches */
+ open = l_queue_find(station->owe_scan_list,
+ owe_open_bss_match, bss);
+ if (!open)
+ goto free;
+
+ network = station_network_find(station,
+ util_ssid_to_utf8(open->ssid_len, open->ssid),
+ SECURITY_NONE);
+ if (L_WARN_ON(!network))
+ 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);
+
+ /* Networks get notified in destroy */
+ 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;
+ struct scan_bss *open;
+
+ while ((open = l_queue_pop_head(station->owe_scan_list))) {
+ network = station_network_find(station,
+ util_ssid_to_utf8(open->ssid_len, open->ssid),
+ SECURITY_NONE);
+ if (L_WARN_ON(!network))
+ continue;
+
+ /*
+ * Check if there are any pending BSS's with the same SSID we
+ * only want to notify network once.
+ */
+ if (!l_queue_find(station->owe_scan_list, bss_match_ssid, open))
+ WATCHLIST_NOTIFY(&event_watches,
+ station_event_watch_func_t,
+ STATION_EVENT_OWE_HIDDEN_FINISHED,
+ network);
+ }
+
+ l_queue_destroy(station->owe_scan_list, NULL);
+ station->owe_scan_list = NULL;
+
+ station_autoconnect_start(station);
+}
+
static bool bss_free_if_ssid_not_utf8(void *data, void *user_data)
{
struct scan_bss *bss = data;
@@ -661,6 +837,80 @@ 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 bool station_build_owe_list(struct station *station,
+ struct l_queue *bss_list,
+ struct scan_bss *bss,
+ struct network *network,
+ struct l_queue **list)
+{
+ 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 (!*list)
+ *list = l_queue_new();
+
+ /*
+ * The network for this BSS may have already been notified in the case
+ * of multiple Open BSS's. We do still want to push the BSS here in case
+ * the frequency is different but only notify this network once.
+ */
+ if (!l_queue_find(*list, bss_match_ssid, bss))
+ WATCHLIST_NOTIFY(&event_watches, station_event_watch_func_t,
+ STATION_EVENT_OWE_HIDDEN_STARTED, network);
+
+ l_queue_push_head(*list, bss);
+
+ return true;
+}
+
+static bool station_start_owe_scan(struct station *station,
+ struct l_queue *list)
+{
+ station->owe_transition_scan_id = scan_owe_hidden(
+ netdev_get_wdev_id(station->netdev),
+ list, station_owe_transition_triggered,
+ station_owe_transition_results, station,
+ station_owe_transition_destroy);
+ if (!station->owe_transition_scan_id)
+ return false;
+
+ station->owe_scan_list = list;
+
+ 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
@@ -672,6 +922,7 @@ void station_set_scan_results(struct station *station,
{
const struct l_queue_entry *bss_entry;
struct network *network;
+ struct l_queue *owe_scan_list = NULL;
l_queue_foreach_remove(new_bss_list, bss_free_if_ssid_not_utf8, NULL);
@@ -723,6 +974,14 @@ void station_set_scan_results(struct station *station,
continue;
station_start_anqp(station, network, bss);
+
+ station_build_owe_list(station, new_bss_list, bss, network,
+ &owe_scan_list);
+ }
+
+ if (owe_scan_list) {
+ if (!station_start_owe_scan(station, owe_scan_list))
+ l_queue_destroy(owe_scan_list, NULL);
}
station->bss_list = new_bss_list;
@@ -3705,9 +3964,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_scan_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
5:39 a.m.
New subject: [PATCH v5 3/4] 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(+)
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
5:39 a.m.
New subject: [PATCH v5 4/4] 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 | 222 ++++++++++++++++++
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, 256 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..7240e3a8
--- /dev/null
+++ b/autotests/testOWE-transition/connection_test.py
@@ -0,0 +1,222 @@
+#!/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()
+
+ if type(target) != list:
+ testutil.test_ifaces_connected(device.name, target.ifname)
+ self.assertIn(device.address, target.list_sta())
+ else:
+ found = False
+ for t in target:
+ if device.address in t.list_sta():
+ testutil.test_ifaces_connected(device.name, t.ifname)
+ found = True
+
+ self.assertTrue(found)
+
+ 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.hapd_owe2.disable()
+ self.hapd_open2.disable()
+
+ 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.set_value('ssid', 'transition-2')
+ self.hapd_open2.reload()
+ self.hapd_owe2.set_value('vendor_elements',
'dd17506f9a1c02000000f0000c7472616e736974696f6e2d32')
+ self.hapd_owe2.set_value('ssid', 'owe-hidden-2')
+ self.hapd_owe2.reload()
+
+ self.validate(self.wd, self.hapd_owe)
+
+ # Two pairs of open/OWE BSS's (OWE BSS's have different SSIDs) */
+ def test_owe_transition_multi_bss(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',
'dd17506f9a1c02000000f3000c6f77652d68696464656e2d32')
+ self.hapd_open2.set_value('ssid', 'transition')
+ self.hapd_open2.reload()
+ self.hapd_owe2.set_value('vendor_elements',
'dd15506f9a1c02000000f2000a7472616e736974696f6e')
+ self.hapd_owe2.set_value('ssid', 'owe-hidden-2')
+ self.hapd_owe2.reload()
+
+ self.validate(self.wd, [self.hapd_owe, self.hapd_owe2])
+
+ # Two pairs of open/OWE BSS's (OWE BSS's have same SSID) */
+ def test_owe_transition_multi_bss_same_ssid(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',
'dd15506f9a1c02000000f3000a6f77652d68696464656e')
+ self.hapd_open2.set_value('ssid', 'transition')
+ self.hapd_open2.reload()
+ self.hapd_owe2.set_value('vendor_elements',
'dd15506f9a1c02000000f2000a7472616e736974696f6e')
+ self.hapd_owe2.set_value('ssid', 'owe-hidden')
+ self.hapd_owe2.reload()
+
+ self.validate(self.wd, [self.hapd_owe, self.hapd_owe2])
+
+ # 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()
+
+ self.hapd_owe2.disable()
+ self.hapd_open2.disable()
+
+ 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.hapd_owe2.disable()
+ self.hapd_open2.disable()
+
+ 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.hapd_owe2.disable()
+ self.hapd_open2.disable()
+
+ 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.hapd_owe2.disable()
+ self.hapd_open2.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()
+
+ self.hapd_owe2.disable()
+ self.hapd_open2.disable()
+
+ 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()
+
+ self.hapd_owe2.disable()
+ self.hapd_open2.disable()
+
+ 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
366
days inactive
366
days old
3 comments
1 participants
participants (1)
-
James Prestwood