src/rsn_supp/wpa.c

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