2 * WPA/RSN - Shared functions for supplicant and authenticator
3 * Copyright (c) 2002-2013, Jouni Malinen <j@w1.fi>
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
12 #include "crypto/md5.h"
13 #include "crypto/sha1.h"
14 #include "crypto/sha256.h"
15 #include "crypto/aes_wrap.h"
16 #include "crypto/crypto.h"
17 #include "ieee802_11_defs.h"
19 #include "wpa_common.h"
23 * wpa_eapol_key_mic - Calculate EAPOL-Key MIC
24 * @key: EAPOL-Key Key Confirmation Key (KCK)
25 * @akmp: WPA_KEY_MGMT_* used in key derivation
26 * @ver: Key descriptor version (WPA_KEY_INFO_TYPE_*)
27 * @buf: Pointer to the beginning of the EAPOL header (version field)
28 * @len: Length of the EAPOL frame (from EAPOL header to the end of the frame)
29 * @mic: Pointer to the buffer to which the EAPOL-Key MIC is written
30 * Returns: 0 on success, -1 on failure
32 * Calculate EAPOL-Key MIC for an EAPOL-Key packet. The EAPOL-Key MIC field has
33 * to be cleared (all zeroes) when calling this function.
35 * Note: 'IEEE Std 802.11i-2004 - 8.5.2 EAPOL-Key frames' has an error in the
36 * description of the Key MIC calculation. It includes packet data from the
37 * beginning of the EAPOL-Key header, not EAPOL header. This incorrect change
38 * happened during final editing of the standard and the correct behavior is
39 * defined in the last draft (IEEE 802.11i/D10).
41 int wpa_eapol_key_mic(const u8 *key, int akmp, int ver, const u8 *buf,
44 u8 hash[SHA256_MAC_LEN];
48 case WPA_KEY_INFO_TYPE_HMAC_MD5_RC4:
49 return hmac_md5(key, 16, buf, len, mic);
50 #endif /* CONFIG_FIPS */
51 case WPA_KEY_INFO_TYPE_HMAC_SHA1_AES:
52 if (hmac_sha1(key, 16, buf, len, hash))
54 os_memcpy(mic, hash, MD5_MAC_LEN);
56 #if defined(CONFIG_IEEE80211R) || defined(CONFIG_IEEE80211W)
57 case WPA_KEY_INFO_TYPE_AES_128_CMAC:
58 return omac1_aes_128(key, buf, len, mic);
59 #endif /* CONFIG_IEEE80211R || CONFIG_IEEE80211W */
60 case WPA_KEY_INFO_TYPE_AKM_DEFINED:
63 case WPA_KEY_MGMT_OSEN:
64 return omac1_aes_128(key, buf, len, mic);
65 #endif /* CONFIG_HS20 */
67 case WPA_KEY_MGMT_IEEE8021X_SUITE_B:
68 if (hmac_sha256(key, 16, buf, len, hash))
70 os_memcpy(mic, hash, MD5_MAC_LEN);
72 #endif /* CONFIG_SUITEB */
86 * wpa_pmk_to_ptk - Calculate PTK from PMK, addresses, and nonces
87 * @pmk: Pairwise master key
88 * @pmk_len: Length of PMK
89 * @label: Label to use in derivation
92 * @nonce1: ANonce or SNonce
93 * @nonce2: SNonce or ANonce
94 * @ptk: Buffer for pairwise transient key
95 * @ptk_len: Length of PTK
96 * @use_sha256: Whether to use SHA256-based KDF
98 * IEEE Std 802.11i-2004 - 8.5.1.2 Pairwise key hierarchy
99 * PTK = PRF-X(PMK, "Pairwise key expansion",
100 * Min(AA, SA) || Max(AA, SA) ||
101 * Min(ANonce, SNonce) || Max(ANonce, SNonce))
103 * STK = PRF-X(SMK, "Peer key expansion",
104 * Min(MAC_I, MAC_P) || Max(MAC_I, MAC_P) ||
105 * Min(INonce, PNonce) || Max(INonce, PNonce))
107 void wpa_pmk_to_ptk(const u8 *pmk, size_t pmk_len, const char *label,
108 const u8 *addr1, const u8 *addr2,
109 const u8 *nonce1, const u8 *nonce2,
110 u8 *ptk, size_t ptk_len, int use_sha256)
112 u8 data[2 * ETH_ALEN + 2 * WPA_NONCE_LEN];
114 if (os_memcmp(addr1, addr2, ETH_ALEN) < 0) {
115 os_memcpy(data, addr1, ETH_ALEN);
116 os_memcpy(data + ETH_ALEN, addr2, ETH_ALEN);
118 os_memcpy(data, addr2, ETH_ALEN);
119 os_memcpy(data + ETH_ALEN, addr1, ETH_ALEN);
122 if (os_memcmp(nonce1, nonce2, WPA_NONCE_LEN) < 0) {
123 os_memcpy(data + 2 * ETH_ALEN, nonce1, WPA_NONCE_LEN);
124 os_memcpy(data + 2 * ETH_ALEN + WPA_NONCE_LEN, nonce2,
127 os_memcpy(data + 2 * ETH_ALEN, nonce2, WPA_NONCE_LEN);
128 os_memcpy(data + 2 * ETH_ALEN + WPA_NONCE_LEN, nonce1,
132 #ifdef CONFIG_IEEE80211W
134 sha256_prf(pmk, pmk_len, label, data, sizeof(data),
137 #endif /* CONFIG_IEEE80211W */
138 sha1_prf(pmk, pmk_len, label, data, sizeof(data), ptk,
141 wpa_printf(MSG_DEBUG, "WPA: PTK derivation - A1=" MACSTR " A2=" MACSTR,
142 MAC2STR(addr1), MAC2STR(addr2));
143 wpa_hexdump(MSG_DEBUG, "WPA: Nonce1", nonce1, WPA_NONCE_LEN);
144 wpa_hexdump(MSG_DEBUG, "WPA: Nonce2", nonce2, WPA_NONCE_LEN);
145 wpa_hexdump_key(MSG_DEBUG, "WPA: PMK", pmk, pmk_len);
146 wpa_hexdump_key(MSG_DEBUG, "WPA: PTK", ptk, ptk_len);
150 #ifdef CONFIG_IEEE80211R
151 int wpa_ft_mic(const u8 *kck, const u8 *sta_addr, const u8 *ap_addr,
152 u8 transaction_seqnum, const u8 *mdie, size_t mdie_len,
153 const u8 *ftie, size_t ftie_len,
154 const u8 *rsnie, size_t rsnie_len,
155 const u8 *ric, size_t ric_len, u8 *mic)
160 buf_len = 2 * ETH_ALEN + 1 + mdie_len + ftie_len + rsnie_len + ric_len;
161 buf = os_malloc(buf_len);
166 os_memcpy(pos, sta_addr, ETH_ALEN);
168 os_memcpy(pos, ap_addr, ETH_ALEN);
170 *pos++ = transaction_seqnum;
172 os_memcpy(pos, rsnie, rsnie_len);
176 os_memcpy(pos, mdie, mdie_len);
180 struct rsn_ftie *_ftie;
181 os_memcpy(pos, ftie, ftie_len);
182 if (ftie_len < 2 + sizeof(*_ftie)) {
186 _ftie = (struct rsn_ftie *) (pos + 2);
187 os_memset(_ftie->mic, 0, sizeof(_ftie->mic));
191 os_memcpy(pos, ric, ric_len);
195 wpa_hexdump(MSG_MSGDUMP, "FT: MIC data", buf, pos - buf);
196 if (omac1_aes_128(kck, buf, pos - buf, mic)) {
207 static int wpa_ft_parse_ftie(const u8 *ie, size_t ie_len,
208 struct wpa_ft_ies *parse)
213 parse->ftie_len = ie_len;
215 pos = ie + sizeof(struct rsn_ftie);
218 while (pos + 2 <= end && pos + 2 + pos[1] <= end) {
220 case FTIE_SUBELEM_R1KH_ID:
221 if (pos[1] != FT_R1KH_ID_LEN) {
222 wpa_printf(MSG_DEBUG, "FT: Invalid R1KH-ID "
223 "length in FTIE: %d", pos[1]);
226 parse->r1kh_id = pos + 2;
228 case FTIE_SUBELEM_GTK:
229 parse->gtk = pos + 2;
230 parse->gtk_len = pos[1];
232 case FTIE_SUBELEM_R0KH_ID:
233 if (pos[1] < 1 || pos[1] > FT_R0KH_ID_MAX_LEN) {
234 wpa_printf(MSG_DEBUG, "FT: Invalid R0KH-ID "
235 "length in FTIE: %d", pos[1]);
238 parse->r0kh_id = pos + 2;
239 parse->r0kh_id_len = pos[1];
241 #ifdef CONFIG_IEEE80211W
242 case FTIE_SUBELEM_IGTK:
243 parse->igtk = pos + 2;
244 parse->igtk_len = pos[1];
246 #endif /* CONFIG_IEEE80211W */
256 int wpa_ft_parse_ies(const u8 *ies, size_t ies_len,
257 struct wpa_ft_ies *parse)
260 struct wpa_ie_data data;
262 const struct rsn_ftie *ftie;
263 int prot_ie_count = 0;
265 os_memset(parse, 0, sizeof(*parse));
271 while (pos + 2 <= end && pos + 2 + pos[1] <= end) {
274 parse->rsn = pos + 2;
275 parse->rsn_len = pos[1];
276 ret = wpa_parse_wpa_ie_rsn(parse->rsn - 2,
280 wpa_printf(MSG_DEBUG, "FT: Failed to parse "
284 if (data.num_pmkid == 1 && data.pmkid)
285 parse->rsn_pmkid = data.pmkid;
287 case WLAN_EID_MOBILITY_DOMAIN:
288 parse->mdie = pos + 2;
289 parse->mdie_len = pos[1];
291 case WLAN_EID_FAST_BSS_TRANSITION:
292 if (pos[1] < sizeof(*ftie))
294 ftie = (const struct rsn_ftie *) (pos + 2);
295 prot_ie_count = ftie->mic_control[1];
296 if (wpa_ft_parse_ftie(pos + 2, pos[1], parse) < 0)
299 case WLAN_EID_TIMEOUT_INTERVAL:
300 parse->tie = pos + 2;
301 parse->tie_len = pos[1];
303 case WLAN_EID_RIC_DATA:
304 if (parse->ric == NULL)
312 if (prot_ie_count == 0)
313 return 0; /* no MIC */
316 * Check that the protected IE count matches with IEs included in the
325 if (prot_ie_count < 0) {
326 wpa_printf(MSG_DEBUG, "FT: Some required IEs not included in "
327 "the protected IE count");
331 if (prot_ie_count == 0 && parse->ric) {
332 wpa_printf(MSG_DEBUG, "FT: RIC IE(s) in the frame, but not "
333 "included in protected IE count");
337 /* Determine the end of the RIC IE(s) */
339 while (pos && pos + 2 <= end && pos + 2 + pos[1] <= end &&
344 parse->ric_len = pos - parse->ric;
346 wpa_printf(MSG_DEBUG, "FT: %d protected IEs missing from "
347 "frame", (int) prot_ie_count);
353 #endif /* CONFIG_IEEE80211R */
356 static int rsn_selector_to_bitfield(const u8 *s)
358 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_NONE)
359 return WPA_CIPHER_NONE;
360 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_WEP40)
361 return WPA_CIPHER_WEP40;
362 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_TKIP)
363 return WPA_CIPHER_TKIP;
364 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_CCMP)
365 return WPA_CIPHER_CCMP;
366 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_WEP104)
367 return WPA_CIPHER_WEP104;
368 #ifdef CONFIG_IEEE80211W
369 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_AES_128_CMAC)
370 return WPA_CIPHER_AES_128_CMAC;
371 #endif /* CONFIG_IEEE80211W */
372 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_GCMP)
373 return WPA_CIPHER_GCMP;
374 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_CCMP_256)
375 return WPA_CIPHER_CCMP_256;
376 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_GCMP_256)
377 return WPA_CIPHER_GCMP_256;
378 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_BIP_GMAC_128)
379 return WPA_CIPHER_BIP_GMAC_128;
380 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_BIP_GMAC_256)
381 return WPA_CIPHER_BIP_GMAC_256;
382 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_BIP_CMAC_256)
383 return WPA_CIPHER_BIP_CMAC_256;
384 if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_NO_GROUP_ADDRESSED)
385 return WPA_CIPHER_GTK_NOT_USED;
390 static int rsn_key_mgmt_to_bitfield(const u8 *s)
392 if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_UNSPEC_802_1X)
393 return WPA_KEY_MGMT_IEEE8021X;
394 if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X)
395 return WPA_KEY_MGMT_PSK;
396 #ifdef CONFIG_IEEE80211R
397 if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_FT_802_1X)
398 return WPA_KEY_MGMT_FT_IEEE8021X;
399 if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_FT_PSK)
400 return WPA_KEY_MGMT_FT_PSK;
401 #endif /* CONFIG_IEEE80211R */
402 #ifdef CONFIG_IEEE80211W
403 if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_802_1X_SHA256)
404 return WPA_KEY_MGMT_IEEE8021X_SHA256;
405 if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_PSK_SHA256)
406 return WPA_KEY_MGMT_PSK_SHA256;
407 #endif /* CONFIG_IEEE80211W */
409 if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_SAE)
410 return WPA_KEY_MGMT_SAE;
411 if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_FT_SAE)
412 return WPA_KEY_MGMT_FT_SAE;
413 #endif /* CONFIG_SAE */
414 if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_802_1X_SUITE_B)
415 return WPA_KEY_MGMT_IEEE8021X_SUITE_B;
420 static int wpa_cipher_valid_group(int cipher)
422 return wpa_cipher_valid_pairwise(cipher) ||
423 cipher == WPA_CIPHER_WEP104 ||
424 cipher == WPA_CIPHER_WEP40 ||
425 cipher == WPA_CIPHER_GTK_NOT_USED;
429 #ifdef CONFIG_IEEE80211W
430 int wpa_cipher_valid_mgmt_group(int cipher)
432 return cipher == WPA_CIPHER_AES_128_CMAC ||
433 cipher == WPA_CIPHER_BIP_GMAC_128 ||
434 cipher == WPA_CIPHER_BIP_GMAC_256 ||
435 cipher == WPA_CIPHER_BIP_CMAC_256;
437 #endif /* CONFIG_IEEE80211W */
441 * wpa_parse_wpa_ie_rsn - Parse RSN IE
442 * @rsn_ie: Buffer containing RSN IE
443 * @rsn_ie_len: RSN IE buffer length (including IE number and length octets)
444 * @data: Pointer to structure that will be filled in with parsed data
445 * Returns: 0 on success, <0 on failure
447 int wpa_parse_wpa_ie_rsn(const u8 *rsn_ie, size_t rsn_ie_len,
448 struct wpa_ie_data *data)
450 const struct rsn_ie_hdr *hdr;
455 os_memset(data, 0, sizeof(*data));
456 data->proto = WPA_PROTO_RSN;
457 data->pairwise_cipher = WPA_CIPHER_CCMP;
458 data->group_cipher = WPA_CIPHER_CCMP;
459 data->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
460 data->capabilities = 0;
463 #ifdef CONFIG_IEEE80211W
464 data->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
465 #else /* CONFIG_IEEE80211W */
466 data->mgmt_group_cipher = 0;
467 #endif /* CONFIG_IEEE80211W */
469 if (rsn_ie_len == 0) {
470 /* No RSN IE - fail silently */
474 if (rsn_ie_len < sizeof(struct rsn_ie_hdr)) {
475 wpa_printf(MSG_DEBUG, "%s: ie len too short %lu",
476 __func__, (unsigned long) rsn_ie_len);
480 hdr = (const struct rsn_ie_hdr *) rsn_ie;
482 if (hdr->elem_id != WLAN_EID_RSN ||
483 hdr->len != rsn_ie_len - 2 ||
484 WPA_GET_LE16(hdr->version) != RSN_VERSION) {
485 wpa_printf(MSG_DEBUG, "%s: malformed ie or unknown version",
490 pos = (const u8 *) (hdr + 1);
491 left = rsn_ie_len - sizeof(*hdr);
493 if (left >= RSN_SELECTOR_LEN) {
494 data->group_cipher = rsn_selector_to_bitfield(pos);
495 if (!wpa_cipher_valid_group(data->group_cipher)) {
496 wpa_printf(MSG_DEBUG, "%s: invalid group cipher 0x%x",
497 __func__, data->group_cipher);
500 pos += RSN_SELECTOR_LEN;
501 left -= RSN_SELECTOR_LEN;
502 } else if (left > 0) {
503 wpa_printf(MSG_DEBUG, "%s: ie length mismatch, %u too much",
509 data->pairwise_cipher = 0;
510 count = WPA_GET_LE16(pos);
513 if (count == 0 || count > left / RSN_SELECTOR_LEN) {
514 wpa_printf(MSG_DEBUG, "%s: ie count botch (pairwise), "
515 "count %u left %u", __func__, count, left);
518 for (i = 0; i < count; i++) {
519 data->pairwise_cipher |= rsn_selector_to_bitfield(pos);
520 pos += RSN_SELECTOR_LEN;
521 left -= RSN_SELECTOR_LEN;
523 #ifdef CONFIG_IEEE80211W
524 if (data->pairwise_cipher & WPA_CIPHER_AES_128_CMAC) {
525 wpa_printf(MSG_DEBUG, "%s: AES-128-CMAC used as "
526 "pairwise cipher", __func__);
529 #endif /* CONFIG_IEEE80211W */
530 } else if (left == 1) {
531 wpa_printf(MSG_DEBUG, "%s: ie too short (for key mgmt)",
538 count = WPA_GET_LE16(pos);
541 if (count == 0 || count > left / RSN_SELECTOR_LEN) {
542 wpa_printf(MSG_DEBUG, "%s: ie count botch (key mgmt), "
543 "count %u left %u", __func__, count, left);
546 for (i = 0; i < count; i++) {
547 data->key_mgmt |= rsn_key_mgmt_to_bitfield(pos);
548 pos += RSN_SELECTOR_LEN;
549 left -= RSN_SELECTOR_LEN;
551 } else if (left == 1) {
552 wpa_printf(MSG_DEBUG, "%s: ie too short (for capabilities)",
558 data->capabilities = WPA_GET_LE16(pos);
564 u16 num_pmkid = WPA_GET_LE16(pos);
567 if (num_pmkid > (unsigned int) left / PMKID_LEN) {
568 wpa_printf(MSG_DEBUG, "%s: PMKID underflow "
569 "(num_pmkid=%u left=%d)",
570 __func__, num_pmkid, left);
574 data->num_pmkid = num_pmkid;
576 pos += data->num_pmkid * PMKID_LEN;
577 left -= data->num_pmkid * PMKID_LEN;
581 #ifdef CONFIG_IEEE80211W
583 data->mgmt_group_cipher = rsn_selector_to_bitfield(pos);
584 if (!wpa_cipher_valid_mgmt_group(data->mgmt_group_cipher)) {
585 wpa_printf(MSG_DEBUG, "%s: Unsupported management "
586 "group cipher 0x%x", __func__,
587 data->mgmt_group_cipher);
590 pos += RSN_SELECTOR_LEN;
591 left -= RSN_SELECTOR_LEN;
593 #endif /* CONFIG_IEEE80211W */
596 wpa_hexdump(MSG_DEBUG,
597 "wpa_parse_wpa_ie_rsn: ignore trailing bytes",
605 static int wpa_selector_to_bitfield(const u8 *s)
607 if (RSN_SELECTOR_GET(s) == WPA_CIPHER_SUITE_NONE)
608 return WPA_CIPHER_NONE;
609 if (RSN_SELECTOR_GET(s) == WPA_CIPHER_SUITE_WEP40)
610 return WPA_CIPHER_WEP40;
611 if (RSN_SELECTOR_GET(s) == WPA_CIPHER_SUITE_TKIP)
612 return WPA_CIPHER_TKIP;
613 if (RSN_SELECTOR_GET(s) == WPA_CIPHER_SUITE_CCMP)
614 return WPA_CIPHER_CCMP;
615 if (RSN_SELECTOR_GET(s) == WPA_CIPHER_SUITE_WEP104)
616 return WPA_CIPHER_WEP104;
621 static int wpa_key_mgmt_to_bitfield(const u8 *s)
623 if (RSN_SELECTOR_GET(s) == WPA_AUTH_KEY_MGMT_UNSPEC_802_1X)
624 return WPA_KEY_MGMT_IEEE8021X;
625 if (RSN_SELECTOR_GET(s) == WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X)
626 return WPA_KEY_MGMT_PSK;
627 if (RSN_SELECTOR_GET(s) == WPA_AUTH_KEY_MGMT_NONE)
628 return WPA_KEY_MGMT_WPA_NONE;
633 int wpa_parse_wpa_ie_wpa(const u8 *wpa_ie, size_t wpa_ie_len,
634 struct wpa_ie_data *data)
636 const struct wpa_ie_hdr *hdr;
641 os_memset(data, 0, sizeof(*data));
642 data->proto = WPA_PROTO_WPA;
643 data->pairwise_cipher = WPA_CIPHER_TKIP;
644 data->group_cipher = WPA_CIPHER_TKIP;
645 data->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
646 data->capabilities = 0;
649 data->mgmt_group_cipher = 0;
651 if (wpa_ie_len == 0) {
652 /* No WPA IE - fail silently */
656 if (wpa_ie_len < sizeof(struct wpa_ie_hdr)) {
657 wpa_printf(MSG_DEBUG, "%s: ie len too short %lu",
658 __func__, (unsigned long) wpa_ie_len);
662 hdr = (const struct wpa_ie_hdr *) wpa_ie;
664 if (hdr->elem_id != WLAN_EID_VENDOR_SPECIFIC ||
665 hdr->len != wpa_ie_len - 2 ||
666 RSN_SELECTOR_GET(hdr->oui) != WPA_OUI_TYPE ||
667 WPA_GET_LE16(hdr->version) != WPA_VERSION) {
668 wpa_printf(MSG_DEBUG, "%s: malformed ie or unknown version",
673 pos = (const u8 *) (hdr + 1);
674 left = wpa_ie_len - sizeof(*hdr);
676 if (left >= WPA_SELECTOR_LEN) {
677 data->group_cipher = wpa_selector_to_bitfield(pos);
678 pos += WPA_SELECTOR_LEN;
679 left -= WPA_SELECTOR_LEN;
680 } else if (left > 0) {
681 wpa_printf(MSG_DEBUG, "%s: ie length mismatch, %u too much",
687 data->pairwise_cipher = 0;
688 count = WPA_GET_LE16(pos);
691 if (count == 0 || count > left / WPA_SELECTOR_LEN) {
692 wpa_printf(MSG_DEBUG, "%s: ie count botch (pairwise), "
693 "count %u left %u", __func__, count, left);
696 for (i = 0; i < count; i++) {
697 data->pairwise_cipher |= wpa_selector_to_bitfield(pos);
698 pos += WPA_SELECTOR_LEN;
699 left -= WPA_SELECTOR_LEN;
701 } else if (left == 1) {
702 wpa_printf(MSG_DEBUG, "%s: ie too short (for key mgmt)",
709 count = WPA_GET_LE16(pos);
712 if (count == 0 || count > left / WPA_SELECTOR_LEN) {
713 wpa_printf(MSG_DEBUG, "%s: ie count botch (key mgmt), "
714 "count %u left %u", __func__, count, left);
717 for (i = 0; i < count; i++) {
718 data->key_mgmt |= wpa_key_mgmt_to_bitfield(pos);
719 pos += WPA_SELECTOR_LEN;
720 left -= WPA_SELECTOR_LEN;
722 } else if (left == 1) {
723 wpa_printf(MSG_DEBUG, "%s: ie too short (for capabilities)",
729 data->capabilities = WPA_GET_LE16(pos);
735 wpa_hexdump(MSG_DEBUG,
736 "wpa_parse_wpa_ie_wpa: ignore trailing bytes",
744 #ifdef CONFIG_IEEE80211R
747 * wpa_derive_pmk_r0 - Derive PMK-R0 and PMKR0Name
749 * IEEE Std 802.11r-2008 - 8.5.1.5.3
751 void wpa_derive_pmk_r0(const u8 *xxkey, size_t xxkey_len,
752 const u8 *ssid, size_t ssid_len,
753 const u8 *mdid, const u8 *r0kh_id, size_t r0kh_id_len,
754 const u8 *s0kh_id, u8 *pmk_r0, u8 *pmk_r0_name)
756 u8 buf[1 + WPA_MAX_SSID_LEN + MOBILITY_DOMAIN_ID_LEN + 1 +
757 FT_R0KH_ID_MAX_LEN + ETH_ALEN];
758 u8 *pos, r0_key_data[48], hash[32];
763 * R0-Key-Data = KDF-384(XXKey, "FT-R0",
764 * SSIDlength || SSID || MDID || R0KHlength ||
765 * R0KH-ID || S0KH-ID)
766 * XXKey is either the second 256 bits of MSK or PSK.
767 * PMK-R0 = L(R0-Key-Data, 0, 256)
768 * PMK-R0Name-Salt = L(R0-Key-Data, 256, 128)
770 if (ssid_len > WPA_MAX_SSID_LEN || r0kh_id_len > FT_R0KH_ID_MAX_LEN)
774 os_memcpy(pos, ssid, ssid_len);
776 os_memcpy(pos, mdid, MOBILITY_DOMAIN_ID_LEN);
777 pos += MOBILITY_DOMAIN_ID_LEN;
778 *pos++ = r0kh_id_len;
779 os_memcpy(pos, r0kh_id, r0kh_id_len);
781 os_memcpy(pos, s0kh_id, ETH_ALEN);
784 sha256_prf(xxkey, xxkey_len, "FT-R0", buf, pos - buf,
785 r0_key_data, sizeof(r0_key_data));
786 os_memcpy(pmk_r0, r0_key_data, PMK_LEN);
789 * PMKR0Name = Truncate-128(SHA-256("FT-R0N" || PMK-R0Name-Salt)
791 addr[0] = (const u8 *) "FT-R0N";
793 addr[1] = r0_key_data + PMK_LEN;
796 sha256_vector(2, addr, len, hash);
797 os_memcpy(pmk_r0_name, hash, WPA_PMK_NAME_LEN);
802 * wpa_derive_pmk_r1_name - Derive PMKR1Name
804 * IEEE Std 802.11r-2008 - 8.5.1.5.4
806 void wpa_derive_pmk_r1_name(const u8 *pmk_r0_name, const u8 *r1kh_id,
807 const u8 *s1kh_id, u8 *pmk_r1_name)
814 * PMKR1Name = Truncate-128(SHA-256("FT-R1N" || PMKR0Name ||
815 * R1KH-ID || S1KH-ID))
817 addr[0] = (const u8 *) "FT-R1N";
819 addr[1] = pmk_r0_name;
820 len[1] = WPA_PMK_NAME_LEN;
822 len[2] = FT_R1KH_ID_LEN;
826 sha256_vector(4, addr, len, hash);
827 os_memcpy(pmk_r1_name, hash, WPA_PMK_NAME_LEN);
832 * wpa_derive_pmk_r1 - Derive PMK-R1 and PMKR1Name from PMK-R0
834 * IEEE Std 802.11r-2008 - 8.5.1.5.4
836 void wpa_derive_pmk_r1(const u8 *pmk_r0, const u8 *pmk_r0_name,
837 const u8 *r1kh_id, const u8 *s1kh_id,
838 u8 *pmk_r1, u8 *pmk_r1_name)
840 u8 buf[FT_R1KH_ID_LEN + ETH_ALEN];
843 /* PMK-R1 = KDF-256(PMK-R0, "FT-R1", R1KH-ID || S1KH-ID) */
845 os_memcpy(pos, r1kh_id, FT_R1KH_ID_LEN);
846 pos += FT_R1KH_ID_LEN;
847 os_memcpy(pos, s1kh_id, ETH_ALEN);
850 sha256_prf(pmk_r0, PMK_LEN, "FT-R1", buf, pos - buf, pmk_r1, PMK_LEN);
852 wpa_derive_pmk_r1_name(pmk_r0_name, r1kh_id, s1kh_id, pmk_r1_name);
857 * wpa_pmk_r1_to_ptk - Derive PTK and PTKName from PMK-R1
859 * IEEE Std 802.11r-2008 - 8.5.1.5.5
861 void wpa_pmk_r1_to_ptk(const u8 *pmk_r1, const u8 *snonce, const u8 *anonce,
862 const u8 *sta_addr, const u8 *bssid,
863 const u8 *pmk_r1_name,
864 u8 *ptk, size_t ptk_len, u8 *ptk_name)
866 u8 buf[2 * WPA_NONCE_LEN + 2 * ETH_ALEN];
872 * PTK = KDF-PTKLen(PMK-R1, "FT-PTK", SNonce || ANonce ||
876 os_memcpy(pos, snonce, WPA_NONCE_LEN);
877 pos += WPA_NONCE_LEN;
878 os_memcpy(pos, anonce, WPA_NONCE_LEN);
879 pos += WPA_NONCE_LEN;
880 os_memcpy(pos, bssid, ETH_ALEN);
882 os_memcpy(pos, sta_addr, ETH_ALEN);
885 sha256_prf(pmk_r1, PMK_LEN, "FT-PTK", buf, pos - buf, ptk, ptk_len);
888 * PTKName = Truncate-128(SHA-256(PMKR1Name || "FT-PTKN" || SNonce ||
889 * ANonce || BSSID || STA-ADDR))
891 addr[0] = pmk_r1_name;
892 len[0] = WPA_PMK_NAME_LEN;
893 addr[1] = (const u8 *) "FT-PTKN";
896 len[2] = WPA_NONCE_LEN;
898 len[3] = WPA_NONCE_LEN;
904 sha256_vector(6, addr, len, hash);
905 os_memcpy(ptk_name, hash, WPA_PMK_NAME_LEN);
908 #endif /* CONFIG_IEEE80211R */
912 * rsn_pmkid - Calculate PMK identifier
913 * @pmk: Pairwise master key
914 * @pmk_len: Length of pmk in bytes
915 * @aa: Authenticator address
916 * @spa: Supplicant address
917 * @pmkid: Buffer for PMKID
918 * @use_sha256: Whether to use SHA256-based KDF
920 * IEEE Std 802.11i-2004 - 8.5.1.2 Pairwise key hierarchy
921 * PMKID = HMAC-SHA1-128(PMK, "PMK Name" || AA || SPA)
923 void rsn_pmkid(const u8 *pmk, size_t pmk_len, const u8 *aa, const u8 *spa,
924 u8 *pmkid, int use_sha256)
926 char *title = "PMK Name";
928 const size_t len[3] = { 8, ETH_ALEN, ETH_ALEN };
929 unsigned char hash[SHA256_MAC_LEN];
931 addr[0] = (u8 *) title;
935 #ifdef CONFIG_IEEE80211W
937 hmac_sha256_vector(pmk, pmk_len, 3, addr, len, hash);
939 #endif /* CONFIG_IEEE80211W */
940 hmac_sha1_vector(pmk, pmk_len, 3, addr, len, hash);
941 os_memcpy(pmkid, hash, PMKID_LEN);
947 * rsn_pmkid_suite_b - Calculate PMK identifier for Suite B AKM
948 * @kck: Key confirmation key
949 * @kck_len: Length of kck in bytes
950 * @aa: Authenticator address
951 * @spa: Supplicant address
952 * @pmkid: Buffer for PMKID
953 * Returns: 0 on success, -1 on failure
955 * IEEE Std 802.11ac-2013 - 11.6.1.3 Pairwise key hierarchy
956 * PMKID = Truncate(HMAC-SHA-256(KCK, "PMK Name" || AA || SPA))
958 int rsn_pmkid_suite_b(const u8 *kck, size_t kck_len, const u8 *aa,
959 const u8 *spa, u8 *pmkid)
961 char *title = "PMK Name";
963 const size_t len[3] = { 8, ETH_ALEN, ETH_ALEN };
964 unsigned char hash[SHA256_MAC_LEN];
966 addr[0] = (u8 *) title;
970 if (hmac_sha256_vector(kck, kck_len, 3, addr, len, hash) < 0)
972 os_memcpy(pmkid, hash, PMKID_LEN);
975 #endif /* CONFIG_SUITEB */
979 * wpa_cipher_txt - Convert cipher suite to a text string
980 * @cipher: Cipher suite (WPA_CIPHER_* enum)
981 * Returns: Pointer to a text string of the cipher suite name
983 const char * wpa_cipher_txt(int cipher)
986 case WPA_CIPHER_NONE:
988 case WPA_CIPHER_WEP40:
990 case WPA_CIPHER_WEP104:
992 case WPA_CIPHER_TKIP:
994 case WPA_CIPHER_CCMP:
996 case WPA_CIPHER_CCMP | WPA_CIPHER_TKIP:
998 case WPA_CIPHER_GCMP:
1000 case WPA_CIPHER_GCMP_256:
1002 case WPA_CIPHER_CCMP_256:
1004 case WPA_CIPHER_GTK_NOT_USED:
1005 return "GTK_NOT_USED";
1013 * wpa_key_mgmt_txt - Convert key management suite to a text string
1014 * @key_mgmt: Key management suite (WPA_KEY_MGMT_* enum)
1015 * @proto: WPA/WPA2 version (WPA_PROTO_*)
1016 * Returns: Pointer to a text string of the key management suite name
1018 const char * wpa_key_mgmt_txt(int key_mgmt, int proto)
1021 case WPA_KEY_MGMT_IEEE8021X:
1022 if (proto == (WPA_PROTO_RSN | WPA_PROTO_WPA))
1023 return "WPA2+WPA/IEEE 802.1X/EAP";
1024 return proto == WPA_PROTO_RSN ?
1025 "WPA2/IEEE 802.1X/EAP" : "WPA/IEEE 802.1X/EAP";
1026 case WPA_KEY_MGMT_PSK:
1027 if (proto == (WPA_PROTO_RSN | WPA_PROTO_WPA))
1028 return "WPA2-PSK+WPA-PSK";
1029 return proto == WPA_PROTO_RSN ?
1030 "WPA2-PSK" : "WPA-PSK";
1031 case WPA_KEY_MGMT_NONE:
1033 case WPA_KEY_MGMT_IEEE8021X_NO_WPA:
1034 return "IEEE 802.1X (no WPA)";
1035 #ifdef CONFIG_IEEE80211R
1036 case WPA_KEY_MGMT_FT_IEEE8021X:
1038 case WPA_KEY_MGMT_FT_PSK:
1040 #endif /* CONFIG_IEEE80211R */
1041 #ifdef CONFIG_IEEE80211W
1042 case WPA_KEY_MGMT_IEEE8021X_SHA256:
1043 return "WPA2-EAP-SHA256";
1044 case WPA_KEY_MGMT_PSK_SHA256:
1045 return "WPA2-PSK-SHA256";
1046 #endif /* CONFIG_IEEE80211W */
1047 case WPA_KEY_MGMT_IEEE8021X_SUITE_B:
1048 return "WPA2-EAP-SUITE-B";
1055 u32 wpa_akm_to_suite(int akm)
1057 if (akm & WPA_KEY_MGMT_FT_IEEE8021X)
1058 return WLAN_AKM_SUITE_FT_8021X;
1059 if (akm & WPA_KEY_MGMT_FT_PSK)
1060 return WLAN_AKM_SUITE_FT_PSK;
1061 if (akm & WPA_KEY_MGMT_IEEE8021X)
1062 return WLAN_AKM_SUITE_8021X;
1063 if (akm & WPA_KEY_MGMT_IEEE8021X_SHA256)
1064 return WLAN_AKM_SUITE_8021X_SHA256;
1065 if (akm & WPA_KEY_MGMT_IEEE8021X)
1066 return WLAN_AKM_SUITE_8021X;
1067 if (akm & WPA_KEY_MGMT_PSK_SHA256)
1068 return WLAN_AKM_SUITE_PSK_SHA256;
1069 if (akm & WPA_KEY_MGMT_PSK)
1070 return WLAN_AKM_SUITE_PSK;
1071 if (akm & WPA_KEY_MGMT_CCKM)
1072 return WLAN_AKM_SUITE_CCKM;
1073 if (akm & WPA_KEY_MGMT_OSEN)
1074 return WLAN_AKM_SUITE_OSEN;
1075 if (akm & WPA_KEY_MGMT_IEEE8021X_SUITE_B)
1076 return WLAN_AKM_SUITE_8021X_SUITE_B;
1081 int wpa_compare_rsn_ie(int ft_initial_assoc,
1082 const u8 *ie1, size_t ie1len,
1083 const u8 *ie2, size_t ie2len)
1085 if (ie1 == NULL || ie2 == NULL)
1088 if (ie1len == ie2len && os_memcmp(ie1, ie2, ie1len) == 0)
1089 return 0; /* identical IEs */
1091 #ifdef CONFIG_IEEE80211R
1092 if (ft_initial_assoc) {
1093 struct wpa_ie_data ie1d, ie2d;
1095 * The PMKID-List in RSN IE is different between Beacon/Probe
1096 * Response/(Re)Association Request frames and EAPOL-Key
1097 * messages in FT initial mobility domain association. Allow
1098 * for this, but verify that other parts of the RSN IEs are
1101 if (wpa_parse_wpa_ie_rsn(ie1, ie1len, &ie1d) < 0 ||
1102 wpa_parse_wpa_ie_rsn(ie2, ie2len, &ie2d) < 0)
1104 if (ie1d.proto == ie2d.proto &&
1105 ie1d.pairwise_cipher == ie2d.pairwise_cipher &&
1106 ie1d.group_cipher == ie2d.group_cipher &&
1107 ie1d.key_mgmt == ie2d.key_mgmt &&
1108 ie1d.capabilities == ie2d.capabilities &&
1109 ie1d.mgmt_group_cipher == ie2d.mgmt_group_cipher)
1112 #endif /* CONFIG_IEEE80211R */
1118 #ifdef CONFIG_IEEE80211R
1119 int wpa_insert_pmkid(u8 *ies, size_t ies_len, const u8 *pmkid)
1121 u8 *start, *end, *rpos, *rend;
1125 end = ies + ies_len;
1127 while (start < end) {
1128 if (*start == WLAN_EID_RSN)
1130 start += 2 + start[1];
1133 wpa_printf(MSG_ERROR, "FT: Could not find RSN IE in "
1137 wpa_hexdump(MSG_DEBUG, "FT: RSN IE before modification",
1138 start, 2 + start[1]);
1140 /* Find start of PMKID-Count */
1142 rend = rpos + start[1];
1144 /* Skip Version and Group Data Cipher Suite */
1146 /* Skip Pairwise Cipher Suite Count and List */
1147 rpos += 2 + WPA_GET_LE16(rpos) * RSN_SELECTOR_LEN;
1148 /* Skip AKM Suite Count and List */
1149 rpos += 2 + WPA_GET_LE16(rpos) * RSN_SELECTOR_LEN;
1152 /* Add RSN Capabilities */
1153 os_memmove(rpos + 2, rpos, end - rpos);
1157 /* Skip RSN Capabilities */
1160 wpa_printf(MSG_ERROR, "FT: Could not parse RSN IE in "
1167 /* No PMKID-Count field included; add it */
1168 os_memmove(rpos + 2 + PMKID_LEN, rpos, end - rpos);
1169 WPA_PUT_LE16(rpos, 1);
1171 os_memcpy(rpos, pmkid, PMKID_LEN);
1172 added += 2 + PMKID_LEN;
1173 start[1] += 2 + PMKID_LEN;
1175 /* PMKID-Count was included; use it */
1176 if (WPA_GET_LE16(rpos) != 0) {
1177 wpa_printf(MSG_ERROR, "FT: Unexpected PMKID "
1178 "in RSN IE in EAPOL-Key data");
1181 WPA_PUT_LE16(rpos, 1);
1183 os_memmove(rpos + PMKID_LEN, rpos, end - rpos);
1184 os_memcpy(rpos, pmkid, PMKID_LEN);
1186 start[1] += PMKID_LEN;
1189 wpa_hexdump(MSG_DEBUG, "FT: RSN IE after modification "
1190 "(PMKID inserted)", start, 2 + start[1]);
1194 #endif /* CONFIG_IEEE80211R */
1197 int wpa_cipher_key_len(int cipher)
1200 case WPA_CIPHER_CCMP_256:
1201 case WPA_CIPHER_GCMP_256:
1202 case WPA_CIPHER_BIP_GMAC_256:
1203 case WPA_CIPHER_BIP_CMAC_256:
1205 case WPA_CIPHER_CCMP:
1206 case WPA_CIPHER_GCMP:
1207 case WPA_CIPHER_AES_128_CMAC:
1208 case WPA_CIPHER_BIP_GMAC_128:
1210 case WPA_CIPHER_TKIP:
1212 case WPA_CIPHER_WEP104:
1214 case WPA_CIPHER_WEP40:
1222 int wpa_cipher_rsc_len(int cipher)
1225 case WPA_CIPHER_CCMP_256:
1226 case WPA_CIPHER_GCMP_256:
1227 case WPA_CIPHER_CCMP:
1228 case WPA_CIPHER_GCMP:
1229 case WPA_CIPHER_TKIP:
1231 case WPA_CIPHER_WEP104:
1232 case WPA_CIPHER_WEP40:
1240 int wpa_cipher_to_alg(int cipher)
1243 case WPA_CIPHER_CCMP_256:
1244 return WPA_ALG_CCMP_256;
1245 case WPA_CIPHER_GCMP_256:
1246 return WPA_ALG_GCMP_256;
1247 case WPA_CIPHER_CCMP:
1248 return WPA_ALG_CCMP;
1249 case WPA_CIPHER_GCMP:
1250 return WPA_ALG_GCMP;
1251 case WPA_CIPHER_TKIP:
1252 return WPA_ALG_TKIP;
1253 case WPA_CIPHER_WEP104:
1254 case WPA_CIPHER_WEP40:
1256 case WPA_CIPHER_AES_128_CMAC:
1257 return WPA_ALG_IGTK;
1258 case WPA_CIPHER_BIP_GMAC_128:
1259 return WPA_ALG_BIP_GMAC_128;
1260 case WPA_CIPHER_BIP_GMAC_256:
1261 return WPA_ALG_BIP_GMAC_256;
1262 case WPA_CIPHER_BIP_CMAC_256:
1263 return WPA_ALG_BIP_CMAC_256;
1265 return WPA_ALG_NONE;
1269 int wpa_cipher_valid_pairwise(int cipher)
1271 return cipher == WPA_CIPHER_CCMP_256 ||
1272 cipher == WPA_CIPHER_GCMP_256 ||
1273 cipher == WPA_CIPHER_CCMP ||
1274 cipher == WPA_CIPHER_GCMP ||
1275 cipher == WPA_CIPHER_TKIP;
1279 u32 wpa_cipher_to_suite(int proto, int cipher)
1281 if (cipher & WPA_CIPHER_CCMP_256)
1282 return RSN_CIPHER_SUITE_CCMP_256;
1283 if (cipher & WPA_CIPHER_GCMP_256)
1284 return RSN_CIPHER_SUITE_GCMP_256;
1285 if (cipher & WPA_CIPHER_CCMP)
1286 return (proto == WPA_PROTO_RSN ?
1287 RSN_CIPHER_SUITE_CCMP : WPA_CIPHER_SUITE_CCMP);
1288 if (cipher & WPA_CIPHER_GCMP)
1289 return RSN_CIPHER_SUITE_GCMP;
1290 if (cipher & WPA_CIPHER_TKIP)
1291 return (proto == WPA_PROTO_RSN ?
1292 RSN_CIPHER_SUITE_TKIP : WPA_CIPHER_SUITE_TKIP);
1293 if (cipher & WPA_CIPHER_WEP104)
1294 return (proto == WPA_PROTO_RSN ?
1295 RSN_CIPHER_SUITE_WEP104 : WPA_CIPHER_SUITE_WEP104);
1296 if (cipher & WPA_CIPHER_WEP40)
1297 return (proto == WPA_PROTO_RSN ?
1298 RSN_CIPHER_SUITE_WEP40 : WPA_CIPHER_SUITE_WEP40);
1299 if (cipher & WPA_CIPHER_NONE)
1300 return (proto == WPA_PROTO_RSN ?
1301 RSN_CIPHER_SUITE_NONE : WPA_CIPHER_SUITE_NONE);
1302 if (cipher & WPA_CIPHER_GTK_NOT_USED)
1303 return RSN_CIPHER_SUITE_NO_GROUP_ADDRESSED;
1304 if (cipher & WPA_CIPHER_AES_128_CMAC)
1305 return RSN_CIPHER_SUITE_AES_128_CMAC;
1306 if (cipher & WPA_CIPHER_BIP_GMAC_128)
1307 return RSN_CIPHER_SUITE_BIP_GMAC_128;
1308 if (cipher & WPA_CIPHER_BIP_GMAC_256)
1309 return RSN_CIPHER_SUITE_BIP_GMAC_256;
1310 if (cipher & WPA_CIPHER_BIP_CMAC_256)
1311 return RSN_CIPHER_SUITE_BIP_CMAC_256;
1316 int rsn_cipher_put_suites(u8 *start, int ciphers)
1320 if (ciphers & WPA_CIPHER_CCMP_256) {
1321 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_CCMP_256);
1322 pos += RSN_SELECTOR_LEN;
1324 if (ciphers & WPA_CIPHER_GCMP_256) {
1325 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_GCMP_256);
1326 pos += RSN_SELECTOR_LEN;
1328 if (ciphers & WPA_CIPHER_CCMP) {
1329 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_CCMP);
1330 pos += RSN_SELECTOR_LEN;
1332 if (ciphers & WPA_CIPHER_GCMP) {
1333 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_GCMP);
1334 pos += RSN_SELECTOR_LEN;
1336 if (ciphers & WPA_CIPHER_TKIP) {
1337 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_TKIP);
1338 pos += RSN_SELECTOR_LEN;
1340 if (ciphers & WPA_CIPHER_NONE) {
1341 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_NONE);
1342 pos += RSN_SELECTOR_LEN;
1345 return (pos - start) / RSN_SELECTOR_LEN;
1349 int wpa_cipher_put_suites(u8 *start, int ciphers)
1353 if (ciphers & WPA_CIPHER_CCMP) {
1354 RSN_SELECTOR_PUT(pos, WPA_CIPHER_SUITE_CCMP);
1355 pos += WPA_SELECTOR_LEN;
1357 if (ciphers & WPA_CIPHER_TKIP) {
1358 RSN_SELECTOR_PUT(pos, WPA_CIPHER_SUITE_TKIP);
1359 pos += WPA_SELECTOR_LEN;
1361 if (ciphers & WPA_CIPHER_NONE) {
1362 RSN_SELECTOR_PUT(pos, WPA_CIPHER_SUITE_NONE);
1363 pos += WPA_SELECTOR_LEN;
1366 return (pos - start) / RSN_SELECTOR_LEN;
1370 int wpa_pick_pairwise_cipher(int ciphers, int none_allowed)
1372 if (ciphers & WPA_CIPHER_CCMP_256)
1373 return WPA_CIPHER_CCMP_256;
1374 if (ciphers & WPA_CIPHER_GCMP_256)
1375 return WPA_CIPHER_GCMP_256;
1376 if (ciphers & WPA_CIPHER_CCMP)
1377 return WPA_CIPHER_CCMP;
1378 if (ciphers & WPA_CIPHER_GCMP)
1379 return WPA_CIPHER_GCMP;
1380 if (ciphers & WPA_CIPHER_TKIP)
1381 return WPA_CIPHER_TKIP;
1382 if (none_allowed && (ciphers & WPA_CIPHER_NONE))
1383 return WPA_CIPHER_NONE;
1388 int wpa_pick_group_cipher(int ciphers)
1390 if (ciphers & WPA_CIPHER_CCMP_256)
1391 return WPA_CIPHER_CCMP_256;
1392 if (ciphers & WPA_CIPHER_GCMP_256)
1393 return WPA_CIPHER_GCMP_256;
1394 if (ciphers & WPA_CIPHER_CCMP)
1395 return WPA_CIPHER_CCMP;
1396 if (ciphers & WPA_CIPHER_GCMP)
1397 return WPA_CIPHER_GCMP;
1398 if (ciphers & WPA_CIPHER_GTK_NOT_USED)
1399 return WPA_CIPHER_GTK_NOT_USED;
1400 if (ciphers & WPA_CIPHER_TKIP)
1401 return WPA_CIPHER_TKIP;
1402 if (ciphers & WPA_CIPHER_WEP104)
1403 return WPA_CIPHER_WEP104;
1404 if (ciphers & WPA_CIPHER_WEP40)
1405 return WPA_CIPHER_WEP40;
1410 int wpa_parse_cipher(const char *value)
1413 char *start, *end, *buf;
1415 buf = os_strdup(value);
1420 while (*start != '\0') {
1421 while (*start == ' ' || *start == '\t')
1426 while (*end != ' ' && *end != '\t' && *end != '\0')
1428 last = *end == '\0';
1430 if (os_strcmp(start, "CCMP-256") == 0)
1431 val |= WPA_CIPHER_CCMP_256;
1432 else if (os_strcmp(start, "GCMP-256") == 0)
1433 val |= WPA_CIPHER_GCMP_256;
1434 else if (os_strcmp(start, "CCMP") == 0)
1435 val |= WPA_CIPHER_CCMP;
1436 else if (os_strcmp(start, "GCMP") == 0)
1437 val |= WPA_CIPHER_GCMP;
1438 else if (os_strcmp(start, "TKIP") == 0)
1439 val |= WPA_CIPHER_TKIP;
1440 else if (os_strcmp(start, "WEP104") == 0)
1441 val |= WPA_CIPHER_WEP104;
1442 else if (os_strcmp(start, "WEP40") == 0)
1443 val |= WPA_CIPHER_WEP40;
1444 else if (os_strcmp(start, "NONE") == 0)
1445 val |= WPA_CIPHER_NONE;
1446 else if (os_strcmp(start, "GTK_NOT_USED") == 0)
1447 val |= WPA_CIPHER_GTK_NOT_USED;
1463 int wpa_write_ciphers(char *start, char *end, int ciphers, const char *delim)
1468 if (ciphers & WPA_CIPHER_CCMP_256) {
1469 ret = os_snprintf(pos, end - pos, "%sCCMP-256",
1470 pos == start ? "" : delim);
1471 if (os_snprintf_error(end - pos, ret))
1475 if (ciphers & WPA_CIPHER_GCMP_256) {
1476 ret = os_snprintf(pos, end - pos, "%sGCMP-256",
1477 pos == start ? "" : delim);
1478 if (os_snprintf_error(end - pos, ret))
1482 if (ciphers & WPA_CIPHER_CCMP) {
1483 ret = os_snprintf(pos, end - pos, "%sCCMP",
1484 pos == start ? "" : delim);
1485 if (os_snprintf_error(end - pos, ret))
1489 if (ciphers & WPA_CIPHER_GCMP) {
1490 ret = os_snprintf(pos, end - pos, "%sGCMP",
1491 pos == start ? "" : delim);
1492 if (os_snprintf_error(end - pos, ret))
1496 if (ciphers & WPA_CIPHER_TKIP) {
1497 ret = os_snprintf(pos, end - pos, "%sTKIP",
1498 pos == start ? "" : delim);
1499 if (os_snprintf_error(end - pos, ret))
1503 if (ciphers & WPA_CIPHER_WEP104) {
1504 ret = os_snprintf(pos, end - pos, "%sWEP104",
1505 pos == start ? "" : delim);
1506 if (os_snprintf_error(end - pos, ret))
1510 if (ciphers & WPA_CIPHER_WEP40) {
1511 ret = os_snprintf(pos, end - pos, "%sWEP40",
1512 pos == start ? "" : delim);
1513 if (os_snprintf_error(end - pos, ret))
1517 if (ciphers & WPA_CIPHER_NONE) {
1518 ret = os_snprintf(pos, end - pos, "%sNONE",
1519 pos == start ? "" : delim);
1520 if (os_snprintf_error(end - pos, ret))
1529 int wpa_select_ap_group_cipher(int wpa, int wpa_pairwise, int rsn_pairwise)
1533 /* Select group cipher based on the enabled pairwise cipher suites */
1535 pairwise |= wpa_pairwise;
1537 pairwise |= rsn_pairwise;
1539 if (pairwise & WPA_CIPHER_TKIP)
1540 return WPA_CIPHER_TKIP;
1541 if ((pairwise & (WPA_CIPHER_CCMP | WPA_CIPHER_GCMP)) == WPA_CIPHER_GCMP)
1542 return WPA_CIPHER_GCMP;
1543 if ((pairwise & (WPA_CIPHER_GCMP_256 | WPA_CIPHER_CCMP |
1544 WPA_CIPHER_GCMP)) == WPA_CIPHER_GCMP_256)
1545 return WPA_CIPHER_GCMP_256;
1546 if ((pairwise & (WPA_CIPHER_CCMP_256 | WPA_CIPHER_CCMP |
1547 WPA_CIPHER_GCMP)) == WPA_CIPHER_CCMP_256)
1548 return WPA_CIPHER_CCMP_256;
1549 return WPA_CIPHER_CCMP;