tests/hwsim/test_ap_psk.py

   1 # WPA2-Personal tests
   2 # Copyright (c) 2014, Qualcomm Atheros, Inc.
   3 #
   4 # This software may be distributed under the terms of the BSD license.
   5 # See README for more details.
   6
   7 import binascii
   8 from Crypto.Cipher import AES
   9 import hashlib
  10 import hmac
  11 import logging
  12 logger = logging.getLogger()
  13 import os
  14 import re
  15 import struct
  16 import subprocess
  17 import time
  18
  19 import hostapd
  20 from utils import HwsimSkip, fail_test, skip_with_fips
  21 import hwsim_utils
  22 from wpasupplicant import WpaSupplicant
  23
  24 def check_mib(dev, vals):
  25     mib = dev.get_mib()
  26     for v in vals:
  27         if mib[v[0]] != v[1]:
  28             raise Exception("Unexpected {} = {} (expected {})".format(v[0], mib[v[0]], v[1]))
  29
  30 def test_ap_wpa2_psk(dev, apdev):
  31     """WPA2-PSK AP with PSK instead of passphrase"""
  32     ssid = "test-wpa2-psk"
  33     passphrase = 'qwertyuiop'
  34     psk = '602e323e077bc63bd80307ef4745b754b0ae0a925c2638ecd13a794b9527b9e6'
  35     params = hostapd.wpa2_params(ssid=ssid)
  36     params['wpa_psk'] = psk
  37     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
  38     key_mgmt = hapd.get_config()['key_mgmt']
  39     if key_mgmt.split(' ')[0] != "WPA-PSK":
  40         raise Exception("Unexpected GET_CONFIG(key_mgmt): " + key_mgmt)
  41     dev[0].connect(ssid, raw_psk=psk, scan_freq="2412")
  42     dev[1].connect(ssid, psk=passphrase, scan_freq="2412")
  43
  44     sig = dev[0].request("SIGNAL_POLL").splitlines()
  45     pkt = dev[0].request("PKTCNT_POLL").splitlines()
  46     if "FREQUENCY=2412" not in sig:
  47         raise Exception("Unexpected SIGNAL_POLL value: " + str(sig))
  48     if "TXBAD=0" not in pkt:
  49         raise Exception("Unexpected TXBAD value: " + str(pkt))
  50
  51 def test_ap_wpa2_psk_file(dev, apdev):
  52     """WPA2-PSK AP with PSK from a file"""
  53     ssid = "test-wpa2-psk"
  54     passphrase = 'qwertyuiop'
  55     psk = '602e323e077bc63bd80307ef4745b754b0ae0a925c2638ecd13a794b9527b9e6'
  56     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
  57     params['wpa_psk_file'] = 'hostapd.wpa_psk'
  58     hostapd.add_ap(apdev[0]['ifname'], params)
  59     dev[1].connect(ssid, psk="very secret", scan_freq="2412", wait_connect=False)
  60     dev[2].connect(ssid, raw_psk=psk, scan_freq="2412")
  61     dev[2].request("REMOVE_NETWORK all")
  62     dev[0].connect(ssid, psk="very secret", scan_freq="2412")
  63     dev[0].request("REMOVE_NETWORK all")
  64     dev[2].connect(ssid, psk="another passphrase for all STAs", scan_freq="2412")
  65     dev[0].connect(ssid, psk="another passphrase for all STAs", scan_freq="2412")
  66     ev = dev[1].wait_event(["WPA: 4-Way Handshake failed"], timeout=10)
  67     if ev is None:
  68         raise Exception("Timed out while waiting for failure report")
  69     dev[1].request("REMOVE_NETWORK all")
  70
  71 def test_ap_wpa2_psk_mem(dev, apdev):
  72     """WPA2-PSK AP with passphrase only in memory"""
  73     try:
  74         _test_ap_wpa2_psk_mem(dev, apdev)
  75     finally:
  76         dev[0].request("SCAN_INTERVAL 5")
  77         dev[1].request("SCAN_INTERVAL 5")
  78
  79 def _test_ap_wpa2_psk_mem(dev, apdev):
  80     ssid = "test-wpa2-psk"
  81     passphrase = 'qwertyuiop'
  82     psk = '602e323e077bc63bd80307ef4745b754b0ae0a925c2638ecd13a794b9527b9e6'
  83     params = hostapd.wpa2_params(ssid=ssid)
  84     params['wpa_psk'] = psk
  85     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
  86
  87     dev[0].connect(ssid, mem_only_psk="1", scan_freq="2412", wait_connect=False)
  88     dev[0].request("SCAN_INTERVAL 1")
  89     ev = dev[0].wait_event(["CTRL-REQ-PSK_PASSPHRASE"], timeout=10)
  90     if ev is None:
  91         raise Exception("Request for PSK/passphrase timed out")
  92     id = ev.split(':')[0].split('-')[-1]
  93     dev[0].request("CTRL-RSP-PSK_PASSPHRASE-" + id + ':"' + passphrase + '"')
  94     dev[0].wait_connected(timeout=10)
  95
  96     dev[1].connect(ssid, mem_only_psk="1", scan_freq="2412", wait_connect=False)
  97     dev[1].request("SCAN_INTERVAL 1")
  98     ev = dev[1].wait_event(["CTRL-REQ-PSK_PASSPHRASE"], timeout=10)
  99     if ev is None:
 100         raise Exception("Request for PSK/passphrase timed out(2)")
 101     id = ev.split(':')[0].split('-')[-1]
 102     dev[1].request("CTRL-RSP-PSK_PASSPHRASE-" + id + ':' + psk)
 103     dev[1].wait_connected(timeout=10)
 104
 105 def test_ap_wpa2_ptk_rekey(dev, apdev):
 106     """WPA2-PSK AP and PTK rekey enforced by station"""
 107     ssid = "test-wpa2-psk"
 108     passphrase = 'qwertyuiop'
 109     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
 110     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 111     dev[0].connect(ssid, psk=passphrase, wpa_ptk_rekey="1", scan_freq="2412")
 112     ev = dev[0].wait_event(["WPA: Key negotiation completed"])
 113     if ev is None:
 114         raise Exception("PTK rekey timed out")
 115     hwsim_utils.test_connectivity(dev[0], hapd)
 116
 117 def test_ap_wpa2_ptk_rekey_ap(dev, apdev):
 118     """WPA2-PSK AP and PTK rekey enforced by AP"""
 119     ssid = "test-wpa2-psk"
 120     passphrase = 'qwertyuiop'
 121     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
 122     params['wpa_ptk_rekey'] = '2'
 123     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 124     dev[0].connect(ssid, psk=passphrase, scan_freq="2412")
 125     ev = dev[0].wait_event(["WPA: Key negotiation completed"])
 126     if ev is None:
 127         raise Exception("PTK rekey timed out")
 128     hwsim_utils.test_connectivity(dev[0], hapd)
 129
 130 def test_ap_wpa2_sha256_ptk_rekey(dev, apdev):
 131     """WPA2-PSK/SHA256 AKM AP and PTK rekey enforced by station"""
 132     ssid = "test-wpa2-psk"
 133     passphrase = 'qwertyuiop'
 134     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
 135     params["wpa_key_mgmt"] = "WPA-PSK-SHA256"
 136     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 137     dev[0].connect(ssid, psk=passphrase, key_mgmt="WPA-PSK-SHA256",
 138                    wpa_ptk_rekey="1", scan_freq="2412")
 139     ev = dev[0].wait_event(["WPA: Key negotiation completed"])
 140     if ev is None:
 141         raise Exception("PTK rekey timed out")
 142     hwsim_utils.test_connectivity(dev[0], hapd)
 143     check_mib(dev[0], [ ("dot11RSNAAuthenticationSuiteRequested", "00-0f-ac-6"),
 144                         ("dot11RSNAAuthenticationSuiteSelected", "00-0f-ac-6") ])
 145
 146 def test_ap_wpa2_sha256_ptk_rekey_ap(dev, apdev):
 147     """WPA2-PSK/SHA256 AKM AP and PTK rekey enforced by AP"""
 148     ssid = "test-wpa2-psk"
 149     passphrase = 'qwertyuiop'
 150     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
 151     params["wpa_key_mgmt"] = "WPA-PSK-SHA256"
 152     params['wpa_ptk_rekey'] = '2'
 153     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 154     dev[0].connect(ssid, psk=passphrase, key_mgmt="WPA-PSK-SHA256",
 155                    scan_freq="2412")
 156     ev = dev[0].wait_event(["WPA: Key negotiation completed"])
 157     if ev is None:
 158         raise Exception("PTK rekey timed out")
 159     hwsim_utils.test_connectivity(dev[0], hapd)
 160     check_mib(dev[0], [ ("dot11RSNAAuthenticationSuiteRequested", "00-0f-ac-6"),
 161                         ("dot11RSNAAuthenticationSuiteSelected", "00-0f-ac-6") ])
 162
 163 def test_ap_wpa_ptk_rekey(dev, apdev):
 164     """WPA-PSK/TKIP AP and PTK rekey enforced by station"""
 165     skip_with_fips(dev[0])
 166     ssid = "test-wpa-psk"
 167     passphrase = 'qwertyuiop'
 168     params = hostapd.wpa_params(ssid=ssid, passphrase=passphrase)
 169     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 170     dev[0].connect(ssid, psk=passphrase, wpa_ptk_rekey="1", scan_freq="2412")
 171     if "[WPA-PSK-TKIP]" not in dev[0].request("SCAN_RESULTS"):
 172         raise Exception("Scan results missing WPA element info")
 173     ev = dev[0].wait_event(["WPA: Key negotiation completed"])
 174     if ev is None:
 175         raise Exception("PTK rekey timed out")
 176     hwsim_utils.test_connectivity(dev[0], hapd)
 177
 178 def test_ap_wpa_ptk_rekey_ap(dev, apdev):
 179     """WPA-PSK/TKIP AP and PTK rekey enforced by AP"""
 180     skip_with_fips(dev[0])
 181     ssid = "test-wpa-psk"
 182     passphrase = 'qwertyuiop'
 183     params = hostapd.wpa_params(ssid=ssid, passphrase=passphrase)
 184     params['wpa_ptk_rekey'] = '2'
 185     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 186     dev[0].connect(ssid, psk=passphrase, scan_freq="2412")
 187     ev = dev[0].wait_event(["WPA: Key negotiation completed"], timeout=10)
 188     if ev is None:
 189         raise Exception("PTK rekey timed out")
 190     hwsim_utils.test_connectivity(dev[0], hapd)
 191
 192 def test_ap_wpa_ccmp(dev, apdev):
 193     """WPA-PSK/CCMP"""
 194     ssid = "test-wpa-psk"
 195     passphrase = 'qwertyuiop'
 196     params = hostapd.wpa_params(ssid=ssid, passphrase=passphrase)
 197     params['wpa_pairwise'] = "CCMP"
 198     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 199     dev[0].connect(ssid, psk=passphrase, scan_freq="2412")
 200     hwsim_utils.test_connectivity(dev[0], hapd)
 201     check_mib(dev[0], [ ("dot11RSNAConfigGroupCipherSize", "128"),
 202                         ("dot11RSNAGroupCipherRequested", "00-50-f2-4"),
 203                         ("dot11RSNAPairwiseCipherRequested", "00-50-f2-4"),
 204                         ("dot11RSNAAuthenticationSuiteRequested", "00-50-f2-2"),
 205                         ("dot11RSNAGroupCipherSelected", "00-50-f2-4"),
 206                         ("dot11RSNAPairwiseCipherSelected", "00-50-f2-4"),
 207                         ("dot11RSNAAuthenticationSuiteSelected", "00-50-f2-2"),
 208                         ("dot1xSuppSuppControlledPortStatus", "Authorized") ])
 209
 210 def test_ap_wpa2_psk_file(dev, apdev):
 211     """WPA2-PSK AP with various PSK file error and success cases"""
 212     addr0 = dev[0].own_addr()
 213     addr1 = dev[1].own_addr()
 214     addr2 = dev[2].own_addr()
 215     ssid = "psk"
 216     pskfile = "/tmp/ap_wpa2_psk_file_errors.psk_file"
 217     try:
 218         os.remove(pskfile)
 219     except:
 220         pass
 221
 222     params = { "ssid": ssid, "wpa": "2", "wpa_key_mgmt": "WPA-PSK",
 223                "rsn_pairwise": "CCMP", "wpa_psk_file": pskfile }
 224
 225     try:
 226         # missing PSK file
 227         hapd = hostapd.add_ap(apdev[0]['ifname'], params, no_enable=True)
 228         if "FAIL" not in hapd.request("ENABLE"):
 229             raise Exception("Unexpected ENABLE success")
 230         hapd.request("DISABLE")
 231
 232         # invalid MAC address
 233         with open(pskfile, "w") as f:
 234             f.write("\n")
 235             f.write("foo\n")
 236         if "FAIL" not in hapd.request("ENABLE"):
 237             raise Exception("Unexpected ENABLE success")
 238         hapd.request("DISABLE")
 239
 240         # no PSK on line
 241         with open(pskfile, "w") as f:
 242             f.write("00:11:22:33:44:55\n")
 243         if "FAIL" not in hapd.request("ENABLE"):
 244             raise Exception("Unexpected ENABLE success")
 245         hapd.request("DISABLE")
 246
 247         # invalid PSK
 248         with open(pskfile, "w") as f:
 249             f.write("00:11:22:33:44:55 1234567\n")
 250         if "FAIL" not in hapd.request("ENABLE"):
 251             raise Exception("Unexpected ENABLE success")
 252         hapd.request("DISABLE")
 253
 254         # valid PSK file
 255         with open(pskfile, "w") as f:
 256             f.write("00:11:22:33:44:55 12345678\n")
 257             f.write(addr0 + " 123456789\n")
 258             f.write(addr1 + " 123456789a\n")
 259             f.write(addr2 + " 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef\n")
 260         if "FAIL" in hapd.request("ENABLE"):
 261             raise Exception("Unexpected ENABLE failure")
 262
 263         dev[0].connect(ssid, psk="123456789", scan_freq="2412")
 264         dev[1].connect(ssid, psk="123456789a", scan_freq="2412")
 265         dev[2].connect(ssid, raw_psk="0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", scan_freq="2412")
 266
 267     finally:
 268         try:
 269             os.remove(pskfile)
 270         except:
 271             pass
 272
 273 def test_ap_wpa2_psk_wildcard_ssid(dev, apdev):
 274     """WPA2-PSK AP and wildcard SSID configuration"""
 275     ssid = "test-wpa2-psk"
 276     passphrase = 'qwertyuiop'
 277     psk = '602e323e077bc63bd80307ef4745b754b0ae0a925c2638ecd13a794b9527b9e6'
 278     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
 279     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 280     dev[0].connect("", bssid=apdev[0]['bssid'], psk=passphrase,
 281                    scan_freq="2412")
 282     dev[1].connect("", bssid=apdev[0]['bssid'], raw_psk=psk, scan_freq="2412")
 283
 284 def test_ap_wpa2_gtk_rekey(dev, apdev):
 285     """WPA2-PSK AP and GTK rekey enforced by AP"""
 286     ssid = "test-wpa2-psk"
 287     passphrase = 'qwertyuiop'
 288     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
 289     params['wpa_group_rekey'] = '1'
 290     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 291     dev[0].connect(ssid, psk=passphrase, scan_freq="2412")
 292     ev = dev[0].wait_event(["WPA: Group rekeying completed"], timeout=2)
 293     if ev is None:
 294         raise Exception("GTK rekey timed out")
 295     hwsim_utils.test_connectivity(dev[0], hapd)
 296
 297 def test_ap_wpa_gtk_rekey(dev, apdev):
 298     """WPA-PSK/TKIP AP and GTK rekey enforced by AP"""
 299     skip_with_fips(dev[0])
 300     ssid = "test-wpa-psk"
 301     passphrase = 'qwertyuiop'
 302     params = hostapd.wpa_params(ssid=ssid, passphrase=passphrase)
 303     params['wpa_group_rekey'] = '1'
 304     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 305     dev[0].connect(ssid, psk=passphrase, scan_freq="2412")
 306     ev = dev[0].wait_event(["WPA: Group rekeying completed"], timeout=2)
 307     if ev is None:
 308         raise Exception("GTK rekey timed out")
 309     hwsim_utils.test_connectivity(dev[0], hapd)
 310
 311 def test_ap_wpa2_gmk_rekey(dev, apdev):
 312     """WPA2-PSK AP and GMK and GTK rekey enforced by AP"""
 313     ssid = "test-wpa2-psk"
 314     passphrase = 'qwertyuiop'
 315     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
 316     params['wpa_group_rekey'] = '1'
 317     params['wpa_gmk_rekey'] = '2'
 318     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 319     dev[0].connect(ssid, psk=passphrase, scan_freq="2412")
 320     for i in range(0, 3):
 321         ev = dev[0].wait_event(["WPA: Group rekeying completed"], timeout=2)
 322         if ev is None:
 323             raise Exception("GTK rekey timed out")
 324     hwsim_utils.test_connectivity(dev[0], hapd)
 325
 326 def test_ap_wpa2_strict_rekey(dev, apdev):
 327     """WPA2-PSK AP and strict GTK rekey enforced by AP"""
 328     ssid = "test-wpa2-psk"
 329     passphrase = 'qwertyuiop'
 330     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
 331     params['wpa_strict_rekey'] = '1'
 332     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 333     dev[0].connect(ssid, psk=passphrase, scan_freq="2412")
 334     dev[1].connect(ssid, psk=passphrase, scan_freq="2412")
 335     dev[1].request("DISCONNECT")
 336     ev = dev[0].wait_event(["WPA: Group rekeying completed"], timeout=2)
 337     if ev is None:
 338         raise Exception("GTK rekey timed out")
 339     hwsim_utils.test_connectivity(dev[0], hapd)
 340
 341 def test_ap_wpa2_bridge_fdb(dev, apdev):
 342     """Bridge FDB entry removal"""
 343     try:
 344         ssid = "test-wpa2-psk"
 345         passphrase = "12345678"
 346         params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
 347         params['bridge'] = 'ap-br0'
 348         hostapd.add_ap(apdev[0]['ifname'], params)
 349         subprocess.call(['brctl', 'setfd', 'ap-br0', '0'])
 350         subprocess.call(['ip', 'link', 'set', 'dev', 'ap-br0', 'up'])
 351         dev[0].connect(ssid, psk=passphrase, scan_freq="2412",
 352                        bssid=apdev[0]['bssid'])
 353         dev[1].connect(ssid, psk=passphrase, scan_freq="2412",
 354                        bssid=apdev[0]['bssid'])
 355         addr0 = dev[0].p2p_interface_addr()
 356         hwsim_utils.test_connectivity_sta(dev[0], dev[1])
 357         cmd = subprocess.Popen(['brctl', 'showmacs', 'ap-br0'],
 358                                stdout=subprocess.PIPE)
 359         macs1 = cmd.stdout.read()
 360         dev[0].request("DISCONNECT")
 361         dev[1].request("DISCONNECT")
 362         time.sleep(1)
 363         cmd = subprocess.Popen(['brctl', 'showmacs', 'ap-br0'],
 364                                stdout=subprocess.PIPE)
 365         macs2 = cmd.stdout.read()
 366
 367         addr1 = dev[1].p2p_interface_addr()
 368         if addr0 not in macs1 or addr1 not in macs1:
 369             raise Exception("Bridge FDB entry missing")
 370         if addr0 in macs2 or addr1 in macs2:
 371             raise Exception("Bridge FDB entry was not removed")
 372     finally:
 373         subprocess.call(['ip', 'link', 'set', 'dev', 'ap-br0', 'down'])
 374         subprocess.call(['brctl', 'delbr', 'ap-br0'])
 375
 376 def test_ap_wpa2_already_in_bridge(dev, apdev):
 377     """hostapd behavior with interface already in bridge"""
 378     ifname = apdev[0]['ifname']
 379     br_ifname = 'ext-ap-br0'
 380     try:
 381         ssid = "test-wpa2-psk"
 382         passphrase = "12345678"
 383         subprocess.call(['brctl', 'addbr', br_ifname])
 384         subprocess.call(['brctl', 'setfd', br_ifname, '0'])
 385         subprocess.call(['ip', 'link', 'set', 'dev', br_ifname, 'up'])
 386         subprocess.call(['iw', ifname, 'set', 'type', '__ap'])
 387         subprocess.call(['brctl', 'addif', br_ifname, ifname])
 388         params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
 389         hapd = hostapd.add_ap(ifname, params)
 390         if hapd.get_driver_status_field('brname') != br_ifname:
 391             raise Exception("Bridge name not identified correctly")
 392         dev[0].connect(ssid, psk=passphrase, scan_freq="2412")
 393     finally:
 394         subprocess.call(['ip', 'link', 'set', 'dev', br_ifname, 'down'])
 395         subprocess.call(['brctl', 'delif', br_ifname, ifname])
 396         subprocess.call(['iw', ifname, 'set', 'type', 'station'])
 397         subprocess.call(['brctl', 'delbr', br_ifname])
 398
 399 def test_ap_wpa2_in_different_bridge(dev, apdev):
 400     """hostapd behavior with interface in different bridge"""
 401     ifname = apdev[0]['ifname']
 402     br_ifname = 'ext-ap-br0'
 403     try:
 404         ssid = "test-wpa2-psk"
 405         passphrase = "12345678"
 406         subprocess.call(['brctl', 'addbr', br_ifname])
 407         subprocess.call(['brctl', 'setfd', br_ifname, '0'])
 408         subprocess.call(['ip', 'link', 'set', 'dev', br_ifname, 'up'])
 409         subprocess.call(['iw', ifname, 'set', 'type', '__ap'])
 410         subprocess.call(['brctl', 'addif', br_ifname, ifname])
 411         time.sleep(0.5)
 412         params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
 413         params['bridge'] = 'ap-br0'
 414         hapd = hostapd.add_ap(ifname, params)
 415         subprocess.call(['brctl', 'setfd', 'ap-br0', '0'])
 416         subprocess.call(['ip', 'link', 'set', 'dev', 'ap-br0', 'up'])
 417         brname = hapd.get_driver_status_field('brname')
 418         if brname != 'ap-br0':
 419             raise Exception("Incorrect bridge: " + brname)
 420         dev[0].connect(ssid, psk=passphrase, scan_freq="2412")
 421         hwsim_utils.test_connectivity_iface(dev[0], hapd, "ap-br0")
 422         if hapd.get_driver_status_field("added_bridge") != "1":
 423             raise Exception("Unexpected added_bridge value")
 424         if hapd.get_driver_status_field("added_if_into_bridge") != "1":
 425             raise Exception("Unexpected added_if_into_bridge value")
 426         dev[0].request("DISCONNECT")
 427         hapd.disable()
 428     finally:
 429         subprocess.call(['ip', 'link', 'set', 'dev', br_ifname, 'down'])
 430         subprocess.call(['brctl', 'delif', br_ifname, ifname],
 431                         stderr=open('/dev/null', 'w'))
 432         subprocess.call(['brctl', 'delbr', br_ifname])
 433
 434 def test_ap_wpa2_ext_add_to_bridge(dev, apdev):
 435     """hostapd behavior with interface added to bridge externally"""
 436     ifname = apdev[0]['ifname']
 437     br_ifname = 'ext-ap-br0'
 438     try:
 439         ssid = "test-wpa2-psk"
 440         passphrase = "12345678"
 441         params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
 442         hapd = hostapd.add_ap(ifname, params)
 443
 444         subprocess.call(['brctl', 'addbr', br_ifname])
 445         subprocess.call(['brctl', 'setfd', br_ifname, '0'])
 446         subprocess.call(['ip', 'link', 'set', 'dev', br_ifname, 'up'])
 447         subprocess.call(['brctl', 'addif', br_ifname, ifname])
 448         dev[0].connect(ssid, psk=passphrase, scan_freq="2412")
 449         if hapd.get_driver_status_field('brname') != br_ifname:
 450             raise Exception("Bridge name not identified correctly")
 451     finally:
 452         subprocess.call(['ip', 'link', 'set', 'dev', br_ifname, 'down'])
 453         subprocess.call(['brctl', 'delif', br_ifname, ifname])
 454         subprocess.call(['brctl', 'delbr', br_ifname])
 455
 456 def test_ap_wpa2_psk_ext(dev, apdev):
 457     """WPA2-PSK AP using external EAPOL I/O"""
 458     bssid = apdev[0]['bssid']
 459     ssid = "test-wpa2-psk"
 460     passphrase = 'qwertyuiop'
 461     psk = '602e323e077bc63bd80307ef4745b754b0ae0a925c2638ecd13a794b9527b9e6'
 462     params = hostapd.wpa2_params(ssid=ssid)
 463     params['wpa_psk'] = psk
 464     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 465     hapd.request("SET ext_eapol_frame_io 1")
 466     dev[0].request("SET ext_eapol_frame_io 1")
 467     dev[0].connect(ssid, psk=passphrase, scan_freq="2412", wait_connect=False)
 468     addr = dev[0].p2p_interface_addr()
 469     while True:
 470         ev = hapd.wait_event(["EAPOL-TX", "AP-STA-CONNECTED"], timeout=15)
 471         if ev is None:
 472             raise Exception("Timeout on EAPOL-TX from hostapd")
 473         if "AP-STA-CONNECTED" in ev:
 474             dev[0].wait_connected(timeout=15)
 475             break
 476         res = dev[0].request("EAPOL_RX " + bssid + " " + ev.split(' ')[2])
 477         if "OK" not in res:
 478             raise Exception("EAPOL_RX to wpa_supplicant failed")
 479         ev = dev[0].wait_event(["EAPOL-TX", "CTRL-EVENT-CONNECTED"], timeout=15)
 480         if ev is None:
 481             raise Exception("Timeout on EAPOL-TX from wpa_supplicant")
 482         if "CTRL-EVENT-CONNECTED" in ev:
 483             break
 484         res = hapd.request("EAPOL_RX " + addr + " " + ev.split(' ')[2])
 485         if "OK" not in res:
 486             raise Exception("EAPOL_RX to hostapd failed")
 487
 488 def test_ap_wpa2_psk_ext_retry_msg_3(dev, apdev):
 489     """WPA2-PSK AP using external EAPOL I/O and retry for EAPOL-Key msg 3/4"""
 490     bssid = apdev[0]['bssid']
 491     ssid = "test-wpa2-psk"
 492     passphrase = 'qwertyuiop'
 493     psk = '602e323e077bc63bd80307ef4745b754b0ae0a925c2638ecd13a794b9527b9e6'
 494     params = hostapd.wpa2_params(ssid=ssid)
 495     params['wpa_psk'] = psk
 496     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
 497     hapd.request("SET ext_eapol_frame_io 1")
 498     dev[0].request("SET ext_eapol_frame_io 1")
 499     dev[0].connect(ssid, psk=passphrase, scan_freq="2412", wait_connect=False)
 500     addr = dev[0].p2p_interface_addr()
 501
 502     # EAPOL-Key msg 1/4
 503     ev = hapd.wait_event(["EAPOL-TX"], timeout=15)
 504     if ev is None:
 505         raise Exception("Timeout on EAPOL-TX from hostapd")
 506     res = dev[0].request("EAPOL_RX " + bssid + " " + ev.split(' ')[2])
 507     if "OK" not in res:
 508         raise Exception("EAPOL_RX to wpa_supplicant failed")
 509
 510     # EAPOL-Key msg 2/4
 511     ev = dev[0].wait_event(["EAPOL-TX"], timeout=15)
 512     if ev is None:
 513         raise Exception("Timeout on EAPOL-TX from wpa_supplicant")
 514     res = hapd.request("EAPOL_RX " + addr + " " + ev.split(' ')[2])
 515     if "OK" not in res:
 516         raise Exception("EAPOL_RX to hostapd failed")
 517
 518     # EAPOL-Key msg 3/4
 519     ev = hapd.wait_event(["EAPOL-TX"], timeout=15)
 520     if ev is None:
 521         raise Exception("Timeout on EAPOL-TX from hostapd")
 522     res = dev[0].request("EAPOL_RX " + bssid + " " + ev.split(' ')[2])
 523     if "OK" not in res:
 524         raise Exception("EAPOL_RX to wpa_supplicant failed")
 525
 526     # EAPOL-Key msg 4/4
 527     ev = dev[0].wait_event(["EAPOL-TX"], timeout=15)
 528     if ev is None:
 529         raise Exception("Timeout on EAPOL-TX from wpa_supplicant")
 530     # Do not send to the AP
 531     dev[0].wait_connected(timeout=15)
 532
 533     # EAPOL-Key msg 3/4 (retry)
 534     ev = hapd.wait_event(["EAPOL-TX"], timeout=15)
 535     if ev is None:
 536         raise Exception("Timeout on EAPOL-TX from hostapd")
 537     res = dev[0].request("EAPOL_RX " + bssid + " " + ev.split(' ')[2])
 538     if "OK" not in res:
 539         raise Exception("EAPOL_RX to wpa_supplicant failed")
 540
 541     # EAPOL-Key msg 4/4
 542     ev = dev[0].wait_event(["EAPOL-TX"], timeout=15)
 543     if ev is None:
 544         raise Exception("Timeout on EAPOL-TX from wpa_supplicant")
 545     res = hapd.request("EAPOL_RX " + addr + " " + ev.split(' ')[2])
 546     if "OK" not in res:
 547         raise Exception("EAPOL_RX to hostapd failed")
 548
 549     ev = hapd.wait_event(["AP-STA-CONNECTED"], timeout=15)
 550     if ev is None:
 551         raise Exception("Timeout on AP-STA-CONNECTED from hostapd")
 552
 553     hwsim_utils.test_connectivity(dev[0], hapd)
 554
 555 def parse_eapol(data):
 556     (version, type, length) = struct.unpack('>BBH', data[0:4])
 557     payload = data[4:]
 558     if length > len(payload):
 559         raise Exception("Invalid EAPOL length")
 560     if length < len(payload):
 561         payload = payload[0:length]
 562     eapol = {}
 563     eapol['version'] = version
 564     eapol['type'] = type
 565     eapol['length'] = length
 566     eapol['payload'] = payload
 567     if type == 3:
 568         # EAPOL-Key
 569         (eapol['descr_type'],) = struct.unpack('B', payload[0:1])
 570         payload = payload[1:]
 571         if eapol['descr_type'] == 2 or eapol['descr_type'] == 254:
 572             # RSN EAPOL-Key
 573             (key_info, key_len) = struct.unpack('>HH', payload[0:4])
 574             eapol['rsn_key_info'] = key_info
 575             eapol['rsn_key_len'] = key_len
 576             eapol['rsn_replay_counter'] = payload[4:12]
 577             eapol['rsn_key_nonce'] = payload[12:44]
 578             eapol['rsn_key_iv'] = payload[44:60]
 579             eapol['rsn_key_rsc'] = payload[60:68]
 580             eapol['rsn_key_id'] = payload[68:76]
 581             eapol['rsn_key_mic'] = payload[76:92]
 582             payload = payload[92:]
 583             (eapol['rsn_key_data_len'],) = struct.unpack('>H', payload[0:2])
 584             payload = payload[2:]
 585             eapol['rsn_key_data'] = payload
 586     return eapol
 587
 588 def build_eapol(msg):
 589     data = struct.pack(">BBH", msg['version'], msg['type'], msg['length'])
 590     if msg['type'] == 3:
 591         data += struct.pack('>BHH', msg['descr_type'], msg['rsn_key_info'],
 592                             msg['rsn_key_len'])
 593         data += msg['rsn_replay_counter']
 594         data += msg['rsn_key_nonce']
 595         data += msg['rsn_key_iv']
 596         data += msg['rsn_key_rsc']
 597         data += msg['rsn_key_id']
 598         data += msg['rsn_key_mic']
 599         data += struct.pack('>H', msg['rsn_key_data_len'])
 600         data += msg['rsn_key_data']
 601     else:
 602         data += msg['payload']
 603     return data
 604
 605 def sha1_prf(key, label, data, outlen):
 606     res = ''
 607     counter = 0
 608     while outlen > 0:
 609         m = hmac.new(key, label, hashlib.sha1)
 610         m.update(struct.pack('B', 0))
 611         m.update(data)
 612         m.update(struct.pack('B', counter))
 613         counter += 1
 614         hash = m.digest()
 615         if outlen > len(hash):
 616             res += hash
 617             outlen -= len(hash)
 618         else:
 619             res += hash[0:outlen]
 620             outlen = 0
 621     return res
 622
 623 def pmk_to_ptk(pmk, addr1, addr2, nonce1, nonce2):
 624     if addr1 < addr2:
 625         data = binascii.unhexlify(addr1.replace(':','')) + binascii.unhexlify(addr2.replace(':',''))
 626     else:
 627         data = binascii.unhexlify(addr2.replace(':','')) + binascii.unhexlify(addr1.replace(':',''))
 628     if nonce1 < nonce2:
 629         data += nonce1 + nonce2
 630     else:
 631         data += nonce2 + nonce1
 632     label = "Pairwise key expansion"
 633     ptk = sha1_prf(pmk, label, data, 48)
 634     kck = ptk[0:16]
 635     kek = ptk[16:32]
 636     return (ptk, kck, kek)
 637
 638 def eapol_key_mic(kck, msg):
 639     msg['rsn_key_mic'] = binascii.unhexlify('00000000000000000000000000000000')
 640     data = build_eapol(msg)
 641     m = hmac.new(kck, data, hashlib.sha1)
 642     msg['rsn_key_mic'] = m.digest()[0:16]
 643
 644 def rsn_eapol_key_set(msg, key_info, key_len, nonce, data):
 645     msg['rsn_key_info'] = key_info
 646     msg['rsn_key_len'] = key_len
 647     if nonce:
 648         msg['rsn_key_nonce'] = nonce
 649     else:
 650         msg['rsn_key_nonce'] = binascii.unhexlify('0000000000000000000000000000000000000000000000000000000000000000')
 651     if data:
 652         msg['rsn_key_data_len'] = len(data)
 653         msg['rsn_key_data'] = data
 654         msg['length'] = 95 + len(data)
 655     else:
 656         msg['rsn_key_data_len'] = 0
 657         msg['rsn_key_data'] = ''
 658         msg['length'] = 95
 659
 660 def recv_eapol(hapd):
 661     ev = hapd.wait_event(["EAPOL-TX"], timeout=15)
 662     if ev is None:
 663         raise Exception("Timeout on EAPOL-TX from hostapd")
 664     eapol = binascii.unhexlify(ev.split(' ')[2])
 665     return parse_eapol(eapol)
 666
 667 def send_eapol(hapd, addr, data):
 668     res = hapd.request("EAPOL_RX " + addr + " " + binascii.hexlify(data))
 669     if "OK" not in res:
 670         raise Exception("EAPOL_RX to hostapd failed")
 671
 672 def reply_eapol(info, hapd, addr, msg, key_info, nonce, data, kck):
 673     logger.info("Send EAPOL-Key msg " + info)
 674     rsn_eapol_key_set(msg, key_info, 0, nonce, data)
 675     eapol_key_mic(kck, msg)
 676     send_eapol(hapd, addr, build_eapol(msg))
 677
 678 def hapd_connected(hapd):
 679     ev = hapd.wait_event(["AP-STA-CONNECTED"], timeout=15)
 680     if ev is None:
 681         raise Exception("Timeout on AP-STA-CONNECTED from hostapd")
 682
 683 def eapol_test(apdev, dev, wpa2=True):
 684     bssid = apdev['bssid']
 685     if wpa2:
 686         ssid = "test-wpa2-psk"
 687     else:
 688         ssid = "test-wpa-psk"
 689     psk = '602e323e077bc63bd80307ef4745b754b0ae0a925c2638ecd13a794b9527b9e6'
 690     pmk = binascii.unhexlify(psk)
 691     if wpa2:
 692         params = hostapd.wpa2_params(ssid=ssid)
 693     else:
 694         params = hostapd.wpa_params(ssid=ssid)
 695     params['wpa_psk'] = psk
 696     hapd = hostapd.add_ap(apdev['ifname'], params)
 697     hapd.request("SET ext_eapol_frame_io 1")
 698     dev.request("SET ext_eapol_frame_io 1")
 699     dev.connect(ssid, raw_psk=psk, scan_freq="2412", wait_connect=False)
 700     addr = dev.p2p_interface_addr()
 701     if wpa2:
 702         rsne = binascii.unhexlify('30140100000fac040100000fac040100000fac020000')
 703     else:
 704         rsne = binascii.unhexlify('dd160050f20101000050f20201000050f20201000050f202')
 705     snonce = binascii.unhexlify('1111111111111111111111111111111111111111111111111111111111111111')
 706     return (bssid,ssid,hapd,snonce,pmk,addr,rsne)
 707
 708 def test_ap_wpa2_psk_ext_eapol(dev, apdev):
 709     """WPA2-PSK AP using external EAPOL supplicant"""
 710     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
 711
 712     msg = recv_eapol(hapd)
 713     anonce = msg['rsn_key_nonce']
 714     logger.info("Replay same data back")
 715     send_eapol(hapd, addr, build_eapol(msg))
 716
 717     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
 718
 719     logger.info("Truncated Key Data in EAPOL-Key msg 2/4")
 720     rsn_eapol_key_set(msg, 0x0101, 0, snonce, rsne)
 721     msg['length'] = 95 + 22 - 1
 722     send_eapol(hapd, addr, build_eapol(msg))
 723
 724     reply_eapol("2/4", hapd, addr, msg, 0x010a, snonce, rsne, kck)
 725
 726     msg = recv_eapol(hapd)
 727     if anonce != msg['rsn_key_nonce']:
 728         raise Exception("ANonce changed")
 729     logger.info("Replay same data back")
 730     send_eapol(hapd, addr, build_eapol(msg))
 731
 732     reply_eapol("4/4", hapd, addr, msg, 0x030a, None, None, kck)
 733     hapd_connected(hapd)
 734
 735 def test_ap_wpa2_psk_ext_eapol_retry1(dev, apdev):
 736     """WPA2 4-way handshake with EAPOL-Key 1/4 retransmitted"""
 737     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
 738
 739     msg1 = recv_eapol(hapd)
 740     anonce = msg1['rsn_key_nonce']
 741
 742     msg2 = recv_eapol(hapd)
 743     if anonce != msg2['rsn_key_nonce']:
 744         raise Exception("ANonce changed")
 745
 746     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
 747
 748     logger.info("Send EAPOL-Key msg 2/4")
 749     msg = msg2
 750     rsn_eapol_key_set(msg, 0x010a, 0, snonce, rsne)
 751     eapol_key_mic(kck, msg)
 752     send_eapol(hapd, addr, build_eapol(msg))
 753
 754     msg = recv_eapol(hapd)
 755     if anonce != msg['rsn_key_nonce']:
 756         raise Exception("ANonce changed")
 757
 758     reply_eapol("4/4", hapd, addr, msg, 0x030a, None, None, kck)
 759     hapd_connected(hapd)
 760
 761 def test_ap_wpa2_psk_ext_eapol_retry1b(dev, apdev):
 762     """WPA2 4-way handshake with EAPOL-Key 1/4 and 2/4 retransmitted"""
 763     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
 764
 765     msg1 = recv_eapol(hapd)
 766     anonce = msg1['rsn_key_nonce']
 767     msg2 = recv_eapol(hapd)
 768     if anonce != msg2['rsn_key_nonce']:
 769         raise Exception("ANonce changed")
 770
 771     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
 772     reply_eapol("2/4 (a)", hapd, addr, msg1, 0x010a, snonce, rsne, kck)
 773     reply_eapol("2/4 (b)", hapd, addr, msg2, 0x010a, snonce, rsne, kck)
 774
 775     msg = recv_eapol(hapd)
 776     if anonce != msg['rsn_key_nonce']:
 777         raise Exception("ANonce changed")
 778
 779     reply_eapol("4/4", hapd, addr, msg, 0x030a, None, None, kck)
 780     hapd_connected(hapd)
 781
 782 def test_ap_wpa2_psk_ext_eapol_retry1c(dev, apdev):
 783     """WPA2 4-way handshake with EAPOL-Key 1/4 and 2/4 retransmitted and SNonce changing"""
 784     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
 785
 786     msg1 = recv_eapol(hapd)
 787     anonce = msg1['rsn_key_nonce']
 788
 789     msg2 = recv_eapol(hapd)
 790     if anonce != msg2['rsn_key_nonce']:
 791         raise Exception("ANonce changed")
 792     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
 793     reply_eapol("2/4 (a)", hapd, addr, msg1, 0x010a, snonce, rsne, kck)
 794
 795     snonce2 = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
 796     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce2, anonce)
 797     reply_eapol("2/4 (b)", hapd, addr, msg2, 0x010a, snonce2, rsne, kck)
 798
 799     msg = recv_eapol(hapd)
 800     if anonce != msg['rsn_key_nonce']:
 801         raise Exception("ANonce changed")
 802     reply_eapol("4/4", hapd, addr, msg, 0x030a, None, None, kck)
 803     hapd_connected(hapd)
 804
 805 def test_ap_wpa2_psk_ext_eapol_retry1d(dev, apdev):
 806     """WPA2 4-way handshake with EAPOL-Key 1/4 and 2/4 retransmitted and SNonce changing and older used"""
 807     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
 808
 809     msg1 = recv_eapol(hapd)
 810     anonce = msg1['rsn_key_nonce']
 811     msg2 = recv_eapol(hapd)
 812     if anonce != msg2['rsn_key_nonce']:
 813         raise Exception("ANonce changed")
 814
 815     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
 816     reply_eapol("2/4 (a)", hapd, addr, msg1, 0x010a, snonce, rsne, kck)
 817
 818     snonce2 = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
 819     (ptk2, kck2, kek2) = pmk_to_ptk(pmk, addr, bssid, snonce2, anonce)
 820
 821     reply_eapol("2/4 (b)", hapd, addr, msg2, 0x010a, snonce2, rsne, kck2)
 822     msg = recv_eapol(hapd)
 823     if anonce != msg['rsn_key_nonce']:
 824         raise Exception("ANonce changed")
 825     reply_eapol("4/4", hapd, addr, msg, 0x030a, None, None, kck)
 826     hapd_connected(hapd)
 827
 828 def test_ap_wpa2_psk_ext_eapol_type_diff(dev, apdev):
 829     """WPA2 4-way handshake using external EAPOL supplicant"""
 830     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
 831
 832     msg = recv_eapol(hapd)
 833     anonce = msg['rsn_key_nonce']
 834
 835     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
 836
 837     # Incorrect descriptor type (frame dropped)
 838     msg['descr_type'] = 253
 839     rsn_eapol_key_set(msg, 0x010a, 0, snonce, rsne)
 840     eapol_key_mic(kck, msg)
 841     send_eapol(hapd, addr, build_eapol(msg))
 842
 843     # Incorrect descriptor type, but with a workaround (frame processed)
 844     msg['descr_type'] = 254
 845     rsn_eapol_key_set(msg, 0x010a, 0, snonce, rsne)
 846     eapol_key_mic(kck, msg)
 847     send_eapol(hapd, addr, build_eapol(msg))
 848
 849     msg = recv_eapol(hapd)
 850     if anonce != msg['rsn_key_nonce']:
 851         raise Exception("ANonce changed")
 852     logger.info("Replay same data back")
 853     send_eapol(hapd, addr, build_eapol(msg))
 854
 855     reply_eapol("4/4", hapd, addr, msg, 0x030a, None, None, kck)
 856     hapd_connected(hapd)
 857
 858 def test_ap_wpa_psk_ext_eapol(dev, apdev):
 859     """WPA2-PSK AP using external EAPOL supplicant"""
 860     (bssid,ssid,hapd,snonce,pmk,addr,wpae) = eapol_test(apdev[0], dev[0],
 861                                                         wpa2=False)
 862
 863     msg = recv_eapol(hapd)
 864     anonce = msg['rsn_key_nonce']
 865     logger.info("Replay same data back")
 866     send_eapol(hapd, addr, build_eapol(msg))
 867     logger.info("Too short data")
 868     send_eapol(hapd, addr, build_eapol(msg)[0:98])
 869
 870     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
 871     msg['descr_type'] = 2
 872     reply_eapol("2/4(invalid type)", hapd, addr, msg, 0x010a, snonce, wpae, kck)
 873     msg['descr_type'] = 254
 874     reply_eapol("2/4", hapd, addr, msg, 0x010a, snonce, wpae, kck)
 875
 876     msg = recv_eapol(hapd)
 877     if anonce != msg['rsn_key_nonce']:
 878         raise Exception("ANonce changed")
 879     logger.info("Replay same data back")
 880     send_eapol(hapd, addr, build_eapol(msg))
 881
 882     reply_eapol("4/4", hapd, addr, msg, 0x030a, None, None, kck)
 883     hapd_connected(hapd)
 884
 885 def test_ap_wpa2_psk_ext_eapol_key_info(dev, apdev):
 886     """WPA2-PSK 4-way handshake with strange key info values"""
 887     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
 888
 889     msg = recv_eapol(hapd)
 890     anonce = msg['rsn_key_nonce']
 891
 892     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
 893     rsn_eapol_key_set(msg, 0x0000, 0, snonce, rsne)
 894     send_eapol(hapd, addr, build_eapol(msg))
 895     rsn_eapol_key_set(msg, 0xffff, 0, snonce, rsne)
 896     send_eapol(hapd, addr, build_eapol(msg))
 897     # SMK M1
 898     rsn_eapol_key_set(msg, 0x2802, 0, snonce, rsne)
 899     send_eapol(hapd, addr, build_eapol(msg))
 900     # SMK M3
 901     rsn_eapol_key_set(msg, 0x2002, 0, snonce, rsne)
 902     send_eapol(hapd, addr, build_eapol(msg))
 903     # Request
 904     rsn_eapol_key_set(msg, 0x0902, 0, snonce, rsne)
 905     send_eapol(hapd, addr, build_eapol(msg))
 906     # Request
 907     rsn_eapol_key_set(msg, 0x0902, 0, snonce, rsne)
 908     tmp_kck = binascii.unhexlify('00000000000000000000000000000000')
 909     eapol_key_mic(tmp_kck, msg)
 910     send_eapol(hapd, addr, build_eapol(msg))
 911
 912     reply_eapol("2/4", hapd, addr, msg, 0x010a, snonce, rsne, kck)
 913
 914     msg = recv_eapol(hapd)
 915     if anonce != msg['rsn_key_nonce']:
 916         raise Exception("ANonce changed")
 917
 918     # Request (valic MIC)
 919     rsn_eapol_key_set(msg, 0x0902, 0, snonce, rsne)
 920     eapol_key_mic(kck, msg)
 921     send_eapol(hapd, addr, build_eapol(msg))
 922     # Request (valid MIC, replayed counter)
 923     rsn_eapol_key_set(msg, 0x0902, 0, snonce, rsne)
 924     eapol_key_mic(kck, msg)
 925     send_eapol(hapd, addr, build_eapol(msg))
 926
 927     reply_eapol("4/4", hapd, addr, msg, 0x030a, None, None, kck)
 928     hapd_connected(hapd)
 929
 930 def build_eapol_key_1_4(anonce, replay_counter=1, key_data='', key_len=16):
 931     msg = {}
 932     msg['version'] = 2
 933     msg['type'] = 3
 934     msg['length'] = 95 + len(key_data)
 935
 936     msg['descr_type'] = 2
 937     msg['rsn_key_info'] = 0x8a
 938     msg['rsn_key_len'] = key_len
 939     msg['rsn_replay_counter'] = struct.pack('>Q', replay_counter)
 940     msg['rsn_key_nonce'] = anonce
 941     msg['rsn_key_iv'] = binascii.unhexlify('00000000000000000000000000000000')
 942     msg['rsn_key_rsc'] = binascii.unhexlify('0000000000000000')
 943     msg['rsn_key_id'] = binascii.unhexlify('0000000000000000')
 944     msg['rsn_key_mic'] = binascii.unhexlify('00000000000000000000000000000000')
 945     msg['rsn_key_data_len'] = len(key_data)
 946     msg['rsn_key_data'] = key_data
 947     return msg
 948
 949 def build_eapol_key_3_4(anonce, kck, key_data, replay_counter=2,
 950                         key_info=0x13ca, extra_len=0, descr_type=2, key_len=16):
 951     msg = {}
 952     msg['version'] = 2
 953     msg['type'] = 3
 954     msg['length'] = 95 + len(key_data) + extra_len
 955
 956     msg['descr_type'] = descr_type
 957     msg['rsn_key_info'] = key_info
 958     msg['rsn_key_len'] = key_len
 959     msg['rsn_replay_counter'] = struct.pack('>Q', replay_counter)
 960     msg['rsn_key_nonce'] = anonce
 961     msg['rsn_key_iv'] = binascii.unhexlify('00000000000000000000000000000000')
 962     msg['rsn_key_rsc'] = binascii.unhexlify('0000000000000000')
 963     msg['rsn_key_id'] = binascii.unhexlify('0000000000000000')
 964     msg['rsn_key_data_len'] = len(key_data)
 965     msg['rsn_key_data'] = key_data
 966     eapol_key_mic(kck, msg)
 967     return msg
 968
 969 def aes_wrap(kek, plain):
 970     n = len(plain) / 8
 971     a = 0xa6a6a6a6a6a6a6a6
 972     enc = AES.new(kek).encrypt
 973     r = [plain[i * 8:(i + 1) * 8] for i in range(0, n)]
 974     for j in range(6):
 975         for i in range(1, n + 1):
 976             b = enc(struct.pack('>Q', a) + r[i - 1])
 977             a = struct.unpack('>Q', b[:8])[0] ^ (n * j + i)
 978             r[i - 1] =b[8:]
 979     return struct.pack('>Q', a) + ''.join(r)
 980
 981 def pad_key_data(plain):
 982     pad_len = len(plain) % 8
 983     if pad_len:
 984         pad_len = 8 - pad_len
 985         plain += '\xdd'
 986         pad_len -= 1
 987         plain += pad_len * '\0'
 988     return plain
 989
 990 def test_ap_wpa2_psk_supp_proto(dev, apdev):
 991     """WPA2-PSK 4-way handshake protocol testing for supplicant"""
 992     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
 993
 994     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
 995     msg = recv_eapol(hapd)
 996     dev[0].dump_monitor()
 997
 998     # Build own EAPOL-Key msg 1/4
 999     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1000     counter = 1
1001     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1002     counter += 1
1003     send_eapol(dev[0], addr, build_eapol(msg))
1004     msg = recv_eapol(dev[0])
1005     snonce = msg['rsn_key_nonce']
1006
1007     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1008
1009     logger.debug("Invalid AES wrap data length 0")
1010     dev[0].dump_monitor()
1011     msg = build_eapol_key_3_4(anonce, kck, '', replay_counter=counter)
1012     counter += 1
1013     send_eapol(dev[0], addr, build_eapol(msg))
1014     ev = dev[0].wait_event(["WPA: Unsupported AES-WRAP len 0"])
1015     if ev is None:
1016         raise Exception("Unsupported AES-WRAP len 0 not reported")
1017
1018     logger.debug("Invalid AES wrap data length 1")
1019     dev[0].dump_monitor()
1020     msg = build_eapol_key_3_4(anonce, kck, '1', replay_counter=counter)
1021     counter += 1
1022     send_eapol(dev[0], addr, build_eapol(msg))
1023     ev = dev[0].wait_event(["WPA: Unsupported AES-WRAP len 1"])
1024     if ev is None:
1025         raise Exception("Unsupported AES-WRAP len 1 not reported")
1026
1027     logger.debug("Invalid AES wrap data length 9")
1028     dev[0].dump_monitor()
1029     msg = build_eapol_key_3_4(anonce, kck, '123456789', replay_counter=counter)
1030     counter += 1
1031     send_eapol(dev[0], addr, build_eapol(msg))
1032     ev = dev[0].wait_event(["WPA: Unsupported AES-WRAP len 9"])
1033     if ev is None:
1034         raise Exception("Unsupported AES-WRAP len 9 not reported")
1035
1036     logger.debug("Invalid AES wrap data payload")
1037     dev[0].dump_monitor()
1038     msg = build_eapol_key_3_4(anonce, kck, '12345678', replay_counter=counter)
1039     # do not increment counter to test replay protection
1040     send_eapol(dev[0], addr, build_eapol(msg))
1041     ev = dev[0].wait_event(["WPA: AES unwrap failed"])
1042     if ev is None:
1043         raise Exception("AES unwrap failure not reported")
1044
1045     logger.debug("Replay Count not increasing")
1046     dev[0].dump_monitor()
1047     msg = build_eapol_key_3_4(anonce, kck, '12345678', replay_counter=counter)
1048     counter += 1
1049     send_eapol(dev[0], addr, build_eapol(msg))
1050     ev = dev[0].wait_event(["WPA: EAPOL-Key Replay Counter did not increase"])
1051     if ev is None:
1052         raise Exception("Replay Counter replay not reported")
1053
1054     logger.debug("Missing Ack bit in key info")
1055     dev[0].dump_monitor()
1056     msg = build_eapol_key_3_4(anonce, kck, '12345678', replay_counter=counter,
1057                               key_info=0x134a)
1058     counter += 1
1059     send_eapol(dev[0], addr, build_eapol(msg))
1060     ev = dev[0].wait_event(["WPA: No Ack bit in key_info"])
1061     if ev is None:
1062         raise Exception("Missing Ack bit not reported")
1063
1064     logger.debug("Unexpected Request bit in key info")
1065     dev[0].dump_monitor()
1066     msg = build_eapol_key_3_4(anonce, kck, '12345678', replay_counter=counter,
1067                               key_info=0x1bca)
1068     counter += 1
1069     send_eapol(dev[0], addr, build_eapol(msg))
1070     ev = dev[0].wait_event(["WPA: EAPOL-Key with Request bit"])
1071     if ev is None:
1072         raise Exception("Request bit not reported")
1073
1074     logger.debug("Unsupported key descriptor version 0")
1075     dev[0].dump_monitor()
1076     msg = build_eapol_key_3_4(anonce, kck, '0123456789abcdef',
1077                               replay_counter=counter, key_info=0x13c8)
1078     counter += 1
1079     send_eapol(dev[0], addr, build_eapol(msg))
1080     ev = dev[0].wait_event(["WPA: Unsupported EAPOL-Key descriptor version 0"])
1081     if ev is None:
1082         raise Exception("Unsupported EAPOL-Key descriptor version 0 not reported")
1083
1084     logger.debug("Key descriptor version 1 not allowed with CCMP")
1085     dev[0].dump_monitor()
1086     msg = build_eapol_key_3_4(anonce, kck, '0123456789abcdef',
1087                               replay_counter=counter, key_info=0x13c9)
1088     counter += 1
1089     send_eapol(dev[0], addr, build_eapol(msg))
1090     ev = dev[0].wait_event(["WPA: CCMP is used, but EAPOL-Key descriptor version (1) is not 2"])
1091     if ev is None:
1092         raise Exception("Not allowed EAPOL-Key descriptor version not reported")
1093
1094     logger.debug("Invalid AES wrap payload with key descriptor version 2")
1095     dev[0].dump_monitor()
1096     msg = build_eapol_key_3_4(anonce, kck, '0123456789abcdef',
1097                               replay_counter=counter, key_info=0x13ca)
1098     counter += 1
1099     send_eapol(dev[0], addr, build_eapol(msg))
1100     ev = dev[0].wait_event(["WPA: AES unwrap failed"])
1101     if ev is None:
1102         raise Exception("AES unwrap failure not reported")
1103
1104     logger.debug("Key descriptor version 3 workaround")
1105     dev[0].dump_monitor()
1106     msg = build_eapol_key_3_4(anonce, kck, '0123456789abcdef',
1107                               replay_counter=counter, key_info=0x13cb)
1108     counter += 1
1109     send_eapol(dev[0], addr, build_eapol(msg))
1110     ev = dev[0].wait_event(["WPA: CCMP is used, but EAPOL-Key descriptor version (3) is not 2"])
1111     if ev is None:
1112         raise Exception("CCMP key descriptor mismatch not reported")
1113     ev = dev[0].wait_event(["WPA: Interoperability workaround"])
1114     if ev is None:
1115         raise Exception("AES-128-CMAC workaround not reported")
1116     ev = dev[0].wait_event(["WPA: Invalid EAPOL-Key MIC - dropping packet"])
1117     if ev is None:
1118         raise Exception("MIC failure with AES-128-CMAC workaround not reported")
1119
1120     logger.debug("Unsupported key descriptor version 4")
1121     dev[0].dump_monitor()
1122     msg = build_eapol_key_3_4(anonce, kck, '0123456789abcdef',
1123                               replay_counter=counter, key_info=0x13cc)
1124     counter += 1
1125     send_eapol(dev[0], addr, build_eapol(msg))
1126     ev = dev[0].wait_event(["WPA: Unsupported EAPOL-Key descriptor version 4"])
1127     if ev is None:
1128         raise Exception("Unsupported EAPOL-Key descriptor version 4 not reported")
1129
1130     logger.debug("Unsupported key descriptor version 7")
1131     dev[0].dump_monitor()
1132     msg = build_eapol_key_3_4(anonce, kck, '0123456789abcdef',
1133                               replay_counter=counter, key_info=0x13cf)
1134     counter += 1
1135     send_eapol(dev[0], addr, build_eapol(msg))
1136     ev = dev[0].wait_event(["WPA: Unsupported EAPOL-Key descriptor version 7"])
1137     if ev is None:
1138         raise Exception("Unsupported EAPOL-Key descriptor version 7 not reported")
1139
1140     logger.debug("Too short EAPOL header length")
1141     dev[0].dump_monitor()
1142     msg = build_eapol_key_3_4(anonce, kck, '12345678', replay_counter=counter,
1143                               extra_len=-1)
1144     counter += 1
1145     send_eapol(dev[0], addr, build_eapol(msg))
1146     ev = dev[0].wait_event(["WPA: Invalid EAPOL-Key frame - key_data overflow (8 > 7)"])
1147     if ev is None:
1148         raise Exception("Key data overflow not reported")
1149
1150     logger.debug("Too long EAPOL header length")
1151     msg = build_eapol_key_3_4(anonce, kck, '12345678', replay_counter=counter,
1152                               extra_len=1)
1153     counter += 1
1154     send_eapol(dev[0], addr, build_eapol(msg))
1155
1156     logger.debug("Unsupported descriptor type 0")
1157     msg = build_eapol_key_3_4(anonce, kck, '12345678', replay_counter=counter,
1158                               descr_type=0)
1159     counter += 1
1160     send_eapol(dev[0], addr, build_eapol(msg))
1161
1162     logger.debug("WPA descriptor type 0")
1163     msg = build_eapol_key_3_4(anonce, kck, '12345678', replay_counter=counter,
1164                               descr_type=254)
1165     counter += 1
1166     send_eapol(dev[0], addr, build_eapol(msg))
1167
1168     logger.debug("Non-zero key index for pairwise key")
1169     dev[0].dump_monitor()
1170     wrapped = aes_wrap(kek, 16*'z')
1171     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter,
1172                               key_info=0x13ea)
1173     counter += 1
1174     send_eapol(dev[0], addr, build_eapol(msg))
1175     ev = dev[0].wait_event(["WPA: Ignored EAPOL-Key (Pairwise) with non-zero key index"])
1176     if ev is None:
1177         raise Exception("Non-zero key index not reported")
1178
1179     logger.debug("Invalid Key Data plaintext payload --> disconnect")
1180     dev[0].dump_monitor()
1181     wrapped = aes_wrap(kek, 16*'z')
1182     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter)
1183     counter += 1
1184     send_eapol(dev[0], addr, build_eapol(msg))
1185     dev[0].wait_disconnected(timeout=1)
1186
1187 def test_ap_wpa2_psk_supp_proto_no_ie(dev, apdev):
1188     """WPA2-PSK supplicant protocol testing: IE not included"""
1189     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1190
1191     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1192     msg = recv_eapol(hapd)
1193     dev[0].dump_monitor()
1194
1195     # Build own EAPOL-Key msg 1/4
1196     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1197     counter = 1
1198     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1199     counter += 1
1200     send_eapol(dev[0], addr, build_eapol(msg))
1201     msg = recv_eapol(dev[0])
1202     snonce = msg['rsn_key_nonce']
1203
1204     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1205
1206     logger.debug("No IEs in msg 3/4 --> disconnect")
1207     dev[0].dump_monitor()
1208     wrapped = aes_wrap(kek, 16*'\0')
1209     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter)
1210     counter += 1
1211     send_eapol(dev[0], addr, build_eapol(msg))
1212     dev[0].wait_disconnected(timeout=1)
1213
1214 def test_ap_wpa2_psk_supp_proto_ie_mismatch(dev, apdev):
1215     """WPA2-PSK supplicant protocol testing: IE mismatch"""
1216     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1217
1218     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1219     msg = recv_eapol(hapd)
1220     dev[0].dump_monitor()
1221
1222     # Build own EAPOL-Key msg 1/4
1223     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1224     counter = 1
1225     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1226     counter += 1
1227     send_eapol(dev[0], addr, build_eapol(msg))
1228     msg = recv_eapol(dev[0])
1229     snonce = msg['rsn_key_nonce']
1230
1231     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1232
1233     logger.debug("Msg 3/4 with mismatching IE")
1234     dev[0].dump_monitor()
1235     wrapped = aes_wrap(kek, pad_key_data(binascii.unhexlify('30060100000fac04dd16000fac010100dc11188831bf4aa4a8678d2b41498618')))
1236     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter)
1237     counter += 1
1238     send_eapol(dev[0], addr, build_eapol(msg))
1239     dev[0].wait_disconnected(timeout=1)
1240
1241 def test_ap_wpa2_psk_supp_proto_ok(dev, apdev):
1242     """WPA2-PSK supplicant protocol testing: success"""
1243     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1244
1245     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1246     msg = recv_eapol(hapd)
1247     dev[0].dump_monitor()
1248
1249     # Build own EAPOL-Key msg 1/4
1250     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1251     counter = 1
1252     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1253     counter += 1
1254     send_eapol(dev[0], addr, build_eapol(msg))
1255     msg = recv_eapol(dev[0])
1256     snonce = msg['rsn_key_nonce']
1257
1258     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1259
1260     logger.debug("Valid EAPOL-Key msg 3/4")
1261     dev[0].dump_monitor()
1262     plain = binascii.unhexlify('30140100000fac040100000fac040100000fac020c00dd16000fac010100dc11188831bf4aa4a8678d2b41498618')
1263     wrapped = aes_wrap(kek, pad_key_data(plain))
1264     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter)
1265     counter += 1
1266     send_eapol(dev[0], addr, build_eapol(msg))
1267     dev[0].wait_connected(timeout=1)
1268
1269 def test_ap_wpa2_psk_supp_proto_no_gtk(dev, apdev):
1270     """WPA2-PSK supplicant protocol testing: no GTK"""
1271     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1272
1273     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1274     msg = recv_eapol(hapd)
1275     dev[0].dump_monitor()
1276
1277     # Build own EAPOL-Key msg 1/4
1278     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1279     counter = 1
1280     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1281     counter += 1
1282     send_eapol(dev[0], addr, build_eapol(msg))
1283     msg = recv_eapol(dev[0])
1284     snonce = msg['rsn_key_nonce']
1285
1286     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1287
1288     logger.debug("EAPOL-Key msg 3/4 without GTK KDE")
1289     dev[0].dump_monitor()
1290     plain = binascii.unhexlify('30140100000fac040100000fac040100000fac020c00')
1291     wrapped = aes_wrap(kek, pad_key_data(plain))
1292     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter)
1293     counter += 1
1294     send_eapol(dev[0], addr, build_eapol(msg))
1295     ev = dev[0].wait_event(["CTRL-EVENT-CONNECTED"], timeout=0.1)
1296     if ev is not None:
1297         raise Exception("Unexpected connection completion reported")
1298
1299 def test_ap_wpa2_psk_supp_proto_anonce_change(dev, apdev):
1300     """WPA2-PSK supplicant protocol testing: ANonce change"""
1301     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1302
1303     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1304     msg = recv_eapol(hapd)
1305     dev[0].dump_monitor()
1306
1307     # Build own EAPOL-Key msg 1/4
1308     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1309     counter = 1
1310     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1311     counter += 1
1312     send_eapol(dev[0], addr, build_eapol(msg))
1313     msg = recv_eapol(dev[0])
1314     snonce = msg['rsn_key_nonce']
1315
1316     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1317
1318     logger.debug("Valid EAPOL-Key msg 3/4")
1319     dev[0].dump_monitor()
1320     anonce2 = binascii.unhexlify('3333333333333333333333333333333333333333333333333333333333333333')
1321     plain = binascii.unhexlify('30140100000fac040100000fac040100000fac020c00dd16000fac010100dc11188831bf4aa4a8678d2b41498618')
1322     wrapped = aes_wrap(kek, pad_key_data(plain))
1323     msg = build_eapol_key_3_4(anonce2, kck, wrapped, replay_counter=counter)
1324     counter += 1
1325     send_eapol(dev[0], addr, build_eapol(msg))
1326     ev = dev[0].wait_event(["WPA: ANonce from message 1 of 4-Way Handshake differs from 3 of 4-Way Handshake"])
1327     if ev is None:
1328         raise Exception("ANonce change not reported")
1329
1330 def test_ap_wpa2_psk_supp_proto_unexpected_group_msg(dev, apdev):
1331     """WPA2-PSK supplicant protocol testing: unexpected group message"""
1332     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1333
1334     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1335     msg = recv_eapol(hapd)
1336     dev[0].dump_monitor()
1337
1338     # Build own EAPOL-Key msg 1/4
1339     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1340     counter = 1
1341     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1342     counter += 1
1343     send_eapol(dev[0], addr, build_eapol(msg))
1344     msg = recv_eapol(dev[0])
1345     snonce = msg['rsn_key_nonce']
1346
1347     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1348
1349     logger.debug("Group key 1/2 instead of msg 3/4")
1350     dev[0].dump_monitor()
1351     wrapped = aes_wrap(kek, binascii.unhexlify('dd16000fac010100dc11188831bf4aa4a8678d2b41498618'))
1352     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter,
1353                               key_info=0x13c2)
1354     counter += 1
1355     send_eapol(dev[0], addr, build_eapol(msg))
1356     ev = dev[0].wait_event(["WPA: Group Key Handshake started prior to completion of 4-way handshake"])
1357     if ev is None:
1358         raise Exception("Unexpected group key message not reported")
1359     dev[0].wait_disconnected(timeout=1)
1360
1361 def test_ap_wpa2_psk_supp_proto_msg_1_invalid_kde(dev, apdev):
1362     """WPA2-PSK supplicant protocol testing: invalid KDE in msg 1/4"""
1363     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1364
1365     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1366     msg = recv_eapol(hapd)
1367     dev[0].dump_monitor()
1368
1369     # Build own EAPOL-Key msg 1/4 with invalid KDE
1370     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1371     counter = 1
1372     msg = build_eapol_key_1_4(anonce, replay_counter=counter,
1373                               key_data=binascii.unhexlify('5555'))
1374     counter += 1
1375     send_eapol(dev[0], addr, build_eapol(msg))
1376     dev[0].wait_disconnected(timeout=1)
1377
1378 def test_ap_wpa2_psk_supp_proto_wrong_pairwise_key_len(dev, apdev):
1379     """WPA2-PSK supplicant protocol testing: wrong pairwise key length"""
1380     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1381
1382     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1383     msg = recv_eapol(hapd)
1384     dev[0].dump_monitor()
1385
1386     # Build own EAPOL-Key msg 1/4
1387     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1388     counter = 1
1389     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1390     counter += 1
1391     send_eapol(dev[0], addr, build_eapol(msg))
1392     msg = recv_eapol(dev[0])
1393     snonce = msg['rsn_key_nonce']
1394
1395     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1396
1397     logger.debug("Valid EAPOL-Key msg 3/4")
1398     dev[0].dump_monitor()
1399     plain = binascii.unhexlify('30140100000fac040100000fac040100000fac020c00dd16000fac010100dc11188831bf4aa4a8678d2b41498618')
1400     wrapped = aes_wrap(kek, pad_key_data(plain))
1401     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter,
1402                               key_len=15)
1403     counter += 1
1404     send_eapol(dev[0], addr, build_eapol(msg))
1405     ev = dev[0].wait_event(["WPA: Invalid CCMP key length 15"])
1406     if ev is None:
1407         raise Exception("Invalid CCMP key length not reported")
1408     dev[0].wait_disconnected(timeout=1)
1409
1410 def test_ap_wpa2_psk_supp_proto_wrong_group_key_len(dev, apdev):
1411     """WPA2-PSK supplicant protocol testing: wrong group key length"""
1412     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1413
1414     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1415     msg = recv_eapol(hapd)
1416     dev[0].dump_monitor()
1417
1418     # Build own EAPOL-Key msg 1/4
1419     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1420     counter = 1
1421     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1422     counter += 1
1423     send_eapol(dev[0], addr, build_eapol(msg))
1424     msg = recv_eapol(dev[0])
1425     snonce = msg['rsn_key_nonce']
1426
1427     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1428
1429     logger.debug("Valid EAPOL-Key msg 3/4")
1430     dev[0].dump_monitor()
1431     plain = binascii.unhexlify('30140100000fac040100000fac040100000fac020c00dd15000fac010100dc11188831bf4aa4a8678d2b414986')
1432     wrapped = aes_wrap(kek, pad_key_data(plain))
1433     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter)
1434     counter += 1
1435     send_eapol(dev[0], addr, build_eapol(msg))
1436     ev = dev[0].wait_event(["WPA: Unsupported CCMP Group Cipher key length 15"])
1437     if ev is None:
1438         raise Exception("Invalid CCMP key length not reported")
1439     dev[0].wait_disconnected(timeout=1)
1440
1441 def test_ap_wpa2_psk_supp_proto_gtk_tx_bit_workaround(dev, apdev):
1442     """WPA2-PSK supplicant protocol testing: GTK TX bit workaround"""
1443     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1444
1445     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1446     msg = recv_eapol(hapd)
1447     dev[0].dump_monitor()
1448
1449     # Build own EAPOL-Key msg 1/4
1450     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1451     counter = 1
1452     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1453     counter += 1
1454     send_eapol(dev[0], addr, build_eapol(msg))
1455     msg = recv_eapol(dev[0])
1456     snonce = msg['rsn_key_nonce']
1457
1458     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1459
1460     logger.debug("Valid EAPOL-Key msg 3/4")
1461     dev[0].dump_monitor()
1462     plain = binascii.unhexlify('30140100000fac040100000fac040100000fac020c00dd16000fac010500dc11188831bf4aa4a8678d2b41498618')
1463     wrapped = aes_wrap(kek, pad_key_data(plain))
1464     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter)
1465     counter += 1
1466     send_eapol(dev[0], addr, build_eapol(msg))
1467     ev = dev[0].wait_event(["WPA: Tx bit set for GTK, but pairwise keys are used - ignore Tx bit"])
1468     if ev is None:
1469         raise Exception("GTK Tx bit workaround not reported")
1470     dev[0].wait_connected(timeout=1)
1471
1472 def test_ap_wpa2_psk_supp_proto_gtk_keyidx_0_and_3(dev, apdev):
1473     """WPA2-PSK supplicant protocol testing: GTK key index 0 and 3"""
1474     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1475
1476     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1477     msg = recv_eapol(hapd)
1478     dev[0].dump_monitor()
1479
1480     # Build own EAPOL-Key msg 1/4
1481     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1482     counter = 1
1483     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1484     counter += 1
1485     send_eapol(dev[0], addr, build_eapol(msg))
1486     msg = recv_eapol(dev[0])
1487     snonce = msg['rsn_key_nonce']
1488
1489     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1490
1491     logger.debug("Valid EAPOL-Key msg 3/4 (GTK keyidx 0)")
1492     dev[0].dump_monitor()
1493     plain = binascii.unhexlify('30140100000fac040100000fac040100000fac020c00dd16000fac010000dc11188831bf4aa4a8678d2b41498618')
1494     wrapped = aes_wrap(kek, pad_key_data(plain))
1495     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter)
1496     counter += 1
1497     send_eapol(dev[0], addr, build_eapol(msg))
1498     dev[0].wait_connected(timeout=1)
1499
1500     logger.debug("Valid EAPOL-Key group msg 1/2 (GTK keyidx 3)")
1501     dev[0].dump_monitor()
1502     plain = binascii.unhexlify('dd16000fac010300dc11188831bf4aa4a8678d2b41498618')
1503     wrapped = aes_wrap(kek, pad_key_data(plain))
1504     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter,
1505                               key_info=0x13c2)
1506     counter += 1
1507     send_eapol(dev[0], addr, build_eapol(msg))
1508     msg = recv_eapol(dev[0])
1509     ev = dev[0].wait_event(["WPA: Group rekeying completed"])
1510     if ev is None:
1511         raise Exception("GTK rekeing not reported")
1512
1513     logger.debug("Unencrypted GTK KDE in group msg 1/2")
1514     dev[0].dump_monitor()
1515     plain = binascii.unhexlify('dd16000fac010300dc11188831bf4aa4a8678d2b41498618')
1516     msg = build_eapol_key_3_4(anonce, kck, plain, replay_counter=counter,
1517                               key_info=0x03c2)
1518     counter += 1
1519     send_eapol(dev[0], addr, build_eapol(msg))
1520     ev = dev[0].wait_event(["WPA: GTK IE in unencrypted key data"])
1521     if ev is None:
1522         raise Exception("Unencrypted GTK KDE not reported")
1523     dev[0].wait_disconnected(timeout=1)
1524
1525 def test_ap_wpa2_psk_supp_proto_no_gtk_in_group_msg(dev, apdev):
1526     """WPA2-PSK supplicant protocol testing: GTK KDE missing from group msg"""
1527     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1528
1529     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1530     msg = recv_eapol(hapd)
1531     dev[0].dump_monitor()
1532
1533     # Build own EAPOL-Key msg 1/4
1534     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1535     counter = 1
1536     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1537     counter += 1
1538     send_eapol(dev[0], addr, build_eapol(msg))
1539     msg = recv_eapol(dev[0])
1540     snonce = msg['rsn_key_nonce']
1541
1542     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1543
1544     logger.debug("Valid EAPOL-Key msg 3/4 (GTK keyidx 0)")
1545     dev[0].dump_monitor()
1546     plain = binascii.unhexlify('30140100000fac040100000fac040100000fac020c00dd16000fac010000dc11188831bf4aa4a8678d2b41498618')
1547     wrapped = aes_wrap(kek, pad_key_data(plain))
1548     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter)
1549     counter += 1
1550     send_eapol(dev[0], addr, build_eapol(msg))
1551     dev[0].wait_connected(timeout=1)
1552
1553     logger.debug("No GTK KDE in EAPOL-Key group msg 1/2")
1554     dev[0].dump_monitor()
1555     plain = binascii.unhexlify('dd00dd00dd00dd00dd00dd00dd00dd00')
1556     wrapped = aes_wrap(kek, pad_key_data(plain))
1557     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter,
1558                               key_info=0x13c2)
1559     counter += 1
1560     send_eapol(dev[0], addr, build_eapol(msg))
1561     ev = dev[0].wait_event(["WPA: No GTK IE in Group Key msg 1/2"])
1562     if ev is None:
1563         raise Exception("Missing GTK KDE not reported")
1564     dev[0].wait_disconnected(timeout=1)
1565
1566 def test_ap_wpa2_psk_supp_proto_too_long_gtk_in_group_msg(dev, apdev):
1567     """WPA2-PSK supplicant protocol testing: too long GTK KDE in group msg"""
1568     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1569
1570     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1571     msg = recv_eapol(hapd)
1572     dev[0].dump_monitor()
1573
1574     # Build own EAPOL-Key msg 1/4
1575     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1576     counter = 1
1577     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1578     counter += 1
1579     send_eapol(dev[0], addr, build_eapol(msg))
1580     msg = recv_eapol(dev[0])
1581     snonce = msg['rsn_key_nonce']
1582
1583     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1584
1585     logger.debug("Valid EAPOL-Key msg 3/4 (GTK keyidx 0)")
1586     dev[0].dump_monitor()
1587     plain = binascii.unhexlify('30140100000fac040100000fac040100000fac020c00dd16000fac010000dc11188831bf4aa4a8678d2b41498618')
1588     wrapped = aes_wrap(kek, pad_key_data(plain))
1589     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter)
1590     counter += 1
1591     send_eapol(dev[0], addr, build_eapol(msg))
1592     dev[0].wait_connected(timeout=1)
1593
1594     logger.debug("EAPOL-Key group msg 1/2 with too long GTK KDE")
1595     dev[0].dump_monitor()
1596     plain = binascii.unhexlify('dd27000fac010100ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
1597     wrapped = aes_wrap(kek, pad_key_data(plain))
1598     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter,
1599                               key_info=0x13c2)
1600     counter += 1
1601     send_eapol(dev[0], addr, build_eapol(msg))
1602     ev = dev[0].wait_event(["WPA: Unsupported CCMP Group Cipher key length 33"])
1603     if ev is None:
1604         raise Exception("Too long GTK KDE not reported")
1605     dev[0].wait_disconnected(timeout=1)
1606
1607 def test_ap_wpa2_psk_supp_proto_too_long_gtk_kde(dev, apdev):
1608     """WPA2-PSK supplicant protocol testing: too long GTK KDE"""
1609     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1610
1611     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1612     msg = recv_eapol(hapd)
1613     dev[0].dump_monitor()
1614
1615     # Build own EAPOL-Key msg 1/4
1616     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1617     counter = 1
1618     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1619     counter += 1
1620     send_eapol(dev[0], addr, build_eapol(msg))
1621     msg = recv_eapol(dev[0])
1622     snonce = msg['rsn_key_nonce']
1623
1624     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1625
1626     logger.debug("EAPOL-Key msg 3/4 with too short GTK KDE")
1627     dev[0].dump_monitor()
1628     plain = binascii.unhexlify('30140100000fac040100000fac040100000fac020c00dd27000fac010100ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
1629     wrapped = aes_wrap(kek, pad_key_data(plain))
1630     msg = build_eapol_key_3_4(anonce, kck, wrapped, replay_counter=counter)
1631     counter += 1
1632     send_eapol(dev[0], addr, build_eapol(msg))
1633     dev[0].wait_disconnected(timeout=1)
1634
1635 def test_ap_wpa2_psk_supp_proto_gtk_not_encrypted(dev, apdev):
1636     """WPA2-PSK supplicant protocol testing: GTK KDE not encrypted"""
1637     (bssid,ssid,hapd,snonce,pmk,addr,rsne) = eapol_test(apdev[0], dev[0])
1638
1639     # Wait for EAPOL-Key msg 1/4 from hostapd to determine when associated
1640     msg = recv_eapol(hapd)
1641     dev[0].dump_monitor()
1642
1643     # Build own EAPOL-Key msg 1/4
1644     anonce = binascii.unhexlify('2222222222222222222222222222222222222222222222222222222222222222')
1645     counter = 1
1646     msg = build_eapol_key_1_4(anonce, replay_counter=counter)
1647     counter += 1
1648     send_eapol(dev[0], addr, build_eapol(msg))
1649     msg = recv_eapol(dev[0])
1650     snonce = msg['rsn_key_nonce']
1651
1652     (ptk, kck, kek) = pmk_to_ptk(pmk, addr, bssid, snonce, anonce)
1653
1654     logger.debug("Valid EAPOL-Key msg 3/4")
1655     dev[0].dump_monitor()
1656     plain = binascii.unhexlify('30140100000fac040100000fac040100000fac020c00dd16000fac010100dc11188831bf4aa4a8678d2b41498618')
1657     msg = build_eapol_key_3_4(anonce, kck, plain, replay_counter=counter,
1658                               key_info=0x03ca)
1659     counter += 1
1660     send_eapol(dev[0], addr, build_eapol(msg))
1661     ev = dev[0].wait_event(["WPA: GTK IE in unencrypted key data"])
1662     if ev is None:
1663         raise Exception("Unencrypted GTK KDE not reported")
1664     dev[0].wait_disconnected(timeout=1)
1665
1666 def find_wpas_process(dev):
1667     ifname = dev.ifname
1668     cmd = subprocess.Popen(['ps', 'ax'], stdout=subprocess.PIPE)
1669     (data,err) = cmd.communicate()
1670     for l in data.splitlines():
1671         if "wpa_supplicant" not in l:
1672             continue
1673         if "-i" + ifname not in l:
1674             continue
1675         return int(l.strip().split(' ')[0])
1676     raise Exception("Could not find wpa_supplicant process")
1677
1678 def read_process_memory(pid, key=None):
1679     buf = bytes()
1680     with open('/proc/%d/maps' % pid, 'r') as maps, \
1681          open('/proc/%d/mem' % pid, 'r') as mem:
1682         for l in maps.readlines():
1683             m = re.match(r'([0-9a-f]+)-([0-9a-f]+) ([-r][-w][-x][-p])', l)
1684             if not m:
1685                 continue
1686             start = int(m.group(1), 16)
1687             end = int(m.group(2), 16)
1688             perm = m.group(3)
1689             if start > 0xffffffffffff:
1690                 continue
1691             if end < start:
1692                 continue
1693             if not perm.startswith('rw'):
1694                 continue
1695             mem.seek(start)
1696             data = mem.read(end - start)
1697             buf += data
1698             if key and key in data:
1699                 logger.info("Key found in " + l)
1700     return buf
1701
1702 def verify_not_present(buf, key, fname, keyname):
1703     pos = buf.find(key)
1704     if pos < 0:
1705         return
1706
1707     prefix = 2048 if pos > 2048 else pos
1708     with open(fname + keyname, 'w') as f:
1709         f.write(buf[pos - prefix:pos + 2048])
1710     raise Exception(keyname + " found after disassociation")
1711
1712 def get_key_locations(buf, key, keyname):
1713     count = 0
1714     pos = 0
1715     while True:
1716         pos = buf.find(key, pos)
1717         if pos < 0:
1718             break
1719         logger.info("Found %s at %d" % (keyname, pos))
1720         count += 1
1721         pos += len(key)
1722     return count
1723
1724 def test_wpa2_psk_key_lifetime_in_memory(dev, apdev, params):
1725     """WPA2-PSK and PSK/PTK lifetime in memory"""
1726     ssid = "test-wpa2-psk"
1727     passphrase = 'qwertyuiop'
1728     psk = '602e323e077bc63bd80307ef4745b754b0ae0a925c2638ecd13a794b9527b9e6'
1729     pmk = binascii.unhexlify(psk)
1730     p = hostapd.wpa2_params(ssid=ssid)
1731     p['wpa_psk'] = psk
1732     hapd = hostapd.add_ap(apdev[0]['ifname'], p)
1733
1734     pid = find_wpas_process(dev[0])
1735
1736     id = dev[0].connect(ssid, raw_psk=psk, scan_freq="2412",
1737                         only_add_network=True)
1738
1739     logger.info("Checking keys in memory after network profile configuration")
1740     buf = read_process_memory(pid, pmk)
1741     get_key_locations(buf, pmk, "PMK")
1742
1743     dev[0].request("REMOVE_NETWORK all")
1744     logger.info("Checking keys in memory after network profile removal")
1745     buf = read_process_memory(pid, pmk)
1746     get_key_locations(buf, pmk, "PMK")
1747
1748     id = dev[0].connect(ssid, psk=passphrase, scan_freq="2412",
1749                         only_add_network=True)
1750
1751     logger.info("Checking keys in memory before connection")
1752     buf = read_process_memory(pid, pmk)
1753     get_key_locations(buf, pmk, "PMK")
1754
1755     dev[0].connect_network(id, timeout=20)
1756     time.sleep(1)
1757
1758     buf = read_process_memory(pid, pmk)
1759
1760     dev[0].request("DISCONNECT")
1761     dev[0].wait_disconnected()
1762
1763     dev[0].relog()
1764     ptk = None
1765     gtk = None
1766     with open(os.path.join(params['logdir'], 'log0'), 'r') as f:
1767         for l in f.readlines():
1768             if "WPA: PTK - hexdump" in l:
1769                 val = l.strip().split(':')[3].replace(' ', '')
1770                 ptk = binascii.unhexlify(val)
1771             if "WPA: Group Key - hexdump" in l:
1772                 val = l.strip().split(':')[3].replace(' ', '')
1773                 gtk = binascii.unhexlify(val)
1774     if not pmk or not ptk or not gtk:
1775         raise Exception("Could not find keys from debug log")
1776     if len(gtk) != 16:
1777         raise Exception("Unexpected GTK length")
1778
1779     kck = ptk[0:16]
1780     kek = ptk[16:32]
1781     tk = ptk[32:48]
1782
1783     logger.info("Checking keys in memory while associated")
1784     get_key_locations(buf, pmk, "PMK")
1785     if pmk not in buf:
1786         raise HwsimSkip("PMK not found while associated")
1787     if kck not in buf:
1788         raise Exception("KCK not found while associated")
1789     if kek not in buf:
1790         raise Exception("KEK not found while associated")
1791     if tk in buf:
1792         raise Exception("TK found from memory")
1793     if gtk in buf:
1794         raise Exception("GTK found from memory")
1795
1796     logger.info("Checking keys in memory after disassociation")
1797     buf = read_process_memory(pid, pmk)
1798     get_key_locations(buf, pmk, "PMK")
1799
1800     # Note: PMK/PSK is still present in network configuration
1801
1802     fname = os.path.join(params['logdir'],
1803                          'wpa2_psk_key_lifetime_in_memory.memctx-')
1804     verify_not_present(buf, kck, fname, "KCK")
1805     verify_not_present(buf, kek, fname, "KEK")
1806     verify_not_present(buf, tk, fname, "TK")
1807     verify_not_present(buf, gtk, fname, "GTK")
1808
1809     dev[0].request("REMOVE_NETWORK all")
1810
1811     logger.info("Checking keys in memory after network profile removal")
1812     buf = read_process_memory(pid, pmk)
1813     get_key_locations(buf, pmk, "PMK")
1814
1815     verify_not_present(buf, pmk, fname, "PMK")
1816     verify_not_present(buf, kck, fname, "KCK")
1817     verify_not_present(buf, kek, fname, "KEK")
1818     verify_not_present(buf, tk, fname, "TK")
1819     verify_not_present(buf, gtk, fname, "GTK")
1820
1821 def test_ap_wpa2_psk_wep(dev, apdev):
1822     """WPA2-PSK AP and WEP enabled"""
1823     ssid = "test-wpa2-psk"
1824     passphrase = 'qwertyuiop'
1825     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
1826     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
1827     try:
1828         hapd.set('wep_key0', '"hello"')
1829         raise Exception("WEP key accepted to WPA2 network")
1830     except Exception:
1831         pass
1832
1833 def test_ap_wpa2_psk_wpas_in_bridge(dev, apdev):
1834     """WPA2-PSK AP and wpas interface in a bridge"""
1835     br_ifname='sta-br0'
1836     ifname='wlan5'
1837     try:
1838         _test_ap_wpa2_psk_wpas_in_bridge(dev, apdev)
1839     finally:
1840         subprocess.call(['ip', 'link', 'set', 'dev', br_ifname, 'down'])
1841         subprocess.call(['brctl', 'delif', br_ifname, ifname])
1842         subprocess.call(['brctl', 'delbr', br_ifname])
1843         subprocess.call(['iw', ifname, 'set', '4addr', 'off'])
1844
1845 def _test_ap_wpa2_psk_wpas_in_bridge(dev, apdev):
1846     ssid = "test-wpa2-psk"
1847     passphrase = 'qwertyuiop'
1848     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
1849     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
1850
1851     br_ifname='sta-br0'
1852     ifname='wlan5'
1853     wpas = WpaSupplicant(global_iface='/tmp/wpas-wlan5')
1854     subprocess.call(['brctl', 'addbr', br_ifname])
1855     subprocess.call(['brctl', 'setfd', br_ifname, '0'])
1856     subprocess.call(['ip', 'link', 'set', 'dev', br_ifname, 'up'])
1857     subprocess.call(['iw', ifname, 'set', '4addr', 'on'])
1858     subprocess.check_call(['brctl', 'addif', br_ifname, ifname])
1859     wpas.interface_add(ifname, br_ifname=br_ifname)
1860     wpas.dump_monitor()
1861
1862     wpas.connect(ssid, psk=passphrase, scan_freq="2412")
1863     wpas.dump_monitor()
1864
1865 def test_ap_wpa2_psk_ifdown(dev, apdev):
1866     """AP with open mode and external ifconfig down"""
1867     ssid = "test-wpa2-psk"
1868     passphrase = 'qwertyuiop'
1869     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
1870     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
1871     bssid = apdev[0]['bssid']
1872
1873     dev[0].connect(ssid, psk=passphrase, scan_freq="2412")
1874     subprocess.call(['ip', 'link', 'set', 'dev', apdev[0]['ifname'], 'down'])
1875     ev = hapd.wait_event(["INTERFACE-DISABLED"], timeout=10)
1876     if ev is None:
1877         raise Exception("No INTERFACE-DISABLED event")
1878     # this wait tests beacon loss detection in mac80211
1879     dev[0].wait_disconnected()
1880     subprocess.call(['ip', 'link', 'set', 'dev', apdev[0]['ifname'], 'up'])
1881     ev = hapd.wait_event(["INTERFACE-ENABLED"], timeout=10)
1882     if ev is None:
1883         raise Exception("No INTERFACE-ENABLED event")
1884     dev[0].wait_connected()
1885     hwsim_utils.test_connectivity(dev[0], hapd)
1886
1887 def test_ap_wpa2_psk_drop_first_msg_4(dev, apdev):
1888     """WPA2-PSK and first EAPOL-Key msg 4/4 dropped"""
1889     bssid = apdev[0]['bssid']
1890     ssid = "test-wpa2-psk"
1891     passphrase = 'qwertyuiop'
1892     psk = '602e323e077bc63bd80307ef4745b754b0ae0a925c2638ecd13a794b9527b9e6'
1893     params = hostapd.wpa2_params(ssid=ssid)
1894     params['wpa_psk'] = psk
1895     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
1896     hapd.request("SET ext_eapol_frame_io 1")
1897     dev[0].request("SET ext_eapol_frame_io 1")
1898     dev[0].connect(ssid, psk=passphrase, scan_freq="2412", wait_connect=False)
1899     addr = dev[0].own_addr()
1900
1901     # EAPOL-Key msg 1/4
1902     ev = hapd.wait_event(["EAPOL-TX"], timeout=15)
1903     if ev is None:
1904         raise Exception("Timeout on EAPOL-TX from hostapd")
1905     res = dev[0].request("EAPOL_RX " + bssid + " " + ev.split(' ')[2])
1906     if "OK" not in res:
1907         raise Exception("EAPOL_RX to wpa_supplicant failed")
1908
1909     # EAPOL-Key msg 2/4
1910     ev = dev[0].wait_event(["EAPOL-TX"], timeout=15)
1911     if ev is None:
1912         raise Exception("Timeout on EAPOL-TX from wpa_supplicant")
1913     res = hapd.request("EAPOL_RX " + addr + " " + ev.split(' ')[2])
1914     if "OK" not in res:
1915         raise Exception("EAPOL_RX to hostapd failed")
1916
1917     # EAPOL-Key msg 3/4
1918     ev = hapd.wait_event(["EAPOL-TX"], timeout=15)
1919     if ev is None:
1920         raise Exception("Timeout on EAPOL-TX from hostapd")
1921     res = dev[0].request("EAPOL_RX " + bssid + " " + ev.split(' ')[2])
1922     if "OK" not in res:
1923         raise Exception("EAPOL_RX to wpa_supplicant failed")
1924
1925     # EAPOL-Key msg 4/4
1926     ev = dev[0].wait_event(["EAPOL-TX"], timeout=15)
1927     if ev is None:
1928         raise Exception("Timeout on EAPOL-TX from wpa_supplicant")
1929     logger.info("Drop the first EAPOL-Key msg 4/4")
1930
1931     # wpa_supplicant believes now that 4-way handshake succeeded; hostapd
1932     # doesn't. Use normal EAPOL TX/RX to handle retries.
1933     hapd.request("SET ext_eapol_frame_io 0")
1934     dev[0].request("SET ext_eapol_frame_io 0")
1935     dev[0].wait_connected()
1936
1937     ev = hapd.wait_event(["AP-STA-CONNECTED"], timeout=15)
1938     if ev is None:
1939         raise Exception("Timeout on AP-STA-CONNECTED from hostapd")
1940
1941     ev = dev[0].wait_event(["CTRL-EVENT-DISCONNECTED"], timeout=0.1)
1942     if ev is not None:
1943         logger.info("Disconnection detected")
1944         # The EAPOL-Key retries are supposed to allow the connection to be
1945         # established without having to reassociate. However, this does not
1946         # currently work since mac80211 ends up encrypting EAPOL-Key msg 4/4
1947         # after the pairwise key has been configured and AP will drop those and
1948         # disconnect the station after reaching retransmission limit. Connection
1949         # is then established after reassociation. Once that behavior has been
1950         # optimized to prevent EAPOL-Key frame encryption for retransmission
1951         # case, this exception can be uncommented here.
1952         #raise Exception("Unexpected disconnection")
1953
1954 def test_ap_wpa2_psk_disable_enable(dev, apdev):
1955     """WPA2-PSK AP getting disabled and re-enabled"""
1956     ssid = "test-wpa2-psk"
1957     passphrase = 'qwertyuiop'
1958     psk = '602e323e077bc63bd80307ef4745b754b0ae0a925c2638ecd13a794b9527b9e6'
1959     params = hostapd.wpa2_params(ssid=ssid)
1960     params['wpa_psk'] = psk
1961     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
1962     dev[0].connect(ssid, raw_psk=psk, scan_freq="2412")
1963
1964     for i in range(2):
1965         hapd.request("DISABLE")
1966         dev[0].wait_disconnected()
1967         hapd.request("ENABLE")
1968         dev[0].wait_connected()
1969         hwsim_utils.test_connectivity(dev[0], hapd)
1970
1971 def test_ap_wpa2_psk_incorrect_passphrase(dev, apdev):
1972     """WPA2-PSK AP and station using incorrect passphrase"""
1973     ssid = "test-wpa2-psk"
1974     passphrase = 'qwertyuiop'
1975     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
1976     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
1977     dev[0].connect(ssid, psk="incorrect passphrase", scan_freq="2412",
1978                    wait_connect=False)
1979     ev = hapd.wait_event(["AP-STA-POSSIBLE-PSK-MISMATCH"], timeout=10)
1980     if ev is None:
1981         raise Exception("No AP-STA-POSSIBLE-PSK-MISMATCH reported")
1982     dev[0].dump_monitor()
1983
1984     hapd.disable()
1985     hapd.set("wpa_passphrase", "incorrect passphrase")
1986     hapd.enable()
1987
1988     dev[0].wait_connected(timeout=20)
1989
1990 def test_ap_wpa_ie_parsing(dev, apdev):
1991     """WPA IE parsing"""
1992     skip_with_fips(dev[0])
1993     ssid = "test-wpa-psk"
1994     passphrase = 'qwertyuiop'
1995     params = hostapd.wpa_params(ssid=ssid, passphrase=passphrase)
1996     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
1997     id = dev[0].connect(ssid, psk=passphrase, scan_freq="2412",
1998                         only_add_network=True)
1999
2000     tests = [ "dd040050f201",
2001               "dd050050f20101",
2002               "dd060050f2010100",
2003               "dd060050f2010001",
2004               "dd070050f201010000",
2005               "dd080050f20101000050",
2006               "dd090050f20101000050f2",
2007               "dd0a0050f20101000050f202",
2008               "dd0b0050f20101000050f20201",
2009               "dd0c0050f20101000050f2020100",
2010               "dd0c0050f20101000050f2020000",
2011               "dd0c0050f20101000050f202ffff",
2012               "dd0d0050f20101000050f202010000",
2013               "dd0e0050f20101000050f20201000050",
2014               "dd0f0050f20101000050f20201000050f2",
2015               "dd100050f20101000050f20201000050f202",
2016               "dd110050f20101000050f20201000050f20201",
2017               "dd120050f20101000050f20201000050f2020100",
2018               "dd120050f20101000050f20201000050f2020000",
2019               "dd120050f20101000050f20201000050f202ffff",
2020               "dd130050f20101000050f20201000050f202010000",
2021               "dd140050f20101000050f20201000050f20201000050",
2022               "dd150050f20101000050f20201000050f20201000050f2" ]
2023     for t in tests:
2024         try:
2025             if "OK" not in dev[0].request("VENDOR_ELEM_ADD 13 " + t):
2026                 raise Exception("VENDOR_ELEM_ADD failed")
2027             dev[0].select_network(id)
2028             ev = dev[0].wait_event(["CTRL-EVENT-ASSOC-REJECT"], timeout=10)
2029             if ev is None:
2030                 raise Exception("Association rejection not reported")
2031             dev[0].request("DISCONNECT")
2032         finally:
2033             dev[0].request("VENDOR_ELEM_REMOVE 13 *")
2034
2035     tests = [ "dd170050f20101000050f20201000050f20201000050f202ff",
2036               "dd180050f20101000050f20201000050f20201000050f202ffff",
2037               "dd190050f20101000050f20201000050f20201000050f202ffffff" ]
2038     for t in tests:
2039         try:
2040             if "OK" not in dev[0].request("VENDOR_ELEM_ADD 13 " + t):
2041                 raise Exception("VENDOR_ELEM_ADD failed")
2042             dev[0].select_network(id)
2043             dev[0].wait_connected()
2044             dev[0].request("DISCONNECT")
2045         finally:
2046             dev[0].request("VENDOR_ELEM_REMOVE 13 *")
2047
2048 def test_ap_wpa2_psk_no_random(dev, apdev):
2049     """WPA2-PSK AP and no random numbers available"""
2050     ssid = "test-wpa2-psk"
2051     passphrase = 'qwertyuiop'
2052     psk = '602e323e077bc63bd80307ef4745b754b0ae0a925c2638ecd13a794b9527b9e6'
2053     params = hostapd.wpa2_params(ssid=ssid)
2054     params['wpa_psk'] = psk
2055     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
2056     with fail_test(hapd, 1, "wpa_gmk_to_gtk"):
2057         id = dev[0].connect(ssid, raw_psk=psk, scan_freq="2412",
2058                             wait_connect=False)
2059         ev = dev[0].wait_event(["CTRL-EVENT-DISCONNECTED"], timeout=15)
2060         if ev is None:
2061             raise Exception("Disconnection event not reported")
2062         dev[0].request("DISCONNECT")
2063         dev[0].select_network(id, freq=2412)
2064         dev[0].wait_connected()
2065
2066 def test_rsn_ie_proto_psk_sta(dev, apdev):
2067     """RSN element protocol testing for PSK cases on STA side"""
2068     bssid = apdev[0]['bssid']
2069     ssid = "test-wpa2-psk"
2070     passphrase = 'qwertyuiop'
2071     params = hostapd.wpa2_params(ssid=ssid, passphrase=passphrase)
2072     # This is the RSN element used normally by hostapd
2073     params['own_ie_override'] = '30140100000fac040100000fac040100000fac020c00'
2074     hapd = hostapd.add_ap(apdev[0]['ifname'], params)
2075     if "FAIL" not in hapd.request("SET own_ie_override qwerty"):
2076         raise Exception("Invalid own_ie_override value accepted")
2077     id = dev[0].connect(ssid, psk=passphrase, scan_freq="2412")
2078
2079     tests = [ ('No RSN Capabilities field',
2080                '30120100000fac040100000fac040100000fac02'),
2081               ('Reserved RSN Capabilities bits set',
2082                '30140100000fac040100000fac040100000fac023cff'),
2083               ('Extra pairwise cipher suite (unsupported)',
2084                '30180100000fac040200ffffffff000fac040100000fac020c00'),
2085               ('Extra AKM suite (unsupported)',
2086                '30180100000fac040100000fac040200ffffffff000fac020c00'),
2087               ('PMKIDCount field included',
2088                '30160100000fac040100000fac040100000fac020c000000'),
2089               ('Unexpected Group Management Cipher Suite with PMF disabled',
2090                '301a0100000fac040100000fac040100000fac020c000000000fac06'),
2091               ('Extra octet after defined fields (future extensibility)',
2092                '301b0100000fac040100000fac040100000fac020c000000000fac0600') ]
2093     for txt,ie in tests:
2094         dev[0].request("DISCONNECT")
2095         dev[0].wait_disconnected()
2096         logger.info(txt)
2097         hapd.disable()
2098         hapd.set('own_ie_override', ie)
2099         hapd.enable()
2100         dev[0].request("BSS_FLUSH 0")
2101         dev[0].scan_for_bss(bssid, 2412, force_scan=True, only_new=True)
2102         dev[0].select_network(id, freq=2412)
2103         dev[0].wait_connected()
2104
2105 def test_ap_cli_order(dev, apdev):
2106     ssid = "test-rsn-setup"
2107     passphrase = 'zzzzzzzz'
2108     ifname = apdev[0]['ifname']
2109
2110     hapd_global = hostapd.HostapdGlobal()
2111     hapd_global.remove(ifname)
2112     hapd_global.add(ifname)
2113
2114     hapd = hostapd.Hostapd(ifname)
2115     hapd.set_defaults()
2116     hapd.set('ssid', ssid)
2117     hapd.set('wpa_passphrase', passphrase)
2118     hapd.set('rsn_pairwise', 'CCMP')
2119     hapd.set('wpa_key_mgmt', 'WPA-PSK')
2120     hapd.set('wpa', '2')
2121     hapd.enable()
2122     cfg = hapd.get_config()
2123     if cfg['group_cipher'] != 'CCMP':
2124         raise Exception("Unexpected group_cipher: " + cfg['group_cipher'])
2125     if cfg['rsn_pairwise_cipher'] != 'CCMP':
2126         raise Exception("Unexpected rsn_pairwise_cipher: " + cfg['rsn_pairwise_cipher'])
2127
2128     ev = hapd.wait_event(["AP-ENABLED", "AP-DISABLED"], timeout=30)
2129     if ev is None:
2130         raise Exception("AP startup timed out")
2131     if "AP-ENABLED" not in ev:
2132         raise Exception("AP startup failed")
2133
2134     dev[0].connect(ssid, psk=passphrase, scan_freq="2412")