dpp_supplicant.c revision 351611
1/* 2 * wpa_supplicant - DPP 3 * Copyright (c) 2017, Qualcomm Atheros, Inc. 4 * Copyright (c) 2018-2019, The Linux Foundation 5 * 6 * This software may be distributed under the terms of the BSD license. 7 * See README for more details. 8 */ 9 10#include "utils/includes.h" 11 12#include "utils/common.h" 13#include "utils/eloop.h" 14#include "utils/ip_addr.h" 15#include "common/dpp.h" 16#include "common/gas.h" 17#include "common/gas_server.h" 18#include "rsn_supp/wpa.h" 19#include "rsn_supp/pmksa_cache.h" 20#include "wpa_supplicant_i.h" 21#include "config.h" 22#include "driver_i.h" 23#include "offchannel.h" 24#include "gas_query.h" 25#include "bss.h" 26#include "scan.h" 27#include "notify.h" 28#include "dpp_supplicant.h" 29 30 31static int wpas_dpp_listen_start(struct wpa_supplicant *wpa_s, 32 unsigned int freq); 33static void wpas_dpp_reply_wait_timeout(void *eloop_ctx, void *timeout_ctx); 34static void wpas_dpp_auth_success(struct wpa_supplicant *wpa_s, int initiator); 35static void wpas_dpp_tx_status(struct wpa_supplicant *wpa_s, 36 unsigned int freq, const u8 *dst, 37 const u8 *src, const u8 *bssid, 38 const u8 *data, size_t data_len, 39 enum offchannel_send_action_result result); 40static void wpas_dpp_init_timeout(void *eloop_ctx, void *timeout_ctx); 41static int wpas_dpp_auth_init_next(struct wpa_supplicant *wpa_s); 42static void 43wpas_dpp_tx_pkex_status(struct wpa_supplicant *wpa_s, 44 unsigned int freq, const u8 *dst, 45 const u8 *src, const u8 *bssid, 46 const u8 *data, size_t data_len, 47 enum offchannel_send_action_result result); 48 49static const u8 broadcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 50 51/* Use a hardcoded Transaction ID 1 in Peer Discovery frames since there is only 52 * a single transaction in progress at any point in time. */ 53static const u8 TRANSACTION_ID = 1; 54 55 56/** 57 * wpas_dpp_qr_code - Parse and add DPP bootstrapping info from a QR Code 58 * @wpa_s: Pointer to wpa_supplicant data 59 * @cmd: DPP URI read from a QR Code 60 * Returns: Identifier of the stored info or -1 on failure 61 */ 62int wpas_dpp_qr_code(struct wpa_supplicant *wpa_s, const char *cmd) 63{ 64 struct dpp_bootstrap_info *bi; 65 struct dpp_authentication *auth = wpa_s->dpp_auth; 66 67 bi = dpp_add_qr_code(wpa_s->dpp, cmd); 68 if (!bi) 69 return -1; 70 71 if (auth && auth->response_pending && 72 dpp_notify_new_qr_code(auth, bi) == 1) { 73 wpa_printf(MSG_DEBUG, 74 "DPP: Sending out pending authentication response"); 75 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR 76 " freq=%u type=%d", 77 MAC2STR(auth->peer_mac_addr), auth->curr_freq, 78 DPP_PA_AUTHENTICATION_RESP); 79 offchannel_send_action(wpa_s, auth->curr_freq, 80 auth->peer_mac_addr, wpa_s->own_addr, 81 broadcast, 82 wpabuf_head(auth->resp_msg), 83 wpabuf_len(auth->resp_msg), 84 500, wpas_dpp_tx_status, 0); 85 } 86 87 return bi->id; 88} 89 90 91static void wpas_dpp_auth_resp_retry_timeout(void *eloop_ctx, void *timeout_ctx) 92{ 93 struct wpa_supplicant *wpa_s = eloop_ctx; 94 struct dpp_authentication *auth = wpa_s->dpp_auth; 95 96 if (!auth || !auth->resp_msg) 97 return; 98 99 wpa_printf(MSG_DEBUG, 100 "DPP: Retry Authentication Response after timeout"); 101 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR 102 " freq=%u type=%d", 103 MAC2STR(auth->peer_mac_addr), auth->curr_freq, 104 DPP_PA_AUTHENTICATION_RESP); 105 offchannel_send_action(wpa_s, auth->curr_freq, auth->peer_mac_addr, 106 wpa_s->own_addr, broadcast, 107 wpabuf_head(auth->resp_msg), 108 wpabuf_len(auth->resp_msg), 109 500, wpas_dpp_tx_status, 0); 110} 111 112 113static void wpas_dpp_auth_resp_retry(struct wpa_supplicant *wpa_s) 114{ 115 struct dpp_authentication *auth = wpa_s->dpp_auth; 116 unsigned int wait_time, max_tries; 117 118 if (!auth || !auth->resp_msg) 119 return; 120 121 if (wpa_s->dpp_resp_max_tries) 122 max_tries = wpa_s->dpp_resp_max_tries; 123 else 124 max_tries = 5; 125 auth->auth_resp_tries++; 126 if (auth->auth_resp_tries >= max_tries) { 127 wpa_printf(MSG_INFO, "DPP: No confirm received from initiator - stopping exchange"); 128 offchannel_send_action_done(wpa_s); 129 dpp_auth_deinit(wpa_s->dpp_auth); 130 wpa_s->dpp_auth = NULL; 131 return; 132 } 133 134 if (wpa_s->dpp_resp_retry_time) 135 wait_time = wpa_s->dpp_resp_retry_time; 136 else 137 wait_time = 1000; 138 wpa_printf(MSG_DEBUG, 139 "DPP: Schedule retransmission of Authentication Response frame in %u ms", 140 wait_time); 141 eloop_cancel_timeout(wpas_dpp_auth_resp_retry_timeout, wpa_s, NULL); 142 eloop_register_timeout(wait_time / 1000, 143 (wait_time % 1000) * 1000, 144 wpas_dpp_auth_resp_retry_timeout, wpa_s, NULL); 145} 146 147 148static void wpas_dpp_try_to_connect(struct wpa_supplicant *wpa_s) 149{ 150 wpa_printf(MSG_DEBUG, "DPP: Trying to connect to the new network"); 151 wpa_s->disconnected = 0; 152 wpa_s->reassociate = 1; 153 wpa_s->scan_runs = 0; 154 wpa_s->normal_scans = 0; 155 wpa_supplicant_cancel_sched_scan(wpa_s); 156 wpa_supplicant_req_scan(wpa_s, 0, 0); 157} 158 159 160static void wpas_dpp_tx_status(struct wpa_supplicant *wpa_s, 161 unsigned int freq, const u8 *dst, 162 const u8 *src, const u8 *bssid, 163 const u8 *data, size_t data_len, 164 enum offchannel_send_action_result result) 165{ 166 const char *res_txt; 167 struct dpp_authentication *auth = wpa_s->dpp_auth; 168 169 res_txt = result == OFFCHANNEL_SEND_ACTION_SUCCESS ? "SUCCESS" : 170 (result == OFFCHANNEL_SEND_ACTION_NO_ACK ? "no-ACK" : 171 "FAILED"); 172 wpa_printf(MSG_DEBUG, "DPP: TX status: freq=%u dst=" MACSTR 173 " result=%s", freq, MAC2STR(dst), res_txt); 174 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX_STATUS "dst=" MACSTR 175 " freq=%u result=%s", MAC2STR(dst), freq, res_txt); 176 177 if (!wpa_s->dpp_auth) { 178 wpa_printf(MSG_DEBUG, 179 "DPP: Ignore TX status since there is no ongoing authentication exchange"); 180 return; 181 } 182 183#ifdef CONFIG_DPP2 184 if (auth->connect_on_tx_status) { 185 wpa_printf(MSG_DEBUG, 186 "DPP: Try to connect after completed configuration result"); 187 wpas_dpp_try_to_connect(wpa_s); 188 dpp_auth_deinit(wpa_s->dpp_auth); 189 wpa_s->dpp_auth = NULL; 190 return; 191 } 192#endif /* CONFIG_DPP2 */ 193 194 if (wpa_s->dpp_auth->remove_on_tx_status) { 195 wpa_printf(MSG_DEBUG, 196 "DPP: Terminate authentication exchange due to an earlier error"); 197 eloop_cancel_timeout(wpas_dpp_init_timeout, wpa_s, NULL); 198 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL); 199 eloop_cancel_timeout(wpas_dpp_auth_resp_retry_timeout, wpa_s, 200 NULL); 201 offchannel_send_action_done(wpa_s); 202 dpp_auth_deinit(wpa_s->dpp_auth); 203 wpa_s->dpp_auth = NULL; 204 return; 205 } 206 207 if (wpa_s->dpp_auth_ok_on_ack) 208 wpas_dpp_auth_success(wpa_s, 1); 209 210 if (!is_broadcast_ether_addr(dst) && 211 result != OFFCHANNEL_SEND_ACTION_SUCCESS) { 212 wpa_printf(MSG_DEBUG, 213 "DPP: Unicast DPP Action frame was not ACKed"); 214 if (auth->waiting_auth_resp) { 215 /* In case of DPP Authentication Request frame, move to 216 * the next channel immediately. */ 217 offchannel_send_action_done(wpa_s); 218 wpas_dpp_auth_init_next(wpa_s); 219 return; 220 } 221 if (auth->waiting_auth_conf) { 222 wpas_dpp_auth_resp_retry(wpa_s); 223 return; 224 } 225 } 226 227 if (!is_broadcast_ether_addr(dst) && auth->waiting_auth_resp && 228 result == OFFCHANNEL_SEND_ACTION_SUCCESS) { 229 /* Allow timeout handling to stop iteration if no response is 230 * received from a peer that has ACKed a request. */ 231 auth->auth_req_ack = 1; 232 } 233 234 if (!wpa_s->dpp_auth_ok_on_ack && wpa_s->dpp_auth->neg_freq > 0 && 235 wpa_s->dpp_auth->curr_freq != wpa_s->dpp_auth->neg_freq) { 236 wpa_printf(MSG_DEBUG, 237 "DPP: Move from curr_freq %u MHz to neg_freq %u MHz for response", 238 wpa_s->dpp_auth->curr_freq, 239 wpa_s->dpp_auth->neg_freq); 240 offchannel_send_action_done(wpa_s); 241 wpas_dpp_listen_start(wpa_s, wpa_s->dpp_auth->neg_freq); 242 } 243 244 if (wpa_s->dpp_auth_ok_on_ack) 245 wpa_s->dpp_auth_ok_on_ack = 0; 246} 247 248 249static void wpas_dpp_reply_wait_timeout(void *eloop_ctx, void *timeout_ctx) 250{ 251 struct wpa_supplicant *wpa_s = eloop_ctx; 252 struct dpp_authentication *auth = wpa_s->dpp_auth; 253 unsigned int freq; 254 struct os_reltime now, diff; 255 unsigned int wait_time, diff_ms; 256 257 if (!auth || !auth->waiting_auth_resp) 258 return; 259 260 wait_time = wpa_s->dpp_resp_wait_time ? 261 wpa_s->dpp_resp_wait_time : 2000; 262 os_get_reltime(&now); 263 os_reltime_sub(&now, &wpa_s->dpp_last_init, &diff); 264 diff_ms = diff.sec * 1000 + diff.usec / 1000; 265 wpa_printf(MSG_DEBUG, 266 "DPP: Reply wait timeout - wait_time=%u diff_ms=%u", 267 wait_time, diff_ms); 268 269 if (auth->auth_req_ack && diff_ms >= wait_time) { 270 /* Peer ACK'ed Authentication Request frame, but did not reply 271 * with Authentication Response frame within two seconds. */ 272 wpa_printf(MSG_INFO, 273 "DPP: No response received from responder - stopping initiation attempt"); 274 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_INIT_FAILED); 275 offchannel_send_action_done(wpa_s); 276 wpas_dpp_listen_stop(wpa_s); 277 dpp_auth_deinit(auth); 278 wpa_s->dpp_auth = NULL; 279 return; 280 } 281 282 if (diff_ms >= wait_time) { 283 /* Authentication Request frame was not ACK'ed and no reply 284 * was receiving within two seconds. */ 285 wpa_printf(MSG_DEBUG, 286 "DPP: Continue Initiator channel iteration"); 287 offchannel_send_action_done(wpa_s); 288 wpas_dpp_listen_stop(wpa_s); 289 wpas_dpp_auth_init_next(wpa_s); 290 return; 291 } 292 293 /* Driver did not support 2000 ms long wait_time with TX command, so 294 * schedule listen operation to continue waiting for the response. 295 * 296 * DPP listen operations continue until stopped, so simply schedule a 297 * new call to this function at the point when the two second reply 298 * wait has expired. */ 299 wait_time -= diff_ms; 300 301 freq = auth->curr_freq; 302 if (auth->neg_freq > 0) 303 freq = auth->neg_freq; 304 wpa_printf(MSG_DEBUG, 305 "DPP: Continue reply wait on channel %u MHz for %u ms", 306 freq, wait_time); 307 wpa_s->dpp_in_response_listen = 1; 308 wpas_dpp_listen_start(wpa_s, freq); 309 310 eloop_register_timeout(wait_time / 1000, (wait_time % 1000) * 1000, 311 wpas_dpp_reply_wait_timeout, wpa_s, NULL); 312} 313 314 315static void wpas_dpp_set_testing_options(struct wpa_supplicant *wpa_s, 316 struct dpp_authentication *auth) 317{ 318#ifdef CONFIG_TESTING_OPTIONS 319 if (wpa_s->dpp_config_obj_override) 320 auth->config_obj_override = 321 os_strdup(wpa_s->dpp_config_obj_override); 322 if (wpa_s->dpp_discovery_override) 323 auth->discovery_override = 324 os_strdup(wpa_s->dpp_discovery_override); 325 if (wpa_s->dpp_groups_override) 326 auth->groups_override = 327 os_strdup(wpa_s->dpp_groups_override); 328 auth->ignore_netaccesskey_mismatch = 329 wpa_s->dpp_ignore_netaccesskey_mismatch; 330#endif /* CONFIG_TESTING_OPTIONS */ 331} 332 333 334static void wpas_dpp_init_timeout(void *eloop_ctx, void *timeout_ctx) 335{ 336 struct wpa_supplicant *wpa_s = eloop_ctx; 337 338 if (!wpa_s->dpp_auth) 339 return; 340 wpa_printf(MSG_DEBUG, "DPP: Retry initiation after timeout"); 341 wpas_dpp_auth_init_next(wpa_s); 342} 343 344 345static int wpas_dpp_auth_init_next(struct wpa_supplicant *wpa_s) 346{ 347 struct dpp_authentication *auth = wpa_s->dpp_auth; 348 const u8 *dst; 349 unsigned int wait_time, max_wait_time, freq, max_tries, used; 350 struct os_reltime now, diff; 351 352 wpa_s->dpp_in_response_listen = 0; 353 if (!auth) 354 return -1; 355 356 if (auth->freq_idx == 0) 357 os_get_reltime(&wpa_s->dpp_init_iter_start); 358 359 if (auth->freq_idx >= auth->num_freq) { 360 auth->num_freq_iters++; 361 if (wpa_s->dpp_init_max_tries) 362 max_tries = wpa_s->dpp_init_max_tries; 363 else 364 max_tries = 5; 365 if (auth->num_freq_iters >= max_tries || auth->auth_req_ack) { 366 wpa_printf(MSG_INFO, 367 "DPP: No response received from responder - stopping initiation attempt"); 368 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_INIT_FAILED); 369 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, 370 wpa_s, NULL); 371 offchannel_send_action_done(wpa_s); 372 dpp_auth_deinit(wpa_s->dpp_auth); 373 wpa_s->dpp_auth = NULL; 374 return -1; 375 } 376 auth->freq_idx = 0; 377 eloop_cancel_timeout(wpas_dpp_init_timeout, wpa_s, NULL); 378 if (wpa_s->dpp_init_retry_time) 379 wait_time = wpa_s->dpp_init_retry_time; 380 else 381 wait_time = 10000; 382 os_get_reltime(&now); 383 os_reltime_sub(&now, &wpa_s->dpp_init_iter_start, &diff); 384 used = diff.sec * 1000 + diff.usec / 1000; 385 if (used > wait_time) 386 wait_time = 0; 387 else 388 wait_time -= used; 389 wpa_printf(MSG_DEBUG, "DPP: Next init attempt in %u ms", 390 wait_time); 391 eloop_register_timeout(wait_time / 1000, 392 (wait_time % 1000) * 1000, 393 wpas_dpp_init_timeout, wpa_s, 394 NULL); 395 return 0; 396 } 397 freq = auth->freq[auth->freq_idx++]; 398 auth->curr_freq = freq; 399 400 if (is_zero_ether_addr(auth->peer_bi->mac_addr)) 401 dst = broadcast; 402 else 403 dst = auth->peer_bi->mac_addr; 404 wpa_s->dpp_auth_ok_on_ack = 0; 405 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL); 406 wait_time = wpa_s->max_remain_on_chan; 407 max_wait_time = wpa_s->dpp_resp_wait_time ? 408 wpa_s->dpp_resp_wait_time : 2000; 409 if (wait_time > max_wait_time) 410 wait_time = max_wait_time; 411 wait_time += 10; /* give the driver some extra time to complete */ 412 eloop_register_timeout(wait_time / 1000, (wait_time % 1000) * 1000, 413 wpas_dpp_reply_wait_timeout, 414 wpa_s, NULL); 415 wait_time -= 10; 416 if (auth->neg_freq > 0 && freq != auth->neg_freq) { 417 wpa_printf(MSG_DEBUG, 418 "DPP: Initiate on %u MHz and move to neg_freq %u MHz for response", 419 freq, auth->neg_freq); 420 } 421 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d", 422 MAC2STR(dst), freq, DPP_PA_AUTHENTICATION_REQ); 423 auth->auth_req_ack = 0; 424 os_get_reltime(&wpa_s->dpp_last_init); 425 return offchannel_send_action(wpa_s, freq, dst, 426 wpa_s->own_addr, broadcast, 427 wpabuf_head(auth->req_msg), 428 wpabuf_len(auth->req_msg), 429 wait_time, wpas_dpp_tx_status, 0); 430} 431 432 433int wpas_dpp_auth_init(struct wpa_supplicant *wpa_s, const char *cmd) 434{ 435 const char *pos; 436 struct dpp_bootstrap_info *peer_bi, *own_bi = NULL; 437 struct dpp_authentication *auth; 438 u8 allowed_roles = DPP_CAPAB_CONFIGURATOR; 439 unsigned int neg_freq = 0; 440 int tcp = 0; 441#ifdef CONFIG_DPP2 442 int tcp_port = DPP_TCP_PORT; 443 struct hostapd_ip_addr ipaddr; 444 char *addr; 445#endif /* CONFIG_DPP2 */ 446 447 wpa_s->dpp_gas_client = 0; 448 449 pos = os_strstr(cmd, " peer="); 450 if (!pos) 451 return -1; 452 pos += 6; 453 peer_bi = dpp_bootstrap_get_id(wpa_s->dpp, atoi(pos)); 454 if (!peer_bi) { 455 wpa_printf(MSG_INFO, 456 "DPP: Could not find bootstrapping info for the identified peer"); 457 return -1; 458 } 459 460#ifdef CONFIG_DPP2 461 pos = os_strstr(cmd, " tcp_port="); 462 if (pos) { 463 pos += 10; 464 tcp_port = atoi(pos); 465 } 466 467 addr = get_param(cmd, " tcp_addr="); 468 if (addr) { 469 int res; 470 471 res = hostapd_parse_ip_addr(addr, &ipaddr); 472 os_free(addr); 473 if (res) 474 return -1; 475 tcp = 1; 476 } 477#endif /* CONFIG_DPP2 */ 478 479 pos = os_strstr(cmd, " own="); 480 if (pos) { 481 pos += 5; 482 own_bi = dpp_bootstrap_get_id(wpa_s->dpp, atoi(pos)); 483 if (!own_bi) { 484 wpa_printf(MSG_INFO, 485 "DPP: Could not find bootstrapping info for the identified local entry"); 486 return -1; 487 } 488 489 if (peer_bi->curve != own_bi->curve) { 490 wpa_printf(MSG_INFO, 491 "DPP: Mismatching curves in bootstrapping info (peer=%s own=%s)", 492 peer_bi->curve->name, own_bi->curve->name); 493 return -1; 494 } 495 } 496 497 pos = os_strstr(cmd, " role="); 498 if (pos) { 499 pos += 6; 500 if (os_strncmp(pos, "configurator", 12) == 0) 501 allowed_roles = DPP_CAPAB_CONFIGURATOR; 502 else if (os_strncmp(pos, "enrollee", 8) == 0) 503 allowed_roles = DPP_CAPAB_ENROLLEE; 504 else if (os_strncmp(pos, "either", 6) == 0) 505 allowed_roles = DPP_CAPAB_CONFIGURATOR | 506 DPP_CAPAB_ENROLLEE; 507 else 508 goto fail; 509 } 510 511 pos = os_strstr(cmd, " netrole="); 512 if (pos) { 513 pos += 9; 514 wpa_s->dpp_netrole_ap = os_strncmp(pos, "ap", 2) == 0; 515 } 516 517 pos = os_strstr(cmd, " neg_freq="); 518 if (pos) 519 neg_freq = atoi(pos + 10); 520 521 if (!tcp && wpa_s->dpp_auth) { 522 eloop_cancel_timeout(wpas_dpp_init_timeout, wpa_s, NULL); 523 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL); 524 eloop_cancel_timeout(wpas_dpp_auth_resp_retry_timeout, wpa_s, 525 NULL); 526 offchannel_send_action_done(wpa_s); 527 dpp_auth_deinit(wpa_s->dpp_auth); 528 wpa_s->dpp_auth = NULL; 529 } 530 531 auth = dpp_auth_init(wpa_s, peer_bi, own_bi, allowed_roles, neg_freq, 532 wpa_s->hw.modes, wpa_s->hw.num_modes); 533 if (!auth) 534 goto fail; 535 wpas_dpp_set_testing_options(wpa_s, auth); 536 if (dpp_set_configurator(wpa_s->dpp, wpa_s, auth, cmd) < 0) { 537 dpp_auth_deinit(auth); 538 goto fail; 539 } 540 541 auth->neg_freq = neg_freq; 542 543 if (!is_zero_ether_addr(peer_bi->mac_addr)) 544 os_memcpy(auth->peer_mac_addr, peer_bi->mac_addr, ETH_ALEN); 545 546#ifdef CONFIG_DPP2 547 if (tcp) 548 return dpp_tcp_init(wpa_s->dpp, auth, &ipaddr, tcp_port); 549#endif /* CONFIG_DPP2 */ 550 551 wpa_s->dpp_auth = auth; 552 return wpas_dpp_auth_init_next(wpa_s); 553fail: 554 return -1; 555} 556 557 558struct wpas_dpp_listen_work { 559 unsigned int freq; 560 unsigned int duration; 561 struct wpabuf *probe_resp_ie; 562}; 563 564 565static void wpas_dpp_listen_work_free(struct wpas_dpp_listen_work *lwork) 566{ 567 if (!lwork) 568 return; 569 os_free(lwork); 570} 571 572 573static void wpas_dpp_listen_work_done(struct wpa_supplicant *wpa_s) 574{ 575 struct wpas_dpp_listen_work *lwork; 576 577 if (!wpa_s->dpp_listen_work) 578 return; 579 580 lwork = wpa_s->dpp_listen_work->ctx; 581 wpas_dpp_listen_work_free(lwork); 582 radio_work_done(wpa_s->dpp_listen_work); 583 wpa_s->dpp_listen_work = NULL; 584} 585 586 587static void dpp_start_listen_cb(struct wpa_radio_work *work, int deinit) 588{ 589 struct wpa_supplicant *wpa_s = work->wpa_s; 590 struct wpas_dpp_listen_work *lwork = work->ctx; 591 592 if (deinit) { 593 if (work->started) { 594 wpa_s->dpp_listen_work = NULL; 595 wpas_dpp_listen_stop(wpa_s); 596 } 597 wpas_dpp_listen_work_free(lwork); 598 return; 599 } 600 601 wpa_s->dpp_listen_work = work; 602 603 wpa_s->dpp_pending_listen_freq = lwork->freq; 604 605 if (wpa_drv_remain_on_channel(wpa_s, lwork->freq, 606 wpa_s->max_remain_on_chan) < 0) { 607 wpa_printf(MSG_DEBUG, 608 "DPP: Failed to request the driver to remain on channel (%u MHz) for listen", 609 lwork->freq); 610 wpa_s->dpp_listen_freq = 0; 611 wpas_dpp_listen_work_done(wpa_s); 612 wpa_s->dpp_pending_listen_freq = 0; 613 return; 614 } 615 wpa_s->off_channel_freq = 0; 616 wpa_s->roc_waiting_drv_freq = lwork->freq; 617} 618 619 620static int wpas_dpp_listen_start(struct wpa_supplicant *wpa_s, 621 unsigned int freq) 622{ 623 struct wpas_dpp_listen_work *lwork; 624 625 if (wpa_s->dpp_listen_work) { 626 wpa_printf(MSG_DEBUG, 627 "DPP: Reject start_listen since dpp_listen_work already exists"); 628 return -1; 629 } 630 631 if (wpa_s->dpp_listen_freq) 632 wpas_dpp_listen_stop(wpa_s); 633 wpa_s->dpp_listen_freq = freq; 634 635 lwork = os_zalloc(sizeof(*lwork)); 636 if (!lwork) 637 return -1; 638 lwork->freq = freq; 639 640 if (radio_add_work(wpa_s, freq, "dpp-listen", 0, dpp_start_listen_cb, 641 lwork) < 0) { 642 wpas_dpp_listen_work_free(lwork); 643 return -1; 644 } 645 646 return 0; 647} 648 649 650int wpas_dpp_listen(struct wpa_supplicant *wpa_s, const char *cmd) 651{ 652 int freq; 653 654 freq = atoi(cmd); 655 if (freq <= 0) 656 return -1; 657 658 if (os_strstr(cmd, " role=configurator")) 659 wpa_s->dpp_allowed_roles = DPP_CAPAB_CONFIGURATOR; 660 else if (os_strstr(cmd, " role=enrollee")) 661 wpa_s->dpp_allowed_roles = DPP_CAPAB_ENROLLEE; 662 else 663 wpa_s->dpp_allowed_roles = DPP_CAPAB_CONFIGURATOR | 664 DPP_CAPAB_ENROLLEE; 665 wpa_s->dpp_qr_mutual = os_strstr(cmd, " qr=mutual") != NULL; 666 wpa_s->dpp_netrole_ap = os_strstr(cmd, " netrole=ap") != NULL; 667 if (wpa_s->dpp_listen_freq == (unsigned int) freq) { 668 wpa_printf(MSG_DEBUG, "DPP: Already listening on %u MHz", 669 freq); 670 return 0; 671 } 672 673 return wpas_dpp_listen_start(wpa_s, freq); 674} 675 676 677void wpas_dpp_listen_stop(struct wpa_supplicant *wpa_s) 678{ 679 wpa_s->dpp_in_response_listen = 0; 680 if (!wpa_s->dpp_listen_freq) 681 return; 682 683 wpa_printf(MSG_DEBUG, "DPP: Stop listen on %u MHz", 684 wpa_s->dpp_listen_freq); 685 wpa_drv_cancel_remain_on_channel(wpa_s); 686 wpa_s->dpp_listen_freq = 0; 687 wpas_dpp_listen_work_done(wpa_s); 688} 689 690 691void wpas_dpp_cancel_remain_on_channel_cb(struct wpa_supplicant *wpa_s, 692 unsigned int freq) 693{ 694 wpas_dpp_listen_work_done(wpa_s); 695 696 if (wpa_s->dpp_auth && wpa_s->dpp_in_response_listen) { 697 unsigned int new_freq; 698 699 /* Continue listen with a new remain-on-channel */ 700 if (wpa_s->dpp_auth->neg_freq > 0) 701 new_freq = wpa_s->dpp_auth->neg_freq; 702 else 703 new_freq = wpa_s->dpp_auth->curr_freq; 704 wpa_printf(MSG_DEBUG, 705 "DPP: Continue wait on %u MHz for the ongoing DPP provisioning session", 706 new_freq); 707 wpas_dpp_listen_start(wpa_s, new_freq); 708 return; 709 } 710 711 if (wpa_s->dpp_listen_freq) { 712 /* Continue listen with a new remain-on-channel */ 713 wpas_dpp_listen_start(wpa_s, wpa_s->dpp_listen_freq); 714 } 715} 716 717 718static void wpas_dpp_rx_auth_req(struct wpa_supplicant *wpa_s, const u8 *src, 719 const u8 *hdr, const u8 *buf, size_t len, 720 unsigned int freq) 721{ 722 const u8 *r_bootstrap, *i_bootstrap; 723 u16 r_bootstrap_len, i_bootstrap_len; 724 struct dpp_bootstrap_info *own_bi = NULL, *peer_bi = NULL; 725 726 if (!wpa_s->dpp) 727 return; 728 729 wpa_printf(MSG_DEBUG, "DPP: Authentication Request from " MACSTR, 730 MAC2STR(src)); 731 732 r_bootstrap = dpp_get_attr(buf, len, DPP_ATTR_R_BOOTSTRAP_KEY_HASH, 733 &r_bootstrap_len); 734 if (!r_bootstrap || r_bootstrap_len != SHA256_MAC_LEN) { 735 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL 736 "Missing or invalid required Responder Bootstrapping Key Hash attribute"); 737 return; 738 } 739 wpa_hexdump(MSG_MSGDUMP, "DPP: Responder Bootstrapping Key Hash", 740 r_bootstrap, r_bootstrap_len); 741 742 i_bootstrap = dpp_get_attr(buf, len, DPP_ATTR_I_BOOTSTRAP_KEY_HASH, 743 &i_bootstrap_len); 744 if (!i_bootstrap || i_bootstrap_len != SHA256_MAC_LEN) { 745 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL 746 "Missing or invalid required Initiator Bootstrapping Key Hash attribute"); 747 return; 748 } 749 wpa_hexdump(MSG_MSGDUMP, "DPP: Initiator Bootstrapping Key Hash", 750 i_bootstrap, i_bootstrap_len); 751 752 /* Try to find own and peer bootstrapping key matches based on the 753 * received hash values */ 754 dpp_bootstrap_find_pair(wpa_s->dpp, i_bootstrap, r_bootstrap, 755 &own_bi, &peer_bi); 756 if (!own_bi) { 757 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL 758 "No matching own bootstrapping key found - ignore message"); 759 return; 760 } 761 762 if (wpa_s->dpp_auth) { 763 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL 764 "Already in DPP authentication exchange - ignore new one"); 765 return; 766 } 767 768 wpa_s->dpp_gas_client = 0; 769 wpa_s->dpp_auth_ok_on_ack = 0; 770 wpa_s->dpp_auth = dpp_auth_req_rx(wpa_s, wpa_s->dpp_allowed_roles, 771 wpa_s->dpp_qr_mutual, 772 peer_bi, own_bi, freq, hdr, buf, len); 773 if (!wpa_s->dpp_auth) { 774 wpa_printf(MSG_DEBUG, "DPP: No response generated"); 775 return; 776 } 777 wpas_dpp_set_testing_options(wpa_s, wpa_s->dpp_auth); 778 if (dpp_set_configurator(wpa_s->dpp, wpa_s, wpa_s->dpp_auth, 779 wpa_s->dpp_configurator_params) < 0) { 780 dpp_auth_deinit(wpa_s->dpp_auth); 781 wpa_s->dpp_auth = NULL; 782 return; 783 } 784 os_memcpy(wpa_s->dpp_auth->peer_mac_addr, src, ETH_ALEN); 785 786 if (wpa_s->dpp_listen_freq && 787 wpa_s->dpp_listen_freq != wpa_s->dpp_auth->curr_freq) { 788 wpa_printf(MSG_DEBUG, 789 "DPP: Stop listen on %u MHz to allow response on the request %u MHz", 790 wpa_s->dpp_listen_freq, wpa_s->dpp_auth->curr_freq); 791 wpas_dpp_listen_stop(wpa_s); 792 } 793 794 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d", 795 MAC2STR(src), wpa_s->dpp_auth->curr_freq, 796 DPP_PA_AUTHENTICATION_RESP); 797 offchannel_send_action(wpa_s, wpa_s->dpp_auth->curr_freq, 798 src, wpa_s->own_addr, broadcast, 799 wpabuf_head(wpa_s->dpp_auth->resp_msg), 800 wpabuf_len(wpa_s->dpp_auth->resp_msg), 801 500, wpas_dpp_tx_status, 0); 802} 803 804 805static void wpas_dpp_start_gas_server(struct wpa_supplicant *wpa_s) 806{ 807 /* TODO: stop wait and start ROC */ 808} 809 810 811static struct wpa_ssid * wpas_dpp_add_network(struct wpa_supplicant *wpa_s, 812 struct dpp_authentication *auth) 813{ 814 struct wpa_ssid *ssid; 815 816#ifdef CONFIG_DPP2 817 if (auth->akm == DPP_AKM_SAE) { 818#ifdef CONFIG_SAE 819 struct wpa_driver_capa capa; 820 int res; 821 822 res = wpa_drv_get_capa(wpa_s, &capa); 823 if (res == 0 && 824 !(capa.key_mgmt & WPA_DRIVER_CAPA_KEY_MGMT_SAE) && 825 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE)) { 826 wpa_printf(MSG_DEBUG, 827 "DPP: SAE not supported by the driver"); 828 return NULL; 829 } 830#else /* CONFIG_SAE */ 831 wpa_printf(MSG_DEBUG, "DPP: SAE not supported in the build"); 832 return NULL; 833#endif /* CONFIG_SAE */ 834 } 835#endif /* CONFIG_DPP2 */ 836 837 ssid = wpa_config_add_network(wpa_s->conf); 838 if (!ssid) 839 return NULL; 840 wpas_notify_network_added(wpa_s, ssid); 841 wpa_config_set_network_defaults(ssid); 842 ssid->disabled = 1; 843 844 ssid->ssid = os_malloc(auth->ssid_len); 845 if (!ssid->ssid) 846 goto fail; 847 os_memcpy(ssid->ssid, auth->ssid, auth->ssid_len); 848 ssid->ssid_len = auth->ssid_len; 849 850 if (auth->connector) { 851 ssid->key_mgmt = WPA_KEY_MGMT_DPP; 852 ssid->ieee80211w = MGMT_FRAME_PROTECTION_REQUIRED; 853 ssid->dpp_connector = os_strdup(auth->connector); 854 if (!ssid->dpp_connector) 855 goto fail; 856 } 857 858 if (auth->c_sign_key) { 859 ssid->dpp_csign = os_malloc(wpabuf_len(auth->c_sign_key)); 860 if (!ssid->dpp_csign) 861 goto fail; 862 os_memcpy(ssid->dpp_csign, wpabuf_head(auth->c_sign_key), 863 wpabuf_len(auth->c_sign_key)); 864 ssid->dpp_csign_len = wpabuf_len(auth->c_sign_key); 865 } 866 867 if (auth->net_access_key) { 868 ssid->dpp_netaccesskey = 869 os_malloc(wpabuf_len(auth->net_access_key)); 870 if (!ssid->dpp_netaccesskey) 871 goto fail; 872 os_memcpy(ssid->dpp_netaccesskey, 873 wpabuf_head(auth->net_access_key), 874 wpabuf_len(auth->net_access_key)); 875 ssid->dpp_netaccesskey_len = wpabuf_len(auth->net_access_key); 876 ssid->dpp_netaccesskey_expiry = auth->net_access_key_expiry; 877 } 878 879 if (!auth->connector || dpp_akm_psk(auth->akm) || 880 dpp_akm_sae(auth->akm)) { 881 if (!auth->connector) 882 ssid->key_mgmt = 0; 883 if (dpp_akm_psk(auth->akm)) 884 ssid->key_mgmt |= WPA_KEY_MGMT_PSK | 885 WPA_KEY_MGMT_PSK_SHA256 | WPA_KEY_MGMT_FT_PSK; 886 if (dpp_akm_sae(auth->akm)) 887 ssid->key_mgmt |= WPA_KEY_MGMT_SAE | 888 WPA_KEY_MGMT_FT_SAE; 889 ssid->ieee80211w = MGMT_FRAME_PROTECTION_OPTIONAL; 890 if (auth->passphrase[0]) { 891 if (wpa_config_set_quoted(ssid, "psk", 892 auth->passphrase) < 0) 893 goto fail; 894 wpa_config_update_psk(ssid); 895 ssid->export_keys = 1; 896 } else { 897 ssid->psk_set = auth->psk_set; 898 os_memcpy(ssid->psk, auth->psk, PMK_LEN); 899 } 900 } 901 902 return ssid; 903fail: 904 wpas_notify_network_removed(wpa_s, ssid); 905 wpa_config_remove_network(wpa_s->conf, ssid->id); 906 return NULL; 907} 908 909 910static int wpas_dpp_process_config(struct wpa_supplicant *wpa_s, 911 struct dpp_authentication *auth) 912{ 913 struct wpa_ssid *ssid; 914 915 if (wpa_s->conf->dpp_config_processing < 1) 916 return 0; 917 918 ssid = wpas_dpp_add_network(wpa_s, auth); 919 if (!ssid) 920 return -1; 921 922 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_NETWORK_ID "%d", ssid->id); 923 if (wpa_s->conf->dpp_config_processing == 2) 924 ssid->disabled = 0; 925 926#ifndef CONFIG_NO_CONFIG_WRITE 927 if (wpa_s->conf->update_config && 928 wpa_config_write(wpa_s->confname, wpa_s->conf)) 929 wpa_printf(MSG_DEBUG, "DPP: Failed to update configuration"); 930#endif /* CONFIG_NO_CONFIG_WRITE */ 931 932 if (wpa_s->conf->dpp_config_processing < 2) 933 return 0; 934 935#ifdef CONFIG_DPP2 936 if (auth->peer_version >= 2) { 937 wpa_printf(MSG_DEBUG, 938 "DPP: Postpone connection attempt to wait for completion of DPP Configuration Result"); 939 auth->connect_on_tx_status = 1; 940 return 0; 941 } 942#endif /* CONFIG_DPP2 */ 943 944 wpas_dpp_try_to_connect(wpa_s); 945 return 0; 946} 947 948 949static int wpas_dpp_handle_config_obj(struct wpa_supplicant *wpa_s, 950 struct dpp_authentication *auth) 951{ 952 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_RECEIVED); 953 if (auth->ssid_len) 954 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONFOBJ_SSID "%s", 955 wpa_ssid_txt(auth->ssid, auth->ssid_len)); 956 if (auth->connector) { 957 /* TODO: Save the Connector and consider using a command 958 * to fetch the value instead of sending an event with 959 * it. The Connector could end up being larger than what 960 * most clients are ready to receive as an event 961 * message. */ 962 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONNECTOR "%s", 963 auth->connector); 964 } 965 if (auth->c_sign_key) { 966 char *hex; 967 size_t hexlen; 968 969 hexlen = 2 * wpabuf_len(auth->c_sign_key) + 1; 970 hex = os_malloc(hexlen); 971 if (hex) { 972 wpa_snprintf_hex(hex, hexlen, 973 wpabuf_head(auth->c_sign_key), 974 wpabuf_len(auth->c_sign_key)); 975 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_C_SIGN_KEY "%s", 976 hex); 977 os_free(hex); 978 } 979 } 980 if (auth->net_access_key) { 981 char *hex; 982 size_t hexlen; 983 984 hexlen = 2 * wpabuf_len(auth->net_access_key) + 1; 985 hex = os_malloc(hexlen); 986 if (hex) { 987 wpa_snprintf_hex(hex, hexlen, 988 wpabuf_head(auth->net_access_key), 989 wpabuf_len(auth->net_access_key)); 990 if (auth->net_access_key_expiry) 991 wpa_msg(wpa_s, MSG_INFO, 992 DPP_EVENT_NET_ACCESS_KEY "%s %lu", hex, 993 (long unsigned) 994 auth->net_access_key_expiry); 995 else 996 wpa_msg(wpa_s, MSG_INFO, 997 DPP_EVENT_NET_ACCESS_KEY "%s", hex); 998 os_free(hex); 999 } 1000 } 1001 1002 return wpas_dpp_process_config(wpa_s, auth); 1003} 1004 1005 1006static void wpas_dpp_gas_resp_cb(void *ctx, const u8 *addr, u8 dialog_token, 1007 enum gas_query_result result, 1008 const struct wpabuf *adv_proto, 1009 const struct wpabuf *resp, u16 status_code) 1010{ 1011 struct wpa_supplicant *wpa_s = ctx; 1012 const u8 *pos; 1013 struct dpp_authentication *auth = wpa_s->dpp_auth; 1014 int res; 1015 enum dpp_status_error status = DPP_STATUS_CONFIG_REJECTED; 1016 1017 wpa_s->dpp_gas_dialog_token = -1; 1018 1019 if (!auth || !auth->auth_success) { 1020 wpa_printf(MSG_DEBUG, "DPP: No matching exchange in progress"); 1021 return; 1022 } 1023 if (result != GAS_QUERY_SUCCESS || 1024 !resp || status_code != WLAN_STATUS_SUCCESS) { 1025 wpa_printf(MSG_DEBUG, "DPP: GAS query did not succeed"); 1026 goto fail; 1027 } 1028 1029 wpa_hexdump_buf(MSG_DEBUG, "DPP: Configuration Response adv_proto", 1030 adv_proto); 1031 wpa_hexdump_buf(MSG_DEBUG, "DPP: Configuration Response (GAS response)", 1032 resp); 1033 1034 if (wpabuf_len(adv_proto) != 10 || 1035 !(pos = wpabuf_head(adv_proto)) || 1036 pos[0] != WLAN_EID_ADV_PROTO || 1037 pos[1] != 8 || 1038 pos[3] != WLAN_EID_VENDOR_SPECIFIC || 1039 pos[4] != 5 || 1040 WPA_GET_BE24(&pos[5]) != OUI_WFA || 1041 pos[8] != 0x1a || 1042 pos[9] != 1) { 1043 wpa_printf(MSG_DEBUG, 1044 "DPP: Not a DPP Advertisement Protocol ID"); 1045 goto fail; 1046 } 1047 1048 if (dpp_conf_resp_rx(auth, resp) < 0) { 1049 wpa_printf(MSG_DEBUG, "DPP: Configuration attempt failed"); 1050 goto fail; 1051 } 1052 1053 res = wpas_dpp_handle_config_obj(wpa_s, auth); 1054 if (res < 0) 1055 goto fail; 1056 1057 status = DPP_STATUS_OK; 1058#ifdef CONFIG_TESTING_OPTIONS 1059 if (dpp_test == DPP_TEST_REJECT_CONFIG) { 1060 wpa_printf(MSG_INFO, "DPP: TESTING - Reject Config Object"); 1061 status = DPP_STATUS_CONFIG_REJECTED; 1062 } 1063#endif /* CONFIG_TESTING_OPTIONS */ 1064fail: 1065 if (status != DPP_STATUS_OK) 1066 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED); 1067#ifdef CONFIG_DPP2 1068 if (auth->peer_version >= 2 && 1069 auth->conf_resp_status == DPP_STATUS_OK) { 1070 struct wpabuf *msg; 1071 1072 wpa_printf(MSG_DEBUG, "DPP: Send DPP Configuration Result"); 1073 msg = dpp_build_conf_result(auth, status); 1074 if (!msg) 1075 goto fail2; 1076 1077 wpa_msg(wpa_s, MSG_INFO, 1078 DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d", 1079 MAC2STR(addr), auth->curr_freq, 1080 DPP_PA_CONFIGURATION_RESULT); 1081 offchannel_send_action(wpa_s, auth->curr_freq, 1082 addr, wpa_s->own_addr, broadcast, 1083 wpabuf_head(msg), 1084 wpabuf_len(msg), 1085 500, wpas_dpp_tx_status, 0); 1086 wpabuf_free(msg); 1087 1088 /* This exchange will be terminated in the TX status handler */ 1089 return; 1090 } 1091fail2: 1092#endif /* CONFIG_DPP2 */ 1093 dpp_auth_deinit(wpa_s->dpp_auth); 1094 wpa_s->dpp_auth = NULL; 1095} 1096 1097 1098static void wpas_dpp_start_gas_client(struct wpa_supplicant *wpa_s) 1099{ 1100 struct dpp_authentication *auth = wpa_s->dpp_auth; 1101 struct wpabuf *buf; 1102 char json[100]; 1103 int res; 1104 1105 wpa_s->dpp_gas_client = 1; 1106 os_snprintf(json, sizeof(json), 1107 "{\"name\":\"Test\"," 1108 "\"wi-fi_tech\":\"infra\"," 1109 "\"netRole\":\"%s\"}", 1110 wpa_s->dpp_netrole_ap ? "ap" : "sta"); 1111#ifdef CONFIG_TESTING_OPTIONS 1112 if (dpp_test == DPP_TEST_INVALID_CONFIG_ATTR_OBJ_CONF_REQ) { 1113 wpa_printf(MSG_INFO, "DPP: TESTING - invalid Config Attr"); 1114 json[29] = 'k'; /* replace "infra" with "knfra" */ 1115 } 1116#endif /* CONFIG_TESTING_OPTIONS */ 1117 wpa_printf(MSG_DEBUG, "DPP: GAS Config Attributes: %s", json); 1118 1119 offchannel_send_action_done(wpa_s); 1120 wpas_dpp_listen_stop(wpa_s); 1121 1122 buf = dpp_build_conf_req(auth, json); 1123 if (!buf) { 1124 wpa_printf(MSG_DEBUG, 1125 "DPP: No configuration request data available"); 1126 return; 1127 } 1128 1129 wpa_printf(MSG_DEBUG, "DPP: GAS request to " MACSTR " (freq %u MHz)", 1130 MAC2STR(auth->peer_mac_addr), auth->curr_freq); 1131 1132 res = gas_query_req(wpa_s->gas, auth->peer_mac_addr, auth->curr_freq, 1133 1, buf, wpas_dpp_gas_resp_cb, wpa_s); 1134 if (res < 0) { 1135 wpa_msg(wpa_s, MSG_DEBUG, "GAS: Failed to send Query Request"); 1136 wpabuf_free(buf); 1137 } else { 1138 wpa_printf(MSG_DEBUG, 1139 "DPP: GAS query started with dialog token %u", res); 1140 wpa_s->dpp_gas_dialog_token = res; 1141 } 1142} 1143 1144 1145static void wpas_dpp_auth_success(struct wpa_supplicant *wpa_s, int initiator) 1146{ 1147 wpa_printf(MSG_DEBUG, "DPP: Authentication succeeded"); 1148 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_SUCCESS "init=%d", initiator); 1149#ifdef CONFIG_TESTING_OPTIONS 1150 if (dpp_test == DPP_TEST_STOP_AT_AUTH_CONF) { 1151 wpa_printf(MSG_INFO, 1152 "DPP: TESTING - stop at Authentication Confirm"); 1153 if (wpa_s->dpp_auth->configurator) { 1154 /* Prevent GAS response */ 1155 wpa_s->dpp_auth->auth_success = 0; 1156 } 1157 return; 1158 } 1159#endif /* CONFIG_TESTING_OPTIONS */ 1160 1161 if (wpa_s->dpp_auth->configurator) 1162 wpas_dpp_start_gas_server(wpa_s); 1163 else 1164 wpas_dpp_start_gas_client(wpa_s); 1165} 1166 1167 1168static void wpas_dpp_rx_auth_resp(struct wpa_supplicant *wpa_s, const u8 *src, 1169 const u8 *hdr, const u8 *buf, size_t len, 1170 unsigned int freq) 1171{ 1172 struct dpp_authentication *auth = wpa_s->dpp_auth; 1173 struct wpabuf *msg; 1174 1175 wpa_printf(MSG_DEBUG, "DPP: Authentication Response from " MACSTR 1176 " (freq %u MHz)", MAC2STR(src), freq); 1177 1178 if (!auth) { 1179 wpa_printf(MSG_DEBUG, 1180 "DPP: No DPP Authentication in progress - drop"); 1181 return; 1182 } 1183 1184 if (!is_zero_ether_addr(auth->peer_mac_addr) && 1185 os_memcmp(src, auth->peer_mac_addr, ETH_ALEN) != 0) { 1186 wpa_printf(MSG_DEBUG, "DPP: MAC address mismatch (expected " 1187 MACSTR ") - drop", MAC2STR(auth->peer_mac_addr)); 1188 return; 1189 } 1190 1191 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL); 1192 1193 if (auth->curr_freq != freq && auth->neg_freq == freq) { 1194 wpa_printf(MSG_DEBUG, 1195 "DPP: Responder accepted request for different negotiation channel"); 1196 auth->curr_freq = freq; 1197 } 1198 1199 eloop_cancel_timeout(wpas_dpp_init_timeout, wpa_s, NULL); 1200 msg = dpp_auth_resp_rx(auth, hdr, buf, len); 1201 if (!msg) { 1202 if (auth->auth_resp_status == DPP_STATUS_RESPONSE_PENDING) { 1203 wpa_printf(MSG_DEBUG, 1204 "DPP: Start wait for full response"); 1205 offchannel_send_action_done(wpa_s); 1206 wpas_dpp_listen_start(wpa_s, auth->curr_freq); 1207 return; 1208 } 1209 wpa_printf(MSG_DEBUG, "DPP: No confirm generated"); 1210 return; 1211 } 1212 os_memcpy(auth->peer_mac_addr, src, ETH_ALEN); 1213 1214 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d", 1215 MAC2STR(src), auth->curr_freq, DPP_PA_AUTHENTICATION_CONF); 1216 offchannel_send_action(wpa_s, auth->curr_freq, 1217 src, wpa_s->own_addr, broadcast, 1218 wpabuf_head(msg), wpabuf_len(msg), 1219 500, wpas_dpp_tx_status, 0); 1220 wpabuf_free(msg); 1221 wpa_s->dpp_auth_ok_on_ack = 1; 1222} 1223 1224 1225static void wpas_dpp_rx_auth_conf(struct wpa_supplicant *wpa_s, const u8 *src, 1226 const u8 *hdr, const u8 *buf, size_t len) 1227{ 1228 struct dpp_authentication *auth = wpa_s->dpp_auth; 1229 1230 wpa_printf(MSG_DEBUG, "DPP: Authentication Confirmation from " MACSTR, 1231 MAC2STR(src)); 1232 1233 if (!auth) { 1234 wpa_printf(MSG_DEBUG, 1235 "DPP: No DPP Authentication in progress - drop"); 1236 return; 1237 } 1238 1239 if (os_memcmp(src, auth->peer_mac_addr, ETH_ALEN) != 0) { 1240 wpa_printf(MSG_DEBUG, "DPP: MAC address mismatch (expected " 1241 MACSTR ") - drop", MAC2STR(auth->peer_mac_addr)); 1242 return; 1243 } 1244 1245 if (dpp_auth_conf_rx(auth, hdr, buf, len) < 0) { 1246 wpa_printf(MSG_DEBUG, "DPP: Authentication failed"); 1247 return; 1248 } 1249 1250 wpas_dpp_auth_success(wpa_s, 0); 1251} 1252 1253 1254#ifdef CONFIG_DPP2 1255 1256static void wpas_dpp_config_result_wait_timeout(void *eloop_ctx, 1257 void *timeout_ctx) 1258{ 1259 struct wpa_supplicant *wpa_s = eloop_ctx; 1260 struct dpp_authentication *auth = wpa_s->dpp_auth; 1261 1262 if (!auth || !auth->waiting_conf_result) 1263 return; 1264 1265 wpa_printf(MSG_DEBUG, 1266 "DPP: Timeout while waiting for Configuration Result"); 1267 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED); 1268 dpp_auth_deinit(auth); 1269 wpa_s->dpp_auth = NULL; 1270} 1271 1272 1273static void wpas_dpp_rx_conf_result(struct wpa_supplicant *wpa_s, const u8 *src, 1274 const u8 *hdr, const u8 *buf, size_t len) 1275{ 1276 struct dpp_authentication *auth = wpa_s->dpp_auth; 1277 enum dpp_status_error status; 1278 1279 wpa_printf(MSG_DEBUG, "DPP: Configuration Result from " MACSTR, 1280 MAC2STR(src)); 1281 1282 if (!auth || !auth->waiting_conf_result) { 1283 wpa_printf(MSG_DEBUG, 1284 "DPP: No DPP Configuration waiting for result - drop"); 1285 return; 1286 } 1287 1288 if (os_memcmp(src, auth->peer_mac_addr, ETH_ALEN) != 0) { 1289 wpa_printf(MSG_DEBUG, "DPP: MAC address mismatch (expected " 1290 MACSTR ") - drop", MAC2STR(auth->peer_mac_addr)); 1291 return; 1292 } 1293 1294 status = dpp_conf_result_rx(auth, hdr, buf, len); 1295 1296 offchannel_send_action_done(wpa_s); 1297 wpas_dpp_listen_stop(wpa_s); 1298 if (status == DPP_STATUS_OK) 1299 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_SENT); 1300 else 1301 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED); 1302 dpp_auth_deinit(auth); 1303 wpa_s->dpp_auth = NULL; 1304 eloop_cancel_timeout(wpas_dpp_config_result_wait_timeout, wpa_s, NULL); 1305} 1306 1307 1308static int wpas_dpp_process_conf_obj(void *ctx, 1309 struct dpp_authentication *auth) 1310{ 1311 struct wpa_supplicant *wpa_s = ctx; 1312 1313 return wpas_dpp_handle_config_obj(wpa_s, auth); 1314} 1315 1316#endif /* CONFIG_DPP2 */ 1317 1318 1319static void wpas_dpp_rx_peer_disc_resp(struct wpa_supplicant *wpa_s, 1320 const u8 *src, 1321 const u8 *buf, size_t len) 1322{ 1323 struct wpa_ssid *ssid; 1324 const u8 *connector, *trans_id, *status; 1325 u16 connector_len, trans_id_len, status_len; 1326 struct dpp_introduction intro; 1327 struct rsn_pmksa_cache_entry *entry; 1328 struct os_time now; 1329 struct os_reltime rnow; 1330 os_time_t expiry; 1331 unsigned int seconds; 1332 enum dpp_status_error res; 1333 1334 wpa_printf(MSG_DEBUG, "DPP: Peer Discovery Response from " MACSTR, 1335 MAC2STR(src)); 1336 if (is_zero_ether_addr(wpa_s->dpp_intro_bssid) || 1337 os_memcmp(src, wpa_s->dpp_intro_bssid, ETH_ALEN) != 0) { 1338 wpa_printf(MSG_DEBUG, "DPP: Not waiting for response from " 1339 MACSTR " - drop", MAC2STR(src)); 1340 return; 1341 } 1342 offchannel_send_action_done(wpa_s); 1343 1344 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) { 1345 if (ssid == wpa_s->dpp_intro_network) 1346 break; 1347 } 1348 if (!ssid || !ssid->dpp_connector || !ssid->dpp_netaccesskey || 1349 !ssid->dpp_csign) { 1350 wpa_printf(MSG_DEBUG, 1351 "DPP: Profile not found for network introduction"); 1352 return; 1353 } 1354 1355 trans_id = dpp_get_attr(buf, len, DPP_ATTR_TRANSACTION_ID, 1356 &trans_id_len); 1357 if (!trans_id || trans_id_len != 1) { 1358 wpa_printf(MSG_DEBUG, 1359 "DPP: Peer did not include Transaction ID"); 1360 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR 1361 " fail=missing_transaction_id", MAC2STR(src)); 1362 goto fail; 1363 } 1364 if (trans_id[0] != TRANSACTION_ID) { 1365 wpa_printf(MSG_DEBUG, 1366 "DPP: Ignore frame with unexpected Transaction ID %u", 1367 trans_id[0]); 1368 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR 1369 " fail=transaction_id_mismatch", MAC2STR(src)); 1370 goto fail; 1371 } 1372 1373 status = dpp_get_attr(buf, len, DPP_ATTR_STATUS, &status_len); 1374 if (!status || status_len != 1) { 1375 wpa_printf(MSG_DEBUG, "DPP: Peer did not include Status"); 1376 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR 1377 " fail=missing_status", MAC2STR(src)); 1378 goto fail; 1379 } 1380 if (status[0] != DPP_STATUS_OK) { 1381 wpa_printf(MSG_DEBUG, 1382 "DPP: Peer rejected network introduction: Status %u", 1383 status[0]); 1384 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR 1385 " status=%u", MAC2STR(src), status[0]); 1386 goto fail; 1387 } 1388 1389 connector = dpp_get_attr(buf, len, DPP_ATTR_CONNECTOR, &connector_len); 1390 if (!connector) { 1391 wpa_printf(MSG_DEBUG, 1392 "DPP: Peer did not include its Connector"); 1393 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR 1394 " fail=missing_connector", MAC2STR(src)); 1395 goto fail; 1396 } 1397 1398 res = dpp_peer_intro(&intro, ssid->dpp_connector, 1399 ssid->dpp_netaccesskey, 1400 ssid->dpp_netaccesskey_len, 1401 ssid->dpp_csign, 1402 ssid->dpp_csign_len, 1403 connector, connector_len, &expiry); 1404 if (res != DPP_STATUS_OK) { 1405 wpa_printf(MSG_INFO, 1406 "DPP: Network Introduction protocol resulted in failure"); 1407 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR 1408 " fail=peer_connector_validation_failed", MAC2STR(src)); 1409 goto fail; 1410 } 1411 1412 entry = os_zalloc(sizeof(*entry)); 1413 if (!entry) 1414 goto fail; 1415 os_memcpy(entry->aa, src, ETH_ALEN); 1416 os_memcpy(entry->pmkid, intro.pmkid, PMKID_LEN); 1417 os_memcpy(entry->pmk, intro.pmk, intro.pmk_len); 1418 entry->pmk_len = intro.pmk_len; 1419 entry->akmp = WPA_KEY_MGMT_DPP; 1420 if (expiry) { 1421 os_get_time(&now); 1422 seconds = expiry - now.sec; 1423 } else { 1424 seconds = 86400 * 7; 1425 } 1426 os_get_reltime(&rnow); 1427 entry->expiration = rnow.sec + seconds; 1428 entry->reauth_time = rnow.sec + seconds; 1429 entry->network_ctx = ssid; 1430 wpa_sm_pmksa_cache_add_entry(wpa_s->wpa, entry); 1431 1432 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR 1433 " status=%u", MAC2STR(src), status[0]); 1434 1435 wpa_printf(MSG_DEBUG, 1436 "DPP: Try connection again after successful network introduction"); 1437 if (wpa_supplicant_fast_associate(wpa_s) != 1) { 1438 wpa_supplicant_cancel_sched_scan(wpa_s); 1439 wpa_supplicant_req_scan(wpa_s, 0, 0); 1440 } 1441fail: 1442 os_memset(&intro, 0, sizeof(intro)); 1443} 1444 1445 1446static int wpas_dpp_allow_ir(struct wpa_supplicant *wpa_s, unsigned int freq) 1447{ 1448 int i, j; 1449 1450 if (!wpa_s->hw.modes) 1451 return -1; 1452 1453 for (i = 0; i < wpa_s->hw.num_modes; i++) { 1454 struct hostapd_hw_modes *mode = &wpa_s->hw.modes[i]; 1455 1456 for (j = 0; j < mode->num_channels; j++) { 1457 struct hostapd_channel_data *chan = &mode->channels[j]; 1458 1459 if (chan->freq != (int) freq) 1460 continue; 1461 1462 if (chan->flag & (HOSTAPD_CHAN_DISABLED | 1463 HOSTAPD_CHAN_NO_IR | 1464 HOSTAPD_CHAN_RADAR)) 1465 continue; 1466 1467 return 1; 1468 } 1469 } 1470 1471 wpa_printf(MSG_DEBUG, 1472 "DPP: Frequency %u MHz not supported or does not allow PKEX initiation in the current channel list", 1473 freq); 1474 1475 return 0; 1476} 1477 1478 1479static int wpas_dpp_pkex_next_channel(struct wpa_supplicant *wpa_s, 1480 struct dpp_pkex *pkex) 1481{ 1482 if (pkex->freq == 2437) 1483 pkex->freq = 5745; 1484 else if (pkex->freq == 5745) 1485 pkex->freq = 5220; 1486 else if (pkex->freq == 5220) 1487 pkex->freq = 60480; 1488 else 1489 return -1; /* no more channels to try */ 1490 1491 if (wpas_dpp_allow_ir(wpa_s, pkex->freq) == 1) { 1492 wpa_printf(MSG_DEBUG, "DPP: Try to initiate on %u MHz", 1493 pkex->freq); 1494 return 0; 1495 } 1496 1497 /* Could not use this channel - try the next one */ 1498 return wpas_dpp_pkex_next_channel(wpa_s, pkex); 1499} 1500 1501 1502static void wpas_dpp_pkex_retry_timeout(void *eloop_ctx, void *timeout_ctx) 1503{ 1504 struct wpa_supplicant *wpa_s = eloop_ctx; 1505 struct dpp_pkex *pkex = wpa_s->dpp_pkex; 1506 1507 if (!pkex || !pkex->exchange_req) 1508 return; 1509 if (pkex->exch_req_tries >= 5) { 1510 if (wpas_dpp_pkex_next_channel(wpa_s, pkex) < 0) { 1511 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL 1512 "No response from PKEX peer"); 1513 dpp_pkex_free(pkex); 1514 wpa_s->dpp_pkex = NULL; 1515 return; 1516 } 1517 pkex->exch_req_tries = 0; 1518 } 1519 1520 pkex->exch_req_tries++; 1521 wpa_printf(MSG_DEBUG, "DPP: Retransmit PKEX Exchange Request (try %u)", 1522 pkex->exch_req_tries); 1523 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d", 1524 MAC2STR(broadcast), pkex->freq, DPP_PA_PKEX_EXCHANGE_REQ); 1525 offchannel_send_action(wpa_s, pkex->freq, broadcast, 1526 wpa_s->own_addr, broadcast, 1527 wpabuf_head(pkex->exchange_req), 1528 wpabuf_len(pkex->exchange_req), 1529 pkex->exch_req_wait_time, 1530 wpas_dpp_tx_pkex_status, 0); 1531} 1532 1533 1534static void 1535wpas_dpp_tx_pkex_status(struct wpa_supplicant *wpa_s, 1536 unsigned int freq, const u8 *dst, 1537 const u8 *src, const u8 *bssid, 1538 const u8 *data, size_t data_len, 1539 enum offchannel_send_action_result result) 1540{ 1541 const char *res_txt; 1542 struct dpp_pkex *pkex = wpa_s->dpp_pkex; 1543 1544 res_txt = result == OFFCHANNEL_SEND_ACTION_SUCCESS ? "SUCCESS" : 1545 (result == OFFCHANNEL_SEND_ACTION_NO_ACK ? "no-ACK" : 1546 "FAILED"); 1547 wpa_printf(MSG_DEBUG, "DPP: TX status: freq=%u dst=" MACSTR 1548 " result=%s (PKEX)", 1549 freq, MAC2STR(dst), res_txt); 1550 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX_STATUS "dst=" MACSTR 1551 " freq=%u result=%s", MAC2STR(dst), freq, res_txt); 1552 1553 if (!pkex) { 1554 wpa_printf(MSG_DEBUG, 1555 "DPP: Ignore TX status since there is no ongoing PKEX exchange"); 1556 return; 1557 } 1558 1559 if (pkex->failed) { 1560 wpa_printf(MSG_DEBUG, 1561 "DPP: Terminate PKEX exchange due to an earlier error"); 1562 if (pkex->t > pkex->own_bi->pkex_t) 1563 pkex->own_bi->pkex_t = pkex->t; 1564 dpp_pkex_free(pkex); 1565 wpa_s->dpp_pkex = NULL; 1566 return; 1567 } 1568 1569 if (pkex->exch_req_wait_time && pkex->exchange_req) { 1570 /* Wait for PKEX Exchange Response frame and retry request if 1571 * no response is seen. */ 1572 eloop_cancel_timeout(wpas_dpp_pkex_retry_timeout, wpa_s, NULL); 1573 eloop_register_timeout(pkex->exch_req_wait_time / 1000, 1574 (pkex->exch_req_wait_time % 1000) * 1000, 1575 wpas_dpp_pkex_retry_timeout, wpa_s, 1576 NULL); 1577 } 1578} 1579 1580 1581static void 1582wpas_dpp_rx_pkex_exchange_req(struct wpa_supplicant *wpa_s, const u8 *src, 1583 const u8 *buf, size_t len, unsigned int freq) 1584{ 1585 struct wpabuf *msg; 1586 unsigned int wait_time; 1587 1588 wpa_printf(MSG_DEBUG, "DPP: PKEX Exchange Request from " MACSTR, 1589 MAC2STR(src)); 1590 1591 /* TODO: Support multiple PKEX codes by iterating over all the enabled 1592 * values here */ 1593 1594 if (!wpa_s->dpp_pkex_code || !wpa_s->dpp_pkex_bi) { 1595 wpa_printf(MSG_DEBUG, 1596 "DPP: No PKEX code configured - ignore request"); 1597 return; 1598 } 1599 1600 if (wpa_s->dpp_pkex) { 1601 /* TODO: Support parallel operations */ 1602 wpa_printf(MSG_DEBUG, 1603 "DPP: Already in PKEX session - ignore new request"); 1604 return; 1605 } 1606 1607 wpa_s->dpp_pkex = dpp_pkex_rx_exchange_req(wpa_s, wpa_s->dpp_pkex_bi, 1608 wpa_s->own_addr, src, 1609 wpa_s->dpp_pkex_identifier, 1610 wpa_s->dpp_pkex_code, 1611 buf, len); 1612 if (!wpa_s->dpp_pkex) { 1613 wpa_printf(MSG_DEBUG, 1614 "DPP: Failed to process the request - ignore it"); 1615 return; 1616 } 1617 1618 msg = wpa_s->dpp_pkex->exchange_resp; 1619 wait_time = wpa_s->max_remain_on_chan; 1620 if (wait_time > 2000) 1621 wait_time = 2000; 1622 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d", 1623 MAC2STR(src), freq, DPP_PA_PKEX_EXCHANGE_RESP); 1624 offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr, 1625 broadcast, 1626 wpabuf_head(msg), wpabuf_len(msg), 1627 wait_time, wpas_dpp_tx_pkex_status, 0); 1628} 1629 1630 1631static void 1632wpas_dpp_rx_pkex_exchange_resp(struct wpa_supplicant *wpa_s, const u8 *src, 1633 const u8 *buf, size_t len, unsigned int freq) 1634{ 1635 struct wpabuf *msg; 1636 unsigned int wait_time; 1637 1638 wpa_printf(MSG_DEBUG, "DPP: PKEX Exchange Response from " MACSTR, 1639 MAC2STR(src)); 1640 1641 /* TODO: Support multiple PKEX codes by iterating over all the enabled 1642 * values here */ 1643 1644 if (!wpa_s->dpp_pkex || !wpa_s->dpp_pkex->initiator || 1645 wpa_s->dpp_pkex->exchange_done) { 1646 wpa_printf(MSG_DEBUG, "DPP: No matching PKEX session"); 1647 return; 1648 } 1649 1650 eloop_cancel_timeout(wpas_dpp_pkex_retry_timeout, wpa_s, NULL); 1651 wpa_s->dpp_pkex->exch_req_wait_time = 0; 1652 1653 msg = dpp_pkex_rx_exchange_resp(wpa_s->dpp_pkex, src, buf, len); 1654 if (!msg) { 1655 wpa_printf(MSG_DEBUG, "DPP: Failed to process the response"); 1656 return; 1657 } 1658 1659 wpa_printf(MSG_DEBUG, "DPP: Send PKEX Commit-Reveal Request to " MACSTR, 1660 MAC2STR(src)); 1661 1662 wait_time = wpa_s->max_remain_on_chan; 1663 if (wait_time > 2000) 1664 wait_time = 2000; 1665 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d", 1666 MAC2STR(src), freq, DPP_PA_PKEX_COMMIT_REVEAL_REQ); 1667 offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr, 1668 broadcast, 1669 wpabuf_head(msg), wpabuf_len(msg), 1670 wait_time, wpas_dpp_tx_pkex_status, 0); 1671 wpabuf_free(msg); 1672} 1673 1674 1675static struct dpp_bootstrap_info * 1676wpas_dpp_pkex_finish(struct wpa_supplicant *wpa_s, const u8 *peer, 1677 unsigned int freq) 1678{ 1679 struct dpp_bootstrap_info *bi; 1680 1681 bi = dpp_pkex_finish(wpa_s->dpp, wpa_s->dpp_pkex, peer, freq); 1682 if (!bi) 1683 return NULL; 1684 wpa_s->dpp_pkex = NULL; 1685 return bi; 1686} 1687 1688 1689static void 1690wpas_dpp_rx_pkex_commit_reveal_req(struct wpa_supplicant *wpa_s, const u8 *src, 1691 const u8 *hdr, const u8 *buf, size_t len, 1692 unsigned int freq) 1693{ 1694 struct wpabuf *msg; 1695 unsigned int wait_time; 1696 struct dpp_pkex *pkex = wpa_s->dpp_pkex; 1697 1698 wpa_printf(MSG_DEBUG, "DPP: PKEX Commit-Reveal Request from " MACSTR, 1699 MAC2STR(src)); 1700 1701 if (!pkex || pkex->initiator || !pkex->exchange_done) { 1702 wpa_printf(MSG_DEBUG, "DPP: No matching PKEX session"); 1703 return; 1704 } 1705 1706 msg = dpp_pkex_rx_commit_reveal_req(pkex, hdr, buf, len); 1707 if (!msg) { 1708 wpa_printf(MSG_DEBUG, "DPP: Failed to process the request"); 1709 if (pkex->failed) { 1710 wpa_printf(MSG_DEBUG, "DPP: Terminate PKEX exchange"); 1711 if (pkex->t > pkex->own_bi->pkex_t) 1712 pkex->own_bi->pkex_t = pkex->t; 1713 dpp_pkex_free(wpa_s->dpp_pkex); 1714 wpa_s->dpp_pkex = NULL; 1715 } 1716 return; 1717 } 1718 1719 wpa_printf(MSG_DEBUG, "DPP: Send PKEX Commit-Reveal Response to " 1720 MACSTR, MAC2STR(src)); 1721 1722 wait_time = wpa_s->max_remain_on_chan; 1723 if (wait_time > 2000) 1724 wait_time = 2000; 1725 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d", 1726 MAC2STR(src), freq, DPP_PA_PKEX_COMMIT_REVEAL_RESP); 1727 offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr, 1728 broadcast, 1729 wpabuf_head(msg), wpabuf_len(msg), 1730 wait_time, wpas_dpp_tx_pkex_status, 0); 1731 wpabuf_free(msg); 1732 1733 wpas_dpp_pkex_finish(wpa_s, src, freq); 1734} 1735 1736 1737static void 1738wpas_dpp_rx_pkex_commit_reveal_resp(struct wpa_supplicant *wpa_s, const u8 *src, 1739 const u8 *hdr, const u8 *buf, size_t len, 1740 unsigned int freq) 1741{ 1742 int res; 1743 struct dpp_bootstrap_info *bi; 1744 struct dpp_pkex *pkex = wpa_s->dpp_pkex; 1745 char cmd[500]; 1746 1747 wpa_printf(MSG_DEBUG, "DPP: PKEX Commit-Reveal Response from " MACSTR, 1748 MAC2STR(src)); 1749 1750 if (!pkex || !pkex->initiator || !pkex->exchange_done) { 1751 wpa_printf(MSG_DEBUG, "DPP: No matching PKEX session"); 1752 return; 1753 } 1754 1755 res = dpp_pkex_rx_commit_reveal_resp(pkex, hdr, buf, len); 1756 if (res < 0) { 1757 wpa_printf(MSG_DEBUG, "DPP: Failed to process the response"); 1758 return; 1759 } 1760 1761 bi = wpas_dpp_pkex_finish(wpa_s, src, freq); 1762 if (!bi) 1763 return; 1764 1765 os_snprintf(cmd, sizeof(cmd), " peer=%u %s", 1766 bi->id, 1767 wpa_s->dpp_pkex_auth_cmd ? wpa_s->dpp_pkex_auth_cmd : ""); 1768 wpa_printf(MSG_DEBUG, 1769 "DPP: Start authentication after PKEX with parameters: %s", 1770 cmd); 1771 if (wpas_dpp_auth_init(wpa_s, cmd) < 0) { 1772 wpa_printf(MSG_DEBUG, 1773 "DPP: Authentication initialization failed"); 1774 return; 1775 } 1776} 1777 1778 1779void wpas_dpp_rx_action(struct wpa_supplicant *wpa_s, const u8 *src, 1780 const u8 *buf, size_t len, unsigned int freq) 1781{ 1782 u8 crypto_suite; 1783 enum dpp_public_action_frame_type type; 1784 const u8 *hdr; 1785 unsigned int pkex_t; 1786 1787 if (len < DPP_HDR_LEN) 1788 return; 1789 if (WPA_GET_BE24(buf) != OUI_WFA || buf[3] != DPP_OUI_TYPE) 1790 return; 1791 hdr = buf; 1792 buf += 4; 1793 len -= 4; 1794 crypto_suite = *buf++; 1795 type = *buf++; 1796 len -= 2; 1797 1798 wpa_printf(MSG_DEBUG, 1799 "DPP: Received DPP Public Action frame crypto suite %u type %d from " 1800 MACSTR " freq=%u", 1801 crypto_suite, type, MAC2STR(src), freq); 1802 if (crypto_suite != 1) { 1803 wpa_printf(MSG_DEBUG, "DPP: Unsupported crypto suite %u", 1804 crypto_suite); 1805 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_RX "src=" MACSTR 1806 " freq=%u type=%d ignore=unsupported-crypto-suite", 1807 MAC2STR(src), freq, type); 1808 return; 1809 } 1810 wpa_hexdump(MSG_MSGDUMP, "DPP: Received message attributes", buf, len); 1811 if (dpp_check_attrs(buf, len) < 0) { 1812 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_RX "src=" MACSTR 1813 " freq=%u type=%d ignore=invalid-attributes", 1814 MAC2STR(src), freq, type); 1815 return; 1816 } 1817 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_RX "src=" MACSTR " freq=%u type=%d", 1818 MAC2STR(src), freq, type); 1819 1820 switch (type) { 1821 case DPP_PA_AUTHENTICATION_REQ: 1822 wpas_dpp_rx_auth_req(wpa_s, src, hdr, buf, len, freq); 1823 break; 1824 case DPP_PA_AUTHENTICATION_RESP: 1825 wpas_dpp_rx_auth_resp(wpa_s, src, hdr, buf, len, freq); 1826 break; 1827 case DPP_PA_AUTHENTICATION_CONF: 1828 wpas_dpp_rx_auth_conf(wpa_s, src, hdr, buf, len); 1829 break; 1830 case DPP_PA_PEER_DISCOVERY_RESP: 1831 wpas_dpp_rx_peer_disc_resp(wpa_s, src, buf, len); 1832 break; 1833 case DPP_PA_PKEX_EXCHANGE_REQ: 1834 wpas_dpp_rx_pkex_exchange_req(wpa_s, src, buf, len, freq); 1835 break; 1836 case DPP_PA_PKEX_EXCHANGE_RESP: 1837 wpas_dpp_rx_pkex_exchange_resp(wpa_s, src, buf, len, freq); 1838 break; 1839 case DPP_PA_PKEX_COMMIT_REVEAL_REQ: 1840 wpas_dpp_rx_pkex_commit_reveal_req(wpa_s, src, hdr, buf, len, 1841 freq); 1842 break; 1843 case DPP_PA_PKEX_COMMIT_REVEAL_RESP: 1844 wpas_dpp_rx_pkex_commit_reveal_resp(wpa_s, src, hdr, buf, len, 1845 freq); 1846 break; 1847#ifdef CONFIG_DPP2 1848 case DPP_PA_CONFIGURATION_RESULT: 1849 wpas_dpp_rx_conf_result(wpa_s, src, hdr, buf, len); 1850 break; 1851#endif /* CONFIG_DPP2 */ 1852 default: 1853 wpa_printf(MSG_DEBUG, 1854 "DPP: Ignored unsupported frame subtype %d", type); 1855 break; 1856 } 1857 1858 if (wpa_s->dpp_pkex) 1859 pkex_t = wpa_s->dpp_pkex->t; 1860 else if (wpa_s->dpp_pkex_bi) 1861 pkex_t = wpa_s->dpp_pkex_bi->pkex_t; 1862 else 1863 pkex_t = 0; 1864 if (pkex_t >= PKEX_COUNTER_T_LIMIT) { 1865 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PKEX_T_LIMIT "id=0"); 1866 wpas_dpp_pkex_remove(wpa_s, "*"); 1867 } 1868} 1869 1870 1871static struct wpabuf * 1872wpas_dpp_gas_req_handler(void *ctx, const u8 *sa, const u8 *query, 1873 size_t query_len) 1874{ 1875 struct wpa_supplicant *wpa_s = ctx; 1876 struct dpp_authentication *auth = wpa_s->dpp_auth; 1877 struct wpabuf *resp; 1878 1879 wpa_printf(MSG_DEBUG, "DPP: GAS request from " MACSTR, 1880 MAC2STR(sa)); 1881 if (!auth || !auth->auth_success || 1882 os_memcmp(sa, auth->peer_mac_addr, ETH_ALEN) != 0) { 1883 wpa_printf(MSG_DEBUG, "DPP: No matching exchange in progress"); 1884 return NULL; 1885 } 1886 1887 if (wpa_s->dpp_auth_ok_on_ack && auth->configurator) { 1888 wpa_printf(MSG_DEBUG, 1889 "DPP: Have not received ACK for Auth Confirm yet - assume it was received based on this GAS request"); 1890 /* wpas_dpp_auth_success() would normally have been called from 1891 * TX status handler, but since there was no such handler call 1892 * yet, simply send out the event message and proceed with 1893 * exchange. */ 1894 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_SUCCESS "init=1"); 1895 wpa_s->dpp_auth_ok_on_ack = 0; 1896 } 1897 1898 wpa_hexdump(MSG_DEBUG, 1899 "DPP: Received Configuration Request (GAS Query Request)", 1900 query, query_len); 1901 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_REQ_RX "src=" MACSTR, 1902 MAC2STR(sa)); 1903 resp = dpp_conf_req_rx(auth, query, query_len); 1904 if (!resp) 1905 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED); 1906 auth->conf_resp = resp; 1907 return resp; 1908} 1909 1910 1911static void 1912wpas_dpp_gas_status_handler(void *ctx, struct wpabuf *resp, int ok) 1913{ 1914 struct wpa_supplicant *wpa_s = ctx; 1915 struct dpp_authentication *auth = wpa_s->dpp_auth; 1916 1917 if (!auth) { 1918 wpabuf_free(resp); 1919 return; 1920 } 1921 if (auth->conf_resp != resp) { 1922 wpa_printf(MSG_DEBUG, 1923 "DPP: Ignore GAS status report (ok=%d) for unknown response", 1924 ok); 1925 wpabuf_free(resp); 1926 return; 1927 } 1928 1929 wpa_printf(MSG_DEBUG, "DPP: Configuration exchange completed (ok=%d)", 1930 ok); 1931 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL); 1932 eloop_cancel_timeout(wpas_dpp_auth_resp_retry_timeout, wpa_s, NULL); 1933#ifdef CONFIG_DPP2 1934 if (ok && auth->peer_version >= 2 && 1935 auth->conf_resp_status == DPP_STATUS_OK) { 1936 wpa_printf(MSG_DEBUG, "DPP: Wait for Configuration Result"); 1937 auth->waiting_conf_result = 1; 1938 auth->conf_resp = NULL; 1939 wpabuf_free(resp); 1940 eloop_cancel_timeout(wpas_dpp_config_result_wait_timeout, 1941 wpa_s, NULL); 1942 eloop_register_timeout(2, 0, 1943 wpas_dpp_config_result_wait_timeout, 1944 wpa_s, NULL); 1945 return; 1946 } 1947#endif /* CONFIG_DPP2 */ 1948 offchannel_send_action_done(wpa_s); 1949 wpas_dpp_listen_stop(wpa_s); 1950 if (ok) 1951 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_SENT); 1952 else 1953 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED); 1954 dpp_auth_deinit(wpa_s->dpp_auth); 1955 wpa_s->dpp_auth = NULL; 1956 wpabuf_free(resp); 1957} 1958 1959 1960int wpas_dpp_configurator_sign(struct wpa_supplicant *wpa_s, const char *cmd) 1961{ 1962 struct dpp_authentication *auth; 1963 int ret = -1; 1964 char *curve = NULL; 1965 1966 auth = os_zalloc(sizeof(*auth)); 1967 if (!auth) 1968 return -1; 1969 1970 curve = get_param(cmd, " curve="); 1971 wpas_dpp_set_testing_options(wpa_s, auth); 1972 if (dpp_set_configurator(wpa_s->dpp, wpa_s, auth, cmd) == 0 && 1973 dpp_configurator_own_config(auth, curve, 0) == 0) 1974 ret = wpas_dpp_handle_config_obj(wpa_s, auth); 1975 1976 dpp_auth_deinit(auth); 1977 os_free(curve); 1978 1979 return ret; 1980} 1981 1982 1983static void 1984wpas_dpp_tx_introduction_status(struct wpa_supplicant *wpa_s, 1985 unsigned int freq, const u8 *dst, 1986 const u8 *src, const u8 *bssid, 1987 const u8 *data, size_t data_len, 1988 enum offchannel_send_action_result result) 1989{ 1990 const char *res_txt; 1991 1992 res_txt = result == OFFCHANNEL_SEND_ACTION_SUCCESS ? "SUCCESS" : 1993 (result == OFFCHANNEL_SEND_ACTION_NO_ACK ? "no-ACK" : 1994 "FAILED"); 1995 wpa_printf(MSG_DEBUG, "DPP: TX status: freq=%u dst=" MACSTR 1996 " result=%s (DPP Peer Discovery Request)", 1997 freq, MAC2STR(dst), res_txt); 1998 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX_STATUS "dst=" MACSTR 1999 " freq=%u result=%s", MAC2STR(dst), freq, res_txt); 2000 /* TODO: Time out wait for response more quickly in error cases? */ 2001} 2002 2003 2004int wpas_dpp_check_connect(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid, 2005 struct wpa_bss *bss) 2006{ 2007 struct os_time now; 2008 struct wpabuf *msg; 2009 unsigned int wait_time; 2010 const u8 *rsn; 2011 struct wpa_ie_data ied; 2012 2013 if (!(ssid->key_mgmt & WPA_KEY_MGMT_DPP) || !bss) 2014 return 0; /* Not using DPP AKM - continue */ 2015 rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN); 2016 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ied) == 0 && 2017 !(ied.key_mgmt & WPA_KEY_MGMT_DPP)) 2018 return 0; /* AP does not support DPP AKM - continue */ 2019 if (wpa_sm_pmksa_exists(wpa_s->wpa, bss->bssid, ssid)) 2020 return 0; /* PMKSA exists for DPP AKM - continue */ 2021 2022 if (!ssid->dpp_connector || !ssid->dpp_netaccesskey || 2023 !ssid->dpp_csign) { 2024 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_MISSING_CONNECTOR 2025 "missing %s", 2026 !ssid->dpp_connector ? "Connector" : 2027 (!ssid->dpp_netaccesskey ? "netAccessKey" : 2028 "C-sign-key")); 2029 return -1; 2030 } 2031 2032 os_get_time(&now); 2033 2034 if (ssid->dpp_netaccesskey_expiry && 2035 (os_time_t) ssid->dpp_netaccesskey_expiry < now.sec) { 2036 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_MISSING_CONNECTOR 2037 "netAccessKey expired"); 2038 return -1; 2039 } 2040 2041 wpa_printf(MSG_DEBUG, 2042 "DPP: Starting network introduction protocol to derive PMKSA for " 2043 MACSTR, MAC2STR(bss->bssid)); 2044 2045 msg = dpp_alloc_msg(DPP_PA_PEER_DISCOVERY_REQ, 2046 5 + 4 + os_strlen(ssid->dpp_connector)); 2047 if (!msg) 2048 return -1; 2049 2050#ifdef CONFIG_TESTING_OPTIONS 2051 if (dpp_test == DPP_TEST_NO_TRANSACTION_ID_PEER_DISC_REQ) { 2052 wpa_printf(MSG_INFO, "DPP: TESTING - no Transaction ID"); 2053 goto skip_trans_id; 2054 } 2055 if (dpp_test == DPP_TEST_INVALID_TRANSACTION_ID_PEER_DISC_REQ) { 2056 wpa_printf(MSG_INFO, "DPP: TESTING - invalid Transaction ID"); 2057 wpabuf_put_le16(msg, DPP_ATTR_TRANSACTION_ID); 2058 wpabuf_put_le16(msg, 0); 2059 goto skip_trans_id; 2060 } 2061#endif /* CONFIG_TESTING_OPTIONS */ 2062 2063 /* Transaction ID */ 2064 wpabuf_put_le16(msg, DPP_ATTR_TRANSACTION_ID); 2065 wpabuf_put_le16(msg, 1); 2066 wpabuf_put_u8(msg, TRANSACTION_ID); 2067 2068#ifdef CONFIG_TESTING_OPTIONS 2069skip_trans_id: 2070 if (dpp_test == DPP_TEST_NO_CONNECTOR_PEER_DISC_REQ) { 2071 wpa_printf(MSG_INFO, "DPP: TESTING - no Connector"); 2072 goto skip_connector; 2073 } 2074 if (dpp_test == DPP_TEST_INVALID_CONNECTOR_PEER_DISC_REQ) { 2075 char *connector; 2076 2077 wpa_printf(MSG_INFO, "DPP: TESTING - invalid Connector"); 2078 connector = dpp_corrupt_connector_signature( 2079 ssid->dpp_connector); 2080 if (!connector) { 2081 wpabuf_free(msg); 2082 return -1; 2083 } 2084 wpabuf_put_le16(msg, DPP_ATTR_CONNECTOR); 2085 wpabuf_put_le16(msg, os_strlen(connector)); 2086 wpabuf_put_str(msg, connector); 2087 os_free(connector); 2088 goto skip_connector; 2089 } 2090#endif /* CONFIG_TESTING_OPTIONS */ 2091 2092 /* DPP Connector */ 2093 wpabuf_put_le16(msg, DPP_ATTR_CONNECTOR); 2094 wpabuf_put_le16(msg, os_strlen(ssid->dpp_connector)); 2095 wpabuf_put_str(msg, ssid->dpp_connector); 2096 2097#ifdef CONFIG_TESTING_OPTIONS 2098skip_connector: 2099#endif /* CONFIG_TESTING_OPTIONS */ 2100 2101 /* TODO: Timeout on AP response */ 2102 wait_time = wpa_s->max_remain_on_chan; 2103 if (wait_time > 2000) 2104 wait_time = 2000; 2105 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d", 2106 MAC2STR(bss->bssid), bss->freq, DPP_PA_PEER_DISCOVERY_REQ); 2107 offchannel_send_action(wpa_s, bss->freq, bss->bssid, wpa_s->own_addr, 2108 broadcast, 2109 wpabuf_head(msg), wpabuf_len(msg), 2110 wait_time, wpas_dpp_tx_introduction_status, 0); 2111 wpabuf_free(msg); 2112 2113 /* Request this connection attempt to terminate - new one will be 2114 * started when network introduction protocol completes */ 2115 os_memcpy(wpa_s->dpp_intro_bssid, bss->bssid, ETH_ALEN); 2116 wpa_s->dpp_intro_network = ssid; 2117 return 1; 2118} 2119 2120 2121int wpas_dpp_pkex_add(struct wpa_supplicant *wpa_s, const char *cmd) 2122{ 2123 struct dpp_bootstrap_info *own_bi; 2124 const char *pos, *end; 2125 unsigned int wait_time; 2126 2127 pos = os_strstr(cmd, " own="); 2128 if (!pos) 2129 return -1; 2130 pos += 5; 2131 own_bi = dpp_bootstrap_get_id(wpa_s->dpp, atoi(pos)); 2132 if (!own_bi) { 2133 wpa_printf(MSG_DEBUG, 2134 "DPP: Identified bootstrap info not found"); 2135 return -1; 2136 } 2137 if (own_bi->type != DPP_BOOTSTRAP_PKEX) { 2138 wpa_printf(MSG_DEBUG, 2139 "DPP: Identified bootstrap info not for PKEX"); 2140 return -1; 2141 } 2142 wpa_s->dpp_pkex_bi = own_bi; 2143 own_bi->pkex_t = 0; /* clear pending errors on new code */ 2144 2145 os_free(wpa_s->dpp_pkex_identifier); 2146 wpa_s->dpp_pkex_identifier = NULL; 2147 pos = os_strstr(cmd, " identifier="); 2148 if (pos) { 2149 pos += 12; 2150 end = os_strchr(pos, ' '); 2151 if (!end) 2152 return -1; 2153 wpa_s->dpp_pkex_identifier = os_malloc(end - pos + 1); 2154 if (!wpa_s->dpp_pkex_identifier) 2155 return -1; 2156 os_memcpy(wpa_s->dpp_pkex_identifier, pos, end - pos); 2157 wpa_s->dpp_pkex_identifier[end - pos] = '\0'; 2158 } 2159 2160 pos = os_strstr(cmd, " code="); 2161 if (!pos) 2162 return -1; 2163 os_free(wpa_s->dpp_pkex_code); 2164 wpa_s->dpp_pkex_code = os_strdup(pos + 6); 2165 if (!wpa_s->dpp_pkex_code) 2166 return -1; 2167 2168 if (os_strstr(cmd, " init=1")) { 2169 struct dpp_pkex *pkex; 2170 struct wpabuf *msg; 2171 2172 wpa_printf(MSG_DEBUG, "DPP: Initiating PKEX"); 2173 dpp_pkex_free(wpa_s->dpp_pkex); 2174 wpa_s->dpp_pkex = dpp_pkex_init(wpa_s, own_bi, wpa_s->own_addr, 2175 wpa_s->dpp_pkex_identifier, 2176 wpa_s->dpp_pkex_code); 2177 pkex = wpa_s->dpp_pkex; 2178 if (!pkex) 2179 return -1; 2180 2181 msg = pkex->exchange_req; 2182 wait_time = wpa_s->max_remain_on_chan; 2183 if (wait_time > 2000) 2184 wait_time = 2000; 2185 pkex->freq = 2437; 2186 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR 2187 " freq=%u type=%d", 2188 MAC2STR(broadcast), pkex->freq, 2189 DPP_PA_PKEX_EXCHANGE_REQ); 2190 offchannel_send_action(wpa_s, pkex->freq, broadcast, 2191 wpa_s->own_addr, broadcast, 2192 wpabuf_head(msg), wpabuf_len(msg), 2193 wait_time, wpas_dpp_tx_pkex_status, 0); 2194 if (wait_time == 0) 2195 wait_time = 2000; 2196 pkex->exch_req_wait_time = wait_time; 2197 pkex->exch_req_tries = 1; 2198 } 2199 2200 /* TODO: Support multiple PKEX info entries */ 2201 2202 os_free(wpa_s->dpp_pkex_auth_cmd); 2203 wpa_s->dpp_pkex_auth_cmd = os_strdup(cmd); 2204 2205 return 1; 2206} 2207 2208 2209int wpas_dpp_pkex_remove(struct wpa_supplicant *wpa_s, const char *id) 2210{ 2211 unsigned int id_val; 2212 2213 if (os_strcmp(id, "*") == 0) { 2214 id_val = 0; 2215 } else { 2216 id_val = atoi(id); 2217 if (id_val == 0) 2218 return -1; 2219 } 2220 2221 if ((id_val != 0 && id_val != 1) || !wpa_s->dpp_pkex_code) 2222 return -1; 2223 2224 /* TODO: Support multiple PKEX entries */ 2225 os_free(wpa_s->dpp_pkex_code); 2226 wpa_s->dpp_pkex_code = NULL; 2227 os_free(wpa_s->dpp_pkex_identifier); 2228 wpa_s->dpp_pkex_identifier = NULL; 2229 os_free(wpa_s->dpp_pkex_auth_cmd); 2230 wpa_s->dpp_pkex_auth_cmd = NULL; 2231 wpa_s->dpp_pkex_bi = NULL; 2232 /* TODO: Remove dpp_pkex only if it is for the identified PKEX code */ 2233 dpp_pkex_free(wpa_s->dpp_pkex); 2234 wpa_s->dpp_pkex = NULL; 2235 return 0; 2236} 2237 2238 2239void wpas_dpp_stop(struct wpa_supplicant *wpa_s) 2240{ 2241 dpp_auth_deinit(wpa_s->dpp_auth); 2242 wpa_s->dpp_auth = NULL; 2243 dpp_pkex_free(wpa_s->dpp_pkex); 2244 wpa_s->dpp_pkex = NULL; 2245 if (wpa_s->dpp_gas_client && wpa_s->dpp_gas_dialog_token >= 0) 2246 gas_query_stop(wpa_s->gas, wpa_s->dpp_gas_dialog_token); 2247} 2248 2249 2250int wpas_dpp_init(struct wpa_supplicant *wpa_s) 2251{ 2252 struct dpp_global_config config; 2253 u8 adv_proto_id[7]; 2254 2255 adv_proto_id[0] = WLAN_EID_VENDOR_SPECIFIC; 2256 adv_proto_id[1] = 5; 2257 WPA_PUT_BE24(&adv_proto_id[2], OUI_WFA); 2258 adv_proto_id[5] = DPP_OUI_TYPE; 2259 adv_proto_id[6] = 0x01; 2260 2261 if (gas_server_register(wpa_s->gas_server, adv_proto_id, 2262 sizeof(adv_proto_id), wpas_dpp_gas_req_handler, 2263 wpas_dpp_gas_status_handler, wpa_s) < 0) 2264 return -1; 2265 2266 os_memset(&config, 0, sizeof(config)); 2267 config.msg_ctx = wpa_s; 2268 config.cb_ctx = wpa_s; 2269#ifdef CONFIG_DPP2 2270 config.process_conf_obj = wpas_dpp_process_conf_obj; 2271#endif /* CONFIG_DPP2 */ 2272 wpa_s->dpp = dpp_global_init(&config); 2273 return wpa_s->dpp ? 0 : -1; 2274} 2275 2276 2277void wpas_dpp_deinit(struct wpa_supplicant *wpa_s) 2278{ 2279#ifdef CONFIG_TESTING_OPTIONS 2280 os_free(wpa_s->dpp_config_obj_override); 2281 wpa_s->dpp_config_obj_override = NULL; 2282 os_free(wpa_s->dpp_discovery_override); 2283 wpa_s->dpp_discovery_override = NULL; 2284 os_free(wpa_s->dpp_groups_override); 2285 wpa_s->dpp_groups_override = NULL; 2286 wpa_s->dpp_ignore_netaccesskey_mismatch = 0; 2287#endif /* CONFIG_TESTING_OPTIONS */ 2288 if (!wpa_s->dpp) 2289 return; 2290 dpp_global_clear(wpa_s->dpp); 2291 eloop_cancel_timeout(wpas_dpp_pkex_retry_timeout, wpa_s, NULL); 2292 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL); 2293 eloop_cancel_timeout(wpas_dpp_init_timeout, wpa_s, NULL); 2294 eloop_cancel_timeout(wpas_dpp_auth_resp_retry_timeout, wpa_s, NULL); 2295#ifdef CONFIG_DPP2 2296 eloop_cancel_timeout(wpas_dpp_config_result_wait_timeout, wpa_s, NULL); 2297 dpp_pfs_free(wpa_s->dpp_pfs); 2298 wpa_s->dpp_pfs = NULL; 2299#endif /* CONFIG_DPP2 */ 2300 offchannel_send_action_done(wpa_s); 2301 wpas_dpp_listen_stop(wpa_s); 2302 wpas_dpp_stop(wpa_s); 2303 wpas_dpp_pkex_remove(wpa_s, "*"); 2304 os_memset(wpa_s->dpp_intro_bssid, 0, ETH_ALEN); 2305 os_free(wpa_s->dpp_configurator_params); 2306 wpa_s->dpp_configurator_params = NULL; 2307} 2308 2309 2310#ifdef CONFIG_DPP2 2311int wpas_dpp_controller_start(struct wpa_supplicant *wpa_s, const char *cmd) 2312{ 2313 struct dpp_controller_config config; 2314 const char *pos; 2315 2316 os_memset(&config, 0, sizeof(config)); 2317 if (cmd) { 2318 pos = os_strstr(cmd, " tcp_port="); 2319 if (pos) { 2320 pos += 10; 2321 config.tcp_port = atoi(pos); 2322 } 2323 } 2324 config.configurator_params = wpa_s->dpp_configurator_params; 2325 return dpp_controller_start(wpa_s->dpp, &config); 2326} 2327#endif /* CONFIG_DPP2 */ 2328