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