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,PMF,Required,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,PMF,Required,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,PMF,Required")
 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                "wpa_key_mgmt": "DPP",
 974                "rsn_pairwise": "CCMP",
 975                "dpp_connector": ap_connector,
 976                "dpp_csign": csign_pub,
 977                "dpp_netaccesskey": ap_netaccesskey }
 978     try:
 979         hapd = hostapd.add_ap(apdev[0], params)
 980     except:
 981         raise HwsimSkip("DPP not supported")
 982
 983     sigma = start_sigma_dut(dev[0].ifname)
 984     try:
 985         dev[0].set("dpp_config_processing", "2")
 986
 987         cmd = "DPP_CONFIGURATOR_ADD key=" + csign
 988         res = dev[1].request(cmd);
 989         if "FAIL" in res:
 990             raise Exception("Failed to add configurator")
 991         conf_id = int(res)
 992
 993         addr = dev[1].own_addr().replace(':', '')
 994         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
 995         res = dev[1].request(cmd)
 996         if "FAIL" in res:
 997             raise Exception("Failed to generate bootstrapping info")
 998         id0 = int(res)
 999         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1000
1001         dev[1].set("dpp_configurator_params",
1002                    " conf=sta-dpp ssid=%s configurator=%d" % ("DPPNET01".encode("hex"), conf_id));
1003         cmd = "DPP_LISTEN 2437 role=configurator"
1004         if "OK" not in dev[1].request(cmd):
1005             raise Exception("Failed to start listen operation")
1006
1007         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1008         if "status,COMPLETE" not in res:
1009             raise Exception("dev_exec_action did not succeed: " + res)
1010
1011         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)
1012         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
1013             raise Exception("Unexpected result: " + res)
1014     finally:
1015         dev[0].set("dpp_config_processing", "0")
1016         stop_sigma_dut(sigma)
1017
1018 def test_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev):
1019     """sigma_dut DPP/QR (mutual) initiator as Enrollee"""
1020     run_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev)
1021
1022 def test_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev):
1023     """sigma_dut DPP/QR (mutual) initiator as Enrollee (extra check)"""
1024     run_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev,
1025                                                     extra="DPPAuthDirection,Mutual,")
1026
1027 def run_sigma_dut_dpp_qr_mutual_init_enrollee_check(dev, apdev, extra=''):
1028     check_dpp_capab(dev[0])
1029     check_dpp_capab(dev[1])
1030
1031     csign = "30770201010420768240a3fc89d6662d9782f120527fe7fb9edc6366ab0b9c7dde96125cfd250fa00a06082a8648ce3d030107a144034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1032     csign_pub = "3059301306072a8648ce3d020106082a8648ce3d030107034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1033     ap_connector = "eyJ0eXAiOiJkcHBDb24iLCJraWQiOiJwYWtZbXVzd1dCdWpSYTl5OEsweDViaTVrT3VNT3dzZHRlaml2UG55ZHZzIiwiYWxnIjoiRVMyNTYifQ.eyJncm91cHMiOlt7Imdyb3VwSWQiOiIqIiwibmV0Um9sZSI6ImFwIn1dLCJuZXRBY2Nlc3NLZXkiOnsia3R5IjoiRUMiLCJjcnYiOiJQLTI1NiIsIngiOiIybU5vNXZuRkI5bEw3d1VWb1hJbGVPYzBNSEE1QXZKbnpwZXZULVVTYzVNIiwieSI6IlhzS3dqVHJlLTg5WWdpU3pKaG9CN1haeUttTU05OTl3V2ZaSVl0bi01Q3MifX0.XhjFpZgcSa7G2lHy0OCYTvaZFRo5Hyx6b7g7oYyusLC7C_73AJ4_BxEZQVYJXAtDuGvb3dXSkHEKxREP9Q6Qeg"
1034     ap_netaccesskey = "30770201010420ceba752db2ad5200fa7bc565b9c05c69b7eb006751b0b329b0279de1c19ca67ca00a06082a8648ce3d030107a14403420004da6368e6f9c507d94bef0515a1722578e73430703902f267ce97af4fe51273935ec2b08d3adefbcf588224b3261a01ed76722a630cf7df7059f64862d9fee42b"
1035
1036     params = { "ssid": "DPPNET01",
1037                "wpa": "2",
1038                "wpa_key_mgmt": "DPP",
1039                "rsn_pairwise": "CCMP",
1040                "dpp_connector": ap_connector,
1041                "dpp_csign": csign_pub,
1042                "dpp_netaccesskey": ap_netaccesskey }
1043     try:
1044         hapd = hostapd.add_ap(apdev[0], params)
1045     except:
1046         raise HwsimSkip("DPP not supported")
1047
1048     sigma = start_sigma_dut(dev[0].ifname)
1049     try:
1050         dev[0].set("dpp_config_processing", "2")
1051
1052         cmd = "DPP_CONFIGURATOR_ADD key=" + csign
1053         res = dev[1].request(cmd);
1054         if "FAIL" in res:
1055             raise Exception("Failed to add configurator")
1056         conf_id = int(res)
1057
1058         addr = dev[1].own_addr().replace(':', '')
1059         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1060         res = dev[1].request(cmd)
1061         if "FAIL" in res:
1062             raise Exception("Failed to generate bootstrapping info")
1063         id0 = int(res)
1064         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1065
1066         dev[1].set("dpp_configurator_params",
1067                    " conf=sta-dpp ssid=%s configurator=%d" % ("DPPNET01".encode("hex"), conf_id));
1068         cmd = "DPP_LISTEN 2437 role=configurator qr=mutual"
1069         if "OK" not in dev[1].request(cmd):
1070             raise Exception("Failed to start listen operation")
1071
1072         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1073         if "status,COMPLETE" not in res:
1074             raise Exception("dev_exec_action did not succeed: " + res)
1075         hex = res.split(',')[3]
1076         uri = hex.decode('hex')
1077         logger.info("URI from sigma_dut: " + uri)
1078
1079         res = dev[1].request("DPP_QR_CODE " + uri)
1080         if "FAIL" in res:
1081             raise Exception("Failed to parse QR Code URI")
1082         id1 = int(res)
1083
1084         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1085         if "status,COMPLETE" not in res:
1086             raise Exception("dev_exec_action did not succeed: " + res)
1087
1088         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,%sDPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6,DPPWaitForConnect,Yes" % extra, timeout=10)
1089         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
1090             raise Exception("Unexpected result: " + res)
1091     finally:
1092         dev[0].set("dpp_config_processing", "0")
1093         stop_sigma_dut(sigma)
1094
1095 def dpp_init_conf_mutual(dev, id1, conf_id, own_id=None):
1096     time.sleep(1)
1097     logger.info("Starting DPP initiator/configurator in a thread")
1098     cmd = "DPP_AUTH_INIT peer=%d conf=sta-dpp ssid=%s configurator=%d" % (id1, "DPPNET01".encode("hex"), conf_id)
1099     if own_id is not None:
1100         cmd += " own=%d" % own_id
1101     if "OK" not in dev.request(cmd):
1102         raise Exception("Failed to initiate DPP Authentication")
1103     ev = dev.wait_event(["DPP-CONF-SENT"], timeout=10)
1104     if ev is None:
1105         raise Exception("DPP configuration not completed (Configurator)")
1106     logger.info("DPP initiator/configurator done")
1107
1108 def test_sigma_dut_dpp_qr_mutual_resp_enrollee(dev, apdev):
1109     """sigma_dut DPP/QR (mutual) responder as Enrollee"""
1110     run_sigma_dut_dpp_qr_mutual_resp_enrollee(dev, apdev)
1111
1112 def test_sigma_dut_dpp_qr_mutual_resp_enrollee_pending(dev, apdev):
1113     """sigma_dut DPP/QR (mutual) responder as Enrollee (response pending)"""
1114     run_sigma_dut_dpp_qr_mutual_resp_enrollee(dev, apdev, ',DPPDelayQRResponse,1')
1115
1116 def run_sigma_dut_dpp_qr_mutual_resp_enrollee(dev, apdev, extra=None):
1117     check_dpp_capab(dev[0])
1118     check_dpp_capab(dev[1])
1119
1120     csign = "30770201010420768240a3fc89d6662d9782f120527fe7fb9edc6366ab0b9c7dde96125cfd250fa00a06082a8648ce3d030107a144034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1121     csign_pub = "3059301306072a8648ce3d020106082a8648ce3d030107034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1122     ap_connector = "eyJ0eXAiOiJkcHBDb24iLCJraWQiOiJwYWtZbXVzd1dCdWpSYTl5OEsweDViaTVrT3VNT3dzZHRlaml2UG55ZHZzIiwiYWxnIjoiRVMyNTYifQ.eyJncm91cHMiOlt7Imdyb3VwSWQiOiIqIiwibmV0Um9sZSI6ImFwIn1dLCJuZXRBY2Nlc3NLZXkiOnsia3R5IjoiRUMiLCJjcnYiOiJQLTI1NiIsIngiOiIybU5vNXZuRkI5bEw3d1VWb1hJbGVPYzBNSEE1QXZKbnpwZXZULVVTYzVNIiwieSI6IlhzS3dqVHJlLTg5WWdpU3pKaG9CN1haeUttTU05OTl3V2ZaSVl0bi01Q3MifX0.XhjFpZgcSa7G2lHy0OCYTvaZFRo5Hyx6b7g7oYyusLC7C_73AJ4_BxEZQVYJXAtDuGvb3dXSkHEKxREP9Q6Qeg"
1123     ap_netaccesskey = "30770201010420ceba752db2ad5200fa7bc565b9c05c69b7eb006751b0b329b0279de1c19ca67ca00a06082a8648ce3d030107a14403420004da6368e6f9c507d94bef0515a1722578e73430703902f267ce97af4fe51273935ec2b08d3adefbcf588224b3261a01ed76722a630cf7df7059f64862d9fee42b"
1124
1125     params = { "ssid": "DPPNET01",
1126                "wpa": "2",
1127                "wpa_key_mgmt": "DPP",
1128                "rsn_pairwise": "CCMP",
1129                "dpp_connector": ap_connector,
1130                "dpp_csign": csign_pub,
1131                "dpp_netaccesskey": ap_netaccesskey }
1132     try:
1133         hapd = hostapd.add_ap(apdev[0], params)
1134     except:
1135         raise HwsimSkip("DPP not supported")
1136
1137     sigma = start_sigma_dut(dev[0].ifname)
1138     try:
1139         dev[0].set("dpp_config_processing", "2")
1140
1141         cmd = "DPP_CONFIGURATOR_ADD key=" + csign
1142         res = dev[1].request(cmd);
1143         if "FAIL" in res:
1144             raise Exception("Failed to add configurator")
1145         conf_id = int(res)
1146
1147         addr = dev[1].own_addr().replace(':', '')
1148         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1149         res = dev[1].request(cmd)
1150         if "FAIL" in res:
1151             raise Exception("Failed to generate bootstrapping info")
1152         id0 = int(res)
1153         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1154
1155         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1156         if "status,COMPLETE" not in res:
1157             raise Exception("dev_exec_action did not succeed: " + res)
1158         hex = res.split(',')[3]
1159         uri = hex.decode('hex')
1160         logger.info("URI from sigma_dut: " + uri)
1161
1162         res = dev[1].request("DPP_QR_CODE " + uri)
1163         if "FAIL" in res:
1164             raise Exception("Failed to parse QR Code URI")
1165         id1 = int(res)
1166
1167         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1168         if "status,COMPLETE" not in res:
1169             raise Exception("dev_exec_action did not succeed: " + res)
1170
1171         t = threading.Thread(target=dpp_init_conf_mutual,
1172                              args=(dev[1], id1, conf_id, id0))
1173         t.start()
1174
1175         cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Mutual,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,20,DPPWaitForConnect,Yes"
1176         if extra:
1177             cmd += extra
1178         res = sigma_dut_cmd(cmd, timeout=25)
1179         t.join()
1180         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
1181             raise Exception("Unexpected result: " + res)
1182     finally:
1183         dev[0].set("dpp_config_processing", "0")
1184         stop_sigma_dut(sigma)
1185
1186 def dpp_resp_conf_mutual(dev, conf_id, uri):
1187     logger.info("Starting DPP responder/configurator in a thread")
1188     dev.set("dpp_configurator_params",
1189             " conf=sta-dpp ssid=%s configurator=%d" % ("DPPNET01".encode("hex"), conf_id));
1190     cmd = "DPP_LISTEN 2437 role=configurator qr=mutual"
1191     if "OK" not in dev.request(cmd):
1192         raise Exception("Failed to initiate DPP listen")
1193     if uri:
1194         ev = dev.wait_event(["DPP-SCAN-PEER-QR-CODE"], timeout=10)
1195         if ev is None:
1196             raise Exception("QR Code scan for mutual authentication not requested")
1197         res = dev.request("DPP_QR_CODE " + uri)
1198         if "FAIL" in res:
1199             raise Exception("Failed to parse QR Code URI")
1200     ev = dev.wait_event(["DPP-CONF-SENT"], timeout=10)
1201     if ev is None:
1202         raise Exception("DPP configuration not completed (Configurator)")
1203     logger.info("DPP responder/configurator done")
1204
1205 def test_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev):
1206     """sigma_dut DPP/QR (mutual) initiator as Enrollee"""
1207     run_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev, False)
1208
1209 def test_sigma_dut_dpp_qr_mutual_init_enrollee_pending(dev, apdev):
1210     """sigma_dut DPP/QR (mutual) initiator as Enrollee (response pending)"""
1211     run_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev, True)
1212
1213 def run_sigma_dut_dpp_qr_mutual_init_enrollee(dev, apdev, resp_pending):
1214     check_dpp_capab(dev[0])
1215     check_dpp_capab(dev[1])
1216
1217     csign = "30770201010420768240a3fc89d6662d9782f120527fe7fb9edc6366ab0b9c7dde96125cfd250fa00a06082a8648ce3d030107a144034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1218     csign_pub = "3059301306072a8648ce3d020106082a8648ce3d030107034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1219     ap_connector = "eyJ0eXAiOiJkcHBDb24iLCJraWQiOiJwYWtZbXVzd1dCdWpSYTl5OEsweDViaTVrT3VNT3dzZHRlaml2UG55ZHZzIiwiYWxnIjoiRVMyNTYifQ.eyJncm91cHMiOlt7Imdyb3VwSWQiOiIqIiwibmV0Um9sZSI6ImFwIn1dLCJuZXRBY2Nlc3NLZXkiOnsia3R5IjoiRUMiLCJjcnYiOiJQLTI1NiIsIngiOiIybU5vNXZuRkI5bEw3d1VWb1hJbGVPYzBNSEE1QXZKbnpwZXZULVVTYzVNIiwieSI6IlhzS3dqVHJlLTg5WWdpU3pKaG9CN1haeUttTU05OTl3V2ZaSVl0bi01Q3MifX0.XhjFpZgcSa7G2lHy0OCYTvaZFRo5Hyx6b7g7oYyusLC7C_73AJ4_BxEZQVYJXAtDuGvb3dXSkHEKxREP9Q6Qeg"
1220     ap_netaccesskey = "30770201010420ceba752db2ad5200fa7bc565b9c05c69b7eb006751b0b329b0279de1c19ca67ca00a06082a8648ce3d030107a14403420004da6368e6f9c507d94bef0515a1722578e73430703902f267ce97af4fe51273935ec2b08d3adefbcf588224b3261a01ed76722a630cf7df7059f64862d9fee42b"
1221
1222     params = { "ssid": "DPPNET01",
1223                "wpa": "2",
1224                "wpa_key_mgmt": "DPP",
1225                "rsn_pairwise": "CCMP",
1226                "dpp_connector": ap_connector,
1227                "dpp_csign": csign_pub,
1228                "dpp_netaccesskey": ap_netaccesskey }
1229     try:
1230         hapd = hostapd.add_ap(apdev[0], params)
1231     except:
1232         raise HwsimSkip("DPP not supported")
1233
1234     sigma = start_sigma_dut(dev[0].ifname)
1235     try:
1236         dev[0].set("dpp_config_processing", "2")
1237
1238         cmd = "DPP_CONFIGURATOR_ADD key=" + csign
1239         res = dev[1].request(cmd);
1240         if "FAIL" in res:
1241             raise Exception("Failed to add configurator")
1242         conf_id = int(res)
1243
1244         addr = dev[1].own_addr().replace(':', '')
1245         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1246         res = dev[1].request(cmd)
1247         if "FAIL" in res:
1248             raise Exception("Failed to generate bootstrapping info")
1249         id0 = int(res)
1250         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1251
1252         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1253         if "status,COMPLETE" not in res:
1254             raise Exception("dev_exec_action did not succeed: " + res)
1255         hex = res.split(',')[3]
1256         uri = hex.decode('hex')
1257         logger.info("URI from sigma_dut: " + uri)
1258
1259         if not resp_pending:
1260             res = dev[1].request("DPP_QR_CODE " + uri)
1261             if "FAIL" in res:
1262                 raise Exception("Failed to parse QR Code URI")
1263             uri = None
1264
1265         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1266         if "status,COMPLETE" not in res:
1267             raise Exception("dev_exec_action did not succeed: " + res)
1268
1269         t = threading.Thread(target=dpp_resp_conf_mutual,
1270                              args=(dev[1], conf_id, uri))
1271         t.start()
1272
1273         time.sleep(1)
1274         cmd = "dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Initiator,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,10,DPPWaitForConnect,Yes"
1275         res = sigma_dut_cmd(cmd, timeout=15)
1276         t.join()
1277         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
1278             raise Exception("Unexpected result: " + res)
1279     finally:
1280         dev[0].set("dpp_config_processing", "0")
1281         stop_sigma_dut(sigma)
1282
1283 def test_sigma_dut_dpp_qr_init_enrollee_psk(dev, apdev):
1284     """sigma_dut DPP/QR initiator as Enrollee (PSK)"""
1285     check_dpp_capab(dev[0])
1286     check_dpp_capab(dev[1])
1287
1288     params = hostapd.wpa2_params(ssid="DPPNET01",
1289                                  passphrase="ThisIsDppPassphrase")
1290     hapd = hostapd.add_ap(apdev[0], params)
1291
1292     sigma = start_sigma_dut(dev[0].ifname)
1293     try:
1294         dev[0].set("dpp_config_processing", "2")
1295
1296         cmd = "DPP_CONFIGURATOR_ADD"
1297         res = dev[1].request(cmd);
1298         if "FAIL" in res:
1299             raise Exception("Failed to add configurator")
1300         conf_id = int(res)
1301
1302         addr = dev[1].own_addr().replace(':', '')
1303         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1304         res = dev[1].request(cmd)
1305         if "FAIL" in res:
1306             raise Exception("Failed to generate bootstrapping info")
1307         id0 = int(res)
1308         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1309
1310         dev[1].set("dpp_configurator_params",
1311                    " conf=sta-psk ssid=%s pass=%s configurator=%d" % ("DPPNET01".encode("hex"), "ThisIsDppPassphrase".encode("hex"), conf_id));
1312         cmd = "DPP_LISTEN 2437 role=configurator"
1313         if "OK" not in dev[1].request(cmd):
1314             raise Exception("Failed to start listen operation")
1315
1316         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1317         if "status,COMPLETE" not in res:
1318             raise Exception("dev_exec_action did not succeed: " + res)
1319
1320         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)
1321         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkConnectResult,OK" not in res:
1322             raise Exception("Unexpected result: " + res)
1323     finally:
1324         dev[0].set("dpp_config_processing", "0")
1325         stop_sigma_dut(sigma)
1326
1327 def test_sigma_dut_dpp_qr_init_configurator_1(dev, apdev):
1328     """sigma_dut DPP/QR initiator as Configurator (conf index 1)"""
1329     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 1)
1330
1331 def test_sigma_dut_dpp_qr_init_configurator_2(dev, apdev):
1332     """sigma_dut DPP/QR initiator as Configurator (conf index 2)"""
1333     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 2)
1334
1335 def test_sigma_dut_dpp_qr_init_configurator_3(dev, apdev):
1336     """sigma_dut DPP/QR initiator as Configurator (conf index 3)"""
1337     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 3)
1338
1339 def test_sigma_dut_dpp_qr_init_configurator_4(dev, apdev):
1340     """sigma_dut DPP/QR initiator as Configurator (conf index 4)"""
1341     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 4)
1342
1343 def test_sigma_dut_dpp_qr_init_configurator_5(dev, apdev):
1344     """sigma_dut DPP/QR initiator as Configurator (conf index 5)"""
1345     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 5)
1346
1347 def test_sigma_dut_dpp_qr_init_configurator_6(dev, apdev):
1348     """sigma_dut DPP/QR initiator as Configurator (conf index 6)"""
1349     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 6)
1350
1351 def test_sigma_dut_dpp_qr_init_configurator_7(dev, apdev):
1352     """sigma_dut DPP/QR initiator as Configurator (conf index 7)"""
1353     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 7)
1354
1355 def test_sigma_dut_dpp_qr_init_configurator_both(dev, apdev):
1356     """sigma_dut DPP/QR initiator as Configurator or Enrollee (conf index 1)"""
1357     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 1, "Both")
1358
1359 def test_sigma_dut_dpp_qr_init_configurator_neg_freq(dev, apdev):
1360     """sigma_dut DPP/QR initiator as Configurator (neg_freq)"""
1361     run_sigma_dut_dpp_qr_init_configurator(dev, apdev, 1, extra='DPPSubsequentChannel,81/11')
1362
1363 def run_sigma_dut_dpp_qr_init_configurator(dev, apdev, conf_idx,
1364                                            prov_role="Configurator",
1365                                            extra=None):
1366     check_dpp_capab(dev[0])
1367     check_dpp_capab(dev[1])
1368     sigma = start_sigma_dut(dev[0].ifname)
1369     try:
1370         addr = dev[1].own_addr().replace(':', '')
1371         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1372         res = dev[1].request(cmd)
1373         if "FAIL" in res:
1374             raise Exception("Failed to generate bootstrapping info")
1375         id0 = int(res)
1376         uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1377
1378         cmd = "DPP_LISTEN 2437 role=enrollee"
1379         if "OK" not in dev[1].request(cmd):
1380             raise Exception("Failed to start listen operation")
1381
1382         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1383         if "status,COMPLETE" not in res:
1384             raise Exception("dev_exec_action did not succeed: " + res)
1385
1386         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)
1387         if extra:
1388             cmd += "," + extra
1389         res = sigma_dut_cmd(cmd)
1390         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
1391             raise Exception("Unexpected result: " + res)
1392     finally:
1393         stop_sigma_dut(sigma)
1394
1395 def test_sigma_dut_dpp_pkex_init_configurator(dev, apdev):
1396     """sigma_dut DPP/PKEX initiator as Configurator"""
1397     check_dpp_capab(dev[0])
1398     check_dpp_capab(dev[1])
1399     sigma = start_sigma_dut(dev[0].ifname)
1400     try:
1401         cmd = "DPP_BOOTSTRAP_GEN type=pkex"
1402         res = dev[1].request(cmd)
1403         if "FAIL" in res:
1404             raise Exception("Failed to generate bootstrapping info")
1405         id1 = int(res)
1406         cmd = "DPP_PKEX_ADD own=%d identifier=test code=secret" % (id1)
1407         res = dev[1].request(cmd)
1408         if "FAIL" in res:
1409             raise Exception("Failed to set PKEX data (responder)")
1410         cmd = "DPP_LISTEN 2437 role=enrollee"
1411         if "OK" not in dev[1].request(cmd):
1412             raise Exception("Failed to start listen operation")
1413
1414         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")
1415         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
1416             raise Exception("Unexpected result: " + res)
1417     finally:
1418         stop_sigma_dut(sigma)
1419
1420 def dpp_init_conf(dev, id1, conf, conf_id, extra):
1421     logger.info("Starting DPP initiator/configurator in a thread")
1422     cmd = "DPP_AUTH_INIT peer=%d conf=%s %s configurator=%d" % (id1, conf, extra, conf_id)
1423     if "OK" not in dev.request(cmd):
1424         raise Exception("Failed to initiate DPP Authentication")
1425     ev = dev.wait_event(["DPP-CONF-SENT"], timeout=5)
1426     if ev is None:
1427         raise Exception("DPP configuration not completed (Configurator)")
1428     logger.info("DPP initiator/configurator done")
1429
1430 def test_sigma_dut_ap_dpp_qr(dev, apdev, params):
1431     """sigma_dut controlled AP (DPP)"""
1432     run_sigma_dut_ap_dpp_qr(dev, apdev, params, "ap-dpp", "sta-dpp")
1433
1434 def test_sigma_dut_ap_dpp_qr_legacy(dev, apdev, params):
1435     """sigma_dut controlled AP (legacy)"""
1436     run_sigma_dut_ap_dpp_qr(dev, apdev, params, "ap-psk", "sta-psk",
1437                             extra="pass=%s" % "qwertyuiop".encode("hex"))
1438
1439 def test_sigma_dut_ap_dpp_qr_legacy_psk(dev, apdev, params):
1440     """sigma_dut controlled AP (legacy)"""
1441     run_sigma_dut_ap_dpp_qr(dev, apdev, params, "ap-psk", "sta-psk",
1442                             extra="psk=%s" % (32*"12"))
1443
1444 def run_sigma_dut_ap_dpp_qr(dev, apdev, params, ap_conf, sta_conf, extra=""):
1445     check_dpp_capab(dev[0])
1446     logdir = os.path.join(params['logdir'], "sigma_dut_ap_dpp_qr.sigma-hostapd")
1447     with HWSimRadio() as (radio, iface):
1448         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
1449         try:
1450             sigma_dut_cmd_check("ap_reset_default,program,DPP")
1451             res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1452             if "status,COMPLETE" not in res:
1453                 raise Exception("dev_exec_action did not succeed: " + res)
1454             hex = res.split(',')[3]
1455             uri = hex.decode('hex')
1456             logger.info("URI from sigma_dut: " + uri)
1457
1458             cmd = "DPP_CONFIGURATOR_ADD"
1459             res = dev[0].request(cmd);
1460             if "FAIL" in res:
1461                 raise Exception("Failed to add configurator")
1462             conf_id = int(res)
1463
1464             res = dev[0].request("DPP_QR_CODE " + uri)
1465             if "FAIL" in res:
1466                 raise Exception("Failed to parse QR Code URI")
1467             id1 = int(res)
1468
1469             t = threading.Thread(target=dpp_init_conf,
1470                                  args=(dev[0], id1, ap_conf, conf_id, extra))
1471             t.start()
1472             res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,AutomaticDPP,DPPAuthRole,Responder,DPPAuthDirection,Single,DPPProvisioningRole,Enrollee,DPPBS,QR,DPPTimeout,6")
1473             t.join()
1474             if "ConfResult,OK" not in res:
1475                 raise Exception("Unexpected result: " + res)
1476
1477             addr = dev[1].own_addr().replace(':', '')
1478             cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/1 mac=" + addr
1479             res = dev[1].request(cmd)
1480             if "FAIL" in res:
1481                 raise Exception("Failed to generate bootstrapping info")
1482             id1 = int(res)
1483             uri1 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id1)
1484
1485             res = dev[0].request("DPP_QR_CODE " + uri1)
1486             if "FAIL" in res:
1487                 raise Exception("Failed to parse QR Code URI")
1488             id0b = int(res)
1489
1490             dev[1].set("dpp_config_processing", "2")
1491             cmd = "DPP_LISTEN 2412"
1492             if "OK" not in dev[1].request(cmd):
1493                 raise Exception("Failed to start listen operation")
1494             cmd = "DPP_AUTH_INIT peer=%d conf=%s %s configurator=%d" % (id0b, sta_conf, extra, conf_id)
1495             if "OK" not in dev[0].request(cmd):
1496                 raise Exception("Failed to initiate DPP Authentication")
1497             dev[1].wait_connected()
1498
1499             sigma_dut_cmd_check("ap_reset_default")
1500         finally:
1501             dev[1].set("dpp_config_processing", "0")
1502             stop_sigma_dut(sigma)
1503
1504 def test_sigma_dut_ap_dpp_pkex_responder(dev, apdev, params):
1505     """sigma_dut controlled AP as DPP PKEX responder"""
1506     check_dpp_capab(dev[0])
1507     logdir = os.path.join(params['logdir'],
1508                           "sigma_dut_ap_dpp_pkex_responder.sigma-hostapd")
1509     with HWSimRadio() as (radio, iface):
1510         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
1511         try:
1512             run_sigma_dut_ap_dpp_pkex_responder(dev, apdev)
1513         finally:
1514             stop_sigma_dut(sigma)
1515
1516 def dpp_init_conf_pkex(dev, conf_id):
1517     logger.info("Starting DPP PKEX initiator/configurator in a thread")
1518     time.sleep(1.5)
1519     cmd = "DPP_BOOTSTRAP_GEN type=pkex"
1520     res = dev.request(cmd)
1521     if "FAIL" in res:
1522         raise Exception("Failed to generate bootstrapping info")
1523     id = int(res)
1524     cmd = "DPP_PKEX_ADD own=%d init=1 conf=ap-dpp configurator=%d code=password" % (id, conf_id)
1525     res = dev.request(cmd)
1526     if "FAIL" in res:
1527         raise Exception("Failed to initiate DPP PKEX")
1528     ev = dev.wait_event(["DPP-CONF-SENT"], timeout=5)
1529     if ev is None:
1530         raise Exception("DPP configuration not completed (Configurator)")
1531     logger.info("DPP initiator/configurator done")
1532
1533 def run_sigma_dut_ap_dpp_pkex_responder(dev, apdev):
1534     sigma_dut_cmd_check("ap_reset_default,program,DPP")
1535
1536     cmd = "DPP_CONFIGURATOR_ADD"
1537     res = dev[0].request(cmd);
1538     if "FAIL" in res:
1539         raise Exception("Failed to add configurator")
1540     conf_id = int(res)
1541
1542     t = threading.Thread(target=dpp_init_conf_pkex, args=(dev[0], conf_id))
1543     t.start()
1544     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)
1545     t.join()
1546     if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
1547         raise Exception("Unexpected result: " + res)
1548
1549     sigma_dut_cmd_check("ap_reset_default")
1550
1551 def dpp_proto_init(dev, id1):
1552     time.sleep(1)
1553     logger.info("Starting DPP initiator/configurator in a thread")
1554     cmd = "DPP_CONFIGURATOR_ADD"
1555     res = dev.request(cmd);
1556     if "FAIL" in res:
1557         raise Exception("Failed to add configurator")
1558     conf_id = int(res)
1559
1560     cmd = "DPP_AUTH_INIT peer=%d conf=sta-dpp configurator=%d" % (id1, conf_id)
1561     if "OK" not in dev.request(cmd):
1562         raise Exception("Failed to initiate DPP Authentication")
1563
1564 def test_sigma_dut_dpp_proto_initiator(dev, apdev):
1565     """sigma_dut DPP protocol testing - Initiator"""
1566     check_dpp_capab(dev[0])
1567     check_dpp_capab(dev[1])
1568     tests = [ ("InvalidValue", "AuthenticationRequest", "WrappedData",
1569                "BootstrapResult,OK,AuthResult,Errorsent",
1570                None),
1571               ("InvalidValue", "AuthenticationConfirm", "WrappedData",
1572                "BootstrapResult,OK,AuthResult,Errorsent",
1573                None),
1574               ("MissingAttribute", "AuthenticationRequest", "InitCapabilities",
1575                "BootstrapResult,OK,AuthResult,Errorsent",
1576                "Missing or invalid I-capabilities"),
1577               ("InvalidValue", "AuthenticationConfirm", "InitAuthTag",
1578                "BootstrapResult,OK,AuthResult,Errorsent",
1579                "Mismatching Initiator Authenticating Tag"),
1580               ("MissingAttribute", "ConfigurationResponse", "EnrolleeNonce",
1581                "BootstrapResult,OK,AuthResult,OK,ConfResult,Errorsent",
1582                "Missing or invalid Enrollee Nonce attribute") ]
1583     for step, frame, attr, result, fail in tests:
1584         dev[0].request("FLUSH")
1585         dev[1].request("FLUSH")
1586         sigma = start_sigma_dut(dev[0].ifname)
1587         try:
1588             run_sigma_dut_dpp_proto_initiator(dev, step, frame, attr, result,
1589                                               fail)
1590         finally:
1591             stop_sigma_dut(sigma)
1592
1593 def run_sigma_dut_dpp_proto_initiator(dev, step, frame, attr, result, fail):
1594     addr = dev[1].own_addr().replace(':', '')
1595     cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1596     res = dev[1].request(cmd)
1597     if "FAIL" in res:
1598         raise Exception("Failed to generate bootstrapping info")
1599     id0 = int(res)
1600     uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1601
1602     cmd = "DPP_LISTEN 2437 role=enrollee"
1603     if "OK" not in dev[1].request(cmd):
1604         raise Exception("Failed to start listen operation")
1605
1606     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1607     if "status,COMPLETE" not in res:
1608         raise Exception("dev_exec_action did not succeed: " + res)
1609
1610     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))
1611     if result not in res:
1612         raise Exception("Unexpected result: " + res)
1613     if fail:
1614         ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
1615         if ev is None or fail not in ev:
1616             raise Exception("Failure not reported correctly: " + str(ev))
1617
1618     dev[1].request("DPP_STOP_LISTEN")
1619     dev[0].dump_monitor()
1620     dev[1].dump_monitor()
1621
1622 def test_sigma_dut_dpp_proto_responder(dev, apdev):
1623     """sigma_dut DPP protocol testing - Responder"""
1624     check_dpp_capab(dev[0])
1625     check_dpp_capab(dev[1])
1626     tests = [ ("MissingAttribute", "AuthenticationResponse", "DPPStatus",
1627                "BootstrapResult,OK,AuthResult,Errorsent",
1628                "Missing or invalid required DPP Status attribute"),
1629               ("MissingAttribute", "ConfigurationRequest", "EnrolleeNonce",
1630                "BootstrapResult,OK,AuthResult,OK,ConfResult,Errorsent",
1631                "Missing or invalid Enrollee Nonce attribute") ]
1632     for step, frame, attr, result, fail in tests:
1633         dev[0].request("FLUSH")
1634         dev[1].request("FLUSH")
1635         sigma = start_sigma_dut(dev[0].ifname)
1636         try:
1637             run_sigma_dut_dpp_proto_responder(dev, step, frame, attr, result,
1638                                               fail)
1639         finally:
1640             stop_sigma_dut(sigma)
1641
1642 def run_sigma_dut_dpp_proto_responder(dev, step, frame, attr, result, fail):
1643     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1644     if "status,COMPLETE" not in res:
1645         raise Exception("dev_exec_action did not succeed: " + res)
1646     hex = res.split(',')[3]
1647     uri = hex.decode('hex')
1648     logger.info("URI from sigma_dut: " + uri)
1649
1650     res = dev[1].request("DPP_QR_CODE " + uri)
1651     if "FAIL" in res:
1652         raise Exception("Failed to parse QR Code URI")
1653     id1 = int(res)
1654
1655     t = threading.Thread(target=dpp_proto_init, args=(dev[1], id1))
1656     t.start()
1657     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)
1658     t.join()
1659     if result not in res:
1660         raise Exception("Unexpected result: " + res)
1661     if fail:
1662         ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
1663         if ev is None or fail not in ev:
1664             raise Exception("Failure not reported correctly:" + str(ev))
1665
1666     dev[1].request("DPP_STOP_LISTEN")
1667     dev[0].dump_monitor()
1668     dev[1].dump_monitor()
1669
1670 def test_sigma_dut_dpp_proto_stop_at_initiator(dev, apdev):
1671     """sigma_dut DPP protocol testing - Stop at RX on Initiator"""
1672     check_dpp_capab(dev[0])
1673     check_dpp_capab(dev[1])
1674     tests = [ ("AuthenticationResponse",
1675                "BootstrapResult,OK,AuthResult,Errorsent",
1676                None),
1677               ("ConfigurationRequest",
1678                "BootstrapResult,OK,AuthResult,OK,ConfResult,Errorsent",
1679                None)]
1680     for frame, result, fail in tests:
1681         dev[0].request("FLUSH")
1682         dev[1].request("FLUSH")
1683         sigma = start_sigma_dut(dev[0].ifname)
1684         try:
1685             run_sigma_dut_dpp_proto_stop_at_initiator(dev, frame, result, fail)
1686         finally:
1687             stop_sigma_dut(sigma)
1688
1689 def run_sigma_dut_dpp_proto_stop_at_initiator(dev, frame, result, fail):
1690     addr = dev[1].own_addr().replace(':', '')
1691     cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1692     res = dev[1].request(cmd)
1693     if "FAIL" in res:
1694         raise Exception("Failed to generate bootstrapping info")
1695     id0 = int(res)
1696     uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1697
1698     cmd = "DPP_LISTEN 2437 role=enrollee"
1699     if "OK" not in dev[1].request(cmd):
1700         raise Exception("Failed to start listen operation")
1701
1702     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1703     if "status,COMPLETE" not in res:
1704         raise Exception("dev_exec_action did not succeed: " + res)
1705
1706     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))
1707     if result not in res:
1708         raise Exception("Unexpected result: " + res)
1709     if fail:
1710         ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
1711         if ev is None or fail not in ev:
1712             raise Exception("Failure not reported correctly: " + str(ev))
1713
1714     dev[1].request("DPP_STOP_LISTEN")
1715     dev[0].dump_monitor()
1716     dev[1].dump_monitor()
1717
1718 def test_sigma_dut_dpp_proto_stop_at_responder(dev, apdev):
1719     """sigma_dut DPP protocol testing - Stop at RX on Responder"""
1720     check_dpp_capab(dev[0])
1721     check_dpp_capab(dev[1])
1722     tests = [ ("AuthenticationRequest",
1723                "BootstrapResult,OK,AuthResult,Errorsent",
1724                None),
1725               ("AuthenticationConfirm",
1726                "BootstrapResult,OK,AuthResult,Errorsent",
1727                None) ]
1728     for frame, result, fail in tests:
1729         dev[0].request("FLUSH")
1730         dev[1].request("FLUSH")
1731         sigma = start_sigma_dut(dev[0].ifname)
1732         try:
1733             run_sigma_dut_dpp_proto_stop_at_responder(dev, frame, result, fail)
1734         finally:
1735             stop_sigma_dut(sigma)
1736
1737 def run_sigma_dut_dpp_proto_stop_at_responder(dev, frame, result, fail):
1738     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,GetLocalBootstrap,DPPCryptoIdentifier,P-256,DPPBS,QR")
1739     if "status,COMPLETE" not in res:
1740         raise Exception("dev_exec_action did not succeed: " + res)
1741     hex = res.split(',')[3]
1742     uri = hex.decode('hex')
1743     logger.info("URI from sigma_dut: " + uri)
1744
1745     res = dev[1].request("DPP_QR_CODE " + uri)
1746     if "FAIL" in res:
1747         raise Exception("Failed to parse QR Code URI")
1748     id1 = int(res)
1749
1750     t = threading.Thread(target=dpp_proto_init, args=(dev[1], id1))
1751     t.start()
1752     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)
1753     t.join()
1754     if result not in res:
1755         raise Exception("Unexpected result: " + res)
1756     if fail:
1757         ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
1758         if ev is None or fail not in ev:
1759             raise Exception("Failure not reported correctly:" + str(ev))
1760
1761     dev[1].request("DPP_STOP_LISTEN")
1762     dev[0].dump_monitor()
1763     dev[1].dump_monitor()
1764
1765 def dpp_proto_init_pkex(dev):
1766     time.sleep(1)
1767     logger.info("Starting DPP PKEX initiator/configurator in a thread")
1768     cmd = "DPP_CONFIGURATOR_ADD"
1769     res = dev.request(cmd);
1770     if "FAIL" in res:
1771         raise Exception("Failed to add configurator")
1772     conf_id = int(res)
1773
1774     cmd = "DPP_BOOTSTRAP_GEN type=pkex"
1775     res = dev.request(cmd)
1776     if "FAIL" in res:
1777         raise Exception("Failed to generate bootstrapping info")
1778     id = int(res)
1779
1780     cmd = "DPP_PKEX_ADD own=%d init=1 conf=sta-dpp configurator=%d code=secret" % (id, conf_id)
1781     if "FAIL" in dev.request(cmd):
1782         raise Exception("Failed to initiate DPP PKEX")
1783
1784 def test_sigma_dut_dpp_proto_initiator_pkex(dev, apdev):
1785     """sigma_dut DPP protocol testing - Initiator (PKEX)"""
1786     check_dpp_capab(dev[0])
1787     check_dpp_capab(dev[1])
1788     tests = [ ("InvalidValue", "PKEXCRRequest", "WrappedData",
1789                "BootstrapResult,Errorsent",
1790                None),
1791               ("MissingAttribute", "PKEXExchangeRequest", "FiniteCyclicGroup",
1792                "BootstrapResult,Errorsent",
1793                "Missing or invalid Finite Cyclic Group attribute"),
1794               ("MissingAttribute", "PKEXCRRequest", "BSKey",
1795                "BootstrapResult,Errorsent",
1796                "No valid peer bootstrapping key found") ]
1797     for step, frame, attr, result, fail in tests:
1798         dev[0].request("FLUSH")
1799         dev[1].request("FLUSH")
1800         sigma = start_sigma_dut(dev[0].ifname)
1801         try:
1802             run_sigma_dut_dpp_proto_initiator_pkex(dev, step, frame, attr,
1803                                                    result, fail)
1804         finally:
1805             stop_sigma_dut(sigma)
1806
1807 def run_sigma_dut_dpp_proto_initiator_pkex(dev, step, frame, attr, result, fail):
1808     cmd = "DPP_BOOTSTRAP_GEN type=pkex"
1809     res = dev[1].request(cmd)
1810     if "FAIL" in res:
1811         raise Exception("Failed to generate bootstrapping info")
1812     id1 = int(res)
1813
1814     cmd = "DPP_PKEX_ADD own=%d code=secret" % (id1)
1815     res = dev[1].request(cmd)
1816     if "FAIL" in res:
1817         raise Exception("Failed to set PKEX data (responder)")
1818
1819     cmd = "DPP_LISTEN 2437 role=enrollee"
1820     if "OK" not in dev[1].request(cmd):
1821         raise Exception("Failed to start listen operation")
1822
1823     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))
1824     if result not in res:
1825         raise Exception("Unexpected result: " + res)
1826     if fail:
1827         ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
1828         if ev is None or fail not in ev:
1829             raise Exception("Failure not reported correctly: " + str(ev))
1830
1831     dev[1].request("DPP_STOP_LISTEN")
1832     dev[0].dump_monitor()
1833     dev[1].dump_monitor()
1834
1835 def test_sigma_dut_dpp_proto_responder_pkex(dev, apdev):
1836     """sigma_dut DPP protocol testing - Responder (PKEX)"""
1837     check_dpp_capab(dev[0])
1838     check_dpp_capab(dev[1])
1839     tests = [ ("InvalidValue", "PKEXCRResponse", "WrappedData",
1840                "BootstrapResult,Errorsent",
1841                None),
1842               ("MissingAttribute", "PKEXExchangeResponse", "DPPStatus",
1843                "BootstrapResult,Errorsent",
1844                "No DPP Status attribute"),
1845               ("MissingAttribute", "PKEXCRResponse", "BSKey",
1846                "BootstrapResult,Errorsent",
1847                "No valid peer bootstrapping key found") ]
1848     for step, frame, attr, result, fail in tests:
1849         dev[0].request("FLUSH")
1850         dev[1].request("FLUSH")
1851         sigma = start_sigma_dut(dev[0].ifname)
1852         try:
1853             run_sigma_dut_dpp_proto_responder_pkex(dev, step, frame, attr,
1854                                                    result, fail)
1855         finally:
1856             stop_sigma_dut(sigma)
1857
1858 def run_sigma_dut_dpp_proto_responder_pkex(dev, step, frame, attr, result, fail):
1859     t = threading.Thread(target=dpp_proto_init_pkex, args=(dev[1],))
1860     t.start()
1861     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)
1862     t.join()
1863     if result not in res:
1864         raise Exception("Unexpected result: " + res)
1865     if fail:
1866         ev = dev[1].wait_event(["DPP-FAIL"], timeout=5)
1867         if ev is None or fail not in ev:
1868             raise Exception("Failure not reported correctly:" + str(ev))
1869
1870     dev[1].request("DPP_STOP_LISTEN")
1871     dev[0].dump_monitor()
1872     dev[1].dump_monitor()
1873
1874 def init_sigma_dut_dpp_proto_peer_disc_req(dev, apdev):
1875     check_dpp_capab(dev[0])
1876     check_dpp_capab(dev[1])
1877
1878     csign = "30770201010420768240a3fc89d6662d9782f120527fe7fb9edc6366ab0b9c7dde96125cfd250fa00a06082a8648ce3d030107a144034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1879     csign_pub = "3059301306072a8648ce3d020106082a8648ce3d030107034200042908e1baf7bf413cc66f9e878a03e8bb1835ba94b033dbe3d6969fc8575d5eb5dfda1cb81c95cee21d0cd7d92ba30541ffa05cb6296f5dd808b0c1c2a83c0708"
1880     ap_connector = "eyJ0eXAiOiJkcHBDb24iLCJraWQiOiJwYWtZbXVzd1dCdWpSYTl5OEsweDViaTVrT3VNT3dzZHRlaml2UG55ZHZzIiwiYWxnIjoiRVMyNTYifQ.eyJncm91cHMiOlt7Imdyb3VwSWQiOiIqIiwibmV0Um9sZSI6ImFwIn1dLCJuZXRBY2Nlc3NLZXkiOnsia3R5IjoiRUMiLCJjcnYiOiJQLTI1NiIsIngiOiIybU5vNXZuRkI5bEw3d1VWb1hJbGVPYzBNSEE1QXZKbnpwZXZULVVTYzVNIiwieSI6IlhzS3dqVHJlLTg5WWdpU3pKaG9CN1haeUttTU05OTl3V2ZaSVl0bi01Q3MifX0.XhjFpZgcSa7G2lHy0OCYTvaZFRo5Hyx6b7g7oYyusLC7C_73AJ4_BxEZQVYJXAtDuGvb3dXSkHEKxREP9Q6Qeg"
1881     ap_netaccesskey = "30770201010420ceba752db2ad5200fa7bc565b9c05c69b7eb006751b0b329b0279de1c19ca67ca00a06082a8648ce3d030107a14403420004da6368e6f9c507d94bef0515a1722578e73430703902f267ce97af4fe51273935ec2b08d3adefbcf588224b3261a01ed76722a630cf7df7059f64862d9fee42b"
1882
1883     params = { "ssid": "DPPNET01",
1884                "wpa": "2",
1885                "wpa_key_mgmt": "DPP",
1886                "rsn_pairwise": "CCMP",
1887                "dpp_connector": ap_connector,
1888                "dpp_csign": csign_pub,
1889                "dpp_netaccesskey": ap_netaccesskey }
1890     try:
1891         hapd = hostapd.add_ap(apdev[0], params)
1892     except:
1893         raise HwsimSkip("DPP not supported")
1894
1895     dev[0].set("dpp_config_processing", "2")
1896
1897     cmd = "DPP_CONFIGURATOR_ADD key=" + csign
1898     res = dev[1].request(cmd);
1899     if "FAIL" in res:
1900         raise Exception("Failed to add configurator")
1901     conf_id = int(res)
1902
1903     addr = dev[1].own_addr().replace(':', '')
1904     cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/6 mac=" + addr
1905     res = dev[1].request(cmd)
1906     if "FAIL" in res:
1907         raise Exception("Failed to generate bootstrapping info")
1908     id0 = int(res)
1909     uri0 = dev[1].request("DPP_BOOTSTRAP_GET_URI %d" % id0)
1910
1911     dev[1].set("dpp_configurator_params",
1912                " conf=sta-dpp ssid=%s configurator=%d" % ("DPPNET01".encode("hex"), conf_id));
1913     cmd = "DPP_LISTEN 2437 role=configurator"
1914     if "OK" not in dev[1].request(cmd):
1915         raise Exception("Failed to start listen operation")
1916
1917     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri0.encode('hex'))
1918     if "status,COMPLETE" not in res:
1919         raise Exception("dev_exec_action did not succeed: " + res)
1920
1921 def test_sigma_dut_dpp_proto_peer_disc_req(dev, apdev):
1922     """sigma_dut DPP protocol testing - Peer Discovery Request"""
1923     sigma = start_sigma_dut(dev[0].ifname)
1924     try:
1925         init_sigma_dut_dpp_proto_peer_disc_req(dev, apdev)
1926
1927         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)
1928         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,Errorsent" not in res:
1929             raise Exception("Unexpected result: " + res)
1930     finally:
1931         dev[0].set("dpp_config_processing", "0")
1932         stop_sigma_dut(sigma)
1933
1934 def test_sigma_dut_dpp_self_config(dev, apdev):
1935     """sigma_dut DPP Configurator enrolling an AP and using self-configuration"""
1936     check_dpp_capab(dev[0])
1937
1938     hapd = hostapd.add_ap(apdev[0], { "ssid": "unconfigured" })
1939     check_dpp_capab(hapd)
1940
1941     sigma = start_sigma_dut(dev[0].ifname)
1942     try:
1943         dev[0].set("dpp_config_processing", "2")
1944         addr = hapd.own_addr().replace(':', '')
1945         cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/1 mac=" + addr
1946         res = hapd.request(cmd)
1947         if "FAIL" in res:
1948             raise Exception("Failed to generate bootstrapping info")
1949         id = int(res)
1950         uri = hapd.request("DPP_BOOTSTRAP_GET_URI %d" % id)
1951
1952         res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri.encode('hex'))
1953         if "status,COMPLETE" not in res:
1954             raise Exception("dev_exec_action did not succeed: " + res)
1955
1956         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")
1957         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
1958             raise Exception("Unexpected result: " + res)
1959         update_hapd_config(hapd)
1960
1961         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"
1962         res = sigma_dut_cmd(cmd, timeout=10)
1963         if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK,NetworkIntroResult,OK,NetworkConnectResult,OK" not in res:
1964             raise Exception("Unexpected result: " + res)
1965     finally:
1966         stop_sigma_dut(sigma)
1967         dev[0].set("dpp_config_processing", "0")
1968
1969 def test_sigma_dut_ap_dpp_self_config(dev, apdev, params):
1970     """sigma_dut DPP AP Configurator using self-configuration"""
1971     logdir = os.path.join(params['logdir'],
1972                           "sigma_dut_ap_dpp_self_config.sigma-hostapd")
1973     with HWSimRadio() as (radio, iface):
1974         sigma = start_sigma_dut(iface, hostapd_logdir=logdir)
1975         try:
1976             run_sigma_dut_ap_dpp_self_config(dev, apdev)
1977         finally:
1978             stop_sigma_dut(sigma)
1979             dev[0].set("dpp_config_processing", "0")
1980
1981 def run_sigma_dut_ap_dpp_self_config(dev, apdev):
1982     check_dpp_capab(dev[0])
1983
1984     sigma_dut_cmd_check("ap_reset_default,program,DPP")
1985
1986     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)
1987     if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
1988             raise Exception("Unexpected result: " + res)
1989
1990     dev[0].set("dpp_config_processing", "2")
1991
1992     addr = dev[0].own_addr().replace(':', '')
1993     cmd = "DPP_BOOTSTRAP_GEN type=qrcode chan=81/11 mac=" + addr
1994     res = dev[0].request(cmd)
1995     if "FAIL" in res:
1996         raise Exception("Failed to generate bootstrapping info")
1997     id = int(res)
1998     uri = dev[0].request("DPP_BOOTSTRAP_GET_URI %d" % id)
1999     cmd = "DPP_LISTEN 2462 role=enrollee"
2000     if "OK" not in dev[0].request(cmd):
2001         raise Exception("Failed to start listen operation")
2002
2003     res = sigma_dut_cmd("dev_exec_action,program,DPP,DPPActionType,SetPeerBootstrap,DPPBootstrappingdata,%s,DPPBS,QR" % uri.encode('hex'))
2004     if "status,COMPLETE" not in res:
2005         raise Exception("dev_exec_action did not succeed: " + res)
2006     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"
2007     res = sigma_dut_cmd(cmd)
2008     if "BootstrapResult,OK,AuthResult,OK,ConfResult,OK" not in res:
2009         raise Exception("Unexpected result: " + res)
2010     dev[0].wait_connected()
2011     dev[0].request("DISCONNECT")
2012     dev[0].wait_disconnected()
2013     sigma_dut_cmd_check("ap_reset_default")
2014
2015 def test_sigma_dut_preconfigured_profile(dev, apdev):
2016     """sigma_dut controlled connection using preconfigured profile"""
2017     try:
2018         run_sigma_dut_preconfigured_profile(dev, apdev)
2019     finally:
2020         dev[0].set("ignore_old_scan_res", "0")
2021
2022 def run_sigma_dut_preconfigured_profile(dev, apdev):
2023     ifname = dev[0].ifname
2024     sigma = start_sigma_dut(ifname)
2025
2026     params = hostapd.wpa2_params(ssid="test-psk", passphrase="12345678")
2027     hapd = hostapd.add_ap(apdev[0], params)
2028     dev[0].connect("test-psk", psk="12345678", scan_freq="2412",
2029                    only_add_network=True)
2030
2031     sigma_dut_cmd_check("sta_set_ip_config,interface,%s,dhcp,0,ip,127.0.0.11,mask,255.255.255.0" % ifname)
2032     sigma_dut_cmd_check("sta_associate,interface,%s,ssid,%s" % (ifname, "test-psk"))
2033     sigma_dut_wait_connected(ifname)
2034     sigma_dut_cmd_check("sta_get_ip_config,interface," + ifname)
2035     sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
2036     sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
2037
2038     stop_sigma_dut(sigma)
2039
2040 def test_sigma_dut_wps_pbc(dev, apdev):
2041     """sigma_dut and WPS PBC Enrollee"""
2042     try:
2043         run_sigma_dut_wps_pbc(dev, apdev)
2044     finally:
2045         dev[0].set("ignore_old_scan_res", "0")
2046
2047 def run_sigma_dut_wps_pbc(dev, apdev):
2048     ssid = "test-wps-conf"
2049     hapd = hostapd.add_ap(apdev[0],
2050                           { "ssid": "wps", "eap_server": "1", "wps_state": "2",
2051                             "wpa_passphrase": "12345678", "wpa": "2",
2052                             "wpa_key_mgmt": "WPA-PSK", "rsn_pairwise": "CCMP" })
2053     hapd.request("WPS_PBC")
2054
2055     ifname = dev[0].ifname
2056     sigma = start_sigma_dut(ifname)
2057
2058     cmd = "start_wps_registration,interface,%s" % ifname
2059     cmd += ",WpsRole,Enrollee"
2060     cmd += ",WpsConfigMethod,PBC"
2061     sigma_dut_cmd_check(cmd, timeout=15)
2062
2063     sigma_dut_cmd_check("sta_disconnect,interface," + ifname)
2064     hapd.disable()
2065     sigma_dut_cmd_check("sta_reset_default,interface," + ifname)
2066     stop_sigma_dut(sigma)
2067     dev[0].flush_scan_cache()
2068
2069 def test_sigma_dut_sta_scan_bss(dev, apdev):
2070     """sigma_dut sta_scan_bss"""
2071     hapd = hostapd.add_ap(apdev[0], { "ssid": "test" })
2072     sigma = start_sigma_dut(dev[0].ifname)
2073     try:
2074         cmd = "sta_scan_bss,Interface,%s,BSSID,%s" % (dev[0].ifname, \
2075                                                       hapd.own_addr())
2076         res = sigma_dut_cmd(cmd, timeout=10)
2077         if "ssid,test,bsschannel,1" not in res:
2078             raise Exception("Unexpected result: " + res)
2079     finally:
2080         stop_sigma_dut(sigma)