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