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):
 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"] = "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     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
 820               group_mgmt=cipher)
 821
 822 def test_ap_ft_over_ds_pull(dev, apdev):
 823     """WPA2-PSK-FT AP over DS (pull PMK)"""
 824     ssid = "test-ft"
 825     passphrase="12345678"
 826
 827     params = ft_params1(ssid=ssid, passphrase=passphrase)
 828     params["pmk_r1_push"] = "0"
 829     hapd0 = hostapd.add_ap(apdev[0], params)
 830     params = ft_params2(ssid=ssid, passphrase=passphrase)
 831     params["pmk_r1_push"] = "0"
 832     hapd1 = hostapd.add_ap(apdev[1], params)
 833
 834     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True)
 835
 836 def test_ap_ft_over_ds_pull_old_key(dev, apdev):
 837     """WPA2-PSK-FT AP over DS (pull PMK; old key)"""
 838     ssid = "test-ft"
 839     passphrase="12345678"
 840
 841     params = ft_params1_old_key(ssid=ssid, passphrase=passphrase)
 842     params["pmk_r1_push"] = "0"
 843     hapd0 = hostapd.add_ap(apdev[0], params)
 844     params = ft_params2_old_key(ssid=ssid, passphrase=passphrase)
 845     params["pmk_r1_push"] = "0"
 846     hapd1 = hostapd.add_ap(apdev[1], params)
 847
 848     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True)
 849
 850 def test_ap_ft_over_ds_pull_vlan(dev, apdev):
 851     """WPA2-PSK-FT AP over DS (pull PMK) with VLAN"""
 852     ssid = "test-ft"
 853     passphrase="12345678"
 854
 855     params = ft_params1(ssid=ssid, passphrase=passphrase)
 856     params["pmk_r1_push"] = "0"
 857     params['dynamic_vlan'] = "1"
 858     params['accept_mac_file'] = "hostapd.accept"
 859     hapd0 = hostapd.add_ap(apdev[0]['ifname'], params)
 860     params = ft_params2(ssid=ssid, passphrase=passphrase)
 861     params["pmk_r1_push"] = "0"
 862     params['dynamic_vlan'] = "1"
 863     params['accept_mac_file'] = "hostapd.accept"
 864     hapd1 = hostapd.add_ap(apdev[1]['ifname'], params)
 865
 866     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
 867               conndev="brvlan1")
 868
 869 def test_ap_ft_sae(dev, apdev):
 870     """WPA2-PSK-FT-SAE AP"""
 871     if "SAE" not in dev[0].get_capability("auth_alg"):
 872         raise HwsimSkip("SAE not supported")
 873     ssid = "test-ft"
 874     passphrase="12345678"
 875
 876     params = ft_params1(ssid=ssid, passphrase=passphrase)
 877     params['wpa_key_mgmt'] = "FT-SAE"
 878     hapd0 = hostapd.add_ap(apdev[0], params)
 879     params = ft_params2(ssid=ssid, passphrase=passphrase)
 880     params['wpa_key_mgmt'] = "FT-SAE"
 881     hapd = hostapd.add_ap(apdev[1], params)
 882     key_mgmt = hapd.get_config()['key_mgmt']
 883     if key_mgmt.split(' ')[0] != "FT-SAE":
 884         raise Exception("Unexpected GET_CONFIG(key_mgmt): " + key_mgmt)
 885
 886     dev[0].request("SET sae_groups ")
 887     run_roams(dev[0], apdev, hapd0, hapd, ssid, passphrase, sae=True)
 888
 889 def test_ap_ft_sae_over_ds(dev, apdev):
 890     """WPA2-PSK-FT-SAE AP over DS"""
 891     if "SAE" not in dev[0].get_capability("auth_alg"):
 892         raise HwsimSkip("SAE not supported")
 893     ssid = "test-ft"
 894     passphrase="12345678"
 895
 896     params = ft_params1(ssid=ssid, passphrase=passphrase)
 897     params['wpa_key_mgmt'] = "FT-SAE"
 898     hapd0 = hostapd.add_ap(apdev[0], params)
 899     params = ft_params2(ssid=ssid, passphrase=passphrase)
 900     params['wpa_key_mgmt'] = "FT-SAE"
 901     hapd1 = hostapd.add_ap(apdev[1], params)
 902
 903     dev[0].request("SET sae_groups ")
 904     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, sae=True,
 905               over_ds=True)
 906
 907 def test_ap_ft_sae_pw_id(dev, apdev):
 908     """FT-SAE with Password Identifier"""
 909     if "SAE" not in dev[0].get_capability("auth_alg"):
 910         raise HwsimSkip("SAE not supported")
 911     ssid = "test-ft"
 912
 913     params = ft_params1(ssid=ssid)
 914     params["ieee80211w"] = "2"
 915     params['wpa_key_mgmt'] = "FT-SAE"
 916     params['sae_password'] = 'secret|id=pwid'
 917     hapd0 = hostapd.add_ap(apdev[0], params)
 918     params = ft_params2(ssid=ssid)
 919     params["ieee80211w"] = "2"
 920     params['wpa_key_mgmt'] = "FT-SAE"
 921     params['sae_password'] = 'secret|id=pwid'
 922     hapd = hostapd.add_ap(apdev[1], params)
 923
 924     dev[0].request("SET sae_groups ")
 925     run_roams(dev[0], apdev, hapd0, hapd, ssid, passphrase=None, sae=True,
 926               sae_password="secret", sae_password_id="pwid")
 927
 928 def generic_ap_ft_eap(dev, apdev, vlan=False, cui=False, over_ds=False,
 929                       discovery=False, roams=1):
 930     ssid = "test-ft"
 931     passphrase="12345678"
 932     if vlan:
 933         identity="gpsk-vlan1"
 934         conndev="brvlan1"
 935     elif cui:
 936         identity="gpsk-cui"
 937         conndev=False
 938     else:
 939         identity="gpsk user"
 940         conndev=False
 941
 942     radius = hostapd.radius_params()
 943     params = ft_params1(ssid=ssid, passphrase=passphrase, discovery=discovery)
 944     params['wpa_key_mgmt'] = "FT-EAP"
 945     params["ieee8021x"] = "1"
 946     if vlan:
 947         params["dynamic_vlan"] = "1"
 948     params = dict(list(radius.items()) + list(params.items()))
 949     hapd = hostapd.add_ap(apdev[0], params)
 950     key_mgmt = hapd.get_config()['key_mgmt']
 951     if key_mgmt.split(' ')[0] != "FT-EAP":
 952         raise Exception("Unexpected GET_CONFIG(key_mgmt): " + key_mgmt)
 953     params = ft_params2(ssid=ssid, passphrase=passphrase, discovery=discovery)
 954     params['wpa_key_mgmt'] = "FT-EAP"
 955     params["ieee8021x"] = "1"
 956     if vlan:
 957         params["dynamic_vlan"] = "1"
 958     params = dict(list(radius.items()) + list(params.items()))
 959     hapd1 = hostapd.add_ap(apdev[1], params)
 960
 961     run_roams(dev[0], apdev, hapd, hapd1, ssid, passphrase, eap=True,
 962               over_ds=over_ds, roams=roams, eap_identity=identity,
 963               conndev=conndev)
 964     if "[WPA2-FT/EAP-CCMP]" not in dev[0].request("SCAN_RESULTS"):
 965         raise Exception("Scan results missing RSN element info")
 966     check_mib(dev[0], [ ("dot11RSNAAuthenticationSuiteRequested", "00-0f-ac-3"),
 967                         ("dot11RSNAAuthenticationSuiteSelected", "00-0f-ac-3") ])
 968
 969     # Verify EAPOL reauthentication after FT protocol
 970     if dev[0].get_status_field('bssid') == apdev[0]['bssid']:
 971         ap = hapd
 972     else:
 973         ap = hapd1
 974     ap.request("EAPOL_REAUTH " + dev[0].own_addr())
 975     ev = dev[0].wait_event(["CTRL-EVENT-EAP-STARTED"], timeout=5)
 976     if ev is None:
 977         raise Exception("EAP authentication did not start")
 978     ev = dev[0].wait_event(["CTRL-EVENT-EAP-SUCCESS"], timeout=5)
 979     if ev is None:
 980         raise Exception("EAP authentication did not succeed")
 981     time.sleep(0.1)
 982     if conndev:
 983         hwsim_utils.test_connectivity_iface(dev[0], ap, conndev)
 984     else:
 985         hwsim_utils.test_connectivity(dev[0], ap)
 986
 987 def test_ap_ft_eap(dev, apdev):
 988     """WPA2-EAP-FT AP"""
 989     generic_ap_ft_eap(dev, apdev)
 990
 991 def test_ap_ft_eap_cui(dev, apdev):
 992     """WPA2-EAP-FT AP with CUI"""
 993     generic_ap_ft_eap(dev, apdev, vlan=False, cui=True)
 994
 995 def test_ap_ft_eap_vlan(dev, apdev):
 996     """WPA2-EAP-FT AP with VLAN"""
 997     generic_ap_ft_eap(dev, apdev, vlan=True)
 998
 999 def test_ap_ft_eap_vlan_multi(dev, apdev):
1000     """WPA2-EAP-FT AP with VLAN"""
1001     generic_ap_ft_eap(dev, apdev, vlan=True, roams=50)
1002
1003 def test_ap_ft_eap_over_ds(dev, apdev):
1004     """WPA2-EAP-FT AP using over-the-DS"""
1005     generic_ap_ft_eap(dev, apdev, over_ds=True)
1006
1007 def test_ap_ft_eap_dis(dev, apdev):
1008     """WPA2-EAP-FT AP with AP discovery"""
1009     generic_ap_ft_eap(dev, apdev, discovery=True)
1010
1011 def test_ap_ft_eap_dis_over_ds(dev, apdev):
1012     """WPA2-EAP-FT AP with AP discovery and over-the-DS"""
1013     generic_ap_ft_eap(dev, apdev, over_ds=True, discovery=True)
1014
1015 def test_ap_ft_eap_vlan(dev, apdev):
1016     """WPA2-EAP-FT AP with VLAN"""
1017     generic_ap_ft_eap(dev, apdev, vlan=True)
1018
1019 def test_ap_ft_eap_vlan_multi(dev, apdev):
1020     """WPA2-EAP-FT AP with VLAN"""
1021     generic_ap_ft_eap(dev, apdev, vlan=True, roams=50)
1022
1023 def test_ap_ft_eap_vlan_over_ds(dev, apdev):
1024     """WPA2-EAP-FT AP with VLAN + over_ds"""
1025     generic_ap_ft_eap(dev, apdev, vlan=True, over_ds=True)
1026
1027 def test_ap_ft_eap_vlan_over_ds_multi(dev, apdev):
1028     """WPA2-EAP-FT AP with VLAN + over_ds"""
1029     generic_ap_ft_eap(dev, apdev, vlan=True, over_ds=True, roams=50)
1030
1031 def generic_ap_ft_eap_pull(dev, apdev, vlan=False):
1032     """WPA2-EAP-FT AP (pull PMK)"""
1033     ssid = "test-ft"
1034     passphrase="12345678"
1035     if vlan:
1036         identity="gpsk-vlan1"
1037         conndev="brvlan1"
1038     else:
1039         identity="gpsk user"
1040         conndev=False
1041
1042     radius = hostapd.radius_params()
1043     params = ft_params1(ssid=ssid, passphrase=passphrase)
1044     params['wpa_key_mgmt'] = "FT-EAP"
1045     params["ieee8021x"] = "1"
1046     params["pmk_r1_push"] = "0"
1047     if vlan:
1048         params["dynamic_vlan"] = "1"
1049     params = dict(list(radius.items()) + list(params.items()))
1050     hapd = hostapd.add_ap(apdev[0], params)
1051     key_mgmt = hapd.get_config()['key_mgmt']
1052     if key_mgmt.split(' ')[0] != "FT-EAP":
1053         raise Exception("Unexpected GET_CONFIG(key_mgmt): " + key_mgmt)
1054     params = ft_params2(ssid=ssid, passphrase=passphrase)
1055     params['wpa_key_mgmt'] = "FT-EAP"
1056     params["ieee8021x"] = "1"
1057     params["pmk_r1_push"] = "0"
1058     if vlan:
1059         params["dynamic_vlan"] = "1"
1060     params = dict(list(radius.items()) + list(params.items()))
1061     hapd1 = hostapd.add_ap(apdev[1], params)
1062
1063     run_roams(dev[0], apdev, hapd, hapd1, ssid, passphrase, eap=True,
1064               eap_identity=identity, conndev=conndev)
1065
1066 def test_ap_ft_eap_pull(dev, apdev):
1067     """WPA2-EAP-FT AP (pull PMK)"""
1068     generic_ap_ft_eap_pull(dev, apdev)
1069
1070 def test_ap_ft_eap_pull_vlan(dev, apdev):
1071     generic_ap_ft_eap_pull(dev, apdev, vlan=True)
1072
1073 def test_ap_ft_eap_pull_wildcard(dev, apdev):
1074     """WPA2-EAP-FT AP (pull PMK) - wildcard R0KH/R1KH"""
1075     ssid = "test-ft"
1076     passphrase="12345678"
1077
1078     radius = hostapd.radius_params()
1079     params = ft_params1(ssid=ssid, passphrase=passphrase, discovery=True)
1080     params['wpa_key_mgmt'] = "WPA-EAP FT-EAP"
1081     params["ieee8021x"] = "1"
1082     params["pmk_r1_push"] = "0"
1083     params["r0kh"] = "ff:ff:ff:ff:ff:ff * 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
1084     params["r1kh"] = "00:00:00:00:00:00 00:00:00:00:00:00 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
1085     params["ft_psk_generate_local"] = "1"
1086     params["eap_server"] = "0"
1087     params = dict(list(radius.items()) + list(params.items()))
1088     hapd = hostapd.add_ap(apdev[0], params)
1089     params = ft_params2(ssid=ssid, passphrase=passphrase, discovery=True)
1090     params['wpa_key_mgmt'] = "WPA-EAP FT-EAP"
1091     params["ieee8021x"] = "1"
1092     params["pmk_r1_push"] = "0"
1093     params["r0kh"] = "ff:ff:ff:ff:ff:ff * 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
1094     params["r1kh"] = "00:00:00:00:00:00 00:00:00:00:00:00 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
1095     params["ft_psk_generate_local"] = "1"
1096     params["eap_server"] = "0"
1097     params = dict(list(radius.items()) + list(params.items()))
1098     hapd1 = hostapd.add_ap(apdev[1], params)
1099
1100     run_roams(dev[0], apdev, hapd, hapd1, ssid, passphrase, eap=True)
1101
1102 @remote_compatible
1103 def test_ap_ft_mismatching_rrb_key_push(dev, apdev):
1104     """WPA2-PSK-FT AP over DS with mismatching RRB key (push)"""
1105     ssid = "test-ft"
1106     passphrase="12345678"
1107
1108     params = ft_params1(ssid=ssid, passphrase=passphrase)
1109     params["ieee80211w"] = "2"
1110     hapd0 = hostapd.add_ap(apdev[0], params)
1111     params = ft_params2_incorrect_rrb_key(ssid=ssid, passphrase=passphrase)
1112     params["ieee80211w"] = "2"
1113     hapd1 = hostapd.add_ap(apdev[1], params)
1114
1115     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1116               fail_test=True)
1117
1118 @remote_compatible
1119 def test_ap_ft_mismatching_rrb_key_pull(dev, apdev):
1120     """WPA2-PSK-FT AP over DS with mismatching RRB key (pull)"""
1121     ssid = "test-ft"
1122     passphrase="12345678"
1123
1124     params = ft_params1(ssid=ssid, passphrase=passphrase)
1125     params["pmk_r1_push"] = "0"
1126     hapd0 = hostapd.add_ap(apdev[0], params)
1127     params = ft_params2_incorrect_rrb_key(ssid=ssid, passphrase=passphrase)
1128     params["pmk_r1_push"] = "0"
1129     hapd1 = hostapd.add_ap(apdev[1], params)
1130
1131     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1132               fail_test=True)
1133
1134 @remote_compatible
1135 def test_ap_ft_mismatching_r0kh_id_pull(dev, apdev):
1136     """WPA2-PSK-FT AP over DS with mismatching R0KH-ID (pull)"""
1137     ssid = "test-ft"
1138     passphrase="12345678"
1139
1140     params = ft_params1(ssid=ssid, passphrase=passphrase)
1141     params["pmk_r1_push"] = "0"
1142     params["nas_identifier"] = "nas0.w1.fi"
1143     hostapd.add_ap(apdev[0], params)
1144     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1145                    scan_freq="2412")
1146
1147     params = ft_params2(ssid=ssid, passphrase=passphrase)
1148     params["pmk_r1_push"] = "0"
1149     hostapd.add_ap(apdev[1], params)
1150
1151     dev[0].scan_for_bss(apdev[1]['bssid'], freq="2412")
1152     dev[0].roam_over_ds(apdev[1]['bssid'], fail_test=True)
1153
1154 @remote_compatible
1155 def test_ap_ft_mismatching_rrb_r0kh_push(dev, apdev):
1156     """WPA2-PSK-FT AP over DS with mismatching R0KH key (push)"""
1157     ssid = "test-ft"
1158     passphrase="12345678"
1159
1160     params = ft_params1(ssid=ssid, passphrase=passphrase)
1161     params["ieee80211w"] = "2"
1162     hapd0 = hostapd.add_ap(apdev[0], params)
1163     params = ft_params2_r0kh_mismatch(ssid=ssid, passphrase=passphrase)
1164     params["ieee80211w"] = "2"
1165     hapd1 = hostapd.add_ap(apdev[1], params)
1166
1167     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1168               fail_test=True)
1169
1170 @remote_compatible
1171 def test_ap_ft_mismatching_rrb_r0kh_pull(dev, apdev):
1172     """WPA2-PSK-FT AP over DS with mismatching R0KH key (pull)"""
1173     ssid = "test-ft"
1174     passphrase="12345678"
1175
1176     params = ft_params1_r0kh_mismatch(ssid=ssid, passphrase=passphrase)
1177     params["pmk_r1_push"] = "0"
1178     hapd0 = hostapd.add_ap(apdev[0], params)
1179     params = ft_params2(ssid=ssid, passphrase=passphrase)
1180     params["pmk_r1_push"] = "0"
1181     hapd1 = hostapd.add_ap(apdev[1], params)
1182
1183     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1184               fail_test=True)
1185
1186 def test_ap_ft_mismatching_rrb_key_push_eap(dev, apdev):
1187     """WPA2-EAP-FT AP over DS with mismatching RRB key (push)"""
1188     ssid = "test-ft"
1189     passphrase="12345678"
1190
1191     radius = hostapd.radius_params()
1192     params = ft_params1(ssid=ssid, passphrase=passphrase)
1193     params["ieee80211w"] = "2"
1194     params['wpa_key_mgmt'] = "FT-EAP"
1195     params["ieee8021x"] = "1"
1196     params = dict(list(radius.items()) + list(params.items()))
1197     hapd0 = hostapd.add_ap(apdev[0], params)
1198     params = ft_params2_incorrect_rrb_key(ssid=ssid, passphrase=passphrase)
1199     params["ieee80211w"] = "2"
1200     params['wpa_key_mgmt'] = "FT-EAP"
1201     params["ieee8021x"] = "1"
1202     params = dict(list(radius.items()) + list(params.items()))
1203     hapd1 = hostapd.add_ap(apdev[1], params)
1204
1205     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1206               fail_test=True, eap=True)
1207
1208 def test_ap_ft_mismatching_rrb_key_pull_eap(dev, apdev):
1209     """WPA2-EAP-FT AP over DS with mismatching RRB key (pull)"""
1210     ssid = "test-ft"
1211     passphrase="12345678"
1212
1213     radius = hostapd.radius_params()
1214     params = ft_params1(ssid=ssid, passphrase=passphrase)
1215     params["pmk_r1_push"] = "0"
1216     params['wpa_key_mgmt'] = "FT-EAP"
1217     params["ieee8021x"] = "1"
1218     params = dict(list(radius.items()) + list(params.items()))
1219     hapd0 = hostapd.add_ap(apdev[0], params)
1220     params = ft_params2_incorrect_rrb_key(ssid=ssid, passphrase=passphrase)
1221     params["pmk_r1_push"] = "0"
1222     params['wpa_key_mgmt'] = "FT-EAP"
1223     params["ieee8021x"] = "1"
1224     params = dict(list(radius.items()) + list(params.items()))
1225     hapd1 = hostapd.add_ap(apdev[1], params)
1226
1227     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1228               fail_test=True, eap=True)
1229
1230 def test_ap_ft_mismatching_r0kh_id_pull_eap(dev, apdev):
1231     """WPA2-EAP-FT AP over DS with mismatching R0KH-ID (pull)"""
1232     ssid = "test-ft"
1233     passphrase="12345678"
1234
1235     radius = hostapd.radius_params()
1236     params = ft_params1(ssid=ssid, passphrase=passphrase)
1237     params["pmk_r1_push"] = "0"
1238     params["nas_identifier"] = "nas0.w1.fi"
1239     params['wpa_key_mgmt'] = "FT-EAP"
1240     params["ieee8021x"] = "1"
1241     params = dict(list(radius.items()) + list(params.items()))
1242     hostapd.add_ap(apdev[0], params)
1243     dev[0].connect(ssid, key_mgmt="FT-EAP", proto="WPA2", ieee80211w="1",
1244                    eap="GPSK", identity="gpsk user",
1245                    password="abcdefghijklmnop0123456789abcdef",
1246                    scan_freq="2412")
1247
1248     params = ft_params2(ssid=ssid, passphrase=passphrase)
1249     params["pmk_r1_push"] = "0"
1250     params['wpa_key_mgmt'] = "FT-EAP"
1251     params["ieee8021x"] = "1"
1252     params = dict(list(radius.items()) + list(params.items()))
1253     hostapd.add_ap(apdev[1], params)
1254
1255     dev[0].scan_for_bss(apdev[1]['bssid'], freq="2412")
1256     dev[0].roam_over_ds(apdev[1]['bssid'], fail_test=True)
1257
1258 def test_ap_ft_mismatching_rrb_r0kh_push_eap(dev, apdev):
1259     """WPA2-EAP-FT AP over DS with mismatching R0KH key (push)"""
1260     ssid = "test-ft"
1261     passphrase="12345678"
1262
1263     radius = hostapd.radius_params()
1264     params = ft_params1(ssid=ssid, passphrase=passphrase)
1265     params["ieee80211w"] = "2"
1266     params['wpa_key_mgmt'] = "FT-EAP"
1267     params["ieee8021x"] = "1"
1268     params = dict(list(radius.items()) + list(params.items()))
1269     hapd0 = hostapd.add_ap(apdev[0], params)
1270     params = ft_params2_r0kh_mismatch(ssid=ssid, passphrase=passphrase)
1271     params["ieee80211w"] = "2"
1272     params['wpa_key_mgmt'] = "FT-EAP"
1273     params["ieee8021x"] = "1"
1274     params = dict(list(radius.items()) + list(params.items()))
1275     hapd1 = hostapd.add_ap(apdev[1], params)
1276
1277     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1278               fail_test=True, eap=True)
1279
1280 def test_ap_ft_mismatching_rrb_r0kh_pull_eap(dev, apdev):
1281     """WPA2-EAP-FT AP over DS with mismatching R0KH key (pull)"""
1282     ssid = "test-ft"
1283     passphrase="12345678"
1284
1285     radius = hostapd.radius_params()
1286     params = ft_params1_r0kh_mismatch(ssid=ssid, passphrase=passphrase)
1287     params["pmk_r1_push"] = "0"
1288     params['wpa_key_mgmt'] = "FT-EAP"
1289     params["ieee8021x"] = "1"
1290     params = dict(list(radius.items()) + list(params.items()))
1291     hapd0 = hostapd.add_ap(apdev[0], params)
1292     params = ft_params2(ssid=ssid, passphrase=passphrase)
1293     params["pmk_r1_push"] = "0"
1294     params['wpa_key_mgmt'] = "FT-EAP"
1295     params["ieee8021x"] = "1"
1296     params = dict(list(radius.items()) + list(params.items()))
1297     hapd1 = hostapd.add_ap(apdev[1], params)
1298
1299     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
1300               fail_test=True, eap=True)
1301
1302 def test_ap_ft_gtk_rekey(dev, apdev):
1303     """WPA2-PSK-FT AP and GTK rekey"""
1304     ssid = "test-ft"
1305     passphrase="12345678"
1306
1307     params = ft_params1(ssid=ssid, passphrase=passphrase)
1308     params['wpa_group_rekey'] = '1'
1309     hapd = hostapd.add_ap(apdev[0], params)
1310
1311     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1312                    ieee80211w="1", scan_freq="2412")
1313
1314     ev = dev[0].wait_event(["WPA: Group rekeying completed"], timeout=2)
1315     if ev is None:
1316         raise Exception("GTK rekey timed out after initial association")
1317     hwsim_utils.test_connectivity(dev[0], hapd)
1318
1319     params = ft_params2(ssid=ssid, passphrase=passphrase)
1320     params['wpa_group_rekey'] = '1'
1321     hapd1 = hostapd.add_ap(apdev[1], params)
1322
1323     dev[0].scan_for_bss(apdev[1]['bssid'], freq="2412")
1324     dev[0].roam(apdev[1]['bssid'])
1325     if dev[0].get_status_field('bssid') != apdev[1]['bssid']:
1326         raise Exception("Did not connect to correct AP")
1327     hwsim_utils.test_connectivity(dev[0], hapd1)
1328
1329     ev = dev[0].wait_event(["WPA: Group rekeying completed"], timeout=2)
1330     if ev is None:
1331         raise Exception("GTK rekey timed out after FT protocol")
1332     hwsim_utils.test_connectivity(dev[0], hapd1)
1333
1334 def test_ft_psk_key_lifetime_in_memory(dev, apdev, params):
1335     """WPA2-PSK-FT and key lifetime in memory"""
1336     ssid = "test-ft"
1337     passphrase="04c2726b4b8d5f1b4db9c07aa4d9e9d8f765cb5d25ec817e6cc4fcdd5255db0"
1338     psk = '93c90846ff67af9037ed83fb72b63dbeddaa81d47f926c20909b5886f1d9358d'
1339     pmk = binascii.unhexlify(psk)
1340     p = ft_params1(ssid=ssid, passphrase=passphrase)
1341     hapd0 = hostapd.add_ap(apdev[0], p)
1342     p = ft_params2(ssid=ssid, passphrase=passphrase)
1343     hapd1 = hostapd.add_ap(apdev[1], p)
1344
1345     pid = find_wpas_process(dev[0])
1346
1347     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1348                    scan_freq="2412")
1349     # The decrypted copy of GTK is freed only after the CTRL-EVENT-CONNECTED
1350     # event has been delivered, so verify that wpa_supplicant has returned to
1351     # eloop before reading process memory.
1352     time.sleep(1)
1353     dev[0].ping()
1354
1355     buf = read_process_memory(pid, pmk)
1356
1357     dev[0].request("DISCONNECT")
1358     dev[0].wait_disconnected()
1359
1360     dev[0].relog()
1361     pmkr0 = None
1362     pmkr1 = None
1363     ptk = None
1364     gtk = None
1365     with open(os.path.join(params['logdir'], 'log0'), 'r') as f:
1366         for l in f.readlines():
1367             if "FT: PMK-R0 - hexdump" in l:
1368                 val = l.strip().split(':')[3].replace(' ', '')
1369                 pmkr0 = binascii.unhexlify(val)
1370             if "FT: PMK-R1 - hexdump" in l:
1371                 val = l.strip().split(':')[3].replace(' ', '')
1372                 pmkr1 = binascii.unhexlify(val)
1373             if "FT: KCK - hexdump" in l:
1374                 val = l.strip().split(':')[3].replace(' ', '')
1375                 kck = binascii.unhexlify(val)
1376             if "FT: KEK - hexdump" in l:
1377                 val = l.strip().split(':')[3].replace(' ', '')
1378                 kek = binascii.unhexlify(val)
1379             if "FT: TK - hexdump" in l:
1380                 val = l.strip().split(':')[3].replace(' ', '')
1381                 tk = binascii.unhexlify(val)
1382             if "WPA: Group Key - hexdump" in l:
1383                 val = l.strip().split(':')[3].replace(' ', '')
1384                 gtk = binascii.unhexlify(val)
1385     if not pmkr0 or not pmkr1 or not kck or not kek or not tk or not gtk:
1386         raise Exception("Could not find keys from debug log")
1387     if len(gtk) != 16:
1388         raise Exception("Unexpected GTK length")
1389
1390     logger.info("Checking keys in memory while associated")
1391     get_key_locations(buf, pmk, "PMK")
1392     get_key_locations(buf, pmkr0, "PMK-R0")
1393     get_key_locations(buf, pmkr1, "PMK-R1")
1394     if pmk not in buf:
1395         raise HwsimSkip("PMK not found while associated")
1396     if pmkr0 not in buf:
1397         raise HwsimSkip("PMK-R0 not found while associated")
1398     if pmkr1 not in buf:
1399         raise HwsimSkip("PMK-R1 not found while associated")
1400     if kck not in buf:
1401         raise Exception("KCK not found while associated")
1402     if kek not in buf:
1403         raise Exception("KEK not found while associated")
1404     #if tk in buf:
1405     #    raise Exception("TK found from memory")
1406
1407     logger.info("Checking keys in memory after disassociation")
1408     buf = read_process_memory(pid, pmk)
1409     get_key_locations(buf, pmk, "PMK")
1410     get_key_locations(buf, pmkr0, "PMK-R0")
1411     get_key_locations(buf, pmkr1, "PMK-R1")
1412
1413     # Note: PMK/PSK is still present in network configuration
1414
1415     fname = os.path.join(params['logdir'],
1416                          'ft_psk_key_lifetime_in_memory.memctx-')
1417     verify_not_present(buf, pmkr0, fname, "PMK-R0")
1418     verify_not_present(buf, pmkr1, fname, "PMK-R1")
1419     verify_not_present(buf, kck, fname, "KCK")
1420     verify_not_present(buf, kek, fname, "KEK")
1421     verify_not_present(buf, tk, fname, "TK")
1422     if gtk in buf:
1423         get_key_locations(buf, gtk, "GTK")
1424     verify_not_present(buf, gtk, fname, "GTK")
1425
1426     dev[0].request("REMOVE_NETWORK all")
1427
1428     logger.info("Checking keys in memory after network profile removal")
1429     buf = read_process_memory(pid, pmk)
1430     get_key_locations(buf, pmk, "PMK")
1431     get_key_locations(buf, pmkr0, "PMK-R0")
1432     get_key_locations(buf, pmkr1, "PMK-R1")
1433
1434     verify_not_present(buf, pmk, fname, "PMK")
1435     verify_not_present(buf, pmkr0, fname, "PMK-R0")
1436     verify_not_present(buf, pmkr1, fname, "PMK-R1")
1437     verify_not_present(buf, kck, fname, "KCK")
1438     verify_not_present(buf, kek, fname, "KEK")
1439     verify_not_present(buf, tk, fname, "TK")
1440     verify_not_present(buf, gtk, fname, "GTK")
1441
1442 @remote_compatible
1443 def test_ap_ft_invalid_resp(dev, apdev):
1444     """WPA2-PSK-FT AP and invalid response IEs"""
1445     ssid = "test-ft"
1446     passphrase="12345678"
1447
1448     params = ft_params1(ssid=ssid, passphrase=passphrase)
1449     hapd0 = hostapd.add_ap(apdev[0], params)
1450     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1451                    scan_freq="2412")
1452
1453     params = ft_params2(ssid=ssid, passphrase=passphrase)
1454     hapd1 = hostapd.add_ap(apdev[1], params)
1455
1456     tests = [
1457         # Various IEs for test coverage. The last one is FTIE with invalid
1458         # R1KH-ID subelement.
1459         "020002000000" + "3800" + "38051122334455" + "3754000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010100",
1460         # FTIE with invalid R0KH-ID subelement (len=0).
1461         "020002000000" + "3754000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010300",
1462         # FTIE with invalid R0KH-ID subelement (len=49).
1463         "020002000000" + "378500010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001033101020304050607080910111213141516171819202122232425262728293031323334353637383940414243444546474849",
1464         # Invalid RSNE.
1465         "020002000000" + "3000",
1466         # Required IEs missing from protected IE count.
1467         "020002000000" + "3603a1b201" + "375200010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001" + "3900",
1468         # RIC missing from protected IE count.
1469         "020002000000" + "3603a1b201" + "375200020203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001" + "3900",
1470         # Protected IE missing.
1471         "020002000000" + "3603a1b201" + "375200ff0203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001020304050607080900010203040506070809000102030405060708090001" + "3900" + "0000" ]
1472     for t in tests:
1473         dev[0].scan_for_bss(apdev[1]['bssid'], freq="2412")
1474         hapd1.set("ext_mgmt_frame_handling", "1")
1475         hapd1.dump_monitor()
1476         if "OK" not in dev[0].request("ROAM " + apdev[1]['bssid']):
1477             raise Exception("ROAM failed")
1478         auth = None
1479         for i in range(20):
1480             msg = hapd1.mgmt_rx()
1481             if msg['subtype'] == 11:
1482                 auth = msg
1483                 break
1484         if not auth:
1485             raise Exception("Authentication frame not seen")
1486
1487         resp = {}
1488         resp['fc'] = auth['fc']
1489         resp['da'] = auth['sa']
1490         resp['sa'] = auth['da']
1491         resp['bssid'] = auth['bssid']
1492         resp['payload'] = binascii.unhexlify(t)
1493         hapd1.mgmt_tx(resp)
1494         hapd1.set("ext_mgmt_frame_handling", "0")
1495         dev[0].wait_disconnected()
1496
1497         dev[0].request("RECONNECT")
1498         dev[0].wait_connected()
1499
1500 def test_ap_ft_gcmp_256(dev, apdev):
1501     """WPA2-PSK-FT AP with GCMP-256 cipher"""
1502     if "GCMP-256" not in dev[0].get_capability("pairwise"):
1503         raise HwsimSkip("Cipher GCMP-256 not supported")
1504     ssid = "test-ft"
1505     passphrase="12345678"
1506
1507     params = ft_params1(ssid=ssid, passphrase=passphrase)
1508     params['rsn_pairwise'] = "GCMP-256"
1509     hapd0 = hostapd.add_ap(apdev[0], params)
1510     params = ft_params2(ssid=ssid, passphrase=passphrase)
1511     params['rsn_pairwise'] = "GCMP-256"
1512     hapd1 = hostapd.add_ap(apdev[1], params)
1513
1514     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase,
1515               pairwise_cipher="GCMP-256", group_cipher="GCMP-256")
1516
1517 def setup_ap_ft_oom(dev, apdev):
1518     skip_with_fips(dev[0])
1519     ssid = "test-ft"
1520     passphrase="12345678"
1521
1522     params = ft_params1(ssid=ssid, passphrase=passphrase)
1523     hapd0 = hostapd.add_ap(apdev[0], params)
1524     params = ft_params2(ssid=ssid, passphrase=passphrase)
1525     hapd1 = hostapd.add_ap(apdev[1], params)
1526
1527     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1528                    scan_freq="2412")
1529     if dev[0].get_status_field('bssid') == apdev[0]['bssid']:
1530         dst = apdev[1]['bssid']
1531     else:
1532         dst = apdev[0]['bssid']
1533
1534     dev[0].scan_for_bss(dst, freq="2412")
1535
1536     return dst
1537
1538 def test_ap_ft_oom(dev, apdev):
1539     """WPA2-PSK-FT and OOM"""
1540     dst = setup_ap_ft_oom(dev, apdev)
1541     with alloc_fail(dev[0], 1, "wpa_ft_gen_req_ies"):
1542         dev[0].roam(dst)
1543
1544 def test_ap_ft_oom2(dev, apdev):
1545     """WPA2-PSK-FT and OOM (2)"""
1546     dst = setup_ap_ft_oom(dev, apdev)
1547     with fail_test(dev[0], 1, "wpa_ft_mic"):
1548         dev[0].roam(dst, fail_test=True, assoc_reject_ok=True)
1549
1550 def test_ap_ft_oom3(dev, apdev):
1551     """WPA2-PSK-FT and OOM (3)"""
1552     dst = setup_ap_ft_oom(dev, apdev)
1553     with fail_test(dev[0], 1, "os_get_random;wpa_ft_prepare_auth_request"):
1554         dev[0].roam(dst)
1555
1556 def test_ap_ft_oom4(dev, apdev):
1557     """WPA2-PSK-FT and OOM (4)"""
1558     ssid = "test-ft"
1559     passphrase="12345678"
1560     dst = setup_ap_ft_oom(dev, apdev)
1561     dev[0].request("REMOVE_NETWORK all")
1562     with alloc_fail(dev[0], 1, "=sme_update_ft_ies"):
1563         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1564                        scan_freq="2412")
1565
1566 def test_ap_ft_ap_oom(dev, apdev):
1567     """WPA2-PSK-FT and AP OOM"""
1568     ssid = "test-ft"
1569     passphrase="12345678"
1570
1571     params = ft_params1(ssid=ssid, passphrase=passphrase)
1572     hapd0 = hostapd.add_ap(apdev[0], params)
1573     bssid0 = hapd0.own_addr()
1574
1575     dev[0].scan_for_bss(bssid0, freq="2412")
1576     with alloc_fail(hapd0, 1, "wpa_ft_store_pmk_r0"):
1577         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1578                        scan_freq="2412")
1579
1580     params = ft_params2(ssid=ssid, passphrase=passphrase)
1581     hapd1 = hostapd.add_ap(apdev[1], params)
1582     bssid1 = hapd1.own_addr()
1583     dev[0].scan_for_bss(bssid1, freq="2412")
1584     # This roam will fail due to missing PMK-R0 (OOM prevented storing it)
1585     dev[0].roam(bssid1)
1586
1587 def test_ap_ft_ap_oom2(dev, apdev):
1588     """WPA2-PSK-FT and AP OOM 2"""
1589     ssid = "test-ft"
1590     passphrase="12345678"
1591
1592     params = ft_params1(ssid=ssid, passphrase=passphrase)
1593     hapd0 = hostapd.add_ap(apdev[0], params)
1594     bssid0 = hapd0.own_addr()
1595
1596     dev[0].scan_for_bss(bssid0, freq="2412")
1597     with alloc_fail(hapd0, 1, "wpa_ft_store_pmk_r1"):
1598         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1599                        scan_freq="2412")
1600
1601     params = ft_params2(ssid=ssid, passphrase=passphrase)
1602     hapd1 = hostapd.add_ap(apdev[1], params)
1603     bssid1 = hapd1.own_addr()
1604     dev[0].scan_for_bss(bssid1, freq="2412")
1605     dev[0].roam(bssid1)
1606     if dev[0].get_status_field('bssid') != bssid1:
1607         raise Exception("Did not roam to AP1")
1608     # This roam will fail due to missing PMK-R1 (OOM prevented storing it)
1609     dev[0].roam(bssid0)
1610
1611 def test_ap_ft_ap_oom3(dev, apdev):
1612     """WPA2-PSK-FT and AP OOM 3"""
1613     ssid = "test-ft"
1614     passphrase="12345678"
1615
1616     params = ft_params1(ssid=ssid, passphrase=passphrase)
1617     hapd0 = hostapd.add_ap(apdev[0], params)
1618     bssid0 = hapd0.own_addr()
1619
1620     dev[0].scan_for_bss(bssid0, freq="2412")
1621     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1622                    scan_freq="2412")
1623
1624     params = ft_params2(ssid=ssid, passphrase=passphrase)
1625     hapd1 = hostapd.add_ap(apdev[1], params)
1626     bssid1 = hapd1.own_addr()
1627     dev[0].scan_for_bss(bssid1, freq="2412")
1628     with alloc_fail(hapd1, 1, "wpa_ft_pull_pmk_r1"):
1629         # This will fail due to not being able to send out PMK-R1 pull request
1630         dev[0].roam(bssid1)
1631
1632     with fail_test(hapd1, 2, "os_get_random;wpa_ft_pull_pmk_r1"):
1633         # This will fail due to not being able to send out PMK-R1 pull request
1634         dev[0].roam(bssid1)
1635
1636     with fail_test(hapd1, 2, "aes_siv_encrypt;wpa_ft_pull_pmk_r1"):
1637         # This will fail due to not being able to send out PMK-R1 pull request
1638         dev[0].roam(bssid1)
1639
1640 def test_ap_ft_ap_oom3b(dev, apdev):
1641     """WPA2-PSK-FT and AP OOM 3b"""
1642     ssid = "test-ft"
1643     passphrase="12345678"
1644
1645     params = ft_params1(ssid=ssid, passphrase=passphrase)
1646     hapd0 = hostapd.add_ap(apdev[0], params)
1647     bssid0 = hapd0.own_addr()
1648
1649     dev[0].scan_for_bss(bssid0, freq="2412")
1650     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1651                    scan_freq="2412")
1652
1653     params = ft_params2(ssid=ssid, passphrase=passphrase)
1654     hapd1 = hostapd.add_ap(apdev[1], params)
1655     bssid1 = hapd1.own_addr()
1656     dev[0].scan_for_bss(bssid1, freq="2412")
1657     with fail_test(hapd1, 1, "os_get_random;wpa_ft_pull_pmk_r1"):
1658         # This will fail due to not being able to send out PMK-R1 pull request
1659         dev[0].roam(bssid1)
1660
1661 def test_ap_ft_ap_oom4(dev, apdev):
1662     """WPA2-PSK-FT and AP OOM 4"""
1663     ssid = "test-ft"
1664     passphrase="12345678"
1665
1666     params = ft_params1(ssid=ssid, passphrase=passphrase)
1667     hapd0 = hostapd.add_ap(apdev[0], params)
1668     bssid0 = hapd0.own_addr()
1669
1670     dev[0].scan_for_bss(bssid0, freq="2412")
1671     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1672                    scan_freq="2412")
1673
1674     params = ft_params2(ssid=ssid, passphrase=passphrase)
1675     hapd1 = hostapd.add_ap(apdev[1], params)
1676     bssid1 = hapd1.own_addr()
1677     dev[0].scan_for_bss(bssid1, freq="2412")
1678     with alloc_fail(hapd1, 1, "wpa_ft_gtk_subelem"):
1679         dev[0].roam(bssid1)
1680         if dev[0].get_status_field('bssid') != bssid1:
1681             raise Exception("Did not roam to AP1")
1682
1683     with fail_test(hapd0, 1, "wpa_auth_get_seqnum;wpa_ft_gtk_subelem"):
1684         dev[0].roam(bssid0)
1685         if dev[0].get_status_field('bssid') != bssid0:
1686             raise Exception("Did not roam to AP0")
1687
1688     with fail_test(hapd0, 1, "aes_wrap;wpa_ft_gtk_subelem"):
1689         dev[0].roam(bssid1)
1690         if dev[0].get_status_field('bssid') != bssid1:
1691             raise Exception("Did not roam to AP1")
1692
1693 def test_ap_ft_ap_oom5(dev, apdev):
1694     """WPA2-PSK-FT and AP OOM 5"""
1695     ssid = "test-ft"
1696     passphrase="12345678"
1697
1698     params = ft_params1(ssid=ssid, passphrase=passphrase)
1699     hapd0 = hostapd.add_ap(apdev[0], params)
1700     bssid0 = hapd0.own_addr()
1701
1702     dev[0].scan_for_bss(bssid0, freq="2412")
1703     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1704                    scan_freq="2412")
1705
1706     params = ft_params2(ssid=ssid, passphrase=passphrase)
1707     hapd1 = hostapd.add_ap(apdev[1], params)
1708     bssid1 = hapd1.own_addr()
1709     dev[0].scan_for_bss(bssid1, freq="2412")
1710     with alloc_fail(hapd1, 1, "=wpa_ft_process_auth_req"):
1711         # This will fail to roam
1712         dev[0].roam(bssid1)
1713
1714     with fail_test(hapd1, 1, "os_get_random;wpa_ft_process_auth_req"):
1715         # This will fail to roam
1716         dev[0].roam(bssid1)
1717
1718     with fail_test(hapd1, 1, "sha256_prf_bits;wpa_pmk_r1_to_ptk;wpa_ft_process_auth_req"):
1719         # This will fail to roam
1720         dev[0].roam(bssid1)
1721
1722     with fail_test(hapd1, 3, "wpa_pmk_r1_to_ptk;wpa_ft_process_auth_req"):
1723         # This will fail to roam
1724         dev[0].roam(bssid1)
1725
1726     with fail_test(hapd1, 1, "wpa_derive_pmk_r1_name;wpa_ft_process_auth_req"):
1727         # This will fail to roam
1728         dev[0].roam(bssid1)
1729
1730 def test_ap_ft_ap_oom6(dev, apdev):
1731     """WPA2-PSK-FT and AP OOM 6"""
1732     ssid = "test-ft"
1733     passphrase="12345678"
1734
1735     params = ft_params1(ssid=ssid, passphrase=passphrase)
1736     hapd0 = hostapd.add_ap(apdev[0], params)
1737     bssid0 = hapd0.own_addr()
1738
1739     dev[0].scan_for_bss(bssid0, freq="2412")
1740     with fail_test(hapd0, 1, "wpa_derive_pmk_r0;wpa_auth_derive_ptk_ft"):
1741         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1742                        scan_freq="2412")
1743     dev[0].request("REMOVE_NETWORK all")
1744     dev[0].wait_disconnected()
1745     with fail_test(hapd0, 1, "wpa_derive_pmk_r1;wpa_auth_derive_ptk_ft"):
1746         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1747                        scan_freq="2412")
1748     dev[0].request("REMOVE_NETWORK all")
1749     dev[0].wait_disconnected()
1750     with fail_test(hapd0, 1, "wpa_pmk_r1_to_ptk;wpa_auth_derive_ptk_ft"):
1751         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1752                        scan_freq="2412")
1753
1754 def test_ap_ft_ap_oom7a(dev, apdev):
1755     """WPA2-PSK-FT and AP OOM 7a"""
1756     ssid = "test-ft"
1757     passphrase="12345678"
1758
1759     params = ft_params1(ssid=ssid, passphrase=passphrase)
1760     params["ieee80211w"] = "2"
1761     hapd0 = hostapd.add_ap(apdev[0], params)
1762     bssid0 = hapd0.own_addr()
1763
1764     dev[0].scan_for_bss(bssid0, freq="2412")
1765     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1766                    ieee80211w="2", scan_freq="2412")
1767
1768     params = ft_params2(ssid=ssid, passphrase=passphrase)
1769     params["ieee80211w"] = "2"
1770     hapd1 = hostapd.add_ap(apdev[1], params)
1771     bssid1 = hapd1.own_addr()
1772     dev[0].scan_for_bss(bssid1, freq="2412")
1773     with alloc_fail(hapd1, 1, "wpa_ft_igtk_subelem"):
1774         # This will fail to roam
1775         dev[0].roam(bssid1)
1776
1777 def test_ap_ft_ap_oom7b(dev, apdev):
1778     """WPA2-PSK-FT and AP OOM 7b"""
1779     ssid = "test-ft"
1780     passphrase="12345678"
1781
1782     params = ft_params1(ssid=ssid, passphrase=passphrase)
1783     params["ieee80211w"] = "2"
1784     hapd0 = hostapd.add_ap(apdev[0], params)
1785     bssid0 = hapd0.own_addr()
1786
1787     dev[0].scan_for_bss(bssid0, freq="2412")
1788     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1789                    ieee80211w="2", scan_freq="2412")
1790
1791     params = ft_params2(ssid=ssid, passphrase=passphrase)
1792     params["ieee80211w"] = "2"
1793     hapd1 = hostapd.add_ap(apdev[1], params)
1794     bssid1 = hapd1.own_addr()
1795     dev[0].scan_for_bss(bssid1, freq="2412")
1796     with fail_test(hapd1, 1, "aes_wrap;wpa_ft_igtk_subelem"):
1797         # This will fail to roam
1798         dev[0].roam(bssid1)
1799
1800 def test_ap_ft_ap_oom7c(dev, apdev):
1801     """WPA2-PSK-FT and AP OOM 7c"""
1802     ssid = "test-ft"
1803     passphrase="12345678"
1804
1805     params = ft_params1(ssid=ssid, passphrase=passphrase)
1806     params["ieee80211w"] = "2"
1807     hapd0 = hostapd.add_ap(apdev[0], params)
1808     bssid0 = hapd0.own_addr()
1809
1810     dev[0].scan_for_bss(bssid0, freq="2412")
1811     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1812                    ieee80211w="2", scan_freq="2412")
1813
1814     params = ft_params2(ssid=ssid, passphrase=passphrase)
1815     params["ieee80211w"] = "2"
1816     hapd1 = hostapd.add_ap(apdev[1], params)
1817     bssid1 = hapd1.own_addr()
1818     dev[0].scan_for_bss(bssid1, freq="2412")
1819     with alloc_fail(hapd1, 1, "=wpa_sm_write_assoc_resp_ies"):
1820         # This will fail to roam
1821         dev[0].roam(bssid1)
1822
1823 def test_ap_ft_ap_oom7d(dev, apdev):
1824     """WPA2-PSK-FT and AP OOM 7d"""
1825     ssid = "test-ft"
1826     passphrase="12345678"
1827
1828     params = ft_params1(ssid=ssid, passphrase=passphrase)
1829     params["ieee80211w"] = "2"
1830     hapd0 = hostapd.add_ap(apdev[0], params)
1831     bssid0 = hapd0.own_addr()
1832
1833     dev[0].scan_for_bss(bssid0, freq="2412")
1834     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1835                    ieee80211w="2", scan_freq="2412")
1836
1837     params = ft_params2(ssid=ssid, passphrase=passphrase)
1838     params["ieee80211w"] = "2"
1839     hapd1 = hostapd.add_ap(apdev[1], params)
1840     bssid1 = hapd1.own_addr()
1841     dev[0].scan_for_bss(bssid1, freq="2412")
1842     with fail_test(hapd1, 1, "wpa_ft_mic;wpa_sm_write_assoc_resp_ies"):
1843         # This will fail to roam
1844         dev[0].roam(bssid1)
1845
1846 def test_ap_ft_ap_oom8(dev, apdev):
1847     """WPA2-PSK-FT and AP OOM 8"""
1848     ssid = "test-ft"
1849     passphrase="12345678"
1850
1851     params = ft_params1(ssid=ssid, passphrase=passphrase)
1852     params['ft_psk_generate_local'] = "1"
1853     hapd0 = hostapd.add_ap(apdev[0], params)
1854     bssid0 = hapd0.own_addr()
1855
1856     dev[0].scan_for_bss(bssid0, freq="2412")
1857     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1858                    scan_freq="2412")
1859
1860     params = ft_params2(ssid=ssid, passphrase=passphrase)
1861     params['ft_psk_generate_local'] = "1"
1862     hapd1 = hostapd.add_ap(apdev[1], params)
1863     bssid1 = hapd1.own_addr()
1864     dev[0].scan_for_bss(bssid1, freq="2412")
1865     with fail_test(hapd1, 1, "wpa_derive_pmk_r0;wpa_ft_psk_pmk_r1"):
1866         # This will fail to roam
1867         dev[0].roam(bssid1)
1868     with fail_test(hapd1, 1, "wpa_derive_pmk_r1;wpa_ft_psk_pmk_r1"):
1869         # This will fail to roam
1870         dev[0].roam(bssid1)
1871
1872 def test_ap_ft_ap_oom9(dev, apdev):
1873     """WPA2-PSK-FT and AP OOM 9"""
1874     ssid = "test-ft"
1875     passphrase="12345678"
1876
1877     params = ft_params1(ssid=ssid, passphrase=passphrase)
1878     hapd0 = hostapd.add_ap(apdev[0], params)
1879     bssid0 = hapd0.own_addr()
1880
1881     dev[0].scan_for_bss(bssid0, freq="2412")
1882     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1883                    scan_freq="2412")
1884
1885     params = ft_params2(ssid=ssid, passphrase=passphrase)
1886     hapd1 = hostapd.add_ap(apdev[1], params)
1887     bssid1 = hapd1.own_addr()
1888     dev[0].scan_for_bss(bssid1, freq="2412")
1889
1890     with alloc_fail(hapd0, 1, "wpa_ft_action_rx"):
1891         # This will fail to roam
1892         if "OK" not in dev[0].request("FT_DS " + bssid1):
1893             raise Exception("FT_DS failed")
1894         wait_fail_trigger(hapd0, "GET_ALLOC_FAIL")
1895
1896     with alloc_fail(hapd1, 1, "wpa_ft_rrb_rx_request"):
1897         # This will fail to roam
1898         if "OK" not in dev[0].request("FT_DS " + bssid1):
1899             raise Exception("FT_DS failed")
1900         wait_fail_trigger(hapd1, "GET_ALLOC_FAIL")
1901
1902     with alloc_fail(hapd1, 1, "wpa_ft_send_rrb_auth_resp"):
1903         # This will fail to roam
1904         if "OK" not in dev[0].request("FT_DS " + bssid1):
1905             raise Exception("FT_DS failed")
1906         wait_fail_trigger(hapd1, "GET_ALLOC_FAIL")
1907
1908 def test_ap_ft_ap_oom10(dev, apdev):
1909     """WPA2-PSK-FT and AP OOM 10"""
1910     ssid = "test-ft"
1911     passphrase="12345678"
1912
1913     params = ft_params1(ssid=ssid, passphrase=passphrase)
1914     hapd0 = hostapd.add_ap(apdev[0], params)
1915     bssid0 = hapd0.own_addr()
1916
1917     dev[0].scan_for_bss(bssid0, freq="2412")
1918     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1919                    scan_freq="2412")
1920
1921     params = ft_params2(ssid=ssid, passphrase=passphrase)
1922     hapd1 = hostapd.add_ap(apdev[1], params)
1923     bssid1 = hapd1.own_addr()
1924     dev[0].scan_for_bss(bssid1, freq="2412")
1925
1926     with fail_test(hapd0, 1, "aes_siv_decrypt;wpa_ft_rrb_rx_pull"):
1927         # This will fail to roam
1928         if "OK" not in dev[0].request("FT_DS " + bssid1):
1929             raise Exception("FT_DS failed")
1930         wait_fail_trigger(hapd0, "GET_FAIL")
1931
1932     with fail_test(hapd0, 1, "wpa_derive_pmk_r1;wpa_ft_rrb_rx_pull"):
1933         # This will fail to roam
1934         if "OK" not in dev[0].request("FT_DS " + bssid1):
1935             raise Exception("FT_DS failed")
1936         wait_fail_trigger(hapd0, "GET_FAIL")
1937
1938     with fail_test(hapd0, 1, "aes_siv_encrypt;wpa_ft_rrb_rx_pull"):
1939         # This will fail to roam
1940         if "OK" not in dev[0].request("FT_DS " + bssid1):
1941             raise Exception("FT_DS failed")
1942         wait_fail_trigger(hapd0, "GET_FAIL")
1943
1944     with fail_test(hapd1, 1, "aes_siv_decrypt;wpa_ft_rrb_rx_resp"):
1945         # This will fail to roam
1946         if "OK" not in dev[0].request("FT_DS " + bssid1):
1947             raise Exception("FT_DS failed")
1948         wait_fail_trigger(hapd1, "GET_FAIL")
1949
1950 def test_ap_ft_ap_oom11(dev, apdev):
1951     """WPA2-PSK-FT and AP OOM 11"""
1952     ssid = "test-ft"
1953     passphrase="12345678"
1954
1955     params = ft_params1(ssid=ssid, passphrase=passphrase)
1956     hapd0 = hostapd.add_ap(apdev[0], params)
1957     bssid0 = hapd0.own_addr()
1958
1959     dev[0].scan_for_bss(bssid0, freq="2412")
1960     with fail_test(hapd0, 1, "wpa_derive_pmk_r1;wpa_ft_generate_pmk_r1"):
1961         dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1962                        scan_freq="2412")
1963         wait_fail_trigger(hapd0, "GET_FAIL")
1964
1965     dev[1].scan_for_bss(bssid0, freq="2412")
1966     with fail_test(hapd0, 1, "aes_siv_encrypt;wpa_ft_generate_pmk_r1"):
1967         dev[1].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1968                        scan_freq="2412")
1969         wait_fail_trigger(hapd0, "GET_FAIL")
1970
1971 def test_ap_ft_over_ds_proto_ap(dev, apdev):
1972     """WPA2-PSK-FT AP over DS protocol testing for AP processing"""
1973     ssid = "test-ft"
1974     passphrase="12345678"
1975
1976     params = ft_params1(ssid=ssid, passphrase=passphrase)
1977     hapd0 = hostapd.add_ap(apdev[0], params)
1978     bssid0 = hapd0.own_addr()
1979     _bssid0 = bssid0.replace(':', '')
1980     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
1981                    scan_freq="2412")
1982     addr = dev[0].own_addr()
1983     _addr = addr.replace(':', '')
1984
1985     params = ft_params2(ssid=ssid, passphrase=passphrase)
1986     hapd1 = hostapd.add_ap(apdev[1], params)
1987     bssid1 = hapd1.own_addr()
1988     _bssid1 = bssid1.replace(':', '')
1989
1990     hapd0.set("ext_mgmt_frame_handling", "1")
1991     hdr = "d0003a01" + _bssid0 + _addr + _bssid0 + "1000"
1992     valid = "0601" + _addr + _bssid1
1993     tests = [ "0601",
1994               "0601" + _addr,
1995               "0601" + _addr + _bssid0,
1996               "0601" + _addr + "ffffffffffff",
1997               "0601" + _bssid0 + _bssid0,
1998               valid,
1999               valid + "01",
2000               valid + "3700",
2001               valid + "3600",
2002               valid + "3603ffffff",
2003               valid + "3603a1b2ff",
2004               valid + "3603a1b2ff" + "3700",
2005               valid + "3603a1b2ff" + "37520000" + 16*"00" + 32*"00" + 32*"00",
2006               valid + "3603a1b2ff" + "37520001" + 16*"00" + 32*"00" + 32*"00",
2007               valid + "3603a1b2ff" + "37550000" + 16*"00" + 32*"00" + 32*"00" + "0301aa",
2008               valid + "3603a1b2ff" + "37550000" + 16*"00" + 32*"00" + 32*"00" + "0301aa" + "3000",
2009               valid + "3603a1b2ff" + "37550000" + 16*"00" + 32*"00" + 32*"00" + "0301aa" + "30260100000fac040100000fac040100000facff00000100a225368fe0983b5828a37a0acb37f253",
2010               valid + "3603a1b2ff" + "37550000" + 16*"00" + 32*"00" + 32*"00" + "0301aa" + "30260100000fac040100000fac030100000fac0400000100a225368fe0983b5828a37a0acb37f253",
2011               valid + "3603a1b2ff" + "37550000" + 16*"00" + 32*"00" + 32*"00" + "0301aa" + "30260100000fac040100000fac040100000fac0400000100a225368fe0983b5828a37a0acb37f253",
2012               valid + "0001" ]
2013     for t in tests:
2014         hapd0.dump_monitor()
2015         if "OK" not in hapd0.request("MGMT_RX_PROCESS freq=2412 datarate=0 ssi_signal=-30 frame=" + hdr + t):
2016             raise Exception("MGMT_RX_PROCESS failed")
2017
2018     hapd0.set("ext_mgmt_frame_handling", "0")
2019
2020 def test_ap_ft_over_ds_proto(dev, apdev):
2021     """WPA2-PSK-FT AP over DS protocol testing"""
2022     ssid = "test-ft"
2023     passphrase="12345678"
2024
2025     params = ft_params1(ssid=ssid, passphrase=passphrase)
2026     hapd0 = hostapd.add_ap(apdev[0], params)
2027     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2028                    scan_freq="2412")
2029
2030     # FT Action Response while no FT-over-DS in progress
2031     msg = {}
2032     msg['fc'] = 13 << 4
2033     msg['da'] = dev[0].own_addr()
2034     msg['sa'] = apdev[0]['bssid']
2035     msg['bssid'] = apdev[0]['bssid']
2036     msg['payload'] = binascii.unhexlify("06020200000000000200000004000000")
2037     hapd0.mgmt_tx(msg)
2038
2039     params = ft_params2(ssid=ssid, passphrase=passphrase)
2040     hapd1 = hostapd.add_ap(apdev[1], params)
2041     dev[0].scan_for_bss(apdev[1]['bssid'], freq="2412")
2042     hapd0.set("ext_mgmt_frame_handling", "1")
2043     hapd0.dump_monitor()
2044     dev[0].request("FT_DS " + apdev[1]['bssid'])
2045     for i in range(0, 10):
2046         req = hapd0.mgmt_rx()
2047         if req is None:
2048             raise Exception("MGMT RX wait timed out")
2049         if req['subtype'] == 13:
2050             break
2051         req = None
2052     if not req:
2053         raise Exception("FT Action frame not received")
2054
2055     # FT Action Response for unexpected Target AP
2056     msg['payload'] = binascii.unhexlify("0602020000000000" + "f20000000400" + "0000")
2057     hapd0.mgmt_tx(msg)
2058
2059     # FT Action Response without MDIE
2060     msg['payload'] = binascii.unhexlify("0602020000000000" + "020000000400" + "0000")
2061     hapd0.mgmt_tx(msg)
2062
2063     # FT Action Response without FTIE
2064     msg['payload'] = binascii.unhexlify("0602020000000000" + "020000000400" + "0000" + "3603a1b201")
2065     hapd0.mgmt_tx(msg)
2066
2067     # FT Action Response with FTIE SNonce mismatch
2068     msg['payload'] = binascii.unhexlify("0602020000000000" + "020000000400" + "0000" + "3603a1b201" + "3766000000000000000000000000000000000000c4e67ac1999bebd00ff4ae4d5dcaf87896bb060b469f7c78d49623fb395c3455ffffff6b693fe6f8d8c5dfac0a22344750775bd09437f98b238c9f87b97f790c0106000102030406030a6e6173312e77312e6669")
2069     hapd0.mgmt_tx(msg)
2070
2071 @remote_compatible
2072 def test_ap_ft_rrb(dev, apdev):
2073     """WPA2-PSK-FT RRB protocol testing"""
2074     ssid = "test-ft"
2075     passphrase="12345678"
2076
2077     params = ft_params1(ssid=ssid, passphrase=passphrase)
2078     hapd0 = hostapd.add_ap(apdev[0], params)
2079
2080     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2081                    scan_freq="2412")
2082
2083     _dst_ll = binascii.unhexlify(apdev[0]['bssid'].replace(':',''))
2084     _src_ll = binascii.unhexlify(dev[0].own_addr().replace(':',''))
2085     proto = b'\x89\x0d'
2086     ehdr = _dst_ll + _src_ll + proto
2087
2088     # Too short RRB frame
2089     pkt = ehdr + b'\x01'
2090     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2091         raise Exception("DATA_TEST_FRAME failed")
2092
2093     # RRB discarded frame wikth unrecognized type
2094     pkt = ehdr + b'\x02' + b'\x02' + b'\x01\x00' + _src_ll
2095     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2096         raise Exception("DATA_TEST_FRAME failed")
2097
2098     # RRB frame too short for action frame
2099     pkt = ehdr + b'\x01' + b'\x02' + b'\x01\x00' + _src_ll
2100     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2101         raise Exception("DATA_TEST_FRAME failed")
2102
2103     # Too short RRB frame (not enough room for Action Frame body)
2104     pkt = ehdr + b'\x01' + b'\x02' + b'\x00\x00' + _src_ll
2105     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2106         raise Exception("DATA_TEST_FRAME failed")
2107
2108     # Unexpected Action frame category
2109     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'
2110     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2111         raise Exception("DATA_TEST_FRAME failed")
2112
2113     # Unexpected Action in RRB Request
2114     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'
2115     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2116         raise Exception("DATA_TEST_FRAME failed")
2117
2118     # Target AP address in RRB Request does not match with own address
2119     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'
2120     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2121         raise Exception("DATA_TEST_FRAME failed")
2122
2123     # Not enough room for status code in RRB Response
2124     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'
2125     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2126         raise Exception("DATA_TEST_FRAME failed")
2127
2128     # RRB discarded frame with unknown packet_type
2129     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'
2130     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2131         raise Exception("DATA_TEST_FRAME failed")
2132
2133     # RRB Response with non-zero status code; no STA match
2134     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'
2135     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2136         raise Exception("DATA_TEST_FRAME failed")
2137
2138     # RRB Response with zero status code and extra data; STA match
2139     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'
2140     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2141         raise Exception("DATA_TEST_FRAME failed")
2142
2143     # Too short PMK-R1 pull
2144     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'
2145     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2146         raise Exception("DATA_TEST_FRAME failed")
2147
2148     # Too short PMK-R1 resp
2149     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'
2150     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2151         raise Exception("DATA_TEST_FRAME failed")
2152
2153     # Too short PMK-R1 push
2154     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'
2155     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2156         raise Exception("DATA_TEST_FRAME failed")
2157
2158     # No matching R0KH address found for PMK-R0 pull response
2159     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'
2160     if "OK" not in dev[0].request("DATA_TEST_FRAME " + binascii.hexlify(pkt).decode()):
2161         raise Exception("DATA_TEST_FRAME failed")
2162
2163 @remote_compatible
2164 def test_rsn_ie_proto_ft_psk_sta(dev, apdev):
2165     """RSN element protocol testing for FT-PSK + PMF cases on STA side"""
2166     bssid = apdev[0]['bssid']
2167     ssid = "test-ft"
2168     passphrase="12345678"
2169
2170     params = ft_params1(ssid=ssid, passphrase=passphrase)
2171     params["ieee80211w"] = "1"
2172     # This is the RSN element used normally by hostapd
2173     params['own_ie_override'] = '30140100000fac040100000fac040100000fac048c00' + '3603a1b201'
2174     hapd = hostapd.add_ap(apdev[0], params)
2175     id = dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2176                         ieee80211w="1", scan_freq="2412",
2177                         pairwise="CCMP", group="CCMP")
2178
2179     tests = [ ('PMKIDCount field included',
2180                '30160100000fac040100000fac040100000fac048c000000' + '3603a1b201'),
2181               ('Extra IE before RSNE',
2182                'dd0400000000' + '30140100000fac040100000fac040100000fac048c00' + '3603a1b201'),
2183               ('PMKIDCount and Group Management Cipher suite fields included',
2184                '301a0100000fac040100000fac040100000fac048c000000000fac06' + '3603a1b201'),
2185               ('Extra octet after defined fields (future extensibility)',
2186                '301b0100000fac040100000fac040100000fac048c000000000fac0600' + '3603a1b201'),
2187               ('No RSN Capabilities field (PMF disabled in practice)',
2188                '30120100000fac040100000fac040100000fac04' + '3603a1b201') ]
2189     for txt,ie in tests:
2190         dev[0].request("DISCONNECT")
2191         dev[0].wait_disconnected()
2192         logger.info(txt)
2193         hapd.disable()
2194         hapd.set('own_ie_override', ie)
2195         hapd.enable()
2196         dev[0].request("BSS_FLUSH 0")
2197         dev[0].scan_for_bss(bssid, 2412, force_scan=True, only_new=True)
2198         dev[0].select_network(id, freq=2412)
2199         dev[0].wait_connected()
2200
2201     dev[0].request("DISCONNECT")
2202     dev[0].wait_disconnected()
2203
2204     logger.info('Invalid RSNE causing internal hostapd error')
2205     hapd.disable()
2206     hapd.set('own_ie_override', '30130100000fac040100000fac040100000fac048c' + '3603a1b201')
2207     hapd.enable()
2208     dev[0].request("BSS_FLUSH 0")
2209     dev[0].scan_for_bss(bssid, 2412, force_scan=True, only_new=True)
2210     dev[0].select_network(id, freq=2412)
2211     # hostapd fails to generate EAPOL-Key msg 3/4, so this connection cannot
2212     # complete.
2213     ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED"], timeout=1)
2214     if ev is not None:
2215         raise Exception("Unexpected connection")
2216     dev[0].request("DISCONNECT")
2217
2218     logger.info('Unexpected PMKID causing internal hostapd error')
2219     hapd.disable()
2220     hapd.set('own_ie_override', '30260100000fac040100000fac040100000fac048c000100ffffffffffffffffffffffffffffffff' + '3603a1b201')
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     # hostapd fails to generate EAPOL-Key msg 3/4, so this connection cannot
2226     # complete.
2227     ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED"], timeout=1)
2228     if ev is not None:
2229         raise Exception("Unexpected connection")
2230     dev[0].request("DISCONNECT")
2231
2232 def test_ap_ft_ptk_rekey(dev, apdev):
2233     """WPA2-PSK-FT PTK rekeying triggered by station after roam"""
2234     ssid = "test-ft"
2235     passphrase="12345678"
2236
2237     params = ft_params1(ssid=ssid, passphrase=passphrase)
2238     hapd0 = hostapd.add_ap(apdev[0], params)
2239     params = ft_params2(ssid=ssid, passphrase=passphrase)
2240     hapd1 = hostapd.add_ap(apdev[1], params)
2241
2242     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, ptk_rekey="1")
2243
2244     ev = dev[0].wait_event(["CTRL-EVENT-DISCONNECTED",
2245                             "WPA: Key negotiation completed"], timeout=5)
2246     if ev is None:
2247         raise Exception("No event received after roam")
2248     if "CTRL-EVENT-DISCONNECTED" in ev:
2249         raise Exception("Unexpected disconnection after roam")
2250
2251     if dev[0].get_status_field('bssid') == apdev[0]['bssid']:
2252         hapd = hapd0
2253     else:
2254         hapd = hapd1
2255     hwsim_utils.test_connectivity(dev[0], hapd)
2256
2257 def test_ap_ft_ptk_rekey_ap(dev, apdev):
2258     """WPA2-PSK-FT PTK rekeying triggered by AP after roam"""
2259     ssid = "test-ft"
2260     passphrase="12345678"
2261
2262     params = ft_params1(ssid=ssid, passphrase=passphrase)
2263     params['wpa_ptk_rekey'] = '2'
2264     hapd0 = hostapd.add_ap(apdev[0], params)
2265     params = ft_params2(ssid=ssid, passphrase=passphrase)
2266     params['wpa_ptk_rekey'] = '2'
2267     hapd1 = hostapd.add_ap(apdev[1], params)
2268
2269     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase)
2270
2271     ev = dev[0].wait_event(["CTRL-EVENT-DISCONNECTED",
2272                             "WPA: Key negotiation completed"], timeout=5)
2273     if ev is None:
2274         raise Exception("No event received after roam")
2275     if "CTRL-EVENT-DISCONNECTED" in ev:
2276         raise Exception("Unexpected disconnection after roam")
2277
2278     if dev[0].get_status_field('bssid') == apdev[0]['bssid']:
2279         hapd = hapd0
2280     else:
2281         hapd = hapd1
2282     hwsim_utils.test_connectivity(dev[0], hapd)
2283
2284 def test_ap_ft_internal_rrb_check(dev, apdev):
2285     """RRB internal delivery only to WPA enabled BSS"""
2286     ssid = "test-ft"
2287     passphrase="12345678"
2288
2289     radius = hostapd.radius_params()
2290     params = ft_params1(ssid=ssid, passphrase=passphrase)
2291     params['wpa_key_mgmt'] = "FT-EAP"
2292     params["ieee8021x"] = "1"
2293     params = dict(list(radius.items()) + list(params.items()))
2294     hapd = hostapd.add_ap(apdev[0], params)
2295     key_mgmt = hapd.get_config()['key_mgmt']
2296     if key_mgmt.split(' ')[0] != "FT-EAP":
2297         raise Exception("Unexpected GET_CONFIG(key_mgmt): " + key_mgmt)
2298
2299     hapd1 = hostapd.add_ap(apdev[1], { "ssid" : ssid })
2300
2301     # Connect to WPA enabled AP
2302     dev[0].connect(ssid, key_mgmt="FT-EAP", proto="WPA2", ieee80211w="1",
2303                    eap="GPSK", identity="gpsk user",
2304                    password="abcdefghijklmnop0123456789abcdef",
2305                    scan_freq="2412")
2306
2307     # Try over_ds roaming to non-WPA-enabled AP.
2308     # If hostapd does not check hapd->wpa_auth internally, it will crash now.
2309     dev[0].roam_over_ds(apdev[1]['bssid'], fail_test=True)
2310
2311 def test_ap_ft_extra_ie(dev, apdev):
2312     """WPA2-PSK-FT AP with WPA2-PSK enabled and unexpected MDE"""
2313     ssid = "test-ft"
2314     passphrase="12345678"
2315
2316     params = ft_params1(ssid=ssid, passphrase=passphrase)
2317     params["wpa_key_mgmt"] = "WPA-PSK FT-PSK"
2318     hapd0 = hostapd.add_ap(apdev[0], params)
2319     dev[1].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2320                    scan_freq="2412")
2321     dev[2].connect(ssid, psk=passphrase, key_mgmt="WPA-PSK", proto="WPA2",
2322                    scan_freq="2412")
2323     try:
2324         # Add Mobility Domain element to test AP validation code.
2325         dev[0].request("VENDOR_ELEM_ADD 13 3603a1b201")
2326         dev[0].connect(ssid, psk=passphrase, key_mgmt="WPA-PSK", proto="WPA2",
2327                        scan_freq="2412", wait_connect=False)
2328         ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED",
2329                                 "CTRL-EVENT-ASSOC-REJECT"], timeout=10)
2330         if ev is None:
2331             raise Exception("No connection result")
2332         if "CTRL-EVENT-CONNECTED" in ev:
2333             raise Exception("Non-FT association accepted with MDE")
2334         if "status_code=43" not in ev:
2335             raise Exception("Unexpected status code: " + ev)
2336         dev[0].request("DISCONNECT")
2337     finally:
2338         dev[0].request("VENDOR_ELEM_REMOVE 13 *")
2339
2340 def test_ap_ft_ric(dev, apdev):
2341     """WPA2-PSK-FT AP and RIC"""
2342     ssid = "test-ft"
2343     passphrase="12345678"
2344
2345     params = ft_params1(ssid=ssid, passphrase=passphrase)
2346     hapd0 = hostapd.add_ap(apdev[0], params)
2347     params = ft_params2(ssid=ssid, passphrase=passphrase)
2348     hapd1 = hostapd.add_ap(apdev[1], params)
2349
2350     dev[0].set("ric_ies", "")
2351     dev[0].set("ric_ies", '""')
2352     if "FAIL" not in dev[0].request("SET ric_ies q"):
2353         raise Exception("Invalid ric_ies value accepted")
2354
2355     tests = [ "3900",
2356               "3900ff04eeeeeeee",
2357               "390400000000",
2358               "390400000000" + "390400000000",
2359               "390400000000" + "dd050050f20202",
2360               "390400000000" + "dd3d0050f2020201" + 55*"00",
2361               "390400000000" + "dd3d0050f2020201aa300010270000000000000000000000000000000000000000000000000000ffffff7f00000000000000000000000040420f00ffff0000",
2362               "390401010000" + "dd3d0050f2020201aa3000dc050000000000000000000000000000000000000000000000000000dc050000000000000000000000000000808d5b0028230000" ]
2363     for t in tests:
2364         dev[0].set("ric_ies", t)
2365         run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase,
2366                   test_connectivity=False)
2367         dev[0].request("REMOVE_NETWORK all")
2368         dev[0].wait_disconnected()
2369         dev[0].dump_monitor()
2370
2371 def ie_hex(ies, id):
2372     return binascii.hexlify(struct.pack('BB', id, len(ies[id])) + ies[id]).decode()
2373
2374 def test_ap_ft_reassoc_proto(dev, apdev):
2375     """WPA2-PSK-FT AP Reassociation Request frame parsing"""
2376     ssid = "test-ft"
2377     passphrase="12345678"
2378
2379     params = ft_params1(ssid=ssid, passphrase=passphrase)
2380     hapd0 = hostapd.add_ap(apdev[0], params)
2381     params = ft_params2(ssid=ssid, passphrase=passphrase)
2382     hapd1 = hostapd.add_ap(apdev[1], params)
2383
2384     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2385                    ieee80211w="1", scan_freq="2412")
2386     if dev[0].get_status_field('bssid') == hapd0.own_addr():
2387         hapd1ap = hapd0
2388         hapd2ap = hapd1
2389     else:
2390         hapd1ap = hapd1
2391         hapd2ap = hapd0
2392
2393     dev[0].scan_for_bss(hapd2ap.own_addr(), freq="2412")
2394     hapd2ap.set("ext_mgmt_frame_handling", "1")
2395     dev[0].request("ROAM " + hapd2ap.own_addr())
2396
2397     while True:
2398         req = hapd2ap.mgmt_rx()
2399         hapd2ap.request("MGMT_RX_PROCESS freq=2412 datarate=0 ssi_signal=-30 frame=" + binascii.hexlify(req['frame']).decode())
2400         if req['subtype'] == 11:
2401             break
2402
2403     while True:
2404         req = hapd2ap.mgmt_rx()
2405         if req['subtype'] == 2:
2406             break
2407         hapd2ap.request("MGMT_RX_PROCESS freq=2412 datarate=0 ssi_signal=-30 frame=" + binascii.hexlify(req['frame']).decode())
2408
2409     # IEEE 802.11 header + fixed fields before IEs
2410     hdr = binascii.hexlify(req['frame'][0:34]).decode()
2411     ies = parse_ie(binascii.hexlify(req['frame'][34:]))
2412     # First elements: SSID, Supported Rates, Extended Supported Rates
2413     ies1 = ie_hex(ies, 0) + ie_hex(ies, 1) + ie_hex(ies, 50)
2414
2415     rsne = ie_hex(ies, 48)
2416     mde = ie_hex(ies, 54)
2417     fte = ie_hex(ies, 55)
2418     tests = [ ]
2419     # RSN: Trying to use FT, but MDIE not included
2420     tests += [ rsne ]
2421     # RSN: Attempted to use unknown MDIE
2422     tests += [ rsne + "3603000000" ]
2423     # Invalid RSN pairwise cipher
2424     tests += [ "30260100000fac040100000fac030100000fac040000010029208a42cd25c85aa571567dce10dae3" ]
2425     # FT: No PMKID in RSNIE
2426     tests += [ "30160100000fac040100000fac040100000fac0400000000" + ie_hex(ies, 54) ]
2427     # FT: Invalid FTIE
2428     tests += [ rsne + mde ]
2429     # FT: RIC IE(s) in the frame, but not included in protected IE count
2430     # FT: Failed to parse FT IEs
2431     tests += [ rsne + mde + fte + "3900" ]
2432     # FT: SNonce mismatch in FTIE
2433     tests += [ rsne + mde + "37520000" + 16*"00" + 32*"00" + 32*"00" ]
2434     # FT: ANonce mismatch in FTIE
2435     tests += [ rsne + mde + fte[0:40] + 32*"00" + fte[104:] ]
2436     # FT: No R0KH-ID subelem in FTIE
2437     tests += [ rsne + mde + "3752" + fte[4:168] ]
2438     # FT: R0KH-ID in FTIE did not match with the current R0KH-ID
2439     tests += [ rsne + mde + "3755" + fte[4:168] + "0301ff" ]
2440     # FT: No R1KH-ID subelem in FTIE
2441     tests += [ rsne + mde + "375e" + fte[4:168] + "030a" + binascii.hexlify(b"nas1.w1.fi").decode() ]
2442     # FT: Unknown R1KH-ID used in ReassocReq
2443     tests += [ rsne + mde + "3766" + fte[4:168] + "030a" + binascii.hexlify(b"nas1.w1.fi").decode() + "0106000000000000" ]
2444     # FT: PMKID in Reassoc Req did not match with the PMKR1Name derived from auth request
2445     tests += [ rsne[:-32] + 16*"00" + mde + fte ]
2446     # Invalid MIC in FTIE
2447     tests += [ rsne + mde + fte[0:8] + 16*"00" + fte[40:] ]
2448     for t in tests:
2449         hapd2ap.request("MGMT_RX_PROCESS freq=2412 datarate=0 ssi_signal=-30 frame=" + hdr + ies1 + t)
2450
2451 def test_ap_ft_reassoc_local_fail(dev, apdev):
2452     """WPA2-PSK-FT AP Reassociation Request frame and local failure"""
2453     ssid = "test-ft"
2454     passphrase="12345678"
2455
2456     params = ft_params1(ssid=ssid, passphrase=passphrase)
2457     hapd0 = hostapd.add_ap(apdev[0], params)
2458     params = ft_params2(ssid=ssid, passphrase=passphrase)
2459     hapd1 = hostapd.add_ap(apdev[1], params)
2460
2461     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2462                    ieee80211w="1", scan_freq="2412")
2463     if dev[0].get_status_field('bssid') == hapd0.own_addr():
2464         hapd1ap = hapd0
2465         hapd2ap = hapd1
2466     else:
2467         hapd1ap = hapd1
2468         hapd2ap = hapd0
2469
2470     dev[0].scan_for_bss(hapd2ap.own_addr(), freq="2412")
2471     # FT: Failed to calculate MIC
2472     with fail_test(hapd2ap, 1, "wpa_ft_validate_reassoc"):
2473         dev[0].request("ROAM " + hapd2ap.own_addr())
2474         ev = dev[0].wait_event(["CTRL-EVENT-ASSOC-REJECT"], timeout=10)
2475         dev[0].request("DISCONNECT")
2476         if ev is None:
2477             raise Exception("Association reject not seen")
2478
2479 def test_ap_ft_reassoc_replay(dev, apdev, params):
2480     """WPA2-PSK-FT AP and replayed Reassociation Request frame"""
2481     capfile = os.path.join(params['logdir'], "hwsim0.pcapng")
2482     ssid = "test-ft"
2483     passphrase="12345678"
2484
2485     params = ft_params1(ssid=ssid, passphrase=passphrase)
2486     hapd0 = hostapd.add_ap(apdev[0], params)
2487     params = ft_params2(ssid=ssid, passphrase=passphrase)
2488     hapd1 = hostapd.add_ap(apdev[1], params)
2489
2490     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2491                    scan_freq="2412")
2492     if dev[0].get_status_field('bssid') == hapd0.own_addr():
2493         hapd1ap = hapd0
2494         hapd2ap = hapd1
2495     else:
2496         hapd1ap = hapd1
2497         hapd2ap = hapd0
2498
2499     dev[0].scan_for_bss(hapd2ap.own_addr(), freq="2412")
2500     hapd2ap.set("ext_mgmt_frame_handling", "1")
2501     dev[0].dump_monitor()
2502     if "OK" not in dev[0].request("ROAM " + hapd2ap.own_addr()):
2503         raise Exception("ROAM failed")
2504
2505     reassocreq = None
2506     count = 0
2507     while count < 100:
2508         req = hapd2ap.mgmt_rx()
2509         count += 1
2510         hapd2ap.dump_monitor()
2511         hapd2ap.request("MGMT_RX_PROCESS freq=2412 datarate=0 ssi_signal=-30 frame=" + binascii.hexlify(req['frame']).decode())
2512         if req['subtype'] == 2:
2513             reassocreq = req
2514             ev = hapd2ap.wait_event(["MGMT-TX-STATUS"], timeout=5)
2515             if ev is None:
2516                 raise Exception("No TX status seen")
2517             cmd = "MGMT_TX_STATUS_PROCESS %s" % (" ".join(ev.split(' ')[1:4]))
2518             if "OK" not in hapd2ap.request(cmd):
2519                 raise Exception("MGMT_TX_STATUS_PROCESS failed")
2520             break
2521     hapd2ap.set("ext_mgmt_frame_handling", "0")
2522     if reassocreq is None:
2523         raise Exception("No Reassociation Request frame seen")
2524     dev[0].wait_connected()
2525     dev[0].dump_monitor()
2526     hapd2ap.dump_monitor()
2527
2528     hwsim_utils.test_connectivity(dev[0], hapd2ap)
2529
2530     logger.info("Replay the last Reassociation Request frame")
2531     hapd2ap.dump_monitor()
2532     hapd2ap.set("ext_mgmt_frame_handling", "1")
2533     hapd2ap.request("MGMT_RX_PROCESS freq=2412 datarate=0 ssi_signal=-30 frame=" + binascii.hexlify(req['frame']).decode())
2534     ev = hapd2ap.wait_event(["MGMT-TX-STATUS"], timeout=5)
2535     if ev is None:
2536         raise Exception("No TX status seen")
2537     cmd = "MGMT_TX_STATUS_PROCESS %s" % (" ".join(ev.split(' ')[1:4]))
2538     if "OK" not in hapd2ap.request(cmd):
2539         raise Exception("MGMT_TX_STATUS_PROCESS failed")
2540     hapd2ap.set("ext_mgmt_frame_handling", "0")
2541
2542     try:
2543         hwsim_utils.test_connectivity(dev[0], hapd2ap)
2544         ok = True
2545     except:
2546         ok = False
2547
2548     ap = hapd2ap.own_addr()
2549     sta = dev[0].own_addr()
2550     filt = "wlan.fc.type == 2 && " + \
2551            "wlan.da == " + sta + " && " + \
2552            "wlan.sa == " + ap
2553     fields = [ "wlan.ccmp.extiv" ]
2554     res = run_tshark(capfile, filt, fields)
2555     vals = res.splitlines()
2556     logger.info("CCMP PN: " + str(vals))
2557     if len(vals) < 2:
2558         raise Exception("Could not find all CCMP protected frames from capture")
2559     if len(set(vals)) < len(vals):
2560         raise Exception("Duplicate CCMP PN used")
2561
2562     if not ok:
2563         raise Exception("The second hwsim connectivity test failed")
2564
2565 def test_ap_ft_psk_file(dev, apdev):
2566     """WPA2-PSK-FT AP with PSK from a file"""
2567     ssid = "test-ft"
2568     passphrase="12345678"
2569
2570     params = ft_params1a(ssid=ssid, passphrase=passphrase)
2571     params['wpa_psk_file'] = 'hostapd.wpa_psk'
2572     hapd = hostapd.add_ap(apdev[0], params)
2573
2574     dev[1].connect(ssid, psk="very secret",
2575                    key_mgmt="FT-PSK", proto="WPA2", ieee80211w="1",
2576                    scan_freq="2412", wait_connect=False)
2577     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2578                    ieee80211w="1", scan_freq="2412")
2579     dev[0].request("REMOVE_NETWORK all")
2580     dev[0].wait_disconnected()
2581     dev[0].connect(ssid, psk="very secret", key_mgmt="FT-PSK", proto="WPA2",
2582                    ieee80211w="1", scan_freq="2412")
2583     dev[0].request("REMOVE_NETWORK all")
2584     dev[0].wait_disconnected()
2585     dev[0].connect(ssid, psk="secret passphrase",
2586                    key_mgmt="FT-PSK", proto="WPA2", ieee80211w="1",
2587                    scan_freq="2412")
2588     dev[2].connect(ssid, psk="another passphrase for all STAs",
2589                    key_mgmt="FT-PSK", proto="WPA2", ieee80211w="1",
2590                    scan_freq="2412")
2591     ev = dev[1].wait_event(["WPA: 4-Way Handshake failed"], timeout=10)
2592     if ev is None:
2593         raise Exception("Timed out while waiting for failure report")
2594     dev[1].request("REMOVE_NETWORK all")
2595
2596 def test_ap_ft_eap_ap_config_change(dev, apdev):
2597     """WPA2-EAP-FT AP changing from 802.1X-only to FT-only"""
2598     ssid = "test-ft"
2599     passphrase="12345678"
2600     bssid = apdev[0]['bssid']
2601
2602     radius = hostapd.radius_params()
2603     params = ft_params1(ssid=ssid, passphrase=passphrase, discovery=True)
2604     params['wpa_key_mgmt'] = "WPA-EAP"
2605     params["ieee8021x"] = "1"
2606     params["pmk_r1_push"] = "0"
2607     params["r0kh"] = "ff:ff:ff:ff:ff:ff * 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
2608     params["r1kh"] = "00:00:00:00:00:00 00:00:00:00:00:00 00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
2609     params["eap_server"] = "0"
2610     params = dict(list(radius.items()) + list(params.items()))
2611     hapd = hostapd.add_ap(apdev[0], params)
2612
2613     dev[0].connect(ssid, key_mgmt="FT-EAP WPA-EAP", proto="WPA2",
2614                    eap="GPSK", identity="gpsk user",
2615                    password="abcdefghijklmnop0123456789abcdef",
2616                    scan_freq="2412")
2617     dev[0].request("DISCONNECT")
2618     dev[0].wait_disconnected()
2619     dev[0].dump_monitor()
2620
2621     hapd.disable()
2622     hapd.set('wpa_key_mgmt', "FT-EAP")
2623     hapd.enable()
2624
2625     dev[0].request("BSS_FLUSH 0")
2626     dev[0].scan_for_bss(bssid, 2412, force_scan=True, only_new=True)
2627
2628     dev[0].request("RECONNECT")
2629     dev[0].wait_connected()
2630
2631 def test_ap_ft_eap_sha384(dev, apdev):
2632     """WPA2-EAP-FT with SHA384"""
2633     ssid = "test-ft"
2634     passphrase="12345678"
2635
2636     radius = hostapd.radius_params()
2637     params = ft_params1(ssid=ssid, passphrase=passphrase)
2638     params["ieee80211w"] = "2"
2639     params['wpa_key_mgmt'] = "FT-EAP-SHA384"
2640     params["ieee8021x"] = "1"
2641     params = dict(list(radius.items()) + list(params.items()))
2642     hapd0 = hostapd.add_ap(apdev[0], params)
2643     params = ft_params2(ssid=ssid, passphrase=passphrase)
2644     params["ieee80211w"] = "2"
2645     params['wpa_key_mgmt'] = "FT-EAP-SHA384"
2646     params["ieee8021x"] = "1"
2647     params = dict(list(radius.items()) + list(params.items()))
2648     hapd1 = hostapd.add_ap(apdev[1], params)
2649
2650     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, eap=True,
2651               sha384=True)
2652
2653 def test_ap_ft_eap_sha384_over_ds(dev, apdev):
2654     """WPA2-EAP-FT with SHA384 over DS"""
2655     ssid = "test-ft"
2656     passphrase="12345678"
2657
2658     radius = hostapd.radius_params()
2659     params = ft_params1(ssid=ssid, passphrase=passphrase)
2660     params["ieee80211w"] = "2"
2661     params['wpa_key_mgmt'] = "FT-EAP-SHA384"
2662     params["ieee8021x"] = "1"
2663     params = dict(list(radius.items()) + list(params.items()))
2664     hapd0 = hostapd.add_ap(apdev[0], params)
2665     params = ft_params2(ssid=ssid, passphrase=passphrase)
2666     params["ieee80211w"] = "2"
2667     params['wpa_key_mgmt'] = "FT-EAP-SHA384"
2668     params["ieee8021x"] = "1"
2669     params = dict(list(radius.items()) + list(params.items()))
2670     hapd1 = hostapd.add_ap(apdev[1], params)
2671
2672     run_roams(dev[0], apdev, hapd0, hapd1, ssid, passphrase, over_ds=True,
2673               eap=True, sha384=True)
2674
2675 def test_ap_ft_roam_rrm(dev, apdev):
2676     """WPA2-PSK-FT AP and radio measurement request"""
2677     ssid = "test-ft"
2678     passphrase="12345678"
2679
2680     params = ft_params1(ssid=ssid, passphrase=passphrase)
2681     params["rrm_beacon_report"] = "1"
2682     hapd0 = hostapd.add_ap(apdev[0], params)
2683     bssid0 = hapd0.own_addr()
2684
2685     addr = dev[0].own_addr()
2686     dev[0].connect(ssid, psk=passphrase, key_mgmt="FT-PSK", proto="WPA2",
2687                    scan_freq="2412")
2688     check_beacon_req(hapd0, addr, 1)
2689
2690     params = ft_params2(ssid=ssid, passphrase=passphrase)
2691     params["rrm_beacon_report"] = "1"
2692     hapd1 = hostapd.add_ap(apdev[1], params)
2693     bssid1 = hapd1.own_addr()
2694
2695     dev[0].scan_for_bss(bssid1, freq=2412)
2696     dev[0].roam(bssid1)
2697     check_beacon_req(hapd1, addr, 2)
2698
2699     dev[0].scan_for_bss(bssid0, freq=2412)
2700     dev[0].roam(bssid0)
2701     check_beacon_req(hapd0, addr, 3)