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