tests/hwsim/test_sigma_dut.py

   1 # Test cases for sigma_dut
   2 # Copyright (c) 2017, 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 logging
   8 logger = logging.getLogger()
   9 import os
  10 import socket
  11 import subprocess
  12 import threading
  13 import time
  14
  15 import hostapd
  16 from utils import HwsimSkip
  17 from hwsim import HWSimRadio
  18 from test_dpp import check_dpp_capab, update_hapd_config
  19 from test_suite_b import check_suite_b_192_capa, suite_b_as_params, suite_b_192_rsa_ap_params
  20
  21 def check_sigma_dut():
  22     if not os.path.exists("./sigma_dut"):
  23         raise HwsimSkip("sigma_dut not available")
  24
  25 def sigma_dut_cmd(cmd, port=9000, timeout=2):
  26     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM,
  27                          socket.IPPROTO_TCP)
  28     sock.settimeout(timeout)
  29     addr = ('127.0.0.1', port)
  30     sock.connect(addr)
  31     sock.send(cmd + "\r\n")
  32     try:
  33         res = sock.recv(1000)
  34         running = False
  35         done = False
  36         for line in res.splitlines():
  37             if line.startswith("status,RUNNING"):
  38                 running = True
  39             elif line.startswith("status,INVALID"):
  40                 done = True
  41             elif line.startswith("status,ERROR"):
  42                 done = True
  43             elif line.startswith("status,COMPLETE"):
  44                 done = True
  45         if running and not done:
  46             # Read the actual response
  47             res = sock.recv(1000)
  48     except:
  49         res = ''
  50         pass
  51     sock.close()
  52     res = res.rstrip()
  53     logger.debug("sigma_dut: '%s' --> '%s'" % (cmd, res))
  54     return res
  55
  56 def sigma_dut_cmd_check(cmd, port=9000, timeout=2):
  57     res = sigma_dut_cmd(cmd, port=port, timeout=timeout)
  58     if "COMPLETE" not in res:
  59         raise Exception("sigma_dut command failed: " + cmd)
  60     return res
  61
  62 def start_sigma_dut(ifname, debug=False, hostapd_logdir=None, cert_path=None):
  63     check_sigma_dut()
  64     cmd = [ './sigma_dut',
  65             '-M', ifname,
  66             '-S', ifname,
  67             '-F', '../../hostapd/hostapd',
  68             '-G',
  69             '-w', '/var/run/wpa_supplicant/',
  70             '-j', ifname ]
  71     if debug:
  72         cmd += [ '-d' ]
  73     if hostapd_logdir:
  74         cmd += [ '-H', hostapd_logdir ]
  75     if cert_path:
  76         cmd += [ '-C', cert_path ]
  77     sigma = subprocess.Popen(cmd, stdout=subprocess.PIPE,
  78                              stderr=subprocess.PIPE)
  79     for i in range(20):
  80         try:
  81             res = sigma_dut_cmd("HELLO")
  82             break
  83         except:
  84             time.sleep(0.05)
  85     return sigma
  86
  87 def stop_sigma_dut(sigma):
  88     sigma.terminate()
  89     sigma.wait()
  90     out, err = sigma.communicate()
  91     logger.debug("sigma_dut stdout: " + str(out))
  92     logger.debug("sigma_dut stderr: " + str(err))
  93
  94 def sigma_dut_wait_connected(ifname):
  95     for i in range(50):
  96         res = sigma_dut_cmd("sta_is_connected,interface," + ifname)
  97         if "connected,1" in res:
  98             break
  99         time.sleep(0.2)
 100         if i == 49:
 101             raise Exception("Connection did not complete")
 102
 103 def test_sigma_dut_basic(dev, apdev):
 104     """sigma_dut basic functionality"""
 105     sigma = start_sigma_dut(dev[0].ifname)
 106
 107     res = sigma_dut_cmd("UNKNOWN")
 108     if "status,INVALID,errorCode,Unknown command" not in res:
 109         raise Exception("Unexpected sigma_dut response to unknown command")
 110
 111     tests = [ ("ca_get_version", "status,COMPLETE,version,1.0"),
 112               ("device_get_info", "status,COMPLETE,vendor"),
 113               ("device_list_interfaces,interfaceType,foo", "status,ERROR"),
 114               ("device_list_interfaces,interfaceType,802.11",
 115                "status,COMPLETE,interfaceType,802.11,interfaceID," + dev[0].ifname) ]
 116     for cmd, response in tests:
 117         res = sigma_dut_cmd(cmd)
 118         if response not in res:
 119             raise Exception("Unexpected %s response: %s" % (cmd, res))
 120
 121     stop_sigma_dut(sigma)
 122
 123 def test_sigma_dut_open(dev, apdev):
 124     """sigma_dut controlled open network association"""
 125     try:
 126         run_sigma_dut_open(dev, apdev)
 127     finally:
 128         dev[0].set("ignore_old_scan_res", "0")
 129
 130 def run_sigma_dut_open(dev, apdev):
 131     ifname = dev[0].ifname
 132     sigma = start_sigma_dut(ifname)
 133
 134     hapd = hostapd.add_ap(apdev[0], { "ssid": "open" })
 135
 136     sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
 137     sigma_dut_cmd_check("sta_set_encryption,interface,%s,ssid,%s,encpType,none" % (ifname, "open"))
 138     sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s" % (ifname, "open"))
 139     sigma_dut_wait_connected(ifname)
 140     sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
 141     sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
 142     sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
 143
 144     stop_sigma_dut(sigma)
 145
 146 def test_sigma_dut_psk_pmf(dev, apdev):
 147     """sigma_dut controlled PSK+PMF association"""
 148     try:
 149         run_sigma_dut_psk_pmf(dev, apdev)
 150     finally:
 151         dev[0].set("ignore_old_scan_res", "0")
 152
 153 def run_sigma_dut_psk_pmf(dev, apdev):
 154     ifname = dev[0].ifname
 155     sigma = start_sigma_dut(ifname)
 156
 157     ssid = "test-pmf-required"
 158     params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
 159     params["wpa_key_mgmt"] = "WPA-PSK-SHA256"
 160     params["ieee80211w"] = "2"
 161     hapd = hostapd.add_ap(apdev[0], params)
 162
 163     sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,PMF" % ifname)
 164     sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
 165     sigma_dut_cmd_check("sta_set_psk,interface,%s,ssid,%s,passphrase,%s,encpType,aes-ccmp,keymgmttype,wpa2,PMF,Required" % (ifname, "test-pmf-required", "12345678"))
 166     sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-pmf-required"))
 167     sigma_dut_wait_connected(ifname)
 168     sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
 169     sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
 170     sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
 171
 172     stop_sigma_dut(sigma)
 173
 174 def test_sigma_dut_psk_pmf_bip_cmac_128(dev, apdev):
 175     """sigma_dut controlled PSK+PMF association with BIP-CMAC-128"""
 176     try:
 177         run_sigma_dut_psk_pmf_cipher(dev, apdev, "BIP-CMAC-128", "AES-128-CMAC")
 178     finally:
 179         dev[0].set("ignore_old_scan_res", "0")
 180
 181 def test_sigma_dut_psk_pmf_bip_cmac_256(dev, apdev):
 182     """sigma_dut controlled PSK+PMF association with BIP-CMAC-256"""
 183     try:
 184         run_sigma_dut_psk_pmf_cipher(dev, apdev, "BIP-CMAC-256", "BIP-CMAC-256")
 185     finally:
 186         dev[0].set("ignore_old_scan_res", "0")
 187
 188 def test_sigma_dut_psk_pmf_bip_gmac_128(dev, apdev):
 189     """sigma_dut controlled PSK+PMF association with BIP-GMAC-128"""
 190     try:
 191         run_sigma_dut_psk_pmf_cipher(dev, apdev, "BIP-GMAC-128", "BIP-GMAC-128")
 192     finally:
 193         dev[0].set("ignore_old_scan_res", "0")
 194
 195 def test_sigma_dut_psk_pmf_bip_gmac_256(dev, apdev):
 196     """sigma_dut controlled PSK+PMF association with BIP-GMAC-256"""
 197     try:
 198         run_sigma_dut_psk_pmf_cipher(dev, apdev, "BIP-GMAC-256", "BIP-GMAC-256")
 199     finally:
 200         dev[0].set("ignore_old_scan_res", "0")
 201
 202 def test_sigma_dut_psk_pmf_bip_gmac_256_mismatch(dev, apdev):
 203     """sigma_dut controlled PSK+PMF association with BIP-GMAC-256 mismatch"""
 204     try:
 205         run_sigma_dut_psk_pmf_cipher(dev, apdev, "BIP-GMAC-256", "AES-128-CMAC",
 206                                      failure=True)
 207     finally:
 208         dev[0].set("ignore_old_scan_res", "0")
 209
 210 def run_sigma_dut_psk_pmf_cipher(dev, apdev, sigma_cipher, hostapd_cipher,
 211                                  failure=False):
 212     ifname = dev[0].ifname
 213     sigma = start_sigma_dut(ifname)
 214
 215     ssid = "test-pmf-required"
 216     params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
 217     params["wpa_key_mgmt"] = "WPA-PSK-SHA256"
 218     params["ieee80211w"] = "2"
 219     params["group_mgmt_cipher"] = hostapd_cipher
 220     hapd = hostapd.add_ap(apdev[0], params)
 221
 222     sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,PMF" % ifname)
 223     sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
 224     sigma_dut_cmd_check("sta_set_psk,interface,%s,ssid,%s,passphrase,%s,encpType,aes-ccmp,keymgmttype,wpa2,PMF,Required,GroupMgntCipher,%s" % (ifname, "test-pmf-required", "12345678", sigma_cipher))
 225     sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-pmf-required"))
 226     if failure:
 227         ev = dev[0].wait_event(["CTRL-EVENT-NETWORK-NOT-FOUND",
 228                                 "CTRL-EVENT-CONNECTED"], timeout=10)
 229         if ev is None:
 230             raise Exception("Network selection result not indicated")
 231         if "CTRL-EVENT-CONNECTED" in ev:
 232             raise Exception("Unexpected connection")
 233         res = sigma_dut_cmd("sta_is_connected,interface," + ifname)
 234         if "connected,1" in res:
 235             raise Exception("Connection reported")
 236     else:
 237         sigma_dut_wait_connected(ifname)
 238         sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
 239
 240     sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
 241     sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
 242
 243     stop_sigma_dut(sigma)
 244
 245 def test_sigma_dut_sae(dev, apdev):
 246     """sigma_dut controlled SAE association"""
 247     if "SAE" not in dev[0].get_capability("auth_alg"):
 248         raise HwsimSkip("SAE not supported")
 249
 250     ifname = dev[0].ifname
 251     sigma = start_sigma_dut(ifname)
 252
 253     ssid = "test-sae"
 254     params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
 255     params['wpa_key_mgmt'] = 'SAE'
 256     params["ieee80211w"] = "2"
 257     hapd = hostapd.add_ap(apdev[0], params)
 258
 259     sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
 260     sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
 261     sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2" % (ifname, "test-sae", "12345678"))
 262     sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"))
 263     sigma_dut_wait_connected(ifname)
 264     sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
 265     if dev[0].get_status_field('sae_group') != '19':
 266             raise Exception("Expected default SAE group not used")
 267     sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
 268
 269     sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
 270
 271     sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
 272     sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2,ECGroupID,20" % (ifname, "test-sae", "12345678"))
 273     sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"))
 274     sigma_dut_wait_connected(ifname)
 275     sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
 276     if dev[0].get_status_field('sae_group') != '20':
 277             raise Exception("Expected SAE group not used")
 278     sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
 279     sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
 280
 281     stop_sigma_dut(sigma)
 282
 283 def test_sigma_dut_sae_password(dev, apdev):
 284     """sigma_dut controlled SAE association and long password"""
 285     if "SAE" not in dev[0].get_capability("auth_alg"):
 286         raise HwsimSkip("SAE not supported")
 287
 288     ifname = dev[0].ifname
 289     sigma = start_sigma_dut(ifname)
 290
 291     try:
 292         ssid = "test-sae"
 293         params = hostapd.wpa2_params(ssid=ssid)
 294         params['sae_password'] = 100*'B'
 295         params['wpa_key_mgmt'] = 'SAE'
 296         params["ieee80211w"] = "2"
 297         hapd = hostapd.add_ap(apdev[0], params)
 298
 299         sigma_dut_cmd_check("sta_reset_default,interface,%s" % ifname)
 300         sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
 301         sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,passphrase,%s,type,SAE,encpType,aes-ccmp,keymgmttype,wpa2" % (ifname, "test-sae", 100*'B'))
 302         sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-sae"))
 303         sigma_dut_wait_connected(ifname)
 304         sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
 305         sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
 306         sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
 307     finally:
 308         stop_sigma_dut(sigma)
 309
 310 def test_sigma_dut_sta_override_rsne(dev, apdev):
 311     """sigma_dut and RSNE override on STA"""
 312     try:
 313         run_sigma_dut_sta_override_rsne(dev, apdev)
 314     finally:
 315         dev[0].set("ignore_old_scan_res", "0")
 316
 317 def run_sigma_dut_sta_override_rsne(dev, apdev):
 318     ifname = dev[0].ifname
 319     sigma = start_sigma_dut(ifname)
 320
 321     ssid = "test-psk"
 322     params = hostapd.wpa2_params(ssid=ssid, passphrase="12345678")
 323     hapd = hostapd.add_ap(apdev[0], params)
 324
 325     sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
 326
 327     tests = [ "30120100000fac040100000fac040100000fac02",
 328               "30140100000fac040100000fac040100000fac02ffff" ]
 329     for test in tests:
 330         sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,type,PSK,passphrase,%s,EncpType,aes-ccmp,KeyMgmtType,wpa2" % (ifname, "test-psk", "12345678"))
 331         sigma_dut_cmd_check("dev_configure_ie,interface,%s,IE_Name,RSNE,Contents,%s" % (ifname, test))
 332         sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-psk"))
 333         sigma_dut_wait_connected(ifname)
 334         sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
 335         dev[0].dump_monitor()
 336
 337     sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,%s,type,PSK,passphrase,%s,EncpType,aes-ccmp,KeyMgmtType,wpa2" % (ifname, "test-psk", "12345678"))
 338     sigma_dut_cmd_check("dev_configure_ie,interface,%s,IE_Name,RSNE,Contents,300101" % ifname)
 339     sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-psk"))
 340
 341     ev = dev[0].wait_event(["CTRL-EVENT-ASSOC-REJECT"])
 342     if ev is None:
 343         raise Exception("Association rejection not reported")
 344     if "status_code=40" not in ev:
 345         raise Exception("Unexpected status code: " + ev)
 346
 347     sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
 348
 349     stop_sigma_dut(sigma)
 350
 351 def test_sigma_dut_ap_psk(dev, apdev):
 352     """sigma_dut controlled AP"""
 353     with HWSimRadio() as (radio, iface):
 354         sigma = start_sigma_dut(iface)
 355         try:
 356             sigma_dut_cmd_check("ap_reset_default")
 357             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-psk,MODE,11ng")
 358             sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-PSK,PSK,12345678")
 359             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 360
 361             dev[0].connect("test-psk", psk="12345678", scan_freq="2412")
 362
 363             sigma_dut_cmd_check("ap_reset_default")
 364         finally:
 365             stop_sigma_dut(sigma)
 366
 367 def test_sigma_dut_ap_pskhex(dev, apdev, params):
 368     """sigma_dut controlled AP and PSKHEX"""
 369     logdir = os.path.join(params['logdir'],
 370                           "sigma_dut_ap_pskhex.sigma-hostapd")
 371     with HWSimRadio() as (radio, iface):
 372         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
 373         try:
 374             psk = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
 375             sigma_dut_cmd_check("ap_reset_default")
 376             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-psk,MODE,11ng")
 377             sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-PSK,PSKHEX," + psk)
 378             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 379
 380             dev[0].connect("test-psk", raw_psk=psk, scan_freq="2412")
 381
 382             sigma_dut_cmd_check("ap_reset_default")
 383         finally:
 384             stop_sigma_dut(sigma)
 385
 386 def test_sigma_dut_suite_b(dev, apdev, params):
 387     """sigma_dut controlled STA Suite B"""
 388     check_suite_b_192_capa(dev)
 389     logdir = params['logdir']
 390
 391     with open("auth_serv/ec2-ca.pem", "r") as f:
 392         with open(os.path.join(logdir, "suite_b_ca.pem"), "w") as f2:
 393             f2.write(f.read())
 394
 395     with open("auth_serv/ec2-user.pem", "r") as f:
 396         with open("auth_serv/ec2-user.key", "r") as f2:
 397             with open(os.path.join(logdir, "suite_b.pem"), "w") as f3:
 398                 f3.write(f.read())
 399                 f3.write(f2.read())
 400
 401     dev[0].flush_scan_cache()
 402     params = suite_b_as_params()
 403     params['ca_cert'] = 'auth_serv/ec2-ca.pem'
 404     params['server_cert'] = 'auth_serv/ec2-server.pem'
 405     params['private_key'] = 'auth_serv/ec2-server.key'
 406     params['openssl_ciphers'] = 'SUITEB192'
 407     hostapd.add_ap(apdev[1], params)
 408
 409     params = { "ssid": "test-suite-b",
 410                "wpa": "2",
 411                "wpa_key_mgmt": "WPA-EAP-SUITE-B-192",
 412                "rsn_pairwise": "GCMP-256",
 413                "group_mgmt_cipher": "BIP-GMAC-256",
 414                "ieee80211w": "2",
 415                "ieee8021x": "1",
 416                'auth_server_addr': "127.0.0.1",
 417                'auth_server_port': "18129",
 418                'auth_server_shared_secret': "radius",
 419                'nas_identifier': "nas.w1.fi" }
 420     hapd = hostapd.add_ap(apdev[0], params)
 421
 422     ifname = dev[0].ifname
 423     sigma = start_sigma_dut(ifname, cert_path=logdir)
 424
 425     sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,PMF" % ifname)
 426     sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
 427     sigma_dut_cmd_check("sta_set_security,type,eaptls,interface,%s,ssid,%s,PairwiseCipher,AES-GCMP-256,GroupCipher,AES-GCMP-256,GroupMgntCipher,BIP-GMAC-256,keymgmttype,SuiteB,clientCertificate,suite_b.pem,trustedRootCA,suite_b_ca.pem,CertType,ECC" % (ifname, "test-suite-b"))
 428     sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-suite-b"))
 429     sigma_dut_wait_connected(ifname)
 430     sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
 431     sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
 432     sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
 433
 434     stop_sigma_dut(sigma)
 435
 436 def test_sigma_dut_suite_b_rsa(dev, apdev, params):
 437     """sigma_dut controlled STA Suite B (RSA)"""
 438     check_suite_b_192_capa(dev)
 439     logdir = params['logdir']
 440
 441     with open("auth_serv/rsa3072-ca.pem", "r") as f:
 442         with open(os.path.join(logdir, "suite_b_ca_rsa.pem"), "w") as f2:
 443             f2.write(f.read())
 444
 445     with open("auth_serv/rsa3072-user.pem", "r") as f:
 446         with open("auth_serv/rsa3072-user.key", "r") as f2:
 447             with open(os.path.join(logdir, "suite_b_rsa.pem"), "w") as f3:
 448                 f3.write(f.read())
 449                 f3.write(f2.read())
 450
 451     dev[0].flush_scan_cache()
 452     params = suite_b_192_rsa_ap_params()
 453     hapd = hostapd.add_ap(apdev[0], params)
 454
 455     ifname = dev[0].ifname
 456     sigma = start_sigma_dut(ifname, cert_path=logdir)
 457
 458     cmd = "sta_set_security,type,eaptls,interface,%s,ssid,%s,PairwiseCipher,AES-GCMP-256,GroupCipher,AES-GCMP-256,GroupMgntCipher,BIP-GMAC-256,keymgmttype,SuiteB,clientCertificate,suite_b_rsa.pem,trustedRootCA,suite_b_ca_rsa.pem,CertType,RSA" % (ifname, "test-suite-b")
 459
 460     tests = [ "",
 461               ",TLSCipher,TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
 462               ",TLSCipher,TLS_DHE_RSA_WITH_AES_256_GCM_SHA384" ]
 463     for extra in tests:
 464         sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,PMF" % ifname)
 465         sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
 466         sigma_dut_cmd_check(cmd + extra)
 467         sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s,channel,1" % (ifname, "test-suite-b"))
 468         sigma_dut_wait_connected(ifname)
 469         sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
 470         sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
 471         sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
 472
 473     stop_sigma_dut(sigma)
 474
 475 def test_sigma_dut_ap_suite_b(dev, apdev, params):
 476     """sigma_dut controlled AP Suite B"""
 477     check_suite_b_192_capa(dev)
 478     logdir = os.path.join(params['logdir'],
 479                           "sigma_dut_ap_suite_b.sigma-hostapd")
 480     params = suite_b_as_params()
 481     params['ca_cert'] = 'auth_serv/ec2-ca.pem'
 482     params['server_cert'] = 'auth_serv/ec2-server.pem'
 483     params['private_key'] = 'auth_serv/ec2-server.key'
 484     params['openssl_ciphers'] = 'SUITEB192'
 485     hostapd.add_ap(apdev[1], params)
 486     with HWSimRadio() as (radio, iface):
 487         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
 488         try:
 489             sigma_dut_cmd_check("ap_reset_default")
 490             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-suite-b,MODE,11ng")
 491             sigma_dut_cmd_check("ap_set_radius,NAME,AP,IPADDR,127.0.0.1,PORT,18129,PASSWORD,radius")
 492             sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,SuiteB")
 493             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 494
 495             dev[0].connect("test-suite-b", key_mgmt="WPA-EAP-SUITE-B-192",
 496                            ieee80211w="2",
 497                            openssl_ciphers="SUITEB192",
 498                            eap="TLS", identity="tls user",
 499                            ca_cert="auth_serv/ec2-ca.pem",
 500                            client_cert="auth_serv/ec2-user.pem",
 501                            private_key="auth_serv/ec2-user.key",
 502                            pairwise="GCMP-256", group="GCMP-256",
 503                            scan_freq="2412")
 504
 505             sigma_dut_cmd_check("ap_reset_default")
 506         finally:
 507             stop_sigma_dut(sigma)
 508
 509 def test_sigma_dut_ap_cipher_gcmp_128(dev, apdev, params):
 510     """sigma_dut controlled AP with GCMP-128/BIP-GMAC-128 cipher"""
 511     run_sigma_dut_ap_cipher(dev, apdev, params, "AES-GCMP-128", "BIP-GMAC-128",
 512                             "GCMP")
 513
 514 def test_sigma_dut_ap_cipher_gcmp_256(dev, apdev, params):
 515     """sigma_dut controlled AP with GCMP-256/BIP-GMAC-256 cipher"""
 516     run_sigma_dut_ap_cipher(dev, apdev, params, "AES-GCMP-256", "BIP-GMAC-256",
 517                             "GCMP-256")
 518
 519 def test_sigma_dut_ap_cipher_ccmp_128(dev, apdev, params):
 520     """sigma_dut controlled AP with CCMP-128/BIP-CMAC-128 cipher"""
 521     run_sigma_dut_ap_cipher(dev, apdev, params, "AES-CCMP-128", "BIP-CMAC-128",
 522                             "CCMP")
 523
 524 def test_sigma_dut_ap_cipher_ccmp_256(dev, apdev, params):
 525     """sigma_dut controlled AP with CCMP-256/BIP-CMAC-256 cipher"""
 526     run_sigma_dut_ap_cipher(dev, apdev, params, "AES-CCMP-256", "BIP-CMAC-256",
 527                             "CCMP-256")
 528
 529 def test_sigma_dut_ap_cipher_ccmp_gcmp_1(dev, apdev, params):
 530     """sigma_dut controlled AP with CCMP-128+GCMP-256 ciphers (1)"""
 531     run_sigma_dut_ap_cipher(dev, apdev, params, "AES-CCMP-128 AES-GCMP-256",
 532                             "BIP-GMAC-256", "CCMP")
 533
 534 def test_sigma_dut_ap_cipher_ccmp_gcmp_2(dev, apdev, params):
 535     """sigma_dut controlled AP with CCMP-128+GCMP-256 ciphers (2)"""
 536     run_sigma_dut_ap_cipher(dev, apdev, params, "AES-CCMP-128 AES-GCMP-256",
 537                             "BIP-GMAC-256", "GCMP-256", "CCMP")
 538
 539 def test_sigma_dut_ap_cipher_gcmp_256_group_ccmp(dev, apdev, params):
 540     """sigma_dut controlled AP with GCMP-256/CCMP/BIP-GMAC-256 cipher"""
 541     run_sigma_dut_ap_cipher(dev, apdev, params, "AES-GCMP-256", "BIP-GMAC-256",
 542                             "GCMP-256", "CCMP", "AES-CCMP-128")
 543
 544 def run_sigma_dut_ap_cipher(dev, apdev, params, ap_pairwise, ap_group_mgmt,
 545                             sta_cipher, sta_cipher_group=None, ap_group=None):
 546     check_suite_b_192_capa(dev)
 547     logdir = os.path.join(params['logdir'],
 548                           "sigma_dut_ap_cipher.sigma-hostapd")
 549     params = suite_b_as_params()
 550     params['ca_cert'] = 'auth_serv/ec2-ca.pem'
 551     params['server_cert'] = 'auth_serv/ec2-server.pem'
 552     params['private_key'] = 'auth_serv/ec2-server.key'
 553     params['openssl_ciphers'] = 'SUITEB192'
 554     hostapd.add_ap(apdev[1], params)
 555     with HWSimRadio() as (radio, iface):
 556         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
 557         try:
 558             sigma_dut_cmd_check("ap_reset_default")
 559             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-suite-b,MODE,11ng")
 560             sigma_dut_cmd_check("ap_set_radius,NAME,AP,IPADDR,127.0.0.1,PORT,18129,PASSWORD,radius")
 561             cmd = "ap_set_security,NAME,AP,KEYMGNT,SuiteB,PMF,Required,PairwiseCipher,%s,GroupMgntCipher,%s" % (ap_pairwise, ap_group_mgmt)
 562             if ap_group:
 563                 cmd += ",GroupCipher,%s" % ap_group
 564             sigma_dut_cmd_check(cmd)
 565             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 566
 567             if sta_cipher_group is None:
 568                 sta_cipher_group = sta_cipher
 569             dev[0].connect("test-suite-b", key_mgmt="WPA-EAP-SUITE-B-192",
 570                            ieee80211w="2",
 571                            openssl_ciphers="SUITEB192",
 572                            eap="TLS", identity="tls user",
 573                            ca_cert="auth_serv/ec2-ca.pem",
 574                            client_cert="auth_serv/ec2-user.pem",
 575                            private_key="auth_serv/ec2-user.key",
 576                            pairwise=sta_cipher, group=sta_cipher_group,
 577                            scan_freq="2412")
 578
 579             sigma_dut_cmd_check("ap_reset_default")
 580         finally:
 581             stop_sigma_dut(sigma)
 582
 583 def test_sigma_dut_ap_override_rsne(dev, apdev):
 584     """sigma_dut controlled AP overriding RSNE"""
 585     with HWSimRadio() as (radio, iface):
 586         sigma = start_sigma_dut(iface)
 587         try:
 588             sigma_dut_cmd_check("ap_reset_default")
 589             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-psk,MODE,11ng")
 590             sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-PSK,PSK,12345678")
 591             sigma_dut_cmd_check("dev_configure_ie,NAME,AP,interface,%s,IE_Name,RSNE,Contents,30180100000fac040200ffffffff000fac040100000fac020c00" % iface)
 592             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 593
 594             dev[0].connect("test-psk", psk="12345678", scan_freq="2412")
 595
 596             sigma_dut_cmd_check("ap_reset_default")
 597         finally:
 598             stop_sigma_dut(sigma)
 599
 600 def test_sigma_dut_ap_sae(dev, apdev, params):
 601     """sigma_dut controlled AP with SAE"""
 602     logdir = os.path.join(params['logdir'],
 603                           "sigma_dut_ap_sae.sigma-hostapd")
 604     if "SAE" not in dev[0].get_capability("auth_alg"):
 605         raise HwsimSkip("SAE not supported")
 606     with HWSimRadio() as (radio, iface):
 607         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
 608         try:
 609             sigma_dut_cmd_check("ap_reset_default")
 610             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
 611             sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678")
 612             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 613
 614             dev[0].request("SET sae_groups ")
 615             dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
 616                            ieee80211w="2", scan_freq="2412")
 617             if dev[0].get_status_field('sae_group') != '19':
 618                 raise Exception("Expected default SAE group not used")
 619
 620             sigma_dut_cmd_check("ap_reset_default")
 621         finally:
 622             stop_sigma_dut(sigma)
 623
 624 def test_sigma_dut_ap_sae_password(dev, apdev, params):
 625     """sigma_dut controlled AP with SAE and long password"""
 626     logdir = os.path.join(params['logdir'],
 627                           "sigma_dut_ap_sae_password.sigma-hostapd")
 628     if "SAE" not in dev[0].get_capability("auth_alg"):
 629         raise HwsimSkip("SAE not supported")
 630     with HWSimRadio() as (radio, iface):
 631         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
 632         try:
 633             sigma_dut_cmd_check("ap_reset_default")
 634             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
 635             sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK," + 100*'C')
 636             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 637
 638             dev[0].request("SET sae_groups ")
 639             dev[0].connect("test-sae", key_mgmt="SAE", sae_password=100*'C',
 640                            ieee80211w="2", scan_freq="2412")
 641             if dev[0].get_status_field('sae_group') != '19':
 642                 raise Exception("Expected default SAE group not used")
 643
 644             sigma_dut_cmd_check("ap_reset_default")
 645         finally:
 646             stop_sigma_dut(sigma)
 647
 648 def test_sigma_dut_ap_sae_group(dev, apdev, params):
 649     """sigma_dut controlled AP with SAE and specific group"""
 650     logdir = os.path.join(params['logdir'],
 651                           "sigma_dut_ap_sae_group.sigma-hostapd")
 652     if "SAE" not in dev[0].get_capability("auth_alg"):
 653         raise HwsimSkip("SAE not supported")
 654     with HWSimRadio() as (radio, iface):
 655         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
 656         try:
 657             sigma_dut_cmd_check("ap_reset_default")
 658             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
 659             sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-SAE,PSK,12345678,ECGroupID,20")
 660             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 661
 662             dev[0].request("SET sae_groups ")
 663             dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
 664                            ieee80211w="2", scan_freq="2412")
 665             if dev[0].get_status_field('sae_group') != '20':
 666                 raise Exception("Expected SAE group not used")
 667
 668             sigma_dut_cmd_check("ap_reset_default")
 669         finally:
 670             stop_sigma_dut(sigma)
 671
 672 def test_sigma_dut_ap_psk_sae(dev, apdev, params):
 673     """sigma_dut controlled AP with PSK+SAE"""
 674     if "SAE" not in dev[0].get_capability("auth_alg"):
 675         raise HwsimSkip("SAE not supported")
 676     logdir = os.path.join(params['logdir'],
 677                           "sigma_dut_ap_psk_sae.sigma-hostapd")
 678     with HWSimRadio() as (radio, iface):
 679         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
 680         try:
 681             sigma_dut_cmd_check("ap_reset_default")
 682             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,test-sae,MODE,11ng")
 683             sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,WPA2-PSK-SAE,PSK,12345678")
 684             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 685
 686             dev[2].request("SET sae_groups ")
 687             dev[2].connect("test-sae", key_mgmt="SAE", psk="12345678",
 688                            scan_freq="2412", ieee80211w="0", wait_connect=False)
 689             dev[0].request("SET sae_groups ")
 690             dev[0].connect("test-sae", key_mgmt="SAE", psk="12345678",
 691                            scan_freq="2412", ieee80211w="2")
 692             dev[1].connect("test-sae", psk="12345678", scan_freq="2412")
 693
 694             ev = dev[2].wait_event(["CTRL-EVENT-CONNECTED"], timeout=0.1)
 695             dev[2].request("DISCONNECT")
 696             if ev is not None:
 697                 raise Exception("Unexpected connection without PMF")
 698
 699             sigma_dut_cmd_check("ap_reset_default")
 700         finally:
 701             stop_sigma_dut(sigma)
 702
 703 def test_sigma_dut_owe(dev, apdev):
 704     """sigma_dut controlled OWE station"""
 705     try:
 706         run_sigma_dut_owe(dev, apdev)
 707     finally:
 708         dev[0].set("ignore_old_scan_res", "0")
 709
 710 def run_sigma_dut_owe(dev, apdev):
 711     if "OWE" not in dev[0].get_capability("key_mgmt"):
 712         raise HwsimSkip("OWE not supported")
 713
 714     ifname = dev[0].ifname
 715     sigma = start_sigma_dut(ifname)
 716
 717     try:
 718         params = { "ssid": "owe",
 719                    "wpa": "2",
 720                    "wpa_key_mgmt": "OWE",
 721                    "ieee80211w": "2",
 722                    "rsn_pairwise": "CCMP" }
 723         hapd = hostapd.add_ap(apdev[0], params)
 724         bssid = hapd.own_addr()
 725
 726         sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
 727         sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
 728         sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,owe,Type,OWE" % ifname)
 729         sigma_dut_cmd_check("sta_associate,interface,%s,ssid,owe,channel,1" % ifname)
 730         sigma_dut_wait_connected(ifname)
 731         sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
 732
 733         dev[0].dump_monitor()
 734         sigma_dut_cmd("sta_reassoc,interface,%s,Channel,1,bssid,%s" % (ifname, bssid))
 735         dev[0].wait_connected()
 736         sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
 737         dev[0].wait_disconnected()
 738         dev[0].dump_monitor()
 739
 740         sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
 741         sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
 742         sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,owe,Type,OWE,ECGroupID,20" % ifname)
 743         sigma_dut_cmd_check("sta_associate,interface,%s,ssid,owe,channel,1" % ifname)
 744         sigma_dut_wait_connected(ifname)
 745         sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
 746         sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
 747         dev[0].wait_disconnected()
 748         dev[0].dump_monitor()
 749
 750         sigma_dut_cmd_check("sta_reset_default,interface,%s,prog,WPA3" % ifname)
 751         sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
 752         sigma_dut_cmd_check("sta_set_security,interface,%s,ssid,owe,Type,OWE,ECGroupID,0" % ifname)
 753         sigma_dut_cmd_check("sta_associate,interface,%s,ssid,owe,channel,1" % ifname)
 754         ev = dev[0].wait_event(["CTRL-EVENT-ASSOC-REJECT"], timeout=10)
 755         sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
 756         if ev is None:
 757             raise Exception("Association not rejected")
 758         if "status_code=77" not in ev:
 759             raise Exception("Unexpected rejection reason: " + ev)
 760
 761         sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
 762     finally:
 763         stop_sigma_dut(sigma)
 764
 765 def test_sigma_dut_ap_owe(dev, apdev, params):
 766     """sigma_dut controlled AP with OWE"""
 767     logdir = os.path.join(params['logdir'],
 768                           "sigma_dut_ap_owe.sigma-hostapd")
 769     if "OWE" not in dev[0].get_capability("key_mgmt"):
 770         raise HwsimSkip("OWE not supported")
 771     with HWSimRadio() as (radio, iface):
 772         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
 773         try:
 774             sigma_dut_cmd_check("ap_reset_default,NAME,AP,Program,WPA3")
 775             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,owe,MODE,11ng")
 776             sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,OWE")
 777             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 778
 779             dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
 780                            scan_freq="2412")
 781
 782             sigma_dut_cmd_check("ap_reset_default")
 783         finally:
 784             stop_sigma_dut(sigma)
 785
 786 def test_sigma_dut_ap_owe_ecgroupid(dev, apdev):
 787     """sigma_dut controlled AP with OWE and ECGroupID"""
 788     if "OWE" not in dev[0].get_capability("key_mgmt"):
 789         raise HwsimSkip("OWE not supported")
 790     with HWSimRadio() as (radio, iface):
 791         sigma = start_sigma_dut(iface)
 792         try:
 793             sigma_dut_cmd_check("ap_reset_default,NAME,AP,Program,WPA3")
 794             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,CHANNEL,1,SSID,owe,MODE,11ng")
 795             sigma_dut_cmd_check("ap_set_security,NAME,AP,KEYMGNT,OWE,ECGroupID,20 21,PMF,Required")
 796             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 797
 798             dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
 799                            owe_group="20", scan_freq="2412")
 800             dev[0].request("REMOVE_NETWORK all")
 801             dev[0].wait_disconnected()
 802
 803             dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
 804                            owe_group="21", scan_freq="2412")
 805             dev[0].request("REMOVE_NETWORK all")
 806             dev[0].wait_disconnected()
 807
 808             dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
 809                            owe_group="19", scan_freq="2412", wait_connect=False)
 810             ev = dev[0].wait_event(["CTRL-EVENT-ASSOC-REJECT"], timeout=10)
 811             dev[0].request("DISCONNECT")
 812             if ev is None:
 813                 raise Exception("Association not rejected")
 814             if "status_code=77" not in ev:
 815                 raise Exception("Unexpected rejection reason: " + ev)
 816             dev[0].dump_monitor()
 817
 818             sigma_dut_cmd_check("ap_reset_default")
 819         finally:
 820             stop_sigma_dut(sigma)
 821
 822 def test_sigma_dut_ap_owe_transition_mode(dev, apdev, params):
 823     """sigma_dut controlled AP with OWE and transition mode"""
 824     if "OWE" not in dev[0].get_capability("key_mgmt"):
 825         raise HwsimSkip("OWE not supported")
 826     logdir = os.path.join(params['logdir'],
 827                           "sigma_dut_ap_owe_transition_mode.sigma-hostapd")
 828     with HWSimRadio() as (radio, iface):
 829         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
 830         try:
 831             sigma_dut_cmd_check("ap_reset_default,NAME,AP,Program,WPA3")
 832             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,WLAN_TAG,1,CHANNEL,1,SSID,owe,MODE,11ng")
 833             sigma_dut_cmd_check("ap_set_security,NAME,AP,WLAN_TAG,1,KEYMGNT,OWE")
 834             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,WLAN_TAG,2,CHANNEL,1,SSID,owe,MODE,11ng")
 835             sigma_dut_cmd_check("ap_set_security,NAME,AP,WLAN_TAG,2,KEYMGNT,NONE")
 836             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 837
 838             res1 = sigma_dut_cmd_check("ap_get_mac_address,NAME,AP,WLAN_TAG,1,Interface,24G")
 839             res2 = sigma_dut_cmd_check("ap_get_mac_address,NAME,AP,WLAN_TAG,2,Interface,24G")
 840
 841             dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
 842                            scan_freq="2412")
 843             dev[1].connect("owe", key_mgmt="NONE", scan_freq="2412")
 844             if dev[0].get_status_field('bssid') not in res1:
 845                 raise Exception("Unexpected ap_get_mac_address WLAN_TAG,1: " + res1)
 846             if dev[1].get_status_field('bssid') not in res2:
 847                 raise Exception("Unexpected ap_get_mac_address WLAN_TAG,2: " + res2)
 848
 849             sigma_dut_cmd_check("ap_reset_default")
 850         finally:
 851             stop_sigma_dut(sigma)
 852
 853 def test_sigma_dut_ap_owe_transition_mode_2(dev, apdev, params):
 854     """sigma_dut controlled AP with OWE and transition mode (2)"""
 855     if "OWE" not in dev[0].get_capability("key_mgmt"):
 856         raise HwsimSkip("OWE not supported")
 857     logdir = os.path.join(params['logdir'],
 858                           "sigma_dut_ap_owe_transition_mode_2.sigma-hostapd")
 859     with HWSimRadio() as (radio, iface):
 860         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
 861         try:
 862             sigma_dut_cmd_check("ap_reset_default,NAME,AP,Program,WPA3")
 863             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,WLAN_TAG,1,CHANNEL,1,SSID,owe,MODE,11ng")
 864             sigma_dut_cmd_check("ap_set_security,NAME,AP,WLAN_TAG,1,KEYMGNT,NONE")
 865             sigma_dut_cmd_check("ap_set_wireless,NAME,AP,WLAN_TAG,2,CHANNEL,1,MODE,11ng")
 866             sigma_dut_cmd_check("ap_set_security,NAME,AP,WLAN_TAG,2,KEYMGNT,OWE")
 867             sigma_dut_cmd_check("ap_config_commit,NAME,AP")
 868
 869             res1 = sigma_dut_cmd_check("ap_get_mac_address,NAME,AP,WLAN_TAG,1,Interface,24G")
 870             res2 = sigma_dut_cmd_check("ap_get_mac_address,NAME,AP,WLAN_TAG,2,Interface,24G")
 871
 872             dev[0].connect("owe", key_mgmt="OWE", ieee80211w="2",
 873                            scan_freq="2412")
 874             dev[1].connect("owe", key_mgmt="NONE", scan_freq="2412")
 875             if dev[0].get_status_field('bssid') not in res2:
 876                 raise Exception("Unexpected ap_get_mac_address WLAN_TAG,2: " + res1)
 877             if dev[1].get_status_field('bssid') not in res1:
 878                 raise Exception("Unexpected ap_get_mac_address WLAN_TAG,1: " + res2)
 879
 880             sigma_dut_cmd_check("ap_reset_default")
 881         finally:
 882             stop_sigma_dut(sigma)
 883
 884 def dpp_init_enrollee(dev, id1):
 885     logger.info("Starting DPP initiator/enrollee in a thread")
 886     time.sleep(1)
 887     cmd = "DPP_AUTH_INIT peer=%d role=enrollee" % id1
 888     if "OK" not in dev.request(cmd):
 889         raise Exception("Failed to initiate DPP Authentication")
 890     ev = dev.wait_event(["DPP-CONF-RECEIVED"], timeout=5)
 891     if ev is None:
 892         raise Exception("DPP configuration not completed (Enrollee)")
 893     logger.info("DPP initiator/enrollee done")
 894
 895 def test_sigma_dut_dpp_qr_resp_1(dev, apdev):
 896     """sigma_dut DPP/QR responder (conf index 1)"""
 897     run_sigma_dut_dpp_qr_resp(dev, apdev, 1)
 898
 899 def test_sigma_dut_dpp_qr_resp_2(dev, apdev):
 900     """sigma_dut DPP/QR responder (conf index 2)"""
 901     run_sigma_dut_dpp_qr_resp(dev, apdev, 2)
 902
 903 def test_sigma_dut_dpp_qr_resp_3(dev, apdev):
 904     """sigma_dut DPP/QR responder (conf index 3)"""
 905     run_sigma_dut_dpp_qr_resp(dev, apdev, 3)
 906
 907 def test_sigma_dut_dpp_qr_resp_4(dev, apdev):
 908     """sigma_dut DPP/QR responder (conf index 4)"""
 909     run_sigma_dut_dpp_qr_resp(dev, apdev, 4)
 910
 911 def test_sigma_dut_dpp_qr_resp_5(dev, apdev):
 912     """sigma_dut DPP/QR responder (conf index 5)"""
 913     run_sigma_dut_dpp_qr_resp(dev, apdev, 5)
 914
 915 def test_sigma_dut_dpp_qr_resp_6(dev, apdev):
 916     """sigma_dut DPP/QR responder (conf index 6)"""
 917     run_sigma_dut_dpp_qr_resp(dev, apdev, 6)
 918
 919 def test_sigma_dut_dpp_qr_resp_7(dev, apdev):
 920     """sigma_dut DPP/QR responder (conf index 7)"""
 921     run_sigma_dut_dpp_qr_resp(dev, apdev, 7)
 922
 923 def test_sigma_dut_dpp_qr_resp_chan_list(dev, apdev):
 924     """sigma_dut DPP/QR responder (channel list override)"""
 925     run_sigma_dut_dpp_qr_resp(dev, apdev, 1, chan_list='81/2 81/6 81/1',
 926                               listen_chan=2)
 927
 928 def run_sigma_dut_dpp_qr_resp(dev, apdev, conf_idx, chan_list=None,
 929                               listen_chan=None):
 930     check_dpp_capab(dev[0])
 931     check_dpp_capab(dev[1])
 932     sigma = start_sigma_dut(dev[0].ifname)
 933     try:
 934         cmd = "dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR"
 935         if chan_list:
 936             cmd += ",DPPChannelList," + chan_list
 937         res = sigma_dut_cmd(cmd)
 938         if "status,COMPLETE" not in res:
 939             raise Exception("dev_exec_action did not succeed: " + res)
 940         hex = res.split(',')[3]
 941         uri = hex.decode('hex')
 942         logger.info("URI from sigma_dut: " + uri)
 943
 944         res = dev[1].request("DPP_QR_CODE " + uri)
 945         if "FAIL" in res:
 946             raise Exception("Failed to parse QR Code URI")
 947         id1 = int(res)
 948
 949         t = threading.Thread(target=dpp_init_enrollee, args=(dev[1], id1))
 950         t.start()
 951         cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPConfIndex,%d,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfEnrolleeRole,STA,DPPSigningKeyECC,P-256,DPPBS,QR,DPPTimeout,6" % conf_idx
 952         if listen_chan:
 953             cmd += ",DPPListenChannel," + str(listen_chan)
 954         res = sigma_dut_cmd(cmd, timeout=10)
 955         t.join()
 956         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
 957             raise Exception("Unexpected result: " + res)
 958     finally:
 959         stop_sigma_dut(sigma)
 960
 961 def test_sigma_dut_dpp_qr_init_enrollee(dev, apdev):
 962     """sigma_dut DPP/QR initiator as Enrollee"""
 963     check_dpp_capab(dev[0])
 964     check_dpp_capab(dev[1])
 965
 966     csign = "30770201010420768240a3fc89d6662d9782f120527fe7fb9edc6366ab0b9c7dde96125cfd250fa00a06082a8648ce3d030107a144034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
 967     csign_pub = "3059301306072a8648ce3d020106082a8648ce3d030107034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
 968     ap_connector = "eyJ0eXAiOiJkcHBDb24iLCJraWQiOiJwYWtZbXVzd1dCdWpSYTl5OEsweDViaTVrT3VNT3dzZHRlaml2UG55ZHZzIiwiYWxnIjoiRVMyNTYifQ.eyJncm91cHMiOlt7Imdyb3VwSWQiOiIqIiwibmV0Um9sZSI6ImFwIn1dLCJuZXRBY2Nlc3NLZXkiOnsia3R5IjoiRUMiLCJjcnYiOiJQLTI1NiIsIngiOiIybU5vNXZuRkI5bEw3d1VWb1hJbGVPYzBNSEE1QXZKbnpwZXZULVVTYzVNIiwieSI6IlhzS3dqVHJlLTg5WWdpU3pKaG9CN1haeUttTU05OTl3V2ZaSVl0bi01Q3MifX0.XhjFpZgcSa7G2lHy0OCYTvaZFRo5Hyx6b7g7oYyusLC7C_73AJ4_BxEZQVYJXAtDuGvb3dXSkHEKxREP9Q6Qeg"
 969     ap_netaccesskey = "30770201010420ceba752db2ad5200fa7bc565b9c05c69b7eb006751b0b329b0279de1c19ca67ca00a06082a8648ce3d030107a14403420004da6368e6f9c507d94bef0515a1722578e73430703902f267ce97af4fe51273935ec2b08d3adefbcf588224b3261a01ed76722a630cf7df7059f64862d9fee42b"
 970
 971     params = { "ssid": "DPPNET01",
 972                "wpa": "2",
 973                "ieee80211w": "2",
 974                "wpa_key_mgmt": "DPP",
 975                "rsn_pairwise": "CCMP",
 976                "dpp_connector": ap_connector,
 977                "dpp_csign": csign_pub,
 978                "dpp_netaccesskey": ap_netaccesskey }
 979     try:
 980         hapd = hostapd.add_ap(apdev[0], params)
 981     except:
 982         raise HwsimSkip("DPP not supported")
 983
 984     sigma = start_sigma_dut(dev[0].ifname)
 985     try:
 986         dev[0].set("dpp_config_processing", "2")
 987
 988         cmd = "DPP_CONFIGURATOR_ADD key=" + csign
 989         res = dev[1].request(cmd);
 990         if "FAIL" in res:
 991             raise Exception("Failed to add configurator")
 992         conf_id = int(res)
 993
 994         addr = dev[1].own_addr().replace(':', '')
 995         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
 996         res = dev[1].request(cmd)
 997         if "FAIL" in res:
 998             raise Exception("Failed to generate bootstrapping info")
 999         id0 = int(res)
1000         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1001
1002         dev[1].set("dpp_configurator_params",
1003                    " conf=sta-dpp ssid=%s configurator=%d" % ("DPPNET01".encode("hex"), conf_id));
1004         cmd = "DPP_LISTEN 2437 role=configurator"
1005         if "OK" not in dev[1].request(cmd):
1006             raise Exception("Failed to start listen operation")
1007
1008         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1009         if "status,COMPLETE" not in res:
1010             raise Exception("dev_exec_action did not succeed: " + res)
1011
1012         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6,DPPWaitForConnect,Yes", timeout=10)
1013         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
1014             raise Exception("Unexpected result: " + res)
1015     finally:
1016         dev[0].set("dpp_config_processing", "0")
1017         stop_sigma_dut(sigma)
1018
1019 def test_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev):
1020     """sigma_dut DPP/QR (mutual) initiator as Enrollee"""
1021     run_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev)
1022
1023 def test_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev):
1024     """sigma_dut DPP/QR (mutual) initiator as Enrollee (extra check)"""
1025     run_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev,
1026                                                     extra="DPPAuthDirection,Mutual,")
1027
1028 def run_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev, extra=''):
1029     check_dpp_capab(dev[0])
1030     check_dpp_capab(dev[1])
1031
1032     csign = "30770201010420768240a3fc89d6662d9782f120527fe7fb9edc6366ab0b9c7dde96125cfd250fa00a06082a8648ce3d030107a144034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1033     csign_pub = "3059301306072a8648ce3d020106082a8648ce3d030107034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1034     ap_connector = "eyJ0eXAiOiJkcHBDb24iLCJraWQiOiJwYWtZbXVzd1dCdWpSYTl5OEsweDViaTVrT3VNT3dzZHRlaml2UG55ZHZzIiwiYWxnIjoiRVMyNTYifQ.eyJncm91cHMiOlt7Imdyb3VwSWQiOiIqIiwibmV0Um9sZSI6ImFwIn1dLCJuZXRBY2Nlc3NLZXkiOnsia3R5IjoiRUMiLCJjcnYiOiJQLTI1NiIsIngiOiIybU5vNXZuRkI5bEw3d1VWb1hJbGVPYzBNSEE1QXZKbnpwZXZULVVTYzVNIiwieSI6IlhzS3dqVHJlLTg5WWdpU3pKaG9CN1haeUttTU05OTl3V2ZaSVl0bi01Q3MifX0.XhjFpZgcSa7G2lHy0OCYTvaZFRo5Hyx6b7g7oYyusLC7C_73AJ4_BxEZQVYJXAtDuGvb3dXSkHEKxREP9Q6Qeg"
1035     ap_netaccesskey = "30770201010420ceba752db2ad5200fa7bc565b9c05c69b7eb006751b0b329b0279de1c19ca67ca00a06082a8648ce3d030107a14403420004da6368e6f9c507d94bef0515a1722578e73430703902f267ce97af4fe51273935ec2b08d3adefbcf588224b3261a01ed76722a630cf7df7059f64862d9fee42b"
1036
1037     params = { "ssid": "DPPNET01",
1038                "wpa": "2",
1039                "ieee80211w": "2",
1040                "wpa_key_mgmt": "DPP",
1041                "rsn_pairwise": "CCMP",
1042                "dpp_connector": ap_connector,
1043                "dpp_csign": csign_pub,
1044                "dpp_netaccesskey": ap_netaccesskey }
1045     try:
1046         hapd = hostapd.add_ap(apdev[0], params)
1047     except:
1048         raise HwsimSkip("DPP not supported")
1049
1050     sigma = start_sigma_dut(dev[0].ifname)
1051     try:
1052         dev[0].set("dpp_config_processing", "2")
1053
1054         cmd = "DPP_CONFIGURATOR_ADD key=" + csign
1055         res = dev[1].request(cmd);
1056         if "FAIL" in res:
1057             raise Exception("Failed to add configurator")
1058         conf_id = int(res)
1059
1060         addr = dev[1].own_addr().replace(':', '')
1061         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1062         res = dev[1].request(cmd)
1063         if "FAIL" in res:
1064             raise Exception("Failed to generate bootstrapping info")
1065         id0 = int(res)
1066         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1067
1068         dev[1].set("dpp_configurator_params",
1069                    " conf=sta-dpp ssid=%s configurator=%d" % ("DPPNET01".encode("hex"), conf_id));
1070         cmd = "DPP_LISTEN 2437 role=configurator qr=mutual"
1071         if "OK" not in dev[1].request(cmd):
1072             raise Exception("Failed to start listen operation")
1073
1074         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1075         if "status,COMPLETE" not in res:
1076             raise Exception("dev_exec_action did not succeed: " + res)
1077         hex = res.split(',')[3]
1078         uri = hex.decode('hex')
1079         logger.info("URI from sigma_dut: " + uri)
1080
1081         res = dev[1].request("DPP_QR_CODE " + uri)
1082         if "FAIL" in res:
1083             raise Exception("Failed to parse QR Code URI")
1084         id1 = int(res)
1085
1086         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1087         if "status,COMPLETE" not in res:
1088             raise Exception("dev_exec_action did not succeed: " + res)
1089
1090         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,%sDPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6,DPPWaitForConnect,Yes" % extra, timeout=10)
1091         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
1092             raise Exception("Unexpected result: " + res)
1093     finally:
1094         dev[0].set("dpp_config_processing", "0")
1095         stop_sigma_dut(sigma)
1096
1097 def dpp_init_conf_mutual(dev, id1, conf_id, own_id=None):
1098     time.sleep(1)
1099     logger.info("Starting DPP initiator/configurator in a thread")
1100     cmd = "DPP_AUTH_INIT peer=%d conf=sta-dpp ssid=%s configurator=%d" % (id1, "DPPNET01".encode("hex"), conf_id)
1101     if own_id is not None:
1102         cmd += " own=%d" % own_id
1103     if "OK" not in dev.request(cmd):
1104         raise Exception("Failed to initiate DPP Authentication")
1105     ev = dev.wait_event(["DPP-CONF-SENT"], timeout=10)
1106     if ev is None:
1107         raise Exception("DPP configuration not completed (Configurator)")
1108     logger.info("DPP initiator/configurator done")
1109
1110 def test_sigma_dut_dpp_qr_mutual_resp_enrollee(dev, apdev):
1111     """sigma_dut DPP/QR (mutual) responder as Enrollee"""
1112     run_sigma_dut_dpp_qr_mutual_resp_enrollee(dev, apdev)
1113
1114 def test_sigma_dut_dpp_qr_mutual_resp_enrollee_pending(dev, apdev):
1115     """sigma_dut DPP/QR (mutual) responder as Enrollee (response pending)"""
1116     run_sigma_dut_dpp_qr_mutual_resp_enrollee(dev, apdev, ',DPPDelayQRResponse,1')
1117
1118 def run_sigma_dut_dpp_qr_mutual_resp_enrollee(dev, apdev, extra=None):
1119     check_dpp_capab(dev[0])
1120     check_dpp_capab(dev[1])
1121
1122     csign = "30770201010420768240a3fc89d6662d9782f120527fe7fb9edc6366ab0b9c7dde96125cfd250fa00a06082a8648ce3d030107a144034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1123     csign_pub = "3059301306072a8648ce3d020106082a8648ce3d030107034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1124     ap_connector = "eyJ0eXAiOiJkcHBDb24iLCJraWQiOiJwYWtZbXVzd1dCdWpSYTl5OEsweDViaTVrT3VNT3dzZHRlaml2UG55ZHZzIiwiYWxnIjoiRVMyNTYifQ.eyJncm91cHMiOlt7Imdyb3VwSWQiOiIqIiwibmV0Um9sZSI6ImFwIn1dLCJuZXRBY2Nlc3NLZXkiOnsia3R5IjoiRUMiLCJjcnYiOiJQLTI1NiIsIngiOiIybU5vNXZuRkI5bEw3d1VWb1hJbGVPYzBNSEE1QXZKbnpwZXZULVVTYzVNIiwieSI6IlhzS3dqVHJlLTg5WWdpU3pKaG9CN1haeUttTU05OTl3V2ZaSVl0bi01Q3MifX0.XhjFpZgcSa7G2lHy0OCYTvaZFRo5Hyx6b7g7oYyusLC7C_73AJ4_BxEZQVYJXAtDuGvb3dXSkHEKxREP9Q6Qeg"
1125     ap_netaccesskey = "30770201010420ceba752db2ad5200fa7bc565b9c05c69b7eb006751b0b329b0279de1c19ca67ca00a06082a8648ce3d030107a14403420004da6368e6f9c507d94bef0515a1722578e73430703902f267ce97af4fe51273935ec2b08d3adefbcf588224b3261a01ed76722a630cf7df7059f64862d9fee42b"
1126
1127     params = { "ssid": "DPPNET01",
1128                "wpa": "2",
1129                "ieee80211w": "2",
1130                "wpa_key_mgmt": "DPP",
1131                "rsn_pairwise": "CCMP",
1132                "dpp_connector": ap_connector,
1133                "dpp_csign": csign_pub,
1134                "dpp_netaccesskey": ap_netaccesskey }
1135     try:
1136         hapd = hostapd.add_ap(apdev[0], params)
1137     except:
1138         raise HwsimSkip("DPP not supported")
1139
1140     sigma = start_sigma_dut(dev[0].ifname)
1141     try:
1142         dev[0].set("dpp_config_processing", "2")
1143
1144         cmd = "DPP_CONFIGURATOR_ADD key=" + csign
1145         res = dev[1].request(cmd);
1146         if "FAIL" in res:
1147             raise Exception("Failed to add configurator")
1148         conf_id = int(res)
1149
1150         addr = dev[1].own_addr().replace(':', '')
1151         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1152         res = dev[1].request(cmd)
1153         if "FAIL" in res:
1154             raise Exception("Failed to generate bootstrapping info")
1155         id0 = int(res)
1156         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1157
1158         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1159         if "status,COMPLETE" not in res:
1160             raise Exception("dev_exec_action did not succeed: " + res)
1161         hex = res.split(',')[3]
1162         uri = hex.decode('hex')
1163         logger.info("URI from sigma_dut: " + uri)
1164
1165         res = dev[1].request("DPP_QR_CODE " + uri)
1166         if "FAIL" in res:
1167             raise Exception("Failed to parse QR Code URI")
1168         id1 = int(res)
1169
1170         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1171         if "status,COMPLETE" not in res:
1172             raise Exception("dev_exec_action did not succeed: " + res)
1173
1174         t = threading.Thread(target=dpp_init_conf_mutual,
1175                              args=(dev[1], id1, conf_id, id0))
1176         t.start()
1177
1178         cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Mutual,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,20,DPPWaitForConnect,Yes"
1179         if extra:
1180             cmd += extra
1181         res = sigma_dut_cmd(cmd, timeout=25)
1182         t.join()
1183         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
1184             raise Exception("Unexpected result: " + res)
1185     finally:
1186         dev[0].set("dpp_config_processing", "0")
1187         stop_sigma_dut(sigma)
1188
1189 def dpp_resp_conf_mutual(dev, conf_id, uri):
1190     logger.info("Starting DPP responder/configurator in a thread")
1191     dev.set("dpp_configurator_params",
1192             " conf=sta-dpp ssid=%s configurator=%d" % ("DPPNET01".encode("hex"), conf_id));
1193     cmd = "DPP_LISTEN 2437 role=configurator qr=mutual"
1194     if "OK" not in dev.request(cmd):
1195         raise Exception("Failed to initiate DPP listen")
1196     if uri:
1197         ev = dev.wait_event(["DPP-SCAN-PEER-QR-CODE"], timeout=10)
1198         if ev is None:
1199             raise Exception("QR Code scan for mutual authentication not requested")
1200         res = dev.request("DPP_QR_CODE " + uri)
1201         if "FAIL" in res:
1202             raise Exception("Failed to parse QR Code URI")
1203     ev = dev.wait_event(["DPP-CONF-SENT"], timeout=10)
1204     if ev is None:
1205         raise Exception("DPP configuration not completed (Configurator)")
1206     logger.info("DPP responder/configurator done")
1207
1208 def test_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev):
1209     """sigma_dut DPP/QR (mutual) initiator as Enrollee"""
1210     run_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev, False)
1211
1212 def test_sigma_dut_dpp_qr_mutual_init_enrollee_pending(dev, apdev):
1213     """sigma_dut DPP/QR (mutual) initiator as Enrollee (response pending)"""
1214     run_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev, True)
1215
1216 def run_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev, resp_pending):
1217     check_dpp_capab(dev[0])
1218     check_dpp_capab(dev[1])
1219
1220     csign = "30770201010420768240a3fc89d6662d9782f120527fe7fb9edc6366ab0b9c7dde96125cfd250fa00a06082a8648ce3d030107a144034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1221     csign_pub = "3059301306072a8648ce3d020106082a8648ce3d030107034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1222     ap_connector = "eyJ0eXAiOiJkcHBDb24iLCJraWQiOiJwYWtZbXVzd1dCdWpSYTl5OEsweDViaTVrT3VNT3dzZHRlaml2UG55ZHZzIiwiYWxnIjoiRVMyNTYifQ.eyJncm91cHMiOlt7Imdyb3VwSWQiOiIqIiwibmV0Um9sZSI6ImFwIn1dLCJuZXRBY2Nlc3NLZXkiOnsia3R5IjoiRUMiLCJjcnYiOiJQLTI1NiIsIngiOiIybU5vNXZuRkI5bEw3d1VWb1hJbGVPYzBNSEE1QXZKbnpwZXZULVVTYzVNIiwieSI6IlhzS3dqVHJlLTg5WWdpU3pKaG9CN1haeUttTU05OTl3V2ZaSVl0bi01Q3MifX0.XhjFpZgcSa7G2lHy0OCYTvaZFRo5Hyx6b7g7oYyusLC7C_73AJ4_BxEZQVYJXAtDuGvb3dXSkHEKxREP9Q6Qeg"
1223     ap_netaccesskey = "30770201010420ceba752db2ad5200fa7bc565b9c05c69b7eb006751b0b329b0279de1c19ca67ca00a06082a8648ce3d030107a14403420004da6368e6f9c507d94bef0515a1722578e73430703902f267ce97af4fe51273935ec2b08d3adefbcf588224b3261a01ed76722a630cf7df7059f64862d9fee42b"
1224
1225     params = { "ssid": "DPPNET01",
1226                "wpa": "2",
1227                "ieee80211w": "2",
1228                "wpa_key_mgmt": "DPP",
1229                "rsn_pairwise": "CCMP",
1230                "dpp_connector": ap_connector,
1231                "dpp_csign": csign_pub,
1232                "dpp_netaccesskey": ap_netaccesskey }
1233     try:
1234         hapd = hostapd.add_ap(apdev[0], params)
1235     except:
1236         raise HwsimSkip("DPP not supported")
1237
1238     sigma = start_sigma_dut(dev[0].ifname)
1239     try:
1240         dev[0].set("dpp_config_processing", "2")
1241
1242         cmd = "DPP_CONFIGURATOR_ADD key=" + csign
1243         res = dev[1].request(cmd);
1244         if "FAIL" in res:
1245             raise Exception("Failed to add configurator")
1246         conf_id = int(res)
1247
1248         addr = dev[1].own_addr().replace(':', '')
1249         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1250         res = dev[1].request(cmd)
1251         if "FAIL" in res:
1252             raise Exception("Failed to generate bootstrapping info")
1253         id0 = int(res)
1254         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1255
1256         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1257         if "status,COMPLETE" not in res:
1258             raise Exception("dev_exec_action did not succeed: " + res)
1259         hex = res.split(',')[3]
1260         uri = hex.decode('hex')
1261         logger.info("URI from sigma_dut: " + uri)
1262
1263         if not resp_pending:
1264             res = dev[1].request("DPP_QR_CODE " + uri)
1265             if "FAIL" in res:
1266                 raise Exception("Failed to parse QR Code URI")
1267             uri = None
1268
1269         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1270         if "status,COMPLETE" not in res:
1271             raise Exception("dev_exec_action did not succeed: " + res)
1272
1273         t = threading.Thread(target=dpp_resp_conf_mutual,
1274                              args=(dev[1], conf_id, uri))
1275         t.start()
1276
1277         time.sleep(1)
1278         cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,10,DPPWaitForConnect,Yes"
1279         res = sigma_dut_cmd(cmd, timeout=15)
1280         t.join()
1281         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
1282             raise Exception("Unexpected result: " + res)
1283     finally:
1284         dev[0].set("dpp_config_processing", "0")
1285         stop_sigma_dut(sigma)
1286
1287 def test_sigma_dut_dpp_qr_init_enrollee_psk(dev, apdev):
1288     """sigma_dut DPP/QR initiator as Enrollee (PSK)"""
1289     check_dpp_capab(dev[0])
1290     check_dpp_capab(dev[1])
1291
1292     params = hostapd.wpa2_params(ssid="DPPNET01",
1293                                  passphrase="ThisIsDppPassphrase")
1294     hapd = hostapd.add_ap(apdev[0], params)
1295
1296     sigma = start_sigma_dut(dev[0].ifname)
1297     try:
1298         dev[0].set("dpp_config_processing", "2")
1299
1300         cmd = "DPP_CONFIGURATOR_ADD"
1301         res = dev[1].request(cmd);
1302         if "FAIL" in res:
1303             raise Exception("Failed to add configurator")
1304         conf_id = int(res)
1305
1306         addr = dev[1].own_addr().replace(':', '')
1307         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1308         res = dev[1].request(cmd)
1309         if "FAIL" in res:
1310             raise Exception("Failed to generate bootstrapping info")
1311         id0 = int(res)
1312         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1313
1314         dev[1].set("dpp_configurator_params",
1315                    " conf=sta-psk ssid=%s pass=%s configurator=%d" % ("DPPNET01".encode("hex"), "ThisIsDppPassphrase".encode("hex"), conf_id));
1316         cmd = "DPP_LISTEN 2437 role=configurator"
1317         if "OK" not in dev[1].request(cmd):
1318             raise Exception("Failed to start listen operation")
1319
1320         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1321         if "status,COMPLETE" not in res:
1322             raise Exception("dev_exec_action did not succeed: " + res)
1323
1324         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6,DPPWaitForConnect,Yes", timeout=10)
1325         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkConnectResult,OK" not in res:
1326             raise Exception("Unexpected result: " + res)
1327     finally:
1328         dev[0].set("dpp_config_processing", "0")
1329         stop_sigma_dut(sigma)
1330
1331 def test_sigma_dut_dpp_qr_init_configurator_1(dev, apdev):
1332     """sigma_dut DPP/QR initiator as Configurator (conf index 1)"""
1333     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 1)
1334
1335 def test_sigma_dut_dpp_qr_init_configurator_2(dev, apdev):
1336     """sigma_dut DPP/QR initiator as Configurator (conf index 2)"""
1337     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 2)
1338
1339 def test_sigma_dut_dpp_qr_init_configurator_3(dev, apdev):
1340     """sigma_dut DPP/QR initiator as Configurator (conf index 3)"""
1341     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 3)
1342
1343 def test_sigma_dut_dpp_qr_init_configurator_4(dev, apdev):
1344     """sigma_dut DPP/QR initiator as Configurator (conf index 4)"""
1345     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 4)
1346
1347 def test_sigma_dut_dpp_qr_init_configurator_5(dev, apdev):
1348     """sigma_dut DPP/QR initiator as Configurator (conf index 5)"""
1349     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 5)
1350
1351 def test_sigma_dut_dpp_qr_init_configurator_6(dev, apdev):
1352     """sigma_dut DPP/QR initiator as Configurator (conf index 6)"""
1353     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 6)
1354
1355 def test_sigma_dut_dpp_qr_init_configurator_7(dev, apdev):
1356     """sigma_dut DPP/QR initiator as Configurator (conf index 7)"""
1357     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 7)
1358
1359 def test_sigma_dut_dpp_qr_init_configurator_both(dev, apdev):
1360     """sigma_dut DPP/QR initiator as Configurator or Enrollee (conf index 1)"""
1361     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 1, "Both")
1362
1363 def test_sigma_dut_dpp_qr_init_configurator_neg_freq(dev, apdev):
1364     """sigma_dut DPP/QR initiator as Configurator (neg_freq)"""
1365     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 1, extra='DPPSubsequentChannel,81/11')
1366
1367 def run_sigma_dut_dpp_qr_init_configurator(dev, apdev, conf_idx,
1368                                            prov_role="Configurator",
1369                                            extra=None):
1370     check_dpp_capab(dev[0])
1371     check_dpp_capab(dev[1])
1372     sigma = start_sigma_dut(dev[0].ifname)
1373     try:
1374         addr = dev[1].own_addr().replace(':', '')
1375         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1376         res = dev[1].request(cmd)
1377         if "FAIL" in res:
1378             raise Exception("Failed to generate bootstrapping info")
1379         id0 = int(res)
1380         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1381
1382         cmd = "DPP_LISTEN 2437 role=enrollee"
1383         if "OK" not in dev[1].request(cmd):
1384             raise Exception("Failed to start listen operation")
1385
1386         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1387         if "status,COMPLETE" not in res:
1388             raise Exception("dev_exec_action did not succeed: " + res)
1389
1390         cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,%s,DPPConfIndex,%d,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,6" % (prov_role, conf_idx)
1391         if extra:
1392             cmd += "," + extra
1393         res = sigma_dut_cmd(cmd)
1394         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
1395             raise Exception("Unexpected result: " + res)
1396     finally:
1397         stop_sigma_dut(sigma)
1398
1399 def test_sigma_dut_dpp_incompatible_roles_init(dev, apdev):
1400     """sigma_dut DPP roles incompatible (Initiator)"""
1401     check_dpp_capab(dev[0])
1402     check_dpp_capab(dev[1])
1403     sigma = start_sigma_dut(dev[0].ifname)
1404     try:
1405         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1406         if "status,COMPLETE" not in res:
1407             raise Exception("dev_exec_action did not succeed: " + res)
1408         hex = res.split(',')[3]
1409         uri = hex.decode('hex')
1410         logger.info("URI from sigma_dut: " + uri)
1411
1412         res = dev[1].request("DPP_QR_CODE " + uri)
1413         if "FAIL" in res:
1414             raise Exception("Failed to parse QR Code URI")
1415         id1 = int(res)
1416
1417         addr = dev[1].own_addr().replace(':', '')
1418         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1419         res = dev[1].request(cmd)
1420         if "FAIL" in res:
1421             raise Exception("Failed to generate bootstrapping info")
1422         id0 = int(res)
1423         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1424
1425         cmd = "DPP_LISTEN 2437 role=enrollee"
1426         if "OK" not in dev[1].request(cmd):
1427             raise Exception("Failed to start listen operation")
1428
1429         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1430         if "status,COMPLETE" not in res:
1431             raise Exception("dev_exec_action did not succeed: " + res)
1432
1433         cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Mutual,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6"
1434         res = sigma_dut_cmd(cmd)
1435         if "BootstrapResult,OK,AuthResult,ROLES_NOT_COMPATIBLE" not in res:
1436             raise Exception("Unexpected result: " + res)
1437     finally:
1438         stop_sigma_dut(sigma)
1439
1440 def dpp_init_enrollee_mutual(dev, id1, own_id):
1441     logger.info("Starting DPP initiator/enrollee in a thread")
1442     time.sleep(1)
1443     cmd = "DPP_AUTH_INIT peer=%d own=%d role=enrollee" % (id1, own_id)
1444     if "OK" not in dev.request(cmd):
1445         raise Exception("Failed to initiate DPP Authentication")
1446     ev = dev.wait_event(["DPP-CONF-RECEIVED",
1447                          "DPP-NOT-COMPATIBLE"], timeout=5)
1448     if ev is None:
1449         raise Exception("DPP configuration not completed (Enrollee)")
1450     logger.info("DPP initiator/enrollee done")
1451
1452 def test_sigma_dut_dpp_incompatible_roles_resp(dev, apdev):
1453     """sigma_dut DPP roles incompatible (Responder)"""
1454     check_dpp_capab(dev[0])
1455     check_dpp_capab(dev[1])
1456     sigma = start_sigma_dut(dev[0].ifname)
1457     try:
1458         cmd = "dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR"
1459         res = sigma_dut_cmd(cmd)
1460         if "status,COMPLETE" not in res:
1461             raise Exception("dev_exec_action did not succeed: " + res)
1462         hex = res.split(',')[3]
1463         uri = hex.decode('hex')
1464         logger.info("URI from sigma_dut: " + uri)
1465
1466         res = dev[1].request("DPP_QR_CODE " + uri)
1467         if "FAIL" in res:
1468             raise Exception("Failed to parse QR Code URI")
1469         id1 = int(res)
1470
1471         addr = dev[1].own_addr().replace(':', '')
1472         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1473         res = dev[1].request(cmd)
1474         if "FAIL" in res:
1475             raise Exception("Failed to generate bootstrapping info")
1476         id0 = int(res)
1477         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1478
1479         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1480         if "status,COMPLETE" not in res:
1481             raise Exception("dev_exec_action did not succeed: " + res)
1482
1483         t = threading.Thread(target=dpp_init_enrollee_mutual, args=(dev[1], id1, id0))
1484         t.start()
1485         cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Mutual,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6"
1486         res = sigma_dut_cmd(cmd, timeout=10)
1487         t.join()
1488         if "BootstrapResult,OK,AuthResult,ROLES_NOT_COMPATIBLE" not in res:
1489             raise Exception("Unexpected result: " + res)
1490     finally:
1491         stop_sigma_dut(sigma)
1492
1493 def test_sigma_dut_dpp_pkex_init_configurator(dev, apdev):
1494     """sigma_dut DPP/PKEX initiator as Configurator"""
1495     check_dpp_capab(dev[0])
1496     check_dpp_capab(dev[1])
1497     sigma = start_sigma_dut(dev[0].ifname)
1498     try:
1499         cmd = "DPP_BOOTSTRAP_GEN type=pkex"
1500         res = dev[1].request(cmd)
1501         if "FAIL" in res:
1502             raise Exception("Failed to generate bootstrapping info")
1503         id1 = int(res)
1504         cmd = "DPP_PKEX_ADD own=%d identifier=test code=secret" % (id1)
1505         res = dev[1].request(cmd)
1506         if "FAIL" in res:
1507             raise Exception("Failed to set PKEX data (responder)")
1508         cmd = "DPP_LISTEN 2437 role=enrollee"
1509         if "OK" not in dev[1].request(cmd):
1510             raise Exception("Failed to start listen operation")
1511
1512         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,PKEX,DPPPKEXCodeIdentifier,test,DPPPKEXCode,secret,DPPTimeout,6")
1513         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
1514             raise Exception("Unexpected result: " + res)
1515     finally:
1516         stop_sigma_dut(sigma)
1517
1518 def dpp_init_conf(dev, id1, conf, conf_id, extra):
1519     logger.info("Starting DPP initiator/configurator in a thread")
1520     cmd = "DPP_AUTH_INIT peer=%d conf=%s %s configurator=%d" % (id1, conf, extra, conf_id)
1521     if "OK" not in dev.request(cmd):
1522         raise Exception("Failed to initiate DPP Authentication")
1523     ev = dev.wait_event(["DPP-CONF-SENT"], timeout=5)
1524     if ev is None:
1525         raise Exception("DPP configuration not completed (Configurator)")
1526     logger.info("DPP initiator/configurator done")
1527
1528 def test_sigma_dut_ap_dpp_qr(dev, apdev, params):
1529     """sigma_dut controlled AP (DPP)"""
1530     run_sigma_dut_ap_dpp_qr(dev, apdev, params, "ap-dpp", "sta-dpp")
1531
1532 def test_sigma_dut_ap_dpp_qr_legacy(dev, apdev, params):
1533     """sigma_dut controlled AP (legacy)"""
1534     run_sigma_dut_ap_dpp_qr(dev, apdev, params, "ap-psk", "sta-psk",
1535                             extra="pass=%s" % "qwertyuiop".encode("hex"))
1536
1537 def test_sigma_dut_ap_dpp_qr_legacy_psk(dev, apdev, params):
1538     """sigma_dut controlled AP (legacy)"""
1539     run_sigma_dut_ap_dpp_qr(dev, apdev, params, "ap-psk", "sta-psk",
1540                             extra="psk=%s" % (32*"12"))
1541
1542 def run_sigma_dut_ap_dpp_qr(dev, apdev, params, ap_conf, sta_conf, extra=""):
1543     check_dpp_capab(dev[0])
1544     logdir = os.path.join(params['logdir'], "sigma_dut_ap_dpp_qr.sigma-hostapd")
1545     with HWSimRadio() as (radio, iface):
1546         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
1547         try:
1548             sigma_dut_cmd_check("ap_reset_default,program,DPP")
1549             res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1550             if "status,COMPLETE" not in res:
1551                 raise Exception("dev_exec_action did not succeed: " + res)
1552             hex = res.split(',')[3]
1553             uri = hex.decode('hex')
1554             logger.info("URI from sigma_dut: " + uri)
1555
1556             cmd = "DPP_CONFIGURATOR_ADD"
1557             res = dev[0].request(cmd);
1558             if "FAIL" in res:
1559                 raise Exception("Failed to add configurator")
1560             conf_id = int(res)
1561
1562             res = dev[0].request("DPP_QR_CODE " + uri)
1563             if "FAIL" in res:
1564                 raise Exception("Failed to parse QR Code URI")
1565             id1 = int(res)
1566
1567             t = threading.Thread(target=dpp_init_conf,
1568                                  args=(dev[0], id1, ap_conf, conf_id, extra))
1569             t.start()
1570             res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6")
1571             t.join()
1572             if "ConfResult,OK" not in res:
1573                 raise Exception("Unexpected result: " + res)
1574
1575             addr = dev[1].own_addr().replace(':', '')
1576             cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/1 mac=" + addr
1577             res = dev[1].request(cmd)
1578             if "FAIL" in res:
1579                 raise Exception("Failed to generate bootstrapping info")
1580             id1 = int(res)
1581             uri1 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id1)
1582
1583             res = dev[0].request("DPP_QR_CODE " + uri1)
1584             if "FAIL" in res:
1585                 raise Exception("Failed to parse QR Code URI")
1586             id0b = int(res)
1587
1588             dev[1].set("dpp_config_processing", "2")
1589             cmd = "DPP_LISTEN 2412"
1590             if "OK" not in dev[1].request(cmd):
1591                 raise Exception("Failed to start listen operation")
1592             cmd = "DPP_AUTH_INIT peer=%d conf=%s %s configurator=%d" % (id0b, sta_conf, extra, conf_id)
1593             if "OK" not in dev[0].request(cmd):
1594                 raise Exception("Failed to initiate DPP Authentication")
1595             dev[1].wait_connected()
1596
1597             sigma_dut_cmd_check("ap_reset_default")
1598         finally:
1599             dev[1].set("dpp_config_processing", "0")
1600             stop_sigma_dut(sigma)
1601
1602 def test_sigma_dut_ap_dpp_pkex_responder(dev, apdev, params):
1603     """sigma_dut controlled AP as DPP PKEX responder"""
1604     check_dpp_capab(dev[0])
1605     logdir = os.path.join(params['logdir'],
1606                           "sigma_dut_ap_dpp_pkex_responder.sigma-hostapd")
1607     with HWSimRadio() as (radio, iface):
1608         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
1609         try:
1610             run_sigma_dut_ap_dpp_pkex_responder(dev, apdev)
1611         finally:
1612             stop_sigma_dut(sigma)
1613
1614 def dpp_init_conf_pkex(dev, conf_id):
1615     logger.info("Starting DPP PKEX initiator/configurator in a thread")
1616     time.sleep(1.5)
1617     cmd = "DPP_BOOTSTRAP_GEN type=pkex"
1618     res = dev.request(cmd)
1619     if "FAIL" in res:
1620         raise Exception("Failed to generate bootstrapping info")
1621     id = int(res)
1622     cmd = "DPP_PKEX_ADD own=%d init=1 conf=ap-dpp configurator=%d code=password" % (id, conf_id)
1623     res = dev.request(cmd)
1624     if "FAIL" in res:
1625         raise Exception("Failed to initiate DPP PKEX")
1626     ev = dev.wait_event(["DPP-CONF-SENT"], timeout=5)
1627     if ev is None:
1628         raise Exception("DPP configuration not completed (Configurator)")
1629     logger.info("DPP initiator/configurator done")
1630
1631 def run_sigma_dut_ap_dpp_pkex_responder(dev, apdev):
1632     sigma_dut_cmd_check("ap_reset_default,program,DPP")
1633
1634     cmd = "DPP_CONFIGURATOR_ADD"
1635     res = dev[0].request(cmd);
1636     if "FAIL" in res:
1637         raise Exception("Failed to add configurator")
1638     conf_id = int(res)
1639
1640     t = threading.Thread(target=dpp_init_conf_pkex, args=(dev[0], conf_id))
1641     t.start()
1642     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Mutual,DPPProvisioningRole,Enrollee,DPPBS,PKEX,DPPPKEXCode,password,DPPTimeout,6", timeout=10)
1643     t.join()
1644     if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
1645         raise Exception("Unexpected result: " + res)
1646
1647     sigma_dut_cmd_check("ap_reset_default")
1648
1649 def dpp_proto_init(dev, id1):
1650     time.sleep(1)
1651     logger.info("Starting DPP initiator/configurator in a thread")
1652     cmd = "DPP_CONFIGURATOR_ADD"
1653     res = dev.request(cmd);
1654     if "FAIL" in res:
1655         raise Exception("Failed to add configurator")
1656     conf_id = int(res)
1657
1658     cmd = "DPP_AUTH_INIT peer=%d conf=sta-dpp configurator=%d" % (id1, conf_id)
1659     if "OK" not in dev.request(cmd):
1660         raise Exception("Failed to initiate DPP Authentication")
1661
1662 def test_sigma_dut_dpp_proto_initiator(dev, apdev):
1663     """sigma_dut DPP protocol testing - Initiator"""
1664     check_dpp_capab(dev[0])
1665     check_dpp_capab(dev[1])
1666     tests = [ ("InvalidValue", "AuthenticationRequest", "WrappedData",
1667                "BootstrapResult,OK,AuthResult,Errorsent",
1668                None),
1669               ("InvalidValue", "AuthenticationConfirm", "WrappedData",
1670                "BootstrapResult,OK,AuthResult,Errorsent",
1671                None),
1672               ("MissingAttribute", "AuthenticationRequest", "InitCapabilities",
1673                "BootstrapResult,OK,AuthResult,Errorsent",
1674                "Missing or invalid I-capabilities"),
1675               ("InvalidValue", "AuthenticationConfirm", "InitAuthTag",
1676                "BootstrapResult,OK,AuthResult,Errorsent",
1677                "Mismatching Initiator Authenticating Tag"),
1678               ("MissingAttribute", "ConfigurationResponse", "EnrolleeNonce",
1679                "BootstrapResult,OK,AuthResult,OK,ConfResult,Errorsent",
1680                "Missing or invalid Enrollee Nonce attribute") ]
1681     for step, frame, attr, result, fail in tests:
1682         dev[0].request("FLUSH")
1683         dev[1].request("FLUSH")
1684         sigma = start_sigma_dut(dev[0].ifname)
1685         try:
1686             run_sigma_dut_dpp_proto_initiator(dev, step, frame, attr, result,
1687                                               fail)
1688         finally:
1689             stop_sigma_dut(sigma)
1690
1691 def run_sigma_dut_dpp_proto_initiator(dev, step, frame, attr, result, fail):
1692     addr = dev[1].own_addr().replace(':', '')
1693     cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1694     res = dev[1].request(cmd)
1695     if "FAIL" in res:
1696         raise Exception("Failed to generate bootstrapping info")
1697     id0 = int(res)
1698     uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1699
1700     cmd = "DPP_LISTEN 2437 role=enrollee"
1701     if "OK" not in dev[1].request(cmd):
1702         raise Exception("Failed to start listen operation")
1703
1704     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1705     if "status,COMPLETE" not in res:
1706         raise Exception("dev_exec_action did not succeed: " + res)
1707
1708     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,6,DPPStep,%s,DPPFrameType,%s,DPPIEAttribute,%s" % (step, frame, attr),
1709                         timeout=10)
1710     if result not in res:
1711         raise Exception("Unexpected result: " + res)
1712     if fail:
1713         ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
1714         if ev is None or fail not in ev:
1715             raise Exception("Failure not reported correctly: " + str(ev))
1716
1717     dev[1].request("DPP_STOP_LISTEN")
1718     dev[0].dump_monitor()
1719     dev[1].dump_monitor()
1720
1721 def test_sigma_dut_dpp_proto_responder(dev, apdev):
1722     """sigma_dut DPP protocol testing - Responder"""
1723     check_dpp_capab(dev[0])
1724     check_dpp_capab(dev[1])
1725     tests = [ ("MissingAttribute", "AuthenticationResponse", "DPPStatus",
1726                "BootstrapResult,OK,AuthResult,Errorsent",
1727                "Missing or invalid required DPP Status attribute"),
1728               ("MissingAttribute", "ConfigurationRequest", "EnrolleeNonce",
1729                "BootstrapResult,OK,AuthResult,OK,ConfResult,Errorsent",
1730                "Missing or invalid Enrollee Nonce attribute") ]
1731     for step, frame, attr, result, fail in tests:
1732         dev[0].request("FLUSH")
1733         dev[1].request("FLUSH")
1734         sigma = start_sigma_dut(dev[0].ifname)
1735         try:
1736             run_sigma_dut_dpp_proto_responder(dev, step, frame, attr, result,
1737                                               fail)
1738         finally:
1739             stop_sigma_dut(sigma)
1740
1741 def run_sigma_dut_dpp_proto_responder(dev, step, frame, attr, result, fail):
1742     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1743     if "status,COMPLETE" not in res:
1744         raise Exception("dev_exec_action did not succeed: " + res)
1745     hex = res.split(',')[3]
1746     uri = hex.decode('hex')
1747     logger.info("URI from sigma_dut: " + uri)
1748
1749     res = dev[1].request("DPP_QR_CODE " + uri)
1750     if "FAIL" in res:
1751         raise Exception("Failed to parse QR Code URI")
1752     id1 = int(res)
1753
1754     t = threading.Thread(target=dpp_proto_init, args=(dev[1], id1))
1755     t.start()
1756     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,6,DPPStep,%s,DPPFrameType,%s,DPPIEAttribute,%s" % (step, frame, attr), timeout=10)
1757     t.join()
1758     if result not in res:
1759         raise Exception("Unexpected result: " + res)
1760     if fail:
1761         ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
1762         if ev is None or fail not in ev:
1763             raise Exception("Failure not reported correctly:" + str(ev))
1764
1765     dev[1].request("DPP_STOP_LISTEN")
1766     dev[0].dump_monitor()
1767     dev[1].dump_monitor()
1768
1769 def test_sigma_dut_dpp_proto_stop_at_initiator(dev, apdev):
1770     """sigma_dut DPP protocol testing - Stop at RX on Initiator"""
1771     check_dpp_capab(dev[0])
1772     check_dpp_capab(dev[1])
1773     tests = [ ("AuthenticationResponse",
1774                "BootstrapResult,OK,AuthResult,Errorsent",
1775                None),
1776               ("ConfigurationRequest",
1777                "BootstrapResult,OK,AuthResult,OK,ConfResult,Errorsent",
1778                None)]
1779     for frame, result, fail in tests:
1780         dev[0].request("FLUSH")
1781         dev[1].request("FLUSH")
1782         sigma = start_sigma_dut(dev[0].ifname)
1783         try:
1784             run_sigma_dut_dpp_proto_stop_at_initiator(dev, frame, result, fail)
1785         finally:
1786             stop_sigma_dut(sigma)
1787
1788 def run_sigma_dut_dpp_proto_stop_at_initiator(dev, frame, result, fail):
1789     addr = dev[1].own_addr().replace(':', '')
1790     cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1791     res = dev[1].request(cmd)
1792     if "FAIL" in res:
1793         raise Exception("Failed to generate bootstrapping info")
1794     id0 = int(res)
1795     uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1796
1797     cmd = "DPP_LISTEN 2437 role=enrollee"
1798     if "OK" not in dev[1].request(cmd):
1799         raise Exception("Failed to start listen operation")
1800
1801     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1802     if "status,COMPLETE" not in res:
1803         raise Exception("dev_exec_action did not succeed: " + res)
1804
1805     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,6,DPPStep,Timeout,DPPFrameType,%s" % (frame))
1806     if result not in res:
1807         raise Exception("Unexpected result: " + res)
1808     if fail:
1809         ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
1810         if ev is None or fail not in ev:
1811             raise Exception("Failure not reported correctly: " + str(ev))
1812
1813     dev[1].request("DPP_STOP_LISTEN")
1814     dev[0].dump_monitor()
1815     dev[1].dump_monitor()
1816
1817 def test_sigma_dut_dpp_proto_stop_at_responder(dev, apdev):
1818     """sigma_dut DPP protocol testing - Stop at RX on Responder"""
1819     check_dpp_capab(dev[0])
1820     check_dpp_capab(dev[1])
1821     tests = [ ("AuthenticationRequest",
1822                "BootstrapResult,OK,AuthResult,Errorsent",
1823                None),
1824               ("AuthenticationConfirm",
1825                "BootstrapResult,OK,AuthResult,Errorsent",
1826                None) ]
1827     for frame, result, fail in tests:
1828         dev[0].request("FLUSH")
1829         dev[1].request("FLUSH")
1830         sigma = start_sigma_dut(dev[0].ifname)
1831         try:
1832             run_sigma_dut_dpp_proto_stop_at_responder(dev, frame, result, fail)
1833         finally:
1834             stop_sigma_dut(sigma)
1835
1836 def run_sigma_dut_dpp_proto_stop_at_responder(dev, frame, result, fail):
1837     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1838     if "status,COMPLETE" not in res:
1839         raise Exception("dev_exec_action did not succeed: " + res)
1840     hex = res.split(',')[3]
1841     uri = hex.decode('hex')
1842     logger.info("URI from sigma_dut: " + uri)
1843
1844     res = dev[1].request("DPP_QR_CODE " + uri)
1845     if "FAIL" in res:
1846         raise Exception("Failed to parse QR Code URI")
1847     id1 = int(res)
1848
1849     t = threading.Thread(target=dpp_proto_init, args=(dev[1], id1))
1850     t.start()
1851     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,6,DPPStep,Timeout,DPPFrameType,%s" % (frame), timeout=10)
1852     t.join()
1853     if result not in res:
1854         raise Exception("Unexpected result: " + res)
1855     if fail:
1856         ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
1857         if ev is None or fail not in ev:
1858             raise Exception("Failure not reported correctly:" + str(ev))
1859
1860     dev[1].request("DPP_STOP_LISTEN")
1861     dev[0].dump_monitor()
1862     dev[1].dump_monitor()
1863
1864 def dpp_proto_init_pkex(dev):
1865     time.sleep(1)
1866     logger.info("Starting DPP PKEX initiator/configurator in a thread")
1867     cmd = "DPP_CONFIGURATOR_ADD"
1868     res = dev.request(cmd);
1869     if "FAIL" in res:
1870         raise Exception("Failed to add configurator")
1871     conf_id = int(res)
1872
1873     cmd = "DPP_BOOTSTRAP_GEN type=pkex"
1874     res = dev.request(cmd)
1875     if "FAIL" in res:
1876         raise Exception("Failed to generate bootstrapping info")
1877     id = int(res)
1878
1879     cmd = "DPP_PKEX_ADD own=%d init=1 conf=sta-dpp configurator=%d code=secret" % (id, conf_id)
1880     if "FAIL" in dev.request(cmd):
1881         raise Exception("Failed to initiate DPP PKEX")
1882
1883 def test_sigma_dut_dpp_proto_initiator_pkex(dev, apdev):
1884     """sigma_dut DPP protocol testing - Initiator (PKEX)"""
1885     check_dpp_capab(dev[0])
1886     check_dpp_capab(dev[1])
1887     tests = [ ("InvalidValue", "PKEXCRRequest", "WrappedData",
1888                "BootstrapResult,Errorsent",
1889                None),
1890               ("MissingAttribute", "PKEXExchangeRequest", "FiniteCyclicGroup",
1891                "BootstrapResult,Errorsent",
1892                "Missing or invalid Finite Cyclic Group attribute"),
1893               ("MissingAttribute", "PKEXCRRequest", "BSKey",
1894                "BootstrapResult,Errorsent",
1895                "No valid peer bootstrapping key found") ]
1896     for step, frame, attr, result, fail in tests:
1897         dev[0].request("FLUSH")
1898         dev[1].request("FLUSH")
1899         sigma = start_sigma_dut(dev[0].ifname)
1900         try:
1901             run_sigma_dut_dpp_proto_initiator_pkex(dev, step, frame, attr,
1902                                                    result, fail)
1903         finally:
1904             stop_sigma_dut(sigma)
1905
1906 def run_sigma_dut_dpp_proto_initiator_pkex(dev, step, frame, attr, result, fail):
1907     cmd = "DPP_BOOTSTRAP_GEN type=pkex"
1908     res = dev[1].request(cmd)
1909     if "FAIL" in res:
1910         raise Exception("Failed to generate bootstrapping info")
1911     id1 = int(res)
1912
1913     cmd = "DPP_PKEX_ADD own=%d code=secret" % (id1)
1914     res = dev[1].request(cmd)
1915     if "FAIL" in res:
1916         raise Exception("Failed to set PKEX data (responder)")
1917
1918     cmd = "DPP_LISTEN 2437 role=enrollee"
1919     if "OK" not in dev[1].request(cmd):
1920         raise Exception("Failed to start listen operation")
1921
1922     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,PKEX,DPPPKEXCode,secret,DPPTimeout,6,DPPStep,%s,DPPFrameType,%s,DPPIEAttribute,%s" % (step, frame, attr))
1923     if result not in res:
1924         raise Exception("Unexpected result: " + res)
1925     if fail:
1926         ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
1927         if ev is None or fail not in ev:
1928             raise Exception("Failure not reported correctly: " + str(ev))
1929
1930     dev[1].request("DPP_STOP_LISTEN")
1931     dev[0].dump_monitor()
1932     dev[1].dump_monitor()
1933
1934 def test_sigma_dut_dpp_proto_responder_pkex(dev, apdev):
1935     """sigma_dut DPP protocol testing - Responder (PKEX)"""
1936     check_dpp_capab(dev[0])
1937     check_dpp_capab(dev[1])
1938     tests = [ ("InvalidValue", "PKEXCRResponse", "WrappedData",
1939                "BootstrapResult,Errorsent",
1940                None),
1941               ("MissingAttribute", "PKEXExchangeResponse", "DPPStatus",
1942                "BootstrapResult,Errorsent",
1943                "No DPP Status attribute"),
1944               ("MissingAttribute", "PKEXCRResponse", "BSKey",
1945                "BootstrapResult,Errorsent",
1946                "No valid peer bootstrapping key found") ]
1947     for step, frame, attr, result, fail in tests:
1948         dev[0].request("FLUSH")
1949         dev[1].request("FLUSH")
1950         sigma = start_sigma_dut(dev[0].ifname)
1951         try:
1952             run_sigma_dut_dpp_proto_responder_pkex(dev, step, frame, attr,
1953                                                    result, fail)
1954         finally:
1955             stop_sigma_dut(sigma)
1956
1957 def run_sigma_dut_dpp_proto_responder_pkex(dev, step, frame, attr, result, fail):
1958     t = threading.Thread(target=dpp_proto_init_pkex, args=(dev[1],))
1959     t.start()
1960     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,PKEX,DPPPKEXCode,secret,DPPTimeout,6,DPPStep,%s,DPPFrameType,%s,DPPIEAttribute,%s" % (step, frame, attr), timeout=10)
1961     t.join()
1962     if result not in res:
1963         raise Exception("Unexpected result: " + res)
1964     if fail:
1965         ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
1966         if ev is None or fail not in ev:
1967             raise Exception("Failure not reported correctly:" + str(ev))
1968
1969     dev[1].request("DPP_STOP_LISTEN")
1970     dev[0].dump_monitor()
1971     dev[1].dump_monitor()
1972
1973 def init_sigma_dut_dpp_proto_peer_disc_req(dev, apdev):
1974     check_dpp_capab(dev[0])
1975     check_dpp_capab(dev[1])
1976
1977     csign = "30770201010420768240a3fc89d6662d9782f120527fe7fb9edc6366ab0b9c7dde96125cfd250fa00a06082a8648ce3d030107a144034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1978     csign_pub = "3059301306072a8648ce3d020106082a8648ce3d030107034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1979     ap_connector = "eyJ0eXAiOiJkcHBDb24iLCJraWQiOiJwYWtZbXVzd1dCdWpSYTl5OEsweDViaTVrT3VNT3dzZHRlaml2UG55ZHZzIiwiYWxnIjoiRVMyNTYifQ.eyJncm91cHMiOlt7Imdyb3VwSWQiOiIqIiwibmV0Um9sZSI6ImFwIn1dLCJuZXRBY2Nlc3NLZXkiOnsia3R5IjoiRUMiLCJjcnYiOiJQLTI1NiIsIngiOiIybU5vNXZuRkI5bEw3d1VWb1hJbGVPYzBNSEE1QXZKbnpwZXZULVVTYzVNIiwieSI6IlhzS3dqVHJlLTg5WWdpU3pKaG9CN1haeUttTU05OTl3V2ZaSVl0bi01Q3MifX0.XhjFpZgcSa7G2lHy0OCYTvaZFRo5Hyx6b7g7oYyusLC7C_73AJ4_BxEZQVYJXAtDuGvb3dXSkHEKxREP9Q6Qeg"
1980     ap_netaccesskey = "30770201010420ceba752db2ad5200fa7bc565b9c05c69b7eb006751b0b329b0279de1c19ca67ca00a06082a8648ce3d030107a14403420004da6368e6f9c507d94bef0515a1722578e73430703902f267ce97af4fe51273935ec2b08d3adefbcf588224b3261a01ed76722a630cf7df7059f64862d9fee42b"
1981
1982     params = { "ssid": "DPPNET01",
1983                "wpa": "2",
1984                "ieee80211w": "2",
1985                "wpa_key_mgmt": "DPP",
1986                "rsn_pairwise": "CCMP",
1987                "dpp_connector": ap_connector,
1988                "dpp_csign": csign_pub,
1989                "dpp_netaccesskey": ap_netaccesskey }
1990     try:
1991         hapd = hostapd.add_ap(apdev[0], params)
1992     except:
1993         raise HwsimSkip("DPP not supported")
1994
1995     dev[0].set("dpp_config_processing", "2")
1996
1997     cmd = "DPP_CONFIGURATOR_ADD key=" + csign
1998     res = dev[1].request(cmd);
1999     if "FAIL" in res:
2000         raise Exception("Failed to add configurator")
2001     conf_id = int(res)
2002
2003     addr = dev[1].own_addr().replace(':', '')
2004     cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
2005     res = dev[1].request(cmd)
2006     if "FAIL" in res:
2007         raise Exception("Failed to generate bootstrapping info")
2008     id0 = int(res)
2009     uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
2010
2011     dev[1].set("dpp_configurator_params",
2012                " conf=sta-dpp ssid=%s configurator=%d" % ("DPPNET01".encode("hex"), conf_id));
2013     cmd = "DPP_LISTEN 2437 role=configurator"
2014     if "OK" not in dev[1].request(cmd):
2015         raise Exception("Failed to start listen operation")
2016
2017     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
2018     if "status,COMPLETE" not in res:
2019         raise Exception("dev_exec_action did not succeed: " + res)
2020
2021 def test_sigma_dut_dpp_proto_peer_disc_req(dev, apdev):
2022     """sigma_dut DPP protocol testing - Peer Discovery Request"""
2023     sigma = start_sigma_dut(dev[0].ifname)
2024     try:
2025         init_sigma_dut_dpp_proto_peer_disc_req(dev, apdev)
2026
2027         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6,DPPWaitForConnect,Yes,DPPStep,MissingAttribute,DPPFrameType,PeerDiscoveryRequest,DPPIEAttribute,TransactionID", timeout=10)
2028         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,Errorsent" not in res:
2029             raise Exception("Unexpected result: " + res)
2030     finally:
2031         dev[0].set("dpp_config_processing", "0")
2032         stop_sigma_dut(sigma)
2033
2034 def test_sigma_dut_dpp_self_config(dev, apdev):
2035     """sigma_dut DPP Configurator enrolling an AP and using self-configuration"""
2036     check_dpp_capab(dev[0])
2037
2038     hapd = hostapd.add_ap(apdev[0], { "ssid": "unconfigured" })
2039     check_dpp_capab(hapd)
2040
2041     sigma = start_sigma_dut(dev[0].ifname)
2042     try:
2043         dev[0].set("dpp_config_processing", "2")
2044         addr = hapd.own_addr().replace(':', '')
2045         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/1 mac=" + addr
2046         res = hapd.request(cmd)
2047         if "FAIL" in res:
2048             raise Exception("Failed to generate bootstrapping info")
2049         id = int(res)
2050         uri = hapd.request("DPP_BOOTSTRAP_GET_URI %d" % id)
2051
2052         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri.encode('hex'))
2053         if "status,COMPLETE" not in res:
2054             raise Exception("dev_exec_action did not succeed: " + res)
2055
2056         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,AP,DPPBS,QR,DPPTimeout,6")
2057         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
2058             raise Exception("Unexpected result: " + res)
2059         update_hapd_config(hapd)
2060
2061         cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPCryptoIdentifier,P-256,DPPBS,QR,DPPAuthRole,Initiator,DPPProvisioningRole,Configurator,DPPAuthDirection,Single,DPPConfIndex,1,DPPTimeout,6,DPPWaitForConnect,Yes,DPPSelfConfigure,Yes"
2062         res = sigma_dut_cmd(cmd, timeout=10)
2063         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
2064             raise Exception("Unexpected result: " + res)
2065     finally:
2066         stop_sigma_dut(sigma)
2067         dev[0].set("dpp_config_processing", "0")
2068
2069 def test_sigma_dut_ap_dpp_self_config(dev, apdev, params):
2070     """sigma_dut DPP AP Configurator using self-configuration"""
2071     logdir = os.path.join(params['logdir'],
2072                           "sigma_dut_ap_dpp_self_config.sigma-hostapd")
2073     with HWSimRadio() as (radio, iface):
2074         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
2075         try:
2076             run_sigma_dut_ap_dpp_self_config(dev, apdev)
2077         finally:
2078             stop_sigma_dut(sigma)
2079             dev[0].set("dpp_config_processing", "0")
2080
2081 def run_sigma_dut_ap_dpp_self_config(dev, apdev):
2082     check_dpp_capab(dev[0])
2083
2084     sigma_dut_cmd_check("ap_reset_default,program,DPP")
2085
2086     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfEnrolleeRole,AP,DPPBS,QR,DPPConfIndex,1,DPPSelfConfigure,Yes,DPPTimeout,6", timeout=10)
2087     if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
2088             raise Exception("Unexpected result: " + res)
2089
2090     dev[0].set("dpp_config_processing", "2")
2091
2092     addr = dev[0].own_addr().replace(':', '')
2093     cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/11 mac=" + addr
2094     res = dev[0].request(cmd)
2095     if "FAIL" in res:
2096         raise Exception("Failed to generate bootstrapping info")
2097     id = int(res)
2098     uri = dev[0].request("DPP_BOOTSTRAP_GET_URI %d" % id)
2099     cmd = "DPP_LISTEN 2462 role=enrollee"
2100     if "OK" not in dev[0].request(cmd):
2101         raise Exception("Failed to start listen operation")
2102
2103     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri.encode('hex'))
2104     if "status,COMPLETE" not in res:
2105         raise Exception("dev_exec_action did not succeed: " + res)
2106     cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPAuthDirection,Single,DPPProvisioningRole,Configurator,DPPConfIndex,1,DPPSigningKeyECC,P-256,DPPConfEnrolleeRole,STA,DPPBS,QR,DPPTimeout,6"
2107     res = sigma_dut_cmd(cmd)
2108     if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
2109         raise Exception("Unexpected result: " + res)
2110     dev[0].wait_connected()
2111     dev[0].request("DISCONNECT")
2112     dev[0].wait_disconnected()
2113     sigma_dut_cmd_check("ap_reset_default")
2114
2115 def test_sigma_dut_preconfigured_profile(dev, apdev):
2116     """sigma_dut controlled connection using preconfigured profile"""
2117     try:
2118         run_sigma_dut_preconfigured_profile(dev, apdev)
2119     finally:
2120         dev[0].set("ignore_old_scan_res", "0")
2121
2122 def run_sigma_dut_preconfigured_profile(dev, apdev):
2123     ifname = dev[0].ifname
2124     sigma = start_sigma_dut(ifname)
2125
2126     params = hostapd.wpa2_params(ssid="test-psk", passphrase="12345678")
2127     hapd = hostapd.add_ap(apdev[0], params)
2128     dev[0].connect("test-psk", psk="12345678", scan_freq="2412",
2129                    only_add_network=True)
2130
2131     sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
2132     sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s" % (ifname, "test-psk"))
2133     sigma_dut_wait_connected(ifname)
2134     sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
2135     sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
2136     sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
2137
2138     stop_sigma_dut(sigma)
2139
2140 def test_sigma_dut_wps_pbc(dev, apdev):
2141     """sigma_dut and WPS PBC Enrollee"""
2142     try:
2143         run_sigma_dut_wps_pbc(dev, apdev)
2144     finally:
2145         dev[0].set("ignore_old_scan_res", "0")
2146
2147 def run_sigma_dut_wps_pbc(dev, apdev):
2148     ssid = "test-wps-conf"
2149     hapd = hostapd.add_ap(apdev[0],
2150                           { "ssid": "wps", "eap_server": "1", "wps_state": "2",
2151                             "wpa_passphrase": "12345678", "wpa": "2",
2152                             "wpa_key_mgmt": "WPA-PSK", "rsn_pairwise": "CCMP" })
2153     hapd.request("WPS_PBC")
2154
2155     ifname = dev[0].ifname
2156     sigma = start_sigma_dut(ifname)
2157
2158     cmd = "start_wps_registration,interface,%s" % ifname
2159     cmd += ",WpsRole,Enrollee"
2160     cmd += ",WpsConfigMethod,PBC"
2161     sigma_dut_cmd_check(cmd, timeout=15)
2162
2163     sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
2164     hapd.disable()
2165     sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
2166     stop_sigma_dut(sigma)
2167     dev[0].flush_scan_cache()
2168
2169 def test_sigma_dut_sta_scan_bss(dev, apdev):
2170     """sigma_dut sta_scan_bss"""
2171     hapd = hostapd.add_ap(apdev[0], { "ssid": "test" })
2172     sigma = start_sigma_dut(dev[0].ifname)
2173     try:
2174         cmd = "sta_scan_bss,Interface,%s,BSSID,%s" % (dev[0].ifname, \
2175                                                       hapd.own_addr())
2176         res = sigma_dut_cmd(cmd, timeout=10)
2177         if "ssid,test,bsschannel,1" not in res:
2178             raise Exception("Unexpected result: " + res)
2179     finally:
2180         stop_sigma_dut(sigma)