src/rsn_supp/wpa.c

   1 /*
   2  * WPA Supplicant - WPA state machine and EAPOL-Key processing
   3  * Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  16
  17 #include "common.h"
  18 #include "rc4.h"
  19 #include "aes_wrap.h"
  20 #include "wpa.h"
  21 #include "eloop.h"
  22 #include "eapol_supp/eapol_supp_sm.h"
  23 #include "preauth.h"
  24 #include "pmksa_cache.h"
  25 #include "wpa_i.h"
  26 #include "wpa_ie.h"
  27 #include "peerkey.h"
  28 #include "ieee802_11_defs.h"
  29
  30
  31 /**
  32  * wpa_cipher_txt - Convert cipher suite to a text string
  33  * @cipher: Cipher suite (WPA_CIPHER_* enum)
  34  * Returns: Pointer to a text string of the cipher suite name
  35  */
  36 static const char * wpa_cipher_txt(int cipher)
  37 {
  38         switch (cipher) {
  39         case WPA_CIPHER_NONE:
  40                 return "NONE";
  41         case WPA_CIPHER_WEP40:
  42                 return "WEP-40";
  43         case WPA_CIPHER_WEP104:
  44                 return "WEP-104";
  45         case WPA_CIPHER_TKIP:
  46                 return "TKIP";
  47         case WPA_CIPHER_CCMP:
  48                 return "CCMP";
  49         default:
  50                 return "UNKNOWN";
  51         }
  52 }
  53
  54
  55 /**
  56  * wpa_key_mgmt_txt - Convert key management suite to a text string
  57  * @key_mgmt: Key management suite (WPA_KEY_MGMT_* enum)
  58  * @proto: WPA/WPA2 version (WPA_PROTO_*)
  59  * Returns: Pointer to a text string of the key management suite name
  60  */
  61 static const char * wpa_key_mgmt_txt(int key_mgmt, int proto)
  62 {
  63         switch (key_mgmt) {
  64         case WPA_KEY_MGMT_IEEE8021X:
  65                 return proto == WPA_PROTO_RSN ?
  66                         "WPA2/IEEE 802.1X/EAP" : "WPA/IEEE 802.1X/EAP";
  67         case WPA_KEY_MGMT_PSK:
  68                 return proto == WPA_PROTO_RSN ?
  69                         "WPA2-PSK" : "WPA-PSK";
  70         case WPA_KEY_MGMT_NONE:
  71                 return "NONE";
  72         case WPA_KEY_MGMT_IEEE8021X_NO_WPA:
  73                 return "IEEE 802.1X (no WPA)";
  74 #ifdef CONFIG_IEEE80211R
  75         case WPA_KEY_MGMT_FT_IEEE8021X:
  76                 return "FT-EAP";
  77         case WPA_KEY_MGMT_FT_PSK:
  78                 return "FT-PSK";
  79 #endif /* CONFIG_IEEE80211R */
  80         default:
  81                 return "UNKNOWN";
  82         }
  83 }
  84
  85
  86 /**
  87  * wpa_eapol_key_send - Send WPA/RSN EAPOL-Key message
  88  * @sm: Pointer to WPA state machine data from wpa_sm_init()
  89  * @kck: Key Confirmation Key (KCK, part of PTK)
  90  * @ver: Version field from Key Info
  91  * @dest: Destination address for the frame
  92  * @proto: Ethertype (usually ETH_P_EAPOL)
  93  * @msg: EAPOL-Key message
  94  * @msg_len: Length of message
  95  * @key_mic: Pointer to the buffer to which the EAPOL-Key MIC is written
  96  */
  97 void wpa_eapol_key_send(struct wpa_sm *sm, const u8 *kck,
  98                         int ver, const u8 *dest, u16 proto,
  99                         u8 *msg, size_t msg_len, u8 *key_mic)
 100 {
 101         if (is_zero_ether_addr(dest) && is_zero_ether_addr(sm->bssid)) {
 102                 /*
 103                  * Association event was not yet received; try to fetch
 104                  * BSSID from the driver.
 105                  */
 106                 if (wpa_sm_get_bssid(sm, sm->bssid) < 0) {
 107                         wpa_printf(MSG_DEBUG, "WPA: Failed to read BSSID for "
 108                                    "EAPOL-Key destination address");
 109                 } else {
 110                         dest = sm->bssid;
 111                         wpa_printf(MSG_DEBUG, "WPA: Use BSSID (" MACSTR
 112                                    ") as the destination for EAPOL-Key",
 113                                    MAC2STR(dest));
 114                 }
 115         }
 116         if (key_mic)
 117                 wpa_eapol_key_mic(kck, ver, msg, msg_len, key_mic);
 118         wpa_hexdump(MSG_MSGDUMP, "WPA: TX EAPOL-Key", msg, msg_len);
 119         wpa_sm_ether_send(sm, dest, proto, msg, msg_len);
 120         eapol_sm_notify_tx_eapol_key(sm->eapol);
 121         os_free(msg);
 122 }
 123
 124
 125 /**
 126  * wpa_sm_key_request - Send EAPOL-Key Request
 127  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 128  * @error: Indicate whether this is an Michael MIC error report
 129  * @pairwise: 1 = error report for pairwise packet, 0 = for group packet
 130  * Returns: Pointer to the current network structure or %NULL on failure
 131  *
 132  * Send an EAPOL-Key Request to the current authenticator. This function is
 133  * used to request rekeying and it is usually called when a local Michael MIC
 134  * failure is detected.
 135  */
 136 void wpa_sm_key_request(struct wpa_sm *sm, int error, int pairwise)
 137 {
 138         size_t rlen;
 139         struct wpa_eapol_key *reply;
 140         int key_info, ver;
 141         u8 bssid[ETH_ALEN], *rbuf;
 142
 143         if (sm->key_mgmt == WPA_KEY_MGMT_FT_IEEE8021X ||
 144             sm->key_mgmt == WPA_KEY_MGMT_FT_PSK)
 145                 ver = WPA_KEY_INFO_TYPE_AES_128_CMAC;
 146         else if (sm->pairwise_cipher == WPA_CIPHER_CCMP)
 147                 ver = WPA_KEY_INFO_TYPE_HMAC_SHA1_AES;
 148         else
 149                 ver = WPA_KEY_INFO_TYPE_HMAC_MD5_RC4;
 150
 151         if (wpa_sm_get_bssid(sm, bssid) < 0) {
 152                 wpa_printf(MSG_WARNING, "Failed to read BSSID for EAPOL-Key "
 153                            "request");
 154                 return;
 155         }
 156
 157         rbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY, NULL,
 158                                   sizeof(*reply), &rlen, (void *) &reply);
 159         if (rbuf == NULL)
 160                 return;
 161
 162         reply->type = sm->proto == WPA_PROTO_RSN ?
 163                 EAPOL_KEY_TYPE_RSN : EAPOL_KEY_TYPE_WPA;
 164         key_info = WPA_KEY_INFO_REQUEST | ver;
 165         if (sm->ptk_set)
 166                 key_info |= WPA_KEY_INFO_MIC;
 167         if (error)
 168                 key_info |= WPA_KEY_INFO_ERROR;
 169         if (pairwise)
 170                 key_info |= WPA_KEY_INFO_KEY_TYPE;
 171         WPA_PUT_BE16(reply->key_info, key_info);
 172         WPA_PUT_BE16(reply->key_length, 0);
 173         os_memcpy(reply->replay_counter, sm->request_counter,
 174                   WPA_REPLAY_COUNTER_LEN);
 175         inc_byte_array(sm->request_counter, WPA_REPLAY_COUNTER_LEN);
 176
 177         WPA_PUT_BE16(reply->key_data_length, 0);
 178
 179         wpa_printf(MSG_INFO, "WPA: Sending EAPOL-Key Request (error=%d "
 180                    "pairwise=%d ptk_set=%d len=%lu)",
 181                    error, pairwise, sm->ptk_set, (unsigned long) rlen);
 182         wpa_eapol_key_send(sm, sm->ptk.kck, ver, bssid, ETH_P_EAPOL,
 183                            rbuf, rlen, key_info & WPA_KEY_INFO_MIC ?
 184                            reply->key_mic : NULL);
 185 }
 186
 187
 188 static int wpa_supplicant_get_pmk(struct wpa_sm *sm,
 189                                   const unsigned char *src_addr,
 190                                   const u8 *pmkid)
 191 {
 192         int abort_cached = 0;
 193
 194         if (pmkid && !sm->cur_pmksa) {
 195                 /* When using drivers that generate RSN IE, wpa_supplicant may
 196                  * not have enough time to get the association information
 197                  * event before receiving this 1/4 message, so try to find a
 198                  * matching PMKSA cache entry here. */
 199                 sm->cur_pmksa = pmksa_cache_get(sm->pmksa, src_addr, pmkid);
 200                 if (sm->cur_pmksa) {
 201                         wpa_printf(MSG_DEBUG, "RSN: found matching PMKID from "
 202                                    "PMKSA cache");
 203                 } else {
 204                         wpa_printf(MSG_DEBUG, "RSN: no matching PMKID found");
 205                         abort_cached = 1;
 206                 }
 207         }
 208
 209         if (pmkid && sm->cur_pmksa &&
 210             os_memcmp(pmkid, sm->cur_pmksa->pmkid, PMKID_LEN) == 0) {
 211                 wpa_hexdump(MSG_DEBUG, "RSN: matched PMKID", pmkid, PMKID_LEN);
 212                 wpa_sm_set_pmk_from_pmksa(sm);
 213                 wpa_hexdump_key(MSG_DEBUG, "RSN: PMK from PMKSA cache",
 214                                 sm->pmk, sm->pmk_len);
 215                 eapol_sm_notify_cached(sm->eapol);
 216 #ifdef CONFIG_IEEE80211R
 217                 sm->xxkey_len = 0;
 218 #endif /* CONFIG_IEEE80211R */
 219         } else if ((sm->key_mgmt == WPA_KEY_MGMT_IEEE8021X ||
 220                     sm->key_mgmt == WPA_KEY_MGMT_FT_IEEE8021X) && sm->eapol) {
 221                 int res, pmk_len;
 222                 pmk_len = PMK_LEN;
 223                 res = eapol_sm_get_key(sm->eapol, sm->pmk, PMK_LEN);
 224                 if (res) {
 225                         /*
 226                          * EAP-LEAP is an exception from other EAP methods: it
 227                          * uses only 16-byte PMK.
 228                          */
 229                         res = eapol_sm_get_key(sm->eapol, sm->pmk, 16);
 230                         pmk_len = 16;
 231                 } else {
 232 #ifdef CONFIG_IEEE80211R
 233                         u8 buf[2 * PMK_LEN];
 234                         if (eapol_sm_get_key(sm->eapol, buf, 2 * PMK_LEN) == 0)
 235                         {
 236                                 os_memcpy(sm->xxkey, buf + PMK_LEN, PMK_LEN);
 237                                 sm->xxkey_len = PMK_LEN;
 238                                 os_memset(buf, 0, sizeof(buf));
 239                         }
 240 #endif /* CONFIG_IEEE80211R */
 241                 }
 242                 if (res == 0) {
 243                         wpa_hexdump_key(MSG_DEBUG, "WPA: PMK from EAPOL state "
 244                                         "machines", sm->pmk, pmk_len);
 245                         sm->pmk_len = pmk_len;
 246                         pmksa_cache_add(sm->pmksa, sm->pmk, pmk_len, src_addr,
 247                                         sm->own_addr, sm->network_ctx);
 248                         if (!sm->cur_pmksa && pmkid &&
 249                             pmksa_cache_get(sm->pmksa, src_addr, pmkid)) {
 250                                 wpa_printf(MSG_DEBUG, "RSN: the new PMK "
 251                                            "matches with the PMKID");
 252                                 abort_cached = 0;
 253                         }
 254                 } else {
 255                         wpa_msg(sm->ctx->ctx, MSG_WARNING,
 256                                 "WPA: Failed to get master session key from "
 257                                 "EAPOL state machines");
 258                         wpa_msg(sm->ctx->ctx, MSG_WARNING,
 259                                 "WPA: Key handshake aborted");
 260                         if (sm->cur_pmksa) {
 261                                 wpa_printf(MSG_DEBUG, "RSN: Cancelled PMKSA "
 262                                            "caching attempt");
 263                                 sm->cur_pmksa = NULL;
 264                                 abort_cached = 1;
 265                         } else {
 266                                 return -1;
 267                         }
 268                 }
 269         }
 270
 271         if (abort_cached && (sm->key_mgmt == WPA_KEY_MGMT_IEEE8021X ||
 272                              sm->key_mgmt == WPA_KEY_MGMT_FT_IEEE8021X)) {
 273                 /* Send EAPOL-Start to trigger full EAP authentication. */
 274                 u8 *buf;
 275                 size_t buflen;
 276
 277                 wpa_printf(MSG_DEBUG, "RSN: no PMKSA entry found - trigger "
 278                            "full EAP authentication");
 279                 buf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_START,
 280                                          NULL, 0, &buflen, NULL);
 281                 if (buf) {
 282                         wpa_sm_ether_send(sm, sm->bssid, ETH_P_EAPOL,
 283                                           buf, buflen);
 284                         os_free(buf);
 285                 }
 286
 287                 return -1;
 288         }
 289
 290         return 0;
 291 }
 292
 293
 294 /**
 295  * wpa_supplicant_send_2_of_4 - Send message 2 of WPA/RSN 4-Way Handshake
 296  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 297  * @dst: Destination address for the frame
 298  * @key: Pointer to the EAPOL-Key frame header
 299  * @ver: Version bits from EAPOL-Key Key Info
 300  * @nonce: Nonce value for the EAPOL-Key frame
 301  * @wpa_ie: WPA/RSN IE
 302  * @wpa_ie_len: Length of the WPA/RSN IE
 303  * @ptk: PTK to use for keyed hash and encryption
 304  * Returns: 0 on success, -1 on failure
 305  */
 306 int wpa_supplicant_send_2_of_4(struct wpa_sm *sm, const unsigned char *dst,
 307                                const struct wpa_eapol_key *key,
 308                                int ver, const u8 *nonce,
 309                                const u8 *wpa_ie, size_t wpa_ie_len,
 310                                struct wpa_ptk *ptk)
 311 {
 312         size_t rlen;
 313         struct wpa_eapol_key *reply;
 314         u8 *rbuf;
 315
 316         if (wpa_ie == NULL) {
 317                 wpa_printf(MSG_WARNING, "WPA: No wpa_ie set - cannot "
 318                            "generate msg 2/4");
 319                 return -1;
 320         }
 321
 322         wpa_hexdump(MSG_DEBUG, "WPA: WPA IE for msg 2/4", wpa_ie, wpa_ie_len);
 323
 324         rbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY,
 325                                   NULL, sizeof(*reply) + wpa_ie_len,
 326                                   &rlen, (void *) &reply);
 327         if (rbuf == NULL)
 328                 return -1;
 329
 330         reply->type = sm->proto == WPA_PROTO_RSN ?
 331                 EAPOL_KEY_TYPE_RSN : EAPOL_KEY_TYPE_WPA;
 332         WPA_PUT_BE16(reply->key_info,
 333                      ver | WPA_KEY_INFO_KEY_TYPE | WPA_KEY_INFO_MIC);
 334         if (sm->proto == WPA_PROTO_RSN)
 335                 WPA_PUT_BE16(reply->key_length, 0);
 336         else
 337                 os_memcpy(reply->key_length, key->key_length, 2);
 338         os_memcpy(reply->replay_counter, key->replay_counter,
 339                   WPA_REPLAY_COUNTER_LEN);
 340
 341         WPA_PUT_BE16(reply->key_data_length, wpa_ie_len);
 342         os_memcpy(reply + 1, wpa_ie, wpa_ie_len);
 343
 344         os_memcpy(reply->key_nonce, nonce, WPA_NONCE_LEN);
 345
 346         wpa_printf(MSG_DEBUG, "WPA: Sending EAPOL-Key 2/4");
 347         wpa_eapol_key_send(sm, ptk->kck, ver, dst, ETH_P_EAPOL,
 348                            rbuf, rlen, reply->key_mic);
 349
 350         return 0;
 351 }
 352
 353
 354 static int wpa_derive_ptk(struct wpa_sm *sm, const unsigned char *src_addr,
 355                           const struct wpa_eapol_key *key,
 356                           struct wpa_ptk *ptk)
 357 {
 358 #ifdef CONFIG_IEEE80211R
 359         if (sm->key_mgmt == WPA_KEY_MGMT_FT_IEEE8021X ||
 360             sm->key_mgmt == WPA_KEY_MGMT_FT_PSK)
 361                 return wpa_derive_ptk_ft(sm, src_addr, key, ptk);
 362 #endif /* CONFIG_IEEE80211R */
 363
 364         wpa_pmk_to_ptk(sm->pmk, sm->pmk_len, "Pairwise key expansion",
 365                        sm->own_addr, sm->bssid, sm->snonce, key->key_nonce,
 366                        (u8 *) ptk, sizeof(*ptk));
 367         return 0;
 368 }
 369
 370
 371 static void wpa_supplicant_process_1_of_4(struct wpa_sm *sm,
 372                                           const unsigned char *src_addr,
 373                                           const struct wpa_eapol_key *key,
 374                                           u16 ver)
 375 {
 376         struct wpa_eapol_ie_parse ie;
 377         struct wpa_ptk *ptk;
 378         u8 buf[8];
 379
 380         if (wpa_sm_get_network_ctx(sm) == NULL) {
 381                 wpa_printf(MSG_WARNING, "WPA: No SSID info found (msg 1 of "
 382                            "4).");
 383                 return;
 384         }
 385
 386         wpa_sm_set_state(sm, WPA_4WAY_HANDSHAKE);
 387         wpa_printf(MSG_DEBUG, "WPA: RX message 1 of 4-Way Handshake from "
 388                    MACSTR " (ver=%d)", MAC2STR(src_addr), ver);
 389
 390         os_memset(&ie, 0, sizeof(ie));
 391
 392 #ifndef CONFIG_NO_WPA2
 393         if (sm->proto == WPA_PROTO_RSN) {
 394                 /* RSN: msg 1/4 should contain PMKID for the selected PMK */
 395                 const u8 *_buf = (const u8 *) (key + 1);
 396                 size_t len = WPA_GET_BE16(key->key_data_length);
 397                 wpa_hexdump(MSG_DEBUG, "RSN: msg 1/4 key data", _buf, len);
 398                 wpa_supplicant_parse_ies(_buf, len, &ie);
 399                 if (ie.pmkid) {
 400                         wpa_hexdump(MSG_DEBUG, "RSN: PMKID from "
 401                                     "Authenticator", ie.pmkid, PMKID_LEN);
 402                 }
 403         }
 404 #endif /* CONFIG_NO_WPA2 */
 405
 406         if (wpa_supplicant_get_pmk(sm, src_addr, ie.pmkid))
 407                 return;
 408
 409         if (sm->renew_snonce) {
 410                 if (os_get_random(sm->snonce, WPA_NONCE_LEN)) {
 411                         wpa_msg(sm->ctx->ctx, MSG_WARNING,
 412                                 "WPA: Failed to get random data for SNonce");
 413                         return;
 414                 }
 415                 sm->renew_snonce = 0;
 416                 wpa_hexdump(MSG_DEBUG, "WPA: Renewed SNonce",
 417                             sm->snonce, WPA_NONCE_LEN);
 418         }
 419
 420         /* Calculate PTK which will be stored as a temporary PTK until it has
 421          * been verified when processing message 3/4. */
 422         ptk = &sm->tptk;
 423         wpa_derive_ptk(sm, src_addr, key, ptk);
 424         /* Supplicant: swap tx/rx Mic keys */
 425         os_memcpy(buf, ptk->u.auth.tx_mic_key, 8);
 426         os_memcpy(ptk->u.auth.tx_mic_key, ptk->u.auth.rx_mic_key, 8);
 427         os_memcpy(ptk->u.auth.rx_mic_key, buf, 8);
 428         sm->tptk_set = 1;
 429
 430         if (wpa_supplicant_send_2_of_4(sm, sm->bssid, key, ver, sm->snonce,
 431                                        sm->assoc_wpa_ie, sm->assoc_wpa_ie_len,
 432                                        ptk))
 433                 return;
 434
 435         os_memcpy(sm->anonce, key->key_nonce, WPA_NONCE_LEN);
 436 }
 437
 438
 439 static void wpa_sm_start_preauth(void *eloop_ctx, void *timeout_ctx)
 440 {
 441         struct wpa_sm *sm = eloop_ctx;
 442         rsn_preauth_candidate_process(sm);
 443 }
 444
 445
 446 static void wpa_supplicant_key_neg_complete(struct wpa_sm *sm,
 447                                             const u8 *addr, int secure)
 448 {
 449         wpa_msg(sm->ctx->ctx, MSG_INFO, "WPA: Key negotiation completed with "
 450                 MACSTR " [PTK=%s GTK=%s]", MAC2STR(addr),
 451                 wpa_cipher_txt(sm->pairwise_cipher),
 452                 wpa_cipher_txt(sm->group_cipher));
 453         wpa_sm_cancel_auth_timeout(sm);
 454         wpa_sm_set_state(sm, WPA_COMPLETED);
 455
 456         if (secure) {
 457                 wpa_sm_mlme_setprotection(
 458                         sm, addr, MLME_SETPROTECTION_PROTECT_TYPE_RX_TX,
 459                         MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
 460                 eapol_sm_notify_portValid(sm->eapol, TRUE);
 461                 if (sm->key_mgmt == WPA_KEY_MGMT_PSK ||
 462                     sm->key_mgmt == WPA_KEY_MGMT_FT_PSK)
 463                         eapol_sm_notify_eap_success(sm->eapol, TRUE);
 464                 /*
 465                  * Start preauthentication after a short wait to avoid a
 466                  * possible race condition between the data receive and key
 467                  * configuration after the 4-Way Handshake. This increases the
 468                  * likelyhood of the first preauth EAPOL-Start frame getting to
 469                  * the target AP.
 470                  */
 471                 eloop_register_timeout(1, 0, wpa_sm_start_preauth, sm, NULL);
 472         }
 473
 474         if (sm->cur_pmksa && sm->cur_pmksa->opportunistic) {
 475                 wpa_printf(MSG_DEBUG, "RSN: Authenticator accepted "
 476                            "opportunistic PMKSA entry - marking it valid");
 477                 sm->cur_pmksa->opportunistic = 0;
 478         }
 479
 480 #ifdef CONFIG_IEEE80211R
 481         if (sm->key_mgmt == WPA_KEY_MGMT_FT_IEEE8021X ||
 482             sm->key_mgmt == WPA_KEY_MGMT_FT_PSK) {
 483                 /* Prepare for the next transition */
 484                 wpa_ft_prepare_auth_request(sm);
 485         }
 486 #endif /* CONFIG_IEEE80211R */
 487 }
 488
 489
 490 static int wpa_supplicant_install_ptk(struct wpa_sm *sm,
 491                                       const struct wpa_eapol_key *key)
 492 {
 493         int keylen, rsclen;
 494         wpa_alg alg;
 495         const u8 *key_rsc;
 496         u8 null_rsc[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
 497
 498         wpa_printf(MSG_DEBUG, "WPA: Installing PTK to the driver.");
 499
 500         switch (sm->pairwise_cipher) {
 501         case WPA_CIPHER_CCMP:
 502                 alg = WPA_ALG_CCMP;
 503                 keylen = 16;
 504                 rsclen = 6;
 505                 break;
 506         case WPA_CIPHER_TKIP:
 507                 alg = WPA_ALG_TKIP;
 508                 keylen = 32;
 509                 rsclen = 6;
 510                 break;
 511         case WPA_CIPHER_NONE:
 512                 wpa_printf(MSG_DEBUG, "WPA: Pairwise Cipher Suite: "
 513                            "NONE - do not use pairwise keys");
 514                 return 0;
 515         default:
 516                 wpa_printf(MSG_WARNING, "WPA: Unsupported pairwise cipher %d",
 517                            sm->pairwise_cipher);
 518                 return -1;
 519         }
 520
 521         if (sm->proto == WPA_PROTO_RSN) {
 522                 key_rsc = null_rsc;
 523         } else {
 524                 key_rsc = key->key_rsc;
 525                 wpa_hexdump(MSG_DEBUG, "WPA: RSC", key_rsc, rsclen);
 526         }
 527
 528         if (wpa_sm_set_key(sm, alg, sm->bssid, 0, 1, key_rsc, rsclen,
 529                            (u8 *) sm->ptk.tk1, keylen) < 0) {
 530                 wpa_printf(MSG_WARNING, "WPA: Failed to set PTK to the "
 531                            "driver.");
 532                 return -1;
 533         }
 534         return 0;
 535 }
 536
 537
 538 static int wpa_supplicant_check_group_cipher(int group_cipher,
 539                                              int keylen, int maxkeylen,
 540                                              int *key_rsc_len, wpa_alg *alg)
 541 {
 542         int ret = 0;
 543
 544         switch (group_cipher) {
 545         case WPA_CIPHER_CCMP:
 546                 if (keylen != 16 || maxkeylen < 16) {
 547                         ret = -1;
 548                         break;
 549                 }
 550                 *key_rsc_len = 6;
 551                 *alg = WPA_ALG_CCMP;
 552                 break;
 553         case WPA_CIPHER_TKIP:
 554                 if (keylen != 32 || maxkeylen < 32) {
 555                         ret = -1;
 556                         break;
 557                 }
 558                 *key_rsc_len = 6;
 559                 *alg = WPA_ALG_TKIP;
 560                 break;
 561         case WPA_CIPHER_WEP104:
 562                 if (keylen != 13 || maxkeylen < 13) {
 563                         ret = -1;
 564                         break;
 565                 }
 566                 *key_rsc_len = 0;
 567                 *alg = WPA_ALG_WEP;
 568                 break;
 569         case WPA_CIPHER_WEP40:
 570                 if (keylen != 5 || maxkeylen < 5) {
 571                         ret = -1;
 572                         break;
 573                 }
 574                 *key_rsc_len = 0;
 575                 *alg = WPA_ALG_WEP;
 576                 break;
 577         default:
 578                 wpa_printf(MSG_WARNING, "WPA: Unsupported Group Cipher %d",
 579                            group_cipher);
 580                 return -1;
 581         }
 582
 583         if (ret < 0 ) {
 584                 wpa_printf(MSG_WARNING, "WPA: Unsupported %s Group Cipher key "
 585                            "length %d (%d).",
 586                            wpa_cipher_txt(group_cipher), keylen, maxkeylen);
 587         }
 588
 589         return ret;
 590 }
 591
 592
 593 struct wpa_gtk_data {
 594         wpa_alg alg;
 595         int tx, key_rsc_len, keyidx;
 596         u8 gtk[32];
 597         int gtk_len;
 598 };
 599
 600
 601 static int wpa_supplicant_install_gtk(struct wpa_sm *sm,
 602                                       const struct wpa_gtk_data *gd,
 603                                       const u8 *key_rsc)
 604 {
 605         const u8 *_gtk = gd->gtk;
 606         u8 gtk_buf[32];
 607
 608         wpa_hexdump_key(MSG_DEBUG, "WPA: Group Key", gd->gtk, gd->gtk_len);
 609         wpa_printf(MSG_DEBUG, "WPA: Installing GTK to the driver "
 610                    "(keyidx=%d tx=%d len=%d).", gd->keyidx, gd->tx,
 611                    gd->gtk_len);
 612         wpa_hexdump(MSG_DEBUG, "WPA: RSC", key_rsc, gd->key_rsc_len);
 613         if (sm->group_cipher == WPA_CIPHER_TKIP) {
 614                 /* Swap Tx/Rx keys for Michael MIC */
 615                 os_memcpy(gtk_buf, gd->gtk, 16);
 616                 os_memcpy(gtk_buf + 16, gd->gtk + 24, 8);
 617                 os_memcpy(gtk_buf + 24, gd->gtk + 16, 8);
 618                 _gtk = gtk_buf;
 619         }
 620         if (sm->pairwise_cipher == WPA_CIPHER_NONE) {
 621                 if (wpa_sm_set_key(sm, gd->alg,
 622                                    (u8 *) "\xff\xff\xff\xff\xff\xff",
 623                                    gd->keyidx, 1, key_rsc, gd->key_rsc_len,
 624                                    _gtk, gd->gtk_len) < 0) {
 625                         wpa_printf(MSG_WARNING, "WPA: Failed to set "
 626                                    "GTK to the driver (Group only).");
 627                         return -1;
 628                 }
 629         } else if (wpa_sm_set_key(sm, gd->alg,
 630                                   (u8 *) "\xff\xff\xff\xff\xff\xff",
 631                                   gd->keyidx, gd->tx, key_rsc, gd->key_rsc_len,
 632                                   _gtk, gd->gtk_len) < 0) {
 633                 wpa_printf(MSG_WARNING, "WPA: Failed to set GTK to "
 634                            "the driver.");
 635                 return -1;
 636         }
 637
 638         return 0;
 639 }
 640
 641
 642 static int wpa_supplicant_gtk_tx_bit_workaround(const struct wpa_sm *sm,
 643                                                 int tx)
 644 {
 645         if (tx && sm->pairwise_cipher != WPA_CIPHER_NONE) {
 646                 /* Ignore Tx bit for GTK if a pairwise key is used. One AP
 647                  * seemed to set this bit (incorrectly, since Tx is only when
 648                  * doing Group Key only APs) and without this workaround, the
 649                  * data connection does not work because wpa_supplicant
 650                  * configured non-zero keyidx to be used for unicast. */
 651                 wpa_printf(MSG_INFO, "WPA: Tx bit set for GTK, but pairwise "
 652                            "keys are used - ignore Tx bit");
 653                 return 0;
 654         }
 655         return tx;
 656 }
 657
 658
 659 static int wpa_supplicant_pairwise_gtk(struct wpa_sm *sm,
 660                                        const struct wpa_eapol_key *key,
 661                                        const u8 *gtk, size_t gtk_len,
 662                                        int key_info)
 663 {
 664 #ifndef CONFIG_NO_WPA2
 665         struct wpa_gtk_data gd;
 666
 667         /*
 668          * IEEE Std 802.11i-2004 - 8.5.2 EAPOL-Key frames - Figure 43x
 669          * GTK KDE format:
 670          * KeyID[bits 0-1], Tx [bit 2], Reserved [bits 3-7]
 671          * Reserved [bits 0-7]
 672          * GTK
 673          */
 674
 675         os_memset(&gd, 0, sizeof(gd));
 676         wpa_hexdump_key(MSG_DEBUG, "RSN: received GTK in pairwise handshake",
 677                         gtk, gtk_len);
 678
 679         if (gtk_len < 2 || gtk_len - 2 > sizeof(gd.gtk))
 680                 return -1;
 681
 682         gd.keyidx = gtk[0] & 0x3;
 683         gd.tx = wpa_supplicant_gtk_tx_bit_workaround(sm,
 684                                                      !!(gtk[0] & BIT(2)));
 685         gtk += 2;
 686         gtk_len -= 2;
 687
 688         os_memcpy(gd.gtk, gtk, gtk_len);
 689         gd.gtk_len = gtk_len;
 690
 691         if (wpa_supplicant_check_group_cipher(sm->group_cipher,
 692                                               gtk_len, gtk_len,
 693                                               &gd.key_rsc_len, &gd.alg) ||
 694             wpa_supplicant_install_gtk(sm, &gd, key->key_rsc)) {
 695                 wpa_printf(MSG_DEBUG, "RSN: Failed to install GTK");
 696                 return -1;
 697         }
 698
 699         wpa_supplicant_key_neg_complete(sm, sm->bssid,
 700                                         key_info & WPA_KEY_INFO_SECURE);
 701         return 0;
 702 #else /* CONFIG_NO_WPA2 */
 703         return -1;
 704 #endif /* CONFIG_NO_WPA2 */
 705 }
 706
 707
 708 static int ieee80211w_set_keys(struct wpa_sm *sm,
 709                                struct wpa_eapol_ie_parse *ie)
 710 {
 711 #ifdef CONFIG_IEEE80211W
 712         if (sm->mgmt_group_cipher != WPA_CIPHER_AES_128_CMAC)
 713                 return 0;
 714
 715         if (ie->igtk) {
 716                 const struct wpa_igtk_kde *igtk;
 717                 u16 keyidx;
 718                 if (ie->igtk_len != sizeof(*igtk))
 719                         return -1;
 720                 igtk = (const struct wpa_igtk_kde *) ie->igtk;
 721                 keyidx = WPA_GET_LE16(igtk->keyid);
 722                 wpa_printf(MSG_DEBUG, "WPA: IGTK keyid %d "
 723                            "pn %02x%02x%02x%02x%02x%02x",
 724                            keyidx, MAC2STR(igtk->pn));
 725                 wpa_hexdump_key(MSG_DEBUG, "WPA: IGTK",
 726                                 igtk->igtk, WPA_IGTK_LEN);
 727                 if (keyidx > 4095) {
 728                         wpa_printf(MSG_WARNING, "WPA: Invalid IGTK KeyID %d",
 729                                    keyidx);
 730                         return -1;
 731                 }
 732                 if (wpa_sm_set_key(sm, WPA_ALG_IGTK,
 733                                    (u8 *) "\xff\xff\xff\xff\xff\xff",
 734                                    keyidx, 0, igtk->pn, sizeof(igtk->pn),
 735                                    igtk->igtk, WPA_IGTK_LEN) < 0) {
 736                         wpa_printf(MSG_WARNING, "WPA: Failed to configure IGTK"
 737                                    " to the driver");
 738                         return -1;
 739                 }
 740         }
 741
 742         return 0;
 743 #else /* CONFIG_IEEE80211W */
 744         return 0;
 745 #endif /* CONFIG_IEEE80211W */
 746 }
 747
 748
 749 static void wpa_report_ie_mismatch(struct wpa_sm *sm,
 750                                    const char *reason, const u8 *src_addr,
 751                                    const u8 *wpa_ie, size_t wpa_ie_len,
 752                                    const u8 *rsn_ie, size_t rsn_ie_len)
 753 {
 754         wpa_msg(sm->ctx->ctx, MSG_WARNING, "WPA: %s (src=" MACSTR ")",
 755                 reason, MAC2STR(src_addr));
 756
 757         if (sm->ap_wpa_ie) {
 758                 wpa_hexdump(MSG_INFO, "WPA: WPA IE in Beacon/ProbeResp",
 759                             sm->ap_wpa_ie, sm->ap_wpa_ie_len);
 760         }
 761         if (wpa_ie) {
 762                 if (!sm->ap_wpa_ie) {
 763                         wpa_printf(MSG_INFO, "WPA: No WPA IE in "
 764                                    "Beacon/ProbeResp");
 765                 }
 766                 wpa_hexdump(MSG_INFO, "WPA: WPA IE in 3/4 msg",
 767                             wpa_ie, wpa_ie_len);
 768         }
 769
 770         if (sm->ap_rsn_ie) {
 771                 wpa_hexdump(MSG_INFO, "WPA: RSN IE in Beacon/ProbeResp",
 772                             sm->ap_rsn_ie, sm->ap_rsn_ie_len);
 773         }
 774         if (rsn_ie) {
 775                 if (!sm->ap_rsn_ie) {
 776                         wpa_printf(MSG_INFO, "WPA: No RSN IE in "
 777                                    "Beacon/ProbeResp");
 778                 }
 779                 wpa_hexdump(MSG_INFO, "WPA: RSN IE in 3/4 msg",
 780                             rsn_ie, rsn_ie_len);
 781         }
 782
 783         wpa_sm_disassociate(sm, WLAN_REASON_IE_IN_4WAY_DIFFERS);
 784 }
 785
 786
 787 static int wpa_supplicant_validate_ie(struct wpa_sm *sm,
 788                                       const unsigned char *src_addr,
 789                                       struct wpa_eapol_ie_parse *ie)
 790 {
 791         if (sm->ap_wpa_ie == NULL && sm->ap_rsn_ie == NULL) {
 792                 wpa_printf(MSG_DEBUG, "WPA: No WPA/RSN IE for this AP known. "
 793                            "Trying to get from scan results");
 794                 if (wpa_sm_get_beacon_ie(sm) < 0) {
 795                         wpa_printf(MSG_WARNING, "WPA: Could not find AP from "
 796                                    "the scan results");
 797                 } else {
 798                         wpa_printf(MSG_DEBUG, "WPA: Found the current AP from "
 799                                    "updated scan results");
 800                 }
 801         }
 802
 803         if (ie->wpa_ie == NULL && ie->rsn_ie == NULL &&
 804             (sm->ap_wpa_ie || sm->ap_rsn_ie)) {
 805                 wpa_report_ie_mismatch(sm, "IE in 3/4 msg does not match "
 806                                        "with IE in Beacon/ProbeResp (no IE?)",
 807                                        src_addr, ie->wpa_ie, ie->wpa_ie_len,
 808                                        ie->rsn_ie, ie->rsn_ie_len);
 809                 return -1;
 810         }
 811
 812         if ((ie->wpa_ie && sm->ap_wpa_ie &&
 813              (ie->wpa_ie_len != sm->ap_wpa_ie_len ||
 814               os_memcmp(ie->wpa_ie, sm->ap_wpa_ie, ie->wpa_ie_len) != 0)) ||
 815             (ie->rsn_ie && sm->ap_rsn_ie &&
 816              (ie->rsn_ie_len != sm->ap_rsn_ie_len ||
 817               os_memcmp(ie->rsn_ie, sm->ap_rsn_ie, ie->rsn_ie_len) != 0))) {
 818                 wpa_report_ie_mismatch(sm, "IE in 3/4 msg does not match "
 819                                        "with IE in Beacon/ProbeResp",
 820                                        src_addr, ie->wpa_ie, ie->wpa_ie_len,
 821                                        ie->rsn_ie, ie->rsn_ie_len);
 822                 return -1;
 823         }
 824
 825         if (sm->proto == WPA_PROTO_WPA &&
 826             ie->rsn_ie && sm->ap_rsn_ie == NULL && sm->rsn_enabled) {
 827                 wpa_report_ie_mismatch(sm, "Possible downgrade attack "
 828                                        "detected - RSN was enabled and RSN IE "
 829                                        "was in msg 3/4, but not in "
 830                                        "Beacon/ProbeResp",
 831                                        src_addr, ie->wpa_ie, ie->wpa_ie_len,
 832                                        ie->rsn_ie, ie->rsn_ie_len);
 833                 return -1;
 834         }
 835
 836 #ifdef CONFIG_IEEE80211R
 837         if (sm->key_mgmt == WPA_KEY_MGMT_FT_IEEE8021X ||
 838             sm->key_mgmt == WPA_KEY_MGMT_FT_PSK) {
 839                 struct rsn_mdie *mdie;
 840                 /* TODO: verify that full MDIE matches with the one from scan
 841                  * results, not only mobility domain */
 842                 mdie = (struct rsn_mdie *) (ie->mdie + 2);
 843                 if (ie->mdie == NULL || ie->mdie_len < 2 + sizeof(*mdie) ||
 844                     os_memcmp(mdie->mobility_domain, sm->mobility_domain,
 845                               MOBILITY_DOMAIN_ID_LEN) != 0) {
 846                         wpa_printf(MSG_DEBUG, "FT: MDIE in msg 3/4 did not "
 847                                    "match with the current mobility domain");
 848                         return -1;
 849                 }
 850         }
 851 #endif /* CONFIG_IEEE80211R */
 852
 853         return 0;
 854 }
 855
 856
 857 /**
 858  * wpa_supplicant_send_4_of_4 - Send message 4 of WPA/RSN 4-Way Handshake
 859  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 860  * @dst: Destination address for the frame
 861  * @key: Pointer to the EAPOL-Key frame header
 862  * @ver: Version bits from EAPOL-Key Key Info
 863  * @key_info: Key Info
 864  * @kde: KDEs to include the EAPOL-Key frame
 865  * @kde_len: Length of KDEs
 866  * @ptk: PTK to use for keyed hash and encryption
 867  * Returns: 0 on success, -1 on failure
 868  */
 869 int wpa_supplicant_send_4_of_4(struct wpa_sm *sm, const unsigned char *dst,
 870                                const struct wpa_eapol_key *key,
 871                                u16 ver, u16 key_info,
 872                                const u8 *kde, size_t kde_len,
 873                                struct wpa_ptk *ptk)
 874 {
 875         size_t rlen;
 876         struct wpa_eapol_key *reply;
 877         u8 *rbuf;
 878
 879         if (kde)
 880                 wpa_hexdump(MSG_DEBUG, "WPA: KDE for msg 4/4", kde, kde_len);
 881
 882         rbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY, NULL,
 883                                   sizeof(*reply) + kde_len,
 884                                   &rlen, (void *) &reply);
 885         if (rbuf == NULL)
 886                 return -1;
 887
 888         reply->type = sm->proto == WPA_PROTO_RSN ?
 889                 EAPOL_KEY_TYPE_RSN : EAPOL_KEY_TYPE_WPA;
 890         key_info &= WPA_KEY_INFO_SECURE;
 891         key_info |= ver | WPA_KEY_INFO_KEY_TYPE | WPA_KEY_INFO_MIC;
 892         WPA_PUT_BE16(reply->key_info, key_info);
 893         if (sm->proto == WPA_PROTO_RSN)
 894                 WPA_PUT_BE16(reply->key_length, 0);
 895         else
 896                 os_memcpy(reply->key_length, key->key_length, 2);
 897         os_memcpy(reply->replay_counter, key->replay_counter,
 898                   WPA_REPLAY_COUNTER_LEN);
 899
 900         WPA_PUT_BE16(reply->key_data_length, kde_len);
 901         if (kde)
 902                 os_memcpy(reply + 1, kde, kde_len);
 903
 904         wpa_printf(MSG_DEBUG, "WPA: Sending EAPOL-Key 4/4");
 905         wpa_eapol_key_send(sm, ptk->kck, ver, dst, ETH_P_EAPOL,
 906                            rbuf, rlen, reply->key_mic);
 907
 908         return 0;
 909 }
 910
 911
 912 static void wpa_supplicant_process_3_of_4(struct wpa_sm *sm,
 913                                           const struct wpa_eapol_key *key,
 914                                           u16 ver)
 915 {
 916         u16 key_info, keylen, len;
 917         const u8 *pos;
 918         struct wpa_eapol_ie_parse ie;
 919
 920         wpa_sm_set_state(sm, WPA_4WAY_HANDSHAKE);
 921         wpa_printf(MSG_DEBUG, "WPA: RX message 3 of 4-Way Handshake from "
 922                    MACSTR " (ver=%d)", MAC2STR(sm->bssid), ver);
 923
 924         key_info = WPA_GET_BE16(key->key_info);
 925
 926         pos = (const u8 *) (key + 1);
 927         len = WPA_GET_BE16(key->key_data_length);
 928         wpa_hexdump(MSG_DEBUG, "WPA: IE KeyData", pos, len);
 929         wpa_supplicant_parse_ies(pos, len, &ie);
 930         if (ie.gtk && !(key_info & WPA_KEY_INFO_ENCR_KEY_DATA)) {
 931                 wpa_printf(MSG_WARNING, "WPA: GTK IE in unencrypted key data");
 932                 return;
 933         }
 934 #ifdef CONFIG_IEEE80211W
 935         if (ie.igtk && !(key_info & WPA_KEY_INFO_ENCR_KEY_DATA)) {
 936                 wpa_printf(MSG_WARNING, "WPA: IGTK KDE in unencrypted key "
 937                            "data");
 938                 return;
 939         }
 940
 941         if (ie.igtk && ie.igtk_len != sizeof(struct wpa_igtk_kde)) {
 942                 wpa_printf(MSG_WARNING, "WPA: Invalid IGTK KDE length %lu",
 943                            (unsigned long) ie.igtk_len);
 944                 return;
 945         }
 946 #endif /* CONFIG_IEEE80211W */
 947
 948         if (wpa_supplicant_validate_ie(sm, sm->bssid, &ie) < 0)
 949                 return;
 950
 951         if (os_memcmp(sm->anonce, key->key_nonce, WPA_NONCE_LEN) != 0) {
 952                 wpa_printf(MSG_WARNING, "WPA: ANonce from message 1 of 4-Way "
 953                            "Handshake differs from 3 of 4-Way Handshake - drop"
 954                            " packet (src=" MACSTR ")", MAC2STR(sm->bssid));
 955                 return;
 956         }
 957
 958         keylen = WPA_GET_BE16(key->key_length);
 959         switch (sm->pairwise_cipher) {
 960         case WPA_CIPHER_CCMP:
 961                 if (keylen != 16) {
 962                         wpa_printf(MSG_WARNING, "WPA: Invalid CCMP key length "
 963                                    "%d (src=" MACSTR ")",
 964                                    keylen, MAC2STR(sm->bssid));
 965                         return;
 966                 }
 967                 break;
 968         case WPA_CIPHER_TKIP:
 969                 if (keylen != 32) {
 970                         wpa_printf(MSG_WARNING, "WPA: Invalid TKIP key length "
 971                                    "%d (src=" MACSTR ")",
 972                                    keylen, MAC2STR(sm->bssid));
 973                         return;
 974                 }
 975                 break;
 976         }
 977
 978         if (wpa_supplicant_send_4_of_4(sm, sm->bssid, key, ver, key_info,
 979                                        NULL, 0, &sm->ptk))
 980                 return;
 981
 982         /* SNonce was successfully used in msg 3/4, so mark it to be renewed
 983          * for the next 4-Way Handshake. If msg 3 is received again, the old
 984          * SNonce will still be used to avoid changing PTK. */
 985         sm->renew_snonce = 1;
 986
 987         if (key_info & WPA_KEY_INFO_INSTALL) {
 988                 wpa_supplicant_install_ptk(sm, key);
 989         }
 990
 991         if (key_info & WPA_KEY_INFO_SECURE) {
 992                 wpa_sm_mlme_setprotection(
 993                         sm, sm->bssid, MLME_SETPROTECTION_PROTECT_TYPE_RX,
 994                         MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
 995                 eapol_sm_notify_portValid(sm->eapol, TRUE);
 996         }
 997         wpa_sm_set_state(sm, WPA_GROUP_HANDSHAKE);
 998
 999         if (ie.gtk &&
1000             wpa_supplicant_pairwise_gtk(sm, key,
1001                                         ie.gtk, ie.gtk_len, key_info) < 0) {
1002                 wpa_printf(MSG_INFO, "RSN: Failed to configure GTK");
1003         }
1004
1005         if (ieee80211w_set_keys(sm, &ie) < 0)
1006                 wpa_printf(MSG_INFO, "RSN: Failed to configure IGTK");
1007 }
1008
1009
1010 static int wpa_supplicant_process_1_of_2_rsn(struct wpa_sm *sm,
1011                                              const u8 *keydata,
1012                                              size_t keydatalen,
1013                                              u16 key_info,
1014                                              struct wpa_gtk_data *gd)
1015 {
1016         int maxkeylen;
1017         struct wpa_eapol_ie_parse ie;
1018
1019         wpa_hexdump(MSG_DEBUG, "RSN: msg 1/2 key data", keydata, keydatalen);
1020         wpa_supplicant_parse_ies(keydata, keydatalen, &ie);
1021         if (ie.gtk && !(key_info & WPA_KEY_INFO_ENCR_KEY_DATA)) {
1022                 wpa_printf(MSG_WARNING, "WPA: GTK IE in unencrypted key data");
1023                 return -1;
1024         }
1025         if (ie.gtk == NULL) {
1026                 wpa_printf(MSG_INFO, "WPA: No GTK IE in Group Key msg 1/2");
1027                 return -1;
1028         }
1029         maxkeylen = gd->gtk_len = ie.gtk_len - 2;
1030
1031         if (wpa_supplicant_check_group_cipher(sm->group_cipher,
1032                                               gd->gtk_len, maxkeylen,
1033                                               &gd->key_rsc_len, &gd->alg))
1034                 return -1;
1035
1036         wpa_hexdump(MSG_DEBUG, "RSN: received GTK in group key handshake",
1037                     ie.gtk, ie.gtk_len);
1038         gd->keyidx = ie.gtk[0] & 0x3;
1039         gd->tx = wpa_supplicant_gtk_tx_bit_workaround(sm,
1040                                                       !!(ie.gtk[0] & BIT(2)));
1041         if (ie.gtk_len - 2 > sizeof(gd->gtk)) {
1042                 wpa_printf(MSG_INFO, "RSN: Too long GTK in GTK IE "
1043                            "(len=%lu)", (unsigned long) ie.gtk_len - 2);
1044                 return -1;
1045         }
1046         os_memcpy(gd->gtk, ie.gtk + 2, ie.gtk_len - 2);
1047
1048         if (ieee80211w_set_keys(sm, &ie) < 0)
1049                 wpa_printf(MSG_INFO, "RSN: Failed to configure IGTK");
1050
1051         return 0;
1052 }
1053
1054
1055 static int wpa_supplicant_process_1_of_2_wpa(struct wpa_sm *sm,
1056                                              const struct wpa_eapol_key *key,
1057                                              size_t keydatalen, int key_info,
1058                                              size_t extra_len, u16 ver,
1059                                              struct wpa_gtk_data *gd)
1060 {
1061         size_t maxkeylen;
1062         u8 ek[32];
1063
1064         gd->gtk_len = WPA_GET_BE16(key->key_length);
1065         maxkeylen = keydatalen;
1066         if (keydatalen > extra_len) {
1067                 wpa_printf(MSG_INFO, "WPA: Truncated EAPOL-Key packet:"
1068                            " key_data_length=%lu > extra_len=%lu",
1069                            (unsigned long) keydatalen,
1070                            (unsigned long) extra_len);
1071                 return -1;
1072         }
1073         if (ver == WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
1074                 if (maxkeylen < 8) {
1075                         wpa_printf(MSG_INFO, "WPA: Too short maxkeylen (%lu)",
1076                                    (unsigned long) maxkeylen);
1077                         return -1;
1078                 }
1079                 maxkeylen -= 8;
1080         }
1081
1082         if (wpa_supplicant_check_group_cipher(sm->group_cipher,
1083                                               gd->gtk_len, maxkeylen,
1084                                               &gd->key_rsc_len, &gd->alg))
1085                 return -1;
1086
1087         gd->keyidx = (key_info & WPA_KEY_INFO_KEY_INDEX_MASK) >>
1088                 WPA_KEY_INFO_KEY_INDEX_SHIFT;
1089         if (ver == WPA_KEY_INFO_TYPE_HMAC_MD5_RC4) {
1090                 os_memcpy(ek, key->key_iv, 16);
1091                 os_memcpy(ek + 16, sm->ptk.kek, 16);
1092                 if (keydatalen > sizeof(gd->gtk)) {
1093                         wpa_printf(MSG_WARNING, "WPA: RC4 key data "
1094                                    "too long (%lu)",
1095                                    (unsigned long) keydatalen);
1096                         return -1;
1097                 }
1098                 os_memcpy(gd->gtk, key + 1, keydatalen);
1099                 rc4_skip(ek, 32, 256, gd->gtk, keydatalen);
1100         } else if (ver == WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
1101                 if (keydatalen % 8) {
1102                         wpa_printf(MSG_WARNING, "WPA: Unsupported AES-WRAP "
1103                                    "len %lu", (unsigned long) keydatalen);
1104                         return -1;
1105                 }
1106                 if (maxkeylen > sizeof(gd->gtk)) {
1107                         wpa_printf(MSG_WARNING, "WPA: AES-WRAP key data "
1108                                    "too long (keydatalen=%lu maxkeylen=%lu)",
1109                                    (unsigned long) keydatalen,
1110                                    (unsigned long) maxkeylen);
1111                         return -1;
1112                 }
1113                 if (aes_unwrap(sm->ptk.kek, maxkeylen / 8,
1114                                (const u8 *) (key + 1), gd->gtk)) {
1115                         wpa_printf(MSG_WARNING, "WPA: AES unwrap "
1116                                    "failed - could not decrypt GTK");
1117                         return -1;
1118                 }
1119         } else {
1120                 wpa_printf(MSG_WARNING, "WPA: Unsupported key_info type %d",
1121                            ver);
1122                 return -1;
1123         }
1124         gd->tx = wpa_supplicant_gtk_tx_bit_workaround(
1125                 sm, !!(key_info & WPA_KEY_INFO_TXRX));
1126         return 0;
1127 }
1128
1129
1130 static int wpa_supplicant_send_2_of_2(struct wpa_sm *sm,
1131                                       const struct wpa_eapol_key *key,
1132                                       int ver, u16 key_info)
1133 {
1134         size_t rlen;
1135         struct wpa_eapol_key *reply;
1136         u8 *rbuf;
1137
1138         rbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY, NULL,
1139                                   sizeof(*reply), &rlen, (void *) &reply);
1140         if (rbuf == NULL)
1141                 return -1;
1142
1143         reply->type = sm->proto == WPA_PROTO_RSN ?
1144                 EAPOL_KEY_TYPE_RSN : EAPOL_KEY_TYPE_WPA;
1145         key_info &= WPA_KEY_INFO_KEY_INDEX_MASK;
1146         key_info |= ver | WPA_KEY_INFO_MIC | WPA_KEY_INFO_SECURE;
1147         WPA_PUT_BE16(reply->key_info, key_info);
1148         if (sm->proto == WPA_PROTO_RSN)
1149                 WPA_PUT_BE16(reply->key_length, 0);
1150         else
1151                 os_memcpy(reply->key_length, key->key_length, 2);
1152         os_memcpy(reply->replay_counter, key->replay_counter,
1153                   WPA_REPLAY_COUNTER_LEN);
1154
1155         WPA_PUT_BE16(reply->key_data_length, 0);
1156
1157         wpa_printf(MSG_DEBUG, "WPA: Sending EAPOL-Key 2/2");
1158         wpa_eapol_key_send(sm, sm->ptk.kck, ver, sm->bssid, ETH_P_EAPOL,
1159                            rbuf, rlen, reply->key_mic);
1160
1161         return 0;
1162 }
1163
1164
1165 static void wpa_supplicant_process_1_of_2(struct wpa_sm *sm,
1166                                           const unsigned char *src_addr,
1167                                           const struct wpa_eapol_key *key,
1168                                           int extra_len, u16 ver)
1169 {
1170         u16 key_info, keydatalen;
1171         int rekey, ret;
1172         struct wpa_gtk_data gd;
1173
1174         os_memset(&gd, 0, sizeof(gd));
1175
1176         rekey = wpa_sm_get_state(sm) == WPA_COMPLETED;
1177         wpa_printf(MSG_DEBUG, "WPA: RX message 1 of Group Key Handshake from "
1178                    MACSTR " (ver=%d)", MAC2STR(src_addr), ver);
1179
1180         key_info = WPA_GET_BE16(key->key_info);
1181         keydatalen = WPA_GET_BE16(key->key_data_length);
1182
1183         if (sm->proto == WPA_PROTO_RSN) {
1184                 ret = wpa_supplicant_process_1_of_2_rsn(sm,
1185                                                         (const u8 *) (key + 1),
1186                                                         keydatalen, key_info,
1187                                                         &gd);
1188         } else {
1189                 ret = wpa_supplicant_process_1_of_2_wpa(sm, key, keydatalen,
1190                                                         key_info, extra_len,
1191                                                         ver, &gd);
1192         }
1193
1194         wpa_sm_set_state(sm, WPA_GROUP_HANDSHAKE);
1195
1196         if (ret)
1197                 return;
1198
1199         if (wpa_supplicant_install_gtk(sm, &gd, key->key_rsc) ||
1200             wpa_supplicant_send_2_of_2(sm, key, ver, key_info))
1201                 return;
1202
1203         if (rekey) {
1204                 wpa_msg(sm->ctx->ctx, MSG_INFO, "WPA: Group rekeying "
1205                         "completed with " MACSTR " [GTK=%s]",
1206                         MAC2STR(sm->bssid), wpa_cipher_txt(sm->group_cipher));
1207                 wpa_sm_cancel_auth_timeout(sm);
1208                 wpa_sm_set_state(sm, WPA_COMPLETED);
1209         } else {
1210                 wpa_supplicant_key_neg_complete(sm, sm->bssid,
1211                                                 key_info &
1212                                                 WPA_KEY_INFO_SECURE);
1213         }
1214 }
1215
1216
1217 static int wpa_supplicant_verify_eapol_key_mic(struct wpa_sm *sm,
1218                                                struct wpa_eapol_key *key,
1219                                                u16 ver,
1220                                                const u8 *buf, size_t len)
1221 {
1222         u8 mic[16];
1223         int ok = 0;
1224
1225         os_memcpy(mic, key->key_mic, 16);
1226         if (sm->tptk_set) {
1227                 os_memset(key->key_mic, 0, 16);
1228                 wpa_eapol_key_mic(sm->tptk.kck, ver, buf, len,
1229                                   key->key_mic);
1230                 if (os_memcmp(mic, key->key_mic, 16) != 0) {
1231                         wpa_printf(MSG_WARNING, "WPA: Invalid EAPOL-Key MIC "
1232                                    "when using TPTK - ignoring TPTK");
1233                 } else {
1234                         ok = 1;
1235                         sm->tptk_set = 0;
1236                         sm->ptk_set = 1;
1237                         os_memcpy(&sm->ptk, &sm->tptk, sizeof(sm->ptk));
1238                 }
1239         }
1240
1241         if (!ok && sm->ptk_set) {
1242                 os_memset(key->key_mic, 0, 16);
1243                 wpa_eapol_key_mic(sm->ptk.kck, ver, buf, len,
1244                                   key->key_mic);
1245                 if (os_memcmp(mic, key->key_mic, 16) != 0) {
1246                         wpa_printf(MSG_WARNING, "WPA: Invalid EAPOL-Key MIC "
1247                                    "- dropping packet");
1248                         return -1;
1249                 }
1250                 ok = 1;
1251         }
1252
1253         if (!ok) {
1254                 wpa_printf(MSG_WARNING, "WPA: Could not verify EAPOL-Key MIC "
1255                            "- dropping packet");
1256                 return -1;
1257         }
1258
1259         os_memcpy(sm->rx_replay_counter, key->replay_counter,
1260                   WPA_REPLAY_COUNTER_LEN);
1261         sm->rx_replay_counter_set = 1;
1262         return 0;
1263 }
1264
1265
1266 /* Decrypt RSN EAPOL-Key key data (RC4 or AES-WRAP) */
1267 static int wpa_supplicant_decrypt_key_data(struct wpa_sm *sm,
1268                                            struct wpa_eapol_key *key, u16 ver)
1269 {
1270         u16 keydatalen = WPA_GET_BE16(key->key_data_length);
1271
1272         wpa_hexdump(MSG_DEBUG, "RSN: encrypted key data",
1273                     (u8 *) (key + 1), keydatalen);
1274         if (!sm->ptk_set) {
1275                 wpa_printf(MSG_WARNING, "WPA: PTK not available, "
1276                            "cannot decrypt EAPOL-Key key data.");
1277                 return -1;
1278         }
1279
1280         /* Decrypt key data here so that this operation does not need
1281          * to be implemented separately for each message type. */
1282         if (ver == WPA_KEY_INFO_TYPE_HMAC_MD5_RC4) {
1283                 u8 ek[32];
1284                 os_memcpy(ek, key->key_iv, 16);
1285                 os_memcpy(ek + 16, sm->ptk.kek, 16);
1286                 rc4_skip(ek, 32, 256, (u8 *) (key + 1), keydatalen);
1287         } else if (ver == WPA_KEY_INFO_TYPE_HMAC_SHA1_AES ||
1288                    ver == WPA_KEY_INFO_TYPE_AES_128_CMAC) {
1289                 u8 *buf;
1290                 if (keydatalen % 8) {
1291                         wpa_printf(MSG_WARNING, "WPA: Unsupported "
1292                                    "AES-WRAP len %d", keydatalen);
1293                         return -1;
1294                 }
1295                 keydatalen -= 8; /* AES-WRAP adds 8 bytes */
1296                 buf = os_malloc(keydatalen);
1297                 if (buf == NULL) {
1298                         wpa_printf(MSG_WARNING, "WPA: No memory for "
1299                                    "AES-UNWRAP buffer");
1300                         return -1;
1301                 }
1302                 if (aes_unwrap(sm->ptk.kek, keydatalen / 8,
1303                                (u8 *) (key + 1), buf)) {
1304                         os_free(buf);
1305                         wpa_printf(MSG_WARNING, "WPA: AES unwrap failed - "
1306                                    "could not decrypt EAPOL-Key key data");
1307                         return -1;
1308                 }
1309                 os_memcpy(key + 1, buf, keydatalen);
1310                 os_free(buf);
1311                 WPA_PUT_BE16(key->key_data_length, keydatalen);
1312         } else {
1313                 wpa_printf(MSG_WARNING, "WPA: Unsupported key_info type %d",
1314                            ver);
1315                 return -1;
1316         }
1317         wpa_hexdump_key(MSG_DEBUG, "WPA: decrypted EAPOL-Key key data",
1318                         (u8 *) (key + 1), keydatalen);
1319         return 0;
1320 }
1321
1322
1323 /**
1324  * wpa_sm_aborted_cached - Notify WPA that PMKSA caching was aborted
1325  * @sm: Pointer to WPA state machine data from wpa_sm_init()
1326  */
1327 void wpa_sm_aborted_cached(struct wpa_sm *sm)
1328 {
1329         if (sm && sm->cur_pmksa) {
1330                 wpa_printf(MSG_DEBUG, "RSN: Cancelling PMKSA caching attempt");
1331                 sm->cur_pmksa = NULL;
1332         }
1333 }
1334
1335
1336 static void wpa_eapol_key_dump(const struct wpa_eapol_key *key)
1337 {
1338 #ifndef CONFIG_NO_STDOUT_DEBUG
1339         u16 key_info = WPA_GET_BE16(key->key_info);
1340
1341         wpa_printf(MSG_DEBUG, "  EAPOL-Key type=%d", key->type);
1342         wpa_printf(MSG_DEBUG, "  key_info 0x%x (ver=%d keyidx=%d rsvd=%d %s"
1343                    "%s%s%s%s%s%s%s)",
1344                    key_info, key_info & WPA_KEY_INFO_TYPE_MASK,
1345                    (key_info & WPA_KEY_INFO_KEY_INDEX_MASK) >>
1346                    WPA_KEY_INFO_KEY_INDEX_SHIFT,
1347                    (key_info & (BIT(13) | BIT(14) | BIT(15))) >> 13,
1348                    key_info & WPA_KEY_INFO_KEY_TYPE ? "Pairwise" : "Group",
1349                    key_info & WPA_KEY_INFO_INSTALL ? " Install" : "",
1350                    key_info & WPA_KEY_INFO_ACK ? " Ack" : "",
1351                    key_info & WPA_KEY_INFO_MIC ? " MIC" : "",
1352                    key_info & WPA_KEY_INFO_SECURE ? " Secure" : "",
1353                    key_info & WPA_KEY_INFO_ERROR ? " Error" : "",
1354                    key_info & WPA_KEY_INFO_REQUEST ? " Request" : "",
1355                    key_info & WPA_KEY_INFO_ENCR_KEY_DATA ? " Encr" : "");
1356         wpa_printf(MSG_DEBUG, "  key_length=%u key_data_length=%u",
1357                    WPA_GET_BE16(key->key_length),
1358                    WPA_GET_BE16(key->key_data_length));
1359         wpa_hexdump(MSG_DEBUG, "  replay_counter",
1360                     key->replay_counter, WPA_REPLAY_COUNTER_LEN);
1361         wpa_hexdump(MSG_DEBUG, "  key_nonce", key->key_nonce, WPA_NONCE_LEN);
1362         wpa_hexdump(MSG_DEBUG, "  key_iv", key->key_iv, 16);
1363         wpa_hexdump(MSG_DEBUG, "  key_rsc", key->key_rsc, 8);
1364         wpa_hexdump(MSG_DEBUG, "  key_id (reserved)", key->key_id, 8);
1365         wpa_hexdump(MSG_DEBUG, "  key_mic", key->key_mic, 16);
1366 #endif /* CONFIG_NO_STDOUT_DEBUG */
1367 }
1368
1369
1370 /**
1371  * wpa_sm_rx_eapol - Process received WPA EAPOL frames
1372  * @sm: Pointer to WPA state machine data from wpa_sm_init()
1373  * @src_addr: Source MAC address of the EAPOL packet
1374  * @buf: Pointer to the beginning of the EAPOL data (EAPOL header)
1375  * @len: Length of the EAPOL frame
1376  * Returns: 1 = WPA EAPOL-Key processed, 0 = not a WPA EAPOL-Key, -1 failure
1377  *
1378  * This function is called for each received EAPOL frame. Other than EAPOL-Key
1379  * frames can be skipped if filtering is done elsewhere. wpa_sm_rx_eapol() is
1380  * only processing WPA and WPA2 EAPOL-Key frames.
1381  *
1382  * The received EAPOL-Key packets are validated and valid packets are replied
1383  * to. In addition, key material (PTK, GTK) is configured at the end of a
1384  * successful key handshake.
1385  */
1386 int wpa_sm_rx_eapol(struct wpa_sm *sm, const u8 *src_addr,
1387                     const u8 *buf, size_t len)
1388 {
1389         size_t plen, data_len, extra_len;
1390         struct ieee802_1x_hdr *hdr;
1391         struct wpa_eapol_key *key;
1392         u16 key_info, ver;
1393         u8 *tmp;
1394         int ret = -1;
1395         struct wpa_peerkey *peerkey = NULL;
1396
1397 #ifdef CONFIG_IEEE80211R
1398         sm->ft_completed = 0;
1399 #endif /* CONFIG_IEEE80211R */
1400
1401         if (len < sizeof(*hdr) + sizeof(*key)) {
1402                 wpa_printf(MSG_DEBUG, "WPA: EAPOL frame too short to be a WPA "
1403                            "EAPOL-Key (len %lu, expecting at least %lu)",
1404                            (unsigned long) len,
1405                            (unsigned long) sizeof(*hdr) + sizeof(*key));
1406                 return 0;
1407         }
1408
1409         tmp = os_malloc(len);
1410         if (tmp == NULL)
1411                 return -1;
1412         os_memcpy(tmp, buf, len);
1413
1414         hdr = (struct ieee802_1x_hdr *) tmp;
1415         key = (struct wpa_eapol_key *) (hdr + 1);
1416         plen = be_to_host16(hdr->length);
1417         data_len = plen + sizeof(*hdr);
1418         wpa_printf(MSG_DEBUG, "IEEE 802.1X RX: version=%d type=%d length=%lu",
1419                    hdr->version, hdr->type, (unsigned long) plen);
1420
1421         if (hdr->version < EAPOL_VERSION) {
1422                 /* TODO: backwards compatibility */
1423         }
1424         if (hdr->type != IEEE802_1X_TYPE_EAPOL_KEY) {
1425                 wpa_printf(MSG_DEBUG, "WPA: EAPOL frame (type %u) discarded, "
1426                         "not a Key frame", hdr->type);
1427                 ret = 0;
1428                 goto out;
1429         }
1430         if (plen > len - sizeof(*hdr) || plen < sizeof(*key)) {
1431                 wpa_printf(MSG_DEBUG, "WPA: EAPOL frame payload size %lu "
1432                            "invalid (frame size %lu)",
1433                            (unsigned long) plen, (unsigned long) len);
1434                 ret = 0;
1435                 goto out;
1436         }
1437
1438         if (key->type != EAPOL_KEY_TYPE_WPA && key->type != EAPOL_KEY_TYPE_RSN)
1439         {
1440                 wpa_printf(MSG_DEBUG, "WPA: EAPOL-Key type (%d) unknown, "
1441                            "discarded", key->type);
1442                 ret = 0;
1443                 goto out;
1444         }
1445         wpa_eapol_key_dump(key);
1446
1447         eapol_sm_notify_lower_layer_success(sm->eapol, 0);
1448         wpa_hexdump(MSG_MSGDUMP, "WPA: RX EAPOL-Key", tmp, len);
1449         if (data_len < len) {
1450                 wpa_printf(MSG_DEBUG, "WPA: ignoring %lu bytes after the IEEE "
1451                            "802.1X data", (unsigned long) len - data_len);
1452         }
1453         key_info = WPA_GET_BE16(key->key_info);
1454         ver = key_info & WPA_KEY_INFO_TYPE_MASK;
1455         if (ver != WPA_KEY_INFO_TYPE_HMAC_MD5_RC4 &&
1456 #ifdef CONFIG_IEEE80211R
1457             ver != WPA_KEY_INFO_TYPE_AES_128_CMAC &&
1458 #endif /* CONFIG_IEEE80211R */
1459             ver != WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
1460                 wpa_printf(MSG_INFO, "WPA: Unsupported EAPOL-Key descriptor "
1461                            "version %d.", ver);
1462                 goto out;
1463         }
1464
1465 #ifdef CONFIG_IEEE80211R
1466         if (sm->key_mgmt == WPA_KEY_MGMT_FT_IEEE8021X ||
1467             sm->key_mgmt == WPA_KEY_MGMT_FT_PSK) {
1468                 /* IEEE 802.11r uses a new key_info type (AES-128-CMAC). */
1469                 if (ver != WPA_KEY_INFO_TYPE_AES_128_CMAC) {
1470                         wpa_printf(MSG_INFO, "FT: AP did not use "
1471                                    "AES-128-CMAC.");
1472                         goto out;
1473                 }
1474         } else
1475 #endif /* CONFIG_IEEE80211R */
1476         if (sm->pairwise_cipher == WPA_CIPHER_CCMP &&
1477             ver != WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
1478                 wpa_printf(MSG_INFO, "WPA: CCMP is used, but EAPOL-Key "
1479                            "descriptor version (%d) is not 2.", ver);
1480                 if (sm->group_cipher != WPA_CIPHER_CCMP &&
1481                     !(key_info & WPA_KEY_INFO_KEY_TYPE)) {
1482                         /* Earlier versions of IEEE 802.11i did not explicitly
1483                          * require version 2 descriptor for all EAPOL-Key
1484                          * packets, so allow group keys to use version 1 if
1485                          * CCMP is not used for them. */
1486                         wpa_printf(MSG_INFO, "WPA: Backwards compatibility: "
1487                                    "allow invalid version for non-CCMP group "
1488                                    "keys");
1489                 } else
1490                         goto out;
1491         }
1492
1493 #ifdef CONFIG_PEERKEY
1494         for (peerkey = sm->peerkey; peerkey; peerkey = peerkey->next) {
1495                 if (os_memcmp(peerkey->addr, src_addr, ETH_ALEN) == 0)
1496                         break;
1497         }
1498
1499         if (!(key_info & WPA_KEY_INFO_SMK_MESSAGE) && peerkey) {
1500                 if (!peerkey->initiator && peerkey->replay_counter_set &&
1501                     os_memcmp(key->replay_counter, peerkey->replay_counter,
1502                               WPA_REPLAY_COUNTER_LEN) <= 0) {
1503                         wpa_printf(MSG_WARNING, "RSN: EAPOL-Key Replay "
1504                                    "Counter did not increase (STK) - dropping "
1505                                    "packet");
1506                         goto out;
1507                 } else if (peerkey->initiator) {
1508                         u8 _tmp[WPA_REPLAY_COUNTER_LEN];
1509                         os_memcpy(_tmp, key->replay_counter,
1510                                   WPA_REPLAY_COUNTER_LEN);
1511                         inc_byte_array(_tmp, WPA_REPLAY_COUNTER_LEN);
1512                         if (os_memcmp(_tmp, peerkey->replay_counter,
1513                                       WPA_REPLAY_COUNTER_LEN) != 0) {
1514                                 wpa_printf(MSG_DEBUG, "RSN: EAPOL-Key Replay "
1515                                            "Counter did not match (STK) - "
1516                                            "dropping packet");
1517                                 goto out;
1518                         }
1519                 }
1520         }
1521
1522         if (peerkey && peerkey->initiator && (key_info & WPA_KEY_INFO_ACK)) {
1523                 wpa_printf(MSG_INFO, "RSN: Ack bit in key_info from STK peer");
1524                 goto out;
1525         }
1526 #endif /* CONFIG_PEERKEY */
1527
1528         if (!peerkey && sm->rx_replay_counter_set &&
1529             os_memcmp(key->replay_counter, sm->rx_replay_counter,
1530                       WPA_REPLAY_COUNTER_LEN) <= 0) {
1531                 wpa_printf(MSG_WARNING, "WPA: EAPOL-Key Replay Counter did not"
1532                            " increase - dropping packet");
1533                 goto out;
1534         }
1535
1536         if (!(key_info & (WPA_KEY_INFO_ACK | WPA_KEY_INFO_SMK_MESSAGE))
1537 #ifdef CONFIG_PEERKEY
1538             && (peerkey == NULL || !peerkey->initiator)
1539 #endif /* CONFIG_PEERKEY */
1540                 ) {
1541                 wpa_printf(MSG_INFO, "WPA: No Ack bit in key_info");
1542                 goto out;
1543         }
1544
1545         if (key_info & WPA_KEY_INFO_REQUEST) {
1546                 wpa_printf(MSG_INFO, "WPA: EAPOL-Key with Request bit - "
1547                            "dropped");
1548                 goto out;
1549         }
1550
1551         if ((key_info & WPA_KEY_INFO_MIC) && !peerkey &&
1552             wpa_supplicant_verify_eapol_key_mic(sm, key, ver, tmp, data_len))
1553                 goto out;
1554
1555 #ifdef CONFIG_PEERKEY
1556         if ((key_info & WPA_KEY_INFO_MIC) && peerkey &&
1557             peerkey_verify_eapol_key_mic(sm, peerkey, key, ver, tmp, data_len))
1558                 goto out;
1559 #endif /* CONFIG_PEERKEY */
1560
1561         extra_len = data_len - sizeof(*hdr) - sizeof(*key);
1562
1563         if (WPA_GET_BE16(key->key_data_length) > extra_len) {
1564                 wpa_msg(sm->ctx->ctx, MSG_INFO, "WPA: Invalid EAPOL-Key "
1565                         "frame - key_data overflow (%d > %lu)",
1566                         WPA_GET_BE16(key->key_data_length),
1567                         (unsigned long) extra_len);
1568                 goto out;
1569         }
1570         extra_len = WPA_GET_BE16(key->key_data_length);
1571
1572         if (sm->proto == WPA_PROTO_RSN &&
1573             (key_info & WPA_KEY_INFO_ENCR_KEY_DATA)) {
1574                 if (wpa_supplicant_decrypt_key_data(sm, key, ver))
1575                         goto out;
1576                 extra_len = WPA_GET_BE16(key->key_data_length);
1577         }
1578
1579         if (key_info & WPA_KEY_INFO_KEY_TYPE) {
1580                 if (key_info & WPA_KEY_INFO_KEY_INDEX_MASK) {
1581                         wpa_printf(MSG_WARNING, "WPA: Ignored EAPOL-Key "
1582                                    "(Pairwise) with non-zero key index");
1583                         goto out;
1584                 }
1585                 if (peerkey) {
1586                         /* PeerKey 4-Way Handshake */
1587                         peerkey_rx_eapol_4way(sm, peerkey, key, key_info, ver);
1588                 } else if (key_info & WPA_KEY_INFO_MIC) {
1589                         /* 3/4 4-Way Handshake */
1590                         wpa_supplicant_process_3_of_4(sm, key, ver);
1591                 } else {
1592                         /* 1/4 4-Way Handshake */
1593                         wpa_supplicant_process_1_of_4(sm, src_addr, key,
1594                                                       ver);
1595                 }
1596         } else if (key_info & WPA_KEY_INFO_SMK_MESSAGE) {
1597                 /* PeerKey SMK Handshake */
1598                 peerkey_rx_eapol_smk(sm, src_addr, key, extra_len, key_info,
1599                                      ver);
1600         } else {
1601                 if (key_info & WPA_KEY_INFO_MIC) {
1602                         /* 1/2 Group Key Handshake */
1603                         wpa_supplicant_process_1_of_2(sm, src_addr, key,
1604                                                       extra_len, ver);
1605                 } else {
1606                         wpa_printf(MSG_WARNING, "WPA: EAPOL-Key (Group) "
1607                                    "without Mic bit - dropped");
1608                 }
1609         }
1610
1611         ret = 1;
1612
1613 out:
1614         os_free(tmp);
1615         return ret;
1616 }
1617
1618
1619 #ifdef CONFIG_CTRL_IFACE
1620 static int wpa_cipher_bits(int cipher)
1621 {
1622         switch (cipher) {
1623         case WPA_CIPHER_CCMP:
1624                 return 128;
1625         case WPA_CIPHER_TKIP:
1626                 return 256;
1627         case WPA_CIPHER_WEP104:
1628                 return 104;
1629         case WPA_CIPHER_WEP40:
1630                 return 40;
1631         default:
1632                 return 0;
1633         }
1634 }
1635
1636
1637 static u32 wpa_key_mgmt_suite(struct wpa_sm *sm)
1638 {
1639         switch (sm->key_mgmt) {
1640         case WPA_KEY_MGMT_IEEE8021X:
1641                 return (sm->proto == WPA_PROTO_RSN ?
1642                         RSN_AUTH_KEY_MGMT_UNSPEC_802_1X :
1643                         WPA_AUTH_KEY_MGMT_UNSPEC_802_1X);
1644         case WPA_KEY_MGMT_PSK:
1645                 return (sm->proto == WPA_PROTO_RSN ?
1646                         RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X :
1647                         WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X);
1648 #ifdef CONFIG_IEEE80211R
1649         case WPA_KEY_MGMT_FT_IEEE8021X:
1650                 return RSN_AUTH_KEY_MGMT_FT_802_1X;
1651         case WPA_KEY_MGMT_FT_PSK:
1652                 return RSN_AUTH_KEY_MGMT_FT_PSK;
1653 #endif /* CONFIG_IEEE80211R */
1654         case WPA_KEY_MGMT_WPA_NONE:
1655                 return WPA_AUTH_KEY_MGMT_NONE;
1656         default:
1657                 return 0;
1658         }
1659 }
1660
1661
1662 static u32 wpa_cipher_suite(struct wpa_sm *sm, int cipher)
1663 {
1664         switch (cipher) {
1665         case WPA_CIPHER_CCMP:
1666                 return (sm->proto == WPA_PROTO_RSN ?
1667                         RSN_CIPHER_SUITE_CCMP : WPA_CIPHER_SUITE_CCMP);
1668         case WPA_CIPHER_TKIP:
1669                 return (sm->proto == WPA_PROTO_RSN ?
1670                         RSN_CIPHER_SUITE_TKIP : WPA_CIPHER_SUITE_TKIP);
1671         case WPA_CIPHER_WEP104:
1672                 return (sm->proto == WPA_PROTO_RSN ?
1673                         RSN_CIPHER_SUITE_WEP104 : WPA_CIPHER_SUITE_WEP104);
1674         case WPA_CIPHER_WEP40:
1675                 return (sm->proto == WPA_PROTO_RSN ?
1676                         RSN_CIPHER_SUITE_WEP40 : WPA_CIPHER_SUITE_WEP40);
1677         case WPA_CIPHER_NONE:
1678                 return (sm->proto == WPA_PROTO_RSN ?
1679                         RSN_CIPHER_SUITE_NONE : WPA_CIPHER_SUITE_NONE);
1680         default:
1681                 return 0;
1682         }
1683 }
1684
1685
1686 #define RSN_SUITE "%02x-%02x-%02x-%d"
1687 #define RSN_SUITE_ARG(s) \
1688 ((s) >> 24) & 0xff, ((s) >> 16) & 0xff, ((s) >> 8) & 0xff, (s) & 0xff
1689
1690 /**
1691  * wpa_sm_get_mib - Dump text list of MIB entries
1692  * @sm: Pointer to WPA state machine data from wpa_sm_init()
1693  * @buf: Buffer for the list
1694  * @buflen: Length of the buffer
1695  * Returns: Number of bytes written to buffer
1696  *
1697  * This function is used fetch dot11 MIB variables.
1698  */
1699 int wpa_sm_get_mib(struct wpa_sm *sm, char *buf, size_t buflen)
1700 {
1701         char pmkid_txt[PMKID_LEN * 2 + 1];
1702         int rsna, ret;
1703         size_t len;
1704
1705         if (sm->cur_pmksa) {
1706                 wpa_snprintf_hex(pmkid_txt, sizeof(pmkid_txt),
1707                                  sm->cur_pmksa->pmkid, PMKID_LEN);
1708         } else
1709                 pmkid_txt[0] = '\0';
1710
1711         if ((sm->key_mgmt == WPA_KEY_MGMT_PSK ||
1712              sm->key_mgmt == WPA_KEY_MGMT_IEEE8021X ||
1713              sm->key_mgmt == WPA_KEY_MGMT_FT_PSK ||
1714              sm->key_mgmt == WPA_KEY_MGMT_FT_IEEE8021X) &&
1715             sm->proto == WPA_PROTO_RSN)
1716                 rsna = 1;
1717         else
1718                 rsna = 0;
1719
1720         ret = os_snprintf(buf, buflen,
1721                           "dot11RSNAOptionImplemented=TRUE\n"
1722                           "dot11RSNAPreauthenticationImplemented=TRUE\n"
1723                           "dot11RSNAEnabled=%s\n"
1724                           "dot11RSNAPreauthenticationEnabled=%s\n"
1725                           "dot11RSNAConfigVersion=%d\n"
1726                           "dot11RSNAConfigPairwiseKeysSupported=5\n"
1727                           "dot11RSNAConfigGroupCipherSize=%d\n"
1728                           "dot11RSNAConfigPMKLifetime=%d\n"
1729                           "dot11RSNAConfigPMKReauthThreshold=%d\n"
1730                           "dot11RSNAConfigNumberOfPTKSAReplayCounters=1\n"
1731                           "dot11RSNAConfigSATimeout=%d\n",
1732                           rsna ? "TRUE" : "FALSE",
1733                           rsna ? "TRUE" : "FALSE",
1734                           RSN_VERSION,
1735                           wpa_cipher_bits(sm->group_cipher),
1736                           sm->dot11RSNAConfigPMKLifetime,
1737                           sm->dot11RSNAConfigPMKReauthThreshold,
1738                           sm->dot11RSNAConfigSATimeout);
1739         if (ret < 0 || (size_t) ret >= buflen)
1740                 return 0;
1741         len = ret;
1742
1743         ret = os_snprintf(
1744                 buf + len, buflen - len,
1745                 "dot11RSNAAuthenticationSuiteSelected=" RSN_SUITE "\n"
1746                 "dot11RSNAPairwiseCipherSelected=" RSN_SUITE "\n"
1747                 "dot11RSNAGroupCipherSelected=" RSN_SUITE "\n"
1748                 "dot11RSNAPMKIDUsed=%s\n"
1749                 "dot11RSNAAuthenticationSuiteRequested=" RSN_SUITE "\n"
1750                 "dot11RSNAPairwiseCipherRequested=" RSN_SUITE "\n"
1751                 "dot11RSNAGroupCipherRequested=" RSN_SUITE "\n"
1752                 "dot11RSNAConfigNumberOfGTKSAReplayCounters=0\n"
1753                 "dot11RSNA4WayHandshakeFailures=%u\n",
1754                 RSN_SUITE_ARG(wpa_key_mgmt_suite(sm)),
1755                 RSN_SUITE_ARG(wpa_cipher_suite(sm, sm->pairwise_cipher)),
1756                 RSN_SUITE_ARG(wpa_cipher_suite(sm, sm->group_cipher)),
1757                 pmkid_txt,
1758                 RSN_SUITE_ARG(wpa_key_mgmt_suite(sm)),
1759                 RSN_SUITE_ARG(wpa_cipher_suite(sm, sm->pairwise_cipher)),
1760                 RSN_SUITE_ARG(wpa_cipher_suite(sm, sm->group_cipher)),
1761                 sm->dot11RSNA4WayHandshakeFailures);
1762         if (ret >= 0 && (size_t) ret < buflen)
1763                 len += ret;
1764
1765         return (int) len;
1766 }
1767 #endif /* CONFIG_CTRL_IFACE */
1768
1769
1770 static void wpa_sm_pmksa_free_cb(struct rsn_pmksa_cache_entry *entry,
1771                                  void *ctx, int replace)
1772 {
1773         struct wpa_sm *sm = ctx;
1774
1775         if (sm->cur_pmksa == entry ||
1776             (sm->pmk_len == entry->pmk_len &&
1777              os_memcmp(sm->pmk, entry->pmk, sm->pmk_len) == 0)) {
1778                 wpa_printf(MSG_DEBUG, "RSN: removed current PMKSA entry");
1779                 sm->cur_pmksa = NULL;
1780
1781                 if (replace) {
1782                         /* A new entry is being added, so no need to
1783                          * deauthenticate in this case. This happens when EAP
1784                          * authentication is completed again (reauth or failed
1785                          * PMKSA caching attempt). */
1786                         return;
1787                 }
1788
1789                 os_memset(sm->pmk, 0, sizeof(sm->pmk));
1790                 wpa_sm_deauthenticate(sm, WLAN_REASON_UNSPECIFIED);
1791         }
1792 }
1793
1794
1795 /**
1796  * wpa_sm_init - Initialize WPA state machine
1797  * @ctx: Context pointer for callbacks; this needs to be an allocated buffer
1798  * Returns: Pointer to the allocated WPA state machine data
1799  *
1800  * This function is used to allocate a new WPA state machine and the returned
1801  * value is passed to all WPA state machine calls.
1802  */
1803 struct wpa_sm * wpa_sm_init(struct wpa_sm_ctx *ctx)
1804 {
1805         struct wpa_sm *sm;
1806
1807         sm = os_zalloc(sizeof(*sm));
1808         if (sm == NULL)
1809                 return NULL;
1810         sm->renew_snonce = 1;
1811         sm->ctx = ctx;
1812
1813         sm->dot11RSNAConfigPMKLifetime = 43200;
1814         sm->dot11RSNAConfigPMKReauthThreshold = 70;
1815         sm->dot11RSNAConfigSATimeout = 60;
1816
1817         sm->pmksa = pmksa_cache_init(wpa_sm_pmksa_free_cb, sm, sm);
1818         if (sm->pmksa == NULL) {
1819                 wpa_printf(MSG_ERROR, "RSN: PMKSA cache initialization "
1820                            "failed");
1821                 os_free(sm);
1822                 return NULL;
1823         }
1824
1825         return sm;
1826 }
1827
1828
1829 /**
1830  * wpa_sm_deinit - Deinitialize WPA state machine
1831  * @sm: Pointer to WPA state machine data from wpa_sm_init()
1832  */
1833 void wpa_sm_deinit(struct wpa_sm *sm)
1834 {
1835         if (sm == NULL)
1836                 return;
1837         pmksa_cache_deinit(sm->pmksa);
1838         eloop_cancel_timeout(wpa_sm_start_preauth, sm, NULL);
1839         os_free(sm->assoc_wpa_ie);
1840         os_free(sm->ap_wpa_ie);
1841         os_free(sm->ap_rsn_ie);
1842         os_free(sm->ctx);
1843         peerkey_deinit(sm);
1844         os_free(sm);
1845 }
1846
1847
1848 /**
1849  * wpa_sm_notify_assoc - Notify WPA state machine about association
1850  * @sm: Pointer to WPA state machine data from wpa_sm_init()
1851  * @bssid: The BSSID of the new association
1852  *
1853  * This function is called to let WPA state machine know that the connection
1854  * was established.
1855  */
1856 void wpa_sm_notify_assoc(struct wpa_sm *sm, const u8 *bssid)
1857 {
1858         int clear_ptk = 1;
1859
1860         if (sm == NULL)
1861                 return;
1862
1863         wpa_printf(MSG_DEBUG, "WPA: Association event - clear replay counter");
1864         os_memcpy(sm->bssid, bssid, ETH_ALEN);
1865         os_memset(sm->rx_replay_counter, 0, WPA_REPLAY_COUNTER_LEN);
1866         sm->rx_replay_counter_set = 0;
1867         sm->renew_snonce = 1;
1868         if (os_memcmp(sm->preauth_bssid, bssid, ETH_ALEN) == 0)
1869                 rsn_preauth_deinit(sm);
1870
1871 #ifdef CONFIG_IEEE80211R
1872         if (wpa_ft_is_completed(sm)) {
1873                 wpa_supplicant_key_neg_complete(sm, sm->bssid, 1);
1874
1875                 /* Prepare for the next transition */
1876                 wpa_ft_prepare_auth_request(sm);
1877
1878                 clear_ptk = 0;
1879         }
1880 #endif /* CONFIG_IEEE80211R */
1881
1882         if (clear_ptk) {
1883                 /*
1884                  * IEEE 802.11, 8.4.10: Delete PTK SA on (re)association if
1885                  * this is not part of a Fast BSS Transition.
1886                  */
1887                 wpa_printf(MSG_DEBUG, "WPA: Clear old PTK");
1888                 sm->ptk_set = 0;
1889                 sm->tptk_set = 0;
1890         }
1891 }
1892
1893
1894 /**
1895  * wpa_sm_notify_disassoc - Notify WPA state machine about disassociation
1896  * @sm: Pointer to WPA state machine data from wpa_sm_init()
1897  *
1898  * This function is called to let WPA state machine know that the connection
1899  * was lost. This will abort any existing pre-authentication session.
1900  */
1901 void wpa_sm_notify_disassoc(struct wpa_sm *sm)
1902 {
1903         rsn_preauth_deinit(sm);
1904         if (wpa_sm_get_state(sm) == WPA_4WAY_HANDSHAKE)
1905                 sm->dot11RSNA4WayHandshakeFailures++;
1906 }
1907
1908
1909 /**
1910  * wpa_sm_set_pmk - Set PMK
1911  * @sm: Pointer to WPA state machine data from wpa_sm_init()
1912  * @pmk: The new PMK
1913  * @pmk_len: The length of the new PMK in bytes
1914  *
1915  * Configure the PMK for WPA state machine.
1916  */
1917 void wpa_sm_set_pmk(struct wpa_sm *sm, const u8 *pmk, size_t pmk_len)
1918 {
1919         if (sm == NULL)
1920                 return;
1921
1922         sm->pmk_len = pmk_len;
1923         os_memcpy(sm->pmk, pmk, pmk_len);
1924
1925 #ifdef CONFIG_IEEE80211R
1926         /* Set XXKey to be PSK for FT key derivation */
1927         sm->xxkey_len = pmk_len;
1928         os_memcpy(sm->xxkey, pmk, pmk_len);
1929 #endif /* CONFIG_IEEE80211R */
1930 }
1931
1932
1933 /**
1934  * wpa_sm_set_pmk_from_pmksa - Set PMK based on the current PMKSA
1935  * @sm: Pointer to WPA state machine data from wpa_sm_init()
1936  *
1937  * Take the PMK from the current PMKSA into use. If no PMKSA is active, the PMK
1938  * will be cleared.
1939  */
1940 void wpa_sm_set_pmk_from_pmksa(struct wpa_sm *sm)
1941 {
1942         if (sm == NULL)
1943                 return;
1944
1945         if (sm->cur_pmksa) {
1946                 sm->pmk_len = sm->cur_pmksa->pmk_len;
1947                 os_memcpy(sm->pmk, sm->cur_pmksa->pmk, sm->pmk_len);
1948         } else {
1949                 sm->pmk_len = PMK_LEN;
1950                 os_memset(sm->pmk, 0, PMK_LEN);
1951         }
1952 }
1953
1954
1955 /**
1956  * wpa_sm_set_fast_reauth - Set fast reauthentication (EAP) enabled/disabled
1957  * @sm: Pointer to WPA state machine data from wpa_sm_init()
1958  * @fast_reauth: Whether fast reauthentication (EAP) is allowed
1959  */
1960 void wpa_sm_set_fast_reauth(struct wpa_sm *sm, int fast_reauth)
1961 {
1962         if (sm)
1963                 sm->fast_reauth = fast_reauth;
1964 }
1965
1966
1967 /**
1968  * wpa_sm_set_scard_ctx - Set context pointer for smartcard callbacks
1969  * @sm: Pointer to WPA state machine data from wpa_sm_init()
1970  * @scard_ctx: Context pointer for smartcard related callback functions
1971  */
1972 void wpa_sm_set_scard_ctx(struct wpa_sm *sm, void *scard_ctx)
1973 {
1974         if (sm == NULL)
1975                 return;
1976         sm->scard_ctx = scard_ctx;
1977         if (sm->preauth_eapol)
1978                 eapol_sm_register_scard_ctx(sm->preauth_eapol, scard_ctx);
1979 }
1980
1981
1982 /**
1983  * wpa_sm_set_config - Notification of current configration change
1984  * @sm: Pointer to WPA state machine data from wpa_sm_init()
1985  * @config: Pointer to current network configuration
1986  *
1987  * Notify WPA state machine that configuration has changed. config will be
1988  * stored as a backpointer to network configuration. This can be %NULL to clear
1989  * the stored pointed.
1990  */
1991 void wpa_sm_set_config(struct wpa_sm *sm, struct rsn_supp_config *config)
1992 {
1993         if (!sm)
1994                 return;
1995
1996         if (config) {
1997                 sm->network_ctx = config->network_ctx;
1998                 sm->peerkey_enabled = config->peerkey_enabled;
1999                 sm->allowed_pairwise_cipher = config->allowed_pairwise_cipher;
2000                 sm->proactive_key_caching = config->proactive_key_caching;
2001                 sm->eap_workaround = config->eap_workaround;
2002                 sm->eap_conf_ctx = config->eap_conf_ctx;
2003                 if (config->ssid) {
2004                         os_memcpy(sm->ssid, config->ssid, config->ssid_len);
2005                         sm->ssid_len = config->ssid_len;
2006                 } else
2007                         sm->ssid_len = 0;
2008         } else {
2009                 sm->network_ctx = NULL;
2010                 sm->peerkey_enabled = 0;
2011                 sm->allowed_pairwise_cipher = 0;
2012                 sm->proactive_key_caching = 0;
2013                 sm->eap_workaround = 0;
2014                 sm->eap_conf_ctx = NULL;
2015                 sm->ssid_len = 0;
2016         }
2017         pmksa_cache_notify_reconfig(sm->pmksa);
2018 }
2019
2020
2021 /**
2022  * wpa_sm_set_own_addr - Set own MAC address
2023  * @sm: Pointer to WPA state machine data from wpa_sm_init()
2024  * @addr: Own MAC address
2025  */
2026 void wpa_sm_set_own_addr(struct wpa_sm *sm, const u8 *addr)
2027 {
2028         if (sm)
2029                 os_memcpy(sm->own_addr, addr, ETH_ALEN);
2030 }
2031
2032
2033 /**
2034  * wpa_sm_set_ifname - Set network interface name
2035  * @sm: Pointer to WPA state machine data from wpa_sm_init()
2036  * @ifname: Interface name
2037  * @bridge_ifname: Optional bridge interface name (for pre-auth)
2038  */
2039 void wpa_sm_set_ifname(struct wpa_sm *sm, const char *ifname,
2040                        const char *bridge_ifname)
2041 {
2042         if (sm) {
2043                 sm->ifname = ifname;
2044                 sm->bridge_ifname = bridge_ifname;
2045         }
2046 }
2047
2048
2049 /**
2050  * wpa_sm_set_eapol - Set EAPOL state machine pointer
2051  * @sm: Pointer to WPA state machine data from wpa_sm_init()
2052  * @eapol: Pointer to EAPOL state machine allocated with eapol_sm_init()
2053  */
2054 void wpa_sm_set_eapol(struct wpa_sm *sm, struct eapol_sm *eapol)
2055 {
2056         if (sm)
2057                 sm->eapol = eapol;
2058 }
2059
2060
2061 /**
2062  * wpa_sm_set_param - Set WPA state machine parameters
2063  * @sm: Pointer to WPA state machine data from wpa_sm_init()
2064  * @param: Parameter field
2065  * @value: Parameter value
2066  * Returns: 0 on success, -1 on failure
2067  */
2068 int wpa_sm_set_param(struct wpa_sm *sm, enum wpa_sm_conf_params param,
2069                      unsigned int value)
2070 {
2071         int ret = 0;
2072
2073         if (sm == NULL)
2074                 return -1;
2075
2076         switch (param) {
2077         case RSNA_PMK_LIFETIME:
2078                 if (value > 0)
2079                         sm->dot11RSNAConfigPMKLifetime = value;
2080                 else
2081                         ret = -1;
2082                 break;
2083         case RSNA_PMK_REAUTH_THRESHOLD:
2084                 if (value > 0 && value <= 100)
2085                         sm->dot11RSNAConfigPMKReauthThreshold = value;
2086                 else
2087                         ret = -1;
2088                 break;
2089         case RSNA_SA_TIMEOUT:
2090                 if (value > 0)
2091                         sm->dot11RSNAConfigSATimeout = value;
2092                 else
2093                         ret = -1;
2094                 break;
2095         case WPA_PARAM_PROTO:
2096                 sm->proto = value;
2097                 break;
2098         case WPA_PARAM_PAIRWISE:
2099                 sm->pairwise_cipher = value;
2100                 break;
2101         case WPA_PARAM_GROUP:
2102                 sm->group_cipher = value;
2103                 break;
2104         case WPA_PARAM_KEY_MGMT:
2105                 sm->key_mgmt = value;
2106                 break;
2107 #ifdef CONFIG_IEEE80211W
2108         case WPA_PARAM_MGMT_GROUP:
2109                 sm->mgmt_group_cipher = value;
2110                 break;
2111 #endif /* CONFIG_IEEE80211W */
2112         case WPA_PARAM_RSN_ENABLED:
2113                 sm->rsn_enabled = value;
2114                 break;
2115         default:
2116                 break;
2117         }
2118
2119         return ret;
2120 }
2121
2122
2123 /**
2124  * wpa_sm_get_param - Get WPA state machine parameters
2125  * @sm: Pointer to WPA state machine data from wpa_sm_init()
2126  * @param: Parameter field
2127  * Returns: Parameter value
2128  */
2129 unsigned int wpa_sm_get_param(struct wpa_sm *sm, enum wpa_sm_conf_params param)
2130 {
2131         if (sm == NULL)
2132                 return 0;
2133
2134         switch (param) {
2135         case RSNA_PMK_LIFETIME:
2136                 return sm->dot11RSNAConfigPMKLifetime;
2137         case RSNA_PMK_REAUTH_THRESHOLD:
2138                 return sm->dot11RSNAConfigPMKReauthThreshold;
2139         case RSNA_SA_TIMEOUT:
2140                 return sm->dot11RSNAConfigSATimeout;
2141         case WPA_PARAM_PROTO:
2142                 return sm->proto;
2143         case WPA_PARAM_PAIRWISE:
2144                 return sm->pairwise_cipher;
2145         case WPA_PARAM_GROUP:
2146                 return sm->group_cipher;
2147         case WPA_PARAM_KEY_MGMT:
2148                 return sm->key_mgmt;
2149 #ifdef CONFIG_IEEE80211W
2150         case WPA_PARAM_MGMT_GROUP:
2151                 return sm->mgmt_group_cipher;
2152 #endif /* CONFIG_IEEE80211W */
2153         case WPA_PARAM_RSN_ENABLED:
2154                 return sm->rsn_enabled;
2155         default:
2156                 return 0;
2157         }
2158 }
2159
2160
2161 /**
2162  * wpa_sm_get_status - Get WPA state machine
2163  * @sm: Pointer to WPA state machine data from wpa_sm_init()
2164  * @buf: Buffer for status information
2165  * @buflen: Maximum buffer length
2166  * @verbose: Whether to include verbose status information
2167  * Returns: Number of bytes written to buf.
2168  *
2169  * Query WPA state machine for status information. This function fills in
2170  * a text area with current status information. If the buffer (buf) is not
2171  * large enough, status information will be truncated to fit the buffer.
2172  */
2173 int wpa_sm_get_status(struct wpa_sm *sm, char *buf, size_t buflen,
2174                       int verbose)
2175 {
2176         char *pos = buf, *end = buf + buflen;
2177         int ret;
2178
2179         ret = os_snprintf(pos, end - pos,
2180                           "pairwise_cipher=%s\n"
2181                           "group_cipher=%s\n"
2182                           "key_mgmt=%s\n",
2183                           wpa_cipher_txt(sm->pairwise_cipher),
2184                           wpa_cipher_txt(sm->group_cipher),
2185                           wpa_key_mgmt_txt(sm->key_mgmt, sm->proto));
2186         if (ret < 0 || ret >= end - pos)
2187                 return pos - buf;
2188         pos += ret;
2189         return pos - buf;
2190 }
2191
2192
2193 /**
2194  * wpa_sm_set_assoc_wpa_ie_default - Generate own WPA/RSN IE from configuration
2195  * @sm: Pointer to WPA state machine data from wpa_sm_init()
2196  * @wpa_ie: Pointer to buffer for WPA/RSN IE
2197  * @wpa_ie_len: Pointer to the length of the wpa_ie buffer
2198  * Returns: 0 on success, -1 on failure
2199  */
2200 int wpa_sm_set_assoc_wpa_ie_default(struct wpa_sm *sm, u8 *wpa_ie,
2201                                     size_t *wpa_ie_len)
2202 {
2203         int res;
2204
2205         if (sm == NULL)
2206                 return -1;
2207
2208         res = wpa_gen_wpa_ie(sm, wpa_ie, *wpa_ie_len);
2209         if (res < 0)
2210                 return -1;
2211         *wpa_ie_len = res;
2212
2213         wpa_hexdump(MSG_DEBUG, "WPA: Set own WPA IE default",
2214                     wpa_ie, *wpa_ie_len);
2215
2216         if (sm->assoc_wpa_ie == NULL) {
2217                 /*
2218                  * Make a copy of the WPA/RSN IE so that 4-Way Handshake gets
2219                  * the correct version of the IE even if PMKSA caching is
2220                  * aborted (which would remove PMKID from IE generation).
2221                  */
2222                 sm->assoc_wpa_ie = os_malloc(*wpa_ie_len);
2223                 if (sm->assoc_wpa_ie == NULL)
2224                         return -1;
2225
2226                 os_memcpy(sm->assoc_wpa_ie, wpa_ie, *wpa_ie_len);
2227                 sm->assoc_wpa_ie_len = *wpa_ie_len;
2228         }
2229
2230         return 0;
2231 }
2232
2233
2234 /**
2235  * wpa_sm_set_assoc_wpa_ie - Set own WPA/RSN IE from (Re)AssocReq
2236  * @sm: Pointer to WPA state machine data from wpa_sm_init()
2237  * @ie: Pointer to IE data (starting from id)
2238  * @len: IE length
2239  * Returns: 0 on success, -1 on failure
2240  *
2241  * Inform WPA state machine about the WPA/RSN IE used in (Re)Association
2242  * Request frame. The IE will be used to override the default value generated
2243  * with wpa_sm_set_assoc_wpa_ie_default().
2244  */
2245 int wpa_sm_set_assoc_wpa_ie(struct wpa_sm *sm, const u8 *ie, size_t len)
2246 {
2247         if (sm == NULL)
2248                 return -1;
2249
2250         os_free(sm->assoc_wpa_ie);
2251         if (ie == NULL || len == 0) {
2252                 wpa_printf(MSG_DEBUG, "WPA: clearing own WPA/RSN IE");
2253                 sm->assoc_wpa_ie = NULL;
2254                 sm->assoc_wpa_ie_len = 0;
2255         } else {
2256                 wpa_hexdump(MSG_DEBUG, "WPA: set own WPA/RSN IE", ie, len);
2257                 sm->assoc_wpa_ie = os_malloc(len);
2258                 if (sm->assoc_wpa_ie == NULL)
2259                         return -1;
2260
2261                 os_memcpy(sm->assoc_wpa_ie, ie, len);
2262                 sm->assoc_wpa_ie_len = len;
2263         }
2264
2265         return 0;
2266 }
2267
2268
2269 /**
2270  * wpa_sm_set_ap_wpa_ie - Set AP WPA IE from Beacon/ProbeResp
2271  * @sm: Pointer to WPA state machine data from wpa_sm_init()
2272  * @ie: Pointer to IE data (starting from id)
2273  * @len: IE length
2274  * Returns: 0 on success, -1 on failure
2275  *
2276  * Inform WPA state machine about the WPA IE used in Beacon / Probe Response
2277  * frame.
2278  */
2279 int wpa_sm_set_ap_wpa_ie(struct wpa_sm *sm, const u8 *ie, size_t len)
2280 {
2281         if (sm == NULL)
2282                 return -1;
2283
2284         os_free(sm->ap_wpa_ie);
2285         if (ie == NULL || len == 0) {
2286                 wpa_printf(MSG_DEBUG, "WPA: clearing AP WPA IE");
2287                 sm->ap_wpa_ie = NULL;
2288                 sm->ap_wpa_ie_len = 0;
2289         } else {
2290                 wpa_hexdump(MSG_DEBUG, "WPA: set AP WPA IE", ie, len);
2291                 sm->ap_wpa_ie = os_malloc(len);
2292                 if (sm->ap_wpa_ie == NULL)
2293                         return -1;
2294
2295                 os_memcpy(sm->ap_wpa_ie, ie, len);
2296                 sm->ap_wpa_ie_len = len;
2297         }
2298
2299         return 0;
2300 }
2301
2302
2303 /**
2304  * wpa_sm_set_ap_rsn_ie - Set AP RSN IE from Beacon/ProbeResp
2305  * @sm: Pointer to WPA state machine data from wpa_sm_init()
2306  * @ie: Pointer to IE data (starting from id)
2307  * @len: IE length
2308  * Returns: 0 on success, -1 on failure
2309  *
2310  * Inform WPA state machine about the RSN IE used in Beacon / Probe Response
2311  * frame.
2312  */
2313 int wpa_sm_set_ap_rsn_ie(struct wpa_sm *sm, const u8 *ie, size_t len)
2314 {
2315         if (sm == NULL)
2316                 return -1;
2317
2318         os_free(sm->ap_rsn_ie);
2319         if (ie == NULL || len == 0) {
2320                 wpa_printf(MSG_DEBUG, "WPA: clearing AP RSN IE");
2321                 sm->ap_rsn_ie = NULL;
2322                 sm->ap_rsn_ie_len = 0;
2323         } else {
2324                 wpa_hexdump(MSG_DEBUG, "WPA: set AP RSN IE", ie, len);
2325                 sm->ap_rsn_ie = os_malloc(len);
2326                 if (sm->ap_rsn_ie == NULL)
2327                         return -1;
2328
2329                 os_memcpy(sm->ap_rsn_ie, ie, len);
2330                 sm->ap_rsn_ie_len = len;
2331         }
2332
2333         return 0;
2334 }
2335
2336
2337 /**
2338  * wpa_sm_parse_own_wpa_ie - Parse own WPA/RSN IE
2339  * @sm: Pointer to WPA state machine data from wpa_sm_init()
2340  * @data: Pointer to data area for parsing results
2341  * Returns: 0 on success, -1 if IE is not known, or -2 on parsing failure
2342  *
2343  * Parse the contents of the own WPA or RSN IE from (Re)AssocReq and write the
2344  * parsed data into data.
2345  */
2346 int wpa_sm_parse_own_wpa_ie(struct wpa_sm *sm, struct wpa_ie_data *data)
2347 {
2348         if (sm == NULL || sm->assoc_wpa_ie == NULL) {
2349                 wpa_printf(MSG_DEBUG, "WPA: No WPA/RSN IE available from "
2350                            "association info");
2351                 return -1;
2352         }
2353         if (wpa_parse_wpa_ie(sm->assoc_wpa_ie, sm->assoc_wpa_ie_len, data))
2354                 return -2;
2355         return 0;
2356 }