1 /*
2 * hostapd - WPA/RSN IE and KDE definitions
3 * Copyright (c) 2004-2018, Jouni Malinen <j@w1.fi>
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "utils/includes.h"
10
11 #include "utils/common.h"
12 #include "common/ieee802_11_defs.h"
13 #include "drivers/driver.h"
14 #include "eapol_auth/eapol_auth_sm.h"
15 #include "ap_config.h"
16 #include "ieee802_11.h"
17 #include "wpa_auth.h"
18 #include "pmksa_cache_auth.h"
19 #include "wpa_auth_ie.h"
20 #include "wpa_auth_i.h"
21
22
23 #ifdef CONFIG_RSN_TESTING
24 int rsn_testing = 0;
25 #endif /* CONFIG_RSN_TESTING */
26
27
wpa_write_wpa_ie(struct wpa_auth_config * conf,u8 * buf,size_t len)28 static int wpa_write_wpa_ie(struct wpa_auth_config *conf, u8 *buf, size_t len)
29 {
30 struct wpa_ie_hdr *hdr;
31 int num_suites;
32 u8 *pos, *count;
33 u32 suite;
34
35 hdr = (struct wpa_ie_hdr *) buf;
36 hdr->elem_id = WLAN_EID_VENDOR_SPECIFIC;
37 RSN_SELECTOR_PUT(hdr->oui, WPA_OUI_TYPE);
38 WPA_PUT_LE16(hdr->version, WPA_VERSION);
39 pos = (u8 *) (hdr + 1);
40
41 suite = wpa_cipher_to_suite(WPA_PROTO_WPA, conf->wpa_group);
42 if (suite == 0) {
43 wpa_printf(MSG_DEBUG, "Invalid group cipher (%d).",
44 conf->wpa_group);
45 return -1;
46 }
47 RSN_SELECTOR_PUT(pos, suite);
48 pos += WPA_SELECTOR_LEN;
49
50 count = pos;
51 pos += 2;
52
53 num_suites = wpa_cipher_put_suites(pos, conf->wpa_pairwise);
54 if (num_suites == 0) {
55 wpa_printf(MSG_DEBUG, "Invalid pairwise cipher (%d).",
56 conf->wpa_pairwise);
57 return -1;
58 }
59 pos += num_suites * WPA_SELECTOR_LEN;
60 WPA_PUT_LE16(count, num_suites);
61
62 num_suites = 0;
63 count = pos;
64 pos += 2;
65
66 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
67 RSN_SELECTOR_PUT(pos, WPA_AUTH_KEY_MGMT_UNSPEC_802_1X);
68 pos += WPA_SELECTOR_LEN;
69 num_suites++;
70 }
71 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) {
72 RSN_SELECTOR_PUT(pos, WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X);
73 pos += WPA_SELECTOR_LEN;
74 num_suites++;
75 }
76
77 if (num_suites == 0) {
78 wpa_printf(MSG_DEBUG, "Invalid key management type (%d).",
79 conf->wpa_key_mgmt);
80 return -1;
81 }
82 WPA_PUT_LE16(count, num_suites);
83
84 /* WPA Capabilities; use defaults, so no need to include it */
85
86 hdr->len = (pos - buf) - 2;
87
88 return pos - buf;
89 }
90
91
wpa_own_rsn_capab(struct wpa_auth_config * conf)92 static u16 wpa_own_rsn_capab(struct wpa_auth_config *conf)
93 {
94 u16 capab = 0;
95
96 if (conf->rsn_preauth)
97 capab |= WPA_CAPABILITY_PREAUTH;
98 if (conf->wmm_enabled) {
99 /* 4 PTKSA replay counters when using WMM */
100 capab |= (RSN_NUM_REPLAY_COUNTERS_16 << 2);
101 }
102 if (conf->ieee80211w != NO_MGMT_FRAME_PROTECTION) {
103 capab |= WPA_CAPABILITY_MFPC;
104 if (conf->ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED)
105 capab |= WPA_CAPABILITY_MFPR;
106 }
107 #ifdef CONFIG_OCV
108 if (conf->ocv)
109 capab |= WPA_CAPABILITY_OCVC;
110 #endif /* CONFIG_OCV */
111 #ifdef CONFIG_RSN_TESTING
112 if (rsn_testing)
113 capab |= BIT(8) | BIT(15);
114 #endif /* CONFIG_RSN_TESTING */
115 if (conf->extended_key_id)
116 capab |= WPA_CAPABILITY_EXT_KEY_ID_FOR_UNICAST;
117
118 return capab;
119 }
120
121
wpa_write_rsn_ie(struct wpa_auth_config * conf,u8 * buf,size_t len,const u8 * pmkid)122 int wpa_write_rsn_ie(struct wpa_auth_config *conf, u8 *buf, size_t len,
123 const u8 *pmkid)
124 {
125 struct rsn_ie_hdr *hdr;
126 int num_suites, res;
127 u8 *pos, *count;
128 u32 suite;
129
130 hdr = (struct rsn_ie_hdr *) buf;
131 hdr->elem_id = WLAN_EID_RSN;
132 WPA_PUT_LE16(hdr->version, RSN_VERSION);
133 pos = (u8 *) (hdr + 1);
134
135 suite = wpa_cipher_to_suite(WPA_PROTO_RSN, conf->wpa_group);
136 if (suite == 0) {
137 wpa_printf(MSG_DEBUG, "Invalid group cipher (%d).",
138 conf->wpa_group);
139 return -1;
140 }
141 RSN_SELECTOR_PUT(pos, suite);
142 pos += RSN_SELECTOR_LEN;
143
144 num_suites = 0;
145 count = pos;
146 pos += 2;
147
148 #ifdef CONFIG_RSN_TESTING
149 if (rsn_testing) {
150 RSN_SELECTOR_PUT(pos, RSN_SELECTOR(0x12, 0x34, 0x56, 1));
151 pos += RSN_SELECTOR_LEN;
152 num_suites++;
153 }
154 #endif /* CONFIG_RSN_TESTING */
155
156 res = rsn_cipher_put_suites(pos, conf->rsn_pairwise);
157 num_suites += res;
158 pos += res * RSN_SELECTOR_LEN;
159
160 #ifdef CONFIG_RSN_TESTING
161 if (rsn_testing) {
162 RSN_SELECTOR_PUT(pos, RSN_SELECTOR(0x12, 0x34, 0x56, 2));
163 pos += RSN_SELECTOR_LEN;
164 num_suites++;
165 }
166 #endif /* CONFIG_RSN_TESTING */
167
168 if (num_suites == 0) {
169 wpa_printf(MSG_DEBUG, "Invalid pairwise cipher (%d).",
170 conf->rsn_pairwise);
171 return -1;
172 }
173 WPA_PUT_LE16(count, num_suites);
174
175 num_suites = 0;
176 count = pos;
177 pos += 2;
178
179 #ifdef CONFIG_RSN_TESTING
180 if (rsn_testing) {
181 RSN_SELECTOR_PUT(pos, RSN_SELECTOR(0x12, 0x34, 0x56, 1));
182 pos += RSN_SELECTOR_LEN;
183 num_suites++;
184 }
185 #endif /* CONFIG_RSN_TESTING */
186
187 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
188 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_UNSPEC_802_1X);
189 pos += RSN_SELECTOR_LEN;
190 num_suites++;
191 }
192 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) {
193 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X);
194 pos += RSN_SELECTOR_LEN;
195 num_suites++;
196 }
197 #ifdef CONFIG_IEEE80211R_AP
198 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X) {
199 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_FT_802_1X);
200 pos += RSN_SELECTOR_LEN;
201 num_suites++;
202 }
203 #ifdef CONFIG_SHA384
204 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X_SHA384) {
205 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_FT_802_1X_SHA384);
206 pos += RSN_SELECTOR_LEN;
207 num_suites++;
208 }
209 #endif /* CONFIG_SHA384 */
210 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_PSK) {
211 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_FT_PSK);
212 pos += RSN_SELECTOR_LEN;
213 num_suites++;
214 }
215 #endif /* CONFIG_IEEE80211R_AP */
216 #ifdef CONFIG_SHA384
217 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA384) {
218 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_802_1X_SHA384);
219 pos += RSN_SELECTOR_LEN;
220 num_suites++;
221 }
222 #endif /* CONFIG_SHA384 */
223 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256) {
224 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_802_1X_SHA256);
225 pos += RSN_SELECTOR_LEN;
226 num_suites++;
227 }
228 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK_SHA256) {
229 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_PSK_SHA256);
230 pos += RSN_SELECTOR_LEN;
231 num_suites++;
232 }
233 #ifdef CONFIG_SAE
234 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_SAE) {
235 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_SAE);
236 pos += RSN_SELECTOR_LEN;
237 num_suites++;
238 }
239 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_SAE_EXT_KEY) {
240 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_SAE_EXT_KEY);
241 pos += RSN_SELECTOR_LEN;
242 num_suites++;
243 }
244 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_SAE) {
245 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_FT_SAE);
246 pos += RSN_SELECTOR_LEN;
247 num_suites++;
248 }
249 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_SAE_EXT_KEY) {
250 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_FT_SAE_EXT_KEY);
251 pos += RSN_SELECTOR_LEN;
252 num_suites++;
253 }
254 #endif /* CONFIG_SAE */
255 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B) {
256 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_802_1X_SUITE_B);
257 pos += RSN_SELECTOR_LEN;
258 num_suites++;
259 }
260 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B_192) {
261 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_802_1X_SUITE_B_192);
262 pos += RSN_SELECTOR_LEN;
263 num_suites++;
264 }
265 #ifdef CONFIG_FILS
266 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_FILS_SHA256) {
267 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_FILS_SHA256);
268 pos += RSN_SELECTOR_LEN;
269 num_suites++;
270 }
271 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_FILS_SHA384) {
272 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_FILS_SHA384);
273 pos += RSN_SELECTOR_LEN;
274 num_suites++;
275 }
276 #ifdef CONFIG_IEEE80211R_AP
277 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA256) {
278 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_FT_FILS_SHA256);
279 pos += RSN_SELECTOR_LEN;
280 num_suites++;
281 }
282 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA384) {
283 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_FT_FILS_SHA384);
284 pos += RSN_SELECTOR_LEN;
285 num_suites++;
286 }
287 #endif /* CONFIG_IEEE80211R_AP */
288 #endif /* CONFIG_FILS */
289 #ifdef CONFIG_OWE
290 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_OWE) {
291 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_OWE);
292 pos += RSN_SELECTOR_LEN;
293 num_suites++;
294 }
295 #endif /* CONFIG_OWE */
296 #ifdef CONFIG_DPP
297 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_DPP) {
298 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_DPP);
299 pos += RSN_SELECTOR_LEN;
300 num_suites++;
301 }
302 #endif /* CONFIG_DPP */
303 #ifdef CONFIG_HS20
304 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_OSEN) {
305 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_OSEN);
306 pos += RSN_SELECTOR_LEN;
307 num_suites++;
308 }
309 #endif /* CONFIG_HS20 */
310 #ifdef CONFIG_PASN
311 if (conf->wpa_key_mgmt & WPA_KEY_MGMT_PASN) {
312 RSN_SELECTOR_PUT(pos, RSN_AUTH_KEY_MGMT_PASN);
313 pos += RSN_SELECTOR_LEN;
314 num_suites++;
315 }
316 #endif /* CONFIG_PASN */
317
318 #ifdef CONFIG_RSN_TESTING
319 if (rsn_testing) {
320 RSN_SELECTOR_PUT(pos, RSN_SELECTOR(0x12, 0x34, 0x56, 2));
321 pos += RSN_SELECTOR_LEN;
322 num_suites++;
323 }
324 #endif /* CONFIG_RSN_TESTING */
325
326 if (num_suites == 0) {
327 wpa_printf(MSG_DEBUG, "Invalid key management type (%d).",
328 conf->wpa_key_mgmt);
329 return -1;
330 }
331 WPA_PUT_LE16(count, num_suites);
332
333 /* RSN Capabilities */
334 WPA_PUT_LE16(pos, wpa_own_rsn_capab(conf));
335 pos += 2;
336
337 if (pmkid) {
338 if (2 + PMKID_LEN > buf + len - pos)
339 return -1;
340 /* PMKID Count */
341 WPA_PUT_LE16(pos, 1);
342 pos += 2;
343 os_memcpy(pos, pmkid, PMKID_LEN);
344 pos += PMKID_LEN;
345 }
346
347 if (conf->ieee80211w != NO_MGMT_FRAME_PROTECTION &&
348 conf->group_mgmt_cipher != WPA_CIPHER_AES_128_CMAC) {
349 if (2 + 4 > buf + len - pos)
350 return -1;
351 if (pmkid == NULL) {
352 /* PMKID Count */
353 WPA_PUT_LE16(pos, 0);
354 pos += 2;
355 }
356
357 /* Management Group Cipher Suite */
358 switch (conf->group_mgmt_cipher) {
359 case WPA_CIPHER_AES_128_CMAC:
360 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_AES_128_CMAC);
361 break;
362 case WPA_CIPHER_BIP_GMAC_128:
363 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_BIP_GMAC_128);
364 break;
365 case WPA_CIPHER_BIP_GMAC_256:
366 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_BIP_GMAC_256);
367 break;
368 case WPA_CIPHER_BIP_CMAC_256:
369 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_BIP_CMAC_256);
370 break;
371 default:
372 wpa_printf(MSG_DEBUG,
373 "Invalid group management cipher (0x%x)",
374 conf->group_mgmt_cipher);
375 return -1;
376 }
377 pos += RSN_SELECTOR_LEN;
378 }
379
380 #ifdef CONFIG_RSN_TESTING
381 if (rsn_testing) {
382 /*
383 * Fill in any defined fields and add extra data to the end of
384 * the element.
385 */
386 int pmkid_count_set = pmkid != NULL;
387 if (conf->ieee80211w != NO_MGMT_FRAME_PROTECTION)
388 pmkid_count_set = 1;
389 /* PMKID Count */
390 WPA_PUT_LE16(pos, 0);
391 pos += 2;
392 if (conf->ieee80211w == NO_MGMT_FRAME_PROTECTION) {
393 /* Management Group Cipher Suite */
394 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_AES_128_CMAC);
395 pos += RSN_SELECTOR_LEN;
396 }
397
398 os_memset(pos, 0x12, 17);
399 pos += 17;
400 }
401 #endif /* CONFIG_RSN_TESTING */
402
403 hdr->len = (pos - buf) - 2;
404
405 return pos - buf;
406 }
407
408
wpa_write_rsnxe(struct wpa_auth_config * conf,u8 * buf,size_t len)409 int wpa_write_rsnxe(struct wpa_auth_config *conf, u8 *buf, size_t len)
410 {
411 u8 *pos = buf;
412 u16 capab = 0;
413 size_t flen;
414
415 if (wpa_key_mgmt_sae(conf->wpa_key_mgmt) &&
416 (conf->sae_pwe == SAE_PWE_HASH_TO_ELEMENT ||
417 conf->sae_pwe == SAE_PWE_BOTH || conf->sae_pk ||
418 wpa_key_mgmt_sae_ext_key(conf->wpa_key_mgmt))) {
419 capab |= BIT(WLAN_RSNX_CAPAB_SAE_H2E);
420 #ifdef CONFIG_SAE_PK
421 if (conf->sae_pk)
422 capab |= BIT(WLAN_RSNX_CAPAB_SAE_PK);
423 #endif /* CONFIG_SAE_PK */
424 }
425
426 if (conf->secure_ltf)
427 capab |= BIT(WLAN_RSNX_CAPAB_SECURE_LTF);
428 if (conf->secure_rtt)
429 capab |= BIT(WLAN_RSNX_CAPAB_SECURE_RTT);
430 if (conf->prot_range_neg)
431 capab |= BIT(WLAN_RSNX_CAPAB_URNM_MFPR);
432
433 flen = (capab & 0xff00) ? 2 : 1;
434 if (!capab)
435 return 0; /* no supported extended RSN capabilities */
436 if (len < 2 + flen)
437 return -1;
438 capab |= flen - 1; /* bit 0-3 = Field length (n - 1) */
439
440 *pos++ = WLAN_EID_RSNX;
441 *pos++ = flen;
442 *pos++ = capab & 0x00ff;
443 capab >>= 8;
444 if (capab)
445 *pos++ = capab;
446
447 return pos - buf;
448 }
449
450
wpa_write_osen(struct wpa_auth_config * conf,u8 * eid)451 static u8 * wpa_write_osen(struct wpa_auth_config *conf, u8 *eid)
452 {
453 u8 *len;
454 u16 capab;
455
456 *eid++ = WLAN_EID_VENDOR_SPECIFIC;
457 len = eid++; /* to be filled */
458 WPA_PUT_BE24(eid, OUI_WFA);
459 eid += 3;
460 *eid++ = HS20_OSEN_OUI_TYPE;
461
462 /* Group Data Cipher Suite */
463 RSN_SELECTOR_PUT(eid, RSN_CIPHER_SUITE_NO_GROUP_ADDRESSED);
464 eid += RSN_SELECTOR_LEN;
465
466 /* Pairwise Cipher Suite Count and List */
467 WPA_PUT_LE16(eid, 1);
468 eid += 2;
469 RSN_SELECTOR_PUT(eid, RSN_CIPHER_SUITE_CCMP);
470 eid += RSN_SELECTOR_LEN;
471
472 /* AKM Suite Count and List */
473 WPA_PUT_LE16(eid, 1);
474 eid += 2;
475 RSN_SELECTOR_PUT(eid, RSN_AUTH_KEY_MGMT_OSEN);
476 eid += RSN_SELECTOR_LEN;
477
478 /* RSN Capabilities */
479 capab = 0;
480 if (conf->wmm_enabled) {
481 /* 4 PTKSA replay counters when using WMM */
482 capab |= (RSN_NUM_REPLAY_COUNTERS_16 << 2);
483 }
484 if (conf->ieee80211w != NO_MGMT_FRAME_PROTECTION) {
485 capab |= WPA_CAPABILITY_MFPC;
486 if (conf->ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED)
487 capab |= WPA_CAPABILITY_MFPR;
488 }
489 #ifdef CONFIG_OCV
490 if (conf->ocv)
491 capab |= WPA_CAPABILITY_OCVC;
492 #endif /* CONFIG_OCV */
493 WPA_PUT_LE16(eid, capab);
494 eid += 2;
495
496 *len = eid - len - 1;
497
498 return eid;
499 }
500
501
wpa_auth_gen_wpa_ie(struct wpa_authenticator * wpa_auth)502 int wpa_auth_gen_wpa_ie(struct wpa_authenticator *wpa_auth)
503 {
504 u8 *pos, buf[128];
505 int res;
506
507 #ifdef CONFIG_TESTING_OPTIONS
508 if (wpa_auth->conf.own_ie_override_len) {
509 wpa_hexdump(MSG_DEBUG, "WPA: Forced own IE(s) for testing",
510 wpa_auth->conf.own_ie_override,
511 wpa_auth->conf.own_ie_override_len);
512 os_free(wpa_auth->wpa_ie);
513 wpa_auth->wpa_ie =
514 os_malloc(wpa_auth->conf.own_ie_override_len);
515 if (wpa_auth->wpa_ie == NULL)
516 return -1;
517 os_memcpy(wpa_auth->wpa_ie, wpa_auth->conf.own_ie_override,
518 wpa_auth->conf.own_ie_override_len);
519 wpa_auth->wpa_ie_len = wpa_auth->conf.own_ie_override_len;
520 return 0;
521 }
522 #endif /* CONFIG_TESTING_OPTIONS */
523
524 pos = buf;
525
526 if (wpa_auth->conf.wpa == WPA_PROTO_OSEN) {
527 pos = wpa_write_osen(&wpa_auth->conf, pos);
528 }
529 if (wpa_auth->conf.wpa & WPA_PROTO_RSN) {
530 res = wpa_write_rsn_ie(&wpa_auth->conf,
531 pos, buf + sizeof(buf) - pos, NULL);
532 if (res < 0)
533 return res;
534 pos += res;
535 res = wpa_write_rsnxe(&wpa_auth->conf, pos,
536 buf + sizeof(buf) - pos);
537 if (res < 0)
538 return res;
539 pos += res;
540 }
541 #ifdef CONFIG_IEEE80211R_AP
542 if (wpa_key_mgmt_ft(wpa_auth->conf.wpa_key_mgmt)) {
543 res = wpa_write_mdie(&wpa_auth->conf, pos,
544 buf + sizeof(buf) - pos);
545 if (res < 0)
546 return res;
547 pos += res;
548 }
549 #endif /* CONFIG_IEEE80211R_AP */
550 if (wpa_auth->conf.wpa & WPA_PROTO_WPA) {
551 res = wpa_write_wpa_ie(&wpa_auth->conf,
552 pos, buf + sizeof(buf) - pos);
553 if (res < 0)
554 return res;
555 pos += res;
556 }
557
558 os_free(wpa_auth->wpa_ie);
559 wpa_auth->wpa_ie = os_malloc(pos - buf);
560 if (wpa_auth->wpa_ie == NULL)
561 return -1;
562 os_memcpy(wpa_auth->wpa_ie, buf, pos - buf);
563 wpa_auth->wpa_ie_len = pos - buf;
564
565 return 0;
566 }
567
568
wpa_add_kde(u8 * pos,u32 kde,const u8 * data,size_t data_len,const u8 * data2,size_t data2_len)569 u8 * wpa_add_kde(u8 *pos, u32 kde, const u8 *data, size_t data_len,
570 const u8 *data2, size_t data2_len)
571 {
572 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
573 *pos++ = RSN_SELECTOR_LEN + data_len + data2_len;
574 RSN_SELECTOR_PUT(pos, kde);
575 pos += RSN_SELECTOR_LEN;
576 os_memcpy(pos, data, data_len);
577 pos += data_len;
578 if (data2) {
579 os_memcpy(pos, data2, data2_len);
580 pos += data2_len;
581 }
582 return pos;
583 }
584
585
586 struct wpa_auth_okc_iter_data {
587 struct rsn_pmksa_cache_entry *pmksa;
588 const u8 *aa;
589 const u8 *spa;
590 const u8 *pmkid;
591 };
592
593
wpa_auth_okc_iter(struct wpa_authenticator * a,void * ctx)594 static int wpa_auth_okc_iter(struct wpa_authenticator *a, void *ctx)
595 {
596 struct wpa_auth_okc_iter_data *data = ctx;
597 data->pmksa = pmksa_cache_get_okc(a->pmksa, data->aa, data->spa,
598 data->pmkid);
599 if (data->pmksa)
600 return 1;
601 return 0;
602 }
603
604
605 enum wpa_validate_result
wpa_validate_wpa_ie(struct wpa_authenticator * wpa_auth,struct wpa_state_machine * sm,int freq,const u8 * wpa_ie,size_t wpa_ie_len,const u8 * rsnxe,size_t rsnxe_len,const u8 * mdie,size_t mdie_len,const u8 * owe_dh,size_t owe_dh_len)606 wpa_validate_wpa_ie(struct wpa_authenticator *wpa_auth,
607 struct wpa_state_machine *sm, int freq,
608 const u8 *wpa_ie, size_t wpa_ie_len,
609 const u8 *rsnxe, size_t rsnxe_len,
610 const u8 *mdie, size_t mdie_len,
611 const u8 *owe_dh, size_t owe_dh_len)
612 {
613 struct wpa_auth_config *conf = &wpa_auth->conf;
614 struct wpa_ie_data data;
615 int ciphers, key_mgmt, res, version;
616 u32 selector;
617 size_t i;
618 const u8 *pmkid = NULL;
619
620 if (wpa_auth == NULL || sm == NULL)
621 return WPA_NOT_ENABLED;
622
623 if (wpa_ie == NULL || wpa_ie_len < 1)
624 return WPA_INVALID_IE;
625
626 if (wpa_ie[0] == WLAN_EID_RSN)
627 version = WPA_PROTO_RSN;
628 else
629 version = WPA_PROTO_WPA;
630
631 if (!(wpa_auth->conf.wpa & version)) {
632 wpa_printf(MSG_DEBUG, "Invalid WPA proto (%d) from " MACSTR,
633 version, MAC2STR(sm->addr));
634 return WPA_INVALID_PROTO;
635 }
636
637 if (version == WPA_PROTO_RSN) {
638 res = wpa_parse_wpa_ie_rsn(wpa_ie, wpa_ie_len, &data);
639 if (!data.has_pairwise)
640 data.pairwise_cipher = wpa_default_rsn_cipher(freq);
641 if (!data.has_group)
642 data.group_cipher = wpa_default_rsn_cipher(freq);
643
644 if (wpa_key_mgmt_ft(data.key_mgmt) && !mdie &&
645 !wpa_key_mgmt_only_ft(data.key_mgmt)) {
646 /* Workaround for some HP and Epson printers that seem
647 * to incorrectly copy the FT-PSK + WPA-PSK AKMs from AP
648 * advertised RSNE to Association Request frame. */
649 wpa_printf(MSG_DEBUG,
650 "RSN: FT set in RSNE AKM but MDE is missing from "
651 MACSTR
652 " - ignore FT AKM(s) because there's also a non-FT AKM",
653 MAC2STR(sm->addr));
654 data.key_mgmt &= ~WPA_KEY_MGMT_FT;
655 }
656
657 selector = RSN_AUTH_KEY_MGMT_UNSPEC_802_1X;
658 if (0) {
659 }
660 else if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B_192)
661 selector = RSN_AUTH_KEY_MGMT_802_1X_SUITE_B_192;
662 else if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B)
663 selector = RSN_AUTH_KEY_MGMT_802_1X_SUITE_B;
664 #ifdef CONFIG_FILS
665 #ifdef CONFIG_IEEE80211R_AP
666 else if (data.key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA384)
667 selector = RSN_AUTH_KEY_MGMT_FT_FILS_SHA384;
668 else if (data.key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA256)
669 selector = RSN_AUTH_KEY_MGMT_FT_FILS_SHA256;
670 #endif /* CONFIG_IEEE80211R_AP */
671 else if (data.key_mgmt & WPA_KEY_MGMT_FILS_SHA384)
672 selector = RSN_AUTH_KEY_MGMT_FILS_SHA384;
673 else if (data.key_mgmt & WPA_KEY_MGMT_FILS_SHA256)
674 selector = RSN_AUTH_KEY_MGMT_FILS_SHA256;
675 #endif /* CONFIG_FILS */
676 #ifdef CONFIG_IEEE80211R_AP
677 #ifdef CONFIG_SHA384
678 else if (data.key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X_SHA384)
679 selector = RSN_AUTH_KEY_MGMT_FT_802_1X_SHA384;
680 #endif /* CONFIG_SHA384 */
681 else if (data.key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
682 selector = RSN_AUTH_KEY_MGMT_FT_802_1X;
683 else if (data.key_mgmt & WPA_KEY_MGMT_FT_PSK)
684 selector = RSN_AUTH_KEY_MGMT_FT_PSK;
685 #endif /* CONFIG_IEEE80211R_AP */
686 else if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256)
687 selector = RSN_AUTH_KEY_MGMT_802_1X_SHA256;
688 else if (data.key_mgmt & WPA_KEY_MGMT_PSK_SHA256)
689 selector = RSN_AUTH_KEY_MGMT_PSK_SHA256;
690 #ifdef CONFIG_SAE
691 else if (data.key_mgmt & WPA_KEY_MGMT_SAE)
692 selector = RSN_AUTH_KEY_MGMT_SAE;
693 else if (data.key_mgmt & WPA_KEY_MGMT_SAE_EXT_KEY)
694 selector = RSN_AUTH_KEY_MGMT_SAE_EXT_KEY;
695 else if (data.key_mgmt & WPA_KEY_MGMT_FT_SAE)
696 selector = RSN_AUTH_KEY_MGMT_FT_SAE;
697 else if (data.key_mgmt & WPA_KEY_MGMT_FT_SAE_EXT_KEY)
698 selector = RSN_AUTH_KEY_MGMT_FT_SAE_EXT_KEY;
699 #endif /* CONFIG_SAE */
700 else if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X)
701 selector = RSN_AUTH_KEY_MGMT_UNSPEC_802_1X;
702 else if (data.key_mgmt & WPA_KEY_MGMT_PSK)
703 selector = RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X;
704 #ifdef CONFIG_OWE
705 else if (data.key_mgmt & WPA_KEY_MGMT_OWE)
706 selector = RSN_AUTH_KEY_MGMT_OWE;
707 #endif /* CONFIG_OWE */
708 #ifdef CONFIG_DPP
709 else if (data.key_mgmt & WPA_KEY_MGMT_DPP)
710 selector = RSN_AUTH_KEY_MGMT_DPP;
711 #endif /* CONFIG_DPP */
712 #ifdef CONFIG_HS20
713 else if (data.key_mgmt & WPA_KEY_MGMT_OSEN)
714 selector = RSN_AUTH_KEY_MGMT_OSEN;
715 #endif /* CONFIG_HS20 */
716 #ifdef CONFIG_SHA384
717 else if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA384)
718 selector = RSN_AUTH_KEY_MGMT_802_1X_SHA384;
719 #endif /* CONFIG_SHA384 */
720 wpa_auth->dot11RSNAAuthenticationSuiteSelected = selector;
721
722 selector = wpa_cipher_to_suite(WPA_PROTO_RSN,
723 data.pairwise_cipher);
724 if (!selector)
725 selector = RSN_CIPHER_SUITE_CCMP;
726 wpa_auth->dot11RSNAPairwiseCipherSelected = selector;
727
728 selector = wpa_cipher_to_suite(WPA_PROTO_RSN,
729 data.group_cipher);
730 if (!selector)
731 selector = RSN_CIPHER_SUITE_CCMP;
732 wpa_auth->dot11RSNAGroupCipherSelected = selector;
733 } else {
734 res = wpa_parse_wpa_ie_wpa(wpa_ie, wpa_ie_len, &data);
735
736 selector = WPA_AUTH_KEY_MGMT_UNSPEC_802_1X;
737 if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X)
738 selector = WPA_AUTH_KEY_MGMT_UNSPEC_802_1X;
739 else if (data.key_mgmt & WPA_KEY_MGMT_PSK)
740 selector = WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X;
741 wpa_auth->dot11RSNAAuthenticationSuiteSelected = selector;
742
743 selector = wpa_cipher_to_suite(WPA_PROTO_WPA,
744 data.pairwise_cipher);
745 if (!selector)
746 selector = RSN_CIPHER_SUITE_TKIP;
747 wpa_auth->dot11RSNAPairwiseCipherSelected = selector;
748
749 selector = wpa_cipher_to_suite(WPA_PROTO_WPA,
750 data.group_cipher);
751 if (!selector)
752 selector = WPA_CIPHER_SUITE_TKIP;
753 wpa_auth->dot11RSNAGroupCipherSelected = selector;
754 }
755 if (res) {
756 wpa_printf(MSG_DEBUG, "Failed to parse WPA/RSN IE from "
757 MACSTR " (res=%d)", MAC2STR(sm->addr), res);
758 wpa_hexdump(MSG_DEBUG, "WPA/RSN IE", wpa_ie, wpa_ie_len);
759 return WPA_INVALID_IE;
760 }
761
762 if (data.group_cipher != wpa_auth->conf.wpa_group) {
763 wpa_printf(MSG_DEBUG, "Invalid WPA group cipher (0x%x) from "
764 MACSTR, data.group_cipher, MAC2STR(sm->addr));
765 return WPA_INVALID_GROUP;
766 }
767
768 key_mgmt = data.key_mgmt & wpa_auth->conf.wpa_key_mgmt;
769 if (!key_mgmt) {
770 wpa_printf(MSG_DEBUG, "Invalid WPA key mgmt (0x%x) from "
771 MACSTR, data.key_mgmt, MAC2STR(sm->addr));
772 return WPA_INVALID_AKMP;
773 }
774 if (0) {
775 }
776 else if (key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B_192)
777 sm->wpa_key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B_192;
778 else if (key_mgmt & WPA_KEY_MGMT_IEEE8021X_SUITE_B)
779 sm->wpa_key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B;
780 #ifdef CONFIG_FILS
781 #ifdef CONFIG_IEEE80211R_AP
782 else if (key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA384)
783 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA384;
784 else if (data.key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA256)
785 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA256;
786 #endif /* CONFIG_IEEE80211R_AP */
787 else if (key_mgmt & WPA_KEY_MGMT_FILS_SHA384)
788 sm->wpa_key_mgmt = WPA_KEY_MGMT_FILS_SHA384;
789 else if (key_mgmt & WPA_KEY_MGMT_FILS_SHA256)
790 sm->wpa_key_mgmt = WPA_KEY_MGMT_FILS_SHA256;
791 #endif /* CONFIG_FILS */
792 #ifdef CONFIG_IEEE80211R_AP
793 #ifdef CONFIG_SHA384
794 else if (key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X_SHA384)
795 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X_SHA384;
796 #endif /* CONFIG_SHA384 */
797 else if (key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
798 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
799 else if (key_mgmt & WPA_KEY_MGMT_FT_PSK)
800 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_PSK;
801 #endif /* CONFIG_IEEE80211R_AP */
802 #ifdef CONFIG_SHA384
803 else if (key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA384)
804 sm->wpa_key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA384;
805 #endif /* CONFIG_SHA384 */
806 else if (key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256)
807 sm->wpa_key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
808 else if (key_mgmt & WPA_KEY_MGMT_PSK_SHA256)
809 sm->wpa_key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
810 #ifdef CONFIG_SAE
811 else if (key_mgmt & WPA_KEY_MGMT_SAE)
812 sm->wpa_key_mgmt = WPA_KEY_MGMT_SAE;
813 else if (key_mgmt & WPA_KEY_MGMT_SAE_EXT_KEY)
814 sm->wpa_key_mgmt = WPA_KEY_MGMT_SAE_EXT_KEY;
815 else if (key_mgmt & WPA_KEY_MGMT_FT_SAE)
816 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_SAE;
817 else if (key_mgmt & WPA_KEY_MGMT_FT_SAE_EXT_KEY)
818 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_SAE_EXT_KEY;
819 #endif /* CONFIG_SAE */
820 else if (key_mgmt & WPA_KEY_MGMT_IEEE8021X)
821 sm->wpa_key_mgmt = WPA_KEY_MGMT_IEEE8021X;
822 #ifdef CONFIG_OWE
823 else if (key_mgmt & WPA_KEY_MGMT_OWE)
824 sm->wpa_key_mgmt = WPA_KEY_MGMT_OWE;
825 #endif /* CONFIG_OWE */
826 #ifdef CONFIG_DPP
827 else if (key_mgmt & WPA_KEY_MGMT_DPP)
828 sm->wpa_key_mgmt = WPA_KEY_MGMT_DPP;
829 #endif /* CONFIG_DPP */
830 #ifdef CONFIG_HS20
831 else if (key_mgmt & WPA_KEY_MGMT_OSEN)
832 sm->wpa_key_mgmt = WPA_KEY_MGMT_OSEN;
833 #endif /* CONFIG_HS20 */
834 else
835 sm->wpa_key_mgmt = WPA_KEY_MGMT_PSK;
836
837 if (version == WPA_PROTO_RSN)
838 ciphers = data.pairwise_cipher & wpa_auth->conf.rsn_pairwise;
839 else
840 ciphers = data.pairwise_cipher & wpa_auth->conf.wpa_pairwise;
841 if (!ciphers) {
842 wpa_printf(MSG_DEBUG, "Invalid %s pairwise cipher (0x%x) "
843 "from " MACSTR,
844 version == WPA_PROTO_RSN ? "RSN" : "WPA",
845 data.pairwise_cipher, MAC2STR(sm->addr));
846 return WPA_INVALID_PAIRWISE;
847 }
848
849 if (wpa_auth->conf.ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED) {
850 if (!(data.capabilities & WPA_CAPABILITY_MFPC)) {
851 wpa_printf(MSG_DEBUG, "Management frame protection "
852 "required, but client did not enable it");
853 return WPA_MGMT_FRAME_PROTECTION_VIOLATION;
854 }
855
856 if (data.mgmt_group_cipher != wpa_auth->conf.group_mgmt_cipher)
857 {
858 wpa_printf(MSG_DEBUG, "Unsupported management group "
859 "cipher %d", data.mgmt_group_cipher);
860 return WPA_INVALID_MGMT_GROUP_CIPHER;
861 }
862 }
863
864 #ifdef CONFIG_SAE
865 if (wpa_auth->conf.ieee80211w == MGMT_FRAME_PROTECTION_OPTIONAL &&
866 wpa_auth->conf.sae_require_mfp &&
867 wpa_key_mgmt_sae(sm->wpa_key_mgmt) &&
868 !(data.capabilities & WPA_CAPABILITY_MFPC)) {
869 wpa_printf(MSG_DEBUG,
870 "Management frame protection required with SAE, but client did not enable it");
871 return WPA_MGMT_FRAME_PROTECTION_VIOLATION;
872 }
873 #endif /* CONFIG_SAE */
874
875 #ifdef CONFIG_OCV
876 if (wpa_auth->conf.ocv && (data.capabilities & WPA_CAPABILITY_OCVC) &&
877 !(data.capabilities & WPA_CAPABILITY_MFPC)) {
878 /* Some legacy MFP incapable STAs wrongly copy OCVC bit from
879 * AP RSN capabilities. To improve interoperability with such
880 * legacy STAs allow connection without enabling OCV when the
881 * workaround mode (ocv=2) is enabled.
882 */
883 if (wpa_auth->conf.ocv == 2) {
884 wpa_printf(MSG_DEBUG,
885 "Allow connecting MFP incapable and OCV capable STA without enabling OCV");
886 wpa_auth_set_ocv(sm, 0);
887 } else {
888 wpa_printf(MSG_DEBUG,
889 "Management frame protection required with OCV, but client did not enable it");
890 return WPA_MGMT_FRAME_PROTECTION_VIOLATION;
891 }
892 } else {
893 wpa_auth_set_ocv(sm, (data.capabilities & WPA_CAPABILITY_OCVC) ?
894 wpa_auth->conf.ocv : 0);
895 }
896 #endif /* CONFIG_OCV */
897
898 if (wpa_auth->conf.ieee80211w == NO_MGMT_FRAME_PROTECTION ||
899 !(data.capabilities & WPA_CAPABILITY_MFPC))
900 sm->mgmt_frame_prot = 0;
901 else
902 sm->mgmt_frame_prot = 1;
903 sm->mfpr = !!(data.capabilities & WPA_CAPABILITY_MFPR);
904
905 if (sm->mgmt_frame_prot && (ciphers & WPA_CIPHER_TKIP)) {
906 wpa_printf(MSG_DEBUG,
907 "Management frame protection cannot use TKIP");
908 return WPA_MGMT_FRAME_PROTECTION_VIOLATION;
909 }
910
911 #ifdef CONFIG_IEEE80211R_AP
912 if (wpa_key_mgmt_ft(sm->wpa_key_mgmt)) {
913 if (mdie == NULL || mdie_len < MOBILITY_DOMAIN_ID_LEN + 1) {
914 wpa_printf(MSG_DEBUG, "RSN: Trying to use FT, but "
915 "MDIE not included");
916 return WPA_INVALID_MDIE;
917 }
918 if (os_memcmp(mdie, wpa_auth->conf.mobility_domain,
919 MOBILITY_DOMAIN_ID_LEN) != 0) {
920 wpa_hexdump(MSG_DEBUG, "RSN: Attempted to use unknown "
921 "MDIE", mdie, MOBILITY_DOMAIN_ID_LEN);
922 return WPA_INVALID_MDIE;
923 }
924 } else if (mdie != NULL) {
925 wpa_printf(MSG_DEBUG,
926 "RSN: Trying to use non-FT AKM suite, but MDIE included");
927 return WPA_INVALID_AKMP;
928 }
929 #endif /* CONFIG_IEEE80211R_AP */
930
931 #ifdef CONFIG_OWE
932 if (sm->wpa_key_mgmt == WPA_KEY_MGMT_OWE && !owe_dh) {
933 wpa_printf(MSG_DEBUG,
934 "OWE: No Diffie-Hellman Parameter element");
935 return WPA_INVALID_AKMP;
936 }
937 #endif /* CONFIG_OWE */
938
939 #ifdef CONFIG_DPP2
940 if (sm->wpa_key_mgmt == WPA_KEY_MGMT_DPP &&
941 ((conf->dpp_pfs == 1 && !owe_dh) ||
942 (conf->dpp_pfs == 2 && owe_dh))) {
943 wpa_printf(MSG_DEBUG, "DPP: PFS %s",
944 conf->dpp_pfs == 1 ? "required" : "not allowed");
945 return WPA_DENIED_OTHER_REASON;
946 }
947 #endif /* CONFIG_DPP2 */
948
949 sm->pairwise = wpa_pick_pairwise_cipher(ciphers, 0);
950 if (sm->pairwise < 0)
951 return WPA_INVALID_PAIRWISE;
952
953 /* TODO: clear WPA/WPA2 state if STA changes from one to another */
954 if (wpa_ie[0] == WLAN_EID_RSN)
955 sm->wpa = WPA_VERSION_WPA2;
956 else
957 sm->wpa = WPA_VERSION_WPA;
958
959 #if defined(CONFIG_IEEE80211R_AP) && defined(CONFIG_FILS)
960 if ((sm->wpa_key_mgmt == WPA_KEY_MGMT_FT_FILS_SHA256 ||
961 sm->wpa_key_mgmt == WPA_KEY_MGMT_FT_FILS_SHA384) &&
962 (sm->auth_alg == WLAN_AUTH_FILS_SK ||
963 sm->auth_alg == WLAN_AUTH_FILS_SK_PFS ||
964 sm->auth_alg == WLAN_AUTH_FILS_PK) &&
965 (data.num_pmkid != 1 || !data.pmkid || !sm->pmk_r1_name_valid ||
966 os_memcmp_const(data.pmkid, sm->pmk_r1_name,
967 WPA_PMK_NAME_LEN) != 0)) {
968 wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_DEBUG,
969 "No PMKR1Name match for FILS+FT");
970 return WPA_INVALID_PMKID;
971 }
972 #endif /* CONFIG_IEEE80211R_AP && CONFIG_FILS */
973
974 sm->pmksa = NULL;
975 for (i = 0; i < data.num_pmkid; i++) {
976 wpa_hexdump(MSG_DEBUG, "RSN IE: STA PMKID",
977 &data.pmkid[i * PMKID_LEN], PMKID_LEN);
978 sm->pmksa = pmksa_cache_auth_get(wpa_auth->pmksa, sm->addr,
979 &data.pmkid[i * PMKID_LEN]);
980 if (sm->pmksa) {
981 pmkid = sm->pmksa->pmkid;
982 break;
983 }
984 }
985 for (i = 0; sm->pmksa == NULL && wpa_auth->conf.okc &&
986 i < data.num_pmkid; i++) {
987 struct wpa_auth_okc_iter_data idata;
988 idata.pmksa = NULL;
989 idata.aa = wpa_auth->addr;
990 idata.spa = sm->addr;
991 idata.pmkid = &data.pmkid[i * PMKID_LEN];
992 wpa_auth_for_each_auth(wpa_auth, wpa_auth_okc_iter, &idata);
993 if (idata.pmksa) {
994 wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_DEBUG,
995 "OKC match for PMKID");
996 sm->pmksa = pmksa_cache_add_okc(wpa_auth->pmksa,
997 idata.pmksa,
998 wpa_auth->addr,
999 idata.pmkid);
1000 pmkid = idata.pmkid;
1001 break;
1002 }
1003 }
1004 if (sm->pmksa && pmkid) {
1005 struct vlan_description *vlan;
1006
1007 vlan = sm->pmksa->vlan_desc;
1008 wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_DEBUG,
1009 "PMKID found from PMKSA cache eap_type=%d vlan=%d%s",
1010 sm->pmksa->eap_type_authsrv,
1011 vlan ? vlan->untagged : 0,
1012 (vlan && vlan->tagged[0]) ? "+" : "");
1013 os_memcpy(wpa_auth->dot11RSNAPMKIDUsed, pmkid, PMKID_LEN);
1014 }
1015
1016 #ifdef CONFIG_SAE
1017 if (sm->wpa_key_mgmt == WPA_KEY_MGMT_SAE ||
1018 sm->wpa_key_mgmt == WPA_KEY_MGMT_SAE_EXT_KEY) {
1019 u64 drv_flags = 0;
1020 u64 drv_flags2 = 0;
1021 bool ap_sae_offload = false;
1022
1023 if (wpa_auth->cb->get_drv_flags &&
1024 wpa_auth->cb->get_drv_flags(wpa_auth->cb_ctx, &drv_flags,
1025 &drv_flags2) == 0)
1026 ap_sae_offload =
1027 !!(drv_flags2 &
1028 WPA_DRIVER_FLAGS2_SAE_OFFLOAD_AP);
1029
1030 if (!ap_sae_offload && data.num_pmkid && !sm->pmksa) {
1031 wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_DEBUG,
1032 "No PMKSA cache entry found for SAE");
1033 return WPA_INVALID_PMKID;
1034 }
1035 }
1036 #endif /* CONFIG_SAE */
1037
1038 #ifdef CONFIG_DPP
1039 if (sm->wpa_key_mgmt == WPA_KEY_MGMT_DPP && !sm->pmksa) {
1040 wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_DEBUG,
1041 "No PMKSA cache entry found for DPP");
1042 return WPA_INVALID_PMKID;
1043 }
1044 #endif /* CONFIG_DPP */
1045
1046 if (conf->extended_key_id && sm->wpa == WPA_VERSION_WPA2 &&
1047 sm->pairwise != WPA_CIPHER_TKIP &&
1048 (data.capabilities & WPA_CAPABILITY_EXT_KEY_ID_FOR_UNICAST)) {
1049 sm->use_ext_key_id = true;
1050 if (conf->extended_key_id == 2 &&
1051 !wpa_key_mgmt_ft(sm->wpa_key_mgmt) &&
1052 !wpa_key_mgmt_fils(sm->wpa_key_mgmt))
1053 sm->keyidx_active = 1;
1054 else
1055 sm->keyidx_active = 0;
1056 wpa_printf(MSG_DEBUG,
1057 "RSN: Extended Key ID supported (start with %d)",
1058 sm->keyidx_active);
1059 } else {
1060 sm->use_ext_key_id = false;
1061 }
1062
1063 if (sm->wpa_ie == NULL || sm->wpa_ie_len < wpa_ie_len) {
1064 os_free(sm->wpa_ie);
1065 sm->wpa_ie = os_malloc(wpa_ie_len);
1066 if (sm->wpa_ie == NULL)
1067 return WPA_ALLOC_FAIL;
1068 }
1069 os_memcpy(sm->wpa_ie, wpa_ie, wpa_ie_len);
1070 sm->wpa_ie_len = wpa_ie_len;
1071
1072 if (rsnxe && rsnxe_len) {
1073 if (!sm->rsnxe || sm->rsnxe_len < rsnxe_len) {
1074 os_free(sm->rsnxe);
1075 sm->rsnxe = os_malloc(rsnxe_len);
1076 if (!sm->rsnxe)
1077 return WPA_ALLOC_FAIL;
1078 }
1079 os_memcpy(sm->rsnxe, rsnxe, rsnxe_len);
1080 sm->rsnxe_len = rsnxe_len;
1081 } else {
1082 os_free(sm->rsnxe);
1083 sm->rsnxe = NULL;
1084 sm->rsnxe_len = 0;
1085 }
1086
1087 return WPA_IE_OK;
1088 }
1089
1090
1091 #ifdef CONFIG_HS20
wpa_validate_osen(struct wpa_authenticator * wpa_auth,struct wpa_state_machine * sm,const u8 * osen_ie,size_t osen_ie_len)1092 int wpa_validate_osen(struct wpa_authenticator *wpa_auth,
1093 struct wpa_state_machine *sm,
1094 const u8 *osen_ie, size_t osen_ie_len)
1095 {
1096 if (wpa_auth == NULL || sm == NULL)
1097 return -1;
1098
1099 /* TODO: parse OSEN element */
1100 sm->wpa_key_mgmt = WPA_KEY_MGMT_OSEN;
1101 sm->mgmt_frame_prot = 1;
1102 sm->pairwise = WPA_CIPHER_CCMP;
1103 sm->wpa = WPA_VERSION_WPA2;
1104
1105 if (sm->wpa_ie == NULL || sm->wpa_ie_len < osen_ie_len) {
1106 os_free(sm->wpa_ie);
1107 sm->wpa_ie = os_malloc(osen_ie_len);
1108 if (sm->wpa_ie == NULL)
1109 return -1;
1110 }
1111
1112 os_memcpy(sm->wpa_ie, osen_ie, osen_ie_len);
1113 sm->wpa_ie_len = osen_ie_len;
1114
1115 return 0;
1116 }
1117
1118 #endif /* CONFIG_HS20 */
1119
1120
wpa_auth_uses_mfp(struct wpa_state_machine * sm)1121 int wpa_auth_uses_mfp(struct wpa_state_machine *sm)
1122 {
1123 return sm ? sm->mgmt_frame_prot : 0;
1124 }
1125
1126
1127 #ifdef CONFIG_OCV
1128
wpa_auth_set_ocv(struct wpa_state_machine * sm,int ocv)1129 void wpa_auth_set_ocv(struct wpa_state_machine *sm, int ocv)
1130 {
1131 if (sm)
1132 sm->ocv_enabled = ocv;
1133 }
1134
1135
wpa_auth_uses_ocv(struct wpa_state_machine * sm)1136 int wpa_auth_uses_ocv(struct wpa_state_machine *sm)
1137 {
1138 return sm ? sm->ocv_enabled : 0;
1139 }
1140
1141 #endif /* CONFIG_OCV */
1142
1143
1144 #ifdef CONFIG_OWE
wpa_auth_write_assoc_resp_owe(struct wpa_state_machine * sm,u8 * pos,size_t max_len,const u8 * req_ies,size_t req_ies_len)1145 u8 * wpa_auth_write_assoc_resp_owe(struct wpa_state_machine *sm,
1146 u8 *pos, size_t max_len,
1147 const u8 *req_ies, size_t req_ies_len)
1148 {
1149 int res;
1150 struct wpa_auth_config *conf;
1151
1152 if (!sm)
1153 return pos;
1154 conf = &sm->wpa_auth->conf;
1155
1156 #ifdef CONFIG_TESTING_OPTIONS
1157 if (conf->own_ie_override_len) {
1158 if (max_len < conf->own_ie_override_len)
1159 return NULL;
1160 wpa_hexdump(MSG_DEBUG, "WPA: Forced own IE(s) for testing",
1161 conf->own_ie_override, conf->own_ie_override_len);
1162 os_memcpy(pos, conf->own_ie_override,
1163 conf->own_ie_override_len);
1164 return pos + conf->own_ie_override_len;
1165 }
1166 #endif /* CONFIG_TESTING_OPTIONS */
1167
1168 res = wpa_write_rsn_ie(conf, pos, max_len,
1169 sm->pmksa ? sm->pmksa->pmkid : NULL);
1170 if (res < 0)
1171 return pos;
1172 return pos + res;
1173 }
1174 #endif /* CONFIG_OWE */
1175
1176
1177 #ifdef CONFIG_FILS
1178
wpa_auth_write_assoc_resp_fils(struct wpa_state_machine * sm,u8 * pos,size_t max_len,const u8 * req_ies,size_t req_ies_len)1179 u8 * wpa_auth_write_assoc_resp_fils(struct wpa_state_machine *sm,
1180 u8 *pos, size_t max_len,
1181 const u8 *req_ies, size_t req_ies_len)
1182 {
1183 int res;
1184
1185 if (!sm ||
1186 sm->wpa_key_mgmt & (WPA_KEY_MGMT_FT_FILS_SHA256 |
1187 WPA_KEY_MGMT_FT_FILS_SHA384))
1188 return pos;
1189
1190 res = wpa_write_rsn_ie(&sm->wpa_auth->conf, pos, max_len, NULL);
1191 if (res < 0)
1192 return pos;
1193 return pos + res;
1194 }
1195
1196
wpa_auth_write_fd_rsn_info(struct wpa_authenticator * wpa_auth,u8 * fd_rsn_info)1197 bool wpa_auth_write_fd_rsn_info(struct wpa_authenticator *wpa_auth,
1198 u8 *fd_rsn_info)
1199 {
1200 struct wpa_auth_config *conf;
1201 u32 selectors = 0;
1202 u8 *pos = fd_rsn_info;
1203 int i, res;
1204 u32 cipher, suite, selector, mask;
1205 u8 tmp[10 * RSN_SELECTOR_LEN];
1206
1207 if (!wpa_auth)
1208 return false;
1209 conf = &wpa_auth->conf;
1210
1211 if (!(conf->wpa & WPA_PROTO_RSN))
1212 return false;
1213
1214 /* RSN Capability (B0..B15) */
1215 WPA_PUT_LE16(pos, wpa_own_rsn_capab(conf));
1216 pos += 2;
1217
1218 /* Group Data Cipher Suite Selector (B16..B21) */
1219 suite = wpa_cipher_to_suite(WPA_PROTO_RSN, conf->wpa_group);
1220 if (suite == RSN_CIPHER_SUITE_NO_GROUP_ADDRESSED)
1221 cipher = 63; /* No cipher suite selected */
1222 else if ((suite >> 8) == 0x000fac && ((suite & 0xff) <= 13))
1223 cipher = suite & 0xff;
1224 else
1225 cipher = 62; /* vendor specific */
1226 selectors |= cipher;
1227
1228 /* Group Management Cipher Suite Selector (B22..B27) */
1229 cipher = 63; /* Default to no cipher suite selected */
1230 if (conf->ieee80211w != NO_MGMT_FRAME_PROTECTION) {
1231 switch (conf->group_mgmt_cipher) {
1232 case WPA_CIPHER_AES_128_CMAC:
1233 cipher = RSN_CIPHER_SUITE_AES_128_CMAC & 0xff;
1234 break;
1235 case WPA_CIPHER_BIP_GMAC_128:
1236 cipher = RSN_CIPHER_SUITE_BIP_GMAC_128 & 0xff;
1237 break;
1238 case WPA_CIPHER_BIP_GMAC_256:
1239 cipher = RSN_CIPHER_SUITE_BIP_GMAC_256 & 0xff;
1240 break;
1241 case WPA_CIPHER_BIP_CMAC_256:
1242 cipher = RSN_CIPHER_SUITE_BIP_CMAC_256 & 0xff;
1243 break;
1244 }
1245 }
1246 selectors |= cipher << 6;
1247
1248 /* Pairwise Cipher Suite Selector (B28..B33) */
1249 cipher = 63; /* Default to no cipher suite selected */
1250 res = rsn_cipher_put_suites(tmp, conf->rsn_pairwise);
1251 if (res == 1 && tmp[0] == 0x00 && tmp[1] == 0x0f && tmp[2] == 0xac &&
1252 tmp[3] <= 13)
1253 cipher = tmp[3];
1254 selectors |= cipher << 12;
1255
1256 /* AKM Suite Selector (B34..B39) */
1257 selector = 0; /* default to AKM from RSNE in Beacon/Probe Response */
1258 mask = WPA_KEY_MGMT_FILS_SHA256 | WPA_KEY_MGMT_FILS_SHA384 |
1259 WPA_KEY_MGMT_FT_FILS_SHA384;
1260 if ((conf->wpa_key_mgmt & mask) && (conf->wpa_key_mgmt & ~mask) == 0) {
1261 suite = conf->wpa_key_mgmt & mask;
1262 if (suite == WPA_KEY_MGMT_FILS_SHA256)
1263 selector = 1; /* 00-0f-ac:14 */
1264 else if (suite == WPA_KEY_MGMT_FILS_SHA384)
1265 selector = 2; /* 00-0f-ac:15 */
1266 else if (suite == (WPA_KEY_MGMT_FILS_SHA256 |
1267 WPA_KEY_MGMT_FILS_SHA384))
1268 selector = 3; /* 00-0f-ac:14 or 00-0f-ac:15 */
1269 else if (suite == WPA_KEY_MGMT_FT_FILS_SHA384)
1270 selector = 4; /* 00-0f-ac:17 */
1271 }
1272 selectors |= selector << 18;
1273
1274 for (i = 0; i < 3; i++) {
1275 *pos++ = selectors & 0xff;
1276 selectors >>= 8;
1277 }
1278
1279 return true;
1280 }
1281
1282 #endif /* CONFIG_FILS */
1283