tests/hwsim/test_ap_ft.py

   1 # Fast BSS Transition tests
   2 # Copyright (c) 2013-2019, Jouni Malinen <j@w1.fi>
   3 #
   4 # This software may be distributed under the terms of the BSD license.
   5 # See README for more details.
   6
   7 from remotehost import remote_compatible
   8 import binascii
   9 import os
  10 import time
  11 import logging
  12 logger = logging.getLogger()
  13 import signal
  14 import struct
  15 import subprocess
  16
  17 import hwsim_utils
  18 from hwsim import HWSimRadio
  19 import hostapd
  20 from tshark import run_tshark
  21 from utils import HwsimSkip, alloc_fail, fail_test, wait_fail_trigger, skip_with_fips, parse_ie
  22 from wlantest import Wlantest
  23 from test_ap_psk import check_mib, find_wpas_process, read_process_memory, verify_not_present, get_key_locations
  24 from test_rrm import check_beacon_req
  25
  26 def ft_base_rsn():
  27     params = {"wpa": "2",
  28               "wpa_key_mgmt": "FT-PSK",
  29               "rsn_pairwise": "CCMP"}
  30     return params
  31
  32 def ft_base_mixed():
  33     params = {"wpa": "3",
  34               "wpa_key_mgmt": "WPA-PSK FT-PSK",
  35               "wpa_pairwise": "TKIP",
  36               "rsn_pairwise": "CCMP"}
  37     return params
  38
  39 def ft_params(rsn=True, ssid=None, passphrase=None):
  40     if rsn:
  41         params = ft_base_rsn()
  42     else:
  43         params = ft_base_mixed()
  44     if ssid:
  45         params["ssid"] = ssid
  46     if passphrase:
  47         params["wpa_passphrase"] = passphrase
  48
  49     params["mobility_domain"] = "a1b2"
  50     params["r0_key_lifetime"] = "10000"
  51     params["pmk_r1_push"] = "1"
  52     params["reassociation_deadline"] = "1000"
  53     return params
  54
  55 def ft_params1a(rsn=True, ssid=None, passphrase=None):
  56     params = ft_params(rsn, ssid, passphrase)
  57     params['nas_identifier'] = "nas1.w1.fi"
  58     params['r1_key_holder'] = "000102030405"
  59     return params
  60
  61 def ft_params1(rsn=True, ssid=None, passphrase=None, discovery=False):
  62     params = ft_params1a(rsn, ssid, passphrase)
  63     if discovery:
  64         params['r0kh'] = "ff:ff:ff:ff:ff:ff * 100102030405060708090a0b0c0d0e0f100102030405060708090a0b0c0d0e0f"
  65         params['r1kh'] = "00:00:00:00:00:00 00:00:00:00:00:00 100102030405060708090a0b0c0d0e0f100102030405060708090a0b0c0d0e0f"
  66     else:
  67         params['r0kh'] = ["02:00:00:00:03:00 nas1.w1.fi 100102030405060708090a0b0c0d0e0f100102030405060708090a0b0c0d0e0f",
  68                           "02:00:00:00:04:00 nas2.w1.fi 300102030405060708090a0b0c0d0e0f300102030405060708090a0b0c0d0e0f"]
  69         params['r1kh'] = "02:00:00:00:04:00 00:01:02:03:04:06 200102030405060708090a0b0c0d0e0f200102030405060708090a0b0c0d0e0f"
  70     return params
  71
  72 def ft_params1_old_key(rsn=True, ssid=None, passphrase=None):
  73     params = ft_params1a(rsn, ssid, passphrase)
  74     params['r0kh'] = ["02:00:00:00:03:00 nas1.w1.fi 100102030405060708090a0b0c0d0e0f",
  75                       "02:00:00:00:04:00 nas2.w1.fi 300102030405060708090a0b0c0d0e0f"]
  76     params['r1kh'] = "02:00:00:00:04:00 00:01:02:03:04:06 200102030405060708090a0b0c0d0e0f"
  77     return params
  78
  79 def ft_params2a(rsn=True, ssid=None, passphrase=None):
  80     params = ft_params(rsn, ssid, passphrase)
  81     params['nas_identifier'] = "nas2.w1.fi"
  82     params['r1_key_holder'] = "000102030406"
  83     return params
  84
  85 def ft_params2(rsn=True, ssid=None, passphrase=None, discovery=False):
  86     params = ft_params2a(rsn, ssid, passphrase)
  87     if discovery:
  88         params['r0kh'] = "ff:ff:ff:ff:ff:ff * 100102030405060708090a0b0c0d0e0f100102030405060708090a0b0c0d0e0f"
  89         params['r1kh'] = "00:00:00:00:00:00 00:00:00:00:00:00 100102030405060708090a0b0c0d0e0f100102030405060708090a0b0c0d0e0f"
  90     else:
  91         params['r0kh'] = ["02:00:00:00:03:00 nas1.w1.fi 200102030405060708090a0b0c0d0e0f200102030405060708090a0b0c0d0e0f",
  92                           "02:00:00:00:04:00 nas2.w1.fi 000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f"]
  93         params['r1kh'] = "02:00:00:00:03:00 00:01:02:03:04:05 300102030405060708090a0b0c0d0e0f300102030405060708090a0b0c0d0e0f"
  94     return params
  95
  96 def ft_params2_old_key(rsn=True, ssid=None, passphrase=None):
  97     params = ft_params2a(rsn, ssid, passphrase)
  98     params['r0kh'] = ["02:00:00:00:03:00 nas1.w1.fi 200102030405060708090a0b0c0d0e0f",
  99                       "02:00:00:00:04:00 nas2.w1.fi 000102030405060708090a0b0c0d0e0f"]
 100     params['r1kh'] = "02:00:00:00:03:00 00:01:02:03:04:05 300102030405060708090a0b0c0d0e0f"
 101     return params
 102
 103 def ft_params1_r0kh_mismatch(rsn=True, ssid=None, passphrase=None):
 104     params = ft_params(rsn, ssid, passphrase)
 105     params['nas_identifier'] = "nas1.w1.fi"
 106     params['r1_key_holder'] = "000102030405"
 107     params['r0kh'] = ["02:00:00:00:03:00 nas1.w1.fi 100102030405060708090a0b0c0d0e0f100102030405060708090a0b0c0d0e0f",
 108                       "12:00:00:00:04:00 nas2.w1.fi 300102030405060708090a0b0c0d0e0f300102030405060708090a0b0c0d0e0f"]
 109     params['r1kh'] = "12:00:00:00:04:00 10:01:02:03:04:06 200102030405060708090a0b0c0d0e0f200102030405060708090a0b0c0d0e0f"
 110     return params
 111
 112 def ft_params2_incorrect_rrb_key(rsn=True, ssid=None, passphrase=None):
 113     params = ft_params(rsn, ssid, passphrase)
 114     params['nas_identifier'] = "nas2.w1.fi"
 115     params['r1_key_holder'] = "000102030406"
 116     params['r0kh'] = ["02:00:00:00:03:00 nas1.w1.fi 200102030405060708090a0b0c0d0ef1200102030405060708090a0b0c0d0ef1",
 117                       "02:00:00:00:04:00 nas2.w1.fi 000102030405060708090a0b0c0d0ef2000102030405060708090a0b0c0d0ef2"]
 118     params['r1kh'] = "02:00:00:00:03:00 00:01:02:03:04:05 300102030405060708090a0b0c0d0ef3300102030405060708090a0b0c0d0ef3"
 119     return params
 120
 121 def ft_params2_r0kh_mismatch(rsn=True, ssid=None, passphrase=None):
 122     params = ft_params(rsn, ssid, passphrase)
 123     params['nas_identifier'] = "nas2.w1.fi"
 124     params['r1_key_holder'] = "000102030406"
 125     params['r0kh'] = ["12:00:00:00:03:00 nas1.w1.fi 200102030405060708090a0b0c0d0e0f200102030405060708090a0b0c0d0e0f",
 126                       "02:00:00:00:04:00 nas2.w1.fi 000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f"]
 127     params['r1kh'] = "12:00:00:00:03:00 10:01:02:03:04:05 300102030405060708090a0b0c0d0e0f300102030405060708090a0b0c0d0e0f"
 128     return params
 129
 130 def run_roams(dev, apdev, hapd0, hapd1, ssid, passphrase, over_ds=False,
 131               sae=False, eap=False, fail_test=False, roams=1,
 132               pairwise_cipher="CCMP", group_cipher="TKIP CCMP", ptk_rekey="0",
 133               test_connectivity=True, eap_identity="gpsk user", conndev=False,
 134               force_initial_conn_to_first_ap=False, sha384=False,
 135               group_mgmt=None, ocv=None, sae_password=None,
 136               sae_password_id=None, sae_and_psk=False):
 137     logger.info("Connect to first AP")
 138
 139     copts = {}
 140     copts["proto"] = "WPA2"
 141     copts["ieee80211w"] = "1"
 142     copts["scan_freq"] = "2412"
 143     copts["pairwise"] = pairwise_cipher
 144     copts["group"] = group_cipher
 145     copts["wpa_ptk_rekey"] = ptk_rekey
 146     if group_mgmt:
 147         copts["group_mgmt"] = group_mgmt
 148     if ocv:
 149         copts["ocv"] = ocv
 150     if eap:
 151         copts["key_mgmt"] = "FT-EAP-SHA384" if sha384 else "FT-EAP"
 152         copts["eap"] = "GPSK"
 153         copts["identity"] = eap_identity
 154         copts["password"] = "abcdefghijklmnop0123456789abcdef"
 155     else:
 156         if sae:
 157             copts["key_mgmt"] = "SAE FT-SAE" if sae_and_psk else "FT-SAE"
 158         else:
 159             copts["key_mgmt"] = "FT-PSK"
 160         if passphrase:
 161             copts["psk"] = passphrase
 162         if sae_password:
 163             copts["sae_password"] = sae_password
 164         if sae_password_id:
 165             copts["sae_password_id"] = sae_password_id
 166     if force_initial_conn_to_first_ap:
 167         copts["bssid"] = apdev[0]['bssid']
 168     dev.connect(ssid, **copts)
 169
 170     if dev.get_status_field('bssid') == apdev[0]['bssid']:
 171         ap1 = apdev[0]
 172         ap2 = apdev[1]
 173         hapd1ap = hapd0
 174         hapd2ap = hapd1
 175     else:
 176         ap1 = apdev[1]
 177         ap2 = apdev[0]
 178         hapd1ap = hapd1
 179         hapd2ap = hapd0
 180     if test_connectivity:
 181         if conndev:
 182             hwsim_utils.test_connectivity_iface(dev, hapd1ap, conndev)
 183         else:
 184             hwsim_utils.test_connectivity(dev, hapd1ap)
 185
 186     dev.scan_for_bss(ap2['bssid'], freq="2412")
 187
 188     for i in range(0, roams):
 189         # Roaming artificially fast can make data test fail because the key is
 190         # set later.
 191         time.sleep(0.01)
 192         logger.info("Roam to the second AP")
 193         if over_ds:
 194             dev.roam_over_ds(ap2['bssid'], fail_test=fail_test)
 195         else:
 196             dev.roam(ap2['bssid'], fail_test=fail_test)
 197         if fail_test:
 198             return
 199         if dev.get_status_field('bssid') != ap2['bssid']:
 200             raise Exception("Did not connect to correct AP")
 201         if (i == 0 or i == roams - 1) and test_connectivity:
 202             if conndev:
 203                 hwsim_utils.test_connectivity_iface(dev, hapd2ap, conndev)
 204             else:
 205                 hwsim_utils.test_connectivity(dev, hapd2ap)
 206
 207         # Roaming artificially fast can make data test fail because the key is
 208         # set later.
 209         time.sleep(0.01)
 210         logger.info("Roam back to the first AP")
 211         if over_ds:
 212             dev.roam_over_ds(ap1['bssid'])
 213         else:
 214             dev.roam(ap1['bssid'])
 215         if dev.get_status_field('bssid') != ap1['bssid']:
 216             raise Exception("Did not connect to correct AP")
 217         if (i == 0 or i == roams - 1) and test_connectivity:
 218             if conndev:
 219                 hwsim_utils.test_connectivity_iface(dev, hapd1ap, conndev)
 220             else:
 221                 hwsim_utils.test_connectivity(dev, hapd1ap)
 222
 223 def test_ap_ft(dev, apdev):
 224     """WPA2-PSK-FT AP"""
 225     ssid = "test-ft"
 226     passphrase = "12345678"
 227
 228     params = ft_params1(ssid=ssid, passphrase=passphrase)
 229     hapd0 = hostapd.add_ap(apdev[0], params)
 230     params = ft_params2(ssid=ssid, passphrase=passphrase)
 231     hapd1 = hostapd.add_ap(apdev[1], params)
 232
 233     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase)
 234     if "[WPA2-FT/PSK-CCMP]" not in dev[0].request("SCAN_RESULTS"):
 235         raise Exception("Scan results missing RSN element info")
 236
 237 def test_ap_ft_old_key(dev, apdev):
 238     """WPA2-PSK-FT AP (old key)"""
 239     ssid = "test-ft"
 240     passphrase = "12345678"
 241
 242     params = ft_params1_old_key(ssid=ssid, passphrase=passphrase)
 243     hapd0 = hostapd.add_ap(apdev[0], params)
 244     params = ft_params2_old_key(ssid=ssid, passphrase=passphrase)
 245     hapd1 = hostapd.add_ap(apdev[1], params)
 246
 247     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase)
 248
 249 def test_ap_ft_multi_akm(dev, apdev):
 250     """WPA2-PSK-FT AP with non-FT AKMs enabled"""
 251     ssid = "test-ft"
 252     passphrase = "12345678"
 253
 254     params = ft_params1(ssid=ssid, passphrase=passphrase)
 255     params["wpa_key_mgmt"] = "FT-PSK WPA-PSK WPA-PSK-SHA256"
 256     hapd0 = hostapd.add_ap(apdev[0], params)
 257     params = ft_params2(ssid=ssid, passphrase=passphrase)
 258     params["wpa_key_mgmt"] = "FT-PSK WPA-PSK WPA-PSK-SHA256"
 259     hapd1 = hostapd.add_ap(apdev[1], params)
 260
 261     Wlantest.setup(hapd0)
 262     wt = Wlantest()
 263     wt.flush()
 264     wt.add_passphrase(passphrase)
 265
 266     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase)
 267     if "[WPA2-PSK+FT/PSK+PSK-SHA256-CCMP]" not in dev[0].request("SCAN_RESULTS"):
 268         raise Exception("Scan results missing RSN element info")
 269     dev[1].connect(ssid, psk=passphrase, scan_freq="2412")
 270     dev[2].connect(ssid, psk=passphrase, key_mgmt="WPA-PSK-SHA256",
 271                    scan_freq="2412")
 272
 273 def test_ap_ft_local_key_gen(dev, apdev):
 274     """WPA2-PSK-FT AP with local key generation (without pull/push)"""
 275     ssid = "test-ft"
 276     passphrase = "12345678"
 277
 278     params = ft_params1a(ssid=ssid, passphrase=passphrase)
 279     params['ft_psk_generate_local'] = "1"
 280     del params['pmk_r1_push']
 281     hapd0 = hostapd.add_ap(apdev[0], params)
 282     params = ft_params2a(ssid=ssid, passphrase=passphrase)
 283     params['ft_psk_generate_local'] = "1"
 284     del params['pmk_r1_push']
 285     hapd1 = hostapd.add_ap(apdev[1], params)
 286
 287     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase)
 288     if "[WPA2-FT/PSK-CCMP]" not in dev[0].request("SCAN_RESULTS"):
 289         raise Exception("Scan results missing RSN element info")
 290
 291 def test_ap_ft_vlan(dev, apdev):
 292     """WPA2-PSK-FT AP with VLAN"""
 293     ssid = "test-ft"
 294     passphrase = "12345678"
 295
 296     params = ft_params1(ssid=ssid, passphrase=passphrase)
 297     params['dynamic_vlan'] = "1"
 298     params['accept_mac_file'] = "hostapd.accept"
 299     hapd0 = hostapd.add_ap(apdev[0]['ifname'], params)
 300
 301     params = ft_params2(ssid=ssid, passphrase=passphrase)
 302     params['dynamic_vlan'] = "1"
 303     params['accept_mac_file'] = "hostapd.accept"
 304     hapd1 = hostapd.add_ap(apdev[1]['ifname'], params)
 305
 306     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, conndev="brvlan1")
 307     if "[WPA2-FT/PSK-CCMP]" not in dev[0].request("SCAN_RESULTS"):
 308         raise Exception("Scan results missing RSN element info")
 309
 310 def test_ap_ft_vlan_disconnected(dev, apdev):
 311     """WPA2-PSK-FT AP with VLAN and local key generation"""
 312     ssid = "test-ft"
 313     passphrase = "12345678"
 314
 315     params = ft_params1a(ssid=ssid, passphrase=passphrase)
 316     params['dynamic_vlan'] = "1"
 317     params['accept_mac_file'] = "hostapd.accept"
 318     params['ft_psk_generate_local'] = "1"
 319     hapd0 = hostapd.add_ap(apdev[0]['ifname'], params)
 320
 321     params = ft_params2a(ssid=ssid, passphrase=passphrase)
 322     params['dynamic_vlan'] = "1"
 323     params['accept_mac_file'] = "hostapd.accept"
 324     params['ft_psk_generate_local'] = "1"
 325     hapd1 = hostapd.add_ap(apdev[1]['ifname'], params)
 326
 327     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, conndev="brvlan1")
 328     if "[WPA2-FT/PSK-CCMP]" not in dev[0].request("SCAN_RESULTS"):
 329         raise Exception("Scan results missing RSN element info")
 330
 331 def test_ap_ft_vlan_2(dev, apdev):
 332     """WPA2-PSK-FT AP with VLAN and dest-AP does not have VLAN info locally"""
 333     ssid = "test-ft"
 334     passphrase = "12345678"
 335
 336     params = ft_params1(ssid=ssid, passphrase=passphrase)
 337     params['dynamic_vlan'] = "1"
 338     params['accept_mac_file'] = "hostapd.accept"
 339     hapd0 = hostapd.add_ap(apdev[0]['ifname'], params)
 340
 341     params = ft_params2(ssid=ssid, passphrase=passphrase)
 342     params['dynamic_vlan'] = "1"
 343     hapd1 = hostapd.add_ap(apdev[1]['ifname'], params)
 344
 345     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, conndev="brvlan1",
 346               force_initial_conn_to_first_ap=True)
 347     if "[WPA2-FT/PSK-CCMP]" not in dev[0].request("SCAN_RESULTS"):
 348         raise Exception("Scan results missing RSN element info")
 349
 350 def test_ap_ft_many(dev, apdev):
 351     """WPA2-PSK-FT AP multiple times"""
 352     ssid = "test-ft"
 353     passphrase = "12345678"
 354
 355     params = ft_params1(ssid=ssid, passphrase=passphrase)
 356     hapd0 = hostapd.add_ap(apdev[0], params)
 357     params = ft_params2(ssid=ssid, passphrase=passphrase)
 358     hapd1 = hostapd.add_ap(apdev[1], params)
 359
 360     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, roams=50)
 361
 362 def test_ap_ft_many_vlan(dev, apdev):
 363     """WPA2-PSK-FT AP with VLAN multiple times"""
 364     ssid = "test-ft"
 365     passphrase = "12345678"
 366
 367     params = ft_params1(ssid=ssid, passphrase=passphrase)
 368     params['dynamic_vlan'] = "1"
 369     params['accept_mac_file'] = "hostapd.accept"
 370     hapd0 = hostapd.add_ap(apdev[0]['ifname'], params)
 371
 372     params = ft_params2(ssid=ssid, passphrase=passphrase)
 373     params['dynamic_vlan'] = "1"
 374     params['accept_mac_file'] = "hostapd.accept"
 375     hapd1 = hostapd.add_ap(apdev[1]['ifname'], params)
 376
 377     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, roams=50,
 378               conndev="brvlan1")
 379
 380 def test_ap_ft_mixed(dev, apdev):
 381     """WPA2-PSK-FT mixed-mode AP"""
 382     ssid = "test-ft-mixed"
 383     passphrase = "12345678"
 384
 385     params = ft_params1(rsn=False, ssid=ssid, passphrase=passphrase)
 386     hapd = hostapd.add_ap(apdev[0], params)
 387     key_mgmt = hapd.get_config()['key_mgmt']
 388     vals = key_mgmt.split(' ')
 389     if vals[0] != "WPA-PSK" or vals[1] != "FT-PSK":
 390         raise Exception("Unexpected GET_CONFIG(key_mgmt): " + key_mgmt)
 391     params = ft_params2(rsn=False, ssid=ssid, passphrase=passphrase)
 392     hapd1 = hostapd.add_ap(apdev[1], params)
 393
 394     run_roams(dev[0], apdev, hapd, hapd1, ssid, passphrase)
 395
 396 def test_ap_ft_pmf(dev, apdev):
 397     """WPA2-PSK-FT AP with PMF"""
 398     ssid = "test-ft"
 399     passphrase = "12345678"
 400
 401     params = ft_params1(ssid=ssid, passphrase=passphrase)
 402     params["ieee80211w"] = "2"
 403     hapd0 = hostapd.add_ap(apdev[0], params)
 404     params = ft_params2(ssid=ssid, passphrase=passphrase)
 405     params["ieee80211w"] = "2"
 406     hapd1 = hostapd.add_ap(apdev[1], params)
 407
 408     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase)
 409
 410 def test_ap_ft_pmf_bip_cmac_128(dev, apdev):
 411     """WPA2-PSK-FT AP with PMF/BIP-CMAC-128"""
 412     run_ap_ft_pmf_bip(dev, apdev, "AES-128-CMAC")
 413
 414 def test_ap_ft_pmf_bip_gmac_128(dev, apdev):
 415     """WPA2-PSK-FT AP with PMF/BIP-GMAC-128"""
 416     run_ap_ft_pmf_bip(dev, apdev, "BIP-GMAC-128")
 417
 418 def test_ap_ft_pmf_bip_gmac_256(dev, apdev):
 419     """WPA2-PSK-FT AP with PMF/BIP-GMAC-256"""
 420     run_ap_ft_pmf_bip(dev, apdev, "BIP-GMAC-256")
 421
 422 def test_ap_ft_pmf_bip_cmac_256(dev, apdev):
 423     """WPA2-PSK-FT AP with PMF/BIP-CMAC-256"""
 424     run_ap_ft_pmf_bip(dev, apdev, "BIP-CMAC-256")
 425
 426 def run_ap_ft_pmf_bip(dev, apdev, cipher):
 427     if cipher not in dev[0].get_capability("group_mgmt"):
 428         raise HwsimSkip("Cipher %s not supported" % cipher)
 429
 430     ssid = "test-ft"
 431     passphrase = "12345678"
 432
 433     params = ft_params1(ssid=ssid, passphrase=passphrase)
 434     params["ieee80211w"] = "2"
 435     params["group_mgmt_cipher"] = cipher
 436     hapd0 = hostapd.add_ap(apdev[0], params)
 437     params = ft_params2(ssid=ssid, passphrase=passphrase)
 438     params["ieee80211w"] = "2"
 439     params["group_mgmt_cipher"] = cipher
 440     hapd1 = hostapd.add_ap(apdev[1], params)
 441
 442     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase,
 443               group_mgmt=cipher)
 444
 445 def test_ap_ft_ocv(dev, apdev):
 446     """WPA2-PSK-FT AP with OCV"""
 447     ssid = "test-ft"
 448     passphrase = "12345678"
 449
 450     params = ft_params1(ssid=ssid, passphrase=passphrase)
 451     params["ieee80211w"] = "2"
 452     params["ocv"] = "1"
 453     try:
 454         hapd0 = hostapd.add_ap(apdev[0], params)
 455     except Exception as e:
 456         if "Failed to set hostapd parameter ocv" in str(e):
 457             raise HwsimSkip("OCV not supported")
 458         raise
 459     params = ft_params2(ssid=ssid, passphrase=passphrase)
 460     params["ieee80211w"] = "2"
 461     params["ocv"] = "1"
 462     hapd1 = hostapd.add_ap(apdev[1], params)
 463
 464     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, ocv="1")
 465
 466 def test_ap_ft_over_ds(dev, apdev):
 467     """WPA2-PSK-FT AP over DS"""
 468     ssid = "test-ft"
 469     passphrase = "12345678"
 470
 471     params = ft_params1(ssid=ssid, passphrase=passphrase)
 472     hapd0 = hostapd.add_ap(apdev[0], params)
 473     params = ft_params2(ssid=ssid, passphrase=passphrase)
 474     hapd1 = hostapd.add_ap(apdev[1], params)
 475
 476     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True)
 477     check_mib(dev[0], [("dot11RSNAAuthenticationSuiteRequested", "00-0f-ac-4"),
 478                        ("dot11RSNAAuthenticationSuiteSelected", "00-0f-ac-4")])
 479
 480 def cleanup_ap_ft_separate_hostapd():
 481     subprocess.call(["brctl", "delif", "br0ft", "veth0"],
 482                     stderr=open('/dev/null', 'w'))
 483     subprocess.call(["brctl", "delif", "br1ft", "veth1"],
 484                     stderr=open('/dev/null', 'w'))
 485     subprocess.call(["ip", "link", "del", "veth0"],
 486                     stderr=open('/dev/null', 'w'))
 487     subprocess.call(["ip", "link", "del", "veth1"],
 488                     stderr=open('/dev/null', 'w'))
 489     for ifname in ['br0ft', 'br1ft', 'br-ft']:
 490         subprocess.call(['ip', 'link', 'set', 'dev', ifname, 'down'],
 491                         stderr=open('/dev/null', 'w'))
 492         subprocess.call(['brctl', 'delbr', ifname],
 493                         stderr=open('/dev/null', 'w'))
 494
 495 def test_ap_ft_separate_hostapd(dev, apdev, params):
 496     """WPA2-PSK-FT AP and separate hostapd process"""
 497     try:
 498         run_ap_ft_separate_hostapd(dev, apdev, params, False)
 499     finally:
 500         cleanup_ap_ft_separate_hostapd()
 501
 502 def test_ap_ft_over_ds_separate_hostapd(dev, apdev, params):
 503     """WPA2-PSK-FT AP over DS and separate hostapd process"""
 504     try:
 505         run_ap_ft_separate_hostapd(dev, apdev, params, True)
 506     finally:
 507         cleanup_ap_ft_separate_hostapd()
 508
 509 def run_ap_ft_separate_hostapd(dev, apdev, params, over_ds):
 510     ssid = "test-ft"
 511     passphrase = "12345678"
 512     logdir = params['logdir']
 513     pidfile = os.path.join(logdir, 'ap_ft_over_ds_separate_hostapd.pid')
 514     logfile = os.path.join(logdir, 'ap_ft_over_ds_separate_hostapd.hapd')
 515     global_ctrl = '/var/run/hostapd-ft'
 516     br_ifname = 'br-ft'
 517
 518     try:
 519         subprocess.check_call(['brctl', 'addbr', br_ifname])
 520         subprocess.check_call(['brctl', 'setfd', br_ifname, '0'])
 521         subprocess.check_call(['ip', 'link', 'set', 'dev', br_ifname, 'up'])
 522
 523         subprocess.check_call(["ip", "link", "add", "veth0", "type", "veth",
 524                                "peer", "name", "veth0br"])
 525         subprocess.check_call(["ip", "link", "add", "veth1", "type", "veth",
 526                                "peer", "name", "veth1br"])
 527         subprocess.check_call(['ip', 'link', 'set', 'dev', 'veth0br', 'up'])
 528         subprocess.check_call(['ip', 'link', 'set', 'dev', 'veth1br', 'up'])
 529         subprocess.check_call(['brctl', 'addif', br_ifname, 'veth0br'])
 530         subprocess.check_call(['brctl', 'addif', br_ifname, 'veth1br'])
 531
 532         subprocess.check_call(['brctl', 'addbr', 'br0ft'])
 533         subprocess.check_call(['brctl', 'setfd', 'br0ft', '0'])
 534         subprocess.check_call(['ip', 'link', 'set', 'dev', 'br0ft', 'up'])
 535         subprocess.check_call(['ip', 'link', 'set', 'dev', 'veth0', 'up'])
 536         subprocess.check_call(['brctl', 'addif', 'br0ft', 'veth0'])
 537         subprocess.check_call(['brctl', 'addbr', 'br1ft'])
 538         subprocess.check_call(['brctl', 'setfd', 'br1ft', '0'])
 539         subprocess.check_call(['ip', 'link', 'set', 'dev', 'br1ft', 'up'])
 540         subprocess.check_call(['ip', 'link', 'set', 'dev', 'veth1', 'up'])
 541         subprocess.check_call(['brctl', 'addif', 'br1ft', 'veth1'])
 542     except subprocess.CalledProcessError:
 543         raise HwsimSkip("Bridge or veth not supported (kernel CONFIG_VETH)")
 544
 545     with HWSimRadio() as (radio, iface):
 546         prg = os.path.join(logdir, 'alt-hostapd/hostapd/hostapd')
 547         if not os.path.exists(prg):
 548             prg = '../../hostapd/hostapd'
 549         cmd = [prg, '-B', '-ddKt',
 550                '-P', pidfile, '-f', logfile, '-g', global_ctrl]
 551         subprocess.check_call(cmd)
 552
 553         hglobal = hostapd.HostapdGlobal(global_ctrl_override=global_ctrl)
 554         apdev_ft = {'ifname': iface}
 555         apdev2 = [apdev_ft, apdev[1]]
 556
 557         params = ft_params1(ssid=ssid, passphrase=passphrase)
 558         params["r0kh"] = "ff:ff:ff:ff:ff:ff * 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
 559         params["r1kh"] = "00:00:00:00:00:00 00:00:00:00:00:00 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
 560         params['bridge'] = 'br0ft'
 561         hapd0 = hostapd.add_ap(apdev2[0], params,
 562                                global_ctrl_override=global_ctrl)
 563         apdev2[0]['bssid'] = hapd0.own_addr()
 564         params = ft_params2(ssid=ssid, passphrase=passphrase)
 565         params["r0kh"] = "ff:ff:ff:ff:ff:ff * 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
 566         params["r1kh"] = "00:00:00:00:00:00 00:00:00:00:00:00 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
 567         params['bridge'] = 'br1ft'
 568         hapd1 = hostapd.add_ap(apdev2[1], params)
 569
 570         run_roams(dev[0], apdev2, hapd0, hapd1, ssid, passphrase,
 571                   over_ds=over_ds, test_connectivity=False)
 572
 573         hglobal.terminate()
 574
 575     if os.path.exists(pidfile):
 576         with open(pidfile, 'r') as f:
 577             pid = int(f.read())
 578             f.close()
 579         os.kill(pid, signal.SIGTERM)
 580
 581 def test_ap_ft_over_ds_ocv(dev, apdev):
 582     """WPA2-PSK-FT AP over DS"""
 583     ssid = "test-ft"
 584     passphrase = "12345678"
 585
 586     params = ft_params1(ssid=ssid, passphrase=passphrase)
 587     params["ieee80211w"] = "2"
 588     params["ocv"] = "1"
 589     try:
 590         hapd0 = hostapd.add_ap(apdev[0], params)
 591     except Exception as e:
 592         if "Failed to set hostapd parameter ocv" in str(e):
 593             raise HwsimSkip("OCV not supported")
 594         raise
 595     params = ft_params2(ssid=ssid, passphrase=passphrase)
 596     params["ieee80211w"] = "2"
 597     params["ocv"] = "1"
 598     hapd1 = hostapd.add_ap(apdev[1], params)
 599
 600     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
 601               ocv="1")
 602
 603 def test_ap_ft_over_ds_disabled(dev, apdev):
 604     """WPA2-PSK-FT AP over DS disabled"""
 605     ssid = "test-ft"
 606     passphrase = "12345678"
 607
 608     params = ft_params1(ssid=ssid, passphrase=passphrase)
 609     params['ft_over_ds'] = '0'
 610     hapd0 = hostapd.add_ap(apdev[0], params)
 611     params = ft_params2(ssid=ssid, passphrase=passphrase)
 612     params['ft_over_ds'] = '0'
 613     hapd1 = hostapd.add_ap(apdev[1], params)
 614
 615     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
 616               fail_test=True)
 617
 618 def test_ap_ft_vlan_over_ds(dev, apdev):
 619     """WPA2-PSK-FT AP over DS with VLAN"""
 620     ssid = "test-ft"
 621     passphrase = "12345678"
 622
 623     params = ft_params1(ssid=ssid, passphrase=passphrase)
 624     params['dynamic_vlan'] = "1"
 625     params['accept_mac_file'] = "hostapd.accept"
 626     hapd0 = hostapd.add_ap(apdev[0]['ifname'], params)
 627     params = ft_params2(ssid=ssid, passphrase=passphrase)
 628     params['dynamic_vlan'] = "1"
 629     params['accept_mac_file'] = "hostapd.accept"
 630     hapd1 = hostapd.add_ap(apdev[1]['ifname'], params)
 631
 632     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
 633               conndev="brvlan1")
 634     check_mib(dev[0], [("dot11RSNAAuthenticationSuiteRequested", "00-0f-ac-4"),
 635                        ("dot11RSNAAuthenticationSuiteSelected", "00-0f-ac-4")])
 636
 637 def test_ap_ft_over_ds_many(dev, apdev):
 638     """WPA2-PSK-FT AP over DS multiple times"""
 639     ssid = "test-ft"
 640     passphrase = "12345678"
 641
 642     params = ft_params1(ssid=ssid, passphrase=passphrase)
 643     hapd0 = hostapd.add_ap(apdev[0], params)
 644     params = ft_params2(ssid=ssid, passphrase=passphrase)
 645     hapd1 = hostapd.add_ap(apdev[1], params)
 646
 647     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
 648               roams=50)
 649
 650 def test_ap_ft_vlan_over_ds_many(dev, apdev):
 651     """WPA2-PSK-FT AP over DS with VLAN multiple times"""
 652     ssid = "test-ft"
 653     passphrase = "12345678"
 654
 655     params = ft_params1(ssid=ssid, passphrase=passphrase)
 656     params['dynamic_vlan'] = "1"
 657     params['accept_mac_file'] = "hostapd.accept"
 658     hapd0 = hostapd.add_ap(apdev[0]['ifname'], params)
 659     params = ft_params2(ssid=ssid, passphrase=passphrase)
 660     params['dynamic_vlan'] = "1"
 661     params['accept_mac_file'] = "hostapd.accept"
 662     hapd1 = hostapd.add_ap(apdev[1]['ifname'], params)
 663
 664     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
 665               roams=50, conndev="brvlan1")
 666
 667 @remote_compatible
 668 def test_ap_ft_over_ds_unknown_target(dev, apdev):
 669     """WPA2-PSK-FT AP"""
 670     ssid = "test-ft"
 671     passphrase = "12345678"
 672
 673     params = ft_params1(ssid=ssid, passphrase=passphrase)
 674     hapd0 = hostapd.add_ap(apdev[0], params)
 675
 676     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
 677                    scan_freq="2412")
 678     dev[0].roam_over_ds("02:11:22:33:44:55", fail_test=True)
 679
 680 @remote_compatible
 681 def test_ap_ft_over_ds_unexpected(dev, apdev):
 682     """WPA2-PSK-FT AP over DS and unexpected response"""
 683     ssid = "test-ft"
 684     passphrase = "12345678"
 685
 686     params = ft_params1(ssid=ssid, passphrase=passphrase)
 687     hapd0 = hostapd.add_ap(apdev[0], params)
 688     params = ft_params2(ssid=ssid, passphrase=passphrase)
 689     hapd1 = hostapd.add_ap(apdev[1], params)
 690
 691     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
 692                    scan_freq="2412")
 693     if dev[0].get_status_field('bssid') == apdev[0]['bssid']:
 694         ap1 = apdev[0]
 695         ap2 = apdev[1]
 696         hapd1ap = hapd0
 697         hapd2ap = hapd1
 698     else:
 699         ap1 = apdev[1]
 700         ap2 = apdev[0]
 701         hapd1ap = hapd1
 702         hapd2ap = hapd0
 703
 704     addr = dev[0].own_addr()
 705     hapd1ap.set("ext_mgmt_frame_handling", "1")
 706     logger.info("Foreign STA address")
 707     msg = {}
 708     msg['fc'] = 13 << 4
 709     msg['da'] = addr
 710     msg['sa'] = ap1['bssid']
 711     msg['bssid'] = ap1['bssid']
 712     msg['payload'] = binascii.unhexlify("06021122334455660102030405060000")
 713     hapd1ap.mgmt_tx(msg)
 714
 715     logger.info("No over-the-DS in progress")
 716     msg['payload'] = binascii.unhexlify("0602" + addr.replace(':', '') + "0102030405060000")
 717     hapd1ap.mgmt_tx(msg)
 718
 719     logger.info("Non-zero status code")
 720     msg['payload'] = binascii.unhexlify("0602" + addr.replace(':', '') + "0102030405060100")
 721     hapd1ap.mgmt_tx(msg)
 722
 723     hapd1ap.dump_monitor()
 724
 725     dev[0].scan_for_bss(ap2['bssid'], freq="2412")
 726     if "OK" not in dev[0].request("FT_DS " + ap2['bssid']):
 727             raise Exception("FT_DS failed")
 728
 729     req = hapd1ap.mgmt_rx()
 730
 731     logger.info("Foreign Target AP")
 732     msg['payload'] = binascii.unhexlify("0602" + addr.replace(':', '') + "0102030405060000")
 733     hapd1ap.mgmt_tx(msg)
 734
 735     addrs = addr.replace(':', '') + ap2['bssid'].replace(':', '')
 736
 737     logger.info("No IEs")
 738     msg['payload'] = binascii.unhexlify("0602" + addrs + "0000")
 739     hapd1ap.mgmt_tx(msg)
 740
 741     logger.info("Invalid IEs (trigger parsing failure)")
 742     msg['payload'] = binascii.unhexlify("0602" + addrs + "00003700")
 743     hapd1ap.mgmt_tx(msg)
 744
 745     logger.info("Too short MDIE")
 746     msg['payload'] = binascii.unhexlify("0602" + addrs + "000036021122")
 747     hapd1ap.mgmt_tx(msg)
 748
 749     logger.info("Mobility domain mismatch")
 750     msg['payload'] = binascii.unhexlify("0602" + addrs + "00003603112201")
 751     hapd1ap.mgmt_tx(msg)
 752
 753     logger.info("No FTIE")
 754     msg['payload'] = binascii.unhexlify("0602" + addrs + "00003603a1b201")
 755     hapd1ap.mgmt_tx(msg)
 756
 757     logger.info("FTIE SNonce mismatch")
 758     msg['payload'] = binascii.unhexlify("0602" + addrs + "00003603a1b201375e0000" + "00000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000" + "1000000000000000000000000000000000000000000000000000000000000001" + "030a6e6173322e77312e6669")
 759     hapd1ap.mgmt_tx(msg)
 760
 761     logger.info("No R0KH-ID subelem in FTIE")
 762     snonce = binascii.hexlify(req['payload'][111:111+32]).decode()
 763     msg['payload'] = binascii.unhexlify("0602" + addrs + "00003603a1b20137520000" + "00000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000" + snonce)
 764     hapd1ap.mgmt_tx(msg)
 765
 766     logger.info("No R0KH-ID subelem mismatch in FTIE")
 767     snonce = binascii.hexlify(req['payload'][111:111+32]).decode()
 768     msg['payload'] = binascii.unhexlify("0602" + addrs + "00003603a1b201375e0000" + "00000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000" + snonce + "030a11223344556677889900")
 769     hapd1ap.mgmt_tx(msg)
 770
 771     logger.info("No R1KH-ID subelem in FTIE")
 772     r0khid = binascii.hexlify(req['payload'][145:145+10]).decode()
 773     msg['payload'] = binascii.unhexlify("0602" + addrs + "00003603a1b201375e0000" + "00000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000" + snonce + "030a" + r0khid)
 774     hapd1ap.mgmt_tx(msg)
 775
 776     logger.info("No RSNE")
 777     r0khid = binascii.hexlify(req['payload'][145:145+10]).decode()
 778     msg['payload'] = binascii.unhexlify("0602" + addrs + "00003603a1b20137660000" + "00000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000000000" + snonce + "030a" + r0khid + "0106000102030405")
 779     hapd1ap.mgmt_tx(msg)
 780
 781 def test_ap_ft_pmf_over_ds(dev, apdev):
 782     """WPA2-PSK-FT AP over DS with PMF"""
 783     run_ap_ft_pmf_bip_over_ds(dev, apdev, None)
 784
 785 def test_ap_ft_pmf_bip_cmac_128_over_ds(dev, apdev):
 786     """WPA2-PSK-FT AP over DS with PMF/BIP-CMAC-128"""
 787     run_ap_ft_pmf_bip_over_ds(dev, apdev, "AES-128-CMAC")
 788
 789 def test_ap_ft_pmf_bip_gmac_128_over_ds(dev, apdev):
 790     """WPA2-PSK-FT AP over DS with PMF/BIP-GMAC-128"""
 791     run_ap_ft_pmf_bip_over_ds(dev, apdev, "BIP-GMAC-128")
 792
 793 def test_ap_ft_pmf_bip_gmac_256_over_ds(dev, apdev):
 794     """WPA2-PSK-FT AP over DS with PMF/BIP-GMAC-256"""
 795     run_ap_ft_pmf_bip_over_ds(dev, apdev, "BIP-GMAC-256")
 796
 797 def test_ap_ft_pmf_bip_cmac_256_over_ds(dev, apdev):
 798     """WPA2-PSK-FT AP over DS with PMF/BIP-CMAC-256"""
 799     run_ap_ft_pmf_bip_over_ds(dev, apdev, "BIP-CMAC-256")
 800
 801 def run_ap_ft_pmf_bip_over_ds(dev, apdev, cipher):
 802     if cipher and cipher not in dev[0].get_capability("group_mgmt"):
 803         raise HwsimSkip("Cipher %s not supported" % cipher)
 804
 805     ssid = "test-ft"
 806     passphrase = "12345678"
 807
 808     params = ft_params1(ssid=ssid, passphrase=passphrase)
 809     params["ieee80211w"] = "2"
 810     if cipher:
 811         params["group_mgmt_cipher"] = cipher
 812     hapd0 = hostapd.add_ap(apdev[0], params)
 813     params = ft_params2(ssid=ssid, passphrase=passphrase)
 814     params["ieee80211w"] = "2"
 815     if cipher:
 816         params["group_mgmt_cipher"] = cipher
 817     hapd1 = hostapd.add_ap(apdev[1], params)
 818
 819     Wlantest.setup(hapd0)
 820     wt = Wlantest()
 821     wt.flush()
 822     wt.add_passphrase(passphrase)
 823
 824     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
 825               group_mgmt=cipher)
 826
 827 def test_ap_ft_over_ds_pull(dev, apdev):
 828     """WPA2-PSK-FT AP over DS (pull PMK)"""
 829     ssid = "test-ft"
 830     passphrase = "12345678"
 831
 832     params = ft_params1(ssid=ssid, passphrase=passphrase)
 833     params["pmk_r1_push"] = "0"
 834     hapd0 = hostapd.add_ap(apdev[0], params)
 835     params = ft_params2(ssid=ssid, passphrase=passphrase)
 836     params["pmk_r1_push"] = "0"
 837     hapd1 = hostapd.add_ap(apdev[1], params)
 838
 839     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True)
 840
 841 def test_ap_ft_over_ds_pull_old_key(dev, apdev):
 842     """WPA2-PSK-FT AP over DS (pull PMK; old key)"""
 843     ssid = "test-ft"
 844     passphrase = "12345678"
 845
 846     params = ft_params1_old_key(ssid=ssid, passphrase=passphrase)
 847     params["pmk_r1_push"] = "0"
 848     hapd0 = hostapd.add_ap(apdev[0], params)
 849     params = ft_params2_old_key(ssid=ssid, passphrase=passphrase)
 850     params["pmk_r1_push"] = "0"
 851     hapd1 = hostapd.add_ap(apdev[1], params)
 852
 853     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True)
 854
 855 def test_ap_ft_over_ds_pull_vlan(dev, apdev):
 856     """WPA2-PSK-FT AP over DS (pull PMK) with VLAN"""
 857     ssid = "test-ft"
 858     passphrase = "12345678"
 859
 860     params = ft_params1(ssid=ssid, passphrase=passphrase)
 861     params["pmk_r1_push"] = "0"
 862     params['dynamic_vlan'] = "1"
 863     params['accept_mac_file'] = "hostapd.accept"
 864     hapd0 = hostapd.add_ap(apdev[0]['ifname'], params)
 865     params = ft_params2(ssid=ssid, passphrase=passphrase)
 866     params["pmk_r1_push"] = "0"
 867     params['dynamic_vlan'] = "1"
 868     params['accept_mac_file'] = "hostapd.accept"
 869     hapd1 = hostapd.add_ap(apdev[1]['ifname'], params)
 870
 871     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
 872               conndev="brvlan1")
 873
 874 def test_ap_ft_sae(dev, apdev):
 875     """WPA2-PSK-FT-SAE AP"""
 876     if "SAE" not in dev[0].get_capability("auth_alg"):
 877         raise HwsimSkip("SAE not supported")
 878     ssid = "test-ft"
 879     passphrase = "12345678"
 880
 881     params = ft_params1(ssid=ssid, passphrase=passphrase)
 882     params['wpa_key_mgmt'] = "FT-SAE"
 883     hapd0 = hostapd.add_ap(apdev[0], params)
 884     params = ft_params2(ssid=ssid, passphrase=passphrase)
 885     params['wpa_key_mgmt'] = "FT-SAE"
 886     hapd = hostapd.add_ap(apdev[1], params)
 887     key_mgmt = hapd.get_config()['key_mgmt']
 888     if key_mgmt.split(' ')[0] != "FT-SAE":
 889         raise Exception("Unexpected GET_CONFIG(key_mgmt): " + key_mgmt)
 890
 891     dev[0].request("SET sae_groups ")
 892     run_roams(dev[0], apdev, hapd0, hapd, ssid, passphrase, sae=True)
 893
 894 def test_ap_ft_sae_over_ds(dev, apdev):
 895     """WPA2-PSK-FT-SAE AP over DS"""
 896     if "SAE" not in dev[0].get_capability("auth_alg"):
 897         raise HwsimSkip("SAE not supported")
 898     ssid = "test-ft"
 899     passphrase = "12345678"
 900
 901     params = ft_params1(ssid=ssid, passphrase=passphrase)
 902     params['wpa_key_mgmt'] = "FT-SAE"
 903     hapd0 = hostapd.add_ap(apdev[0], params)
 904     params = ft_params2(ssid=ssid, passphrase=passphrase)
 905     params['wpa_key_mgmt'] = "FT-SAE"
 906     hapd1 = hostapd.add_ap(apdev[1], params)
 907
 908     dev[0].request("SET sae_groups ")
 909     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, sae=True,
 910               over_ds=True)
 911
 912 def test_ap_ft_sae_pw_id(dev, apdev):
 913     """FT-SAE with Password Identifier"""
 914     if "SAE" not in dev[0].get_capability("auth_alg"):
 915         raise HwsimSkip("SAE not supported")
 916     ssid = "test-ft"
 917
 918     params = ft_params1(ssid=ssid)
 919     params["ieee80211w"] = "2"
 920     params['wpa_key_mgmt'] = "FT-SAE"
 921     params['sae_password'] = 'secret|id=pwid'
 922     hapd0 = hostapd.add_ap(apdev[0], params)
 923     params = ft_params2(ssid=ssid)
 924     params["ieee80211w"] = "2"
 925     params['wpa_key_mgmt'] = "FT-SAE"
 926     params['sae_password'] = 'secret|id=pwid'
 927     hapd = hostapd.add_ap(apdev[1], params)
 928
 929     dev[0].request("SET sae_groups ")
 930     run_roams(dev[0], apdev, hapd0, hapd, ssid, passphrase=None, sae=True,
 931               sae_password="secret", sae_password_id="pwid")
 932
 933 def test_ap_ft_sae_with_both_akms(dev, apdev):
 934     """SAE + FT-SAE configuration"""
 935     if "SAE" not in dev[0].get_capability("auth_alg"):
 936         raise HwsimSkip("SAE not supported")
 937     ssid = "test-ft"
 938     passphrase = "12345678"
 939
 940     params = ft_params1(ssid=ssid, passphrase=passphrase)
 941     params['wpa_key_mgmt'] = "FT-SAE SAE"
 942     hapd0 = hostapd.add_ap(apdev[0], params)
 943     params = ft_params2(ssid=ssid, passphrase=passphrase)
 944     params['wpa_key_mgmt'] = "FT-SAE SAE"
 945     hapd = hostapd.add_ap(apdev[1], params)
 946     key_mgmt = hapd.get_config()['key_mgmt']
 947     if key_mgmt.split(' ')[0] != "FT-SAE":
 948         raise Exception("Unexpected GET_CONFIG(key_mgmt): " + key_mgmt)
 949
 950     dev[0].request("SET sae_groups ")
 951     run_roams(dev[0], apdev, hapd0, hapd, ssid, passphrase, sae=True,
 952               sae_and_psk=True)
 953
 954 def generic_ap_ft_eap(dev, apdev, vlan=False, cui=False, over_ds=False,
 955                       discovery=False, roams=1):
 956     ssid = "test-ft"
 957     passphrase = "12345678"
 958     if vlan:
 959         identity = "gpsk-vlan1"
 960         conndev = "brvlan1"
 961     elif cui:
 962         identity = "gpsk-cui"
 963         conndev = False
 964     else:
 965         identity = "gpsk user"
 966         conndev = False
 967
 968     radius = hostapd.radius_params()
 969     params = ft_params1(ssid=ssid, passphrase=passphrase, discovery=discovery)
 970     params['wpa_key_mgmt'] = "FT-EAP"
 971     params["ieee8021x"] = "1"
 972     if vlan:
 973         params["dynamic_vlan"] = "1"
 974     params = dict(list(radius.items()) + list(params.items()))
 975     hapd = hostapd.add_ap(apdev[0], params)
 976     key_mgmt = hapd.get_config()['key_mgmt']
 977     if key_mgmt.split(' ')[0] != "FT-EAP":
 978         raise Exception("Unexpected GET_CONFIG(key_mgmt): " + key_mgmt)
 979     params = ft_params2(ssid=ssid, passphrase=passphrase, discovery=discovery)
 980     params['wpa_key_mgmt'] = "FT-EAP"
 981     params["ieee8021x"] = "1"
 982     if vlan:
 983         params["dynamic_vlan"] = "1"
 984     params = dict(list(radius.items()) + list(params.items()))
 985     hapd1 = hostapd.add_ap(apdev[1], params)
 986
 987     run_roams(dev[0], apdev, hapd, hapd1, ssid, passphrase, eap=True,
 988               over_ds=over_ds, roams=roams, eap_identity=identity,
 989               conndev=conndev)
 990     if "[WPA2-FT/EAP-CCMP]" not in dev[0].request("SCAN_RESULTS"):
 991         raise Exception("Scan results missing RSN element info")
 992     check_mib(dev[0], [("dot11RSNAAuthenticationSuiteRequested", "00-0f-ac-3"),
 993                        ("dot11RSNAAuthenticationSuiteSelected", "00-0f-ac-3")])
 994
 995     # Verify EAPOL reauthentication after FT protocol
 996     if dev[0].get_status_field('bssid') == apdev[0]['bssid']:
 997         ap = hapd
 998     else:
 999         ap = hapd1
1000     ap.request("EAPOL_REAUTH " + dev[0].own_addr())
1001     ev = dev[0].wait_event(["CTRL-EVENT-EAP-STARTED"], timeout=5)
1002     if ev is None:
1003         raise Exception("EAP authentication did not start")
1004     ev = dev[0].wait_event(["CTRL-EVENT-EAP-SUCCESS"], timeout=5)
1005     if ev is None:
1006         raise Exception("EAP authentication did not succeed")
1007     time.sleep(0.1)
1008     if conndev:
1009         hwsim_utils.test_connectivity_iface(dev[0], ap, conndev)
1010     else:
1011         hwsim_utils.test_connectivity(dev[0], ap)
1012
1013 def test_ap_ft_eap(dev, apdev):
1014     """WPA2-EAP-FT AP"""
1015     generic_ap_ft_eap(dev, apdev)
1016
1017 def test_ap_ft_eap_cui(dev, apdev):
1018     """WPA2-EAP-FT AP with CUI"""
1019     generic_ap_ft_eap(dev, apdev, vlan=False, cui=True)
1020
1021 def test_ap_ft_eap_vlan(dev, apdev):
1022     """WPA2-EAP-FT AP with VLAN"""
1023     generic_ap_ft_eap(dev, apdev, vlan=True)
1024
1025 def test_ap_ft_eap_vlan_multi(dev, apdev):
1026     """WPA2-EAP-FT AP with VLAN"""
1027     generic_ap_ft_eap(dev, apdev, vlan=True, roams=50)
1028
1029 def test_ap_ft_eap_over_ds(dev, apdev):
1030     """WPA2-EAP-FT AP using over-the-DS"""
1031     generic_ap_ft_eap(dev, apdev, over_ds=True)
1032
1033 def test_ap_ft_eap_dis(dev, apdev):
1034     """WPA2-EAP-FT AP with AP discovery"""
1035     generic_ap_ft_eap(dev, apdev, discovery=True)
1036
1037 def test_ap_ft_eap_dis_over_ds(dev, apdev):
1038     """WPA2-EAP-FT AP with AP discovery and over-the-DS"""
1039     generic_ap_ft_eap(dev, apdev, over_ds=True, discovery=True)
1040
1041 def test_ap_ft_eap_vlan(dev, apdev):
1042     """WPA2-EAP-FT AP with VLAN"""
1043     generic_ap_ft_eap(dev, apdev, vlan=True)
1044
1045 def test_ap_ft_eap_vlan_multi(dev, apdev):
1046     """WPA2-EAP-FT AP with VLAN"""
1047     generic_ap_ft_eap(dev, apdev, vlan=True, roams=50)
1048
1049 def test_ap_ft_eap_vlan_over_ds(dev, apdev):
1050     """WPA2-EAP-FT AP with VLAN + over_ds"""
1051     generic_ap_ft_eap(dev, apdev, vlan=True, over_ds=True)
1052
1053 def test_ap_ft_eap_vlan_over_ds_multi(dev, apdev):
1054     """WPA2-EAP-FT AP with VLAN + over_ds"""
1055     generic_ap_ft_eap(dev, apdev, vlan=True, over_ds=True, roams=50)
1056
1057 def generic_ap_ft_eap_pull(dev, apdev, vlan=False):
1058     """WPA2-EAP-FT AP (pull PMK)"""
1059     ssid = "test-ft"
1060     passphrase = "12345678"
1061     if vlan:
1062         identity = "gpsk-vlan1"
1063         conndev = "brvlan1"
1064     else:
1065         identity = "gpsk user"
1066         conndev = False
1067
1068     radius = hostapd.radius_params()
1069     params = ft_params1(ssid=ssid, passphrase=passphrase)
1070     params['wpa_key_mgmt'] = "FT-EAP"
1071     params["ieee8021x"] = "1"
1072     params["pmk_r1_push"] = "0"
1073     if vlan:
1074         params["dynamic_vlan"] = "1"
1075     params = dict(list(radius.items()) + list(params.items()))
1076     hapd = hostapd.add_ap(apdev[0], params)
1077     key_mgmt = hapd.get_config()['key_mgmt']
1078     if key_mgmt.split(' ')[0] != "FT-EAP":
1079         raise Exception("Unexpected GET_CONFIG(key_mgmt): " + key_mgmt)
1080     params = ft_params2(ssid=ssid, passphrase=passphrase)
1081     params['wpa_key_mgmt'] = "FT-EAP"
1082     params["ieee8021x"] = "1"
1083     params["pmk_r1_push"] = "0"
1084     if vlan:
1085         params["dynamic_vlan"] = "1"
1086     params = dict(list(radius.items()) + list(params.items()))
1087     hapd1 = hostapd.add_ap(apdev[1], params)
1088
1089     run_roams(dev[0], apdev, hapd, hapd1, ssid, passphrase, eap=True,
1090               eap_identity=identity, conndev=conndev)
1091
1092 def test_ap_ft_eap_pull(dev, apdev):
1093     """WPA2-EAP-FT AP (pull PMK)"""
1094     generic_ap_ft_eap_pull(dev, apdev)
1095
1096 def test_ap_ft_eap_pull_vlan(dev, apdev):
1097     generic_ap_ft_eap_pull(dev, apdev, vlan=True)
1098
1099 def test_ap_ft_eap_pull_wildcard(dev, apdev):
1100     """WPA2-EAP-FT AP (pull PMK) - wildcard R0KH/R1KH"""
1101     ssid = "test-ft"
1102     passphrase = "12345678"
1103
1104     radius = hostapd.radius_params()
1105     params = ft_params1(ssid=ssid, passphrase=passphrase, discovery=True)
1106     params['wpa_key_mgmt'] = "WPA-EAP FT-EAP"
1107     params["ieee8021x"] = "1"
1108     params["pmk_r1_push"] = "0"
1109     params["r0kh"] = "ff:ff:ff:ff:ff:ff * 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
1110     params["r1kh"] = "00:00:00:00:00:00 00:00:00:00:00:00 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
1111     params["ft_psk_generate_local"] = "1"
1112     params["eap_server"] = "0"
1113     params = dict(list(radius.items()) + list(params.items()))
1114     hapd = hostapd.add_ap(apdev[0], params)
1115     params = ft_params2(ssid=ssid, passphrase=passphrase, discovery=True)
1116     params['wpa_key_mgmt'] = "WPA-EAP FT-EAP"
1117     params["ieee8021x"] = "1"
1118     params["pmk_r1_push"] = "0"
1119     params["r0kh"] = "ff:ff:ff:ff:ff:ff * 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
1120     params["r1kh"] = "00:00:00:00:00:00 00:00:00:00:00:00 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
1121     params["ft_psk_generate_local"] = "1"
1122     params["eap_server"] = "0"
1123     params = dict(list(radius.items()) + list(params.items()))
1124     hapd1 = hostapd.add_ap(apdev[1], params)
1125
1126     run_roams(dev[0], apdev, hapd, hapd1, ssid, passphrase, eap=True)
1127
1128 @remote_compatible
1129 def test_ap_ft_mismatching_rrb_key_push(dev, apdev):
1130     """WPA2-PSK-FT AP over DS with mismatching RRB key (push)"""
1131     ssid = "test-ft"
1132     passphrase = "12345678"
1133
1134     params = ft_params1(ssid=ssid, passphrase=passphrase)
1135     params["ieee80211w"] = "2"
1136     hapd0 = hostapd.add_ap(apdev[0], params)
1137     params = ft_params2_incorrect_rrb_key(ssid=ssid, passphrase=passphrase)
1138     params["ieee80211w"] = "2"
1139     hapd1 = hostapd.add_ap(apdev[1], params)
1140
1141     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1142               fail_test=True)
1143
1144 @remote_compatible
1145 def test_ap_ft_mismatching_rrb_key_pull(dev, apdev):
1146     """WPA2-PSK-FT AP over DS with mismatching RRB key (pull)"""
1147     ssid = "test-ft"
1148     passphrase = "12345678"
1149
1150     params = ft_params1(ssid=ssid, passphrase=passphrase)
1151     params["pmk_r1_push"] = "0"
1152     hapd0 = hostapd.add_ap(apdev[0], params)
1153     params = ft_params2_incorrect_rrb_key(ssid=ssid, passphrase=passphrase)
1154     params["pmk_r1_push"] = "0"
1155     hapd1 = hostapd.add_ap(apdev[1], params)
1156
1157     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1158               fail_test=True)
1159
1160 @remote_compatible
1161 def test_ap_ft_mismatching_r0kh_id_pull(dev, apdev):
1162     """WPA2-PSK-FT AP over DS with mismatching R0KH-ID (pull)"""
1163     ssid = "test-ft"
1164     passphrase = "12345678"
1165
1166     params = ft_params1(ssid=ssid, passphrase=passphrase)
1167     params["pmk_r1_push"] = "0"
1168     params["nas_identifier"] = "nas0.w1.fi"
1169     hostapd.add_ap(apdev[0], params)
1170     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1171                    scan_freq="2412")
1172
1173     params = ft_params2(ssid=ssid, passphrase=passphrase)
1174     params["pmk_r1_push"] = "0"
1175     hostapd.add_ap(apdev[1], params)
1176
1177     dev[0].scan_for_bss(apdev[1]['bssid'], freq="2412")
1178     dev[0].roam_over_ds(apdev[1]['bssid'], fail_test=True)
1179
1180 @remote_compatible
1181 def test_ap_ft_mismatching_rrb_r0kh_push(dev, apdev):
1182     """WPA2-PSK-FT AP over DS with mismatching R0KH key (push)"""
1183     ssid = "test-ft"
1184     passphrase = "12345678"
1185
1186     params = ft_params1(ssid=ssid, passphrase=passphrase)
1187     params["ieee80211w"] = "2"
1188     hapd0 = hostapd.add_ap(apdev[0], params)
1189     params = ft_params2_r0kh_mismatch(ssid=ssid, passphrase=passphrase)
1190     params["ieee80211w"] = "2"
1191     hapd1 = hostapd.add_ap(apdev[1], params)
1192
1193     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1194               fail_test=True)
1195
1196 @remote_compatible
1197 def test_ap_ft_mismatching_rrb_r0kh_pull(dev, apdev):
1198     """WPA2-PSK-FT AP over DS with mismatching R0KH key (pull)"""
1199     ssid = "test-ft"
1200     passphrase = "12345678"
1201
1202     params = ft_params1_r0kh_mismatch(ssid=ssid, passphrase=passphrase)
1203     params["pmk_r1_push"] = "0"
1204     hapd0 = hostapd.add_ap(apdev[0], params)
1205     params = ft_params2(ssid=ssid, passphrase=passphrase)
1206     params["pmk_r1_push"] = "0"
1207     hapd1 = hostapd.add_ap(apdev[1], params)
1208
1209     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1210               fail_test=True)
1211
1212 def test_ap_ft_mismatching_rrb_key_push_eap(dev, apdev):
1213     """WPA2-EAP-FT AP over DS with mismatching RRB key (push)"""
1214     ssid = "test-ft"
1215     passphrase = "12345678"
1216
1217     radius = hostapd.radius_params()
1218     params = ft_params1(ssid=ssid, passphrase=passphrase)
1219     params["ieee80211w"] = "2"
1220     params['wpa_key_mgmt'] = "FT-EAP"
1221     params["ieee8021x"] = "1"
1222     params = dict(list(radius.items()) + list(params.items()))
1223     hapd0 = hostapd.add_ap(apdev[0], params)
1224     params = ft_params2_incorrect_rrb_key(ssid=ssid, passphrase=passphrase)
1225     params["ieee80211w"] = "2"
1226     params['wpa_key_mgmt'] = "FT-EAP"
1227     params["ieee8021x"] = "1"
1228     params = dict(list(radius.items()) + list(params.items()))
1229     hapd1 = hostapd.add_ap(apdev[1], params)
1230
1231     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1232               fail_test=True, eap=True)
1233
1234 def test_ap_ft_mismatching_rrb_key_pull_eap(dev, apdev):
1235     """WPA2-EAP-FT AP over DS with mismatching RRB key (pull)"""
1236     ssid = "test-ft"
1237     passphrase = "12345678"
1238
1239     radius = hostapd.radius_params()
1240     params = ft_params1(ssid=ssid, passphrase=passphrase)
1241     params["pmk_r1_push"] = "0"
1242     params['wpa_key_mgmt'] = "FT-EAP"
1243     params["ieee8021x"] = "1"
1244     params = dict(list(radius.items()) + list(params.items()))
1245     hapd0 = hostapd.add_ap(apdev[0], params)
1246     params = ft_params2_incorrect_rrb_key(ssid=ssid, passphrase=passphrase)
1247     params["pmk_r1_push"] = "0"
1248     params['wpa_key_mgmt'] = "FT-EAP"
1249     params["ieee8021x"] = "1"
1250     params = dict(list(radius.items()) + list(params.items()))
1251     hapd1 = hostapd.add_ap(apdev[1], params)
1252
1253     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1254               fail_test=True, eap=True)
1255
1256 def test_ap_ft_mismatching_r0kh_id_pull_eap(dev, apdev):
1257     """WPA2-EAP-FT AP over DS with mismatching R0KH-ID (pull)"""
1258     ssid = "test-ft"
1259     passphrase = "12345678"
1260
1261     radius = hostapd.radius_params()
1262     params = ft_params1(ssid=ssid, passphrase=passphrase)
1263     params["pmk_r1_push"] = "0"
1264     params["nas_identifier"] = "nas0.w1.fi"
1265     params['wpa_key_mgmt'] = "FT-EAP"
1266     params["ieee8021x"] = "1"
1267     params = dict(list(radius.items()) + list(params.items()))
1268     hostapd.add_ap(apdev[0], params)
1269     dev[0].connect(ssid, key_mgmt="FT-EAP", proto="WPA2", ieee80211w="1",
1270                    eap="GPSK", identity="gpsk user",
1271                    password="abcdefghijklmnop0123456789abcdef",
1272                    scan_freq="2412")
1273
1274     params = ft_params2(ssid=ssid, passphrase=passphrase)
1275     params["pmk_r1_push"] = "0"
1276     params['wpa_key_mgmt'] = "FT-EAP"
1277     params["ieee8021x"] = "1"
1278     params = dict(list(radius.items()) + list(params.items()))
1279     hostapd.add_ap(apdev[1], params)
1280
1281     dev[0].scan_for_bss(apdev[1]['bssid'], freq="2412")
1282     dev[0].roam_over_ds(apdev[1]['bssid'], fail_test=True)
1283
1284 def test_ap_ft_mismatching_rrb_r0kh_push_eap(dev, apdev):
1285     """WPA2-EAP-FT AP over DS with mismatching R0KH key (push)"""
1286     ssid = "test-ft"
1287     passphrase = "12345678"
1288
1289     radius = hostapd.radius_params()
1290     params = ft_params1(ssid=ssid, passphrase=passphrase)
1291     params["ieee80211w"] = "2"
1292     params['wpa_key_mgmt'] = "FT-EAP"
1293     params["ieee8021x"] = "1"
1294     params = dict(list(radius.items()) + list(params.items()))
1295     hapd0 = hostapd.add_ap(apdev[0], params)
1296     params = ft_params2_r0kh_mismatch(ssid=ssid, passphrase=passphrase)
1297     params["ieee80211w"] = "2"
1298     params['wpa_key_mgmt'] = "FT-EAP"
1299     params["ieee8021x"] = "1"
1300     params = dict(list(radius.items()) + list(params.items()))
1301     hapd1 = hostapd.add_ap(apdev[1], params)
1302
1303     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1304               fail_test=True, eap=True)
1305
1306 def test_ap_ft_mismatching_rrb_r0kh_pull_eap(dev, apdev):
1307     """WPA2-EAP-FT AP over DS with mismatching R0KH key (pull)"""
1308     ssid = "test-ft"
1309     passphrase = "12345678"
1310
1311     radius = hostapd.radius_params()
1312     params = ft_params1_r0kh_mismatch(ssid=ssid, passphrase=passphrase)
1313     params["pmk_r1_push"] = "0"
1314     params['wpa_key_mgmt'] = "FT-EAP"
1315     params["ieee8021x"] = "1"
1316     params = dict(list(radius.items()) + list(params.items()))
1317     hapd0 = hostapd.add_ap(apdev[0], params)
1318     params = ft_params2(ssid=ssid, passphrase=passphrase)
1319     params["pmk_r1_push"] = "0"
1320     params['wpa_key_mgmt'] = "FT-EAP"
1321     params["ieee8021x"] = "1"
1322     params = dict(list(radius.items()) + list(params.items()))
1323     hapd1 = hostapd.add_ap(apdev[1], params)
1324
1325     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1326               fail_test=True, eap=True)
1327
1328 def test_ap_ft_gtk_rekey(dev, apdev):
1329     """WPA2-PSK-FT AP and GTK rekey"""
1330     ssid = "test-ft"
1331     passphrase = "12345678"
1332
1333     params = ft_params1(ssid=ssid, passphrase=passphrase)
1334     params['wpa_group_rekey'] = '1'
1335     hapd = hostapd.add_ap(apdev[0], params)
1336
1337     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1338                    ieee80211w="1", scan_freq="2412")
1339
1340     ev = dev[0].wait_event(["WPA: Group rekeying completed"], timeout=2)
1341     if ev is None:
1342         raise Exception("GTK rekey timed out after initial association")
1343     hwsim_utils.test_connectivity(dev[0], hapd)
1344
1345     params = ft_params2(ssid=ssid, passphrase=passphrase)
1346     params['wpa_group_rekey'] = '1'
1347     hapd1 = hostapd.add_ap(apdev[1], params)
1348
1349     dev[0].scan_for_bss(apdev[1]['bssid'], freq="2412")
1350     dev[0].roam(apdev[1]['bssid'])
1351     if dev[0].get_status_field('bssid') != apdev[1]['bssid']:
1352         raise Exception("Did not connect to correct AP")
1353     hwsim_utils.test_connectivity(dev[0], hapd1)
1354
1355     ev = dev[0].wait_event(["WPA: Group rekeying completed"], timeout=2)
1356     if ev is None:
1357         raise Exception("GTK rekey timed out after FT protocol")
1358     hwsim_utils.test_connectivity(dev[0], hapd1)
1359
1360 def test_ft_psk_key_lifetime_in_memory(dev, apdev, params):
1361     """WPA2-PSK-FT and key lifetime in memory"""
1362     ssid = "test-ft"
1363     passphrase = "04c2726b4b8d5f1b4db9c07aa4d9e9d8f765cb5d25ec817e6cc4fcdd5255db0"
1364     psk = '93c90846ff67af9037ed83fb72b63dbeddaa81d47f926c20909b5886f1d9358d'
1365     pmk = binascii.unhexlify(psk)
1366     p = ft_params1(ssid=ssid, passphrase=passphrase)
1367     hapd0 = hostapd.add_ap(apdev[0], p)
1368     p = ft_params2(ssid=ssid, passphrase=passphrase)
1369     hapd1 = hostapd.add_ap(apdev[1], p)
1370
1371     pid = find_wpas_process(dev[0])
1372
1373     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1374                    scan_freq="2412")
1375     # The decrypted copy of GTK is freed only after the CTRL-EVENT-CONNECTED
1376     # event has been delivered, so verify that wpa_supplicant has returned to
1377     # eloop before reading process memory.
1378     time.sleep(1)
1379     dev[0].ping()
1380
1381     buf = read_process_memory(pid, pmk)
1382
1383     dev[0].request("DISCONNECT")
1384     dev[0].wait_disconnected()
1385
1386     dev[0].relog()
1387     pmkr0 = None
1388     pmkr1 = None
1389     ptk = None
1390     gtk = None
1391     with open(os.path.join(params['logdir'], 'log0'), 'r') as f:
1392         for l in f.readlines():
1393             if "FT: PMK-R0 - hexdump" in l:
1394                 val = l.strip().split(':')[3].replace(' ', '')
1395                 pmkr0 = binascii.unhexlify(val)
1396             if "FT: PMK-R1 - hexdump" in l:
1397                 val = l.strip().split(':')[3].replace(' ', '')
1398                 pmkr1 = binascii.unhexlify(val)
1399             if "FT: KCK - hexdump" in l:
1400                 val = l.strip().split(':')[3].replace(' ', '')
1401                 kck = binascii.unhexlify(val)
1402             if "FT: KEK - hexdump" in l:
1403                 val = l.strip().split(':')[3].replace(' ', '')
1404                 kek = binascii.unhexlify(val)
1405             if "FT: TK - hexdump" in l:
1406                 val = l.strip().split(':')[3].replace(' ', '')
1407                 tk = binascii.unhexlify(val)
1408             if "WPA: Group Key - hexdump" in l:
1409                 val = l.strip().split(':')[3].replace(' ', '')
1410                 gtk = binascii.unhexlify(val)
1411     if not pmkr0 or not pmkr1 or not kck or not kek or not tk or not gtk:
1412         raise Exception("Could not find keys from debug log")
1413     if len(gtk) != 16:
1414         raise Exception("Unexpected GTK length")
1415
1416     logger.info("Checking keys in memory while associated")
1417     get_key_locations(buf, pmk, "PMK")
1418     get_key_locations(buf, pmkr0, "PMK-R0")
1419     get_key_locations(buf, pmkr1, "PMK-R1")
1420     if pmk not in buf:
1421         raise HwsimSkip("PMK not found while associated")
1422     if pmkr0 not in buf:
1423         raise HwsimSkip("PMK-R0 not found while associated")
1424     if pmkr1 not in buf:
1425         raise HwsimSkip("PMK-R1 not found while associated")
1426     if kck not in buf:
1427         raise Exception("KCK not found while associated")
1428     if kek not in buf:
1429         raise Exception("KEK not found while associated")
1430     #if tk in buf:
1431     #    raise Exception("TK found from memory")
1432
1433     logger.info("Checking keys in memory after disassociation")
1434     buf = read_process_memory(pid, pmk)
1435     get_key_locations(buf, pmk, "PMK")
1436     get_key_locations(buf, pmkr0, "PMK-R0")
1437     get_key_locations(buf, pmkr1, "PMK-R1")
1438
1439     # Note: PMK/PSK is still present in network configuration
1440
1441     fname = os.path.join(params['logdir'],
1442                          'ft_psk_key_lifetime_in_memory.memctx-')
1443     verify_not_present(buf, pmkr0, fname, "PMK-R0")
1444     verify_not_present(buf, pmkr1, fname, "PMK-R1")
1445     verify_not_present(buf, kck, fname, "KCK")
1446     verify_not_present(buf, kek, fname, "KEK")
1447     verify_not_present(buf, tk, fname, "TK")
1448     if gtk in buf:
1449         get_key_locations(buf, gtk, "GTK")
1450     verify_not_present(buf, gtk, fname, "GTK")
1451
1452     dev[0].request("REMOVE_NETWORK all")
1453
1454     logger.info("Checking keys in memory after network profile removal")
1455     buf = read_process_memory(pid, pmk)
1456     get_key_locations(buf, pmk, "PMK")
1457     get_key_locations(buf, pmkr0, "PMK-R0")
1458     get_key_locations(buf, pmkr1, "PMK-R1")
1459
1460     verify_not_present(buf, pmk, fname, "PMK")
1461     verify_not_present(buf, pmkr0, fname, "PMK-R0")
1462     verify_not_present(buf, pmkr1, fname, "PMK-R1")
1463     verify_not_present(buf, kck, fname, "KCK")
1464     verify_not_present(buf, kek, fname, "KEK")
1465     verify_not_present(buf, tk, fname, "TK")
1466     verify_not_present(buf, gtk, fname, "GTK")
1467
1468 @remote_compatible
1469 def test_ap_ft_invalid_resp(dev, apdev):
1470     """WPA2-PSK-FT AP and invalid response IEs"""
1471     ssid = "test-ft"
1472     passphrase = "12345678"
1473
1474     params = ft_params1(ssid=ssid, passphrase=passphrase)
1475     hapd0 = hostapd.add_ap(apdev[0], params)
1476     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1477                    scan_freq="2412")
1478
1479     params = ft_params2(ssid=ssid, passphrase=passphrase)
1480     hapd1 = hostapd.add_ap(apdev[1], params)
1481
1482     tests = [
1483         # Various IEs for test coverage. The last one is FTIE with invalid
1484         # R1KH-ID subelement.
1485         "020002000000" + "3800" + "38051122334455" + "3754000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010100",
1486         # FTIE with invalid R0KH-ID subelement (len=0).
1487         "020002000000" + "3754000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010300",
1488         # FTIE with invalid R0KH-ID subelement (len=49).
1489         "020002000000" + "378500010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001033101020304050607080910111213141516171819202122232425262728293031323334353637383940414243444546474849",
1490         # Invalid RSNE.
1491         "020002000000" + "3000",
1492         # Required IEs missing from protected IE count.
1493         "020002000000" + "3603a1b201" + "375200010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001" + "3900",
1494         # RIC missing from protected IE count.
1495         "020002000000" + "3603a1b201" + "375200020203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001" + "3900",
1496         # Protected IE missing.
1497         "020002000000" + "3603a1b201" + "375200ff0203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001" + "3900" + "0000"]
1498     for t in tests:
1499         dev[0].scan_for_bss(apdev[1]['bssid'], freq="2412")
1500         hapd1.set("ext_mgmt_frame_handling", "1")
1501         hapd1.dump_monitor()
1502         if "OK" not in dev[0].request("ROAM " + apdev[1]['bssid']):
1503             raise Exception("ROAM failed")
1504         auth = None
1505         for i in range(20):
1506             msg = hapd1.mgmt_rx()
1507             if msg['subtype'] == 11:
1508                 auth = msg
1509                 break
1510         if not auth:
1511             raise Exception("Authentication frame not seen")
1512
1513         resp = {}
1514         resp['fc'] = auth['fc']
1515         resp['da'] = auth['sa']
1516         resp['sa'] = auth['da']
1517         resp['bssid'] = auth['bssid']
1518         resp['payload'] = binascii.unhexlify(t)
1519         hapd1.mgmt_tx(resp)
1520         hapd1.set("ext_mgmt_frame_handling", "0")
1521         dev[0].wait_disconnected()
1522
1523         dev[0].request("RECONNECT")
1524         dev[0].wait_connected()
1525
1526 def test_ap_ft_gcmp_256(dev, apdev):
1527     """WPA2-PSK-FT AP with GCMP-256 cipher"""
1528     if "GCMP-256" not in dev[0].get_capability("pairwise"):
1529         raise HwsimSkip("Cipher GCMP-256 not supported")
1530     ssid = "test-ft"
1531     passphrase = "12345678"
1532
1533     params = ft_params1(ssid=ssid, passphrase=passphrase)
1534     params['rsn_pairwise'] = "GCMP-256"
1535     hapd0 = hostapd.add_ap(apdev[0], params)
1536     params = ft_params2(ssid=ssid, passphrase=passphrase)
1537     params['rsn_pairwise'] = "GCMP-256"
1538     hapd1 = hostapd.add_ap(apdev[1], params)
1539
1540     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase,
1541               pairwise_cipher="GCMP-256", group_cipher="GCMP-256")
1542
1543 def setup_ap_ft_oom(dev, apdev):
1544     skip_with_fips(dev[0])
1545     ssid = "test-ft"
1546     passphrase = "12345678"
1547
1548     params = ft_params1(ssid=ssid, passphrase=passphrase)
1549     hapd0 = hostapd.add_ap(apdev[0], params)
1550     params = ft_params2(ssid=ssid, passphrase=passphrase)
1551     hapd1 = hostapd.add_ap(apdev[1], params)
1552
1553     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1554                    scan_freq="2412")
1555     if dev[0].get_status_field('bssid') == apdev[0]['bssid']:
1556         dst = apdev[1]['bssid']
1557     else:
1558         dst = apdev[0]['bssid']
1559
1560     dev[0].scan_for_bss(dst, freq="2412")
1561
1562     return dst
1563
1564 def test_ap_ft_oom(dev, apdev):
1565     """WPA2-PSK-FT and OOM"""
1566     dst = setup_ap_ft_oom(dev, apdev)
1567     with alloc_fail(dev[0], 1, "wpa_ft_gen_req_ies"):
1568         dev[0].roam(dst)
1569
1570 def test_ap_ft_oom2(dev, apdev):
1571     """WPA2-PSK-FT and OOM (2)"""
1572     dst = setup_ap_ft_oom(dev, apdev)
1573     with fail_test(dev[0], 1, "wpa_ft_mic"):
1574         dev[0].roam(dst, fail_test=True, assoc_reject_ok=True)
1575
1576 def test_ap_ft_oom3(dev, apdev):
1577     """WPA2-PSK-FT and OOM (3)"""
1578     dst = setup_ap_ft_oom(dev, apdev)
1579     with fail_test(dev[0], 1, "os_get_random;wpa_ft_prepare_auth_request"):
1580         dev[0].roam(dst)
1581
1582 def test_ap_ft_oom4(dev, apdev):
1583     """WPA2-PSK-FT and OOM (4)"""
1584     ssid = "test-ft"
1585     passphrase = "12345678"
1586     dst = setup_ap_ft_oom(dev, apdev)
1587     dev[0].request("REMOVE_NETWORK all")
1588     with alloc_fail(dev[0], 1, "=sme_update_ft_ies"):
1589         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1590                        scan_freq="2412")
1591
1592 def test_ap_ft_ap_oom(dev, apdev):
1593     """WPA2-PSK-FT and AP OOM"""
1594     ssid = "test-ft"
1595     passphrase = "12345678"
1596
1597     params = ft_params1(ssid=ssid, passphrase=passphrase)
1598     hapd0 = hostapd.add_ap(apdev[0], params)
1599     bssid0 = hapd0.own_addr()
1600
1601     dev[0].scan_for_bss(bssid0, freq="2412")
1602     with alloc_fail(hapd0, 1, "wpa_ft_store_pmk_r0"):
1603         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1604                        scan_freq="2412")
1605
1606     params = ft_params2(ssid=ssid, passphrase=passphrase)
1607     hapd1 = hostapd.add_ap(apdev[1], params)
1608     bssid1 = hapd1.own_addr()
1609     dev[0].scan_for_bss(bssid1, freq="2412")
1610     # This roam will fail due to missing PMK-R0 (OOM prevented storing it)
1611     dev[0].roam(bssid1)
1612
1613 def test_ap_ft_ap_oom2(dev, apdev):
1614     """WPA2-PSK-FT and AP OOM 2"""
1615     ssid = "test-ft"
1616     passphrase = "12345678"
1617
1618     params = ft_params1(ssid=ssid, passphrase=passphrase)
1619     hapd0 = hostapd.add_ap(apdev[0], params)
1620     bssid0 = hapd0.own_addr()
1621
1622     dev[0].scan_for_bss(bssid0, freq="2412")
1623     with alloc_fail(hapd0, 1, "wpa_ft_store_pmk_r1"):
1624         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1625                        scan_freq="2412")
1626
1627     params = ft_params2(ssid=ssid, passphrase=passphrase)
1628     hapd1 = hostapd.add_ap(apdev[1], params)
1629     bssid1 = hapd1.own_addr()
1630     dev[0].scan_for_bss(bssid1, freq="2412")
1631     dev[0].roam(bssid1)
1632     if dev[0].get_status_field('bssid') != bssid1:
1633         raise Exception("Did not roam to AP1")
1634     # This roam will fail due to missing PMK-R1 (OOM prevented storing it)
1635     dev[0].roam(bssid0)
1636
1637 def test_ap_ft_ap_oom3(dev, apdev):
1638     """WPA2-PSK-FT and AP OOM 3"""
1639     ssid = "test-ft"
1640     passphrase = "12345678"
1641
1642     params = ft_params1(ssid=ssid, passphrase=passphrase)
1643     hapd0 = hostapd.add_ap(apdev[0], params)
1644     bssid0 = hapd0.own_addr()
1645
1646     dev[0].scan_for_bss(bssid0, freq="2412")
1647     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1648                    scan_freq="2412")
1649
1650     params = ft_params2(ssid=ssid, passphrase=passphrase)
1651     hapd1 = hostapd.add_ap(apdev[1], params)
1652     bssid1 = hapd1.own_addr()
1653     dev[0].scan_for_bss(bssid1, freq="2412")
1654     with alloc_fail(hapd1, 1, "wpa_ft_pull_pmk_r1"):
1655         # This will fail due to not being able to send out PMK-R1 pull request
1656         dev[0].roam(bssid1)
1657
1658     with fail_test(hapd1, 2, "os_get_random;wpa_ft_pull_pmk_r1"):
1659         # This will fail due to not being able to send out PMK-R1 pull request
1660         dev[0].roam(bssid1)
1661
1662     with fail_test(hapd1, 2, "aes_siv_encrypt;wpa_ft_pull_pmk_r1"):
1663         # This will fail due to not being able to send out PMK-R1 pull request
1664         dev[0].roam(bssid1)
1665
1666 def test_ap_ft_ap_oom3b(dev, apdev):
1667     """WPA2-PSK-FT and AP OOM 3b"""
1668     ssid = "test-ft"
1669     passphrase = "12345678"
1670
1671     params = ft_params1(ssid=ssid, passphrase=passphrase)
1672     hapd0 = hostapd.add_ap(apdev[0], params)
1673     bssid0 = hapd0.own_addr()
1674
1675     dev[0].scan_for_bss(bssid0, freq="2412")
1676     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1677                    scan_freq="2412")
1678
1679     params = ft_params2(ssid=ssid, passphrase=passphrase)
1680     hapd1 = hostapd.add_ap(apdev[1], params)
1681     bssid1 = hapd1.own_addr()
1682     dev[0].scan_for_bss(bssid1, freq="2412")
1683     with fail_test(hapd1, 1, "os_get_random;wpa_ft_pull_pmk_r1"):
1684         # This will fail due to not being able to send out PMK-R1 pull request
1685         dev[0].roam(bssid1)
1686
1687 def test_ap_ft_ap_oom4(dev, apdev):
1688     """WPA2-PSK-FT and AP OOM 4"""
1689     ssid = "test-ft"
1690     passphrase = "12345678"
1691
1692     params = ft_params1(ssid=ssid, passphrase=passphrase)
1693     hapd0 = hostapd.add_ap(apdev[0], params)
1694     bssid0 = hapd0.own_addr()
1695
1696     dev[0].scan_for_bss(bssid0, freq="2412")
1697     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1698                    scan_freq="2412")
1699
1700     params = ft_params2(ssid=ssid, passphrase=passphrase)
1701     hapd1 = hostapd.add_ap(apdev[1], params)
1702     bssid1 = hapd1.own_addr()
1703     dev[0].scan_for_bss(bssid1, freq="2412")
1704     with alloc_fail(hapd1, 1, "wpa_ft_gtk_subelem"):
1705         dev[0].roam(bssid1)
1706         if dev[0].get_status_field('bssid') != bssid1:
1707             raise Exception("Did not roam to AP1")
1708
1709     with fail_test(hapd0, 1, "wpa_auth_get_seqnum;wpa_ft_gtk_subelem"):
1710         dev[0].roam(bssid0)
1711         if dev[0].get_status_field('bssid') != bssid0:
1712             raise Exception("Did not roam to AP0")
1713
1714     with fail_test(hapd0, 1, "aes_wrap;wpa_ft_gtk_subelem"):
1715         dev[0].roam(bssid1)
1716         if dev[0].get_status_field('bssid') != bssid1:
1717             raise Exception("Did not roam to AP1")
1718
1719 def test_ap_ft_ap_oom5(dev, apdev):
1720     """WPA2-PSK-FT and AP OOM 5"""
1721     ssid = "test-ft"
1722     passphrase = "12345678"
1723
1724     params = ft_params1(ssid=ssid, passphrase=passphrase)
1725     hapd0 = hostapd.add_ap(apdev[0], params)
1726     bssid0 = hapd0.own_addr()
1727
1728     dev[0].scan_for_bss(bssid0, freq="2412")
1729     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1730                    scan_freq="2412")
1731
1732     params = ft_params2(ssid=ssid, passphrase=passphrase)
1733     hapd1 = hostapd.add_ap(apdev[1], params)
1734     bssid1 = hapd1.own_addr()
1735     dev[0].scan_for_bss(bssid1, freq="2412")
1736     with alloc_fail(hapd1, 1, "=wpa_ft_process_auth_req"):
1737         # This will fail to roam
1738         dev[0].roam(bssid1)
1739
1740     with fail_test(hapd1, 1, "os_get_random;wpa_ft_process_auth_req"):
1741         # This will fail to roam
1742         dev[0].roam(bssid1)
1743
1744     with fail_test(hapd1, 1, "sha256_prf_bits;wpa_pmk_r1_to_ptk;wpa_ft_process_auth_req"):
1745         # This will fail to roam
1746         dev[0].roam(bssid1)
1747
1748     with fail_test(hapd1, 3, "wpa_pmk_r1_to_ptk;wpa_ft_process_auth_req"):
1749         # This will fail to roam
1750         dev[0].roam(bssid1)
1751
1752     with fail_test(hapd1, 1, "wpa_derive_pmk_r1_name;wpa_ft_process_auth_req"):
1753         # This will fail to roam
1754         dev[0].roam(bssid1)
1755
1756 def test_ap_ft_ap_oom6(dev, apdev):
1757     """WPA2-PSK-FT and AP OOM 6"""
1758     ssid = "test-ft"
1759     passphrase = "12345678"
1760
1761     params = ft_params1(ssid=ssid, passphrase=passphrase)
1762     hapd0 = hostapd.add_ap(apdev[0], params)
1763     bssid0 = hapd0.own_addr()
1764
1765     dev[0].scan_for_bss(bssid0, freq="2412")
1766     with fail_test(hapd0, 1, "wpa_derive_pmk_r0;wpa_auth_derive_ptk_ft"):
1767         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1768                        scan_freq="2412")
1769     dev[0].request("REMOVE_NETWORK all")
1770     dev[0].wait_disconnected()
1771     with fail_test(hapd0, 1, "wpa_derive_pmk_r1;wpa_auth_derive_ptk_ft"):
1772         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1773                        scan_freq="2412")
1774     dev[0].request("REMOVE_NETWORK all")
1775     dev[0].wait_disconnected()
1776     with fail_test(hapd0, 1, "wpa_pmk_r1_to_ptk;wpa_auth_derive_ptk_ft"):
1777         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1778                        scan_freq="2412")
1779
1780 def test_ap_ft_ap_oom7a(dev, apdev):
1781     """WPA2-PSK-FT and AP OOM 7a"""
1782     ssid = "test-ft"
1783     passphrase = "12345678"
1784
1785     params = ft_params1(ssid=ssid, passphrase=passphrase)
1786     params["ieee80211w"] = "2"
1787     hapd0 = hostapd.add_ap(apdev[0], params)
1788     bssid0 = hapd0.own_addr()
1789
1790     dev[0].scan_for_bss(bssid0, freq="2412")
1791     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1792                    ieee80211w="2", scan_freq="2412")
1793
1794     params = ft_params2(ssid=ssid, passphrase=passphrase)
1795     params["ieee80211w"] = "2"
1796     hapd1 = hostapd.add_ap(apdev[1], params)
1797     bssid1 = hapd1.own_addr()
1798     dev[0].scan_for_bss(bssid1, freq="2412")
1799     with alloc_fail(hapd1, 1, "wpa_ft_igtk_subelem"):
1800         # This will fail to roam
1801         dev[0].roam(bssid1)
1802
1803 def test_ap_ft_ap_oom7b(dev, apdev):
1804     """WPA2-PSK-FT and AP OOM 7b"""
1805     ssid = "test-ft"
1806     passphrase = "12345678"
1807
1808     params = ft_params1(ssid=ssid, passphrase=passphrase)
1809     params["ieee80211w"] = "2"
1810     hapd0 = hostapd.add_ap(apdev[0], params)
1811     bssid0 = hapd0.own_addr()
1812
1813     dev[0].scan_for_bss(bssid0, freq="2412")
1814     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1815                    ieee80211w="2", scan_freq="2412")
1816
1817     params = ft_params2(ssid=ssid, passphrase=passphrase)
1818     params["ieee80211w"] = "2"
1819     hapd1 = hostapd.add_ap(apdev[1], params)
1820     bssid1 = hapd1.own_addr()
1821     dev[0].scan_for_bss(bssid1, freq="2412")
1822     with fail_test(hapd1, 1, "aes_wrap;wpa_ft_igtk_subelem"):
1823         # This will fail to roam
1824         dev[0].roam(bssid1)
1825
1826 def test_ap_ft_ap_oom7c(dev, apdev):
1827     """WPA2-PSK-FT and AP OOM 7c"""
1828     ssid = "test-ft"
1829     passphrase = "12345678"
1830
1831     params = ft_params1(ssid=ssid, passphrase=passphrase)
1832     params["ieee80211w"] = "2"
1833     hapd0 = hostapd.add_ap(apdev[0], params)
1834     bssid0 = hapd0.own_addr()
1835
1836     dev[0].scan_for_bss(bssid0, freq="2412")
1837     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1838                    ieee80211w="2", scan_freq="2412")
1839
1840     params = ft_params2(ssid=ssid, passphrase=passphrase)
1841     params["ieee80211w"] = "2"
1842     hapd1 = hostapd.add_ap(apdev[1], params)
1843     bssid1 = hapd1.own_addr()
1844     dev[0].scan_for_bss(bssid1, freq="2412")
1845     with alloc_fail(hapd1, 1, "=wpa_sm_write_assoc_resp_ies"):
1846         # This will fail to roam
1847         dev[0].roam(bssid1)
1848
1849 def test_ap_ft_ap_oom7d(dev, apdev):
1850     """WPA2-PSK-FT and AP OOM 7d"""
1851     ssid = "test-ft"
1852     passphrase = "12345678"
1853
1854     params = ft_params1(ssid=ssid, passphrase=passphrase)
1855     params["ieee80211w"] = "2"
1856     hapd0 = hostapd.add_ap(apdev[0], params)
1857     bssid0 = hapd0.own_addr()
1858
1859     dev[0].scan_for_bss(bssid0, freq="2412")
1860     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1861                    ieee80211w="2", scan_freq="2412")
1862
1863     params = ft_params2(ssid=ssid, passphrase=passphrase)
1864     params["ieee80211w"] = "2"
1865     hapd1 = hostapd.add_ap(apdev[1], params)
1866     bssid1 = hapd1.own_addr()
1867     dev[0].scan_for_bss(bssid1, freq="2412")
1868     with fail_test(hapd1, 1, "wpa_ft_mic;wpa_sm_write_assoc_resp_ies"):
1869         # This will fail to roam
1870         dev[0].roam(bssid1)
1871
1872 def test_ap_ft_ap_oom8(dev, apdev):
1873     """WPA2-PSK-FT and AP OOM 8"""
1874     ssid = "test-ft"
1875     passphrase = "12345678"
1876
1877     params = ft_params1(ssid=ssid, passphrase=passphrase)
1878     params['ft_psk_generate_local'] = "1"
1879     hapd0 = hostapd.add_ap(apdev[0], params)
1880     bssid0 = hapd0.own_addr()
1881
1882     dev[0].scan_for_bss(bssid0, freq="2412")
1883     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1884                    scan_freq="2412")
1885
1886     params = ft_params2(ssid=ssid, passphrase=passphrase)
1887     params['ft_psk_generate_local'] = "1"
1888     hapd1 = hostapd.add_ap(apdev[1], params)
1889     bssid1 = hapd1.own_addr()
1890     dev[0].scan_for_bss(bssid1, freq="2412")
1891     with fail_test(hapd1, 1, "wpa_derive_pmk_r0;wpa_ft_psk_pmk_r1"):
1892         # This will fail to roam
1893         dev[0].roam(bssid1)
1894     with fail_test(hapd1, 1, "wpa_derive_pmk_r1;wpa_ft_psk_pmk_r1"):
1895         # This will fail to roam
1896         dev[0].roam(bssid1)
1897
1898 def test_ap_ft_ap_oom9(dev, apdev):
1899     """WPA2-PSK-FT and AP OOM 9"""
1900     ssid = "test-ft"
1901     passphrase = "12345678"
1902
1903     params = ft_params1(ssid=ssid, passphrase=passphrase)
1904     hapd0 = hostapd.add_ap(apdev[0], params)
1905     bssid0 = hapd0.own_addr()
1906
1907     dev[0].scan_for_bss(bssid0, freq="2412")
1908     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1909                    scan_freq="2412")
1910
1911     params = ft_params2(ssid=ssid, passphrase=passphrase)
1912     hapd1 = hostapd.add_ap(apdev[1], params)
1913     bssid1 = hapd1.own_addr()
1914     dev[0].scan_for_bss(bssid1, freq="2412")
1915
1916     with alloc_fail(hapd0, 1, "wpa_ft_action_rx"):
1917         # This will fail to roam
1918         if "OK" not in dev[0].request("FT_DS " + bssid1):
1919             raise Exception("FT_DS failed")
1920         wait_fail_trigger(hapd0, "GET_ALLOC_FAIL")
1921
1922     with alloc_fail(hapd1, 1, "wpa_ft_rrb_rx_request"):
1923         # This will fail to roam
1924         if "OK" not in dev[0].request("FT_DS " + bssid1):
1925             raise Exception("FT_DS failed")
1926         wait_fail_trigger(hapd1, "GET_ALLOC_FAIL")
1927
1928     with alloc_fail(hapd1, 1, "wpa_ft_send_rrb_auth_resp"):
1929         # This will fail to roam
1930         if "OK" not in dev[0].request("FT_DS " + bssid1):
1931             raise Exception("FT_DS failed")
1932         wait_fail_trigger(hapd1, "GET_ALLOC_FAIL")
1933
1934 def test_ap_ft_ap_oom10(dev, apdev):
1935     """WPA2-PSK-FT and AP OOM 10"""
1936     ssid = "test-ft"
1937     passphrase = "12345678"
1938
1939     params = ft_params1(ssid=ssid, passphrase=passphrase)
1940     hapd0 = hostapd.add_ap(apdev[0], params)
1941     bssid0 = hapd0.own_addr()
1942
1943     dev[0].scan_for_bss(bssid0, freq="2412")
1944     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1945                    scan_freq="2412")
1946
1947     params = ft_params2(ssid=ssid, passphrase=passphrase)
1948     hapd1 = hostapd.add_ap(apdev[1], params)
1949     bssid1 = hapd1.own_addr()
1950     dev[0].scan_for_bss(bssid1, freq="2412")
1951
1952     with fail_test(hapd0, 1, "aes_siv_decrypt;wpa_ft_rrb_rx_pull"):
1953         # This will fail to roam
1954         if "OK" not in dev[0].request("FT_DS " + bssid1):
1955             raise Exception("FT_DS failed")
1956         wait_fail_trigger(hapd0, "GET_FAIL")
1957
1958     with fail_test(hapd0, 1, "wpa_derive_pmk_r1;wpa_ft_rrb_rx_pull"):
1959         # This will fail to roam
1960         if "OK" not in dev[0].request("FT_DS " + bssid1):
1961             raise Exception("FT_DS failed")
1962         wait_fail_trigger(hapd0, "GET_FAIL")
1963
1964     with fail_test(hapd0, 1, "aes_siv_encrypt;wpa_ft_rrb_rx_pull"):
1965         # This will fail to roam
1966         if "OK" not in dev[0].request("FT_DS " + bssid1):
1967             raise Exception("FT_DS failed")
1968         wait_fail_trigger(hapd0, "GET_FAIL")
1969
1970     with fail_test(hapd1, 1, "aes_siv_decrypt;wpa_ft_rrb_rx_resp"):
1971         # This will fail to roam
1972         if "OK" not in dev[0].request("FT_DS " + bssid1):
1973             raise Exception("FT_DS failed")
1974         wait_fail_trigger(hapd1, "GET_FAIL")
1975
1976 def test_ap_ft_ap_oom11(dev, apdev):
1977     """WPA2-PSK-FT and AP OOM 11"""
1978     ssid = "test-ft"
1979     passphrase = "12345678"
1980
1981     params = ft_params1(ssid=ssid, passphrase=passphrase)
1982     hapd0 = hostapd.add_ap(apdev[0], params)
1983     bssid0 = hapd0.own_addr()
1984
1985     dev[0].scan_for_bss(bssid0, freq="2412")
1986     with fail_test(hapd0, 1, "wpa_derive_pmk_r1;wpa_ft_generate_pmk_r1"):
1987         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1988                        scan_freq="2412")
1989         wait_fail_trigger(hapd0, "GET_FAIL")
1990
1991     dev[1].scan_for_bss(bssid0, freq="2412")
1992     with fail_test(hapd0, 1, "aes_siv_encrypt;wpa_ft_generate_pmk_r1"):
1993         dev[1].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1994                        scan_freq="2412")
1995         wait_fail_trigger(hapd0, "GET_FAIL")
1996
1997 def test_ap_ft_over_ds_proto_ap(dev, apdev):
1998     """WPA2-PSK-FT AP over DS protocol testing for AP processing"""
1999     ssid = "test-ft"
2000     passphrase = "12345678"
2001
2002     params = ft_params1(ssid=ssid, passphrase=passphrase)
2003     hapd0 = hostapd.add_ap(apdev[0], params)
2004     bssid0 = hapd0.own_addr()
2005     _bssid0 = bssid0.replace(':', '')
2006     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2007                    scan_freq="2412")
2008     addr = dev[0].own_addr()
2009     _addr = addr.replace(':', '')
2010
2011     params = ft_params2(ssid=ssid, passphrase=passphrase)
2012     hapd1 = hostapd.add_ap(apdev[1], params)
2013     bssid1 = hapd1.own_addr()
2014     _bssid1 = bssid1.replace(':', '')
2015
2016     hapd0.set("ext_mgmt_frame_handling", "1")
2017     hdr = "d0003a01" + _bssid0 + _addr + _bssid0 + "1000"
2018     valid = "0601" + _addr + _bssid1
2019     tests = ["0601",
2020              "0601" + _addr,
2021              "0601" + _addr + _bssid0,
2022              "0601" + _addr + "ffffffffffff",
2023              "0601" + _bssid0 + _bssid0,
2024              valid,
2025              valid + "01",
2026              valid + "3700",
2027              valid + "3600",
2028              valid + "3603ffffff",
2029              valid + "3603a1b2ff",
2030              valid + "3603a1b2ff" + "3700",
2031              valid + "3603a1b2ff" + "37520000" + 16*"00" + 32*"00" + 32*"00",
2032              valid + "3603a1b2ff" + "37520001" + 16*"00" + 32*"00" + 32*"00",
2033              valid + "3603a1b2ff" + "37550000" + 16*"00" + 32*"00" + 32*"00" + "0301aa",
2034              valid + "3603a1b2ff" + "37550000" + 16*"00" + 32*"00" + 32*"00" + "0301aa" + "3000",
2035              valid + "3603a1b2ff" + "37550000" + 16*"00" + 32*"00" + 32*"00" + "0301aa" + "30260100000fac040100000fac040100000facff00000100a225368fe0983b5828a37a0acb37f253",
2036              valid + "3603a1b2ff" + "37550000" + 16*"00" + 32*"00" + 32*"00" + "0301aa" + "30260100000fac040100000fac030100000fac0400000100a225368fe0983b5828a37a0acb37f253",
2037              valid + "3603a1b2ff" + "37550000" + 16*"00" + 32*"00" + 32*"00" + "0301aa" + "30260100000fac040100000fac040100000fac0400000100a225368fe0983b5828a37a0acb37f253",
2038              valid + "0001"]
2039     for t in tests:
2040         hapd0.dump_monitor()
2041         if "OK" not in hapd0.request("MGMT_RX_PROCESS freq=2412 datarate=0 ssi_signal=-30 frame=" + hdr + t):
2042             raise Exception("MGMT_RX_PROCESS failed")
2043
2044     hapd0.set("ext_mgmt_frame_handling", "0")
2045
2046 def test_ap_ft_over_ds_proto(dev, apdev):
2047     """WPA2-PSK-FT AP over DS protocol testing"""
2048     ssid = "test-ft"
2049     passphrase = "12345678"
2050
2051     params = ft_params1(ssid=ssid, passphrase=passphrase)
2052     hapd0 = hostapd.add_ap(apdev[0], params)
2053     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2054                    scan_freq="2412")
2055
2056     # FT Action Response while no FT-over-DS in progress
2057     msg = {}
2058     msg['fc'] = 13 << 4
2059     msg['da'] = dev[0].own_addr()
2060     msg['sa'] = apdev[0]['bssid']
2061     msg['bssid'] = apdev[0]['bssid']
2062     msg['payload'] = binascii.unhexlify("06020200000000000200000004000000")
2063     hapd0.mgmt_tx(msg)
2064
2065     params = ft_params2(ssid=ssid, passphrase=passphrase)
2066     hapd1 = hostapd.add_ap(apdev[1], params)
2067     dev[0].scan_for_bss(apdev[1]['bssid'], freq="2412")
2068     hapd0.set("ext_mgmt_frame_handling", "1")
2069     hapd0.dump_monitor()
2070     dev[0].request("FT_DS " + apdev[1]['bssid'])
2071     for i in range(0, 10):
2072         req = hapd0.mgmt_rx()
2073         if req is None:
2074             raise Exception("MGMT RX wait timed out")
2075         if req['subtype'] == 13:
2076             break
2077         req = None
2078     if not req:
2079         raise Exception("FT Action frame not received")
2080
2081     # FT Action Response for unexpected Target AP
2082     msg['payload'] = binascii.unhexlify("0602020000000000" + "f20000000400" + "0000")
2083     hapd0.mgmt_tx(msg)
2084
2085     # FT Action Response without MDIE
2086     msg['payload'] = binascii.unhexlify("0602020000000000" + "020000000400" + "0000")
2087     hapd0.mgmt_tx(msg)
2088
2089     # FT Action Response without FTIE
2090     msg['payload'] = binascii.unhexlify("0602020000000000" + "020000000400" + "0000" + "3603a1b201")
2091     hapd0.mgmt_tx(msg)
2092
2093     # FT Action Response with FTIE SNonce mismatch
2094     msg['payload'] = binascii.unhexlify("0602020000000000" + "020000000400" + "0000" + "3603a1b201" + "3766000000000000000000000000000000000000c4e67ac1999bebd00ff4ae4d5dcaf87896bb060b469f7c78d49623fb395c3455ffffff6b693fe6f8d8c5dfac0a22344750775bd09437f98b238c9f87b97f790c0106000102030406030a6e6173312e77312e6669")
2095     hapd0.mgmt_tx(msg)
2096
2097 @remote_compatible
2098 def test_ap_ft_rrb(dev, apdev):
2099     """WPA2-PSK-FT RRB protocol testing"""
2100     ssid = "test-ft"
2101     passphrase = "12345678"
2102
2103     params = ft_params1(ssid=ssid, passphrase=passphrase)
2104     hapd0 = hostapd.add_ap(apdev[0], params)
2105
2106     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2107                    scan_freq="2412")
2108
2109     _dst_ll = binascii.unhexlify(apdev[0]['bssid'].replace(':', ''))
2110     _src_ll = binascii.unhexlify(dev[0].own_addr().replace(':', ''))
2111     proto = b'\x89\x0d'
2112     ehdr = _dst_ll + _src_ll + proto
2113
2114     # Too short RRB frame
2115     pkt = ehdr + b'\x01'
2116     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2117         raise Exception("DATA_TEST_FRAME failed")
2118
2119     # RRB discarded frame wikth unrecognized type
2120     pkt = ehdr + b'\x02' + b'\x02' + b'\x01\x00' + _src_ll
2121     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2122         raise Exception("DATA_TEST_FRAME failed")
2123
2124     # RRB frame too short for action frame
2125     pkt = ehdr + b'\x01' + b'\x02' + b'\x01\x00' + _src_ll
2126     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2127         raise Exception("DATA_TEST_FRAME failed")
2128
2129     # Too short RRB frame (not enough room for Action Frame body)
2130     pkt = ehdr + b'\x01' + b'\x02' + b'\x00\x00' + _src_ll
2131     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2132         raise Exception("DATA_TEST_FRAME failed")
2133
2134     # Unexpected Action frame category
2135     pkt = ehdr + b'\x01' + b'\x02' + b'\x0e\x00' + _src_ll + b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
2136     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2137         raise Exception("DATA_TEST_FRAME failed")
2138
2139     # Unexpected Action in RRB Request
2140     pkt = ehdr + b'\x01' + b'\x00' + b'\x0e\x00' + _src_ll + b'\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
2141     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2142         raise Exception("DATA_TEST_FRAME failed")
2143
2144     # Target AP address in RRB Request does not match with own address
2145     pkt = ehdr + b'\x01' + b'\x00' + b'\x0e\x00' + _src_ll + b'\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
2146     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2147         raise Exception("DATA_TEST_FRAME failed")
2148
2149     # Not enough room for status code in RRB Response
2150     pkt = ehdr + b'\x01' + b'\x01' + b'\x0e\x00' + _src_ll + b'\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
2151     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2152         raise Exception("DATA_TEST_FRAME failed")
2153
2154     # RRB discarded frame with unknown packet_type
2155     pkt = ehdr + b'\x01' + b'\x02' + b'\x0e\x00' + _src_ll + b'\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
2156     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2157         raise Exception("DATA_TEST_FRAME failed")
2158
2159     # RRB Response with non-zero status code; no STA match
2160     pkt = ehdr + b'\x01' + b'\x01' + b'\x10\x00' + _src_ll + b'\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + b'\xff\xff'
2161     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2162         raise Exception("DATA_TEST_FRAME failed")
2163
2164     # RRB Response with zero status code and extra data; STA match
2165     pkt = ehdr + b'\x01' + b'\x01' + b'\x11\x00' + _src_ll + b'\x06\x01' + _src_ll + b'\x00\x00\x00\x00\x00\x00' + b'\x00\x00' + b'\x00'
2166     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2167         raise Exception("DATA_TEST_FRAME failed")
2168
2169     # Too short PMK-R1 pull
2170     pkt = ehdr + b'\x01' + b'\xc8' + b'\x0e\x00' + _src_ll + b'\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
2171     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2172         raise Exception("DATA_TEST_FRAME failed")
2173
2174     # Too short PMK-R1 resp
2175     pkt = ehdr + b'\x01' + b'\xc9' + b'\x0e\x00' + _src_ll + b'\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
2176     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2177         raise Exception("DATA_TEST_FRAME failed")
2178
2179     # Too short PMK-R1 push
2180     pkt = ehdr + b'\x01' + b'\xca' + b'\x0e\x00' + _src_ll + b'\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
2181     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2182         raise Exception("DATA_TEST_FRAME failed")
2183
2184     # No matching R0KH address found for PMK-R0 pull response
2185     pkt = ehdr + b'\x01' + b'\xc9' + b'\x5a\x00' + _src_ll + b'\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' + 76 * b'\00'
2186     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2187         raise Exception("DATA_TEST_FRAME failed")
2188
2189 @remote_compatible
2190 def test_rsn_ie_proto_ft_psk_sta(dev, apdev):
2191     """RSN element protocol testing for FT-PSK + PMF cases on STA side"""
2192     bssid = apdev[0]['bssid']
2193     ssid = "test-ft"
2194     passphrase = "12345678"
2195
2196     params = ft_params1(ssid=ssid, passphrase=passphrase)
2197     params["ieee80211w"] = "1"
2198     # This is the RSN element used normally by hostapd
2199     params['own_ie_override'] = '30140100000fac040100000fac040100000fac048c00' + '3603a1b201'
2200     hapd = hostapd.add_ap(apdev[0], params)
2201     id = dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2202                         ieee80211w="1", scan_freq="2412",
2203                         pairwise="CCMP", group="CCMP")
2204
2205     tests = [('PMKIDCount field included',
2206               '30160100000fac040100000fac040100000fac048c000000' + '3603a1b201'),
2207              ('Extra IE before RSNE',
2208               'dd0400000000' + '30140100000fac040100000fac040100000fac048c00' + '3603a1b201'),
2209              ('PMKIDCount and Group Management Cipher suite fields included',
2210               '301a0100000fac040100000fac040100000fac048c000000000fac06' + '3603a1b201'),
2211              ('Extra octet after defined fields (future extensibility)',
2212               '301b0100000fac040100000fac040100000fac048c000000000fac0600' + '3603a1b201'),
2213              ('No RSN Capabilities field (PMF disabled in practice)',
2214               '30120100000fac040100000fac040100000fac04' + '3603a1b201')]
2215     for txt, ie in tests:
2216         dev[0].request("DISCONNECT")
2217         dev[0].wait_disconnected()
2218         logger.info(txt)
2219         hapd.disable()
2220         hapd.set('own_ie_override', ie)
2221         hapd.enable()
2222         dev[0].request("BSS_FLUSH 0")
2223         dev[0].scan_for_bss(bssid, 2412, force_scan=True, only_new=True)
2224         dev[0].select_network(id, freq=2412)
2225         dev[0].wait_connected()
2226
2227     dev[0].request("DISCONNECT")
2228     dev[0].wait_disconnected()
2229
2230     logger.info('Invalid RSNE causing internal hostapd error')
2231     hapd.disable()
2232     hapd.set('own_ie_override', '30130100000fac040100000fac040100000fac048c' + '3603a1b201')
2233     hapd.enable()
2234     dev[0].request("BSS_FLUSH 0")
2235     dev[0].scan_for_bss(bssid, 2412, force_scan=True, only_new=True)
2236     dev[0].select_network(id, freq=2412)
2237     # hostapd fails to generate EAPOL-Key msg 3/4, so this connection cannot
2238     # complete.
2239     ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED"], timeout=1)
2240     if ev is not None:
2241         raise Exception("Unexpected connection")
2242     dev[0].request("DISCONNECT")
2243
2244     logger.info('Unexpected PMKID causing internal hostapd error')
2245     hapd.disable()
2246     hapd.set('own_ie_override', '30260100000fac040100000fac040100000fac048c000100ffffffffffffffffffffffffffffffff' + '3603a1b201')
2247     hapd.enable()
2248     dev[0].request("BSS_FLUSH 0")
2249     dev[0].scan_for_bss(bssid, 2412, force_scan=True, only_new=True)
2250     dev[0].select_network(id, freq=2412)
2251     # hostapd fails to generate EAPOL-Key msg 3/4, so this connection cannot
2252     # complete.
2253     ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED"], timeout=1)
2254     if ev is not None:
2255         raise Exception("Unexpected connection")
2256     dev[0].request("DISCONNECT")
2257
2258 def test_ap_ft_ptk_rekey(dev, apdev):
2259     """WPA2-PSK-FT PTK rekeying triggered by station after roam"""
2260     ssid = "test-ft"
2261     passphrase = "12345678"
2262
2263     params = ft_params1(ssid=ssid, passphrase=passphrase)
2264     hapd0 = hostapd.add_ap(apdev[0], params)
2265     params = ft_params2(ssid=ssid, passphrase=passphrase)
2266     hapd1 = hostapd.add_ap(apdev[1], params)
2267
2268     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, ptk_rekey="1")
2269
2270     ev = dev[0].wait_event(["CTRL-EVENT-DISCONNECTED",
2271                             "WPA: Key negotiation completed"], timeout=5)
2272     if ev is None:
2273         raise Exception("No event received after roam")
2274     if "CTRL-EVENT-DISCONNECTED" in ev:
2275         raise Exception("Unexpected disconnection after roam")
2276
2277     if dev[0].get_status_field('bssid') == apdev[0]['bssid']:
2278         hapd = hapd0
2279     else:
2280         hapd = hapd1
2281     hwsim_utils.test_connectivity(dev[0], hapd)
2282
2283 def test_ap_ft_ptk_rekey_ap(dev, apdev):
2284     """WPA2-PSK-FT PTK rekeying triggered by AP after roam"""
2285     ssid = "test-ft"
2286     passphrase = "12345678"
2287
2288     params = ft_params1(ssid=ssid, passphrase=passphrase)
2289     params['wpa_ptk_rekey'] = '2'
2290     hapd0 = hostapd.add_ap(apdev[0], params)
2291     params = ft_params2(ssid=ssid, passphrase=passphrase)
2292     params['wpa_ptk_rekey'] = '2'
2293     hapd1 = hostapd.add_ap(apdev[1], params)
2294
2295     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase)
2296
2297     ev = dev[0].wait_event(["CTRL-EVENT-DISCONNECTED",
2298                             "WPA: Key negotiation completed"], timeout=5)
2299     if ev is None:
2300         raise Exception("No event received after roam")
2301     if "CTRL-EVENT-DISCONNECTED" in ev:
2302         raise Exception("Unexpected disconnection after roam")
2303
2304     if dev[0].get_status_field('bssid') == apdev[0]['bssid']:
2305         hapd = hapd0
2306     else:
2307         hapd = hapd1
2308     hwsim_utils.test_connectivity(dev[0], hapd)
2309
2310 def test_ap_ft_internal_rrb_check(dev, apdev):
2311     """RRB internal delivery only to WPA enabled BSS"""
2312     ssid = "test-ft"
2313     passphrase = "12345678"
2314
2315     radius = hostapd.radius_params()
2316     params = ft_params1(ssid=ssid, passphrase=passphrase)
2317     params['wpa_key_mgmt'] = "FT-EAP"
2318     params["ieee8021x"] = "1"
2319     params = dict(list(radius.items()) + list(params.items()))
2320     hapd = hostapd.add_ap(apdev[0], params)
2321     key_mgmt = hapd.get_config()['key_mgmt']
2322     if key_mgmt.split(' ')[0] != "FT-EAP":
2323         raise Exception("Unexpected GET_CONFIG(key_mgmt): " + key_mgmt)
2324
2325     hapd1 = hostapd.add_ap(apdev[1], {"ssid": ssid})
2326
2327     # Connect to WPA enabled AP
2328     dev[0].connect(ssid, key_mgmt="FT-EAP", proto="WPA2", ieee80211w="1",
2329                    eap="GPSK", identity="gpsk user",
2330                    password="abcdefghijklmnop0123456789abcdef",
2331                    scan_freq="2412")
2332
2333     # Try over_ds roaming to non-WPA-enabled AP.
2334     # If hostapd does not check hapd->wpa_auth internally, it will crash now.
2335     dev[0].roam_over_ds(apdev[1]['bssid'], fail_test=True)
2336
2337 def test_ap_ft_extra_ie(dev, apdev):
2338     """WPA2-PSK-FT AP with WPA2-PSK enabled and unexpected MDE"""
2339     ssid = "test-ft"
2340     passphrase = "12345678"
2341
2342     params = ft_params1(ssid=ssid, passphrase=passphrase)
2343     params["wpa_key_mgmt"] = "WPA-PSK FT-PSK"
2344     hapd0 = hostapd.add_ap(apdev[0], params)
2345     dev[1].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2346                    scan_freq="2412")
2347     dev[2].connect(ssid, psk=passphrase, key_mgmt="WPA-PSK", proto="WPA2",
2348                    scan_freq="2412")
2349     try:
2350         # Add Mobility Domain element to test AP validation code.
2351         dev[0].request("VENDOR_ELEM_ADD 13 3603a1b201")
2352         dev[0].connect(ssid, psk=passphrase, key_mgmt="WPA-PSK", proto="WPA2",
2353                        scan_freq="2412", wait_connect=False)
2354         ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED",
2355                                 "CTRL-EVENT-ASSOC-REJECT"], timeout=10)
2356         if ev is None:
2357             raise Exception("No connection result")
2358         if "CTRL-EVENT-CONNECTED" in ev:
2359             raise Exception("Non-FT association accepted with MDE")
2360         if "status_code=43" not in ev:
2361             raise Exception("Unexpected status code: " + ev)
2362         dev[0].request("DISCONNECT")
2363     finally:
2364         dev[0].request("VENDOR_ELEM_REMOVE 13 *")
2365
2366 def test_ap_ft_ric(dev, apdev):
2367     """WPA2-PSK-FT AP and RIC"""
2368     ssid = "test-ft"
2369     passphrase = "12345678"
2370
2371     params = ft_params1(ssid=ssid, passphrase=passphrase)
2372     hapd0 = hostapd.add_ap(apdev[0], params)
2373     params = ft_params2(ssid=ssid, passphrase=passphrase)
2374     hapd1 = hostapd.add_ap(apdev[1], params)
2375
2376     dev[0].set("ric_ies", "")
2377     dev[0].set("ric_ies", '""')
2378     if "FAIL" not in dev[0].request("SET ric_ies q"):
2379         raise Exception("Invalid ric_ies value accepted")
2380
2381     tests = ["3900",
2382              "3900ff04eeeeeeee",
2383              "390400000000",
2384              "390400000000" + "390400000000",
2385              "390400000000" + "dd050050f20202",
2386              "390400000000" + "dd3d0050f2020201" + 55*"00",
2387              "390400000000" + "dd3d0050f2020201aa300010270000000000000000000000000000000000000000000000000000ffffff7f00000000000000000000000040420f00ffff0000",
2388              "390401010000" + "dd3d0050f2020201aa3000dc050000000000000000000000000000000000000000000000000000dc050000000000000000000000000000808d5b0028230000"]
2389     for t in tests:
2390         dev[0].set("ric_ies", t)
2391         run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase,
2392                   test_connectivity=False)
2393         dev[0].request("REMOVE_NETWORK all")
2394         dev[0].wait_disconnected()
2395         dev[0].dump_monitor()
2396
2397 def ie_hex(ies, id):
2398     return binascii.hexlify(struct.pack('BB', id, len(ies[id])) + ies[id]).decode()
2399
2400 def test_ap_ft_reassoc_proto(dev, apdev):
2401     """WPA2-PSK-FT AP Reassociation Request frame parsing"""
2402     ssid = "test-ft"
2403     passphrase = "12345678"
2404
2405     params = ft_params1(ssid=ssid, passphrase=passphrase)
2406     hapd0 = hostapd.add_ap(apdev[0], params)
2407     params = ft_params2(ssid=ssid, passphrase=passphrase)
2408     hapd1 = hostapd.add_ap(apdev[1], params)
2409
2410     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2411                    ieee80211w="1", scan_freq="2412")
2412     if dev[0].get_status_field('bssid') == hapd0.own_addr():
2413         hapd1ap = hapd0
2414         hapd2ap = hapd1
2415     else:
2416         hapd1ap = hapd1
2417         hapd2ap = hapd0
2418
2419     dev[0].scan_for_bss(hapd2ap.own_addr(), freq="2412")
2420     hapd2ap.set("ext_mgmt_frame_handling", "1")
2421     dev[0].request("ROAM " + hapd2ap.own_addr())
2422
2423     while True:
2424         req = hapd2ap.mgmt_rx()
2425         hapd2ap.request("MGMT_RX_PROCESS freq=2412 datarate=0 ssi_signal=-30 frame=" + binascii.hexlify(req['frame']).decode())
2426         if req['subtype'] == 11:
2427             break
2428
2429     while True:
2430         req = hapd2ap.mgmt_rx()
2431         if req['subtype'] == 2:
2432             break
2433         hapd2ap.request("MGMT_RX_PROCESS freq=2412 datarate=0 ssi_signal=-30 frame=" + binascii.hexlify(req['frame']).decode())
2434
2435     # IEEE 802.11 header + fixed fields before IEs
2436     hdr = binascii.hexlify(req['frame'][0:34]).decode()
2437     ies = parse_ie(binascii.hexlify(req['frame'][34:]))
2438     # First elements: SSID, Supported Rates, Extended Supported Rates
2439     ies1 = ie_hex(ies, 0) + ie_hex(ies, 1) + ie_hex(ies, 50)
2440
2441     rsne = ie_hex(ies, 48)
2442     mde = ie_hex(ies, 54)
2443     fte = ie_hex(ies, 55)
2444     tests = []
2445     # RSN: Trying to use FT, but MDIE not included
2446     tests += [rsne]
2447     # RSN: Attempted to use unknown MDIE
2448     tests += [rsne + "3603000000"]
2449     # Invalid RSN pairwise cipher
2450     tests += ["30260100000fac040100000fac030100000fac040000010029208a42cd25c85aa571567dce10dae3"]
2451     # FT: No PMKID in RSNIE
2452     tests += ["30160100000fac040100000fac040100000fac0400000000" + ie_hex(ies, 54)]
2453     # FT: Invalid FTIE
2454     tests += [rsne + mde]
2455     # FT: RIC IE(s) in the frame, but not included in protected IE count
2456     # FT: Failed to parse FT IEs
2457     tests += [rsne + mde + fte + "3900"]
2458     # FT: SNonce mismatch in FTIE
2459     tests += [rsne + mde + "37520000" + 16*"00" + 32*"00" + 32*"00"]
2460     # FT: ANonce mismatch in FTIE
2461     tests += [rsne + mde + fte[0:40] + 32*"00" + fte[104:]]
2462     # FT: No R0KH-ID subelem in FTIE
2463     tests += [rsne + mde + "3752" + fte[4:168]]
2464     # FT: R0KH-ID in FTIE did not match with the current R0KH-ID
2465     tests += [rsne + mde + "3755" + fte[4:168] + "0301ff"]
2466     # FT: No R1KH-ID subelem in FTIE
2467     tests += [rsne + mde + "375e" + fte[4:168] + "030a" + binascii.hexlify(b"nas1.w1.fi").decode()]
2468     # FT: Unknown R1KH-ID used in ReassocReq
2469     tests += [rsne + mde + "3766" + fte[4:168] + "030a" + binascii.hexlify(b"nas1.w1.fi").decode() + "0106000000000000"]
2470     # FT: PMKID in Reassoc Req did not match with the PMKR1Name derived from auth request
2471     tests += [rsne[:-32] + 16*"00" + mde + fte]
2472     # Invalid MIC in FTIE
2473     tests += [rsne + mde + fte[0:8] + 16*"00" + fte[40:]]
2474     for t in tests:
2475         hapd2ap.request("MGMT_RX_PROCESS freq=2412 datarate=0 ssi_signal=-30 frame=" + hdr + ies1 + t)
2476
2477 def test_ap_ft_reassoc_local_fail(dev, apdev):
2478     """WPA2-PSK-FT AP Reassociation Request frame and local failure"""
2479     ssid = "test-ft"
2480     passphrase = "12345678"
2481
2482     params = ft_params1(ssid=ssid, passphrase=passphrase)
2483     hapd0 = hostapd.add_ap(apdev[0], params)
2484     params = ft_params2(ssid=ssid, passphrase=passphrase)
2485     hapd1 = hostapd.add_ap(apdev[1], params)
2486
2487     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2488                    ieee80211w="1", scan_freq="2412")
2489     if dev[0].get_status_field('bssid') == hapd0.own_addr():
2490         hapd1ap = hapd0
2491         hapd2ap = hapd1
2492     else:
2493         hapd1ap = hapd1
2494         hapd2ap = hapd0
2495
2496     dev[0].scan_for_bss(hapd2ap.own_addr(), freq="2412")
2497     # FT: Failed to calculate MIC
2498     with fail_test(hapd2ap, 1, "wpa_ft_validate_reassoc"):
2499         dev[0].request("ROAM " + hapd2ap.own_addr())
2500         ev = dev[0].wait_event(["CTRL-EVENT-ASSOC-REJECT"], timeout=10)
2501         dev[0].request("DISCONNECT")
2502         if ev is None:
2503             raise Exception("Association reject not seen")
2504
2505 def test_ap_ft_reassoc_replay(dev, apdev, params):
2506     """WPA2-PSK-FT AP and replayed Reassociation Request frame"""
2507     capfile = os.path.join(params['logdir'], "hwsim0.pcapng")
2508     ssid = "test-ft"
2509     passphrase = "12345678"
2510
2511     params = ft_params1(ssid=ssid, passphrase=passphrase)
2512     hapd0 = hostapd.add_ap(apdev[0], params)
2513     params = ft_params2(ssid=ssid, passphrase=passphrase)
2514     hapd1 = hostapd.add_ap(apdev[1], params)
2515
2516     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2517                    scan_freq="2412")
2518     if dev[0].get_status_field('bssid') == hapd0.own_addr():
2519         hapd1ap = hapd0
2520         hapd2ap = hapd1
2521     else:
2522         hapd1ap = hapd1
2523         hapd2ap = hapd0
2524
2525     dev[0].scan_for_bss(hapd2ap.own_addr(), freq="2412")
2526     hapd2ap.set("ext_mgmt_frame_handling", "1")
2527     dev[0].dump_monitor()
2528     if "OK" not in dev[0].request("ROAM " + hapd2ap.own_addr()):
2529         raise Exception("ROAM failed")
2530
2531     reassocreq = None
2532     count = 0
2533     while count < 100:
2534         req = hapd2ap.mgmt_rx()
2535         count += 1
2536         hapd2ap.dump_monitor()
2537         hapd2ap.request("MGMT_RX_PROCESS freq=2412 datarate=0 ssi_signal=-30 frame=" + binascii.hexlify(req['frame']).decode())
2538         if req['subtype'] == 2:
2539             reassocreq = req
2540             ev = hapd2ap.wait_event(["MGMT-TX-STATUS"], timeout=5)
2541             if ev is None:
2542                 raise Exception("No TX status seen")
2543             cmd = "MGMT_TX_STATUS_PROCESS %s" % (" ".join(ev.split(' ')[1:4]))
2544             if "OK" not in hapd2ap.request(cmd):
2545                 raise Exception("MGMT_TX_STATUS_PROCESS failed")
2546             break
2547     hapd2ap.set("ext_mgmt_frame_handling", "0")
2548     if reassocreq is None:
2549         raise Exception("No Reassociation Request frame seen")
2550     dev[0].wait_connected()
2551     dev[0].dump_monitor()
2552     hapd2ap.dump_monitor()
2553
2554     hwsim_utils.test_connectivity(dev[0], hapd2ap)
2555
2556     logger.info("Replay the last Reassociation Request frame")
2557     hapd2ap.dump_monitor()
2558     hapd2ap.set("ext_mgmt_frame_handling", "1")
2559     hapd2ap.request("MGMT_RX_PROCESS freq=2412 datarate=0 ssi_signal=-30 frame=" + binascii.hexlify(req['frame']).decode())
2560     ev = hapd2ap.wait_event(["MGMT-TX-STATUS"], timeout=5)
2561     if ev is None:
2562         raise Exception("No TX status seen")
2563     cmd = "MGMT_TX_STATUS_PROCESS %s" % (" ".join(ev.split(' ')[1:4]))
2564     if "OK" not in hapd2ap.request(cmd):
2565         raise Exception("MGMT_TX_STATUS_PROCESS failed")
2566     hapd2ap.set("ext_mgmt_frame_handling", "0")
2567
2568     try:
2569         hwsim_utils.test_connectivity(dev[0], hapd2ap)
2570         ok = True
2571     except:
2572         ok = False
2573
2574     ap = hapd2ap.own_addr()
2575     sta = dev[0].own_addr()
2576     filt = "wlan.fc.type == 2 && " + \
2577            "wlan.da == " + sta + " && " + \
2578            "wlan.sa == " + ap
2579     fields = ["wlan.ccmp.extiv"]
2580     res = run_tshark(capfile, filt, fields)
2581     vals = res.splitlines()
2582     logger.info("CCMP PN: " + str(vals))
2583     if len(vals) < 2:
2584         raise Exception("Could not find all CCMP protected frames from capture")
2585     if len(set(vals)) < len(vals):
2586         raise Exception("Duplicate CCMP PN used")
2587
2588     if not ok:
2589         raise Exception("The second hwsim connectivity test failed")
2590
2591 def test_ap_ft_psk_file(dev, apdev):
2592     """WPA2-PSK-FT AP with PSK from a file"""
2593     ssid = "test-ft"
2594     passphrase = "12345678"
2595
2596     params = ft_params1a(ssid=ssid, passphrase=passphrase)
2597     params['wpa_psk_file'] = 'hostapd.wpa_psk'
2598     hapd = hostapd.add_ap(apdev[0], params)
2599
2600     dev[1].connect(ssid, psk="very secret",
2601                    key_mgmt="FT-PSK", proto="WPA2", ieee80211w="1",
2602                    scan_freq="2412", wait_connect=False)
2603     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2604                    ieee80211w="1", scan_freq="2412")
2605     dev[0].request("REMOVE_NETWORK all")
2606     dev[0].wait_disconnected()
2607     dev[0].connect(ssid, psk="very secret", key_mgmt="FT-PSK", proto="WPA2",
2608                    ieee80211w="1", scan_freq="2412")
2609     dev[0].request("REMOVE_NETWORK all")
2610     dev[0].wait_disconnected()
2611     dev[0].connect(ssid, psk="secret passphrase",
2612                    key_mgmt="FT-PSK", proto="WPA2", ieee80211w="1",
2613                    scan_freq="2412")
2614     dev[2].connect(ssid, psk="another passphrase for all STAs",
2615                    key_mgmt="FT-PSK", proto="WPA2", ieee80211w="1",
2616                    scan_freq="2412")
2617     ev = dev[1].wait_event(["WPA: 4-Way Handshake failed"], timeout=10)
2618     if ev is None:
2619         raise Exception("Timed out while waiting for failure report")
2620     dev[1].request("REMOVE_NETWORK all")
2621
2622 def test_ap_ft_eap_ap_config_change(dev, apdev):
2623     """WPA2-EAP-FT AP changing from 802.1X-only to FT-only"""
2624     ssid = "test-ft"
2625     passphrase = "12345678"
2626     bssid = apdev[0]['bssid']
2627
2628     radius = hostapd.radius_params()
2629     params = ft_params1(ssid=ssid, passphrase=passphrase, discovery=True)
2630     params['wpa_key_mgmt'] = "WPA-EAP"
2631     params["ieee8021x"] = "1"
2632     params["pmk_r1_push"] = "0"
2633     params["r0kh"] = "ff:ff:ff:ff:ff:ff * 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
2634     params["r1kh"] = "00:00:00:00:00:00 00:00:00:00:00:00 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
2635     params["eap_server"] = "0"
2636     params = dict(list(radius.items()) + list(params.items()))
2637     hapd = hostapd.add_ap(apdev[0], params)
2638
2639     dev[0].connect(ssid, key_mgmt="FT-EAP WPA-EAP", proto="WPA2",
2640                    eap="GPSK", identity="gpsk user",
2641                    password="abcdefghijklmnop0123456789abcdef",
2642                    scan_freq="2412")
2643     dev[0].request("DISCONNECT")
2644     dev[0].wait_disconnected()
2645     dev[0].dump_monitor()
2646
2647     hapd.disable()
2648     hapd.set('wpa_key_mgmt', "FT-EAP")
2649     hapd.enable()
2650
2651     dev[0].request("BSS_FLUSH 0")
2652     dev[0].scan_for_bss(bssid, 2412, force_scan=True, only_new=True)
2653
2654     dev[0].request("RECONNECT")
2655     dev[0].wait_connected()
2656
2657 def test_ap_ft_eap_sha384(dev, apdev):
2658     """WPA2-EAP-FT with SHA384"""
2659     ssid = "test-ft"
2660     passphrase = "12345678"
2661
2662     radius = hostapd.radius_params()
2663     params = ft_params1(ssid=ssid, passphrase=passphrase)
2664     params["ieee80211w"] = "2"
2665     params['wpa_key_mgmt'] = "FT-EAP-SHA384"
2666     params["ieee8021x"] = "1"
2667     params = dict(list(radius.items()) + list(params.items()))
2668     hapd0 = hostapd.add_ap(apdev[0], params)
2669     params = ft_params2(ssid=ssid, passphrase=passphrase)
2670     params["ieee80211w"] = "2"
2671     params['wpa_key_mgmt'] = "FT-EAP-SHA384"
2672     params["ieee8021x"] = "1"
2673     params = dict(list(radius.items()) + list(params.items()))
2674     hapd1 = hostapd.add_ap(apdev[1], params)
2675
2676     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, eap=True,
2677               sha384=True)
2678
2679 def test_ap_ft_eap_sha384_over_ds(dev, apdev):
2680     """WPA2-EAP-FT with SHA384 over DS"""
2681     ssid = "test-ft"
2682     passphrase = "12345678"
2683
2684     radius = hostapd.radius_params()
2685     params = ft_params1(ssid=ssid, passphrase=passphrase)
2686     params["ieee80211w"] = "2"
2687     params['wpa_key_mgmt'] = "FT-EAP-SHA384"
2688     params["ieee8021x"] = "1"
2689     params = dict(list(radius.items()) + list(params.items()))
2690     hapd0 = hostapd.add_ap(apdev[0], params)
2691     params = ft_params2(ssid=ssid, passphrase=passphrase)
2692     params["ieee80211w"] = "2"
2693     params['wpa_key_mgmt'] = "FT-EAP-SHA384"
2694     params["ieee8021x"] = "1"
2695     params = dict(list(radius.items()) + list(params.items()))
2696     hapd1 = hostapd.add_ap(apdev[1], params)
2697
2698     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
2699               eap=True, sha384=True)
2700
2701 def test_ap_ft_roam_rrm(dev, apdev):
2702     """WPA2-PSK-FT AP and radio measurement request"""
2703     ssid = "test-ft"
2704     passphrase = "12345678"
2705
2706     params = ft_params1(ssid=ssid, passphrase=passphrase)
2707     params["rrm_beacon_report"] = "1"
2708     hapd0 = hostapd.add_ap(apdev[0], params)
2709     bssid0 = hapd0.own_addr()
2710
2711     addr = dev[0].own_addr()
2712     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2713                    scan_freq="2412")
2714     check_beacon_req(hapd0, addr, 1)
2715
2716     params = ft_params2(ssid=ssid, passphrase=passphrase)
2717     params["rrm_beacon_report"] = "1"
2718     hapd1 = hostapd.add_ap(apdev[1], params)
2719     bssid1 = hapd1.own_addr()
2720
2721     dev[0].scan_for_bss(bssid1, freq=2412)
2722     dev[0].roam(bssid1)
2723     check_beacon_req(hapd1, addr, 2)
2724
2725     dev[0].scan_for_bss(bssid0, freq=2412)
2726     dev[0].roam(bssid0)
2727     check_beacon_req(hapd0, addr, 3)