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