src/common/wpa_common.c

   1 /*
   2  * WPA/RSN - Shared functions for supplicant and authenticator
   3  * Copyright (c) 2002-2013, 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 "includes.h"
  10
  11 #include "common.h"
  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"
  18 #include "defs.h"
  19 #include "wpa_common.h"
  20
  21
  22 /**
  23  * wpa_eapol_key_mic - Calculate EAPOL-Key MIC
  24  * @key: EAPOL-Key Key Confirmation Key (KCK)
  25  * @ver: Key descriptor version (WPA_KEY_INFO_TYPE_*)
  26  * @buf: Pointer to the beginning of the EAPOL header (version field)
  27  * @len: Length of the EAPOL frame (from EAPOL header to the end of the frame)
  28  * @mic: Pointer to the buffer to which the EAPOL-Key MIC is written
  29  * Returns: 0 on success, -1 on failure
  30  *
  31  * Calculate EAPOL-Key MIC for an EAPOL-Key packet. The EAPOL-Key MIC field has
  32  * to be cleared (all zeroes) when calling this function.
  33  *
  34  * Note: 'IEEE Std 802.11i-2004 - 8.5.2 EAPOL-Key frames' has an error in the
  35  * description of the Key MIC calculation. It includes packet data from the
  36  * beginning of the EAPOL-Key header, not EAPOL header. This incorrect change
  37  * happened during final editing of the standard and the correct behavior is
  38  * defined in the last draft (IEEE 802.11i/D10).
  39  */
  40 int wpa_eapol_key_mic(const u8 *key, int ver, const u8 *buf, size_t len,
  41                       u8 *mic)
  42 {
  43         u8 hash[SHA1_MAC_LEN];
  44
  45         switch (ver) {
  46 #ifndef CONFIG_FIPS
  47         case WPA_KEY_INFO_TYPE_HMAC_MD5_RC4:
  48                 return hmac_md5(key, 16, buf, len, mic);
  49 #endif /* CONFIG_FIPS */
  50         case WPA_KEY_INFO_TYPE_HMAC_SHA1_AES:
  51                 if (hmac_sha1(key, 16, buf, len, hash))
  52                         return -1;
  53                 os_memcpy(mic, hash, MD5_MAC_LEN);
  54                 break;
  55 #if defined(CONFIG_IEEE80211R) || defined(CONFIG_IEEE80211W)
  56         case WPA_KEY_INFO_TYPE_AES_128_CMAC:
  57                 return omac1_aes_128(key, buf, len, mic);
  58 #endif /* CONFIG_IEEE80211R || CONFIG_IEEE80211W */
  59 #ifdef CONFIG_HS20
  60         case WPA_KEY_INFO_TYPE_AKM_DEFINED:
  61                 /* FIX: This should be based on negotiated AKM */
  62                 return omac1_aes_128(key, buf, len, mic);
  63 #endif /* CONFIG_HS20 */
  64         default:
  65                 return -1;
  66         }
  67
  68         return 0;
  69 }
  70
  71
  72 /**
  73  * wpa_pmk_to_ptk - Calculate PTK from PMK, addresses, and nonces
  74  * @pmk: Pairwise master key
  75  * @pmk_len: Length of PMK
  76  * @label: Label to use in derivation
  77  * @addr1: AA or SA
  78  * @addr2: SA or AA
  79  * @nonce1: ANonce or SNonce
  80  * @nonce2: SNonce or ANonce
  81  * @ptk: Buffer for pairwise transient key
  82  * @ptk_len: Length of PTK
  83  * @use_sha256: Whether to use SHA256-based KDF
  84  *
  85  * IEEE Std 802.11i-2004 - 8.5.1.2 Pairwise key hierarchy
  86  * PTK = PRF-X(PMK, "Pairwise key expansion",
  87  *             Min(AA, SA) || Max(AA, SA) ||
  88  *             Min(ANonce, SNonce) || Max(ANonce, SNonce))
  89  *
  90  * STK = PRF-X(SMK, "Peer key expansion",
  91  *             Min(MAC_I, MAC_P) || Max(MAC_I, MAC_P) ||
  92  *             Min(INonce, PNonce) || Max(INonce, PNonce))
  93  */
  94 void wpa_pmk_to_ptk(const u8 *pmk, size_t pmk_len, const char *label,
  95                     const u8 *addr1, const u8 *addr2,
  96                     const u8 *nonce1, const u8 *nonce2,
  97                     u8 *ptk, size_t ptk_len, int use_sha256)
  98 {
  99         u8 data[2 * ETH_ALEN + 2 * WPA_NONCE_LEN];
 100
 101         if (os_memcmp(addr1, addr2, ETH_ALEN) < 0) {
 102                 os_memcpy(data, addr1, ETH_ALEN);
 103                 os_memcpy(data + ETH_ALEN, addr2, ETH_ALEN);
 104         } else {
 105                 os_memcpy(data, addr2, ETH_ALEN);
 106                 os_memcpy(data + ETH_ALEN, addr1, ETH_ALEN);
 107         }
 108
 109         if (os_memcmp(nonce1, nonce2, WPA_NONCE_LEN) < 0) {
 110                 os_memcpy(data + 2 * ETH_ALEN, nonce1, WPA_NONCE_LEN);
 111                 os_memcpy(data + 2 * ETH_ALEN + WPA_NONCE_LEN, nonce2,
 112                           WPA_NONCE_LEN);
 113         } else {
 114                 os_memcpy(data + 2 * ETH_ALEN, nonce2, WPA_NONCE_LEN);
 115                 os_memcpy(data + 2 * ETH_ALEN + WPA_NONCE_LEN, nonce1,
 116                           WPA_NONCE_LEN);
 117         }
 118
 119 #ifdef CONFIG_IEEE80211W
 120         if (use_sha256)
 121                 sha256_prf(pmk, pmk_len, label, data, sizeof(data),
 122                            ptk, ptk_len);
 123         else
 124 #endif /* CONFIG_IEEE80211W */
 125                 sha1_prf(pmk, pmk_len, label, data, sizeof(data), ptk,
 126                          ptk_len);
 127
 128         wpa_printf(MSG_DEBUG, "WPA: PTK derivation - A1=" MACSTR " A2=" MACSTR,
 129                    MAC2STR(addr1), MAC2STR(addr2));
 130         wpa_hexdump(MSG_DEBUG, "WPA: Nonce1", nonce1, WPA_NONCE_LEN);
 131         wpa_hexdump(MSG_DEBUG, "WPA: Nonce2", nonce2, WPA_NONCE_LEN);
 132         wpa_hexdump_key(MSG_DEBUG, "WPA: PMK", pmk, pmk_len);
 133         wpa_hexdump_key(MSG_DEBUG, "WPA: PTK", ptk, ptk_len);
 134 }
 135
 136
 137 #ifdef CONFIG_IEEE80211R
 138 int wpa_ft_mic(const u8 *kck, const u8 *sta_addr, const u8 *ap_addr,
 139                u8 transaction_seqnum, const u8 *mdie, size_t mdie_len,
 140                const u8 *ftie, size_t ftie_len,
 141                const u8 *rsnie, size_t rsnie_len,
 142                const u8 *ric, size_t ric_len, u8 *mic)
 143 {
 144         u8 *buf, *pos;
 145         size_t buf_len;
 146
 147         buf_len = 2 * ETH_ALEN + 1 + mdie_len + ftie_len + rsnie_len + ric_len;
 148         buf = os_malloc(buf_len);
 149         if (buf == NULL)
 150                 return -1;
 151
 152         pos = buf;
 153         os_memcpy(pos, sta_addr, ETH_ALEN);
 154         pos += ETH_ALEN;
 155         os_memcpy(pos, ap_addr, ETH_ALEN);
 156         pos += ETH_ALEN;
 157         *pos++ = transaction_seqnum;
 158         if (rsnie) {
 159                 os_memcpy(pos, rsnie, rsnie_len);
 160                 pos += rsnie_len;
 161         }
 162         if (mdie) {
 163                 os_memcpy(pos, mdie, mdie_len);
 164                 pos += mdie_len;
 165         }
 166         if (ftie) {
 167                 struct rsn_ftie *_ftie;
 168                 os_memcpy(pos, ftie, ftie_len);
 169                 if (ftie_len < 2 + sizeof(*_ftie)) {
 170                         os_free(buf);
 171                         return -1;
 172                 }
 173                 _ftie = (struct rsn_ftie *) (pos + 2);
 174                 os_memset(_ftie->mic, 0, sizeof(_ftie->mic));
 175                 pos += ftie_len;
 176         }
 177         if (ric) {
 178                 os_memcpy(pos, ric, ric_len);
 179                 pos += ric_len;
 180         }
 181
 182         wpa_hexdump(MSG_MSGDUMP, "FT: MIC data", buf, pos - buf);
 183         if (omac1_aes_128(kck, buf, pos - buf, mic)) {
 184                 os_free(buf);
 185                 return -1;
 186         }
 187
 188         os_free(buf);
 189
 190         return 0;
 191 }
 192
 193
 194 static int wpa_ft_parse_ftie(const u8 *ie, size_t ie_len,
 195                              struct wpa_ft_ies *parse)
 196 {
 197         const u8 *end, *pos;
 198
 199         parse->ftie = ie;
 200         parse->ftie_len = ie_len;
 201
 202         pos = ie + sizeof(struct rsn_ftie);
 203         end = ie + ie_len;
 204
 205         while (pos + 2 <= end && pos + 2 + pos[1] <= end) {
 206                 switch (pos[0]) {
 207                 case FTIE_SUBELEM_R1KH_ID:
 208                         if (pos[1] != FT_R1KH_ID_LEN) {
 209                                 wpa_printf(MSG_DEBUG, "FT: Invalid R1KH-ID "
 210                                            "length in FTIE: %d", pos[1]);
 211                                 return -1;
 212                         }
 213                         parse->r1kh_id = pos + 2;
 214                         break;
 215                 case FTIE_SUBELEM_GTK:
 216                         parse->gtk = pos + 2;
 217                         parse->gtk_len = pos[1];
 218                         break;
 219                 case FTIE_SUBELEM_R0KH_ID:
 220                         if (pos[1] < 1 || pos[1] > FT_R0KH_ID_MAX_LEN) {
 221                                 wpa_printf(MSG_DEBUG, "FT: Invalid R0KH-ID "
 222                                            "length in FTIE: %d", pos[1]);
 223                                 return -1;
 224                         }
 225                         parse->r0kh_id = pos + 2;
 226                         parse->r0kh_id_len = pos[1];
 227                         break;
 228 #ifdef CONFIG_IEEE80211W
 229                 case FTIE_SUBELEM_IGTK:
 230                         parse->igtk = pos + 2;
 231                         parse->igtk_len = pos[1];
 232                         break;
 233 #endif /* CONFIG_IEEE80211W */
 234                 }
 235
 236                 pos += 2 + pos[1];
 237         }
 238
 239         return 0;
 240 }
 241
 242
 243 int wpa_ft_parse_ies(const u8 *ies, size_t ies_len,
 244                      struct wpa_ft_ies *parse)
 245 {
 246         const u8 *end, *pos;
 247         struct wpa_ie_data data;
 248         int ret;
 249         const struct rsn_ftie *ftie;
 250         int prot_ie_count = 0;
 251
 252         os_memset(parse, 0, sizeof(*parse));
 253         if (ies == NULL)
 254                 return 0;
 255
 256         pos = ies;
 257         end = ies + ies_len;
 258         while (pos + 2 <= end && pos + 2 + pos[1] <= end) {
 259                 switch (pos[0]) {
 260                 case WLAN_EID_RSN:
 261                         parse->rsn = pos + 2;
 262                         parse->rsn_len = pos[1];
 263                         ret = wpa_parse_wpa_ie_rsn(parse->rsn - 2,
 264                                                    parse->rsn_len + 2,
 265                                                    &data);
 266                         if (ret < 0) {
 267                                 wpa_printf(MSG_DEBUG, "FT: Failed to parse "
 268                                            "RSN IE: %d", ret);
 269                                 return -1;
 270                         }
 271                         if (data.num_pmkid == 1 && data.pmkid)
 272                                 parse->rsn_pmkid = data.pmkid;
 273                         break;
 274                 case WLAN_EID_MOBILITY_DOMAIN:
 275                         parse->mdie = pos + 2;
 276                         parse->mdie_len = pos[1];
 277                         break;
 278                 case WLAN_EID_FAST_BSS_TRANSITION:
 279                         if (pos[1] < sizeof(*ftie))
 280                                 return -1;
 281                         ftie = (const struct rsn_ftie *) (pos + 2);
 282                         prot_ie_count = ftie->mic_control[1];
 283                         if (wpa_ft_parse_ftie(pos + 2, pos[1], parse) < 0)
 284                                 return -1;
 285                         break;
 286                 case WLAN_EID_TIMEOUT_INTERVAL:
 287                         parse->tie = pos + 2;
 288                         parse->tie_len = pos[1];
 289                         break;
 290                 case WLAN_EID_RIC_DATA:
 291                         if (parse->ric == NULL)
 292                                 parse->ric = pos;
 293                         break;
 294                 }
 295
 296                 pos += 2 + pos[1];
 297         }
 298
 299         if (prot_ie_count == 0)
 300                 return 0; /* no MIC */
 301
 302         /*
 303          * Check that the protected IE count matches with IEs included in the
 304          * frame.
 305          */
 306         if (parse->rsn)
 307                 prot_ie_count--;
 308         if (parse->mdie)
 309                 prot_ie_count--;
 310         if (parse->ftie)
 311                 prot_ie_count--;
 312         if (prot_ie_count < 0) {
 313                 wpa_printf(MSG_DEBUG, "FT: Some required IEs not included in "
 314                            "the protected IE count");
 315                 return -1;
 316         }
 317
 318         if (prot_ie_count == 0 && parse->ric) {
 319                 wpa_printf(MSG_DEBUG, "FT: RIC IE(s) in the frame, but not "
 320                            "included in protected IE count");
 321                 return -1;
 322         }
 323
 324         /* Determine the end of the RIC IE(s) */
 325         pos = parse->ric;
 326         while (pos && pos + 2 <= end && pos + 2 + pos[1] <= end &&
 327                prot_ie_count) {
 328                 prot_ie_count--;
 329                 pos += 2 + pos[1];
 330         }
 331         parse->ric_len = pos - parse->ric;
 332         if (prot_ie_count) {
 333                 wpa_printf(MSG_DEBUG, "FT: %d protected IEs missing from "
 334                            "frame", (int) prot_ie_count);
 335                 return -1;
 336         }
 337
 338         return 0;
 339 }
 340 #endif /* CONFIG_IEEE80211R */
 341
 342
 343 static int rsn_selector_to_bitfield(const u8 *s)
 344 {
 345         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_NONE)
 346                 return WPA_CIPHER_NONE;
 347         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_WEP40)
 348                 return WPA_CIPHER_WEP40;
 349         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_TKIP)
 350                 return WPA_CIPHER_TKIP;
 351         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_CCMP)
 352                 return WPA_CIPHER_CCMP;
 353         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_WEP104)
 354                 return WPA_CIPHER_WEP104;
 355 #ifdef CONFIG_IEEE80211W
 356         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_AES_128_CMAC)
 357                 return WPA_CIPHER_AES_128_CMAC;
 358 #endif /* CONFIG_IEEE80211W */
 359         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_GCMP)
 360                 return WPA_CIPHER_GCMP;
 361         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_CCMP_256)
 362                 return WPA_CIPHER_CCMP_256;
 363         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_GCMP_256)
 364                 return WPA_CIPHER_GCMP_256;
 365         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_BIP_GMAC_128)
 366                 return WPA_CIPHER_BIP_GMAC_128;
 367         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_BIP_GMAC_256)
 368                 return WPA_CIPHER_BIP_GMAC_256;
 369         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_BIP_CMAC_256)
 370                 return WPA_CIPHER_BIP_CMAC_256;
 371         if (RSN_SELECTOR_GET(s) == RSN_CIPHER_SUITE_NO_GROUP_ADDRESSED)
 372                 return WPA_CIPHER_GTK_NOT_USED;
 373         return 0;
 374 }
 375
 376
 377 static int rsn_key_mgmt_to_bitfield(const u8 *s)
 378 {
 379         if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_UNSPEC_802_1X)
 380                 return WPA_KEY_MGMT_IEEE8021X;
 381         if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X)
 382                 return WPA_KEY_MGMT_PSK;
 383 #ifdef CONFIG_IEEE80211R
 384         if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_FT_802_1X)
 385                 return WPA_KEY_MGMT_FT_IEEE8021X;
 386         if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_FT_PSK)
 387                 return WPA_KEY_MGMT_FT_PSK;
 388 #endif /* CONFIG_IEEE80211R */
 389 #ifdef CONFIG_IEEE80211W
 390         if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_802_1X_SHA256)
 391                 return WPA_KEY_MGMT_IEEE8021X_SHA256;
 392         if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_PSK_SHA256)
 393                 return WPA_KEY_MGMT_PSK_SHA256;
 394 #endif /* CONFIG_IEEE80211W */
 395 #ifdef CONFIG_SAE
 396         if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_SAE)
 397                 return WPA_KEY_MGMT_SAE;
 398         if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_FT_SAE)
 399                 return WPA_KEY_MGMT_FT_SAE;
 400 #endif /* CONFIG_SAE */
 401         if (RSN_SELECTOR_GET(s) == RSN_AUTH_KEY_MGMT_802_1X_SUITE_B)
 402                 return WPA_KEY_MGMT_IEEE8021X_SUITE_B;
 403         return 0;
 404 }
 405
 406
 407 static int wpa_cipher_valid_group(int cipher)
 408 {
 409         return wpa_cipher_valid_pairwise(cipher) ||
 410                 cipher == WPA_CIPHER_WEP104 ||
 411                 cipher == WPA_CIPHER_WEP40 ||
 412                 cipher == WPA_CIPHER_GTK_NOT_USED;
 413 }
 414
 415
 416 #ifdef CONFIG_IEEE80211W
 417 int wpa_cipher_valid_mgmt_group(int cipher)
 418 {
 419         return cipher == WPA_CIPHER_AES_128_CMAC ||
 420                 cipher == WPA_CIPHER_BIP_GMAC_128 ||
 421                 cipher == WPA_CIPHER_BIP_GMAC_256 ||
 422                 cipher == WPA_CIPHER_BIP_CMAC_256;
 423 }
 424 #endif /* CONFIG_IEEE80211W */
 425
 426
 427 /**
 428  * wpa_parse_wpa_ie_rsn - Parse RSN IE
 429  * @rsn_ie: Buffer containing RSN IE
 430  * @rsn_ie_len: RSN IE buffer length (including IE number and length octets)
 431  * @data: Pointer to structure that will be filled in with parsed data
 432  * Returns: 0 on success, <0 on failure
 433  */
 434 int wpa_parse_wpa_ie_rsn(const u8 *rsn_ie, size_t rsn_ie_len,
 435                          struct wpa_ie_data *data)
 436 {
 437         const struct rsn_ie_hdr *hdr;
 438         const u8 *pos;
 439         int left;
 440         int i, count;
 441
 442         os_memset(data, 0, sizeof(*data));
 443         data->proto = WPA_PROTO_RSN;
 444         data->pairwise_cipher = WPA_CIPHER_CCMP;
 445         data->group_cipher = WPA_CIPHER_CCMP;
 446         data->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
 447         data->capabilities = 0;
 448         data->pmkid = NULL;
 449         data->num_pmkid = 0;
 450 #ifdef CONFIG_IEEE80211W
 451         data->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
 452 #else /* CONFIG_IEEE80211W */
 453         data->mgmt_group_cipher = 0;
 454 #endif /* CONFIG_IEEE80211W */
 455
 456         if (rsn_ie_len == 0) {
 457                 /* No RSN IE - fail silently */
 458                 return -1;
 459         }
 460
 461         if (rsn_ie_len < sizeof(struct rsn_ie_hdr)) {
 462                 wpa_printf(MSG_DEBUG, "%s: ie len too short %lu",
 463                            __func__, (unsigned long) rsn_ie_len);
 464                 return -1;
 465         }
 466
 467         hdr = (const struct rsn_ie_hdr *) rsn_ie;
 468
 469         if (hdr->elem_id != WLAN_EID_RSN ||
 470             hdr->len != rsn_ie_len - 2 ||
 471             WPA_GET_LE16(hdr->version) != RSN_VERSION) {
 472                 wpa_printf(MSG_DEBUG, "%s: malformed ie or unknown version",
 473                            __func__);
 474                 return -2;
 475         }
 476
 477         pos = (const u8 *) (hdr + 1);
 478         left = rsn_ie_len - sizeof(*hdr);
 479
 480         if (left >= RSN_SELECTOR_LEN) {
 481                 data->group_cipher = rsn_selector_to_bitfield(pos);
 482                 if (!wpa_cipher_valid_group(data->group_cipher)) {
 483                         wpa_printf(MSG_DEBUG, "%s: invalid group cipher 0x%x",
 484                                    __func__, data->group_cipher);
 485                         return -1;
 486                 }
 487                 pos += RSN_SELECTOR_LEN;
 488                 left -= RSN_SELECTOR_LEN;
 489         } else if (left > 0) {
 490                 wpa_printf(MSG_DEBUG, "%s: ie length mismatch, %u too much",
 491                            __func__, left);
 492                 return -3;
 493         }
 494
 495         if (left >= 2) {
 496                 data->pairwise_cipher = 0;
 497                 count = WPA_GET_LE16(pos);
 498                 pos += 2;
 499                 left -= 2;
 500                 if (count == 0 || left < count * RSN_SELECTOR_LEN) {
 501                         wpa_printf(MSG_DEBUG, "%s: ie count botch (pairwise), "
 502                                    "count %u left %u", __func__, count, left);
 503                         return -4;
 504                 }
 505                 for (i = 0; i < count; i++) {
 506                         data->pairwise_cipher |= rsn_selector_to_bitfield(pos);
 507                         pos += RSN_SELECTOR_LEN;
 508                         left -= RSN_SELECTOR_LEN;
 509                 }
 510 #ifdef CONFIG_IEEE80211W
 511                 if (data->pairwise_cipher & WPA_CIPHER_AES_128_CMAC) {
 512                         wpa_printf(MSG_DEBUG, "%s: AES-128-CMAC used as "
 513                                    "pairwise cipher", __func__);
 514                         return -1;
 515                 }
 516 #endif /* CONFIG_IEEE80211W */
 517         } else if (left == 1) {
 518                 wpa_printf(MSG_DEBUG, "%s: ie too short (for key mgmt)",
 519                            __func__);
 520                 return -5;
 521         }
 522
 523         if (left >= 2) {
 524                 data->key_mgmt = 0;
 525                 count = WPA_GET_LE16(pos);
 526                 pos += 2;
 527                 left -= 2;
 528                 if (count == 0 || left < count * RSN_SELECTOR_LEN) {
 529                         wpa_printf(MSG_DEBUG, "%s: ie count botch (key mgmt), "
 530                                    "count %u left %u", __func__, count, left);
 531                         return -6;
 532                 }
 533                 for (i = 0; i < count; i++) {
 534                         data->key_mgmt |= rsn_key_mgmt_to_bitfield(pos);
 535                         pos += RSN_SELECTOR_LEN;
 536                         left -= RSN_SELECTOR_LEN;
 537                 }
 538         } else if (left == 1) {
 539                 wpa_printf(MSG_DEBUG, "%s: ie too short (for capabilities)",
 540                            __func__);
 541                 return -7;
 542         }
 543
 544         if (left >= 2) {
 545                 data->capabilities = WPA_GET_LE16(pos);
 546                 pos += 2;
 547                 left -= 2;
 548         }
 549
 550         if (left >= 2) {
 551                 data->num_pmkid = WPA_GET_LE16(pos);
 552                 pos += 2;
 553                 left -= 2;
 554                 if (left < (int) data->num_pmkid * PMKID_LEN) {
 555                         wpa_printf(MSG_DEBUG, "%s: PMKID underflow "
 556                                    "(num_pmkid=%lu left=%d)",
 557                                    __func__, (unsigned long) data->num_pmkid,
 558                                    left);
 559                         data->num_pmkid = 0;
 560                         return -9;
 561                 } else {
 562                         data->pmkid = pos;
 563                         pos += data->num_pmkid * PMKID_LEN;
 564                         left -= data->num_pmkid * PMKID_LEN;
 565                 }
 566         }
 567
 568 #ifdef CONFIG_IEEE80211W
 569         if (left >= 4) {
 570                 data->mgmt_group_cipher = rsn_selector_to_bitfield(pos);
 571                 if (!wpa_cipher_valid_mgmt_group(data->mgmt_group_cipher)) {
 572                         wpa_printf(MSG_DEBUG, "%s: Unsupported management "
 573                                    "group cipher 0x%x", __func__,
 574                                    data->mgmt_group_cipher);
 575                         return -10;
 576                 }
 577                 pos += RSN_SELECTOR_LEN;
 578                 left -= RSN_SELECTOR_LEN;
 579         }
 580 #endif /* CONFIG_IEEE80211W */
 581
 582         if (left > 0) {
 583                 wpa_hexdump(MSG_DEBUG,
 584                             "wpa_parse_wpa_ie_rsn: ignore trailing bytes",
 585                             pos, left);
 586         }
 587
 588         return 0;
 589 }
 590
 591
 592 static int wpa_selector_to_bitfield(const u8 *s)
 593 {
 594         if (RSN_SELECTOR_GET(s) == WPA_CIPHER_SUITE_NONE)
 595                 return WPA_CIPHER_NONE;
 596         if (RSN_SELECTOR_GET(s) == WPA_CIPHER_SUITE_WEP40)
 597                 return WPA_CIPHER_WEP40;
 598         if (RSN_SELECTOR_GET(s) == WPA_CIPHER_SUITE_TKIP)
 599                 return WPA_CIPHER_TKIP;
 600         if (RSN_SELECTOR_GET(s) == WPA_CIPHER_SUITE_CCMP)
 601                 return WPA_CIPHER_CCMP;
 602         if (RSN_SELECTOR_GET(s) == WPA_CIPHER_SUITE_WEP104)
 603                 return WPA_CIPHER_WEP104;
 604         return 0;
 605 }
 606
 607
 608 static int wpa_key_mgmt_to_bitfield(const u8 *s)
 609 {
 610         if (RSN_SELECTOR_GET(s) == WPA_AUTH_KEY_MGMT_UNSPEC_802_1X)
 611                 return WPA_KEY_MGMT_IEEE8021X;
 612         if (RSN_SELECTOR_GET(s) == WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X)
 613                 return WPA_KEY_MGMT_PSK;
 614         if (RSN_SELECTOR_GET(s) == WPA_AUTH_KEY_MGMT_NONE)
 615                 return WPA_KEY_MGMT_WPA_NONE;
 616         return 0;
 617 }
 618
 619
 620 int wpa_parse_wpa_ie_wpa(const u8 *wpa_ie, size_t wpa_ie_len,
 621                          struct wpa_ie_data *data)
 622 {
 623         const struct wpa_ie_hdr *hdr;
 624         const u8 *pos;
 625         int left;
 626         int i, count;
 627
 628         os_memset(data, 0, sizeof(*data));
 629         data->proto = WPA_PROTO_WPA;
 630         data->pairwise_cipher = WPA_CIPHER_TKIP;
 631         data->group_cipher = WPA_CIPHER_TKIP;
 632         data->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
 633         data->capabilities = 0;
 634         data->pmkid = NULL;
 635         data->num_pmkid = 0;
 636         data->mgmt_group_cipher = 0;
 637
 638         if (wpa_ie_len == 0) {
 639                 /* No WPA IE - fail silently */
 640                 return -1;
 641         }
 642
 643         if (wpa_ie_len < sizeof(struct wpa_ie_hdr)) {
 644                 wpa_printf(MSG_DEBUG, "%s: ie len too short %lu",
 645                            __func__, (unsigned long) wpa_ie_len);
 646                 return -1;
 647         }
 648
 649         hdr = (const struct wpa_ie_hdr *) wpa_ie;
 650
 651         if (hdr->elem_id != WLAN_EID_VENDOR_SPECIFIC ||
 652             hdr->len != wpa_ie_len - 2 ||
 653             RSN_SELECTOR_GET(hdr->oui) != WPA_OUI_TYPE ||
 654             WPA_GET_LE16(hdr->version) != WPA_VERSION) {
 655                 wpa_printf(MSG_DEBUG, "%s: malformed ie or unknown version",
 656                            __func__);
 657                 return -2;
 658         }
 659
 660         pos = (const u8 *) (hdr + 1);
 661         left = wpa_ie_len - sizeof(*hdr);
 662
 663         if (left >= WPA_SELECTOR_LEN) {
 664                 data->group_cipher = wpa_selector_to_bitfield(pos);
 665                 pos += WPA_SELECTOR_LEN;
 666                 left -= WPA_SELECTOR_LEN;
 667         } else if (left > 0) {
 668                 wpa_printf(MSG_DEBUG, "%s: ie length mismatch, %u too much",
 669                            __func__, left);
 670                 return -3;
 671         }
 672
 673         if (left >= 2) {
 674                 data->pairwise_cipher = 0;
 675                 count = WPA_GET_LE16(pos);
 676                 pos += 2;
 677                 left -= 2;
 678                 if (count == 0 || left < count * WPA_SELECTOR_LEN) {
 679                         wpa_printf(MSG_DEBUG, "%s: ie count botch (pairwise), "
 680                                    "count %u left %u", __func__, count, left);
 681                         return -4;
 682                 }
 683                 for (i = 0; i < count; i++) {
 684                         data->pairwise_cipher |= wpa_selector_to_bitfield(pos);
 685                         pos += WPA_SELECTOR_LEN;
 686                         left -= WPA_SELECTOR_LEN;
 687                 }
 688         } else if (left == 1) {
 689                 wpa_printf(MSG_DEBUG, "%s: ie too short (for key mgmt)",
 690                            __func__);
 691                 return -5;
 692         }
 693
 694         if (left >= 2) {
 695                 data->key_mgmt = 0;
 696                 count = WPA_GET_LE16(pos);
 697                 pos += 2;
 698                 left -= 2;
 699                 if (count == 0 || left < count * WPA_SELECTOR_LEN) {
 700                         wpa_printf(MSG_DEBUG, "%s: ie count botch (key mgmt), "
 701                                    "count %u left %u", __func__, count, left);
 702                         return -6;
 703                 }
 704                 for (i = 0; i < count; i++) {
 705                         data->key_mgmt |= wpa_key_mgmt_to_bitfield(pos);
 706                         pos += WPA_SELECTOR_LEN;
 707                         left -= WPA_SELECTOR_LEN;
 708                 }
 709         } else if (left == 1) {
 710                 wpa_printf(MSG_DEBUG, "%s: ie too short (for capabilities)",
 711                            __func__);
 712                 return -7;
 713         }
 714
 715         if (left >= 2) {
 716                 data->capabilities = WPA_GET_LE16(pos);
 717                 pos += 2;
 718                 left -= 2;
 719         }
 720
 721         if (left > 0) {
 722                 wpa_hexdump(MSG_DEBUG,
 723                             "wpa_parse_wpa_ie_wpa: ignore trailing bytes",
 724                             pos, left);
 725         }
 726
 727         return 0;
 728 }
 729
 730
 731 #ifdef CONFIG_IEEE80211R
 732
 733 /**
 734  * wpa_derive_pmk_r0 - Derive PMK-R0 and PMKR0Name
 735  *
 736  * IEEE Std 802.11r-2008 - 8.5.1.5.3
 737  */
 738 void wpa_derive_pmk_r0(const u8 *xxkey, size_t xxkey_len,
 739                        const u8 *ssid, size_t ssid_len,
 740                        const u8 *mdid, const u8 *r0kh_id, size_t r0kh_id_len,
 741                        const u8 *s0kh_id, u8 *pmk_r0, u8 *pmk_r0_name)
 742 {
 743         u8 buf[1 + WPA_MAX_SSID_LEN + MOBILITY_DOMAIN_ID_LEN + 1 +
 744                FT_R0KH_ID_MAX_LEN + ETH_ALEN];
 745         u8 *pos, r0_key_data[48], hash[32];
 746         const u8 *addr[2];
 747         size_t len[2];
 748
 749         /*
 750          * R0-Key-Data = KDF-384(XXKey, "FT-R0",
 751          *                       SSIDlength || SSID || MDID || R0KHlength ||
 752          *                       R0KH-ID || S0KH-ID)
 753          * XXKey is either the second 256 bits of MSK or PSK.
 754          * PMK-R0 = L(R0-Key-Data, 0, 256)
 755          * PMK-R0Name-Salt = L(R0-Key-Data, 256, 128)
 756          */
 757         if (ssid_len > WPA_MAX_SSID_LEN || r0kh_id_len > FT_R0KH_ID_MAX_LEN)
 758                 return;
 759         pos = buf;
 760         *pos++ = ssid_len;
 761         os_memcpy(pos, ssid, ssid_len);
 762         pos += ssid_len;
 763         os_memcpy(pos, mdid, MOBILITY_DOMAIN_ID_LEN);
 764         pos += MOBILITY_DOMAIN_ID_LEN;
 765         *pos++ = r0kh_id_len;
 766         os_memcpy(pos, r0kh_id, r0kh_id_len);
 767         pos += r0kh_id_len;
 768         os_memcpy(pos, s0kh_id, ETH_ALEN);
 769         pos += ETH_ALEN;
 770
 771         sha256_prf(xxkey, xxkey_len, "FT-R0", buf, pos - buf,
 772                    r0_key_data, sizeof(r0_key_data));
 773         os_memcpy(pmk_r0, r0_key_data, PMK_LEN);
 774
 775         /*
 776          * PMKR0Name = Truncate-128(SHA-256("FT-R0N" || PMK-R0Name-Salt)
 777          */
 778         addr[0] = (const u8 *) "FT-R0N";
 779         len[0] = 6;
 780         addr[1] = r0_key_data + PMK_LEN;
 781         len[1] = 16;
 782
 783         sha256_vector(2, addr, len, hash);
 784         os_memcpy(pmk_r0_name, hash, WPA_PMK_NAME_LEN);
 785 }
 786
 787
 788 /**
 789  * wpa_derive_pmk_r1_name - Derive PMKR1Name
 790  *
 791  * IEEE Std 802.11r-2008 - 8.5.1.5.4
 792  */
 793 void wpa_derive_pmk_r1_name(const u8 *pmk_r0_name, const u8 *r1kh_id,
 794                             const u8 *s1kh_id, u8 *pmk_r1_name)
 795 {
 796         u8 hash[32];
 797         const u8 *addr[4];
 798         size_t len[4];
 799
 800         /*
 801          * PMKR1Name = Truncate-128(SHA-256("FT-R1N" || PMKR0Name ||
 802          *                                  R1KH-ID || S1KH-ID))
 803          */
 804         addr[0] = (const u8 *) "FT-R1N";
 805         len[0] = 6;
 806         addr[1] = pmk_r0_name;
 807         len[1] = WPA_PMK_NAME_LEN;
 808         addr[2] = r1kh_id;
 809         len[2] = FT_R1KH_ID_LEN;
 810         addr[3] = s1kh_id;
 811         len[3] = ETH_ALEN;
 812
 813         sha256_vector(4, addr, len, hash);
 814         os_memcpy(pmk_r1_name, hash, WPA_PMK_NAME_LEN);
 815 }
 816
 817
 818 /**
 819  * wpa_derive_pmk_r1 - Derive PMK-R1 and PMKR1Name from PMK-R0
 820  *
 821  * IEEE Std 802.11r-2008 - 8.5.1.5.4
 822  */
 823 void wpa_derive_pmk_r1(const u8 *pmk_r0, const u8 *pmk_r0_name,
 824                        const u8 *r1kh_id, const u8 *s1kh_id,
 825                        u8 *pmk_r1, u8 *pmk_r1_name)
 826 {
 827         u8 buf[FT_R1KH_ID_LEN + ETH_ALEN];
 828         u8 *pos;
 829
 830         /* PMK-R1 = KDF-256(PMK-R0, "FT-R1", R1KH-ID || S1KH-ID) */
 831         pos = buf;
 832         os_memcpy(pos, r1kh_id, FT_R1KH_ID_LEN);
 833         pos += FT_R1KH_ID_LEN;
 834         os_memcpy(pos, s1kh_id, ETH_ALEN);
 835         pos += ETH_ALEN;
 836
 837         sha256_prf(pmk_r0, PMK_LEN, "FT-R1", buf, pos - buf, pmk_r1, PMK_LEN);
 838
 839         wpa_derive_pmk_r1_name(pmk_r0_name, r1kh_id, s1kh_id, pmk_r1_name);
 840 }
 841
 842
 843 /**
 844  * wpa_pmk_r1_to_ptk - Derive PTK and PTKName from PMK-R1
 845  *
 846  * IEEE Std 802.11r-2008 - 8.5.1.5.5
 847  */
 848 void wpa_pmk_r1_to_ptk(const u8 *pmk_r1, const u8 *snonce, const u8 *anonce,
 849                        const u8 *sta_addr, const u8 *bssid,
 850                        const u8 *pmk_r1_name,
 851                        u8 *ptk, size_t ptk_len, u8 *ptk_name)
 852 {
 853         u8 buf[2 * WPA_NONCE_LEN + 2 * ETH_ALEN];
 854         u8 *pos, hash[32];
 855         const u8 *addr[6];
 856         size_t len[6];
 857
 858         /*
 859          * PTK = KDF-PTKLen(PMK-R1, "FT-PTK", SNonce || ANonce ||
 860          *                  BSSID || STA-ADDR)
 861          */
 862         pos = buf;
 863         os_memcpy(pos, snonce, WPA_NONCE_LEN);
 864         pos += WPA_NONCE_LEN;
 865         os_memcpy(pos, anonce, WPA_NONCE_LEN);
 866         pos += WPA_NONCE_LEN;
 867         os_memcpy(pos, bssid, ETH_ALEN);
 868         pos += ETH_ALEN;
 869         os_memcpy(pos, sta_addr, ETH_ALEN);
 870         pos += ETH_ALEN;
 871
 872         sha256_prf(pmk_r1, PMK_LEN, "FT-PTK", buf, pos - buf, ptk, ptk_len);
 873
 874         /*
 875          * PTKName = Truncate-128(SHA-256(PMKR1Name || "FT-PTKN" || SNonce ||
 876          *                                ANonce || BSSID || STA-ADDR))
 877          */
 878         addr[0] = pmk_r1_name;
 879         len[0] = WPA_PMK_NAME_LEN;
 880         addr[1] = (const u8 *) "FT-PTKN";
 881         len[1] = 7;
 882         addr[2] = snonce;
 883         len[2] = WPA_NONCE_LEN;
 884         addr[3] = anonce;
 885         len[3] = WPA_NONCE_LEN;
 886         addr[4] = bssid;
 887         len[4] = ETH_ALEN;
 888         addr[5] = sta_addr;
 889         len[5] = ETH_ALEN;
 890
 891         sha256_vector(6, addr, len, hash);
 892         os_memcpy(ptk_name, hash, WPA_PMK_NAME_LEN);
 893 }
 894
 895 #endif /* CONFIG_IEEE80211R */
 896
 897
 898 /**
 899  * rsn_pmkid - Calculate PMK identifier
 900  * @pmk: Pairwise master key
 901  * @pmk_len: Length of pmk in bytes
 902  * @aa: Authenticator address
 903  * @spa: Supplicant address
 904  * @pmkid: Buffer for PMKID
 905  * @use_sha256: Whether to use SHA256-based KDF
 906  *
 907  * IEEE Std 802.11i-2004 - 8.5.1.2 Pairwise key hierarchy
 908  * PMKID = HMAC-SHA1-128(PMK, "PMK Name" || AA || SPA)
 909  */
 910 void rsn_pmkid(const u8 *pmk, size_t pmk_len, const u8 *aa, const u8 *spa,
 911                u8 *pmkid, int use_sha256)
 912 {
 913         char *title = "PMK Name";
 914         const u8 *addr[3];
 915         const size_t len[3] = { 8, ETH_ALEN, ETH_ALEN };
 916         unsigned char hash[SHA256_MAC_LEN];
 917
 918         addr[0] = (u8 *) title;
 919         addr[1] = aa;
 920         addr[2] = spa;
 921
 922 #ifdef CONFIG_IEEE80211W
 923         if (use_sha256)
 924                 hmac_sha256_vector(pmk, pmk_len, 3, addr, len, hash);
 925         else
 926 #endif /* CONFIG_IEEE80211W */
 927                 hmac_sha1_vector(pmk, pmk_len, 3, addr, len, hash);
 928         os_memcpy(pmkid, hash, PMKID_LEN);
 929 }
 930
 931
 932 /**
 933  * wpa_cipher_txt - Convert cipher suite to a text string
 934  * @cipher: Cipher suite (WPA_CIPHER_* enum)
 935  * Returns: Pointer to a text string of the cipher suite name
 936  */
 937 const char * wpa_cipher_txt(int cipher)
 938 {
 939         switch (cipher) {
 940         case WPA_CIPHER_NONE:
 941                 return "NONE";
 942         case WPA_CIPHER_WEP40:
 943                 return "WEP-40";
 944         case WPA_CIPHER_WEP104:
 945                 return "WEP-104";
 946         case WPA_CIPHER_TKIP:
 947                 return "TKIP";
 948         case WPA_CIPHER_CCMP:
 949                 return "CCMP";
 950         case WPA_CIPHER_CCMP | WPA_CIPHER_TKIP:
 951                 return "CCMP+TKIP";
 952         case WPA_CIPHER_GCMP:
 953                 return "GCMP";
 954         case WPA_CIPHER_GCMP_256:
 955                 return "GCMP-256";
 956         case WPA_CIPHER_CCMP_256:
 957                 return "CCMP-256";
 958         case WPA_CIPHER_GTK_NOT_USED:
 959                 return "GTK_NOT_USED";
 960         default:
 961                 return "UNKNOWN";
 962         }
 963 }
 964
 965
 966 /**
 967  * wpa_key_mgmt_txt - Convert key management suite to a text string
 968  * @key_mgmt: Key management suite (WPA_KEY_MGMT_* enum)
 969  * @proto: WPA/WPA2 version (WPA_PROTO_*)
 970  * Returns: Pointer to a text string of the key management suite name
 971  */
 972 const char * wpa_key_mgmt_txt(int key_mgmt, int proto)
 973 {
 974         switch (key_mgmt) {
 975         case WPA_KEY_MGMT_IEEE8021X:
 976                 if (proto == (WPA_PROTO_RSN | WPA_PROTO_WPA))
 977                         return "WPA2+WPA/IEEE 802.1X/EAP";
 978                 return proto == WPA_PROTO_RSN ?
 979                         "WPA2/IEEE 802.1X/EAP" : "WPA/IEEE 802.1X/EAP";
 980         case WPA_KEY_MGMT_PSK:
 981                 if (proto == (WPA_PROTO_RSN | WPA_PROTO_WPA))
 982                         return "WPA2-PSK+WPA-PSK";
 983                 return proto == WPA_PROTO_RSN ?
 984                         "WPA2-PSK" : "WPA-PSK";
 985         case WPA_KEY_MGMT_NONE:
 986                 return "NONE";
 987         case WPA_KEY_MGMT_IEEE8021X_NO_WPA:
 988                 return "IEEE 802.1X (no WPA)";
 989 #ifdef CONFIG_IEEE80211R
 990         case WPA_KEY_MGMT_FT_IEEE8021X:
 991                 return "FT-EAP";
 992         case WPA_KEY_MGMT_FT_PSK:
 993                 return "FT-PSK";
 994 #endif /* CONFIG_IEEE80211R */
 995 #ifdef CONFIG_IEEE80211W
 996         case WPA_KEY_MGMT_IEEE8021X_SHA256:
 997                 return "WPA2-EAP-SHA256";
 998         case WPA_KEY_MGMT_PSK_SHA256:
 999                 return "WPA2-PSK-SHA256";
1000 #endif /* CONFIG_IEEE80211W */
1001         case WPA_KEY_MGMT_IEEE8021X_SUITE_B:
1002                 return "WPA2-EAP-SUITE-B";
1003         default:
1004                 return "UNKNOWN";
1005         }
1006 }
1007
1008
1009 u32 wpa_akm_to_suite(int akm)
1010 {
1011         if (akm & WPA_KEY_MGMT_FT_IEEE8021X)
1012                 return WLAN_AKM_SUITE_FT_8021X;
1013         if (akm & WPA_KEY_MGMT_FT_PSK)
1014                 return WLAN_AKM_SUITE_FT_PSK;
1015         if (akm & WPA_KEY_MGMT_IEEE8021X)
1016                 return WLAN_AKM_SUITE_8021X;
1017         if (akm & WPA_KEY_MGMT_IEEE8021X_SHA256)
1018                 return WLAN_AKM_SUITE_8021X_SHA256;
1019         if (akm & WPA_KEY_MGMT_IEEE8021X)
1020                 return WLAN_AKM_SUITE_8021X;
1021         if (akm & WPA_KEY_MGMT_PSK_SHA256)
1022                 return WLAN_AKM_SUITE_PSK_SHA256;
1023         if (akm & WPA_KEY_MGMT_PSK)
1024                 return WLAN_AKM_SUITE_PSK;
1025         if (akm & WPA_KEY_MGMT_CCKM)
1026                 return WLAN_AKM_SUITE_CCKM;
1027         if (akm & WPA_KEY_MGMT_OSEN)
1028                 return WLAN_AKM_SUITE_OSEN;
1029         if (akm & WPA_KEY_MGMT_IEEE8021X_SUITE_B)
1030                 return WLAN_AKM_SUITE_8021X_SUITE_B;
1031         return 0;
1032 }
1033
1034
1035 int wpa_compare_rsn_ie(int ft_initial_assoc,
1036                        const u8 *ie1, size_t ie1len,
1037                        const u8 *ie2, size_t ie2len)
1038 {
1039         if (ie1 == NULL || ie2 == NULL)
1040                 return -1;
1041
1042         if (ie1len == ie2len && os_memcmp(ie1, ie2, ie1len) == 0)
1043                 return 0; /* identical IEs */
1044
1045 #ifdef CONFIG_IEEE80211R
1046         if (ft_initial_assoc) {
1047                 struct wpa_ie_data ie1d, ie2d;
1048                 /*
1049                  * The PMKID-List in RSN IE is different between Beacon/Probe
1050                  * Response/(Re)Association Request frames and EAPOL-Key
1051                  * messages in FT initial mobility domain association. Allow
1052                  * for this, but verify that other parts of the RSN IEs are
1053                  * identical.
1054                  */
1055                 if (wpa_parse_wpa_ie_rsn(ie1, ie1len, &ie1d) < 0 ||
1056                     wpa_parse_wpa_ie_rsn(ie2, ie2len, &ie2d) < 0)
1057                         return -1;
1058                 if (ie1d.proto == ie2d.proto &&
1059                     ie1d.pairwise_cipher == ie2d.pairwise_cipher &&
1060                     ie1d.group_cipher == ie2d.group_cipher &&
1061                     ie1d.key_mgmt == ie2d.key_mgmt &&
1062                     ie1d.capabilities == ie2d.capabilities &&
1063                     ie1d.mgmt_group_cipher == ie2d.mgmt_group_cipher)
1064                         return 0;
1065         }
1066 #endif /* CONFIG_IEEE80211R */
1067
1068         return -1;
1069 }
1070
1071
1072 #ifdef CONFIG_IEEE80211R
1073 int wpa_insert_pmkid(u8 *ies, size_t ies_len, const u8 *pmkid)
1074 {
1075         u8 *start, *end, *rpos, *rend;
1076         int added = 0;
1077
1078         start = ies;
1079         end = ies + ies_len;
1080
1081         while (start < end) {
1082                 if (*start == WLAN_EID_RSN)
1083                         break;
1084                 start += 2 + start[1];
1085         }
1086         if (start >= end) {
1087                 wpa_printf(MSG_ERROR, "FT: Could not find RSN IE in "
1088                            "IEs data");
1089                 return -1;
1090         }
1091         wpa_hexdump(MSG_DEBUG, "FT: RSN IE before modification",
1092                     start, 2 + start[1]);
1093
1094         /* Find start of PMKID-Count */
1095         rpos = start + 2;
1096         rend = rpos + start[1];
1097
1098         /* Skip Version and Group Data Cipher Suite */
1099         rpos += 2 + 4;
1100         /* Skip Pairwise Cipher Suite Count and List */
1101         rpos += 2 + WPA_GET_LE16(rpos) * RSN_SELECTOR_LEN;
1102         /* Skip AKM Suite Count and List */
1103         rpos += 2 + WPA_GET_LE16(rpos) * RSN_SELECTOR_LEN;
1104
1105         if (rpos == rend) {
1106                 /* Add RSN Capabilities */
1107                 os_memmove(rpos + 2, rpos, end - rpos);
1108                 *rpos++ = 0;
1109                 *rpos++ = 0;
1110         } else {
1111                 /* Skip RSN Capabilities */
1112                 rpos += 2;
1113                 if (rpos > rend) {
1114                         wpa_printf(MSG_ERROR, "FT: Could not parse RSN IE in "
1115                                    "IEs data");
1116                         return -1;
1117                 }
1118         }
1119
1120         if (rpos == rend) {
1121                 /* No PMKID-Count field included; add it */
1122                 os_memmove(rpos + 2 + PMKID_LEN, rpos, end - rpos);
1123                 WPA_PUT_LE16(rpos, 1);
1124                 rpos += 2;
1125                 os_memcpy(rpos, pmkid, PMKID_LEN);
1126                 added += 2 + PMKID_LEN;
1127                 start[1] += 2 + PMKID_LEN;
1128         } else {
1129                 /* PMKID-Count was included; use it */
1130                 if (WPA_GET_LE16(rpos) != 0) {
1131                         wpa_printf(MSG_ERROR, "FT: Unexpected PMKID "
1132                                    "in RSN IE in EAPOL-Key data");
1133                         return -1;
1134                 }
1135                 WPA_PUT_LE16(rpos, 1);
1136                 rpos += 2;
1137                 os_memmove(rpos + PMKID_LEN, rpos, end - rpos);
1138                 os_memcpy(rpos, pmkid, PMKID_LEN);
1139                 added += PMKID_LEN;
1140                 start[1] += PMKID_LEN;
1141         }
1142
1143         wpa_hexdump(MSG_DEBUG, "FT: RSN IE after modification "
1144                     "(PMKID inserted)", start, 2 + start[1]);
1145
1146         return added;
1147 }
1148 #endif /* CONFIG_IEEE80211R */
1149
1150
1151 int wpa_cipher_key_len(int cipher)
1152 {
1153         switch (cipher) {
1154         case WPA_CIPHER_CCMP_256:
1155         case WPA_CIPHER_GCMP_256:
1156         case WPA_CIPHER_BIP_GMAC_256:
1157         case WPA_CIPHER_BIP_CMAC_256:
1158                 return 32;
1159         case WPA_CIPHER_CCMP:
1160         case WPA_CIPHER_GCMP:
1161         case WPA_CIPHER_AES_128_CMAC:
1162         case WPA_CIPHER_BIP_GMAC_128:
1163                 return 16;
1164         case WPA_CIPHER_TKIP:
1165                 return 32;
1166         case WPA_CIPHER_WEP104:
1167                 return 13;
1168         case WPA_CIPHER_WEP40:
1169                 return 5;
1170         }
1171
1172         return 0;
1173 }
1174
1175
1176 int wpa_cipher_rsc_len(int cipher)
1177 {
1178         switch (cipher) {
1179         case WPA_CIPHER_CCMP_256:
1180         case WPA_CIPHER_GCMP_256:
1181         case WPA_CIPHER_CCMP:
1182         case WPA_CIPHER_GCMP:
1183         case WPA_CIPHER_TKIP:
1184                 return 6;
1185         case WPA_CIPHER_WEP104:
1186         case WPA_CIPHER_WEP40:
1187                 return 0;
1188         }
1189
1190         return 0;
1191 }
1192
1193
1194 int wpa_cipher_to_alg(int cipher)
1195 {
1196         switch (cipher) {
1197         case WPA_CIPHER_CCMP_256:
1198                 return WPA_ALG_CCMP_256;
1199         case WPA_CIPHER_GCMP_256:
1200                 return WPA_ALG_GCMP_256;
1201         case WPA_CIPHER_CCMP:
1202                 return WPA_ALG_CCMP;
1203         case WPA_CIPHER_GCMP:
1204                 return WPA_ALG_GCMP;
1205         case WPA_CIPHER_TKIP:
1206                 return WPA_ALG_TKIP;
1207         case WPA_CIPHER_WEP104:
1208         case WPA_CIPHER_WEP40:
1209                 return WPA_ALG_WEP;
1210         case WPA_CIPHER_AES_128_CMAC:
1211                 return WPA_ALG_IGTK;
1212         case WPA_CIPHER_BIP_GMAC_128:
1213                 return WPA_ALG_BIP_GMAC_128;
1214         case WPA_CIPHER_BIP_GMAC_256:
1215                 return WPA_ALG_BIP_GMAC_256;
1216         case WPA_CIPHER_BIP_CMAC_256:
1217                 return WPA_ALG_BIP_CMAC_256;
1218         }
1219         return WPA_ALG_NONE;
1220 }
1221
1222
1223 int wpa_cipher_valid_pairwise(int cipher)
1224 {
1225         return cipher == WPA_CIPHER_CCMP_256 ||
1226                 cipher == WPA_CIPHER_GCMP_256 ||
1227                 cipher == WPA_CIPHER_CCMP ||
1228                 cipher == WPA_CIPHER_GCMP ||
1229                 cipher == WPA_CIPHER_TKIP;
1230 }
1231
1232
1233 u32 wpa_cipher_to_suite(int proto, int cipher)
1234 {
1235         if (cipher & WPA_CIPHER_CCMP_256)
1236                 return RSN_CIPHER_SUITE_CCMP_256;
1237         if (cipher & WPA_CIPHER_GCMP_256)
1238                 return RSN_CIPHER_SUITE_GCMP_256;
1239         if (cipher & WPA_CIPHER_CCMP)
1240                 return (proto == WPA_PROTO_RSN ?
1241                         RSN_CIPHER_SUITE_CCMP : WPA_CIPHER_SUITE_CCMP);
1242         if (cipher & WPA_CIPHER_GCMP)
1243                 return RSN_CIPHER_SUITE_GCMP;
1244         if (cipher & WPA_CIPHER_TKIP)
1245                 return (proto == WPA_PROTO_RSN ?
1246                         RSN_CIPHER_SUITE_TKIP : WPA_CIPHER_SUITE_TKIP);
1247         if (cipher & WPA_CIPHER_WEP104)
1248                 return (proto == WPA_PROTO_RSN ?
1249                         RSN_CIPHER_SUITE_WEP104 : WPA_CIPHER_SUITE_WEP104);
1250         if (cipher & WPA_CIPHER_WEP40)
1251                 return (proto == WPA_PROTO_RSN ?
1252                         RSN_CIPHER_SUITE_WEP40 : WPA_CIPHER_SUITE_WEP40);
1253         if (cipher & WPA_CIPHER_NONE)
1254                 return (proto == WPA_PROTO_RSN ?
1255                         RSN_CIPHER_SUITE_NONE : WPA_CIPHER_SUITE_NONE);
1256         if (cipher & WPA_CIPHER_GTK_NOT_USED)
1257                 return RSN_CIPHER_SUITE_NO_GROUP_ADDRESSED;
1258         if (cipher & WPA_CIPHER_AES_128_CMAC)
1259                 return RSN_CIPHER_SUITE_AES_128_CMAC;
1260         if (cipher & WPA_CIPHER_BIP_GMAC_128)
1261                 return RSN_CIPHER_SUITE_BIP_GMAC_128;
1262         if (cipher & WPA_CIPHER_BIP_GMAC_256)
1263                 return RSN_CIPHER_SUITE_BIP_GMAC_256;
1264         if (cipher & WPA_CIPHER_BIP_CMAC_256)
1265                 return RSN_CIPHER_SUITE_BIP_CMAC_256;
1266         return 0;
1267 }
1268
1269
1270 int rsn_cipher_put_suites(u8 *start, int ciphers)
1271 {
1272         u8 *pos = start;
1273
1274         if (ciphers & WPA_CIPHER_CCMP_256) {
1275                 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_CCMP_256);
1276                 pos += RSN_SELECTOR_LEN;
1277         }
1278         if (ciphers & WPA_CIPHER_GCMP_256) {
1279                 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_GCMP_256);
1280                 pos += RSN_SELECTOR_LEN;
1281         }
1282         if (ciphers & WPA_CIPHER_CCMP) {
1283                 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_CCMP);
1284                 pos += RSN_SELECTOR_LEN;
1285         }
1286         if (ciphers & WPA_CIPHER_GCMP) {
1287                 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_GCMP);
1288                 pos += RSN_SELECTOR_LEN;
1289         }
1290         if (ciphers & WPA_CIPHER_TKIP) {
1291                 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_TKIP);
1292                 pos += RSN_SELECTOR_LEN;
1293         }
1294         if (ciphers & WPA_CIPHER_NONE) {
1295                 RSN_SELECTOR_PUT(pos, RSN_CIPHER_SUITE_NONE);
1296                 pos += RSN_SELECTOR_LEN;
1297         }
1298
1299         return (pos - start) / RSN_SELECTOR_LEN;
1300 }
1301
1302
1303 int wpa_cipher_put_suites(u8 *start, int ciphers)
1304 {
1305         u8 *pos = start;
1306
1307         if (ciphers & WPA_CIPHER_CCMP) {
1308                 RSN_SELECTOR_PUT(pos, WPA_CIPHER_SUITE_CCMP);
1309                 pos += WPA_SELECTOR_LEN;
1310         }
1311         if (ciphers & WPA_CIPHER_TKIP) {
1312                 RSN_SELECTOR_PUT(pos, WPA_CIPHER_SUITE_TKIP);
1313                 pos += WPA_SELECTOR_LEN;
1314         }
1315         if (ciphers & WPA_CIPHER_NONE) {
1316                 RSN_SELECTOR_PUT(pos, WPA_CIPHER_SUITE_NONE);
1317                 pos += WPA_SELECTOR_LEN;
1318         }
1319
1320         return (pos - start) / RSN_SELECTOR_LEN;
1321 }
1322
1323
1324 int wpa_pick_pairwise_cipher(int ciphers, int none_allowed)
1325 {
1326         if (ciphers & WPA_CIPHER_CCMP_256)
1327                 return WPA_CIPHER_CCMP_256;
1328         if (ciphers & WPA_CIPHER_GCMP_256)
1329                 return WPA_CIPHER_GCMP_256;
1330         if (ciphers & WPA_CIPHER_CCMP)
1331                 return WPA_CIPHER_CCMP;
1332         if (ciphers & WPA_CIPHER_GCMP)
1333                 return WPA_CIPHER_GCMP;
1334         if (ciphers & WPA_CIPHER_TKIP)
1335                 return WPA_CIPHER_TKIP;
1336         if (none_allowed && (ciphers & WPA_CIPHER_NONE))
1337                 return WPA_CIPHER_NONE;
1338         return -1;
1339 }
1340
1341
1342 int wpa_pick_group_cipher(int ciphers)
1343 {
1344         if (ciphers & WPA_CIPHER_CCMP_256)
1345                 return WPA_CIPHER_CCMP_256;
1346         if (ciphers & WPA_CIPHER_GCMP_256)
1347                 return WPA_CIPHER_GCMP_256;
1348         if (ciphers & WPA_CIPHER_CCMP)
1349                 return WPA_CIPHER_CCMP;
1350         if (ciphers & WPA_CIPHER_GCMP)
1351                 return WPA_CIPHER_GCMP;
1352         if (ciphers & WPA_CIPHER_GTK_NOT_USED)
1353                 return WPA_CIPHER_GTK_NOT_USED;
1354         if (ciphers & WPA_CIPHER_TKIP)
1355                 return WPA_CIPHER_TKIP;
1356         if (ciphers & WPA_CIPHER_WEP104)
1357                 return WPA_CIPHER_WEP104;
1358         if (ciphers & WPA_CIPHER_WEP40)
1359                 return WPA_CIPHER_WEP40;
1360         return -1;
1361 }
1362
1363
1364 int wpa_parse_cipher(const char *value)
1365 {
1366         int val = 0, last;
1367         char *start, *end, *buf;
1368
1369         buf = os_strdup(value);
1370         if (buf == NULL)
1371                 return -1;
1372         start = buf;
1373
1374         while (*start != '\0') {
1375                 while (*start == ' ' || *start == '\t')
1376                         start++;
1377                 if (*start == '\0')
1378                         break;
1379                 end = start;
1380                 while (*end != ' ' && *end != '\t' && *end != '\0')
1381                         end++;
1382                 last = *end == '\0';
1383                 *end = '\0';
1384                 if (os_strcmp(start, "CCMP-256") == 0)
1385                         val |= WPA_CIPHER_CCMP_256;
1386                 else if (os_strcmp(start, "GCMP-256") == 0)
1387                         val |= WPA_CIPHER_GCMP_256;
1388                 else if (os_strcmp(start, "CCMP") == 0)
1389                         val |= WPA_CIPHER_CCMP;
1390                 else if (os_strcmp(start, "GCMP") == 0)
1391                         val |= WPA_CIPHER_GCMP;
1392                 else if (os_strcmp(start, "TKIP") == 0)
1393                         val |= WPA_CIPHER_TKIP;
1394                 else if (os_strcmp(start, "WEP104") == 0)
1395                         val |= WPA_CIPHER_WEP104;
1396                 else if (os_strcmp(start, "WEP40") == 0)
1397                         val |= WPA_CIPHER_WEP40;
1398                 else if (os_strcmp(start, "NONE") == 0)
1399                         val |= WPA_CIPHER_NONE;
1400                 else if (os_strcmp(start, "GTK_NOT_USED") == 0)
1401                         val |= WPA_CIPHER_GTK_NOT_USED;
1402                 else {
1403                         os_free(buf);
1404                         return -1;
1405                 }
1406
1407                 if (last)
1408                         break;
1409                 start = end + 1;
1410         }
1411         os_free(buf);
1412
1413         return val;
1414 }
1415
1416
1417 int wpa_write_ciphers(char *start, char *end, int ciphers, const char *delim)
1418 {
1419         char *pos = start;
1420         int ret;
1421
1422         if (ciphers & WPA_CIPHER_CCMP_256) {
1423                 ret = os_snprintf(pos, end - pos, "%sCCMP-256",
1424                                   pos == start ? "" : delim);
1425                 if (ret < 0 || ret >= end - pos)
1426                         return -1;
1427                 pos += ret;
1428         }
1429         if (ciphers & WPA_CIPHER_GCMP_256) {
1430                 ret = os_snprintf(pos, end - pos, "%sGCMP-256",
1431                                   pos == start ? "" : delim);
1432                 if (ret < 0 || ret >= end - pos)
1433                         return -1;
1434                 pos += ret;
1435         }
1436         if (ciphers & WPA_CIPHER_CCMP) {
1437                 ret = os_snprintf(pos, end - pos, "%sCCMP",
1438                                   pos == start ? "" : delim);
1439                 if (ret < 0 || ret >= end - pos)
1440                         return -1;
1441                 pos += ret;
1442         }
1443         if (ciphers & WPA_CIPHER_GCMP) {
1444                 ret = os_snprintf(pos, end - pos, "%sGCMP",
1445                                   pos == start ? "" : delim);
1446                 if (ret < 0 || ret >= end - pos)
1447                         return -1;
1448                 pos += ret;
1449         }
1450         if (ciphers & WPA_CIPHER_TKIP) {
1451                 ret = os_snprintf(pos, end - pos, "%sTKIP",
1452                                   pos == start ? "" : delim);
1453                 if (ret < 0 || ret >= end - pos)
1454                         return -1;
1455                 pos += ret;
1456         }
1457         if (ciphers & WPA_CIPHER_WEP104) {
1458                 ret = os_snprintf(pos, end - pos, "%sWEP104",
1459                                   pos == start ? "" : delim);
1460                 if (ret < 0 || ret >= end - pos)
1461                         return -1;
1462                 pos += ret;
1463         }
1464         if (ciphers & WPA_CIPHER_WEP40) {
1465                 ret = os_snprintf(pos, end - pos, "%sWEP40",
1466                                   pos == start ? "" : delim);
1467                 if (ret < 0 || ret >= end - pos)
1468                         return -1;
1469                 pos += ret;
1470         }
1471         if (ciphers & WPA_CIPHER_NONE) {
1472                 ret = os_snprintf(pos, end - pos, "%sNONE",
1473                                   pos == start ? "" : delim);
1474                 if (ret < 0 || ret >= end - pos)
1475                         return -1;
1476                 pos += ret;
1477         }
1478
1479         return pos - start;
1480 }
1481
1482
1483 int wpa_select_ap_group_cipher(int wpa, int wpa_pairwise, int rsn_pairwise)
1484 {
1485         int pairwise = 0;
1486
1487         /* Select group cipher based on the enabled pairwise cipher suites */
1488         if (wpa & 1)
1489                 pairwise |= wpa_pairwise;
1490         if (wpa & 2)
1491                 pairwise |= rsn_pairwise;
1492
1493         if (pairwise & WPA_CIPHER_TKIP)
1494                 return WPA_CIPHER_TKIP;
1495         if ((pairwise & (WPA_CIPHER_CCMP | WPA_CIPHER_GCMP)) == WPA_CIPHER_GCMP)
1496                 return WPA_CIPHER_GCMP;
1497         if ((pairwise & (WPA_CIPHER_GCMP_256 | WPA_CIPHER_CCMP |
1498                          WPA_CIPHER_GCMP)) == WPA_CIPHER_GCMP_256)
1499                 return WPA_CIPHER_GCMP_256;
1500         if ((pairwise & (WPA_CIPHER_CCMP_256 | WPA_CIPHER_CCMP |
1501                          WPA_CIPHER_GCMP)) == WPA_CIPHER_CCMP_256)
1502                 return WPA_CIPHER_CCMP_256;
1503         return WPA_CIPHER_CCMP;
1504 }