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