]> git.ipfire.org Git - thirdparty/hostap.git/blob - src/ap/wpa_auth_ft.c
projects / thirdparty / hostap.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
FT: Maintain PMK-R1 for a connected STA
[thirdparty/hostap.git] / src / ap / wpa_auth_ft.c
1 /*
2 * hostapd - IEEE 802.11r - Fast BSS Transition
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 "utils/eloop.h"
13 #include "utils/list.h"
14 #include "common/ieee802_11_defs.h"
15 #include "common/ieee802_11_common.h"
16 #include "common/ocv.h"
17 #include "drivers/driver.h"
18 #include "crypto/aes.h"
19 #include "crypto/aes_siv.h"
20 #include "crypto/aes_wrap.h"
21 #include "crypto/sha384.h"
22 #include "crypto/random.h"
23 #include "ap_config.h"
24 #include "ieee802_11.h"
25 #include "wmm.h"
26 #include "wpa_auth.h"
27 #include "wpa_auth_i.h"
28
29
30 #ifdef CONFIG_IEEE80211R_AP
31
32 const unsigned int ftRRBseqTimeout = 10;
33 const unsigned int ftRRBmaxQueueLen = 100;
34
35
36 static int wpa_ft_send_rrb_auth_resp(struct wpa_state_machine *sm,
37 const u8 *current_ap, const u8 *sta_addr,
38 u16 status, const u8 *resp_ies,
39 size_t resp_ies_len);
40 static void ft_finish_pull(struct wpa_state_machine *sm);
41 static void wpa_ft_expire_pull(void *eloop_ctx, void *timeout_ctx);
42 static void wpa_ft_rrb_seq_timeout(void *eloop_ctx, void *timeout_ctx);
43
44 struct tlv_list {
45 u16 type;
46 size_t len;
47 const u8 *data;
48 };
49
50
51 /**
52 * wpa_ft_rrb_decrypt - Decrypt FT RRB message
53 * @key: AES-SIV key for AEAD
54 * @key_len: Length of key in octets
55 * @enc: Pointer to encrypted TLVs
56 * @enc_len: Length of encrypted TLVs in octets
57 * @auth: Pointer to authenticated TLVs
58 * @auth_len: Length of authenticated TLVs in octets
59 * @src_addr: MAC address of the frame sender
60 * @type: Vendor-specific subtype of the RRB frame (FT_PACKET_*)
61 * @plain: Pointer to return the pointer to the allocated plaintext buffer;
62 * needs to be freed by the caller if not NULL;
63 * will only be returned on success
64 * @plain_len: Pointer to return the length of the allocated plaintext buffer
65 * in octets
66 * Returns: 0 on success, -1 on error
67 */
68 static int wpa_ft_rrb_decrypt(const u8 *key, const size_t key_len,
69 const u8 *enc, size_t enc_len,
70 const u8 *auth, const size_t auth_len,
71 const u8 *src_addr, u8 type,
72 u8 **plain, size_t *plain_size)
73 {
74 const u8 *ad[3] = { src_addr, auth, &type };
75 size_t ad_len[3] = { ETH_ALEN, auth_len, sizeof(type) };
76
77 wpa_printf(MSG_DEBUG, "FT(RRB): src_addr=" MACSTR " type=%u",
78 MAC2STR(src_addr), type);
79 wpa_hexdump_key(MSG_DEBUG, "FT(RRB): decrypt using key", key, key_len);
80 wpa_hexdump(MSG_DEBUG, "FT(RRB): encrypted TLVs", enc, enc_len);
81 wpa_hexdump(MSG_DEBUG, "FT(RRB): authenticated TLVs", auth, auth_len);
82
83 if (!key) { /* skip decryption */
84 *plain = os_memdup(enc, enc_len);
85 if (enc_len > 0 && !*plain)
86 goto err;
87
88 *plain_size = enc_len;
89
90 return 0;
91 }
92
93 *plain = NULL;
94
95 /* SIV overhead */
96 if (enc_len < AES_BLOCK_SIZE)
97 goto err;
98
99 *plain = os_zalloc(enc_len - AES_BLOCK_SIZE);
100 if (!*plain)
101 goto err;
102
103 if (aes_siv_decrypt(key, key_len, enc, enc_len, 3, ad, ad_len,
104 *plain) < 0) {
105 if (enc_len < AES_BLOCK_SIZE + 2)
106 goto err;
107
108 /* Try to work around Ethernet devices that add extra
109 * two octet padding even if the frame is longer than
110 * the minimum Ethernet frame. */
111 enc_len -= 2;
112 if (aes_siv_decrypt(key, key_len, enc, enc_len, 3, ad, ad_len,
113 *plain) < 0)
114 goto err;
115 }
116
117 *plain_size = enc_len - AES_BLOCK_SIZE;
118 wpa_hexdump_key(MSG_DEBUG, "FT(RRB): decrypted TLVs",
119 *plain, *plain_size);
120 return 0;
121 err:
122 os_free(*plain);
123 *plain = NULL;
124 *plain_size = 0;
125
126 wpa_printf(MSG_ERROR, "FT(RRB): Failed to decrypt");
127
128 return -1;
129 }
130
131
132 /* get first tlv record in packet matching type
133 * @data (decrypted) packet
134 * @return 0 on success else -1
135 */
136 static int wpa_ft_rrb_get_tlv(const u8 *plain, size_t plain_len,
137 u16 type, size_t *tlv_len, const u8 **tlv_data)
138 {
139 const struct ft_rrb_tlv *f;
140 size_t left;
141 le16 type16;
142 size_t len;
143
144 left = plain_len;
145 type16 = host_to_le16(type);
146
147 while (left >= sizeof(*f)) {
148 f = (const struct ft_rrb_tlv *) plain;
149
150 left -= sizeof(*f);
151 plain += sizeof(*f);
152 len = le_to_host16(f->len);
153
154 if (left < len) {
155 wpa_printf(MSG_DEBUG, "FT: RRB message truncated");
156 break;
157 }
158
159 if (f->type == type16) {
160 *tlv_len = len;
161 *tlv_data = plain;
162 return 0;
163 }
164
165 left -= len;
166 plain += len;
167 }
168
169 return -1;
170 }
171
172
173 static void wpa_ft_rrb_dump(const u8 *plain, const size_t plain_len)
174 {
175 const struct ft_rrb_tlv *f;
176 size_t left;
177 size_t len;
178
179 left = plain_len;
180
181 wpa_printf(MSG_DEBUG, "FT: RRB dump message");
182 while (left >= sizeof(*f)) {
183 f = (const struct ft_rrb_tlv *) plain;
184
185 left -= sizeof(*f);
186 plain += sizeof(*f);
187 len = le_to_host16(f->len);
188
189 wpa_printf(MSG_DEBUG, "FT: RRB TLV type = %d, len = %zu",
190 le_to_host16(f->type), len);
191
192 if (left < len) {
193 wpa_printf(MSG_DEBUG,
194 "FT: RRB message truncated: left %zu bytes, need %zu",
195 left, len);
196 break;
197 }
198
199 wpa_hexdump(MSG_DEBUG, "FT: RRB TLV data", plain, len);
200
201 left -= len;
202 plain += len;
203 }
204
205 if (left > 0)
206 wpa_hexdump(MSG_DEBUG, "FT: RRB TLV padding", plain, left);
207
208 wpa_printf(MSG_DEBUG, "FT: RRB dump message end");
209 }
210
211
212 static int cmp_int(const void *a, const void *b)
213 {
214 int x, y;
215
216 x = *((int *) a);
217 y = *((int *) b);
218 return x - y;
219 }
220
221
222 static int wpa_ft_rrb_get_tlv_vlan(const u8 *plain, const size_t plain_len,
223 struct vlan_description *vlan)
224 {
225 struct ft_rrb_tlv *f;
226 size_t left;
227 size_t len;
228 int taggedidx;
229 int vlan_id;
230 int type;
231
232 left = plain_len;
233 taggedidx = 0;
234 os_memset(vlan, 0, sizeof(*vlan));
235
236 while (left >= sizeof(*f)) {
237 f = (struct ft_rrb_tlv *) plain;
238
239 left -= sizeof(*f);
240 plain += sizeof(*f);
241
242 len = le_to_host16(f->len);
243 type = le_to_host16(f->type);
244
245 if (left < len) {
246 wpa_printf(MSG_DEBUG, "FT: RRB message truncated");
247 return -1;
248 }
249
250 if (type != FT_RRB_VLAN_UNTAGGED && type != FT_RRB_VLAN_TAGGED)
251 goto skip;
252
253 if (type == FT_RRB_VLAN_UNTAGGED && len != sizeof(le16)) {
254 wpa_printf(MSG_DEBUG,
255 "FT: RRB VLAN_UNTAGGED invalid length");
256 return -1;
257 }
258
259 if (type == FT_RRB_VLAN_TAGGED && len % sizeof(le16) != 0) {
260 wpa_printf(MSG_DEBUG,
261 "FT: RRB VLAN_TAGGED invalid length");
262 return -1;
263 }
264
265 while (len >= sizeof(le16)) {
266 vlan_id = WPA_GET_LE16(plain);
267 plain += sizeof(le16);
268 left -= sizeof(le16);
269 len -= sizeof(le16);
270
271 if (vlan_id <= 0 || vlan_id > MAX_VLAN_ID) {
272 wpa_printf(MSG_DEBUG,
273 "FT: RRB VLAN ID invalid %d",
274 vlan_id);
275 continue;
276 }
277
278 if (type == FT_RRB_VLAN_UNTAGGED)
279 vlan->untagged = vlan_id;
280
281 if (type == FT_RRB_VLAN_TAGGED &&
282 taggedidx < MAX_NUM_TAGGED_VLAN) {
283 vlan->tagged[taggedidx] = vlan_id;
284 taggedidx++;
285 } else if (type == FT_RRB_VLAN_TAGGED) {
286 wpa_printf(MSG_DEBUG, "FT: RRB too many VLANs");
287 }
288 }
289
290 skip:
291 left -= len;
292 plain += len;
293 }
294
295 if (taggedidx)
296 qsort(vlan->tagged, taggedidx, sizeof(int), cmp_int);
297
298 vlan->notempty = vlan->untagged || vlan->tagged[0];
299
300 return 0;
301 }
302
303
304 static size_t wpa_ft_tlv_len(const struct tlv_list *tlvs)
305 {
306 size_t tlv_len = 0;
307 int i;
308
309 if (!tlvs)
310 return 0;
311
312 for (i = 0; tlvs[i].type != FT_RRB_LAST_EMPTY; i++) {
313 tlv_len += sizeof(struct ft_rrb_tlv);
314 tlv_len += tlvs[i].len;
315 }
316
317 return tlv_len;
318 }
319
320
321 static size_t wpa_ft_tlv_lin(const struct tlv_list *tlvs, u8 *start,
322 u8 *endpos)
323 {
324 int i;
325 size_t tlv_len;
326 struct ft_rrb_tlv *hdr;
327 u8 *pos;
328
329 if (!tlvs)
330 return 0;
331
332 tlv_len = 0;
333 pos = start;
334 for (i = 0; tlvs[i].type != FT_RRB_LAST_EMPTY; i++) {
335 if (tlv_len + sizeof(*hdr) > (size_t) (endpos - start))
336 return tlv_len;
337 tlv_len += sizeof(*hdr);
338 hdr = (struct ft_rrb_tlv *) pos;
339 hdr->type = host_to_le16(tlvs[i].type);
340 hdr->len = host_to_le16(tlvs[i].len);
341 pos = start + tlv_len;
342
343 if (tlv_len + tlvs[i].len > (size_t) (endpos - start))
344 return tlv_len;
345 if (tlvs[i].len == 0)
346 continue;
347 tlv_len += tlvs[i].len;
348 os_memcpy(pos, tlvs[i].data, tlvs[i].len);
349 pos = start + tlv_len;
350 }
351
352 return tlv_len;
353 }
354
355
356 static size_t wpa_ft_vlan_len(const struct vlan_description *vlan)
357 {
358 size_t tlv_len = 0;
359 int i;
360
361 if (!vlan || !vlan->notempty)
362 return 0;
363
364 if (vlan->untagged) {
365 tlv_len += sizeof(struct ft_rrb_tlv);
366 tlv_len += sizeof(le16);
367 }
368 if (vlan->tagged[0])
369 tlv_len += sizeof(struct ft_rrb_tlv);
370 for (i = 0; i < MAX_NUM_TAGGED_VLAN && vlan->tagged[i]; i++)
371 tlv_len += sizeof(le16);
372
373 return tlv_len;
374 }
375
376
377 static size_t wpa_ft_vlan_lin(const struct vlan_description *vlan,
378 u8 *start, u8 *endpos)
379 {
380 size_t tlv_len;
381 int i, len;
382 struct ft_rrb_tlv *hdr;
383 u8 *pos = start;
384
385 if (!vlan || !vlan->notempty)
386 return 0;
387
388 tlv_len = 0;
389 if (vlan->untagged) {
390 tlv_len += sizeof(*hdr);
391 if (start + tlv_len > endpos)
392 return tlv_len;
393 hdr = (struct ft_rrb_tlv *) pos;
394 hdr->type = host_to_le16(FT_RRB_VLAN_UNTAGGED);
395 hdr->len = host_to_le16(sizeof(le16));
396 pos = start + tlv_len;
397
398 tlv_len += sizeof(le16);
399 if (start + tlv_len > endpos)
400 return tlv_len;
401 WPA_PUT_LE16(pos, vlan->untagged);
402 pos = start + tlv_len;
403 }
404
405 if (!vlan->tagged[0])
406 return tlv_len;
407
408 tlv_len += sizeof(*hdr);
409 if (start + tlv_len > endpos)
410 return tlv_len;
411 hdr = (struct ft_rrb_tlv *) pos;
412 hdr->type = host_to_le16(FT_RRB_VLAN_TAGGED);
413 len = 0; /* len is computed below */
414 pos = start + tlv_len;
415
416 for (i = 0; i < MAX_NUM_TAGGED_VLAN && vlan->tagged[i]; i++) {
417 tlv_len += sizeof(le16);
418 if (start + tlv_len > endpos)
419 break;
420 len += sizeof(le16);
421 WPA_PUT_LE16(pos, vlan->tagged[i]);
422 pos = start + tlv_len;
423 }
424
425 hdr->len = host_to_le16(len);
426
427 return tlv_len;
428 }
429
430
431 static int wpa_ft_rrb_lin(const struct tlv_list *tlvs1,
432 const struct tlv_list *tlvs2,
433 const struct vlan_description *vlan,
434 u8 **plain, size_t *plain_len)
435 {
436 u8 *pos, *endpos;
437 size_t tlv_len;
438
439 tlv_len = wpa_ft_tlv_len(tlvs1);
440 tlv_len += wpa_ft_tlv_len(tlvs2);
441 tlv_len += wpa_ft_vlan_len(vlan);
442
443 *plain_len = tlv_len;
444 *plain = os_zalloc(tlv_len);
445 if (!*plain) {
446 wpa_printf(MSG_ERROR, "FT: Failed to allocate plaintext");
447 goto err;
448 }
449
450 pos = *plain;
451 endpos = *plain + tlv_len;
452 pos += wpa_ft_tlv_lin(tlvs1, pos, endpos);
453 pos += wpa_ft_tlv_lin(tlvs2, pos, endpos);
454 pos += wpa_ft_vlan_lin(vlan, pos, endpos);
455
456 /* sanity check */
457 if (pos != endpos) {
458 wpa_printf(MSG_ERROR, "FT: Length error building RRB");
459 goto err;
460 }
461
462 return 0;
463
464 err:
465 os_free(*plain);
466 *plain = NULL;
467 *plain_len = 0;
468 return -1;
469 }
470
471
472 static int wpa_ft_rrb_encrypt(const u8 *key, const size_t key_len,
473 const u8 *plain, const size_t plain_len,
474 const u8 *auth, const size_t auth_len,
475 const u8 *src_addr, u8 type, u8 *enc)
476 {
477 const u8 *ad[3] = { src_addr, auth, &type };
478 size_t ad_len[3] = { ETH_ALEN, auth_len, sizeof(type) };
479
480 wpa_printf(MSG_DEBUG, "FT(RRB): src_addr=" MACSTR " type=%u",
481 MAC2STR(src_addr), type);
482 wpa_hexdump_key(MSG_DEBUG, "FT(RRB): plaintext message",
483 plain, plain_len);
484 wpa_hexdump_key(MSG_DEBUG, "FT(RRB): encrypt using key", key, key_len);
485 wpa_hexdump(MSG_DEBUG, "FT(RRB): authenticated TLVs", auth, auth_len);
486
487 if (!key) {
488 /* encryption not needed, return plaintext as packet */
489 os_memcpy(enc, plain, plain_len);
490 } else if (aes_siv_encrypt(key, key_len, plain, plain_len,
491 3, ad, ad_len, enc) < 0) {
492 wpa_printf(MSG_ERROR, "FT: Failed to encrypt RRB-OUI message");
493 return -1;
494 }
495 wpa_hexdump(MSG_DEBUG, "FT(RRB): encrypted TLVs",
496 enc, plain_len + AES_BLOCK_SIZE);
497
498 return 0;
499 }
500
501
502 /**
503 * wpa_ft_rrb_build - Build and encrypt an FT RRB message
504 * @key: AES-SIV key for AEAD
505 * @key_len: Length of key in octets
506 * @tlvs_enc0: First set of to-be-encrypted TLVs
507 * @tlvs_enc1: Second set of to-be-encrypted TLVs
508 * @tlvs_auth: Set of to-be-authenticated TLVs
509 * @src_addr: MAC address of the frame sender
510 * @type: Vendor-specific subtype of the RRB frame (FT_PACKET_*)
511 * @packet Pointer to return the pointer to the allocated packet buffer;
512 * needs to be freed by the caller if not null;
513 * will only be returned on success
514 * @packet_len: Pointer to return the length of the allocated buffer in octets
515 * Returns: 0 on success, -1 on error
516 */
517 static int wpa_ft_rrb_build(const u8 *key, const size_t key_len,
518 const struct tlv_list *tlvs_enc0,
519 const struct tlv_list *tlvs_enc1,
520 const struct tlv_list *tlvs_auth,
521 const struct vlan_description *vlan,
522 const u8 *src_addr, u8 type,
523 u8 **packet, size_t *packet_len)
524 {
525 u8 *plain = NULL, *auth = NULL, *pos, *tmp;
526 size_t plain_len = 0, auth_len = 0;
527 int ret = -1;
528 size_t pad_len = 0;
529
530 *packet = NULL;
531 if (wpa_ft_rrb_lin(tlvs_enc0, tlvs_enc1, vlan, &plain, &plain_len) < 0)
532 goto out;
533
534 if (wpa_ft_rrb_lin(tlvs_auth, NULL, NULL, &auth, &auth_len) < 0)
535 goto out;
536
537 *packet_len = sizeof(u16) + auth_len + plain_len;
538 if (key)
539 *packet_len += AES_BLOCK_SIZE;
540 #define RRB_MIN_MSG_LEN 64
541 if (*packet_len < RRB_MIN_MSG_LEN) {
542 pad_len = RRB_MIN_MSG_LEN - *packet_len;
543 if (pad_len < sizeof(struct ft_rrb_tlv))
544 pad_len = sizeof(struct ft_rrb_tlv);
545 wpa_printf(MSG_DEBUG,
546 "FT: Pad message to minimum Ethernet frame length (%d --> %d)",
547 (int) *packet_len, (int) (*packet_len + pad_len));
548 *packet_len += pad_len;
549 tmp = os_realloc(auth, auth_len + pad_len);
550 if (!tmp)
551 goto out;
552 auth = tmp;
553 pos = auth + auth_len;
554 WPA_PUT_LE16(pos, FT_RRB_LAST_EMPTY);
555 pos += 2;
556 WPA_PUT_LE16(pos, pad_len - sizeof(struct ft_rrb_tlv));
557 pos += 2;
558 os_memset(pos, 0, pad_len - sizeof(struct ft_rrb_tlv));
559 auth_len += pad_len;
560
561 }
562 *packet = os_zalloc(*packet_len);
563 if (!*packet)
564 goto out;
565
566 pos = *packet;
567 WPA_PUT_LE16(pos, auth_len);
568 pos += 2;
569 os_memcpy(pos, auth, auth_len);
570 pos += auth_len;
571 if (wpa_ft_rrb_encrypt(key, key_len, plain, plain_len, auth,
572 auth_len, src_addr, type, pos) < 0)
573 goto out;
574 wpa_hexdump(MSG_MSGDUMP, "FT: RRB frame payload", *packet, *packet_len);
575
576 ret = 0;
577
578 out:
579 bin_clear_free(plain, plain_len);
580 os_free(auth);
581
582 if (ret) {
583 wpa_printf(MSG_ERROR, "FT: Failed to build RRB-OUI message");
584 os_free(*packet);
585 *packet = NULL;
586 *packet_len = 0;
587 }
588
589 return ret;
590 }
591
592
593 #define RRB_GET_SRC(srcfield, type, field, txt, checklength) do { \
594 if (wpa_ft_rrb_get_tlv(srcfield, srcfield##_len, type, \
595 &f_##field##_len, &f_##field) < 0 || \
596 (checklength > 0 && ((size_t) checklength) != f_##field##_len)) { \
597 wpa_printf(MSG_INFO, "FT: Missing required " #field \
598 " in %s from " MACSTR, txt, MAC2STR(src_addr)); \
599 wpa_ft_rrb_dump(srcfield, srcfield##_len); \
600 goto out; \
601 } \
602 } while (0)
603
604 #define RRB_GET(type, field, txt, checklength) \
605 RRB_GET_SRC(plain, type, field, txt, checklength)
606 #define RRB_GET_AUTH(type, field, txt, checklength) \
607 RRB_GET_SRC(auth, type, field, txt, checklength)
608
609 #define RRB_GET_OPTIONAL_SRC(srcfield, type, field, txt, checklength) do { \
610 if (wpa_ft_rrb_get_tlv(srcfield, srcfield##_len, type, \
611 &f_##field##_len, &f_##field) < 0 || \
612 (checklength > 0 && ((size_t) checklength) != f_##field##_len)) { \
613 wpa_printf(MSG_DEBUG, "FT: Missing optional " #field \
614 " in %s from " MACSTR, txt, MAC2STR(src_addr)); \
615 f_##field##_len = 0; \
616 f_##field = NULL; \
617 } \
618 } while (0)
619
620 #define RRB_GET_OPTIONAL(type, field, txt, checklength) \
621 RRB_GET_OPTIONAL_SRC(plain, type, field, txt, checklength)
622 #define RRB_GET_OPTIONAL_AUTH(type, field, txt, checklength) \
623 RRB_GET_OPTIONAL_SRC(auth, type, field, txt, checklength)
624
625 static int wpa_ft_rrb_send(struct wpa_authenticator *wpa_auth, const u8 *dst,
626 const u8 *data, size_t data_len)
627 {
628 if (wpa_auth->cb->send_ether == NULL)
629 return -1;
630 wpa_printf(MSG_DEBUG, "FT: RRB send to " MACSTR, MAC2STR(dst));
631 return wpa_auth->cb->send_ether(wpa_auth->cb_ctx, dst, ETH_P_RRB,
632 data, data_len);
633 }
634
635
636 static int wpa_ft_rrb_oui_send(struct wpa_authenticator *wpa_auth,
637 const u8 *dst, u8 oui_suffix,
638 const u8 *data, size_t data_len)
639 {
640 if (!wpa_auth->cb->send_oui)
641 return -1;
642 wpa_printf(MSG_DEBUG, "FT: RRB-OUI type %u send to " MACSTR " (len=%u)",
643 oui_suffix, MAC2STR(dst), (unsigned int) data_len);
644 return wpa_auth->cb->send_oui(wpa_auth->cb_ctx, dst, oui_suffix, data,
645 data_len);
646 }
647
648
649 static int wpa_ft_action_send(struct wpa_authenticator *wpa_auth,
650 const u8 *dst, const u8 *data, size_t data_len)
651 {
652 if (wpa_auth->cb->send_ft_action == NULL)
653 return -1;
654 return wpa_auth->cb->send_ft_action(wpa_auth->cb_ctx, dst,
655 data, data_len);
656 }
657
658
659 static const u8 * wpa_ft_get_psk(struct wpa_authenticator *wpa_auth,
660 const u8 *addr, const u8 *p2p_dev_addr,
661 const u8 *prev_psk)
662 {
663 if (wpa_auth->cb->get_psk == NULL)
664 return NULL;
665 return wpa_auth->cb->get_psk(wpa_auth->cb_ctx, addr, p2p_dev_addr,
666 prev_psk, NULL, NULL);
667 }
668
669
670 static struct wpa_state_machine *
671 wpa_ft_add_sta(struct wpa_authenticator *wpa_auth, const u8 *sta_addr)
672 {
673 if (wpa_auth->cb->add_sta == NULL)
674 return NULL;
675 return wpa_auth->cb->add_sta(wpa_auth->cb_ctx, sta_addr);
676 }
677
678
679 static int wpa_ft_set_vlan(struct wpa_authenticator *wpa_auth,
680 const u8 *sta_addr, struct vlan_description *vlan)
681 {
682 if (!wpa_auth->cb->set_vlan)
683 return -1;
684 return wpa_auth->cb->set_vlan(wpa_auth->cb_ctx, sta_addr, vlan);
685 }
686
687
688 static int wpa_ft_get_vlan(struct wpa_authenticator *wpa_auth,
689 const u8 *sta_addr, struct vlan_description *vlan)
690 {
691 if (!wpa_auth->cb->get_vlan)
692 return -1;
693 return wpa_auth->cb->get_vlan(wpa_auth->cb_ctx, sta_addr, vlan);
694 }
695
696
697 static int
698 wpa_ft_set_identity(struct wpa_authenticator *wpa_auth, const u8 *sta_addr,
699 const u8 *identity, size_t identity_len)
700 {
701 if (!wpa_auth->cb->set_identity)
702 return -1;
703 return wpa_auth->cb->set_identity(wpa_auth->cb_ctx, sta_addr, identity,
704 identity_len);
705 }
706
707
708 static size_t
709 wpa_ft_get_identity(struct wpa_authenticator *wpa_auth, const u8 *sta_addr,
710 const u8 **buf)
711 {
712 *buf = NULL;
713 if (!wpa_auth->cb->get_identity)
714 return 0;
715 return wpa_auth->cb->get_identity(wpa_auth->cb_ctx, sta_addr, buf);
716 }
717
718
719 static int
720 wpa_ft_set_radius_cui(struct wpa_authenticator *wpa_auth, const u8 *sta_addr,
721 const u8 *radius_cui, size_t radius_cui_len)
722 {
723 if (!wpa_auth->cb->set_radius_cui)
724 return -1;
725 return wpa_auth->cb->set_radius_cui(wpa_auth->cb_ctx, sta_addr,
726 radius_cui, radius_cui_len);
727 }
728
729
730 static size_t
731 wpa_ft_get_radius_cui(struct wpa_authenticator *wpa_auth, const u8 *sta_addr,
732 const u8 **buf)
733 {
734 *buf = NULL;
735 if (!wpa_auth->cb->get_radius_cui)
736 return 0;
737 return wpa_auth->cb->get_radius_cui(wpa_auth->cb_ctx, sta_addr, buf);
738 }
739
740
741 static void
742 wpa_ft_set_session_timeout(struct wpa_authenticator *wpa_auth,
743 const u8 *sta_addr, int session_timeout)
744 {
745 if (!wpa_auth->cb->set_session_timeout)
746 return;
747 wpa_auth->cb->set_session_timeout(wpa_auth->cb_ctx, sta_addr,
748 session_timeout);
749 }
750
751
752 static int
753 wpa_ft_get_session_timeout(struct wpa_authenticator *wpa_auth,
754 const u8 *sta_addr)
755 {
756 if (!wpa_auth->cb->get_session_timeout)
757 return 0;
758 return wpa_auth->cb->get_session_timeout(wpa_auth->cb_ctx, sta_addr);
759 }
760
761
762 static int wpa_ft_add_tspec(struct wpa_authenticator *wpa_auth,
763 const u8 *sta_addr,
764 u8 *tspec_ie, size_t tspec_ielen)
765 {
766 if (wpa_auth->cb->add_tspec == NULL) {
767 wpa_printf(MSG_DEBUG, "FT: add_tspec is not initialized");
768 return -1;
769 }
770 return wpa_auth->cb->add_tspec(wpa_auth->cb_ctx, sta_addr, tspec_ie,
771 tspec_ielen);
772 }
773
774
775 #ifdef CONFIG_OCV
776 static int wpa_channel_info(struct wpa_authenticator *wpa_auth,
777 struct wpa_channel_info *ci)
778 {
779 if (!wpa_auth->cb->channel_info)
780 return -1;
781 return wpa_auth->cb->channel_info(wpa_auth->cb_ctx, ci);
782 }
783 #endif /* CONFIG_OCV */
784
785
786 int wpa_write_mdie(struct wpa_auth_config *conf, u8 *buf, size_t len)
787 {
788 u8 *pos = buf;
789 u8 capab;
790 if (len < 2 + sizeof(struct rsn_mdie))
791 return -1;
792
793 *pos++ = WLAN_EID_MOBILITY_DOMAIN;
794 *pos++ = MOBILITY_DOMAIN_ID_LEN + 1;
795 os_memcpy(pos, conf->mobility_domain, MOBILITY_DOMAIN_ID_LEN);
796 pos += MOBILITY_DOMAIN_ID_LEN;
797 capab = 0;
798 if (conf->ft_over_ds)
799 capab |= RSN_FT_CAPAB_FT_OVER_DS;
800 *pos++ = capab;
801
802 return pos - buf;
803 }
804
805
806 int wpa_write_ftie(struct wpa_auth_config *conf, int use_sha384,
807 const u8 *r0kh_id, size_t r0kh_id_len,
808 const u8 *anonce, const u8 *snonce,
809 u8 *buf, size_t len, const u8 *subelem,
810 size_t subelem_len)
811 {
812 u8 *pos = buf, *ielen;
813 size_t hdrlen = use_sha384 ? sizeof(struct rsn_ftie_sha384) :
814 sizeof(struct rsn_ftie);
815
816 if (len < 2 + hdrlen + 2 + FT_R1KH_ID_LEN + 2 + r0kh_id_len +
817 subelem_len)
818 return -1;
819
820 *pos++ = WLAN_EID_FAST_BSS_TRANSITION;
821 ielen = pos++;
822
823 if (use_sha384) {
824 struct rsn_ftie_sha384 *hdr = (struct rsn_ftie_sha384 *) pos;
825
826 os_memset(hdr, 0, sizeof(*hdr));
827 pos += sizeof(*hdr);
828 WPA_PUT_LE16(hdr->mic_control, 0);
829 if (anonce)
830 os_memcpy(hdr->anonce, anonce, WPA_NONCE_LEN);
831 if (snonce)
832 os_memcpy(hdr->snonce, snonce, WPA_NONCE_LEN);
833 } else {
834 struct rsn_ftie *hdr = (struct rsn_ftie *) pos;
835
836 os_memset(hdr, 0, sizeof(*hdr));
837 pos += sizeof(*hdr);
838 WPA_PUT_LE16(hdr->mic_control, 0);
839 if (anonce)
840 os_memcpy(hdr->anonce, anonce, WPA_NONCE_LEN);
841 if (snonce)
842 os_memcpy(hdr->snonce, snonce, WPA_NONCE_LEN);
843 }
844
845 /* Optional Parameters */
846 *pos++ = FTIE_SUBELEM_R1KH_ID;
847 *pos++ = FT_R1KH_ID_LEN;
848 os_memcpy(pos, conf->r1_key_holder, FT_R1KH_ID_LEN);
849 pos += FT_R1KH_ID_LEN;
850
851 if (r0kh_id) {
852 *pos++ = FTIE_SUBELEM_R0KH_ID;
853 *pos++ = r0kh_id_len;
854 os_memcpy(pos, r0kh_id, r0kh_id_len);
855 pos += r0kh_id_len;
856 }
857
858 if (subelem) {
859 os_memcpy(pos, subelem, subelem_len);
860 pos += subelem_len;
861 }
862
863 *ielen = pos - buf - 2;
864
865 return pos - buf;
866 }
867
868
869 /* A packet to be handled after seq response */
870 struct ft_remote_item {
871 struct dl_list list;
872
873 u8 nonce[FT_RRB_NONCE_LEN];
874 struct os_reltime nonce_ts;
875
876 u8 src_addr[ETH_ALEN];
877 u8 *enc;
878 size_t enc_len;
879 u8 *auth;
880 size_t auth_len;
881 int (*cb)(struct wpa_authenticator *wpa_auth,
882 const u8 *src_addr,
883 const u8 *enc, size_t enc_len,
884 const u8 *auth, size_t auth_len,
885 int no_defer);
886 };
887
888
889 static void wpa_ft_rrb_seq_free(struct ft_remote_item *item)
890 {
891 eloop_cancel_timeout(wpa_ft_rrb_seq_timeout, ELOOP_ALL_CTX, item);
892 dl_list_del(&item->list);
893 bin_clear_free(item->enc, item->enc_len);
894 os_free(item->auth);
895 os_free(item);
896 }
897
898
899 static void wpa_ft_rrb_seq_flush(struct wpa_authenticator *wpa_auth,
900 struct ft_remote_seq *rkh_seq, int cb)
901 {
902 struct ft_remote_item *item, *n;
903
904 dl_list_for_each_safe(item, n, &rkh_seq->rx.queue,
905 struct ft_remote_item, list) {
906 if (cb && item->cb)
907 item->cb(wpa_auth, item->src_addr, item->enc,
908 item->enc_len, item->auth, item->auth_len, 1);
909 wpa_ft_rrb_seq_free(item);
910 }
911 }
912
913
914 static void wpa_ft_rrb_seq_timeout(void *eloop_ctx, void *timeout_ctx)
915 {
916 struct ft_remote_item *item = timeout_ctx;
917
918 wpa_ft_rrb_seq_free(item);
919 }
920
921
922 static int
923 wpa_ft_rrb_seq_req(struct wpa_authenticator *wpa_auth,
924 struct ft_remote_seq *rkh_seq, const u8 *src_addr,
925 const u8 *f_r0kh_id, size_t f_r0kh_id_len,
926 const u8 *f_r1kh_id, const u8 *key, size_t key_len,
927 const u8 *enc, size_t enc_len,
928 const u8 *auth, size_t auth_len,
929 int (*cb)(struct wpa_authenticator *wpa_auth,
930 const u8 *src_addr,
931 const u8 *enc, size_t enc_len,
932 const u8 *auth, size_t auth_len,
933 int no_defer))
934 {
935 struct ft_remote_item *item = NULL;
936 u8 *packet = NULL;
937 size_t packet_len;
938 struct tlv_list seq_req_auth[] = {
939 { .type = FT_RRB_NONCE, .len = FT_RRB_NONCE_LEN,
940 .data = NULL /* to be filled: item->nonce */ },
941 { .type = FT_RRB_R0KH_ID, .len = f_r0kh_id_len,
942 .data = f_r0kh_id },
943 { .type = FT_RRB_R1KH_ID, .len = FT_R1KH_ID_LEN,
944 .data = f_r1kh_id },
945 { .type = FT_RRB_LAST_EMPTY, .len = 0, .data = NULL },
946 };
947
948 if (dl_list_len(&rkh_seq->rx.queue) >= ftRRBmaxQueueLen) {
949 wpa_printf(MSG_DEBUG, "FT: Sequence number queue too long");
950 goto err;
951 }
952
953 wpa_printf(MSG_DEBUG, "FT: Send out sequence number request to " MACSTR,
954 MAC2STR(src_addr));
955 item = os_zalloc(sizeof(*item));
956 if (!item)
957 goto err;
958
959 os_memcpy(item->src_addr, src_addr, ETH_ALEN);
960 item->cb = cb;
961
962 if (random_get_bytes(item->nonce, FT_RRB_NONCE_LEN) < 0) {
963 wpa_printf(MSG_DEBUG, "FT: Seq num nonce: out of random bytes");
964 goto err;
965 }
966
967 if (os_get_reltime(&item->nonce_ts) < 0)
968 goto err;
969
970 if (enc && enc_len > 0) {
971 item->enc = os_memdup(enc, enc_len);
972 item->enc_len = enc_len;
973 if (!item->enc)
974 goto err;
975 }
976
977 if (auth && auth_len > 0) {
978 item->auth = os_memdup(auth, auth_len);
979 item->auth_len = auth_len;
980 if (!item->auth)
981 goto err;
982 }
983
984 eloop_register_timeout(ftRRBseqTimeout, 0, wpa_ft_rrb_seq_timeout,
985 wpa_auth, item);
986
987 seq_req_auth[0].data = item->nonce;
988
989 if (wpa_ft_rrb_build(key, key_len, NULL, NULL, seq_req_auth, NULL,
990 wpa_auth->addr, FT_PACKET_R0KH_R1KH_SEQ_REQ,
991 &packet, &packet_len) < 0) {
992 item = NULL; /* some other seq resp might still accept this */
993 goto err;
994 }
995
996 dl_list_add(&rkh_seq->rx.queue, &item->list);
997
998 wpa_ft_rrb_oui_send(wpa_auth, src_addr, FT_PACKET_R0KH_R1KH_SEQ_REQ,
999 packet, packet_len);
1000
1001 os_free(packet);
1002
1003 return 0;
1004 err:
1005 wpa_printf(MSG_DEBUG, "FT: Failed to send sequence number request");
1006 if (item) {
1007 os_free(item->auth);
1008 bin_clear_free(item->enc, item->enc_len);
1009 os_free(item);
1010 }
1011
1012 return -1;
1013 }
1014
1015
1016 #define FT_RRB_SEQ_OK 0
1017 #define FT_RRB_SEQ_DROP 1
1018 #define FT_RRB_SEQ_DEFER 2
1019
1020 static int
1021 wpa_ft_rrb_seq_chk(struct ft_remote_seq *rkh_seq, const u8 *src_addr,
1022 const u8 *enc, size_t enc_len,
1023 const u8 *auth, size_t auth_len,
1024 const char *msgtype, int no_defer)
1025 {
1026 const u8 *f_seq;
1027 size_t f_seq_len;
1028 const struct ft_rrb_seq *msg_both;
1029 u32 msg_seq, msg_off, rkh_off;
1030 struct os_reltime now;
1031 unsigned int i;
1032
1033 RRB_GET_AUTH(FT_RRB_SEQ, seq, msgtype, sizeof(*msg_both));
1034 wpa_hexdump(MSG_DEBUG, "FT: sequence number", f_seq, f_seq_len);
1035 msg_both = (const struct ft_rrb_seq *) f_seq;
1036
1037 if (rkh_seq->rx.num_last == 0) {
1038 /* first packet from remote */
1039 goto defer;
1040 }
1041
1042 if (le_to_host32(msg_both->dom) != rkh_seq->rx.dom) {
1043 /* remote might have rebooted */
1044 goto defer;
1045 }
1046
1047 if (os_get_reltime(&now) == 0) {
1048 u32 msg_ts_now_remote, msg_ts_off;
1049 struct os_reltime now_remote;
1050
1051 os_reltime_sub(&now, &rkh_seq->rx.time_offset, &now_remote);
1052 msg_ts_now_remote = now_remote.sec;
1053 msg_ts_off = le_to_host32(msg_both->ts) -
1054 (msg_ts_now_remote - ftRRBseqTimeout);
1055 if (msg_ts_off > 2 * ftRRBseqTimeout)
1056 goto defer;
1057 }
1058
1059 msg_seq = le_to_host32(msg_both->seq);
1060 rkh_off = rkh_seq->rx.last[rkh_seq->rx.offsetidx];
1061 msg_off = msg_seq - rkh_off;
1062 if (msg_off > 0xC0000000)
1063 goto out; /* too old message, drop it */
1064
1065 if (msg_off <= 0x40000000) {
1066 for (i = 0; i < rkh_seq->rx.num_last; i++) {
1067 if (rkh_seq->rx.last[i] == msg_seq)
1068 goto out; /* duplicate message, drop it */
1069 }
1070
1071 return FT_RRB_SEQ_OK;
1072 }
1073
1074 defer:
1075 if (no_defer)
1076 goto out;
1077
1078 wpa_printf(MSG_DEBUG, "FT: Possibly invalid sequence number in %s from "
1079 MACSTR, msgtype, MAC2STR(src_addr));
1080
1081 return FT_RRB_SEQ_DEFER;
1082 out:
1083 wpa_printf(MSG_DEBUG, "FT: Invalid sequence number in %s from " MACSTR,
1084 msgtype, MAC2STR(src_addr));
1085
1086 return FT_RRB_SEQ_DROP;
1087 }
1088
1089
1090 static void
1091 wpa_ft_rrb_seq_accept(struct wpa_authenticator *wpa_auth,
1092 struct ft_remote_seq *rkh_seq, const u8 *src_addr,
1093 const u8 *auth, size_t auth_len,
1094 const char *msgtype)
1095 {
1096 const u8 *f_seq;
1097 size_t f_seq_len;
1098 const struct ft_rrb_seq *msg_both;
1099 u32 msg_seq, msg_off, min_off, rkh_off;
1100 int minidx = 0;
1101 unsigned int i;
1102
1103 RRB_GET_AUTH(FT_RRB_SEQ, seq, msgtype, sizeof(*msg_both));
1104 msg_both = (const struct ft_rrb_seq *) f_seq;
1105
1106 msg_seq = le_to_host32(msg_both->seq);
1107
1108 if (rkh_seq->rx.num_last < FT_REMOTE_SEQ_BACKLOG) {
1109 rkh_seq->rx.last[rkh_seq->rx.num_last] = msg_seq;
1110 rkh_seq->rx.num_last++;
1111 return;
1112 }
1113
1114 rkh_off = rkh_seq->rx.last[rkh_seq->rx.offsetidx];
1115 for (i = 0; i < rkh_seq->rx.num_last; i++) {
1116 msg_off = rkh_seq->rx.last[i] - rkh_off;
1117 min_off = rkh_seq->rx.last[minidx] - rkh_off;
1118 if (msg_off < min_off && i != rkh_seq->rx.offsetidx)
1119 minidx = i;
1120 }
1121 rkh_seq->rx.last[rkh_seq->rx.offsetidx] = msg_seq;
1122 rkh_seq->rx.offsetidx = minidx;
1123
1124 return;
1125 out:
1126 /* RRB_GET_AUTH should never fail here as
1127 * wpa_ft_rrb_seq_chk() verified FT_RRB_SEQ presence. */
1128 wpa_printf(MSG_ERROR, "FT: %s() failed", __func__);
1129 }
1130
1131
1132 static int wpa_ft_new_seq(struct ft_remote_seq *rkh_seq,
1133 struct ft_rrb_seq *f_seq)
1134 {
1135 struct os_reltime now;
1136
1137 if (os_get_reltime(&now) < 0)
1138 return -1;
1139
1140 if (!rkh_seq->tx.dom) {
1141 if (random_get_bytes((u8 *) &rkh_seq->tx.seq,
1142 sizeof(rkh_seq->tx.seq))) {
1143 wpa_printf(MSG_ERROR,
1144 "FT: Failed to get random data for sequence number initialization");
1145 rkh_seq->tx.seq = now.usec;
1146 }
1147 if (random_get_bytes((u8 *) &rkh_seq->tx.dom,
1148 sizeof(rkh_seq->tx.dom))) {
1149 wpa_printf(MSG_ERROR,
1150 "FT: Failed to get random data for sequence number initialization");
1151 rkh_seq->tx.dom = now.usec;
1152 }
1153 rkh_seq->tx.dom |= 1;
1154 }
1155
1156 f_seq->dom = host_to_le32(rkh_seq->tx.dom);
1157 f_seq->seq = host_to_le32(rkh_seq->tx.seq);
1158 f_seq->ts = host_to_le32(now.sec);
1159
1160 rkh_seq->tx.seq++;
1161
1162 return 0;
1163 }
1164
1165
1166 struct wpa_ft_pmk_r0_sa {
1167 struct dl_list list;
1168 u8 pmk_r0[PMK_LEN_MAX];
1169 size_t pmk_r0_len;
1170 u8 pmk_r0_name[WPA_PMK_NAME_LEN];
1171 u8 spa[ETH_ALEN];
1172 int pairwise; /* Pairwise cipher suite, WPA_CIPHER_* */
1173 struct vlan_description *vlan;
1174 os_time_t expiration; /* 0 for no expiration */
1175 u8 *identity;
1176 size_t identity_len;
1177 u8 *radius_cui;
1178 size_t radius_cui_len;
1179 os_time_t session_timeout; /* 0 for no expiration */
1180 /* TODO: radius_class, EAP type */
1181 int pmk_r1_pushed;
1182 };
1183
1184 struct wpa_ft_pmk_r1_sa {
1185 struct dl_list list;
1186 u8 pmk_r1[PMK_LEN_MAX];
1187 size_t pmk_r1_len;
1188 u8 pmk_r1_name[WPA_PMK_NAME_LEN];
1189 u8 spa[ETH_ALEN];
1190 int pairwise; /* Pairwise cipher suite, WPA_CIPHER_* */
1191 struct vlan_description *vlan;
1192 u8 *identity;
1193 size_t identity_len;
1194 u8 *radius_cui;
1195 size_t radius_cui_len;
1196 os_time_t session_timeout; /* 0 for no expiration */
1197 /* TODO: radius_class, EAP type */
1198 };
1199
1200 struct wpa_ft_pmk_cache {
1201 struct dl_list pmk_r0; /* struct wpa_ft_pmk_r0_sa */
1202 struct dl_list pmk_r1; /* struct wpa_ft_pmk_r1_sa */
1203 };
1204
1205
1206 static void wpa_ft_expire_pmk_r0(void *eloop_ctx, void *timeout_ctx);
1207 static void wpa_ft_expire_pmk_r1(void *eloop_ctx, void *timeout_ctx);
1208
1209
1210 static void wpa_ft_free_pmk_r0(struct wpa_ft_pmk_r0_sa *r0)
1211 {
1212 if (!r0)
1213 return;
1214
1215 dl_list_del(&r0->list);
1216 eloop_cancel_timeout(wpa_ft_expire_pmk_r0, r0, NULL);
1217
1218 os_memset(r0->pmk_r0, 0, PMK_LEN_MAX);
1219 os_free(r0->vlan);
1220 os_free(r0->identity);
1221 os_free(r0->radius_cui);
1222 os_free(r0);
1223 }
1224
1225
1226 static void wpa_ft_expire_pmk_r0(void *eloop_ctx, void *timeout_ctx)
1227 {
1228 struct wpa_ft_pmk_r0_sa *r0 = eloop_ctx;
1229 struct os_reltime now;
1230 int expires_in;
1231 int session_timeout;
1232
1233 os_get_reltime(&now);
1234
1235 if (!r0)
1236 return;
1237
1238 expires_in = r0->expiration - now.sec;
1239 session_timeout = r0->session_timeout - now.sec;
1240 /* conditions to remove from cache:
1241 * a) r0->expiration is set and hit
1242 * -or-
1243 * b) r0->session_timeout is set and hit
1244 */
1245 if ((!r0->expiration || expires_in > 0) &&
1246 (!r0->session_timeout || session_timeout > 0)) {
1247 wpa_printf(MSG_ERROR,
1248 "FT: %s() called for non-expired entry %p",
1249 __func__, r0);
1250 eloop_cancel_timeout(wpa_ft_expire_pmk_r0, r0, NULL);
1251 if (r0->expiration && expires_in > 0)
1252 eloop_register_timeout(expires_in + 1, 0,
1253 wpa_ft_expire_pmk_r0, r0, NULL);
1254 if (r0->session_timeout && session_timeout > 0)
1255 eloop_register_timeout(session_timeout + 1, 0,
1256 wpa_ft_expire_pmk_r0, r0, NULL);
1257 return;
1258 }
1259
1260 wpa_ft_free_pmk_r0(r0);
1261 }
1262
1263
1264 static void wpa_ft_free_pmk_r1(struct wpa_ft_pmk_r1_sa *r1)
1265 {
1266 if (!r1)
1267 return;
1268
1269 dl_list_del(&r1->list);
1270 eloop_cancel_timeout(wpa_ft_expire_pmk_r1, r1, NULL);
1271
1272 os_memset(r1->pmk_r1, 0, PMK_LEN_MAX);
1273 os_free(r1->vlan);
1274 os_free(r1->identity);
1275 os_free(r1->radius_cui);
1276 os_free(r1);
1277 }
1278
1279
1280 static void wpa_ft_expire_pmk_r1(void *eloop_ctx, void *timeout_ctx)
1281 {
1282 struct wpa_ft_pmk_r1_sa *r1 = eloop_ctx;
1283
1284 wpa_ft_free_pmk_r1(r1);
1285 }
1286
1287
1288 struct wpa_ft_pmk_cache * wpa_ft_pmk_cache_init(void)
1289 {
1290 struct wpa_ft_pmk_cache *cache;
1291
1292 cache = os_zalloc(sizeof(*cache));
1293 if (cache) {
1294 dl_list_init(&cache->pmk_r0);
1295 dl_list_init(&cache->pmk_r1);
1296 }
1297
1298 return cache;
1299 }
1300
1301
1302 void wpa_ft_pmk_cache_deinit(struct wpa_ft_pmk_cache *cache)
1303 {
1304 struct wpa_ft_pmk_r0_sa *r0, *r0prev;
1305 struct wpa_ft_pmk_r1_sa *r1, *r1prev;
1306
1307 dl_list_for_each_safe(r0, r0prev, &cache->pmk_r0,
1308 struct wpa_ft_pmk_r0_sa, list)
1309 wpa_ft_free_pmk_r0(r0);
1310
1311 dl_list_for_each_safe(r1, r1prev, &cache->pmk_r1,
1312 struct wpa_ft_pmk_r1_sa, list)
1313 wpa_ft_free_pmk_r1(r1);
1314
1315 os_free(cache);
1316 }
1317
1318
1319 static int wpa_ft_store_pmk_r0(struct wpa_authenticator *wpa_auth,
1320 const u8 *spa, const u8 *pmk_r0,
1321 size_t pmk_r0_len,
1322 const u8 *pmk_r0_name, int pairwise,
1323 const struct vlan_description *vlan,
1324 int expires_in, int session_timeout,
1325 const u8 *identity, size_t identity_len,
1326 const u8 *radius_cui, size_t radius_cui_len)
1327 {
1328 struct wpa_ft_pmk_cache *cache = wpa_auth->ft_pmk_cache;
1329 struct wpa_ft_pmk_r0_sa *r0;
1330 struct os_reltime now;
1331
1332 /* TODO: add limit on number of entries in cache */
1333 os_get_reltime(&now);
1334
1335 r0 = os_zalloc(sizeof(*r0));
1336 if (r0 == NULL)
1337 return -1;
1338
1339 os_memcpy(r0->pmk_r0, pmk_r0, pmk_r0_len);
1340 r0->pmk_r0_len = pmk_r0_len;
1341 os_memcpy(r0->pmk_r0_name, pmk_r0_name, WPA_PMK_NAME_LEN);
1342 os_memcpy(r0->spa, spa, ETH_ALEN);
1343 r0->pairwise = pairwise;
1344 if (expires_in > 0)
1345 r0->expiration = now.sec + expires_in;
1346 if (vlan && vlan->notempty) {
1347 r0->vlan = os_zalloc(sizeof(*vlan));
1348 if (!r0->vlan) {
1349 bin_clear_free(r0, sizeof(*r0));
1350 return -1;
1351 }
1352 *r0->vlan = *vlan;
1353 }
1354 if (identity) {
1355 r0->identity = os_malloc(identity_len);
1356 if (r0->identity) {
1357 os_memcpy(r0->identity, identity, identity_len);
1358 r0->identity_len = identity_len;
1359 }
1360 }
1361 if (radius_cui) {
1362 r0->radius_cui = os_malloc(radius_cui_len);
1363 if (r0->radius_cui) {
1364 os_memcpy(r0->radius_cui, radius_cui, radius_cui_len);
1365 r0->radius_cui_len = radius_cui_len;
1366 }
1367 }
1368 if (session_timeout > 0)
1369 r0->session_timeout = now.sec + session_timeout;
1370
1371 dl_list_add(&cache->pmk_r0, &r0->list);
1372 if (expires_in > 0)
1373 eloop_register_timeout(expires_in + 1, 0, wpa_ft_expire_pmk_r0,
1374 r0, NULL);
1375 if (session_timeout > 0)
1376 eloop_register_timeout(session_timeout + 1, 0,
1377 wpa_ft_expire_pmk_r0, r0, NULL);
1378
1379 return 0;
1380 }
1381
1382
1383 static int wpa_ft_fetch_pmk_r0(struct wpa_authenticator *wpa_auth,
1384 const u8 *spa, const u8 *pmk_r0_name,
1385 const struct wpa_ft_pmk_r0_sa **r0_out)
1386 {
1387 struct wpa_ft_pmk_cache *cache = wpa_auth->ft_pmk_cache;
1388 struct wpa_ft_pmk_r0_sa *r0;
1389 struct os_reltime now;
1390
1391 os_get_reltime(&now);
1392 dl_list_for_each(r0, &cache->pmk_r0, struct wpa_ft_pmk_r0_sa, list) {
1393 if (os_memcmp(r0->spa, spa, ETH_ALEN) == 0 &&
1394 os_memcmp_const(r0->pmk_r0_name, pmk_r0_name,
1395 WPA_PMK_NAME_LEN) == 0) {
1396 *r0_out = r0;
1397 return 0;
1398 }
1399 }
1400
1401 *r0_out = NULL;
1402 return -1;
1403 }
1404
1405
1406 static int wpa_ft_store_pmk_r1(struct wpa_authenticator *wpa_auth,
1407 const u8 *spa, const u8 *pmk_r1,
1408 size_t pmk_r1_len,
1409 const u8 *pmk_r1_name, int pairwise,
1410 const struct vlan_description *vlan,
1411 int expires_in, int session_timeout,
1412 const u8 *identity, size_t identity_len,
1413 const u8 *radius_cui, size_t radius_cui_len)
1414 {
1415 struct wpa_ft_pmk_cache *cache = wpa_auth->ft_pmk_cache;
1416 int max_expires_in = wpa_auth->conf.r1_max_key_lifetime;
1417 struct wpa_ft_pmk_r1_sa *r1;
1418 struct os_reltime now;
1419
1420 /* TODO: limit on number of entries in cache */
1421 os_get_reltime(&now);
1422
1423 if (max_expires_in && (max_expires_in < expires_in || expires_in == 0))
1424 expires_in = max_expires_in;
1425
1426 r1 = os_zalloc(sizeof(*r1));
1427 if (r1 == NULL)
1428 return -1;
1429
1430 os_memcpy(r1->pmk_r1, pmk_r1, pmk_r1_len);
1431 r1->pmk_r1_len = pmk_r1_len;
1432 os_memcpy(r1->pmk_r1_name, pmk_r1_name, WPA_PMK_NAME_LEN);
1433 os_memcpy(r1->spa, spa, ETH_ALEN);
1434 r1->pairwise = pairwise;
1435 if (vlan && vlan->notempty) {
1436 r1->vlan = os_zalloc(sizeof(*vlan));
1437 if (!r1->vlan) {
1438 bin_clear_free(r1, sizeof(*r1));
1439 return -1;
1440 }
1441 *r1->vlan = *vlan;
1442 }
1443 if (identity) {
1444 r1->identity = os_malloc(identity_len);
1445 if (r1->identity) {
1446 os_memcpy(r1->identity, identity, identity_len);
1447 r1->identity_len = identity_len;
1448 }
1449 }
1450 if (radius_cui) {
1451 r1->radius_cui = os_malloc(radius_cui_len);
1452 if (r1->radius_cui) {
1453 os_memcpy(r1->radius_cui, radius_cui, radius_cui_len);
1454 r1->radius_cui_len = radius_cui_len;
1455 }
1456 }
1457 if (session_timeout > 0)
1458 r1->session_timeout = now.sec + session_timeout;
1459
1460 dl_list_add(&cache->pmk_r1, &r1->list);
1461
1462 if (expires_in > 0)
1463 eloop_register_timeout(expires_in + 1, 0, wpa_ft_expire_pmk_r1,
1464 r1, NULL);
1465 if (session_timeout > 0)
1466 eloop_register_timeout(session_timeout + 1, 0,
1467 wpa_ft_expire_pmk_r1, r1, NULL);
1468
1469 return 0;
1470 }
1471
1472
1473 static int wpa_ft_fetch_pmk_r1(struct wpa_authenticator *wpa_auth,
1474 const u8 *spa, const u8 *pmk_r1_name,
1475 u8 *pmk_r1, size_t *pmk_r1_len, int *pairwise,
1476 struct vlan_description *vlan,
1477 const u8 **identity, size_t *identity_len,
1478 const u8 **radius_cui, size_t *radius_cui_len,
1479 int *session_timeout)
1480 {
1481 struct wpa_ft_pmk_cache *cache = wpa_auth->ft_pmk_cache;
1482 struct wpa_ft_pmk_r1_sa *r1;
1483 struct os_reltime now;
1484
1485 os_get_reltime(&now);
1486
1487 dl_list_for_each(r1, &cache->pmk_r1, struct wpa_ft_pmk_r1_sa, list) {
1488 if (os_memcmp(r1->spa, spa, ETH_ALEN) == 0 &&
1489 os_memcmp_const(r1->pmk_r1_name, pmk_r1_name,
1490 WPA_PMK_NAME_LEN) == 0) {
1491 os_memcpy(pmk_r1, r1->pmk_r1, r1->pmk_r1_len);
1492 *pmk_r1_len = r1->pmk_r1_len;
1493 if (pairwise)
1494 *pairwise = r1->pairwise;
1495 if (vlan && r1->vlan)
1496 *vlan = *r1->vlan;
1497 if (vlan && !r1->vlan)
1498 os_memset(vlan, 0, sizeof(*vlan));
1499 if (identity && identity_len) {
1500 *identity = r1->identity;
1501 *identity_len = r1->identity_len;
1502 }
1503 if (radius_cui && radius_cui_len) {
1504 *radius_cui = r1->radius_cui;
1505 *radius_cui_len = r1->radius_cui_len;
1506 }
1507 if (session_timeout && r1->session_timeout > now.sec)
1508 *session_timeout = r1->session_timeout -
1509 now.sec;
1510 else if (session_timeout && r1->session_timeout)
1511 *session_timeout = 1;
1512 else if (session_timeout)
1513 *session_timeout = 0;
1514 return 0;
1515 }
1516 }
1517
1518 return -1;
1519 }
1520
1521
1522 static int wpa_ft_rrb_init_r0kh_seq(struct ft_remote_r0kh *r0kh)
1523 {
1524 if (r0kh->seq)
1525 return 0;
1526
1527 r0kh->seq = os_zalloc(sizeof(*r0kh->seq));
1528 if (!r0kh->seq) {
1529 wpa_printf(MSG_DEBUG, "FT: Failed to allocate r0kh->seq");
1530 return -1;
1531 }
1532
1533 dl_list_init(&r0kh->seq->rx.queue);
1534
1535 return 0;
1536 }
1537
1538
1539 static void wpa_ft_rrb_lookup_r0kh(struct wpa_authenticator *wpa_auth,
1540 const u8 *f_r0kh_id, size_t f_r0kh_id_len,
1541 struct ft_remote_r0kh **r0kh_out,
1542 struct ft_remote_r0kh **r0kh_wildcard)
1543 {
1544 struct ft_remote_r0kh *r0kh;
1545
1546 *r0kh_wildcard = NULL;
1547 *r0kh_out = NULL;
1548
1549 if (wpa_auth->conf.r0kh_list)
1550 r0kh = *wpa_auth->conf.r0kh_list;
1551 else
1552 r0kh = NULL;
1553 for (; r0kh; r0kh = r0kh->next) {
1554 if (r0kh->id_len == 1 && r0kh->id[0] == '*')
1555 *r0kh_wildcard = r0kh;
1556 if (f_r0kh_id && r0kh->id_len == f_r0kh_id_len &&
1557 os_memcmp_const(f_r0kh_id, r0kh->id, f_r0kh_id_len) == 0)
1558 *r0kh_out = r0kh;
1559 }
1560
1561 if (!*r0kh_out && !*r0kh_wildcard)
1562 wpa_printf(MSG_DEBUG, "FT: No matching R0KH found");
1563
1564 if (*r0kh_out && wpa_ft_rrb_init_r0kh_seq(*r0kh_out) < 0)
1565 *r0kh_out = NULL;
1566 }
1567
1568
1569 static int wpa_ft_rrb_init_r1kh_seq(struct ft_remote_r1kh *r1kh)
1570 {
1571 if (r1kh->seq)
1572 return 0;
1573
1574 r1kh->seq = os_zalloc(sizeof(*r1kh->seq));
1575 if (!r1kh->seq) {
1576 wpa_printf(MSG_DEBUG, "FT: Failed to allocate r1kh->seq");
1577 return -1;
1578 }
1579
1580 dl_list_init(&r1kh->seq->rx.queue);
1581
1582 return 0;
1583 }
1584
1585
1586 static void wpa_ft_rrb_lookup_r1kh(struct wpa_authenticator *wpa_auth,
1587 const u8 *f_r1kh_id,
1588 struct ft_remote_r1kh **r1kh_out,
1589 struct ft_remote_r1kh **r1kh_wildcard)
1590 {
1591 struct ft_remote_r1kh *r1kh;
1592
1593 *r1kh_wildcard = NULL;
1594 *r1kh_out = NULL;
1595
1596 if (wpa_auth->conf.r1kh_list)
1597 r1kh = *wpa_auth->conf.r1kh_list;
1598 else
1599 r1kh = NULL;
1600 for (; r1kh; r1kh = r1kh->next) {
1601 if (is_zero_ether_addr(r1kh->addr) &&
1602 is_zero_ether_addr(r1kh->id))
1603 *r1kh_wildcard = r1kh;
1604 if (f_r1kh_id &&
1605 os_memcmp_const(r1kh->id, f_r1kh_id, FT_R1KH_ID_LEN) == 0)
1606 *r1kh_out = r1kh;
1607 }
1608
1609 if (!*r1kh_out && !*r1kh_wildcard)
1610 wpa_printf(MSG_DEBUG, "FT: No matching R1KH found");
1611
1612 if (*r1kh_out && wpa_ft_rrb_init_r1kh_seq(*r1kh_out) < 0)
1613 *r1kh_out = NULL;
1614 }
1615
1616
1617 static int wpa_ft_rrb_check_r0kh(struct wpa_authenticator *wpa_auth,
1618 const u8 *f_r0kh_id, size_t f_r0kh_id_len)
1619 {
1620 if (f_r0kh_id_len != wpa_auth->conf.r0_key_holder_len ||
1621 os_memcmp_const(f_r0kh_id, wpa_auth->conf.r0_key_holder,
1622 f_r0kh_id_len) != 0)
1623 return -1;
1624
1625 return 0;
1626 }
1627
1628
1629 static int wpa_ft_rrb_check_r1kh(struct wpa_authenticator *wpa_auth,
1630 const u8 *f_r1kh_id)
1631 {
1632 if (os_memcmp_const(f_r1kh_id, wpa_auth->conf.r1_key_holder,
1633 FT_R1KH_ID_LEN) != 0)
1634 return -1;
1635
1636 return 0;
1637 }
1638
1639
1640 static void wpa_ft_rrb_del_r0kh(void *eloop_ctx, void *timeout_ctx)
1641 {
1642 struct wpa_authenticator *wpa_auth = eloop_ctx;
1643 struct ft_remote_r0kh *r0kh, *prev = NULL;
1644
1645 if (!wpa_auth->conf.r0kh_list)
1646 return;
1647
1648 for (r0kh = *wpa_auth->conf.r0kh_list; r0kh; r0kh = r0kh->next) {
1649 if (r0kh == timeout_ctx)
1650 break;
1651 prev = r0kh;
1652 }
1653 if (!r0kh)
1654 return;
1655 if (prev)
1656 prev->next = r0kh->next;
1657 else
1658 *wpa_auth->conf.r0kh_list = r0kh->next;
1659 if (r0kh->seq)
1660 wpa_ft_rrb_seq_flush(wpa_auth, r0kh->seq, 0);
1661 os_free(r0kh->seq);
1662 os_free(r0kh);
1663 }
1664
1665
1666 static void wpa_ft_rrb_r0kh_replenish(struct wpa_authenticator *wpa_auth,
1667 struct ft_remote_r0kh *r0kh, int timeout)
1668 {
1669 if (timeout > 0)
1670 eloop_replenish_timeout(timeout, 0, wpa_ft_rrb_del_r0kh,
1671 wpa_auth, r0kh);
1672 }
1673
1674
1675 static void wpa_ft_rrb_r0kh_timeout(struct wpa_authenticator *wpa_auth,
1676 struct ft_remote_r0kh *r0kh, int timeout)
1677 {
1678 eloop_cancel_timeout(wpa_ft_rrb_del_r0kh, wpa_auth, r0kh);
1679
1680 if (timeout > 0)
1681 eloop_register_timeout(timeout, 0, wpa_ft_rrb_del_r0kh,
1682 wpa_auth, r0kh);
1683 }
1684
1685
1686 static struct ft_remote_r0kh *
1687 wpa_ft_rrb_add_r0kh(struct wpa_authenticator *wpa_auth,
1688 struct ft_remote_r0kh *r0kh_wildcard,
1689 const u8 *src_addr, const u8 *r0kh_id, size_t id_len,
1690 int timeout)
1691 {
1692 struct ft_remote_r0kh *r0kh;
1693
1694 if (!wpa_auth->conf.r0kh_list)
1695 return NULL;
1696
1697 r0kh = os_zalloc(sizeof(*r0kh));
1698 if (!r0kh)
1699 return NULL;
1700
1701 if (src_addr)
1702 os_memcpy(r0kh->addr, src_addr, sizeof(r0kh->addr));
1703
1704 if (id_len > FT_R0KH_ID_MAX_LEN)
1705 id_len = FT_R0KH_ID_MAX_LEN;
1706 os_memcpy(r0kh->id, r0kh_id, id_len);
1707 r0kh->id_len = id_len;
1708
1709 os_memcpy(r0kh->key, r0kh_wildcard->key, sizeof(r0kh->key));
1710
1711 r0kh->next = *wpa_auth->conf.r0kh_list;
1712 *wpa_auth->conf.r0kh_list = r0kh;
1713
1714 if (timeout > 0)
1715 eloop_register_timeout(timeout, 0, wpa_ft_rrb_del_r0kh,
1716 wpa_auth, r0kh);
1717
1718 if (wpa_ft_rrb_init_r0kh_seq(r0kh) < 0)
1719 return NULL;
1720
1721 return r0kh;
1722 }
1723
1724
1725 static void wpa_ft_rrb_del_r1kh(void *eloop_ctx, void *timeout_ctx)
1726 {
1727 struct wpa_authenticator *wpa_auth = eloop_ctx;
1728 struct ft_remote_r1kh *r1kh, *prev = NULL;
1729
1730 if (!wpa_auth->conf.r1kh_list)
1731 return;
1732
1733 for (r1kh = *wpa_auth->conf.r1kh_list; r1kh; r1kh = r1kh->next) {
1734 if (r1kh == timeout_ctx)
1735 break;
1736 prev = r1kh;
1737 }
1738 if (!r1kh)
1739 return;
1740 if (prev)
1741 prev->next = r1kh->next;
1742 else
1743 *wpa_auth->conf.r1kh_list = r1kh->next;
1744 if (r1kh->seq)
1745 wpa_ft_rrb_seq_flush(wpa_auth, r1kh->seq, 0);
1746 os_free(r1kh->seq);
1747 os_free(r1kh);
1748 }
1749
1750
1751 static void wpa_ft_rrb_r1kh_replenish(struct wpa_authenticator *wpa_auth,
1752 struct ft_remote_r1kh *r1kh, int timeout)
1753 {
1754 if (timeout > 0)
1755 eloop_replenish_timeout(timeout, 0, wpa_ft_rrb_del_r1kh,
1756 wpa_auth, r1kh);
1757 }
1758
1759
1760 static struct ft_remote_r1kh *
1761 wpa_ft_rrb_add_r1kh(struct wpa_authenticator *wpa_auth,
1762 struct ft_remote_r1kh *r1kh_wildcard,
1763 const u8 *src_addr, const u8 *r1kh_id, int timeout)
1764 {
1765 struct ft_remote_r1kh *r1kh;
1766
1767 if (!wpa_auth->conf.r1kh_list)
1768 return NULL;
1769
1770 r1kh = os_zalloc(sizeof(*r1kh));
1771 if (!r1kh)
1772 return NULL;
1773
1774 os_memcpy(r1kh->addr, src_addr, sizeof(r1kh->addr));
1775 os_memcpy(r1kh->id, r1kh_id, sizeof(r1kh->id));
1776 os_memcpy(r1kh->key, r1kh_wildcard->key, sizeof(r1kh->key));
1777 r1kh->next = *wpa_auth->conf.r1kh_list;
1778 *wpa_auth->conf.r1kh_list = r1kh;
1779
1780 if (timeout > 0)
1781 eloop_register_timeout(timeout, 0, wpa_ft_rrb_del_r1kh,
1782 wpa_auth, r1kh);
1783
1784 if (wpa_ft_rrb_init_r1kh_seq(r1kh) < 0)
1785 return NULL;
1786
1787 return r1kh;
1788 }
1789
1790
1791 void wpa_ft_sta_deinit(struct wpa_state_machine *sm)
1792 {
1793 eloop_cancel_timeout(wpa_ft_expire_pull, sm, NULL);
1794 }
1795
1796
1797 static void wpa_ft_deinit_seq(struct wpa_authenticator *wpa_auth)
1798 {
1799 struct ft_remote_r0kh *r0kh;
1800 struct ft_remote_r1kh *r1kh;
1801
1802 eloop_cancel_timeout(wpa_ft_rrb_seq_timeout, wpa_auth, ELOOP_ALL_CTX);
1803
1804 if (wpa_auth->conf.r0kh_list)
1805 r0kh = *wpa_auth->conf.r0kh_list;
1806 else
1807 r0kh = NULL;
1808 for (; r0kh; r0kh = r0kh->next) {
1809 if (!r0kh->seq)
1810 continue;
1811 wpa_ft_rrb_seq_flush(wpa_auth, r0kh->seq, 0);
1812 os_free(r0kh->seq);
1813 r0kh->seq = NULL;
1814 }
1815
1816 if (wpa_auth->conf.r1kh_list)
1817 r1kh = *wpa_auth->conf.r1kh_list;
1818 else
1819 r1kh = NULL;
1820 for (; r1kh; r1kh = r1kh->next) {
1821 if (!r1kh->seq)
1822 continue;
1823 wpa_ft_rrb_seq_flush(wpa_auth, r1kh->seq, 0);
1824 os_free(r1kh->seq);
1825 r1kh->seq = NULL;
1826 }
1827 }
1828
1829
1830 static void wpa_ft_deinit_rkh_tmp(struct wpa_authenticator *wpa_auth)
1831 {
1832 struct ft_remote_r0kh *r0kh, *r0kh_next, *r0kh_prev = NULL;
1833 struct ft_remote_r1kh *r1kh, *r1kh_next, *r1kh_prev = NULL;
1834
1835 if (wpa_auth->conf.r0kh_list)
1836 r0kh = *wpa_auth->conf.r0kh_list;
1837 else
1838 r0kh = NULL;
1839 while (r0kh) {
1840 r0kh_next = r0kh->next;
1841 if (eloop_cancel_timeout(wpa_ft_rrb_del_r0kh, wpa_auth,
1842 r0kh) > 0) {
1843 if (r0kh_prev)
1844 r0kh_prev->next = r0kh_next;
1845 else
1846 *wpa_auth->conf.r0kh_list = r0kh_next;
1847 os_free(r0kh);
1848 } else {
1849 r0kh_prev = r0kh;
1850 }
1851 r0kh = r0kh_next;
1852 }
1853
1854 if (wpa_auth->conf.r1kh_list)
1855 r1kh = *wpa_auth->conf.r1kh_list;
1856 else
1857 r1kh = NULL;
1858 while (r1kh) {
1859 r1kh_next = r1kh->next;
1860 if (eloop_cancel_timeout(wpa_ft_rrb_del_r1kh, wpa_auth,
1861 r1kh) > 0) {
1862 if (r1kh_prev)
1863 r1kh_prev->next = r1kh_next;
1864 else
1865 *wpa_auth->conf.r1kh_list = r1kh_next;
1866 os_free(r1kh);
1867 } else {
1868 r1kh_prev = r1kh;
1869 }
1870 r1kh = r1kh_next;
1871 }
1872 }
1873
1874
1875 void wpa_ft_deinit(struct wpa_authenticator *wpa_auth)
1876 {
1877 wpa_ft_deinit_seq(wpa_auth);
1878 wpa_ft_deinit_rkh_tmp(wpa_auth);
1879 }
1880
1881
1882 static void wpa_ft_block_r0kh(struct wpa_authenticator *wpa_auth,
1883 const u8 *f_r0kh_id, size_t f_r0kh_id_len)
1884 {
1885 struct ft_remote_r0kh *r0kh, *r0kh_wildcard;
1886
1887 if (!wpa_auth->conf.rkh_neg_timeout)
1888 return;
1889
1890 wpa_ft_rrb_lookup_r0kh(wpa_auth, f_r0kh_id, f_r0kh_id_len,
1891 &r0kh, &r0kh_wildcard);
1892
1893 if (!r0kh_wildcard) {
1894 /* r0kh removed after neg_timeout and might need re-adding */
1895 return;
1896 }
1897
1898 wpa_hexdump(MSG_DEBUG, "FT: Blacklist R0KH-ID",
1899 f_r0kh_id, f_r0kh_id_len);
1900
1901 if (r0kh) {
1902 wpa_ft_rrb_r0kh_timeout(wpa_auth, r0kh,
1903 wpa_auth->conf.rkh_neg_timeout);
1904 os_memset(r0kh->addr, 0, ETH_ALEN);
1905 } else
1906 wpa_ft_rrb_add_r0kh(wpa_auth, r0kh_wildcard, NULL, f_r0kh_id,
1907 f_r0kh_id_len,
1908 wpa_auth->conf.rkh_neg_timeout);
1909 }
1910
1911
1912 static void wpa_ft_expire_pull(void *eloop_ctx, void *timeout_ctx)
1913 {
1914 struct wpa_state_machine *sm = eloop_ctx;
1915
1916 wpa_printf(MSG_DEBUG, "FT: Timeout pending pull request for " MACSTR,
1917 MAC2STR(sm->addr));
1918 if (sm->ft_pending_pull_left_retries <= 0)
1919 wpa_ft_block_r0kh(sm->wpa_auth, sm->r0kh_id, sm->r0kh_id_len);
1920
1921 /* cancel multiple timeouts */
1922 eloop_cancel_timeout(wpa_ft_expire_pull, sm, NULL);
1923 ft_finish_pull(sm);
1924 }
1925
1926
1927 static int wpa_ft_pull_pmk_r1(struct wpa_state_machine *sm,
1928 const u8 *ies, size_t ies_len,
1929 const u8 *pmk_r0_name)
1930 {
1931 struct ft_remote_r0kh *r0kh, *r0kh_wildcard;
1932 u8 *packet = NULL;
1933 const u8 *key, *f_r1kh_id = sm->wpa_auth->conf.r1_key_holder;
1934 size_t packet_len, key_len;
1935 struct ft_rrb_seq f_seq;
1936 int tsecs, tusecs, first;
1937 struct wpabuf *ft_pending_req_ies;
1938 int r0kh_timeout;
1939 struct tlv_list req_enc[] = {
1940 { .type = FT_RRB_PMK_R0_NAME, .len = WPA_PMK_NAME_LEN,
1941 .data = pmk_r0_name },
1942 { .type = FT_RRB_S1KH_ID, .len = ETH_ALEN,
1943 .data = sm->addr },
1944 { .type = FT_RRB_LAST_EMPTY, .len = 0, .data = NULL },
1945 };
1946 struct tlv_list req_auth[] = {
1947 { .type = FT_RRB_NONCE, .len = FT_RRB_NONCE_LEN,
1948 .data = sm->ft_pending_pull_nonce },
1949 { .type = FT_RRB_SEQ, .len = sizeof(f_seq),
1950 .data = (u8 *) &f_seq },
1951 { .type = FT_RRB_R0KH_ID, .len = sm->r0kh_id_len,
1952 .data = sm->r0kh_id },
1953 { .type = FT_RRB_R1KH_ID, .len = FT_R1KH_ID_LEN,
1954 .data = f_r1kh_id },
1955 { .type = FT_RRB_LAST_EMPTY, .len = 0, .data = NULL },
1956 };
1957
1958 if (sm->ft_pending_pull_left_retries <= 0)
1959 return -1;
1960 first = sm->ft_pending_pull_left_retries ==
1961 sm->wpa_auth->conf.rkh_pull_retries;
1962 sm->ft_pending_pull_left_retries--;
1963
1964 wpa_ft_rrb_lookup_r0kh(sm->wpa_auth, sm->r0kh_id, sm->r0kh_id_len,
1965 &r0kh, &r0kh_wildcard);
1966
1967 /* Keep r0kh sufficiently long in the list for seq num check */
1968 r0kh_timeout = sm->wpa_auth->conf.rkh_pull_timeout / 1000 +
1969 1 + ftRRBseqTimeout;
1970 if (r0kh) {
1971 wpa_ft_rrb_r0kh_replenish(sm->wpa_auth, r0kh, r0kh_timeout);
1972 } else if (r0kh_wildcard) {
1973 wpa_printf(MSG_DEBUG, "FT: Using wildcard R0KH-ID");
1974 /* r0kh->addr: updated by SEQ_RESP and wpa_ft_expire_pull */
1975 r0kh = wpa_ft_rrb_add_r0kh(sm->wpa_auth, r0kh_wildcard,
1976 r0kh_wildcard->addr,
1977 sm->r0kh_id, sm->r0kh_id_len,
1978 r0kh_timeout);
1979 }
1980 if (r0kh == NULL) {
1981 wpa_hexdump(MSG_DEBUG, "FT: Did not find R0KH-ID",
1982 sm->r0kh_id, sm->r0kh_id_len);
1983 return -1;
1984 }
1985 if (is_zero_ether_addr(r0kh->addr)) {
1986 wpa_hexdump(MSG_DEBUG, "FT: R0KH-ID is blacklisted",
1987 sm->r0kh_id, sm->r0kh_id_len);
1988 return -1;
1989 }
1990 if (os_memcmp(r0kh->addr, sm->wpa_auth->addr, ETH_ALEN) == 0) {
1991 wpa_printf(MSG_DEBUG,
1992 "FT: R0KH-ID points to self - no matching key available");
1993 return -1;
1994 }
1995
1996 key = r0kh->key;
1997 key_len = sizeof(r0kh->key);
1998
1999 wpa_printf(MSG_DEBUG, "FT: Send PMK-R1 pull request to remote R0KH "
2000 "address " MACSTR, MAC2STR(r0kh->addr));
2001
2002 if (r0kh->seq->rx.num_last == 0) {
2003 /* A sequence request will be sent out anyway when pull
2004 * response is received. Send it out now to avoid one RTT. */
2005 wpa_ft_rrb_seq_req(sm->wpa_auth, r0kh->seq, r0kh->addr,
2006 r0kh->id, r0kh->id_len, f_r1kh_id, key,
2007 key_len, NULL, 0, NULL, 0, NULL);
2008 }
2009
2010 if (first &&
2011 random_get_bytes(sm->ft_pending_pull_nonce, FT_RRB_NONCE_LEN) < 0) {
2012 wpa_printf(MSG_DEBUG, "FT: Failed to get random data for "
2013 "nonce");
2014 return -1;
2015 }
2016
2017 if (wpa_ft_new_seq(r0kh->seq, &f_seq) < 0) {
2018 wpa_printf(MSG_DEBUG, "FT: Failed to get seq num");
2019 return -1;
2020 }
2021
2022 if (wpa_ft_rrb_build(key, key_len, req_enc, NULL, req_auth, NULL,
2023 sm->wpa_auth->addr, FT_PACKET_R0KH_R1KH_PULL,
2024 &packet, &packet_len) < 0)
2025 return -1;
2026
2027 ft_pending_req_ies = wpabuf_alloc_copy(ies, ies_len);
2028 wpabuf_free(sm->ft_pending_req_ies);
2029 sm->ft_pending_req_ies = ft_pending_req_ies;
2030 if (!sm->ft_pending_req_ies) {
2031 os_free(packet);
2032 return -1;
2033 }
2034
2035 tsecs = sm->wpa_auth->conf.rkh_pull_timeout / 1000;
2036 tusecs = (sm->wpa_auth->conf.rkh_pull_timeout % 1000) * 1000;
2037 eloop_register_timeout(tsecs, tusecs, wpa_ft_expire_pull, sm, NULL);
2038
2039 wpa_ft_rrb_oui_send(sm->wpa_auth, r0kh->addr, FT_PACKET_R0KH_R1KH_PULL,
2040 packet, packet_len);
2041
2042 os_free(packet);
2043
2044 return 0;
2045 }
2046
2047
2048 int wpa_ft_store_pmk_fils(struct wpa_state_machine *sm,
2049 const u8 *pmk_r0, const u8 *pmk_r0_name)
2050 {
2051 int expires_in = sm->wpa_auth->conf.r0_key_lifetime;
2052 struct vlan_description vlan;
2053 const u8 *identity, *radius_cui;
2054 size_t identity_len, radius_cui_len;
2055 int session_timeout;
2056 size_t pmk_r0_len = wpa_key_mgmt_sha384(sm->wpa_key_mgmt) ?
2057 SHA384_MAC_LEN : PMK_LEN;
2058
2059 if (wpa_ft_get_vlan(sm->wpa_auth, sm->addr, &vlan) < 0) {
2060 wpa_printf(MSG_DEBUG, "FT: vlan not available for STA " MACSTR,
2061 MAC2STR(sm->addr));
2062 return -1;
2063 }
2064
2065 identity_len = wpa_ft_get_identity(sm->wpa_auth, sm->addr, &identity);
2066 radius_cui_len = wpa_ft_get_radius_cui(sm->wpa_auth, sm->addr,
2067 &radius_cui);
2068 session_timeout = wpa_ft_get_session_timeout(sm->wpa_auth, sm->addr);
2069
2070 return wpa_ft_store_pmk_r0(sm->wpa_auth, sm->addr, pmk_r0, pmk_r0_len,
2071 pmk_r0_name, sm->pairwise, &vlan, expires_in,
2072 session_timeout, identity, identity_len,
2073 radius_cui, radius_cui_len);
2074 }
2075
2076
2077 int wpa_auth_derive_ptk_ft(struct wpa_state_machine *sm, struct wpa_ptk *ptk)
2078 {
2079 u8 pmk_r0[PMK_LEN_MAX], pmk_r0_name[WPA_PMK_NAME_LEN];
2080 size_t pmk_r0_len = wpa_key_mgmt_sha384(sm->wpa_key_mgmt) ?
2081 SHA384_MAC_LEN : PMK_LEN;
2082 size_t pmk_r1_len = pmk_r0_len;
2083 u8 pmk_r1[PMK_LEN_MAX];
2084 u8 ptk_name[WPA_PMK_NAME_LEN];
2085 const u8 *mdid = sm->wpa_auth->conf.mobility_domain;
2086 const u8 *r0kh = sm->wpa_auth->conf.r0_key_holder;
2087 size_t r0kh_len = sm->wpa_auth->conf.r0_key_holder_len;
2088 const u8 *r1kh = sm->wpa_auth->conf.r1_key_holder;
2089 const u8 *ssid = sm->wpa_auth->conf.ssid;
2090 size_t ssid_len = sm->wpa_auth->conf.ssid_len;
2091 int psk_local = sm->wpa_auth->conf.ft_psk_generate_local;
2092 int expires_in = sm->wpa_auth->conf.r0_key_lifetime;
2093 struct vlan_description vlan;
2094 const u8 *identity, *radius_cui;
2095 size_t identity_len, radius_cui_len;
2096 int session_timeout;
2097
2098 if (sm->xxkey_len == 0) {
2099 wpa_printf(MSG_DEBUG, "FT: XXKey not available for key "
2100 "derivation");
2101 return -1;
2102 }
2103
2104 if (wpa_ft_get_vlan(sm->wpa_auth, sm->addr, &vlan) < 0) {
2105 wpa_printf(MSG_DEBUG, "FT: vlan not available for STA " MACSTR,
2106 MAC2STR(sm->addr));
2107 return -1;
2108 }
2109
2110 identity_len = wpa_ft_get_identity(sm->wpa_auth, sm->addr, &identity);
2111 radius_cui_len = wpa_ft_get_radius_cui(sm->wpa_auth, sm->addr,
2112 &radius_cui);
2113 session_timeout = wpa_ft_get_session_timeout(sm->wpa_auth, sm->addr);
2114
2115 if (wpa_derive_pmk_r0(sm->xxkey, sm->xxkey_len, ssid, ssid_len, mdid,
2116 r0kh, r0kh_len, sm->addr,
2117 pmk_r0, pmk_r0_name,
2118 wpa_key_mgmt_sha384(sm->wpa_key_mgmt)) < 0)
2119 return -1;
2120 wpa_hexdump_key(MSG_DEBUG, "FT: PMK-R0", pmk_r0, pmk_r0_len);
2121 wpa_hexdump(MSG_DEBUG, "FT: PMKR0Name", pmk_r0_name, WPA_PMK_NAME_LEN);
2122 if (!psk_local || !wpa_key_mgmt_ft_psk(sm->wpa_key_mgmt))
2123 wpa_ft_store_pmk_r0(sm->wpa_auth, sm->addr, pmk_r0, pmk_r0_len,
2124 pmk_r0_name,
2125 sm->pairwise, &vlan, expires_in,
2126 session_timeout, identity, identity_len,
2127 radius_cui, radius_cui_len);
2128
2129 if (wpa_derive_pmk_r1(pmk_r0, pmk_r0_len, pmk_r0_name, r1kh, sm->addr,
2130 pmk_r1, sm->pmk_r1_name) < 0)
2131 return -1;
2132 wpa_hexdump_key(MSG_DEBUG, "FT: PMK-R1", pmk_r1, pmk_r1_len);
2133 wpa_hexdump(MSG_DEBUG, "FT: PMKR1Name", sm->pmk_r1_name,
2134 WPA_PMK_NAME_LEN);
2135 if (!psk_local || !wpa_key_mgmt_ft_psk(sm->wpa_key_mgmt))
2136 wpa_ft_store_pmk_r1(sm->wpa_auth, sm->addr, pmk_r1, pmk_r1_len,
2137 sm->pmk_r1_name, sm->pairwise, &vlan,
2138 expires_in, session_timeout, identity,
2139 identity_len, radius_cui, radius_cui_len);
2140
2141 return wpa_pmk_r1_to_ptk(pmk_r1, pmk_r1_len, sm->SNonce, sm->ANonce,
2142 sm->addr, sm->wpa_auth->addr, sm->pmk_r1_name,
2143 ptk, ptk_name, sm->wpa_key_mgmt, sm->pairwise);
2144 }
2145
2146
2147 static inline int wpa_auth_get_seqnum(struct wpa_authenticator *wpa_auth,
2148 const u8 *addr, int idx, u8 *seq)
2149 {
2150 if (wpa_auth->cb->get_seqnum == NULL)
2151 return -1;
2152 return wpa_auth->cb->get_seqnum(wpa_auth->cb_ctx, addr, idx, seq);
2153 }
2154
2155
2156 static u8 * wpa_ft_gtk_subelem(struct wpa_state_machine *sm, size_t *len)
2157 {
2158 u8 *subelem;
2159 struct wpa_group *gsm = sm->group;
2160 size_t subelem_len, pad_len;
2161 const u8 *key;
2162 size_t key_len;
2163 u8 keybuf[32];
2164 const u8 *kek;
2165 size_t kek_len;
2166
2167 if (wpa_key_mgmt_fils(sm->wpa_key_mgmt)) {
2168 kek = sm->PTK.kek2;
2169 kek_len = sm->PTK.kek2_len;
2170 } else {
2171 kek = sm->PTK.kek;
2172 kek_len = sm->PTK.kek_len;
2173 }
2174
2175 key_len = gsm->GTK_len;
2176 if (key_len > sizeof(keybuf))
2177 return NULL;
2178
2179 /*
2180 * Pad key for AES Key Wrap if it is not multiple of 8 bytes or is less
2181 * than 16 bytes.
2182 */
2183 pad_len = key_len % 8;
2184 if (pad_len)
2185 pad_len = 8 - pad_len;
2186 if (key_len + pad_len < 16)
2187 pad_len += 8;
2188 if (pad_len && key_len < sizeof(keybuf)) {
2189 os_memcpy(keybuf, gsm->GTK[gsm->GN - 1], key_len);
2190 os_memset(keybuf + key_len, 0, pad_len);
2191 keybuf[key_len] = 0xdd;
2192 key_len += pad_len;
2193 key = keybuf;
2194 } else
2195 key = gsm->GTK[gsm->GN - 1];
2196
2197 /*
2198 * Sub-elem ID[1] | Length[1] | Key Info[2] | Key Length[1] | RSC[8] |
2199 * Key[5..32].
2200 */
2201 subelem_len = 13 + key_len + 8;
2202 subelem = os_zalloc(subelem_len);
2203 if (subelem == NULL)
2204 return NULL;
2205
2206 subelem[0] = FTIE_SUBELEM_GTK;
2207 subelem[1] = 11 + key_len + 8;
2208 /* Key ID in B0-B1 of Key Info */
2209 WPA_PUT_LE16(&subelem[2], gsm->GN & 0x03);
2210 subelem[4] = gsm->GTK_len;
2211 wpa_auth_get_seqnum(sm->wpa_auth, NULL, gsm->GN, subelem + 5);
2212 if (aes_wrap(kek, kek_len, key_len / 8, key, subelem + 13)) {
2213 wpa_printf(MSG_DEBUG,
2214 "FT: GTK subelem encryption failed: kek_len=%d",
2215 (int) kek_len);
2216 os_free(subelem);
2217 return NULL;
2218 }
2219
2220 *len = subelem_len;
2221 return subelem;
2222 }
2223
2224
2225 #ifdef CONFIG_IEEE80211W
2226 static u8 * wpa_ft_igtk_subelem(struct wpa_state_machine *sm, size_t *len)
2227 {
2228 u8 *subelem, *pos;
2229 struct wpa_group *gsm = sm->group;
2230 size_t subelem_len;
2231 const u8 *kek;
2232 size_t kek_len;
2233 size_t igtk_len;
2234
2235 if (wpa_key_mgmt_fils(sm->wpa_key_mgmt)) {
2236 kek = sm->PTK.kek2;
2237 kek_len = sm->PTK.kek2_len;
2238 } else {
2239 kek = sm->PTK.kek;
2240 kek_len = sm->PTK.kek_len;
2241 }
2242
2243 igtk_len = wpa_cipher_key_len(sm->wpa_auth->conf.group_mgmt_cipher);
2244
2245 /* Sub-elem ID[1] | Length[1] | KeyID[2] | IPN[6] | Key Length[1] |
2246 * Key[16+8] */
2247 subelem_len = 1 + 1 + 2 + 6 + 1 + igtk_len + 8;
2248 subelem = os_zalloc(subelem_len);
2249 if (subelem == NULL)
2250 return NULL;
2251
2252 pos = subelem;
2253 *pos++ = FTIE_SUBELEM_IGTK;
2254 *pos++ = subelem_len - 2;
2255 WPA_PUT_LE16(pos, gsm->GN_igtk);
2256 pos += 2;
2257 wpa_auth_get_seqnum(sm->wpa_auth, NULL, gsm->GN_igtk, pos);
2258 pos += 6;
2259 *pos++ = igtk_len;
2260 if (aes_wrap(kek, kek_len, igtk_len / 8,
2261 gsm->IGTK[gsm->GN_igtk - 4], pos)) {
2262 wpa_printf(MSG_DEBUG,
2263 "FT: IGTK subelem encryption failed: kek_len=%d",
2264 (int) kek_len);
2265 os_free(subelem);
2266 return NULL;
2267 }
2268
2269 *len = subelem_len;
2270 return subelem;
2271 }
2272 #endif /* CONFIG_IEEE80211W */
2273
2274
2275 static u8 * wpa_ft_process_rdie(struct wpa_state_machine *sm,
2276 u8 *pos, u8 *end, u8 id, u8 descr_count,
2277 const u8 *ies, size_t ies_len)
2278 {
2279 struct ieee802_11_elems parse;
2280 struct rsn_rdie *rdie;
2281
2282 wpa_printf(MSG_DEBUG, "FT: Resource Request: id=%d descr_count=%d",
2283 id, descr_count);
2284 wpa_hexdump(MSG_MSGDUMP, "FT: Resource descriptor IE(s)",
2285 ies, ies_len);
2286
2287 if (end - pos < (int) sizeof(*rdie)) {
2288 wpa_printf(MSG_ERROR, "FT: Not enough room for response RDIE");
2289 return pos;
2290 }
2291
2292 *pos++ = WLAN_EID_RIC_DATA;
2293 *pos++ = sizeof(*rdie);
2294 rdie = (struct rsn_rdie *) pos;
2295 rdie->id = id;
2296 rdie->descr_count = 0;
2297 rdie->status_code = host_to_le16(WLAN_STATUS_SUCCESS);
2298 pos += sizeof(*rdie);
2299
2300 if (ieee802_11_parse_elems((u8 *) ies, ies_len, &parse, 1) ==
2301 ParseFailed) {
2302 wpa_printf(MSG_DEBUG, "FT: Failed to parse request IEs");
2303 rdie->status_code =
2304 host_to_le16(WLAN_STATUS_UNSPECIFIED_FAILURE);
2305 return pos;
2306 }
2307
2308 if (parse.wmm_tspec) {
2309 struct wmm_tspec_element *tspec;
2310
2311 if (parse.wmm_tspec_len + 2 < (int) sizeof(*tspec)) {
2312 wpa_printf(MSG_DEBUG, "FT: Too short WMM TSPEC IE "
2313 "(%d)", (int) parse.wmm_tspec_len);
2314 rdie->status_code =
2315 host_to_le16(WLAN_STATUS_UNSPECIFIED_FAILURE);
2316 return pos;
2317 }
2318 if (end - pos < (int) sizeof(*tspec)) {
2319 wpa_printf(MSG_ERROR, "FT: Not enough room for "
2320 "response TSPEC");
2321 rdie->status_code =
2322 host_to_le16(WLAN_STATUS_UNSPECIFIED_FAILURE);
2323 return pos;
2324 }
2325 tspec = (struct wmm_tspec_element *) pos;
2326 os_memcpy(tspec, parse.wmm_tspec - 2, sizeof(*tspec));
2327 }
2328
2329 #ifdef NEED_AP_MLME
2330 if (parse.wmm_tspec && sm->wpa_auth->conf.ap_mlme) {
2331 int res;
2332
2333 res = wmm_process_tspec((struct wmm_tspec_element *) pos);
2334 wpa_printf(MSG_DEBUG, "FT: ADDTS processing result: %d", res);
2335 if (res == WMM_ADDTS_STATUS_INVALID_PARAMETERS)
2336 rdie->status_code =
2337 host_to_le16(WLAN_STATUS_INVALID_PARAMETERS);
2338 else if (res == WMM_ADDTS_STATUS_REFUSED)
2339 rdie->status_code =
2340 host_to_le16(WLAN_STATUS_REQUEST_DECLINED);
2341 else {
2342 /* TSPEC accepted; include updated TSPEC in response */
2343 rdie->descr_count = 1;
2344 pos += sizeof(struct wmm_tspec_element);
2345 }
2346 return pos;
2347 }
2348 #endif /* NEED_AP_MLME */
2349
2350 if (parse.wmm_tspec && !sm->wpa_auth->conf.ap_mlme) {
2351 int res;
2352
2353 res = wpa_ft_add_tspec(sm->wpa_auth, sm->addr, pos,
2354 sizeof(struct wmm_tspec_element));
2355 if (res >= 0) {
2356 if (res)
2357 rdie->status_code = host_to_le16(res);
2358 else {
2359 /* TSPEC accepted; include updated TSPEC in
2360 * response */
2361 rdie->descr_count = 1;
2362 pos += sizeof(struct wmm_tspec_element);
2363 }
2364 return pos;
2365 }
2366 }
2367
2368 wpa_printf(MSG_DEBUG, "FT: No supported resource requested");
2369 rdie->status_code = host_to_le16(WLAN_STATUS_UNSPECIFIED_FAILURE);
2370 return pos;
2371 }
2372
2373
2374 static u8 * wpa_ft_process_ric(struct wpa_state_machine *sm, u8 *pos, u8 *end,
2375 const u8 *ric, size_t ric_len)
2376 {
2377 const u8 *rpos, *start;
2378 const struct rsn_rdie *rdie;
2379
2380 wpa_hexdump(MSG_MSGDUMP, "FT: RIC Request", ric, ric_len);
2381
2382 rpos = ric;
2383 while (rpos + sizeof(*rdie) < ric + ric_len) {
2384 if (rpos[0] != WLAN_EID_RIC_DATA || rpos[1] < sizeof(*rdie) ||
2385 rpos + 2 + rpos[1] > ric + ric_len)
2386 break;
2387 rdie = (const struct rsn_rdie *) (rpos + 2);
2388 rpos += 2 + rpos[1];
2389 start = rpos;
2390
2391 while (rpos + 2 <= ric + ric_len &&
2392 rpos + 2 + rpos[1] <= ric + ric_len) {
2393 if (rpos[0] == WLAN_EID_RIC_DATA)
2394 break;
2395 rpos += 2 + rpos[1];
2396 }
2397 pos = wpa_ft_process_rdie(sm, pos, end, rdie->id,
2398 rdie->descr_count,
2399 start, rpos - start);
2400 }
2401
2402 return pos;
2403 }
2404
2405
2406 u8 * wpa_sm_write_assoc_resp_ies(struct wpa_state_machine *sm, u8 *pos,
2407 size_t max_len, int auth_alg,
2408 const u8 *req_ies, size_t req_ies_len)
2409 {
2410 u8 *end, *mdie, *ftie, *rsnie = NULL, *r0kh_id, *subelem = NULL;
2411 u8 *fte_mic, *elem_count;
2412 size_t mdie_len, ftie_len, rsnie_len = 0, r0kh_id_len, subelem_len = 0;
2413 int res;
2414 struct wpa_auth_config *conf;
2415 struct wpa_ft_ies parse;
2416 u8 *ric_start;
2417 u8 *anonce, *snonce;
2418 const u8 *kck;
2419 size_t kck_len;
2420 int use_sha384;
2421
2422 if (sm == NULL)
2423 return pos;
2424
2425 use_sha384 = wpa_key_mgmt_sha384(sm->wpa_key_mgmt);
2426 conf = &sm->wpa_auth->conf;
2427
2428 if (!wpa_key_mgmt_ft(sm->wpa_key_mgmt))
2429 return pos;
2430
2431 end = pos + max_len;
2432
2433 if (auth_alg == WLAN_AUTH_FT ||
2434 ((auth_alg == WLAN_AUTH_FILS_SK ||
2435 auth_alg == WLAN_AUTH_FILS_SK_PFS ||
2436 auth_alg == WLAN_AUTH_FILS_PK) &&
2437 (sm->wpa_key_mgmt & (WPA_KEY_MGMT_FT_FILS_SHA256 |
2438 WPA_KEY_MGMT_FT_FILS_SHA384)))) {
2439 if (!sm->pmk_r1_name_valid) {
2440 wpa_printf(MSG_ERROR,
2441 "FT: PMKR1Name is not valid for Assoc Resp RSNE");
2442 return NULL;
2443 }
2444 wpa_hexdump(MSG_DEBUG, "FT: PMKR1Name for Assoc Resp RSNE",
2445 sm->pmk_r1_name, WPA_PMK_NAME_LEN);
2446 /*
2447 * RSN (only present if this is a Reassociation Response and
2448 * part of a fast BSS transition; or if this is a
2449 * (Re)Association Response frame during an FT initial mobility
2450 * domain association using FILS)
2451 */
2452 res = wpa_write_rsn_ie(conf, pos, end - pos, sm->pmk_r1_name);
2453 if (res < 0)
2454 return NULL;
2455 rsnie = pos;
2456 rsnie_len = res;
2457 pos += res;
2458 }
2459
2460 /* Mobility Domain Information */
2461 res = wpa_write_mdie(conf, pos, end - pos);
2462 if (res < 0)
2463 return NULL;
2464 mdie = pos;
2465 mdie_len = res;
2466 pos += res;
2467
2468 /* Fast BSS Transition Information */
2469 if (auth_alg == WLAN_AUTH_FT) {
2470 subelem = wpa_ft_gtk_subelem(sm, &subelem_len);
2471 if (!subelem) {
2472 wpa_printf(MSG_DEBUG,
2473 "FT: Failed to add GTK subelement");
2474 return NULL;
2475 }
2476 r0kh_id = sm->r0kh_id;
2477 r0kh_id_len = sm->r0kh_id_len;
2478 anonce = sm->ANonce;
2479 snonce = sm->SNonce;
2480 #ifdef CONFIG_IEEE80211W
2481 if (sm->mgmt_frame_prot) {
2482 u8 *igtk;
2483 size_t igtk_len;
2484 u8 *nbuf;
2485 igtk = wpa_ft_igtk_subelem(sm, &igtk_len);
2486 if (igtk == NULL) {
2487 wpa_printf(MSG_DEBUG,
2488 "FT: Failed to add IGTK subelement");
2489 os_free(subelem);
2490 return NULL;
2491 }
2492 nbuf = os_realloc(subelem, subelem_len + igtk_len);
2493 if (nbuf == NULL) {
2494 os_free(subelem);
2495 os_free(igtk);
2496 return NULL;
2497 }
2498 subelem = nbuf;
2499 os_memcpy(subelem + subelem_len, igtk, igtk_len);
2500 subelem_len += igtk_len;
2501 os_free(igtk);
2502 }
2503 #endif /* CONFIG_IEEE80211W */
2504 #ifdef CONFIG_OCV
2505 if (wpa_auth_uses_ocv(sm)) {
2506 struct wpa_channel_info ci;
2507 u8 *nbuf, *ocipos;
2508
2509 if (wpa_channel_info(sm->wpa_auth, &ci) != 0) {
2510 wpa_printf(MSG_WARNING,
2511 "Failed to get channel info for OCI element");
2512 os_free(subelem);
2513 return NULL;
2514 }
2515
2516 subelem_len += 2 + OCV_OCI_LEN;
2517 nbuf = os_realloc(subelem, subelem_len);
2518 if (!nbuf) {
2519 os_free(subelem);
2520 return NULL;
2521 }
2522 subelem = nbuf;
2523
2524 ocipos = subelem + subelem_len - 2 - OCV_OCI_LEN;
2525 *ocipos++ = FTIE_SUBELEM_OCI;
2526 *ocipos++ = OCV_OCI_LEN;
2527 if (ocv_insert_oci(&ci, &ocipos) < 0) {
2528 os_free(subelem);
2529 return NULL;
2530 }
2531 }
2532 #endif /* CONFIG_OCV */
2533 } else {
2534 r0kh_id = conf->r0_key_holder;
2535 r0kh_id_len = conf->r0_key_holder_len;
2536 anonce = NULL;
2537 snonce = NULL;
2538 }
2539 res = wpa_write_ftie(conf, use_sha384, r0kh_id, r0kh_id_len,
2540 anonce, snonce, pos, end - pos,
2541 subelem, subelem_len);
2542 os_free(subelem);
2543 if (res < 0)
2544 return NULL;
2545 ftie = pos;
2546 ftie_len = res;
2547 pos += res;
2548
2549 if (use_sha384) {
2550 struct rsn_ftie_sha384 *_ftie =
2551 (struct rsn_ftie_sha384 *) (ftie + 2);
2552
2553 fte_mic = _ftie->mic;
2554 elem_count = &_ftie->mic_control[1];
2555 } else {
2556 struct rsn_ftie *_ftie = (struct rsn_ftie *) (ftie + 2);
2557
2558 fte_mic = _ftie->mic;
2559 elem_count = &_ftie->mic_control[1];
2560 }
2561 if (auth_alg == WLAN_AUTH_FT)
2562 *elem_count = 3; /* Information element count */
2563
2564 ric_start = pos;
2565 if (wpa_ft_parse_ies(req_ies, req_ies_len, &parse, use_sha384) == 0
2566 && parse.ric) {
2567 pos = wpa_ft_process_ric(sm, pos, end, parse.ric,
2568 parse.ric_len);
2569 if (auth_alg == WLAN_AUTH_FT)
2570 *elem_count +=
2571 ieee802_11_ie_count(ric_start,
2572 pos - ric_start);
2573 }
2574 if (ric_start == pos)
2575 ric_start = NULL;
2576
2577 if (wpa_key_mgmt_fils(sm->wpa_key_mgmt)) {
2578 kck = sm->PTK.kck2;
2579 kck_len = sm->PTK.kck2_len;
2580 } else {
2581 kck = sm->PTK.kck;
2582 kck_len = sm->PTK.kck_len;
2583 }
2584 if (auth_alg == WLAN_AUTH_FT &&
2585 wpa_ft_mic(kck, kck_len, sm->addr, sm->wpa_auth->addr, 6,
2586 mdie, mdie_len, ftie, ftie_len,
2587 rsnie, rsnie_len,
2588 ric_start, ric_start ? pos - ric_start : 0,
2589 fte_mic) < 0) {
2590 wpa_printf(MSG_DEBUG, "FT: Failed to calculate MIC");
2591 return NULL;
2592 }
2593
2594 os_free(sm->assoc_resp_ftie);
2595 sm->assoc_resp_ftie = os_malloc(ftie_len);
2596 if (!sm->assoc_resp_ftie)
2597 return NULL;
2598 os_memcpy(sm->assoc_resp_ftie, ftie, ftie_len);
2599
2600 return pos;
2601 }
2602
2603
2604 static inline int wpa_auth_set_key(struct wpa_authenticator *wpa_auth,
2605 int vlan_id,
2606 enum wpa_alg alg, const u8 *addr, int idx,
2607 u8 *key, size_t key_len)
2608 {
2609 if (wpa_auth->cb->set_key == NULL)
2610 return -1;
2611 return wpa_auth->cb->set_key(wpa_auth->cb_ctx, vlan_id, alg, addr, idx,
2612 key, key_len);
2613 }
2614
2615
2616 void wpa_ft_install_ptk(struct wpa_state_machine *sm)
2617 {
2618 enum wpa_alg alg;
2619 int klen;
2620
2621 /* MLME-SETKEYS.request(PTK) */
2622 alg = wpa_cipher_to_alg(sm->pairwise);
2623 klen = wpa_cipher_key_len(sm->pairwise);
2624 if (!wpa_cipher_valid_pairwise(sm->pairwise)) {
2625 wpa_printf(MSG_DEBUG, "FT: Unknown pairwise alg 0x%x - skip "
2626 "PTK configuration", sm->pairwise);
2627 return;
2628 }
2629
2630 if (sm->tk_already_set) {
2631 /* Must avoid TK reconfiguration to prevent clearing of TX/RX
2632 * PN in the driver */
2633 wpa_printf(MSG_DEBUG,
2634 "FT: Do not re-install same PTK to the driver");
2635 return;
2636 }
2637
2638 /* FIX: add STA entry to kernel/driver here? The set_key will fail
2639 * most likely without this.. At the moment, STA entry is added only
2640 * after association has been completed. This function will be called
2641 * again after association to get the PTK configured, but that could be
2642 * optimized by adding the STA entry earlier.
2643 */
2644 if (wpa_auth_set_key(sm->wpa_auth, 0, alg, sm->addr, 0,
2645 sm->PTK.tk, klen))
2646 return;
2647
2648 /* FIX: MLME-SetProtection.Request(TA, Tx_Rx) */
2649 sm->pairwise_set = TRUE;
2650 sm->tk_already_set = TRUE;
2651 }
2652
2653
2654 /* Derive PMK-R1 from PSK, check all available PSK */
2655 static int wpa_ft_psk_pmk_r1(struct wpa_state_machine *sm,
2656 const u8 *req_pmk_r1_name,
2657 u8 *out_pmk_r1, int *out_pairwise,
2658 struct vlan_description *out_vlan,
2659 const u8 **out_identity, size_t *out_identity_len,
2660 const u8 **out_radius_cui,
2661 size_t *out_radius_cui_len,
2662 int *out_session_timeout)
2663 {
2664 const u8 *pmk = NULL;
2665 u8 pmk_r0[PMK_LEN], pmk_r0_name[WPA_PMK_NAME_LEN];
2666 u8 pmk_r1[PMK_LEN], pmk_r1_name[WPA_PMK_NAME_LEN];
2667 struct wpa_authenticator *wpa_auth = sm->wpa_auth;
2668 const u8 *mdid = wpa_auth->conf.mobility_domain;
2669 const u8 *r0kh = sm->r0kh_id;
2670 size_t r0kh_len = sm->r0kh_id_len;
2671 const u8 *r1kh = wpa_auth->conf.r1_key_holder;
2672 const u8 *ssid = wpa_auth->conf.ssid;
2673 size_t ssid_len = wpa_auth->conf.ssid_len;
2674 int pairwise;
2675
2676 pairwise = sm->pairwise;
2677
2678 for (;;) {
2679 pmk = wpa_ft_get_psk(wpa_auth, sm->addr, sm->p2p_dev_addr,
2680 pmk);
2681 if (pmk == NULL)
2682 break;
2683
2684 if (wpa_derive_pmk_r0(pmk, PMK_LEN, ssid, ssid_len, mdid, r0kh,
2685 r0kh_len, sm->addr,
2686 pmk_r0, pmk_r0_name, 0) < 0 ||
2687 wpa_derive_pmk_r1(pmk_r0, PMK_LEN, pmk_r0_name, r1kh,
2688 sm->addr, pmk_r1, pmk_r1_name) < 0 ||
2689 os_memcmp_const(pmk_r1_name, req_pmk_r1_name,
2690 WPA_PMK_NAME_LEN) != 0)
2691 continue;
2692
2693 /* We found a PSK that matches the requested pmk_r1_name */
2694 wpa_printf(MSG_DEBUG,
2695 "FT: Found PSK to generate PMK-R1 locally");
2696 os_memcpy(out_pmk_r1, pmk_r1, PMK_LEN);
2697 if (out_pairwise)
2698 *out_pairwise = pairwise;
2699 os_memcpy(sm->PMK, pmk, PMK_LEN);
2700 sm->pmk_len = PMK_LEN;
2701 if (out_vlan &&
2702 wpa_ft_get_vlan(sm->wpa_auth, sm->addr, out_vlan) < 0) {
2703 wpa_printf(MSG_DEBUG, "FT: vlan not available for STA "
2704 MACSTR, MAC2STR(sm->addr));
2705 return -1;
2706 }
2707
2708 if (out_identity && out_identity_len) {
2709 *out_identity_len = wpa_ft_get_identity(
2710 sm->wpa_auth, sm->addr, out_identity);
2711 }
2712
2713 if (out_radius_cui && out_radius_cui_len) {
2714 *out_radius_cui_len = wpa_ft_get_radius_cui(
2715 sm->wpa_auth, sm->addr, out_radius_cui);
2716 }
2717
2718 if (out_session_timeout) {
2719 *out_session_timeout = wpa_ft_get_session_timeout(
2720 sm->wpa_auth, sm->addr);
2721 }
2722
2723 return 0;
2724 }
2725
2726 wpa_printf(MSG_DEBUG,
2727 "FT: Did not find PSK to generate PMK-R1 locally");
2728 return -1;
2729 }
2730
2731
2732 /* Detect the configuration the station asked for.
2733 * Required to detect FT-PSK and pairwise cipher.
2734 */
2735 static int wpa_ft_set_key_mgmt(struct wpa_state_machine *sm,
2736 struct wpa_ft_ies *parse)
2737 {
2738 int key_mgmt, ciphers;
2739
2740 if (sm->wpa_key_mgmt)
2741 return 0;
2742
2743 key_mgmt = parse->key_mgmt & sm->wpa_auth->conf.wpa_key_mgmt;
2744 if (!key_mgmt) {
2745 wpa_printf(MSG_DEBUG, "FT: Invalid key mgmt (0x%x) from "
2746 MACSTR, parse->key_mgmt, MAC2STR(sm->addr));
2747 return -1;
2748 }
2749 if (key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X)
2750 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
2751 #ifdef CONFIG_SHA384
2752 else if (key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X_SHA384)
2753 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X_SHA384;
2754 #endif /* CONFIG_SHA384 */
2755 else if (key_mgmt & WPA_KEY_MGMT_FT_PSK)
2756 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_PSK;
2757 #ifdef CONFIG_FILS
2758 else if (key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA256)
2759 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA256;
2760 else if (key_mgmt & WPA_KEY_MGMT_FT_FILS_SHA384)
2761 sm->wpa_key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA384;
2762 #endif /* CONFIG_FILS */
2763 ciphers = parse->pairwise_cipher & sm->wpa_auth->conf.rsn_pairwise;
2764 if (!ciphers) {
2765 wpa_printf(MSG_DEBUG, "FT: Invalid pairwise cipher (0x%x) from "
2766 MACSTR,
2767 parse->pairwise_cipher, MAC2STR(sm->addr));
2768 return -1;
2769 }
2770 sm->pairwise = wpa_pick_pairwise_cipher(ciphers, 0);
2771
2772 return 0;
2773 }
2774
2775
2776 static int wpa_ft_local_derive_pmk_r1(struct wpa_authenticator *wpa_auth,
2777 struct wpa_state_machine *sm,
2778 const u8 *r0kh_id, size_t r0kh_id_len,
2779 const u8 *req_pmk_r0_name,
2780 const u8 *req_pmk_r1_name,
2781 u8 *out_pmk_r1, int *out_pairwise,
2782 struct vlan_description *vlan,
2783 const u8 **identity, size_t *identity_len,
2784 const u8 **radius_cui,
2785 size_t *radius_cui_len,
2786 int *out_session_timeout)
2787 {
2788 struct wpa_auth_config *conf = &wpa_auth->conf;
2789 const struct wpa_ft_pmk_r0_sa *r0;
2790 u8 pmk_r1_name[WPA_PMK_NAME_LEN];
2791 int expires_in = 0;
2792 int session_timeout = 0;
2793 struct os_reltime now;
2794
2795 if (conf->r0_key_holder_len != r0kh_id_len ||
2796 os_memcmp(conf->r0_key_holder, r0kh_id, conf->r0_key_holder_len) !=
2797 0)
2798 return -1; /* not our R0KH-ID */
2799
2800 wpa_printf(MSG_DEBUG, "FT: STA R0KH-ID matching local configuration");
2801 if (wpa_ft_fetch_pmk_r0(sm->wpa_auth, sm->addr, req_pmk_r0_name, &r0) <
2802 0)
2803 return -1; /* no matching PMKR0Name in local cache */
2804
2805 wpa_printf(MSG_DEBUG, "FT: Requested PMKR0Name found in local cache");
2806
2807 if (wpa_derive_pmk_r1(r0->pmk_r0, r0->pmk_r0_len, r0->pmk_r0_name,
2808 conf->r1_key_holder,
2809 sm->addr, out_pmk_r1, pmk_r1_name) < 0)
2810 return -1;
2811 wpa_hexdump_key(MSG_DEBUG, "FT: PMK-R1", out_pmk_r1, r0->pmk_r0_len);
2812 wpa_hexdump(MSG_DEBUG, "FT: PMKR1Name", pmk_r1_name, WPA_PMK_NAME_LEN);
2813
2814 os_get_reltime(&now);
2815 if (r0->expiration)
2816 expires_in = r0->expiration - now.sec;
2817
2818 if (r0->session_timeout)
2819 session_timeout = r0->session_timeout - now.sec;
2820
2821 wpa_ft_store_pmk_r1(wpa_auth, sm->addr, out_pmk_r1, r0->pmk_r0_len,
2822 pmk_r1_name,
2823 sm->pairwise, r0->vlan, expires_in, session_timeout,
2824 r0->identity, r0->identity_len,
2825 r0->radius_cui, r0->radius_cui_len);
2826
2827 *out_pairwise = sm->pairwise;
2828 if (vlan) {
2829 if (r0->vlan)
2830 *vlan = *r0->vlan;
2831 else
2832 os_memset(vlan, 0, sizeof(*vlan));
2833 }
2834
2835 if (identity && identity_len) {
2836 *identity = r0->identity;
2837 *identity_len = r0->identity_len;
2838 }
2839
2840 if (radius_cui && radius_cui_len) {
2841 *radius_cui = r0->radius_cui;
2842 *radius_cui_len = r0->radius_cui_len;
2843 }
2844
2845 *out_session_timeout = session_timeout;
2846
2847 return 0;
2848 }
2849
2850
2851 static int wpa_ft_process_auth_req(struct wpa_state_machine *sm,
2852 const u8 *ies, size_t ies_len,
2853 u8 **resp_ies, size_t *resp_ies_len)
2854 {
2855 struct rsn_mdie *mdie;
2856 u8 pmk_r1[PMK_LEN_MAX], pmk_r1_name[WPA_PMK_NAME_LEN];
2857 u8 ptk_name[WPA_PMK_NAME_LEN];
2858 struct wpa_auth_config *conf;
2859 struct wpa_ft_ies parse;
2860 size_t buflen;
2861 int ret;
2862 u8 *pos, *end;
2863 int pairwise, session_timeout = 0;
2864 struct vlan_description vlan;
2865 const u8 *identity, *radius_cui;
2866 size_t identity_len = 0, radius_cui_len = 0;
2867 int use_sha384;
2868 size_t pmk_r1_len;
2869
2870 *resp_ies = NULL;
2871 *resp_ies_len = 0;
2872
2873 sm->pmk_r1_name_valid = 0;
2874 conf = &sm->wpa_auth->conf;
2875
2876 wpa_hexdump(MSG_DEBUG, "FT: Received authentication frame IEs",
2877 ies, ies_len);
2878
2879 if (wpa_ft_parse_ies(ies, ies_len, &parse, -1)) {
2880 wpa_printf(MSG_DEBUG, "FT: Failed to parse FT IEs");
2881 return WLAN_STATUS_UNSPECIFIED_FAILURE;
2882 }
2883 use_sha384 = wpa_key_mgmt_sha384(parse.key_mgmt);
2884 pmk_r1_len = use_sha384 ? SHA384_MAC_LEN : PMK_LEN;
2885
2886 mdie = (struct rsn_mdie *) parse.mdie;
2887 if (mdie == NULL || parse.mdie_len < sizeof(*mdie) ||
2888 os_memcmp(mdie->mobility_domain,
2889 sm->wpa_auth->conf.mobility_domain,
2890 MOBILITY_DOMAIN_ID_LEN) != 0) {
2891 wpa_printf(MSG_DEBUG, "FT: Invalid MDIE");
2892 return WLAN_STATUS_INVALID_MDIE;
2893 }
2894
2895 if (use_sha384) {
2896 struct rsn_ftie_sha384 *ftie;
2897
2898 ftie = (struct rsn_ftie_sha384 *) parse.ftie;
2899 if (!ftie || parse.ftie_len < sizeof(*ftie)) {
2900 wpa_printf(MSG_DEBUG, "FT: Invalid FTIE");
2901 return WLAN_STATUS_INVALID_FTIE;
2902 }
2903
2904 os_memcpy(sm->SNonce, ftie->snonce, WPA_NONCE_LEN);
2905 } else {
2906 struct rsn_ftie *ftie;
2907
2908 ftie = (struct rsn_ftie *) parse.ftie;
2909 if (!ftie || parse.ftie_len < sizeof(*ftie)) {
2910 wpa_printf(MSG_DEBUG, "FT: Invalid FTIE");
2911 return WLAN_STATUS_INVALID_FTIE;
2912 }
2913
2914 os_memcpy(sm->SNonce, ftie->snonce, WPA_NONCE_LEN);
2915 }
2916
2917 if (parse.r0kh_id == NULL) {
2918 wpa_printf(MSG_DEBUG, "FT: Invalid FTIE - no R0KH-ID");
2919 return WLAN_STATUS_INVALID_FTIE;
2920 }
2921
2922 wpa_hexdump(MSG_DEBUG, "FT: STA R0KH-ID",
2923 parse.r0kh_id, parse.r0kh_id_len);
2924 os_memcpy(sm->r0kh_id, parse.r0kh_id, parse.r0kh_id_len);
2925 sm->r0kh_id_len = parse.r0kh_id_len;
2926
2927 if (parse.rsn_pmkid == NULL) {
2928 wpa_printf(MSG_DEBUG, "FT: No PMKID in RSNIE");
2929 return WLAN_STATUS_INVALID_PMKID;
2930 }
2931
2932 if (wpa_ft_set_key_mgmt(sm, &parse) < 0)
2933 return WLAN_STATUS_UNSPECIFIED_FAILURE;
2934
2935 wpa_hexdump(MSG_DEBUG, "FT: Requested PMKR0Name",
2936 parse.rsn_pmkid, WPA_PMK_NAME_LEN);
2937 if (wpa_derive_pmk_r1_name(parse.rsn_pmkid,
2938 sm->wpa_auth->conf.r1_key_holder, sm->addr,
2939 pmk_r1_name, use_sha384) < 0)
2940 return WLAN_STATUS_UNSPECIFIED_FAILURE;
2941 wpa_hexdump(MSG_DEBUG, "FT: Derived requested PMKR1Name",
2942 pmk_r1_name, WPA_PMK_NAME_LEN);
2943
2944 if (conf->ft_psk_generate_local &&
2945 wpa_key_mgmt_ft_psk(sm->wpa_key_mgmt)) {
2946 if (wpa_ft_psk_pmk_r1(sm, pmk_r1_name, pmk_r1, &pairwise,
2947 &vlan, &identity, &identity_len,
2948 &radius_cui, &radius_cui_len,
2949 &session_timeout) < 0)
2950 return WLAN_STATUS_INVALID_PMKID;
2951 wpa_printf(MSG_DEBUG,
2952 "FT: Generated PMK-R1 for FT-PSK locally");
2953 } else if (wpa_ft_fetch_pmk_r1(sm->wpa_auth, sm->addr, pmk_r1_name,
2954 pmk_r1, &pmk_r1_len, &pairwise, &vlan,
2955 &identity, &identity_len, &radius_cui,
2956 &radius_cui_len, &session_timeout) < 0) {
2957 wpa_printf(MSG_DEBUG,
2958 "FT: No PMK-R1 available in local cache for the requested PMKR1Name");
2959 if (wpa_ft_local_derive_pmk_r1(sm->wpa_auth, sm,
2960 parse.r0kh_id, parse.r0kh_id_len,
2961 parse.rsn_pmkid,
2962 pmk_r1_name, pmk_r1, &pairwise,
2963 &vlan, &identity, &identity_len,
2964 &radius_cui, &radius_cui_len,
2965 &session_timeout) == 0) {
2966 wpa_printf(MSG_DEBUG,
2967 "FT: Generated PMK-R1 based on local PMK-R0");
2968 goto pmk_r1_derived;
2969 }
2970
2971 if (wpa_ft_pull_pmk_r1(sm, ies, ies_len, parse.rsn_pmkid) < 0) {
2972 wpa_printf(MSG_DEBUG,
2973 "FT: Did not have matching PMK-R1 and either unknown or blocked R0KH-ID or NAK from R0KH");
2974 return WLAN_STATUS_INVALID_PMKID;
2975 }
2976
2977 return -1; /* Status pending */
2978 } else {
2979 wpa_printf(MSG_DEBUG, "FT: Found PMKR1Name from local cache");
2980 }
2981
2982 pmk_r1_derived:
2983 wpa_hexdump_key(MSG_DEBUG, "FT: Selected PMK-R1", pmk_r1, pmk_r1_len);
2984 sm->pmk_r1_name_valid = 1;
2985 os_memcpy(sm->pmk_r1_name, pmk_r1_name, WPA_PMK_NAME_LEN);
2986 os_memcpy(sm->pmk_r1, pmk_r1, pmk_r1_len);
2987 sm->pmk_r1_len = pmk_r1_len;
2988
2989 if (random_get_bytes(sm->ANonce, WPA_NONCE_LEN)) {
2990 wpa_printf(MSG_DEBUG, "FT: Failed to get random data for "
2991 "ANonce");
2992 return WLAN_STATUS_UNSPECIFIED_FAILURE;
2993 }
2994
2995 wpa_hexdump(MSG_DEBUG, "FT: Received SNonce",
2996 sm->SNonce, WPA_NONCE_LEN);
2997 wpa_hexdump(MSG_DEBUG, "FT: Generated ANonce",
2998 sm->ANonce, WPA_NONCE_LEN);
2999
3000 if (wpa_pmk_r1_to_ptk(pmk_r1, pmk_r1_len, sm->SNonce, sm->ANonce,
3001 sm->addr, sm->wpa_auth->addr, pmk_r1_name,
3002 &sm->PTK, ptk_name, sm->wpa_key_mgmt,
3003 pairwise) < 0)
3004 return WLAN_STATUS_UNSPECIFIED_FAILURE;
3005
3006 sm->pairwise = pairwise;
3007 sm->PTK_valid = TRUE;
3008 sm->tk_already_set = FALSE;
3009 wpa_ft_install_ptk(sm);
3010
3011 if (wpa_ft_set_vlan(sm->wpa_auth, sm->addr, &vlan) < 0) {
3012 wpa_printf(MSG_DEBUG, "FT: Failed to configure VLAN");
3013 return WLAN_STATUS_UNSPECIFIED_FAILURE;
3014 }
3015 if (wpa_ft_set_identity(sm->wpa_auth, sm->addr,
3016 identity, identity_len) < 0 ||
3017 wpa_ft_set_radius_cui(sm->wpa_auth, sm->addr,
3018 radius_cui, radius_cui_len) < 0) {
3019 wpa_printf(MSG_DEBUG, "FT: Failed to configure identity/CUI");
3020 return WLAN_STATUS_UNSPECIFIED_FAILURE;
3021 }
3022 wpa_ft_set_session_timeout(sm->wpa_auth, sm->addr, session_timeout);
3023
3024 buflen = 2 + sizeof(struct rsn_mdie) + 2 + sizeof(struct rsn_ftie) +
3025 2 + FT_R1KH_ID_LEN + 200;
3026 *resp_ies = os_zalloc(buflen);
3027 if (*resp_ies == NULL)
3028 goto fail;
3029
3030 pos = *resp_ies;
3031 end = *resp_ies + buflen;
3032
3033 ret = wpa_write_rsn_ie(conf, pos, end - pos, parse.rsn_pmkid);
3034 if (ret < 0)
3035 goto fail;
3036 pos += ret;
3037
3038 ret = wpa_write_mdie(conf, pos, end - pos);
3039 if (ret < 0)
3040 goto fail;
3041 pos += ret;
3042
3043 ret = wpa_write_ftie(conf, use_sha384, parse.r0kh_id, parse.r0kh_id_len,
3044 sm->ANonce, sm->SNonce, pos, end - pos, NULL, 0);
3045 if (ret < 0)
3046 goto fail;
3047 pos += ret;
3048
3049 *resp_ies_len = pos - *resp_ies;
3050
3051 return WLAN_STATUS_SUCCESS;
3052 fail:
3053 os_free(*resp_ies);
3054 *resp_ies = NULL;
3055 return WLAN_STATUS_UNSPECIFIED_FAILURE;
3056 }
3057
3058
3059 void wpa_ft_process_auth(struct wpa_state_machine *sm, const u8 *bssid,
3060 u16 auth_transaction, const u8 *ies, size_t ies_len,
3061 void (*cb)(void *ctx, const u8 *dst, const u8 *bssid,
3062 u16 auth_transaction, u16 status,
3063 const u8 *ies, size_t ies_len),
3064 void *ctx)
3065 {
3066 u16 status;
3067 u8 *resp_ies;
3068 size_t resp_ies_len;
3069 int res;
3070
3071 if (sm == NULL) {
3072 wpa_printf(MSG_DEBUG, "FT: Received authentication frame, but "
3073 "WPA SM not available");
3074 return;
3075 }
3076
3077 wpa_printf(MSG_DEBUG, "FT: Received authentication frame: STA=" MACSTR
3078 " BSSID=" MACSTR " transaction=%d",
3079 MAC2STR(sm->addr), MAC2STR(bssid), auth_transaction);
3080 sm->ft_pending_cb = cb;
3081 sm->ft_pending_cb_ctx = ctx;
3082 sm->ft_pending_auth_transaction = auth_transaction;
3083 sm->ft_pending_pull_left_retries = sm->wpa_auth->conf.rkh_pull_retries;
3084 res = wpa_ft_process_auth_req(sm, ies, ies_len, &resp_ies,
3085 &resp_ies_len);
3086 if (res < 0) {
3087 wpa_printf(MSG_DEBUG, "FT: Callback postponed until response is available");
3088 return;
3089 }
3090 status = res;
3091
3092 wpa_printf(MSG_DEBUG, "FT: FT authentication response: dst=" MACSTR
3093 " auth_transaction=%d status=%d",
3094 MAC2STR(sm->addr), auth_transaction + 1, status);
3095 wpa_hexdump(MSG_DEBUG, "FT: Response IEs", resp_ies, resp_ies_len);
3096 cb(ctx, sm->addr, bssid, auth_transaction + 1, status,
3097 resp_ies, resp_ies_len);
3098 os_free(resp_ies);
3099 }
3100
3101
3102 u16 wpa_ft_validate_reassoc(struct wpa_state_machine *sm, const u8 *ies,
3103 size_t ies_len)
3104 {
3105 struct wpa_ft_ies parse;
3106 struct rsn_mdie *mdie;
3107 u8 mic[WPA_EAPOL_KEY_MIC_MAX_LEN];
3108 size_t mic_len = 16;
3109 unsigned int count;
3110 const u8 *kck;
3111 size_t kck_len;
3112 int use_sha384;
3113 const u8 *anonce, *snonce, *fte_mic;
3114 u8 fte_elem_count;
3115
3116 if (sm == NULL)
3117 return WLAN_STATUS_UNSPECIFIED_FAILURE;
3118
3119 use_sha384 = wpa_key_mgmt_sha384(sm->wpa_key_mgmt);
3120
3121 wpa_hexdump(MSG_DEBUG, "FT: Reassoc Req IEs", ies, ies_len);
3122
3123 if (wpa_ft_parse_ies(ies, ies_len, &parse, use_sha384) < 0) {
3124 wpa_printf(MSG_DEBUG, "FT: Failed to parse FT IEs");
3125 return WLAN_STATUS_UNSPECIFIED_FAILURE;
3126 }
3127
3128 if (parse.rsn == NULL) {
3129 wpa_printf(MSG_DEBUG, "FT: No RSNIE in Reassoc Req");
3130 return WLAN_STATUS_UNSPECIFIED_FAILURE;
3131 }
3132
3133 if (parse.rsn_pmkid == NULL) {
3134 wpa_printf(MSG_DEBUG, "FT: No PMKID in RSNIE");
3135 return WLAN_STATUS_INVALID_PMKID;
3136 }
3137
3138 if (os_memcmp_const(parse.rsn_pmkid, sm->pmk_r1_name, WPA_PMK_NAME_LEN)
3139 != 0) {
3140 wpa_printf(MSG_DEBUG, "FT: PMKID in Reassoc Req did not match "
3141 "with the PMKR1Name derived from auth request");
3142 return WLAN_STATUS_INVALID_PMKID;
3143 }
3144
3145 mdie = (struct rsn_mdie *) parse.mdie;
3146 if (mdie == NULL || parse.mdie_len < sizeof(*mdie) ||
3147 os_memcmp(mdie->mobility_domain,
3148 sm->wpa_auth->conf.mobility_domain,
3149 MOBILITY_DOMAIN_ID_LEN) != 0) {
3150 wpa_printf(MSG_DEBUG, "FT: Invalid MDIE");
3151 return WLAN_STATUS_INVALID_MDIE;
3152 }
3153
3154 if (use_sha384) {
3155 struct rsn_ftie_sha384 *ftie;
3156
3157 ftie = (struct rsn_ftie_sha384 *) parse.ftie;
3158 if (ftie == NULL || parse.ftie_len < sizeof(*ftie)) {
3159 wpa_printf(MSG_DEBUG, "FT: Invalid FTIE");
3160 return WLAN_STATUS_INVALID_FTIE;
3161 }
3162
3163 anonce = ftie->anonce;
3164 snonce = ftie->snonce;
3165 fte_elem_count = ftie->mic_control[1];
3166 fte_mic = ftie->mic;
3167 } else {
3168 struct rsn_ftie *ftie;
3169
3170 ftie = (struct rsn_ftie *) parse.ftie;
3171 if (ftie == NULL || parse.ftie_len < sizeof(*ftie)) {
3172 wpa_printf(MSG_DEBUG, "FT: Invalid FTIE");
3173 return WLAN_STATUS_INVALID_FTIE;
3174 }
3175
3176 anonce = ftie->anonce;
3177 snonce = ftie->snonce;
3178 fte_elem_count = ftie->mic_control[1];
3179 fte_mic = ftie->mic;
3180 }
3181
3182 if (os_memcmp(snonce, sm->SNonce, WPA_NONCE_LEN) != 0) {
3183 wpa_printf(MSG_DEBUG, "FT: SNonce mismatch in FTIE");
3184 wpa_hexdump(MSG_DEBUG, "FT: Received SNonce",
3185 snonce, WPA_NONCE_LEN);
3186 wpa_hexdump(MSG_DEBUG, "FT: Expected SNonce",
3187 sm->SNonce, WPA_NONCE_LEN);
3188 return WLAN_STATUS_INVALID_FTIE;
3189 }
3190
3191 if (os_memcmp(anonce, sm->ANonce, WPA_NONCE_LEN) != 0) {
3192 wpa_printf(MSG_DEBUG, "FT: ANonce mismatch in FTIE");
3193 wpa_hexdump(MSG_DEBUG, "FT: Received ANonce",
3194 anonce, WPA_NONCE_LEN);
3195 wpa_hexdump(MSG_DEBUG, "FT: Expected ANonce",
3196 sm->ANonce, WPA_NONCE_LEN);
3197 return WLAN_STATUS_INVALID_FTIE;
3198 }
3199
3200
3201 if (parse.r0kh_id == NULL) {
3202 wpa_printf(MSG_DEBUG, "FT: No R0KH-ID subelem in FTIE");
3203 return WLAN_STATUS_INVALID_FTIE;
3204 }
3205
3206 if (parse.r0kh_id_len != sm->r0kh_id_len ||
3207 os_memcmp_const(parse.r0kh_id, sm->r0kh_id, parse.r0kh_id_len) != 0)
3208 {
3209 wpa_printf(MSG_DEBUG, "FT: R0KH-ID in FTIE did not match with "
3210 "the current R0KH-ID");
3211 wpa_hexdump(MSG_DEBUG, "FT: R0KH-ID in FTIE",
3212 parse.r0kh_id, parse.r0kh_id_len);
3213 wpa_hexdump(MSG_DEBUG, "FT: The current R0KH-ID",
3214 sm->r0kh_id, sm->r0kh_id_len);
3215 return WLAN_STATUS_INVALID_FTIE;
3216 }
3217
3218 if (parse.r1kh_id == NULL) {
3219 wpa_printf(MSG_DEBUG, "FT: No R1KH-ID subelem in FTIE");
3220 return WLAN_STATUS_INVALID_FTIE;
3221 }
3222
3223 if (os_memcmp_const(parse.r1kh_id, sm->wpa_auth->conf.r1_key_holder,
3224 FT_R1KH_ID_LEN) != 0) {
3225 wpa_printf(MSG_DEBUG, "FT: Unknown R1KH-ID used in "
3226 "ReassocReq");
3227 wpa_hexdump(MSG_DEBUG, "FT: R1KH-ID in FTIE",
3228 parse.r1kh_id, FT_R1KH_ID_LEN);
3229 wpa_hexdump(MSG_DEBUG, "FT: Expected R1KH-ID",
3230 sm->wpa_auth->conf.r1_key_holder, FT_R1KH_ID_LEN);
3231 return WLAN_STATUS_INVALID_FTIE;
3232 }
3233
3234 if (parse.rsn_pmkid == NULL ||
3235 os_memcmp_const(parse.rsn_pmkid, sm->pmk_r1_name, WPA_PMK_NAME_LEN))
3236 {
3237 wpa_printf(MSG_DEBUG, "FT: No matching PMKR1Name (PMKID) in "
3238 "RSNIE (pmkid=%d)", !!parse.rsn_pmkid);
3239 return WLAN_STATUS_INVALID_PMKID;
3240 }
3241
3242 count = 3;
3243 if (parse.ric)
3244 count += ieee802_11_ie_count(parse.ric, parse.ric_len);
3245 if (fte_elem_count != count) {
3246 wpa_printf(MSG_DEBUG, "FT: Unexpected IE count in MIC "
3247 "Control: received %u expected %u",
3248 fte_elem_count, count);
3249 return WLAN_STATUS_UNSPECIFIED_FAILURE;
3250 }
3251
3252 if (wpa_key_mgmt_fils(sm->wpa_key_mgmt)) {
3253 kck = sm->PTK.kck2;
3254 kck_len = sm->PTK.kck2_len;
3255 } else {
3256 kck = sm->PTK.kck;
3257 kck_len = sm->PTK.kck_len;
3258 }
3259 if (wpa_ft_mic(kck, kck_len, sm->addr, sm->wpa_auth->addr, 5,
3260 parse.mdie - 2, parse.mdie_len + 2,
3261 parse.ftie - 2, parse.ftie_len + 2,
3262 parse.rsn - 2, parse.rsn_len + 2,
3263 parse.ric, parse.ric_len,
3264 mic) < 0) {
3265 wpa_printf(MSG_DEBUG, "FT: Failed to calculate MIC");
3266 return WLAN_STATUS_UNSPECIFIED_FAILURE;
3267 }
3268
3269 if (os_memcmp_const(mic, fte_mic, mic_len) != 0) {
3270 wpa_printf(MSG_DEBUG, "FT: Invalid MIC in FTIE");
3271 wpa_printf(MSG_DEBUG, "FT: addr=" MACSTR " auth_addr=" MACSTR,
3272 MAC2STR(sm->addr), MAC2STR(sm->wpa_auth->addr));
3273 wpa_hexdump(MSG_MSGDUMP, "FT: Received MIC",
3274 fte_mic, mic_len);
3275 wpa_hexdump(MSG_MSGDUMP, "FT: Calculated MIC", mic, mic_len);
3276 wpa_hexdump(MSG_MSGDUMP, "FT: MDIE",
3277 parse.mdie - 2, parse.mdie_len + 2);
3278 wpa_hexdump(MSG_MSGDUMP, "FT: FTIE",
3279 parse.ftie - 2, parse.ftie_len + 2);
3280 wpa_hexdump(MSG_MSGDUMP, "FT: RSN",
3281 parse.rsn - 2, parse.rsn_len + 2);
3282 return WLAN_STATUS_INVALID_FTIE;
3283 }
3284
3285 #ifdef CONFIG_OCV
3286 if (wpa_auth_uses_ocv(sm)) {
3287 struct wpa_channel_info ci;
3288 int tx_chanwidth;
3289 int tx_seg1_idx;
3290
3291 if (wpa_channel_info(sm->wpa_auth, &ci) != 0) {
3292 wpa_printf(MSG_WARNING,
3293 "Failed to get channel info to validate received OCI in (Re)Assoc Request");
3294 return WLAN_STATUS_UNSPECIFIED_FAILURE;
3295 }
3296
3297 if (get_sta_tx_parameters(sm,
3298 channel_width_to_int(ci.chanwidth),
3299 ci.seg1_idx, &tx_chanwidth,
3300 &tx_seg1_idx) < 0)
3301 return WLAN_STATUS_UNSPECIFIED_FAILURE;
3302
3303 if (ocv_verify_tx_params(parse.oci, parse.oci_len, &ci,
3304 tx_chanwidth, tx_seg1_idx) != 0) {
3305 wpa_printf(MSG_WARNING, "%s", ocv_errorstr);
3306 return WLAN_STATUS_UNSPECIFIED_FAILURE;
3307 }
3308 }
3309 #endif /* CONFIG_OCV */
3310
3311 return WLAN_STATUS_SUCCESS;
3312 }
3313
3314
3315 int wpa_ft_action_rx(struct wpa_state_machine *sm, const u8 *data, size_t len)
3316 {
3317 const u8 *sta_addr, *target_ap;
3318 const u8 *ies;
3319 size_t ies_len;
3320 u8 action;
3321 struct ft_rrb_frame *frame;
3322
3323 if (sm == NULL)
3324 return -1;
3325
3326 /*
3327 * data: Category[1] Action[1] STA_Address[6] Target_AP_Address[6]
3328 * FT Request action frame body[variable]
3329 */
3330
3331 if (len < 14) {
3332 wpa_printf(MSG_DEBUG, "FT: Too short FT Action frame "
3333 "(len=%lu)", (unsigned long) len);
3334 return -1;
3335 }
3336
3337 action = data[1];
3338 sta_addr = data + 2;
3339 target_ap = data + 8;
3340 ies = data + 14;
3341 ies_len = len - 14;
3342
3343 wpa_printf(MSG_DEBUG, "FT: Received FT Action frame (STA=" MACSTR
3344 " Target AP=" MACSTR " Action=%d)",
3345 MAC2STR(sta_addr), MAC2STR(target_ap), action);
3346
3347 if (os_memcmp(sta_addr, sm->addr, ETH_ALEN) != 0) {
3348 wpa_printf(MSG_DEBUG, "FT: Mismatch in FT Action STA address: "
3349 "STA=" MACSTR " STA-Address=" MACSTR,
3350 MAC2STR(sm->addr), MAC2STR(sta_addr));
3351 return -1;
3352 }
3353
3354 /*
3355 * Do some sanity checking on the target AP address (not own and not
3356 * broadcast. This could be extended to filter based on a list of known
3357 * APs in the MD (if such a list were configured).
3358 */
3359 if ((target_ap[0] & 0x01) ||
3360 os_memcmp(target_ap, sm->wpa_auth->addr, ETH_ALEN) == 0) {
3361 wpa_printf(MSG_DEBUG, "FT: Invalid Target AP in FT Action "
3362 "frame");
3363 return -1;
3364 }
3365
3366 wpa_hexdump(MSG_MSGDUMP, "FT: Action frame body", ies, ies_len);
3367
3368 if (!sm->wpa_auth->conf.ft_over_ds) {
3369 wpa_printf(MSG_DEBUG, "FT: Over-DS option disabled - reject");
3370 return -1;
3371 }
3372
3373 /* RRB - Forward action frame to the target AP */
3374 frame = os_malloc(sizeof(*frame) + len);
3375 if (frame == NULL)
3376 return -1;
3377 frame->frame_type = RSN_REMOTE_FRAME_TYPE_FT_RRB;
3378 frame->packet_type = FT_PACKET_REQUEST;
3379 frame->action_length = host_to_le16(len);
3380 os_memcpy(frame->ap_address, sm->wpa_auth->addr, ETH_ALEN);
3381 os_memcpy(frame + 1, data, len);
3382
3383 wpa_ft_rrb_send(sm->wpa_auth, target_ap, (u8 *) frame,
3384 sizeof(*frame) + len);
3385 os_free(frame);
3386
3387 return 0;
3388 }
3389
3390
3391 static void wpa_ft_rrb_rx_request_cb(void *ctx, const u8 *dst, const u8 *bssid,
3392 u16 auth_transaction, u16 resp,
3393 const u8 *ies, size_t ies_len)
3394 {
3395 struct wpa_state_machine *sm = ctx;
3396 wpa_printf(MSG_DEBUG, "FT: Over-the-DS RX request cb for " MACSTR,
3397 MAC2STR(sm->addr));
3398 wpa_ft_send_rrb_auth_resp(sm, sm->ft_pending_current_ap, sm->addr,
3399 WLAN_STATUS_SUCCESS, ies, ies_len);
3400 }
3401
3402
3403 static int wpa_ft_rrb_rx_request(struct wpa_authenticator *wpa_auth,
3404 const u8 *current_ap, const u8 *sta_addr,
3405 const u8 *body, size_t len)
3406 {
3407 struct wpa_state_machine *sm;
3408 u16 status;
3409 u8 *resp_ies;
3410 size_t resp_ies_len;
3411 int res;
3412
3413 sm = wpa_ft_add_sta(wpa_auth, sta_addr);
3414 if (sm == NULL) {
3415 wpa_printf(MSG_DEBUG, "FT: Failed to add new STA based on "
3416 "RRB Request");
3417 return -1;
3418 }
3419
3420 wpa_hexdump(MSG_MSGDUMP, "FT: RRB Request Frame body", body, len);
3421
3422 sm->ft_pending_cb = wpa_ft_rrb_rx_request_cb;
3423 sm->ft_pending_cb_ctx = sm;
3424 os_memcpy(sm->ft_pending_current_ap, current_ap, ETH_ALEN);
3425 sm->ft_pending_pull_left_retries = sm->wpa_auth->conf.rkh_pull_retries;
3426 res = wpa_ft_process_auth_req(sm, body, len, &resp_ies,
3427 &resp_ies_len);
3428 if (res < 0) {
3429 wpa_printf(MSG_DEBUG, "FT: No immediate response available - wait for pull response");
3430 return 0;
3431 }
3432 status = res;
3433
3434 res = wpa_ft_send_rrb_auth_resp(sm, current_ap, sta_addr, status,
3435 resp_ies, resp_ies_len);
3436 os_free(resp_ies);
3437 return res;
3438 }
3439
3440
3441 static int wpa_ft_send_rrb_auth_resp(struct wpa_state_machine *sm,
3442 const u8 *current_ap, const u8 *sta_addr,
3443 u16 status, const u8 *resp_ies,
3444 size_t resp_ies_len)
3445 {
3446 struct wpa_authenticator *wpa_auth = sm->wpa_auth;
3447 size_t rlen;
3448 struct ft_rrb_frame *frame;
3449 u8 *pos;
3450
3451 wpa_printf(MSG_DEBUG, "FT: RRB authentication response: STA=" MACSTR
3452 " CurrentAP=" MACSTR " status=%d",
3453 MAC2STR(sm->addr), MAC2STR(current_ap), status);
3454 wpa_hexdump(MSG_DEBUG, "FT: Response IEs", resp_ies, resp_ies_len);
3455
3456 /* RRB - Forward action frame response to the Current AP */
3457
3458 /*
3459 * data: Category[1] Action[1] STA_Address[6] Target_AP_Address[6]
3460 * Status_Code[2] FT Request action frame body[variable]
3461 */
3462 rlen = 2 + 2 * ETH_ALEN + 2 + resp_ies_len;
3463
3464 frame = os_malloc(sizeof(*frame) + rlen);
3465 if (frame == NULL)
3466 return -1;
3467 frame->frame_type = RSN_REMOTE_FRAME_TYPE_FT_RRB;
3468 frame->packet_type = FT_PACKET_RESPONSE;
3469 frame->action_length = host_to_le16(rlen);
3470 os_memcpy(frame->ap_address, wpa_auth->addr, ETH_ALEN);
3471 pos = (u8 *) (frame + 1);
3472 *pos++ = WLAN_ACTION_FT;
3473 *pos++ = 2; /* Action: Response */
3474 os_memcpy(pos, sta_addr, ETH_ALEN);
3475 pos += ETH_ALEN;
3476 os_memcpy(pos, wpa_auth->addr, ETH_ALEN);
3477 pos += ETH_ALEN;
3478 WPA_PUT_LE16(pos, status);
3479 pos += 2;
3480 if (resp_ies)
3481 os_memcpy(pos, resp_ies, resp_ies_len);
3482
3483 wpa_ft_rrb_send(wpa_auth, current_ap, (u8 *) frame,
3484 sizeof(*frame) + rlen);
3485 os_free(frame);
3486
3487 return 0;
3488 }
3489
3490
3491 static int wpa_ft_rrb_build_r0(const u8 *key, const size_t key_len,
3492 const struct tlv_list *tlvs,
3493 const struct wpa_ft_pmk_r0_sa *pmk_r0,
3494 const u8 *r1kh_id, const u8 *s1kh_id,
3495 const struct tlv_list *tlv_auth,
3496 const u8 *src_addr, u8 type,
3497 u8 **packet, size_t *packet_len)
3498 {
3499 u8 pmk_r1[PMK_LEN_MAX];
3500 size_t pmk_r1_len = pmk_r0->pmk_r0_len;
3501 u8 pmk_r1_name[WPA_PMK_NAME_LEN];
3502 u8 f_pairwise[sizeof(le16)];
3503 u8 f_expires_in[sizeof(le16)];
3504 u8 f_session_timeout[sizeof(le32)];
3505 int expires_in;
3506 int session_timeout;
3507 struct os_reltime now;
3508 int ret;
3509 struct tlv_list sess_tlv[] = {
3510 { .type = FT_RRB_PMK_R1, .len = pmk_r1_len,
3511 .data = pmk_r1 },
3512 { .type = FT_RRB_PMK_R1_NAME, .len = sizeof(pmk_r1_name),
3513 .data = pmk_r1_name },
3514 { .type = FT_RRB_PAIRWISE, .len = sizeof(f_pairwise),
3515 .data = f_pairwise },
3516 { .type = FT_RRB_EXPIRES_IN, .len = sizeof(f_expires_in),
3517 .data = f_expires_in },
3518 { .type = FT_RRB_IDENTITY, .len = pmk_r0->identity_len,
3519 .data = pmk_r0->identity },
3520 { .type = FT_RRB_RADIUS_CUI, .len = pmk_r0->radius_cui_len,
3521 .data = pmk_r0->radius_cui },
3522 { .type = FT_RRB_SESSION_TIMEOUT,
3523 .len = sizeof(f_session_timeout),
3524 .data = f_session_timeout },
3525 { .type = FT_RRB_LAST_EMPTY, .len = 0, .data = NULL },
3526 };
3527
3528 if (wpa_derive_pmk_r1(pmk_r0->pmk_r0, pmk_r0->pmk_r0_len,
3529 pmk_r0->pmk_r0_name, r1kh_id,
3530 s1kh_id, pmk_r1, pmk_r1_name) < 0)
3531 return -1;
3532 wpa_hexdump_key(MSG_DEBUG, "FT: PMK-R1 (for peer AP)",
3533 pmk_r1, pmk_r1_len);
3534 wpa_hexdump(MSG_DEBUG, "FT: PMKR1Name (for peer AP)",
3535 pmk_r1_name, WPA_PMK_NAME_LEN);
3536 WPA_PUT_LE16(f_pairwise, pmk_r0->pairwise);
3537
3538 os_get_reltime(&now);
3539 if (pmk_r0->expiration > now.sec)
3540 expires_in = pmk_r0->expiration - now.sec;
3541 else if (pmk_r0->expiration)
3542 expires_in = 1;
3543 else
3544 expires_in = 0;
3545 WPA_PUT_LE16(f_expires_in, expires_in);
3546
3547 if (pmk_r0->session_timeout > now.sec)
3548 session_timeout = pmk_r0->session_timeout - now.sec;
3549 else if (pmk_r0->session_timeout)
3550 session_timeout = 1;
3551 else
3552 session_timeout = 0;
3553 WPA_PUT_LE32(f_session_timeout, session_timeout);
3554
3555 ret = wpa_ft_rrb_build(key, key_len, tlvs, sess_tlv, tlv_auth,
3556 pmk_r0->vlan, src_addr, type,
3557 packet, packet_len);
3558
3559 os_memset(pmk_r1, 0, sizeof(pmk_r1));
3560
3561 return ret;
3562 }
3563
3564
3565 static int wpa_ft_rrb_rx_pull(struct wpa_authenticator *wpa_auth,
3566 const u8 *src_addr,
3567 const u8 *enc, size_t enc_len,
3568 const u8 *auth, size_t auth_len,
3569 int no_defer)
3570 {
3571 const char *msgtype = "pull request";
3572 u8 *plain = NULL, *packet = NULL;
3573 size_t plain_len = 0, packet_len = 0;
3574 struct ft_remote_r1kh *r1kh, *r1kh_wildcard;
3575 const u8 *key;
3576 size_t key_len;
3577 int seq_ret;
3578 const u8 *f_nonce, *f_r0kh_id, *f_r1kh_id, *f_s1kh_id, *f_pmk_r0_name;
3579 size_t f_nonce_len, f_r0kh_id_len, f_r1kh_id_len, f_s1kh_id_len;
3580 size_t f_pmk_r0_name_len;
3581 const struct wpa_ft_pmk_r0_sa *r0;
3582 int ret;
3583 struct tlv_list resp[2];
3584 struct tlv_list resp_auth[5];
3585 struct ft_rrb_seq f_seq;
3586
3587 wpa_printf(MSG_DEBUG, "FT: Received PMK-R1 pull");
3588
3589 RRB_GET_AUTH(FT_RRB_R0KH_ID, r0kh_id, msgtype, -1);
3590 wpa_hexdump(MSG_DEBUG, "FT: R0KH-ID", f_r0kh_id, f_r0kh_id_len);
3591
3592 if (wpa_ft_rrb_check_r0kh(wpa_auth, f_r0kh_id, f_r0kh_id_len)) {
3593 wpa_printf(MSG_DEBUG, "FT: R0KH-ID mismatch");
3594 goto out;
3595 }
3596
3597 RRB_GET_AUTH(FT_RRB_R1KH_ID, r1kh_id, msgtype, FT_R1KH_ID_LEN);
3598 wpa_printf(MSG_DEBUG, "FT: R1KH-ID=" MACSTR, MAC2STR(f_r1kh_id));
3599
3600 wpa_ft_rrb_lookup_r1kh(wpa_auth, f_r1kh_id, &r1kh, &r1kh_wildcard);
3601 if (r1kh) {
3602 key = r1kh->key;
3603 key_len = sizeof(r1kh->key);
3604 } else if (r1kh_wildcard) {
3605 wpa_printf(MSG_DEBUG, "FT: Using wildcard R1KH-ID");
3606 key = r1kh_wildcard->key;
3607 key_len = sizeof(r1kh_wildcard->key);
3608 } else {
3609 goto out;
3610 }
3611
3612 RRB_GET_AUTH(FT_RRB_NONCE, nonce, "pull request", FT_RRB_NONCE_LEN);
3613 wpa_hexdump(MSG_DEBUG, "FT: nonce", f_nonce, f_nonce_len);
3614
3615 seq_ret = FT_RRB_SEQ_DROP;
3616 if (r1kh)
3617 seq_ret = wpa_ft_rrb_seq_chk(r1kh->seq, src_addr, enc, enc_len,
3618 auth, auth_len, msgtype, no_defer);
3619 if (!no_defer && r1kh_wildcard &&
3620 (!r1kh || os_memcmp(r1kh->addr, src_addr, ETH_ALEN) != 0)) {
3621 /* wildcard: r1kh-id unknown or changed addr -> do a seq req */
3622 seq_ret = FT_RRB_SEQ_DEFER;
3623 }
3624
3625 if (seq_ret == FT_RRB_SEQ_DROP)
3626 goto out;
3627
3628 if (wpa_ft_rrb_decrypt(key, key_len, enc, enc_len, auth, auth_len,
3629 src_addr, FT_PACKET_R0KH_R1KH_PULL,
3630 &plain, &plain_len) < 0)
3631 goto out;
3632
3633 if (!r1kh)
3634 r1kh = wpa_ft_rrb_add_r1kh(wpa_auth, r1kh_wildcard, src_addr,
3635 f_r1kh_id,
3636 wpa_auth->conf.rkh_pos_timeout);
3637 if (!r1kh)
3638 goto out;
3639
3640 if (seq_ret == FT_RRB_SEQ_DEFER) {
3641 wpa_ft_rrb_seq_req(wpa_auth, r1kh->seq, src_addr, f_r0kh_id,
3642 f_r0kh_id_len, f_r1kh_id, key, key_len,
3643 enc, enc_len, auth, auth_len,
3644 &wpa_ft_rrb_rx_pull);
3645 goto out;
3646 }
3647
3648 wpa_ft_rrb_seq_accept(wpa_auth, r1kh->seq, src_addr, auth, auth_len,
3649 msgtype);
3650 wpa_ft_rrb_r1kh_replenish(wpa_auth, r1kh,
3651 wpa_auth->conf.rkh_pos_timeout);
3652
3653 RRB_GET(FT_RRB_PMK_R0_NAME, pmk_r0_name, msgtype, WPA_PMK_NAME_LEN);
3654 wpa_hexdump(MSG_DEBUG, "FT: PMKR0Name", f_pmk_r0_name,
3655 f_pmk_r0_name_len);
3656
3657 RRB_GET(FT_RRB_S1KH_ID, s1kh_id, msgtype, ETH_ALEN);
3658 wpa_printf(MSG_DEBUG, "FT: S1KH-ID=" MACSTR, MAC2STR(f_s1kh_id));
3659
3660 if (wpa_ft_new_seq(r1kh->seq, &f_seq) < 0) {
3661 wpa_printf(MSG_DEBUG, "FT: Failed to get seq num");
3662 goto out;
3663 }
3664
3665 resp[0].type = FT_RRB_S1KH_ID;
3666 resp[0].len = f_s1kh_id_len;
3667 resp[0].data = f_s1kh_id;
3668 resp[1].type = FT_RRB_LAST_EMPTY;
3669 resp[1].len = 0;
3670 resp[1].data = NULL;
3671
3672 resp_auth[0].type = FT_RRB_NONCE;
3673 resp_auth[0].len = f_nonce_len;
3674 resp_auth[0].data = f_nonce;
3675 resp_auth[1].type = FT_RRB_SEQ;
3676 resp_auth[1].len = sizeof(f_seq);
3677 resp_auth[1].data = (u8 *) &f_seq;
3678 resp_auth[2].type = FT_RRB_R0KH_ID;
3679 resp_auth[2].len = f_r0kh_id_len;
3680 resp_auth[2].data = f_r0kh_id;
3681 resp_auth[3].type = FT_RRB_R1KH_ID;
3682 resp_auth[3].len = f_r1kh_id_len;
3683 resp_auth[3].data = f_r1kh_id;
3684 resp_auth[4].type = FT_RRB_LAST_EMPTY;
3685 resp_auth[4].len = 0;
3686 resp_auth[4].data = NULL;
3687
3688 if (wpa_ft_fetch_pmk_r0(wpa_auth, f_s1kh_id, f_pmk_r0_name, &r0) < 0) {
3689 wpa_printf(MSG_DEBUG, "FT: No matching PMK-R0-Name found");
3690 ret = wpa_ft_rrb_build(key, key_len, resp, NULL, resp_auth,
3691 NULL, wpa_auth->addr,
3692 FT_PACKET_R0KH_R1KH_RESP,
3693 &packet, &packet_len);
3694 } else {
3695 ret = wpa_ft_rrb_build_r0(key, key_len, resp, r0, f_r1kh_id,
3696 f_s1kh_id, resp_auth, wpa_auth->addr,
3697 FT_PACKET_R0KH_R1KH_RESP,
3698 &packet, &packet_len);
3699 }
3700
3701 if (!ret)
3702 wpa_ft_rrb_oui_send(wpa_auth, src_addr,
3703 FT_PACKET_R0KH_R1KH_RESP, packet,
3704 packet_len);
3705
3706 out:
3707 os_free(plain);
3708 os_free(packet);
3709
3710 return 0;
3711 }
3712
3713
3714 /* @returns 0 on success
3715 * -1 on error
3716 * -2 if FR_RRB_PAIRWISE is missing
3717 */
3718 static int wpa_ft_rrb_rx_r1(struct wpa_authenticator *wpa_auth,
3719 const u8 *src_addr, u8 type,
3720 const u8 *enc, size_t enc_len,
3721 const u8 *auth, size_t auth_len,
3722 const char *msgtype, u8 *s1kh_id_out,
3723 int (*cb)(struct wpa_authenticator *wpa_auth,
3724 const u8 *src_addr,
3725 const u8 *enc, size_t enc_len,
3726 const u8 *auth, size_t auth_len,
3727 int no_defer))
3728 {
3729 u8 *plain = NULL;
3730 size_t plain_len = 0;
3731 struct ft_remote_r0kh *r0kh, *r0kh_wildcard;
3732 const u8 *key;
3733 size_t key_len;
3734 int seq_ret;
3735 const u8 *f_r1kh_id, *f_s1kh_id, *f_r0kh_id;
3736 const u8 *f_pmk_r1_name, *f_pairwise, *f_pmk_r1;
3737 const u8 *f_expires_in;
3738 size_t f_r1kh_id_len, f_s1kh_id_len, f_r0kh_id_len;
3739 const u8 *f_identity, *f_radius_cui;
3740 const u8 *f_session_timeout;
3741 size_t f_pmk_r1_name_len, f_pairwise_len, f_pmk_r1_len;
3742 size_t f_expires_in_len;
3743 size_t f_identity_len, f_radius_cui_len;
3744 size_t f_session_timeout_len;
3745 int pairwise;
3746 int ret = -1;
3747 int expires_in;
3748 int session_timeout;
3749 struct vlan_description vlan;
3750 size_t pmk_r1_len;
3751
3752 RRB_GET_AUTH(FT_RRB_R0KH_ID, r0kh_id, msgtype, -1);
3753 wpa_hexdump(MSG_DEBUG, "FT: R0KH-ID", f_r0kh_id, f_r0kh_id_len);
3754
3755 RRB_GET_AUTH(FT_RRB_R1KH_ID, r1kh_id, msgtype, FT_R1KH_ID_LEN);
3756 wpa_printf(MSG_DEBUG, "FT: R1KH-ID=" MACSTR, MAC2STR(f_r1kh_id));
3757
3758 if (wpa_ft_rrb_check_r1kh(wpa_auth, f_r1kh_id)) {
3759 wpa_printf(MSG_DEBUG, "FT: R1KH-ID mismatch");
3760 goto out;
3761 }
3762
3763 wpa_ft_rrb_lookup_r0kh(wpa_auth, f_r0kh_id, f_r0kh_id_len, &r0kh,
3764 &r0kh_wildcard);
3765 if (r0kh) {
3766 key = r0kh->key;
3767 key_len = sizeof(r0kh->key);
3768 } else if (r0kh_wildcard) {
3769 wpa_printf(MSG_DEBUG, "FT: Using wildcard R0KH-ID");
3770 key = r0kh_wildcard->key;
3771 key_len = sizeof(r0kh_wildcard->key);
3772 } else {
3773 goto out;
3774 }
3775
3776 seq_ret = FT_RRB_SEQ_DROP;
3777 if (r0kh) {
3778 seq_ret = wpa_ft_rrb_seq_chk(r0kh->seq, src_addr, enc, enc_len,
3779 auth, auth_len, msgtype,
3780 cb ? 0 : 1);
3781 }
3782 if (cb && r0kh_wildcard &&
3783 (!r0kh || os_memcmp(r0kh->addr, src_addr, ETH_ALEN) != 0)) {
3784 /* wildcard: r0kh-id unknown or changed addr -> do a seq req */
3785 seq_ret = FT_RRB_SEQ_DEFER;
3786 }
3787
3788 if (seq_ret == FT_RRB_SEQ_DROP)
3789 goto out;
3790
3791 if (wpa_ft_rrb_decrypt(key, key_len, enc, enc_len, auth, auth_len,
3792 src_addr, type, &plain, &plain_len) < 0)
3793 goto out;
3794
3795 if (!r0kh)
3796 r0kh = wpa_ft_rrb_add_r0kh(wpa_auth, r0kh_wildcard, src_addr,
3797 f_r0kh_id, f_r0kh_id_len,
3798 wpa_auth->conf.rkh_pos_timeout);
3799 if (!r0kh)
3800 goto out;
3801
3802 if (seq_ret == FT_RRB_SEQ_DEFER) {
3803 wpa_ft_rrb_seq_req(wpa_auth, r0kh->seq, src_addr, f_r0kh_id,
3804 f_r0kh_id_len, f_r1kh_id, key, key_len,
3805 enc, enc_len, auth, auth_len, cb);
3806 goto out;
3807 }
3808
3809 wpa_ft_rrb_seq_accept(wpa_auth, r0kh->seq, src_addr, auth, auth_len,
3810 msgtype);
3811 wpa_ft_rrb_r0kh_replenish(wpa_auth, r0kh,
3812 wpa_auth->conf.rkh_pos_timeout);
3813
3814 RRB_GET(FT_RRB_S1KH_ID, s1kh_id, msgtype, ETH_ALEN);
3815 wpa_printf(MSG_DEBUG, "FT: S1KH-ID=" MACSTR, MAC2STR(f_s1kh_id));
3816
3817 if (s1kh_id_out)
3818 os_memcpy(s1kh_id_out, f_s1kh_id, ETH_ALEN);
3819
3820 ret = -2;
3821 RRB_GET(FT_RRB_PAIRWISE, pairwise, msgtype, sizeof(le16));
3822 wpa_hexdump(MSG_DEBUG, "FT: pairwise", f_pairwise, f_pairwise_len);
3823
3824 ret = -1;
3825 RRB_GET(FT_RRB_PMK_R1_NAME, pmk_r1_name, msgtype, WPA_PMK_NAME_LEN);
3826 wpa_hexdump(MSG_DEBUG, "FT: PMKR1Name",
3827 f_pmk_r1_name, WPA_PMK_NAME_LEN);
3828
3829 pmk_r1_len = PMK_LEN;
3830 if (wpa_ft_rrb_get_tlv(plain, plain_len, FT_RRB_PMK_R1, &f_pmk_r1_len,
3831 &f_pmk_r1) == 0 &&
3832 (f_pmk_r1_len == PMK_LEN || f_pmk_r1_len == SHA384_MAC_LEN))
3833 pmk_r1_len = f_pmk_r1_len;
3834 RRB_GET(FT_RRB_PMK_R1, pmk_r1, msgtype, pmk_r1_len);
3835 wpa_hexdump_key(MSG_DEBUG, "FT: PMK-R1", f_pmk_r1, pmk_r1_len);
3836
3837 pairwise = WPA_GET_LE16(f_pairwise);
3838
3839 RRB_GET_OPTIONAL(FT_RRB_EXPIRES_IN, expires_in, msgtype,
3840 sizeof(le16));
3841 if (f_expires_in)
3842 expires_in = WPA_GET_LE16(f_expires_in);
3843 else
3844 expires_in = 0;
3845
3846 wpa_printf(MSG_DEBUG, "FT: PMK-R1 %s - expires_in=%d", msgtype,
3847 expires_in);
3848
3849 if (wpa_ft_rrb_get_tlv_vlan(plain, plain_len, &vlan) < 0) {
3850 wpa_printf(MSG_DEBUG, "FT: Cannot parse vlan");
3851 wpa_ft_rrb_dump(plain, plain_len);
3852 goto out;
3853 }
3854
3855 wpa_printf(MSG_DEBUG, "FT: vlan %d%s",
3856 le_to_host16(vlan.untagged), vlan.tagged[0] ? "+" : "");
3857
3858 RRB_GET_OPTIONAL(FT_RRB_IDENTITY, identity, msgtype, -1);
3859 if (f_identity)
3860 wpa_hexdump_ascii(MSG_DEBUG, "FT: Identity", f_identity,
3861 f_identity_len);
3862
3863 RRB_GET_OPTIONAL(FT_RRB_RADIUS_CUI, radius_cui, msgtype, -1);
3864 if (f_radius_cui)
3865 wpa_hexdump_ascii(MSG_DEBUG, "FT: CUI", f_radius_cui,
3866 f_radius_cui_len);
3867
3868 RRB_GET_OPTIONAL(FT_RRB_SESSION_TIMEOUT, session_timeout, msgtype,
3869 sizeof(le32));
3870 if (f_session_timeout)
3871 session_timeout = WPA_GET_LE32(f_session_timeout);
3872 else
3873 session_timeout = 0;
3874 wpa_printf(MSG_DEBUG, "FT: session_timeout %d", session_timeout);
3875
3876 if (wpa_ft_store_pmk_r1(wpa_auth, f_s1kh_id, f_pmk_r1, pmk_r1_len,
3877 f_pmk_r1_name,
3878 pairwise, &vlan, expires_in, session_timeout,
3879 f_identity, f_identity_len, f_radius_cui,
3880 f_radius_cui_len) < 0)
3881 goto out;
3882
3883 ret = 0;
3884 out:
3885 if (plain) {
3886 os_memset(plain, 0, plain_len);
3887 os_free(plain);
3888 }
3889
3890 return ret;
3891
3892 }
3893
3894
3895 static void ft_finish_pull(struct wpa_state_machine *sm)
3896 {
3897 int res;
3898 u8 *resp_ies;
3899 size_t resp_ies_len;
3900 u16 status;
3901
3902 if (!sm->ft_pending_cb || !sm->ft_pending_req_ies)
3903 return;
3904
3905 res = wpa_ft_process_auth_req(sm, wpabuf_head(sm->ft_pending_req_ies),
3906 wpabuf_len(sm->ft_pending_req_ies),
3907 &resp_ies, &resp_ies_len);
3908 if (res < 0) {
3909 /* this loop is broken by ft_pending_pull_left_retries */
3910 wpa_printf(MSG_DEBUG,
3911 "FT: Callback postponed until response is available");
3912 return;
3913 }
3914 wpabuf_free(sm->ft_pending_req_ies);
3915 sm->ft_pending_req_ies = NULL;
3916 status = res;
3917 wpa_printf(MSG_DEBUG, "FT: Postponed auth callback result for " MACSTR
3918 " - status %u", MAC2STR(sm->addr), status);
3919
3920 sm->ft_pending_cb(sm->ft_pending_cb_ctx, sm->addr, sm->wpa_auth->addr,
3921 sm->ft_pending_auth_transaction + 1, status,
3922 resp_ies, resp_ies_len);
3923 os_free(resp_ies);
3924 }
3925
3926
3927 struct ft_get_sta_ctx {
3928 const u8 *nonce;
3929 const u8 *s1kh_id;
3930 struct wpa_state_machine *sm;
3931 };
3932
3933
3934 static int ft_get_sta_cb(struct wpa_state_machine *sm, void *ctx)
3935 {
3936 struct ft_get_sta_ctx *info = ctx;
3937
3938 if ((info->s1kh_id &&
3939 os_memcmp(info->s1kh_id, sm->addr, ETH_ALEN) != 0) ||
3940 os_memcmp(info->nonce, sm->ft_pending_pull_nonce,
3941 FT_RRB_NONCE_LEN) != 0 ||
3942 sm->ft_pending_cb == NULL || sm->ft_pending_req_ies == NULL)
3943 return 0;
3944
3945 info->sm = sm;
3946
3947 return 1;
3948 }
3949
3950
3951 static int wpa_ft_rrb_rx_resp(struct wpa_authenticator *wpa_auth,
3952 const u8 *src_addr,
3953 const u8 *enc, size_t enc_len,
3954 const u8 *auth, size_t auth_len,
3955 int no_defer)
3956 {
3957 const char *msgtype = "pull response";
3958 int nak, ret = -1;
3959 struct ft_get_sta_ctx ctx;
3960 u8 s1kh_id[ETH_ALEN];
3961 const u8 *f_nonce;
3962 size_t f_nonce_len;
3963
3964 wpa_printf(MSG_DEBUG, "FT: Received PMK-R1 pull response");
3965
3966 RRB_GET_AUTH(FT_RRB_NONCE, nonce, msgtype, FT_RRB_NONCE_LEN);
3967 wpa_hexdump(MSG_DEBUG, "FT: nonce", f_nonce, f_nonce_len);
3968
3969 os_memset(&ctx, 0, sizeof(ctx));
3970 ctx.nonce = f_nonce;
3971 if (!wpa_auth_for_each_sta(wpa_auth, ft_get_sta_cb, &ctx)) {
3972 /* nonce not found */
3973 wpa_printf(MSG_DEBUG, "FT: Invalid nonce");
3974 return -1;
3975 }
3976
3977 ret = wpa_ft_rrb_rx_r1(wpa_auth, src_addr, FT_PACKET_R0KH_R1KH_RESP,
3978 enc, enc_len, auth, auth_len, msgtype, s1kh_id,
3979 no_defer ? NULL : &wpa_ft_rrb_rx_resp);
3980 if (ret == -2) {
3981 ret = 0;
3982 nak = 1;
3983 } else {
3984 nak = 0;
3985 }
3986 if (ret < 0)
3987 return -1;
3988
3989 ctx.s1kh_id = s1kh_id;
3990 if (wpa_auth_for_each_sta(wpa_auth, ft_get_sta_cb, &ctx)) {
3991 wpa_printf(MSG_DEBUG,
3992 "FT: Response to a pending pull request for " MACSTR,
3993 MAC2STR(ctx.sm->addr));
3994 eloop_cancel_timeout(wpa_ft_expire_pull, ctx.sm, NULL);
3995 if (nak)
3996 ctx.sm->ft_pending_pull_left_retries = 0;
3997 ft_finish_pull(ctx.sm);
3998 }
3999
4000 out:
4001 return ret;
4002 }
4003
4004
4005 static int wpa_ft_rrb_rx_push(struct wpa_authenticator *wpa_auth,
4006 const u8 *src_addr,
4007 const u8 *enc, size_t enc_len,
4008 const u8 *auth, size_t auth_len, int no_defer)
4009 {
4010 const char *msgtype = "push";
4011
4012 wpa_printf(MSG_DEBUG, "FT: Received PMK-R1 push");
4013
4014 if (wpa_ft_rrb_rx_r1(wpa_auth, src_addr, FT_PACKET_R0KH_R1KH_PUSH,
4015 enc, enc_len, auth, auth_len, msgtype, NULL,
4016 no_defer ? NULL : wpa_ft_rrb_rx_push) < 0)
4017 return -1;
4018
4019 return 0;
4020 }
4021
4022
4023 static int wpa_ft_rrb_rx_seq(struct wpa_authenticator *wpa_auth,
4024 const u8 *src_addr, int type,
4025 const u8 *enc, size_t enc_len,
4026 const u8 *auth, size_t auth_len,
4027 struct ft_remote_seq **rkh_seq,
4028 u8 **key, size_t *key_len,
4029 struct ft_remote_r0kh **r0kh_out,
4030 struct ft_remote_r1kh **r1kh_out,
4031 struct ft_remote_r0kh **r0kh_wildcard_out,
4032 struct ft_remote_r1kh **r1kh_wildcard_out)
4033 {
4034 struct ft_remote_r0kh *r0kh = NULL;
4035 struct ft_remote_r1kh *r1kh = NULL;
4036 const u8 *f_r0kh_id, *f_r1kh_id;
4037 size_t f_r0kh_id_len, f_r1kh_id_len;
4038 int to_r0kh, to_r1kh;
4039 u8 *plain = NULL;
4040 size_t plain_len = 0;
4041 struct ft_remote_r0kh *r0kh_wildcard;
4042 struct ft_remote_r1kh *r1kh_wildcard;
4043
4044 RRB_GET_AUTH(FT_RRB_R0KH_ID, r0kh_id, "seq", -1);
4045 RRB_GET_AUTH(FT_RRB_R1KH_ID, r1kh_id, "seq", FT_R1KH_ID_LEN);
4046
4047 to_r0kh = !wpa_ft_rrb_check_r0kh(wpa_auth, f_r0kh_id, f_r0kh_id_len);
4048 to_r1kh = !wpa_ft_rrb_check_r1kh(wpa_auth, f_r1kh_id);
4049
4050 if (to_r0kh && to_r1kh) {
4051 wpa_printf(MSG_DEBUG, "FT: seq - local R0KH-ID and R1KH-ID");
4052 goto out;
4053 }
4054
4055 if (!to_r0kh && !to_r1kh) {
4056 wpa_printf(MSG_DEBUG, "FT: seq - remote R0KH-ID and R1KH-ID");
4057 goto out;
4058 }
4059
4060 if (!to_r0kh) {
4061 wpa_ft_rrb_lookup_r0kh(wpa_auth, f_r0kh_id, f_r0kh_id_len,
4062 &r0kh, &r0kh_wildcard);
4063 if (!r0kh_wildcard &&
4064 (!r0kh || os_memcmp(r0kh->addr, src_addr, ETH_ALEN) != 0)) {
4065 wpa_hexdump(MSG_DEBUG, "FT: Did not find R0KH-ID",
4066 f_r0kh_id, f_r0kh_id_len);
4067 goto out;
4068 }
4069 if (r0kh) {
4070 *key = r0kh->key;
4071 *key_len = sizeof(r0kh->key);
4072 } else {
4073 *key = r0kh_wildcard->key;
4074 *key_len = sizeof(r0kh_wildcard->key);
4075 }
4076 }
4077
4078 if (!to_r1kh) {
4079 wpa_ft_rrb_lookup_r1kh(wpa_auth, f_r1kh_id, &r1kh,
4080 &r1kh_wildcard);
4081 if (!r1kh_wildcard &&
4082 (!r1kh || os_memcmp(r1kh->addr, src_addr, ETH_ALEN) != 0)) {
4083 wpa_hexdump(MSG_DEBUG, "FT: Did not find R1KH-ID",
4084 f_r1kh_id, FT_R1KH_ID_LEN);
4085 goto out;
4086 }
4087 if (r1kh) {
4088 *key = r1kh->key;
4089 *key_len = sizeof(r1kh->key);
4090 } else {
4091 *key = r1kh_wildcard->key;
4092 *key_len = sizeof(r1kh_wildcard->key);
4093 }
4094 }
4095
4096 if (wpa_ft_rrb_decrypt(*key, *key_len, enc, enc_len, auth, auth_len,
4097 src_addr, type, &plain, &plain_len) < 0)
4098 goto out;
4099
4100 os_free(plain);
4101
4102 if (!to_r0kh) {
4103 if (!r0kh)
4104 r0kh = wpa_ft_rrb_add_r0kh(wpa_auth, r0kh_wildcard,
4105 src_addr, f_r0kh_id,
4106 f_r0kh_id_len,
4107 ftRRBseqTimeout);
4108 if (!r0kh)
4109 goto out;
4110
4111 wpa_ft_rrb_r0kh_replenish(wpa_auth, r0kh, ftRRBseqTimeout);
4112 *rkh_seq = r0kh->seq;
4113 if (r0kh_out)
4114 *r0kh_out = r0kh;
4115 if (r0kh_wildcard_out)
4116 *r0kh_wildcard_out = r0kh_wildcard;
4117 }
4118
4119 if (!to_r1kh) {
4120 if (!r1kh)
4121 r1kh = wpa_ft_rrb_add_r1kh(wpa_auth, r1kh_wildcard,
4122 src_addr, f_r1kh_id,
4123 ftRRBseqTimeout);
4124 if (!r1kh)
4125 goto out;
4126
4127 wpa_ft_rrb_r1kh_replenish(wpa_auth, r1kh, ftRRBseqTimeout);
4128 *rkh_seq = r1kh->seq;
4129 if (r1kh_out)
4130 *r1kh_out = r1kh;
4131 if (r1kh_wildcard_out)
4132 *r1kh_wildcard_out = r1kh_wildcard;
4133 }
4134
4135 return 0;
4136 out:
4137 return -1;
4138 }
4139
4140
4141 static int wpa_ft_rrb_rx_seq_req(struct wpa_authenticator *wpa_auth,
4142 const u8 *src_addr,
4143 const u8 *enc, size_t enc_len,
4144 const u8 *auth, size_t auth_len,
4145 int no_defer)
4146 {
4147 int ret = -1;
4148 struct ft_rrb_seq f_seq;
4149 const u8 *f_nonce, *f_r0kh_id, *f_r1kh_id;
4150 size_t f_nonce_len, f_r0kh_id_len, f_r1kh_id_len;
4151 struct ft_remote_seq *rkh_seq = NULL;
4152 u8 *packet = NULL, *key = NULL;
4153 size_t packet_len = 0, key_len = 0;
4154 struct tlv_list seq_resp_auth[5];
4155
4156 wpa_printf(MSG_DEBUG, "FT: Received sequence number request");
4157
4158 if (wpa_ft_rrb_rx_seq(wpa_auth, src_addr, FT_PACKET_R0KH_R1KH_SEQ_REQ,
4159 enc, enc_len, auth, auth_len, &rkh_seq, &key,
4160 &key_len, NULL, NULL, NULL, NULL) < 0)
4161 goto out;
4162
4163 RRB_GET_AUTH(FT_RRB_NONCE, nonce, "seq request", FT_RRB_NONCE_LEN);
4164 wpa_hexdump(MSG_DEBUG, "FT: seq request - nonce", f_nonce, f_nonce_len);
4165
4166 RRB_GET_AUTH(FT_RRB_R0KH_ID, r0kh_id, "seq", -1);
4167 RRB_GET_AUTH(FT_RRB_R1KH_ID, r1kh_id, "seq", FT_R1KH_ID_LEN);
4168
4169 if (wpa_ft_new_seq(rkh_seq, &f_seq) < 0) {
4170 wpa_printf(MSG_DEBUG, "FT: Failed to get seq num");
4171 goto out;
4172 }
4173
4174 seq_resp_auth[0].type = FT_RRB_NONCE;
4175 seq_resp_auth[0].len = f_nonce_len;
4176 seq_resp_auth[0].data = f_nonce;
4177 seq_resp_auth[1].type = FT_RRB_SEQ;
4178 seq_resp_auth[1].len = sizeof(f_seq);
4179 seq_resp_auth[1].data = (u8 *) &f_seq;
4180 seq_resp_auth[2].type = FT_RRB_R0KH_ID;
4181 seq_resp_auth[2].len = f_r0kh_id_len;
4182 seq_resp_auth[2].data = f_r0kh_id;
4183 seq_resp_auth[3].type = FT_RRB_R1KH_ID;
4184 seq_resp_auth[3].len = FT_R1KH_ID_LEN;
4185 seq_resp_auth[3].data = f_r1kh_id;
4186 seq_resp_auth[4].type = FT_RRB_LAST_EMPTY;
4187 seq_resp_auth[4].len = 0;
4188 seq_resp_auth[4].data = NULL;
4189
4190 if (wpa_ft_rrb_build(key, key_len, NULL, NULL, seq_resp_auth, NULL,
4191 wpa_auth->addr, FT_PACKET_R0KH_R1KH_SEQ_RESP,
4192 &packet, &packet_len) < 0)
4193 goto out;
4194
4195 wpa_ft_rrb_oui_send(wpa_auth, src_addr,
4196 FT_PACKET_R0KH_R1KH_SEQ_RESP, packet,
4197 packet_len);
4198
4199 out:
4200 os_free(packet);
4201
4202 return ret;
4203 }
4204
4205
4206 static int wpa_ft_rrb_rx_seq_resp(struct wpa_authenticator *wpa_auth,
4207 const u8 *src_addr,
4208 const u8 *enc, size_t enc_len,
4209 const u8 *auth, size_t auth_len,
4210 int no_defer)
4211 {
4212 u8 *key = NULL;
4213 size_t key_len = 0;
4214 struct ft_remote_r0kh *r0kh = NULL, *r0kh_wildcard = NULL;
4215 struct ft_remote_r1kh *r1kh = NULL, *r1kh_wildcard = NULL;
4216 const u8 *f_nonce, *f_seq;
4217 size_t f_nonce_len, f_seq_len;
4218 struct ft_remote_seq *rkh_seq = NULL;
4219 struct ft_remote_item *item;
4220 struct os_reltime now, now_remote;
4221 int seq_ret, found;
4222 const struct ft_rrb_seq *msg_both;
4223 u32 msg_dom, msg_seq;
4224
4225 wpa_printf(MSG_DEBUG, "FT: Received sequence number response");
4226
4227 if (wpa_ft_rrb_rx_seq(wpa_auth, src_addr, FT_PACKET_R0KH_R1KH_SEQ_RESP,
4228 enc, enc_len, auth, auth_len, &rkh_seq, &key,
4229 &key_len, &r0kh, &r1kh, &r0kh_wildcard,
4230 &r1kh_wildcard) < 0)
4231 goto out;
4232
4233 RRB_GET_AUTH(FT_RRB_NONCE, nonce, "seq response", FT_RRB_NONCE_LEN);
4234 wpa_hexdump(MSG_DEBUG, "FT: seq response - nonce", f_nonce,
4235 f_nonce_len);
4236
4237 found = 0;
4238 dl_list_for_each(item, &rkh_seq->rx.queue, struct ft_remote_item,
4239 list) {
4240 if (os_memcmp_const(f_nonce, item->nonce,
4241 FT_RRB_NONCE_LEN) != 0 ||
4242 os_get_reltime(&now) < 0 ||
4243 os_reltime_expired(&now, &item->nonce_ts, ftRRBseqTimeout))
4244 continue;
4245
4246 found = 1;
4247 break;
4248 }
4249 if (!found) {
4250 wpa_printf(MSG_DEBUG, "FT: seq response - bad nonce");
4251 goto out;
4252 }
4253
4254 if (r0kh) {
4255 wpa_ft_rrb_r0kh_replenish(wpa_auth, r0kh,
4256 wpa_auth->conf.rkh_pos_timeout);
4257 if (r0kh_wildcard)
4258 os_memcpy(r0kh->addr, src_addr, ETH_ALEN);
4259 }
4260
4261 if (r1kh) {
4262 wpa_ft_rrb_r1kh_replenish(wpa_auth, r1kh,
4263 wpa_auth->conf.rkh_pos_timeout);
4264 if (r1kh_wildcard)
4265 os_memcpy(r1kh->addr, src_addr, ETH_ALEN);
4266 }
4267
4268 seq_ret = wpa_ft_rrb_seq_chk(rkh_seq, src_addr, enc, enc_len, auth,
4269 auth_len, "seq response", 1);
4270 if (seq_ret == FT_RRB_SEQ_OK) {
4271 wpa_printf(MSG_DEBUG, "FT: seq response - valid seq number");
4272 wpa_ft_rrb_seq_accept(wpa_auth, rkh_seq, src_addr, auth,
4273 auth_len, "seq response");
4274 } else {
4275 wpa_printf(MSG_DEBUG, "FT: seq response - reset seq number");
4276
4277 RRB_GET_AUTH(FT_RRB_SEQ, seq, "seq response",
4278 sizeof(*msg_both));
4279 msg_both = (const struct ft_rrb_seq *) f_seq;
4280
4281 msg_dom = le_to_host32(msg_both->dom);
4282 msg_seq = le_to_host32(msg_both->seq);
4283 now_remote.sec = le_to_host32(msg_both->ts);
4284 now_remote.usec = 0;
4285
4286 rkh_seq->rx.num_last = 2;
4287 rkh_seq->rx.dom = msg_dom;
4288 rkh_seq->rx.offsetidx = 0;
4289 /* Accept some older, possibly cached packets as well */
4290 rkh_seq->rx.last[0] = msg_seq - FT_REMOTE_SEQ_BACKLOG -
4291 dl_list_len(&rkh_seq->rx.queue);
4292 rkh_seq->rx.last[1] = msg_seq;
4293
4294 /* local time - offset = remote time
4295 * <=> local time - remote time = offset */
4296 os_reltime_sub(&now, &now_remote, &rkh_seq->rx.time_offset);
4297 }
4298
4299 wpa_ft_rrb_seq_flush(wpa_auth, rkh_seq, 1);
4300
4301 return 0;
4302 out:
4303 return -1;
4304 }
4305
4306
4307 int wpa_ft_rrb_rx(struct wpa_authenticator *wpa_auth, const u8 *src_addr,
4308 const u8 *data, size_t data_len)
4309 {
4310 struct ft_rrb_frame *frame;
4311 u16 alen;
4312 const u8 *pos, *end, *start;
4313 u8 action;
4314 const u8 *sta_addr, *target_ap_addr;
4315
4316 wpa_printf(MSG_DEBUG, "FT: RRB received frame from remote AP " MACSTR,
4317 MAC2STR(src_addr));
4318
4319 if (data_len < sizeof(*frame)) {
4320 wpa_printf(MSG_DEBUG, "FT: Too short RRB frame (data_len=%lu)",
4321 (unsigned long) data_len);
4322 return -1;
4323 }
4324
4325 pos = data;
4326 frame = (struct ft_rrb_frame *) pos;
4327 pos += sizeof(*frame);
4328
4329 alen = le_to_host16(frame->action_length);
4330 wpa_printf(MSG_DEBUG, "FT: RRB frame - frame_type=%d packet_type=%d "
4331 "action_length=%d ap_address=" MACSTR,
4332 frame->frame_type, frame->packet_type, alen,
4333 MAC2STR(frame->ap_address));
4334
4335 if (frame->frame_type != RSN_REMOTE_FRAME_TYPE_FT_RRB) {
4336 /* Discard frame per IEEE Std 802.11r-2008, 11A.10.3 */
4337 wpa_printf(MSG_DEBUG, "FT: RRB discarded frame with "
4338 "unrecognized type %d", frame->frame_type);
4339 return -1;
4340 }
4341
4342 if (alen > data_len - sizeof(*frame)) {
4343 wpa_printf(MSG_DEBUG, "FT: RRB frame too short for action "
4344 "frame");
4345 return -1;
4346 }
4347
4348 wpa_hexdump(MSG_MSGDUMP, "FT: RRB - FT Action frame", pos, alen);
4349
4350 if (alen < 1 + 1 + 2 * ETH_ALEN) {
4351 wpa_printf(MSG_DEBUG, "FT: Too short RRB frame (not enough "
4352 "room for Action Frame body); alen=%lu",
4353 (unsigned long) alen);
4354 return -1;
4355 }
4356 start = pos;
4357 end = pos + alen;
4358
4359 if (*pos != WLAN_ACTION_FT) {
4360 wpa_printf(MSG_DEBUG, "FT: Unexpected Action frame category "
4361 "%d", *pos);
4362 return -1;
4363 }
4364
4365 pos++;
4366 action = *pos++;
4367 sta_addr = pos;
4368 pos += ETH_ALEN;
4369 target_ap_addr = pos;
4370 pos += ETH_ALEN;
4371 wpa_printf(MSG_DEBUG, "FT: RRB Action Frame: action=%d sta_addr="
4372 MACSTR " target_ap_addr=" MACSTR,
4373 action, MAC2STR(sta_addr), MAC2STR(target_ap_addr));
4374
4375 if (frame->packet_type == FT_PACKET_REQUEST) {
4376 wpa_printf(MSG_DEBUG, "FT: FT Packet Type - Request");
4377
4378 if (action != 1) {
4379 wpa_printf(MSG_DEBUG, "FT: Unexpected Action %d in "
4380 "RRB Request", action);
4381 return -1;
4382 }
4383
4384 if (os_memcmp(target_ap_addr, wpa_auth->addr, ETH_ALEN) != 0) {
4385 wpa_printf(MSG_DEBUG, "FT: Target AP address in the "
4386 "RRB Request does not match with own "
4387 "address");
4388 return -1;
4389 }
4390
4391 if (wpa_ft_rrb_rx_request(wpa_auth, frame->ap_address,
4392 sta_addr, pos, end - pos) < 0)
4393 return -1;
4394 } else if (frame->packet_type == FT_PACKET_RESPONSE) {
4395 u16 status_code;
4396
4397 if (end - pos < 2) {
4398 wpa_printf(MSG_DEBUG, "FT: Not enough room for status "
4399 "code in RRB Response");
4400 return -1;
4401 }
4402 status_code = WPA_GET_LE16(pos);
4403 pos += 2;
4404
4405 wpa_printf(MSG_DEBUG, "FT: FT Packet Type - Response "
4406 "(status_code=%d)", status_code);
4407
4408 if (wpa_ft_action_send(wpa_auth, sta_addr, start, alen) < 0)
4409 return -1;
4410 } else {
4411 wpa_printf(MSG_DEBUG, "FT: RRB discarded frame with unknown "
4412 "packet_type %d", frame->packet_type);
4413 return -1;
4414 }
4415
4416 if (end > pos) {
4417 wpa_hexdump(MSG_DEBUG, "FT: Ignore extra data in end",
4418 pos, end - pos);
4419 }
4420
4421 return 0;
4422 }
4423
4424
4425 void wpa_ft_rrb_oui_rx(struct wpa_authenticator *wpa_auth, const u8 *src_addr,
4426 const u8 *dst_addr, u8 oui_suffix, const u8 *data,
4427 size_t data_len)
4428 {
4429 const u8 *auth, *enc;
4430 size_t alen, elen;
4431 int no_defer = 0;
4432
4433 wpa_printf(MSG_DEBUG, "FT: RRB-OUI received frame from remote AP "
4434 MACSTR, MAC2STR(src_addr));
4435 wpa_printf(MSG_DEBUG, "FT: RRB-OUI frame - oui_suffix=%d", oui_suffix);
4436 wpa_hexdump(MSG_MSGDUMP, "FT: RRB frame payload", data, data_len);
4437
4438 if (is_multicast_ether_addr(src_addr)) {
4439 wpa_printf(MSG_DEBUG,
4440 "FT: RRB-OUI received frame from multicast address "
4441 MACSTR, MAC2STR(src_addr));
4442 return;
4443 }
4444
4445 if (is_multicast_ether_addr(dst_addr)) {
4446 wpa_printf(MSG_DEBUG,
4447 "FT: RRB-OUI received frame from remote AP " MACSTR
4448 " to multicast address " MACSTR,
4449 MAC2STR(src_addr), MAC2STR(dst_addr));
4450 no_defer = 1;
4451 }
4452
4453 if (data_len < sizeof(u16)) {
4454 wpa_printf(MSG_DEBUG, "FT: RRB-OUI frame too short");
4455 return;
4456 }
4457
4458 alen = WPA_GET_LE16(data);
4459 if (data_len < sizeof(u16) + alen) {
4460 wpa_printf(MSG_DEBUG, "FT: RRB-OUI frame too short");
4461 return;
4462 }
4463
4464 auth = data + sizeof(u16);
4465 wpa_hexdump(MSG_MSGDUMP, "FT: Authenticated payload", auth, alen);
4466 enc = data + sizeof(u16) + alen;
4467 elen = data_len - sizeof(u16) - alen;
4468 wpa_hexdump(MSG_MSGDUMP, "FT: Encrypted payload", enc, elen);
4469
4470 switch (oui_suffix) {
4471 case FT_PACKET_R0KH_R1KH_PULL:
4472 wpa_ft_rrb_rx_pull(wpa_auth, src_addr, enc, elen, auth, alen,
4473 no_defer);
4474 break;
4475 case FT_PACKET_R0KH_R1KH_RESP:
4476 wpa_ft_rrb_rx_resp(wpa_auth, src_addr, enc, elen, auth, alen,
4477 no_defer);
4478 break;
4479 case FT_PACKET_R0KH_R1KH_PUSH:
4480 wpa_ft_rrb_rx_push(wpa_auth, src_addr, enc, elen, auth, alen,
4481 no_defer);
4482 break;
4483 case FT_PACKET_R0KH_R1KH_SEQ_REQ:
4484 wpa_ft_rrb_rx_seq_req(wpa_auth, src_addr, enc, elen, auth, alen,
4485 no_defer);
4486 break;
4487 case FT_PACKET_R0KH_R1KH_SEQ_RESP:
4488 wpa_ft_rrb_rx_seq_resp(wpa_auth, src_addr, enc, elen, auth,
4489 alen, no_defer);
4490 break;
4491 }
4492 }
4493
4494
4495 static int wpa_ft_generate_pmk_r1(struct wpa_authenticator *wpa_auth,
4496 struct wpa_ft_pmk_r0_sa *pmk_r0,
4497 struct ft_remote_r1kh *r1kh,
4498 const u8 *s1kh_id)
4499 {
4500 u8 *packet;
4501 size_t packet_len;
4502 struct ft_rrb_seq f_seq;
4503 struct tlv_list push[] = {
4504 { .type = FT_RRB_S1KH_ID, .len = ETH_ALEN,
4505 .data = s1kh_id },
4506 { .type = FT_RRB_PMK_R0_NAME, .len = WPA_PMK_NAME_LEN,
4507 .data = pmk_r0->pmk_r0_name },
4508 { .type = FT_RRB_LAST_EMPTY, .len = 0, .data = NULL },
4509 };
4510 struct tlv_list push_auth[] = {
4511 { .type = FT_RRB_SEQ, .len = sizeof(f_seq),
4512 .data = (u8 *) &f_seq },
4513 { .type = FT_RRB_R0KH_ID,
4514 .len = wpa_auth->conf.r0_key_holder_len,
4515 .data = wpa_auth->conf.r0_key_holder },
4516 { .type = FT_RRB_R1KH_ID, .len = FT_R1KH_ID_LEN,
4517 .data = r1kh->id },
4518 { .type = FT_RRB_LAST_EMPTY, .len = 0, .data = NULL },
4519 };
4520
4521 if (wpa_ft_new_seq(r1kh->seq, &f_seq) < 0) {
4522 wpa_printf(MSG_DEBUG, "FT: Failed to get seq num");
4523 return -1;
4524 }
4525
4526 if (wpa_ft_rrb_build_r0(r1kh->key, sizeof(r1kh->key), push, pmk_r0,
4527 r1kh->id, s1kh_id, push_auth, wpa_auth->addr,
4528 FT_PACKET_R0KH_R1KH_PUSH,
4529 &packet, &packet_len) < 0)
4530 return -1;
4531
4532 wpa_ft_rrb_oui_send(wpa_auth, r1kh->addr, FT_PACKET_R0KH_R1KH_PUSH,
4533 packet, packet_len);
4534
4535 os_free(packet);
4536 return 0;
4537 }
4538
4539
4540 void wpa_ft_push_pmk_r1(struct wpa_authenticator *wpa_auth, const u8 *addr)
4541 {
4542 struct wpa_ft_pmk_cache *cache = wpa_auth->ft_pmk_cache;
4543 struct wpa_ft_pmk_r0_sa *r0, *r0found = NULL;
4544 struct ft_remote_r1kh *r1kh;
4545
4546 if (!wpa_auth->conf.pmk_r1_push)
4547 return;
4548 if (!wpa_auth->conf.r1kh_list)
4549 return;
4550
4551 dl_list_for_each(r0, &cache->pmk_r0, struct wpa_ft_pmk_r0_sa, list) {
4552 if (os_memcmp(r0->spa, addr, ETH_ALEN) == 0) {
4553 r0found = r0;
4554 break;
4555 }
4556 }
4557
4558 r0 = r0found;
4559 if (r0 == NULL || r0->pmk_r1_pushed)
4560 return;
4561 r0->pmk_r1_pushed = 1;
4562
4563 wpa_printf(MSG_DEBUG, "FT: Deriving and pushing PMK-R1 keys to R1KHs "
4564 "for STA " MACSTR, MAC2STR(addr));
4565
4566 for (r1kh = *wpa_auth->conf.r1kh_list; r1kh; r1kh = r1kh->next) {
4567 if (is_zero_ether_addr(r1kh->addr) ||
4568 is_zero_ether_addr(r1kh->id))
4569 continue;
4570 if (wpa_ft_rrb_init_r1kh_seq(r1kh) < 0)
4571 continue;
4572 wpa_ft_generate_pmk_r1(wpa_auth, r0, r1kh, addr);
4573 }
4574 }
4575
4576 #endif /* CONFIG_IEEE80211R_AP */
Unnamed repository; edit this file 'description' to name the repository.