1 /* 2 * hostapd / EAP Full Authenticator state machine (RFC 4137) 3 * Copyright (c) 2004-2014, 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 * This state machine is based on the full authenticator state machine defined 9 * in RFC 4137. However, to support backend authentication in RADIUS 10 * authentication server functionality, parts of backend authenticator (also 11 * from RFC 4137) are mixed in. This functionality is enabled by setting 12 * backend_auth configuration variable to TRUE. 13 */ 14 15 #include "includes.h" 16 17 #include "common.h" 18 #include "crypto/sha256.h" 19 #include "eap_i.h" 20 #include "state_machine.h" 21 #include "common/wpa_ctrl.h" 22 23 #define STATE_MACHINE_DATA struct eap_sm 24 #define STATE_MACHINE_DEBUG_PREFIX "EAP" 25 26 #define EAP_MAX_AUTH_ROUNDS 50 27 28 static void eap_user_free(struct eap_user *user); 29 30 31 /* EAP state machines are described in RFC 4137 */ 32 33 static int eap_sm_calculateTimeout(struct eap_sm *sm, int retransCount, 34 int eapSRTT, int eapRTTVAR, 35 int methodTimeout); 36 static void eap_sm_parseEapResp(struct eap_sm *sm, const struct wpabuf *resp); 37 static int eap_sm_getId(const struct wpabuf *data); 38 static struct wpabuf * eap_sm_buildSuccess(struct eap_sm *sm, u8 id); 39 static struct wpabuf * eap_sm_buildFailure(struct eap_sm *sm, u8 id); 40 static int eap_sm_nextId(struct eap_sm *sm, int id); 41 static void eap_sm_Policy_update(struct eap_sm *sm, const u8 *nak_list, 42 size_t len); 43 static EapType eap_sm_Policy_getNextMethod(struct eap_sm *sm, int *vendor); 44 static int eap_sm_Policy_getDecision(struct eap_sm *sm); 45 static Boolean eap_sm_Policy_doPickUp(struct eap_sm *sm, EapType method); 46 47 48 static int eap_get_erp_send_reauth_start(struct eap_sm *sm) 49 { 50 if (sm->eapol_cb->get_erp_send_reauth_start) 51 return sm->eapol_cb->get_erp_send_reauth_start(sm->eapol_ctx); 52 return 0; 53 } 54 55 56 static const char * eap_get_erp_domain(struct eap_sm *sm) 57 { 58 if (sm->eapol_cb->get_erp_domain) 59 return sm->eapol_cb->get_erp_domain(sm->eapol_ctx); 60 return NULL; 61 } 62 63 64 #ifdef CONFIG_ERP 65 66 static struct eap_server_erp_key * eap_erp_get_key(struct eap_sm *sm, 67 const char *keyname) 68 { 69 if (sm->eapol_cb->erp_get_key) 70 return sm->eapol_cb->erp_get_key(sm->eapol_ctx, keyname); 71 return NULL; 72 } 73 74 75 static int eap_erp_add_key(struct eap_sm *sm, struct eap_server_erp_key *erp) 76 { 77 if (sm->eapol_cb->erp_add_key) 78 return sm->eapol_cb->erp_add_key(sm->eapol_ctx, erp); 79 return -1; 80 } 81 82 #endif /* CONFIG_ERP */ 83 84 85 static struct wpabuf * eap_sm_buildInitiateReauthStart(struct eap_sm *sm, 86 u8 id) 87 { 88 const char *domain; 89 size_t plen = 1; 90 struct wpabuf *msg; 91 size_t domain_len = 0; 92 93 domain = eap_get_erp_domain(sm); 94 if (domain) { 95 domain_len = os_strlen(domain); 96 plen += 2 + domain_len; 97 } 98 99 msg = eap_msg_alloc(EAP_VENDOR_IETF, 100 (EapType) EAP_ERP_TYPE_REAUTH_START, plen, 101 EAP_CODE_INITIATE, id); 102 if (msg == NULL) 103 return NULL; 104 wpabuf_put_u8(msg, 0); /* Reserved */ 105 if (domain) { 106 /* Domain name TLV */ 107 wpabuf_put_u8(msg, EAP_ERP_TLV_DOMAIN_NAME); 108 wpabuf_put_u8(msg, domain_len); 109 wpabuf_put_data(msg, domain, domain_len); 110 } 111 112 return msg; 113 } 114 115 116 static int eap_copy_buf(struct wpabuf **dst, const struct wpabuf *src) 117 { 118 if (src == NULL) 119 return -1; 120 121 wpabuf_free(*dst); 122 *dst = wpabuf_dup(src); 123 return *dst ? 0 : -1; 124 } 125 126 127 static int eap_copy_data(u8 **dst, size_t *dst_len, 128 const u8 *src, size_t src_len) 129 { 130 if (src == NULL) 131 return -1; 132 133 os_free(*dst); 134 *dst = os_malloc(src_len); 135 if (*dst) { 136 os_memcpy(*dst, src, src_len); 137 *dst_len = src_len; 138 return 0; 139 } else { 140 *dst_len = 0; 141 return -1; 142 } 143 } 144 145 #define EAP_COPY(dst, src) \ 146 eap_copy_data((dst), (dst ## Len), (src), (src ## Len)) 147 148 149 /** 150 * eap_user_get - Fetch user information from the database 151 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init() 152 * @identity: Identity (User-Name) of the user 153 * @identity_len: Length of identity in bytes 154 * @phase2: 0 = EAP phase1 user, 1 = EAP phase2 (tunneled) user 155 * Returns: 0 on success, or -1 on failure 156 * 157 * This function is used to fetch user information for EAP. The user will be 158 * selected based on the specified identity. sm->user and 159 * sm->user_eap_method_index are updated for the new user when a matching user 160 * is found. sm->user can be used to get user information (e.g., password). 161 */ 162 int eap_user_get(struct eap_sm *sm, const u8 *identity, size_t identity_len, 163 int phase2) 164 { 165 struct eap_user *user; 166 167 if (sm == NULL || sm->eapol_cb == NULL || 168 sm->eapol_cb->get_eap_user == NULL) 169 return -1; 170 171 eap_user_free(sm->user); 172 sm->user = NULL; 173 174 user = os_zalloc(sizeof(*user)); 175 if (user == NULL) 176 return -1; 177 178 if (sm->eapol_cb->get_eap_user(sm->eapol_ctx, identity, 179 identity_len, phase2, user) != 0) { 180 eap_user_free(user); 181 return -1; 182 } 183 184 sm->user = user; 185 sm->user_eap_method_index = 0; 186 187 return 0; 188 } 189 190 191 void eap_log_msg(struct eap_sm *sm, const char *fmt, ...) 192 { 193 va_list ap; 194 char *buf; 195 int buflen; 196 197 if (sm == NULL || sm->eapol_cb == NULL || sm->eapol_cb->log_msg == NULL) 198 return; 199 200 va_start(ap, fmt); 201 buflen = vsnprintf(NULL, 0, fmt, ap) + 1; 202 va_end(ap); 203 204 buf = os_malloc(buflen); 205 if (buf == NULL) 206 return; 207 va_start(ap, fmt); 208 vsnprintf(buf, buflen, fmt, ap); 209 va_end(ap); 210 211 sm->eapol_cb->log_msg(sm->eapol_ctx, buf); 212 213 os_free(buf); 214 } 215 216 217 SM_STATE(EAP, DISABLED) 218 { 219 SM_ENTRY(EAP, DISABLED); 220 sm->num_rounds = 0; 221 } 222 223 224 SM_STATE(EAP, INITIALIZE) 225 { 226 SM_ENTRY(EAP, INITIALIZE); 227 228 if (sm->eap_if.eapRestart && !sm->eap_server && sm->identity) { 229 /* 230 * Need to allow internal Identity method to be used instead 231 * of passthrough at the beginning of reauthentication. 232 */ 233 eap_server_clear_identity(sm); 234 } 235 236 sm->try_initiate_reauth = FALSE; 237 sm->currentId = -1; 238 sm->eap_if.eapSuccess = FALSE; 239 sm->eap_if.eapFail = FALSE; 240 sm->eap_if.eapTimeout = FALSE; 241 bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen); 242 sm->eap_if.eapKeyData = NULL; 243 sm->eap_if.eapKeyDataLen = 0; 244 os_free(sm->eap_if.eapSessionId); 245 sm->eap_if.eapSessionId = NULL; 246 sm->eap_if.eapSessionIdLen = 0; 247 sm->eap_if.eapKeyAvailable = FALSE; 248 sm->eap_if.eapRestart = FALSE; 249 250 /* 251 * This is not defined in RFC 4137, but method state needs to be 252 * reseted here so that it does not remain in success state when 253 * re-authentication starts. 254 */ 255 if (sm->m && sm->eap_method_priv) { 256 sm->m->reset(sm, sm->eap_method_priv); 257 sm->eap_method_priv = NULL; 258 } 259 sm->m = NULL; 260 sm->user_eap_method_index = 0; 261 262 if (sm->backend_auth) { 263 sm->currentMethod = EAP_TYPE_NONE; 264 /* parse rxResp, respId, respMethod */ 265 eap_sm_parseEapResp(sm, sm->eap_if.eapRespData); 266 if (sm->rxResp) { 267 sm->currentId = sm->respId; 268 } 269 } 270 sm->num_rounds = 0; 271 sm->method_pending = METHOD_PENDING_NONE; 272 273 wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_STARTED 274 MACSTR, MAC2STR(sm->peer_addr)); 275 } 276 277 278 SM_STATE(EAP, PICK_UP_METHOD) 279 { 280 SM_ENTRY(EAP, PICK_UP_METHOD); 281 282 if (eap_sm_Policy_doPickUp(sm, sm->respMethod)) { 283 sm->currentMethod = sm->respMethod; 284 if (sm->m && sm->eap_method_priv) { 285 sm->m->reset(sm, sm->eap_method_priv); 286 sm->eap_method_priv = NULL; 287 } 288 sm->m = eap_server_get_eap_method(EAP_VENDOR_IETF, 289 sm->currentMethod); 290 if (sm->m && sm->m->initPickUp) { 291 sm->eap_method_priv = sm->m->initPickUp(sm); 292 if (sm->eap_method_priv == NULL) { 293 wpa_printf(MSG_DEBUG, "EAP: Failed to " 294 "initialize EAP method %d", 295 sm->currentMethod); 296 sm->m = NULL; 297 sm->currentMethod = EAP_TYPE_NONE; 298 } 299 } else { 300 sm->m = NULL; 301 sm->currentMethod = EAP_TYPE_NONE; 302 } 303 } 304 305 wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_PROPOSED_METHOD 306 "method=%u", sm->currentMethod); 307 } 308 309 310 SM_STATE(EAP, IDLE) 311 { 312 SM_ENTRY(EAP, IDLE); 313 314 sm->eap_if.retransWhile = eap_sm_calculateTimeout( 315 sm, sm->retransCount, sm->eap_if.eapSRTT, sm->eap_if.eapRTTVAR, 316 sm->methodTimeout); 317 } 318 319 320 SM_STATE(EAP, RETRANSMIT) 321 { 322 SM_ENTRY(EAP, RETRANSMIT); 323 324 sm->retransCount++; 325 if (sm->retransCount <= sm->MaxRetrans && sm->lastReqData) { 326 if (eap_copy_buf(&sm->eap_if.eapReqData, sm->lastReqData) == 0) 327 sm->eap_if.eapReq = TRUE; 328 } 329 } 330 331 332 SM_STATE(EAP, RECEIVED) 333 { 334 SM_ENTRY(EAP, RECEIVED); 335 336 /* parse rxResp, respId, respMethod */ 337 eap_sm_parseEapResp(sm, sm->eap_if.eapRespData); 338 sm->num_rounds++; 339 } 340 341 342 SM_STATE(EAP, DISCARD) 343 { 344 SM_ENTRY(EAP, DISCARD); 345 sm->eap_if.eapResp = FALSE; 346 sm->eap_if.eapNoReq = TRUE; 347 } 348 349 350 SM_STATE(EAP, SEND_REQUEST) 351 { 352 SM_ENTRY(EAP, SEND_REQUEST); 353 354 sm->retransCount = 0; 355 if (sm->eap_if.eapReqData) { 356 if (eap_copy_buf(&sm->lastReqData, sm->eap_if.eapReqData) == 0) 357 { 358 sm->eap_if.eapResp = FALSE; 359 sm->eap_if.eapReq = TRUE; 360 } else { 361 sm->eap_if.eapResp = FALSE; 362 sm->eap_if.eapReq = FALSE; 363 } 364 } else { 365 wpa_printf(MSG_INFO, "EAP: SEND_REQUEST - no eapReqData"); 366 sm->eap_if.eapResp = FALSE; 367 sm->eap_if.eapReq = FALSE; 368 sm->eap_if.eapNoReq = TRUE; 369 } 370 } 371 372 373 SM_STATE(EAP, INTEGRITY_CHECK) 374 { 375 SM_ENTRY(EAP, INTEGRITY_CHECK); 376 377 if (!eap_hdr_len_valid(sm->eap_if.eapRespData, 1)) { 378 sm->ignore = TRUE; 379 return; 380 } 381 382 if (sm->m->check) { 383 sm->ignore = sm->m->check(sm, sm->eap_method_priv, 384 sm->eap_if.eapRespData); 385 } 386 } 387 388 389 SM_STATE(EAP, METHOD_REQUEST) 390 { 391 SM_ENTRY(EAP, METHOD_REQUEST); 392 393 if (sm->m == NULL) { 394 wpa_printf(MSG_DEBUG, "EAP: method not initialized"); 395 return; 396 } 397 398 sm->currentId = eap_sm_nextId(sm, sm->currentId); 399 wpa_printf(MSG_DEBUG, "EAP: building EAP-Request: Identifier %d", 400 sm->currentId); 401 sm->lastId = sm->currentId; 402 wpabuf_free(sm->eap_if.eapReqData); 403 sm->eap_if.eapReqData = sm->m->buildReq(sm, sm->eap_method_priv, 404 sm->currentId); 405 if (sm->m->getTimeout) 406 sm->methodTimeout = sm->m->getTimeout(sm, sm->eap_method_priv); 407 else 408 sm->methodTimeout = 0; 409 } 410 411 412 static void eap_server_erp_init(struct eap_sm *sm) 413 { 414 #ifdef CONFIG_ERP 415 u8 *emsk = NULL; 416 size_t emsk_len = 0; 417 u8 EMSKname[EAP_EMSK_NAME_LEN]; 418 u8 len[2]; 419 const char *domain; 420 size_t domain_len, nai_buf_len; 421 struct eap_server_erp_key *erp = NULL; 422 int pos; 423 424 domain = eap_get_erp_domain(sm); 425 if (!domain) 426 return; 427 428 domain_len = os_strlen(domain); 429 430 nai_buf_len = 2 * EAP_EMSK_NAME_LEN + 1 + domain_len; 431 if (nai_buf_len > 253) { 432 /* 433 * keyName-NAI has a maximum length of 253 octet to fit in 434 * RADIUS attributes. 435 */ 436 wpa_printf(MSG_DEBUG, 437 "EAP: Too long realm for ERP keyName-NAI maximum length"); 438 return; 439 } 440 nai_buf_len++; /* null termination */ 441 erp = os_zalloc(sizeof(*erp) + nai_buf_len); 442 if (erp == NULL) 443 goto fail; 444 erp->recv_seq = (u32) -1; 445 446 emsk = sm->m->get_emsk(sm, sm->eap_method_priv, &emsk_len); 447 if (!emsk || emsk_len == 0 || emsk_len > ERP_MAX_KEY_LEN) { 448 wpa_printf(MSG_DEBUG, 449 "EAP: No suitable EMSK available for ERP"); 450 goto fail; 451 } 452 453 wpa_hexdump_key(MSG_DEBUG, "EAP: EMSK", emsk, emsk_len); 454 455 WPA_PUT_BE16(len, 8); 456 if (hmac_sha256_kdf(sm->eap_if.eapSessionId, sm->eap_if.eapSessionIdLen, 457 "EMSK", len, sizeof(len), 458 EMSKname, EAP_EMSK_NAME_LEN) < 0) { 459 wpa_printf(MSG_DEBUG, "EAP: Could not derive EMSKname"); 460 goto fail; 461 } 462 wpa_hexdump(MSG_DEBUG, "EAP: EMSKname", EMSKname, EAP_EMSK_NAME_LEN); 463 464 pos = wpa_snprintf_hex(erp->keyname_nai, nai_buf_len, 465 EMSKname, EAP_EMSK_NAME_LEN); 466 erp->keyname_nai[pos] = '@'; 467 os_memcpy(&erp->keyname_nai[pos + 1], domain, domain_len); 468 469 WPA_PUT_BE16(len, emsk_len); 470 if (hmac_sha256_kdf(emsk, emsk_len, 471 "EAP Re-authentication Root Key@ietf.org", 472 len, sizeof(len), erp->rRK, emsk_len) < 0) { 473 wpa_printf(MSG_DEBUG, "EAP: Could not derive rRK for ERP"); 474 goto fail; 475 } 476 erp->rRK_len = emsk_len; 477 wpa_hexdump_key(MSG_DEBUG, "EAP: ERP rRK", erp->rRK, erp->rRK_len); 478 479 if (hmac_sha256_kdf(erp->rRK, erp->rRK_len, 480 "EAP Re-authentication Integrity Key@ietf.org", 481 len, sizeof(len), erp->rIK, erp->rRK_len) < 0) { 482 wpa_printf(MSG_DEBUG, "EAP: Could not derive rIK for ERP"); 483 goto fail; 484 } 485 erp->rIK_len = erp->rRK_len; 486 wpa_hexdump_key(MSG_DEBUG, "EAP: ERP rIK", erp->rIK, erp->rIK_len); 487 488 if (eap_erp_add_key(sm, erp) == 0) { 489 wpa_printf(MSG_DEBUG, "EAP: Stored ERP keys %s", 490 erp->keyname_nai); 491 erp = NULL; 492 } 493 494 fail: 495 bin_clear_free(emsk, emsk_len); 496 bin_clear_free(erp, sizeof(*erp)); 497 #endif /* CONFIG_ERP */ 498 } 499 500 501 SM_STATE(EAP, METHOD_RESPONSE) 502 { 503 SM_ENTRY(EAP, METHOD_RESPONSE); 504 505 if (!eap_hdr_len_valid(sm->eap_if.eapRespData, 1)) 506 return; 507 508 sm->m->process(sm, sm->eap_method_priv, sm->eap_if.eapRespData); 509 if (sm->m->isDone(sm, sm->eap_method_priv)) { 510 eap_sm_Policy_update(sm, NULL, 0); 511 bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen); 512 if (sm->m->getKey) { 513 sm->eap_if.eapKeyData = sm->m->getKey( 514 sm, sm->eap_method_priv, 515 &sm->eap_if.eapKeyDataLen); 516 } else { 517 sm->eap_if.eapKeyData = NULL; 518 sm->eap_if.eapKeyDataLen = 0; 519 } 520 os_free(sm->eap_if.eapSessionId); 521 sm->eap_if.eapSessionId = NULL; 522 if (sm->m->getSessionId) { 523 sm->eap_if.eapSessionId = sm->m->getSessionId( 524 sm, sm->eap_method_priv, 525 &sm->eap_if.eapSessionIdLen); 526 wpa_hexdump(MSG_DEBUG, "EAP: Session-Id", 527 sm->eap_if.eapSessionId, 528 sm->eap_if.eapSessionIdLen); 529 } 530 if (sm->erp && sm->m->get_emsk && sm->eap_if.eapSessionId) 531 eap_server_erp_init(sm); 532 sm->methodState = METHOD_END; 533 } else { 534 sm->methodState = METHOD_CONTINUE; 535 } 536 } 537 538 539 SM_STATE(EAP, PROPOSE_METHOD) 540 { 541 int vendor; 542 EapType type; 543 544 SM_ENTRY(EAP, PROPOSE_METHOD); 545 546 sm->try_initiate_reauth = FALSE; 547 try_another_method: 548 type = eap_sm_Policy_getNextMethod(sm, &vendor); 549 if (vendor == EAP_VENDOR_IETF) 550 sm->currentMethod = type; 551 else 552 sm->currentMethod = EAP_TYPE_EXPANDED; 553 if (sm->m && sm->eap_method_priv) { 554 sm->m->reset(sm, sm->eap_method_priv); 555 sm->eap_method_priv = NULL; 556 } 557 sm->m = eap_server_get_eap_method(vendor, type); 558 if (sm->m) { 559 sm->eap_method_priv = sm->m->init(sm); 560 if (sm->eap_method_priv == NULL) { 561 wpa_printf(MSG_DEBUG, "EAP: Failed to initialize EAP " 562 "method %d", sm->currentMethod); 563 sm->m = NULL; 564 sm->currentMethod = EAP_TYPE_NONE; 565 goto try_another_method; 566 } 567 } 568 if (sm->m == NULL) { 569 wpa_printf(MSG_DEBUG, "EAP: Could not find suitable EAP method"); 570 eap_log_msg(sm, "Could not find suitable EAP method"); 571 sm->decision = DECISION_FAILURE; 572 return; 573 } 574 if (sm->currentMethod == EAP_TYPE_IDENTITY || 575 sm->currentMethod == EAP_TYPE_NOTIFICATION) 576 sm->methodState = METHOD_CONTINUE; 577 else 578 sm->methodState = METHOD_PROPOSED; 579 580 wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_PROPOSED_METHOD 581 "vendor=%u method=%u", vendor, sm->currentMethod); 582 eap_log_msg(sm, "Propose EAP method vendor=%u method=%u", 583 vendor, sm->currentMethod); 584 } 585 586 587 SM_STATE(EAP, NAK) 588 { 589 const struct eap_hdr *nak; 590 size_t len = 0; 591 const u8 *pos; 592 const u8 *nak_list = NULL; 593 594 SM_ENTRY(EAP, NAK); 595 596 if (sm->eap_method_priv) { 597 sm->m->reset(sm, sm->eap_method_priv); 598 sm->eap_method_priv = NULL; 599 } 600 sm->m = NULL; 601 602 if (!eap_hdr_len_valid(sm->eap_if.eapRespData, 1)) 603 return; 604 605 nak = wpabuf_head(sm->eap_if.eapRespData); 606 if (nak && wpabuf_len(sm->eap_if.eapRespData) > sizeof(*nak)) { 607 len = be_to_host16(nak->length); 608 if (len > wpabuf_len(sm->eap_if.eapRespData)) 609 len = wpabuf_len(sm->eap_if.eapRespData); 610 pos = (const u8 *) (nak + 1); 611 len -= sizeof(*nak); 612 if (*pos == EAP_TYPE_NAK) { 613 pos++; 614 len--; 615 nak_list = pos; 616 } 617 } 618 eap_sm_Policy_update(sm, nak_list, len); 619 } 620 621 622 SM_STATE(EAP, SELECT_ACTION) 623 { 624 SM_ENTRY(EAP, SELECT_ACTION); 625 626 sm->decision = eap_sm_Policy_getDecision(sm); 627 } 628 629 630 SM_STATE(EAP, TIMEOUT_FAILURE) 631 { 632 SM_ENTRY(EAP, TIMEOUT_FAILURE); 633 634 sm->eap_if.eapTimeout = TRUE; 635 } 636 637 638 SM_STATE(EAP, FAILURE) 639 { 640 SM_ENTRY(EAP, FAILURE); 641 642 wpabuf_free(sm->eap_if.eapReqData); 643 sm->eap_if.eapReqData = eap_sm_buildFailure(sm, sm->currentId); 644 wpabuf_free(sm->lastReqData); 645 sm->lastReqData = NULL; 646 sm->eap_if.eapFail = TRUE; 647 648 wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_FAILURE 649 MACSTR, MAC2STR(sm->peer_addr)); 650 } 651 652 653 SM_STATE(EAP, SUCCESS) 654 { 655 SM_ENTRY(EAP, SUCCESS); 656 657 wpabuf_free(sm->eap_if.eapReqData); 658 sm->eap_if.eapReqData = eap_sm_buildSuccess(sm, sm->currentId); 659 wpabuf_free(sm->lastReqData); 660 sm->lastReqData = NULL; 661 if (sm->eap_if.eapKeyData) 662 sm->eap_if.eapKeyAvailable = TRUE; 663 sm->eap_if.eapSuccess = TRUE; 664 665 wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_SUCCESS 666 MACSTR, MAC2STR(sm->peer_addr)); 667 } 668 669 670 SM_STATE(EAP, INITIATE_REAUTH_START) 671 { 672 SM_ENTRY(EAP, INITIATE_REAUTH_START); 673 674 sm->initiate_reauth_start_sent = TRUE; 675 sm->try_initiate_reauth = TRUE; 676 sm->currentId = eap_sm_nextId(sm, sm->currentId); 677 wpa_printf(MSG_DEBUG, 678 "EAP: building EAP-Initiate-Re-auth-Start: Identifier %d", 679 sm->currentId); 680 sm->lastId = sm->currentId; 681 wpabuf_free(sm->eap_if.eapReqData); 682 sm->eap_if.eapReqData = eap_sm_buildInitiateReauthStart(sm, 683 sm->currentId); 684 wpabuf_free(sm->lastReqData); 685 sm->lastReqData = NULL; 686 } 687 688 689 #ifdef CONFIG_ERP 690 691 static void erp_send_finish_reauth(struct eap_sm *sm, 692 struct eap_server_erp_key *erp, u8 id, 693 u8 flags, u16 seq, const char *nai) 694 { 695 size_t plen; 696 struct wpabuf *msg; 697 u8 hash[SHA256_MAC_LEN]; 698 size_t hash_len; 699 u8 seed[4]; 700 701 if (erp) { 702 switch (erp->cryptosuite) { 703 case EAP_ERP_CS_HMAC_SHA256_256: 704 hash_len = 32; 705 break; 706 case EAP_ERP_CS_HMAC_SHA256_128: 707 hash_len = 16; 708 break; 709 default: 710 return; 711 } 712 } else 713 hash_len = 0; 714 715 plen = 1 + 2 + 2 + os_strlen(nai); 716 if (hash_len) 717 plen += 1 + hash_len; 718 msg = eap_msg_alloc(EAP_VENDOR_IETF, (EapType) EAP_ERP_TYPE_REAUTH, 719 plen, EAP_CODE_FINISH, id); 720 if (msg == NULL) 721 return; 722 wpabuf_put_u8(msg, flags); 723 wpabuf_put_be16(msg, seq); 724 725 wpabuf_put_u8(msg, EAP_ERP_TLV_KEYNAME_NAI); 726 wpabuf_put_u8(msg, os_strlen(nai)); 727 wpabuf_put_str(msg, nai); 728 729 if (erp) { 730 wpabuf_put_u8(msg, erp->cryptosuite); 731 if (hmac_sha256(erp->rIK, erp->rIK_len, 732 wpabuf_head(msg), wpabuf_len(msg), hash) < 0) { 733 wpabuf_free(msg); 734 return; 735 } 736 wpabuf_put_data(msg, hash, hash_len); 737 } 738 739 wpa_printf(MSG_DEBUG, "EAP: Send EAP-Finish/Re-auth (%s)", 740 flags & 0x80 ? "failure" : "success"); 741 742 sm->lastId = sm->currentId; 743 sm->currentId = id; 744 wpabuf_free(sm->eap_if.eapReqData); 745 sm->eap_if.eapReqData = msg; 746 wpabuf_free(sm->lastReqData); 747 sm->lastReqData = NULL; 748 749 if ((flags & 0x80) || !erp) { 750 sm->eap_if.eapFail = TRUE; 751 wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_FAILURE 752 MACSTR, MAC2STR(sm->peer_addr)); 753 return; 754 } 755 756 bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen); 757 sm->eap_if.eapKeyDataLen = 0; 758 sm->eap_if.eapKeyData = os_malloc(erp->rRK_len); 759 if (!sm->eap_if.eapKeyData) 760 return; 761 762 WPA_PUT_BE16(seed, seq); 763 WPA_PUT_BE16(&seed[2], erp->rRK_len); 764 if (hmac_sha256_kdf(erp->rRK, erp->rRK_len, 765 "Re-authentication Master Session Key@ietf.org", 766 seed, sizeof(seed), 767 sm->eap_if.eapKeyData, erp->rRK_len) < 0) { 768 wpa_printf(MSG_DEBUG, "EAP: Could not derive rMSK for ERP"); 769 bin_clear_free(sm->eap_if.eapKeyData, erp->rRK_len); 770 sm->eap_if.eapKeyData = NULL; 771 return; 772 } 773 sm->eap_if.eapKeyDataLen = erp->rRK_len; 774 sm->eap_if.eapKeyAvailable = TRUE; 775 wpa_hexdump_key(MSG_DEBUG, "EAP: ERP rMSK", 776 sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen); 777 sm->eap_if.eapSuccess = TRUE; 778 779 wpa_msg(sm->msg_ctx, MSG_INFO, WPA_EVENT_EAP_SUCCESS 780 MACSTR, MAC2STR(sm->peer_addr)); 781 } 782 783 784 SM_STATE(EAP, INITIATE_RECEIVED) 785 { 786 const u8 *pos, *end, *start, *tlvs, *hdr; 787 const struct eap_hdr *ehdr; 788 size_t len; 789 u8 flags; 790 u16 seq; 791 char nai[254]; 792 struct eap_server_erp_key *erp; 793 int max_len; 794 u8 hash[SHA256_MAC_LEN]; 795 size_t hash_len; 796 struct erp_tlvs parse; 797 u8 resp_flags = 0x80; /* default to failure; cleared on success */ 798 799 SM_ENTRY(EAP, INITIATE_RECEIVED); 800 801 sm->rxInitiate = FALSE; 802 803 pos = eap_hdr_validate(EAP_VENDOR_IETF, (EapType) EAP_ERP_TYPE_REAUTH, 804 sm->eap_if.eapRespData, &len); 805 if (pos == NULL) { 806 wpa_printf(MSG_INFO, "EAP-Initiate: Invalid frame"); 807 goto fail; 808 } 809 hdr = wpabuf_head(sm->eap_if.eapRespData); 810 ehdr = wpabuf_head(sm->eap_if.eapRespData); 811 812 wpa_hexdump(MSG_DEBUG, "EAP: EAP-Initiate/Re-Auth", pos, len); 813 if (len < 4) { 814 wpa_printf(MSG_INFO, "EAP: Too short EAP-Initiate/Re-auth"); 815 goto fail; 816 } 817 end = pos + len; 818 819 flags = *pos++; 820 seq = WPA_GET_BE16(pos); 821 pos += 2; 822 wpa_printf(MSG_DEBUG, "EAP: Flags=0x%x SEQ=%u", flags, seq); 823 tlvs = pos; 824 825 /* 826 * Parse TVs/TLVs. Since we do not yet know the length of the 827 * Authentication Tag, stop parsing if an unknown TV/TLV is seen and 828 * just try to find the keyName-NAI first so that we can check the 829 * Authentication Tag. 830 */ 831 if (erp_parse_tlvs(tlvs, end, &parse, 1) < 0) 832 goto fail; 833 834 if (!parse.keyname) { 835 wpa_printf(MSG_DEBUG, 836 "EAP: No keyName-NAI in EAP-Initiate/Re-auth Packet"); 837 goto fail; 838 } 839 840 wpa_hexdump_ascii(MSG_DEBUG, "EAP: EAP-Initiate/Re-auth - keyName-NAI", 841 parse.keyname, parse.keyname_len); 842 if (parse.keyname_len > 253) { 843 wpa_printf(MSG_DEBUG, 844 "EAP: Too long keyName-NAI in EAP-Initiate/Re-auth"); 845 goto fail; 846 } 847 os_memcpy(nai, parse.keyname, parse.keyname_len); 848 nai[parse.keyname_len] = '\0'; 849 850 if (!sm->eap_server) { 851 /* 852 * In passthrough case, EAP-Initiate/Re-auth replaces 853 * EAP Identity exchange. Use keyName-NAI as the user identity 854 * and forward EAP-Initiate/Re-auth to the backend 855 * authentication server. 856 */ 857 wpa_printf(MSG_DEBUG, 858 "EAP: Use keyName-NAI as user identity for backend authentication"); 859 eap_server_clear_identity(sm); 860 sm->identity = (u8 *) dup_binstr(parse.keyname, 861 parse.keyname_len); 862 if (!sm->identity) 863 goto fail; 864 sm->identity_len = parse.keyname_len; 865 return; 866 } 867 868 erp = eap_erp_get_key(sm, nai); 869 if (!erp) { 870 wpa_printf(MSG_DEBUG, "EAP: No matching ERP key found for %s", 871 nai); 872 goto report_error; 873 } 874 875 if (erp->recv_seq != (u32) -1 && erp->recv_seq >= seq) { 876 wpa_printf(MSG_DEBUG, 877 "EAP: SEQ=%u replayed (already received SEQ=%u)", 878 seq, erp->recv_seq); 879 goto fail; 880 } 881 882 /* Is there enough room for Cryptosuite and Authentication Tag? */ 883 start = parse.keyname + parse.keyname_len; 884 max_len = end - start; 885 if (max_len < 886 1 + (erp->cryptosuite == EAP_ERP_CS_HMAC_SHA256_256 ? 32 : 16)) { 887 wpa_printf(MSG_DEBUG, 888 "EAP: Not enough room for Authentication Tag"); 889 goto fail; 890 } 891 892 switch (erp->cryptosuite) { 893 case EAP_ERP_CS_HMAC_SHA256_256: 894 if (end[-33] != erp->cryptosuite) { 895 wpa_printf(MSG_DEBUG, 896 "EAP: Different Cryptosuite used"); 897 goto fail; 898 } 899 hash_len = 32; 900 break; 901 case EAP_ERP_CS_HMAC_SHA256_128: 902 if (end[-17] != erp->cryptosuite) { 903 wpa_printf(MSG_DEBUG, 904 "EAP: Different Cryptosuite used"); 905 goto fail; 906 } 907 hash_len = 16; 908 break; 909 default: 910 hash_len = 0; 911 break; 912 } 913 914 if (hash_len) { 915 if (hmac_sha256(erp->rIK, erp->rIK_len, hdr, 916 end - hdr - hash_len, hash) < 0) 917 goto fail; 918 if (os_memcmp(end - hash_len, hash, hash_len) != 0) { 919 wpa_printf(MSG_DEBUG, 920 "EAP: Authentication Tag mismatch"); 921 goto fail; 922 } 923 } 924 925 /* Check if any supported CS results in matching tag */ 926 if (!hash_len && max_len >= 1 + 32 && 927 end[-33] == EAP_ERP_CS_HMAC_SHA256_256) { 928 if (hmac_sha256(erp->rIK, erp->rIK_len, hdr, 929 end - hdr - 32, hash) < 0) 930 goto fail; 931 if (os_memcmp(end - 32, hash, 32) == 0) { 932 wpa_printf(MSG_DEBUG, 933 "EAP: Authentication Tag match using HMAC-SHA256-256"); 934 hash_len = 32; 935 erp->cryptosuite = EAP_ERP_CS_HMAC_SHA256_256; 936 } 937 } 938 939 if (!hash_len && end[-17] == EAP_ERP_CS_HMAC_SHA256_128) { 940 if (hmac_sha256(erp->rIK, erp->rIK_len, hdr, 941 end - hdr - 16, hash) < 0) 942 goto fail; 943 if (os_memcmp(end - 16, hash, 16) == 0) { 944 wpa_printf(MSG_DEBUG, 945 "EAP: Authentication Tag match using HMAC-SHA256-128"); 946 hash_len = 16; 947 erp->cryptosuite = EAP_ERP_CS_HMAC_SHA256_128; 948 } 949 } 950 951 if (!hash_len) { 952 wpa_printf(MSG_DEBUG, 953 "EAP: No supported cryptosuite matched Authentication Tag"); 954 goto fail; 955 } 956 end -= 1 + hash_len; 957 958 /* 959 * Parse TVs/TLVs again now that we know the exact part of the buffer 960 * that contains them. 961 */ 962 wpa_hexdump(MSG_DEBUG, "EAP: EAP-Initiate/Re-Auth TVs/TLVs", 963 tlvs, end - tlvs); 964 if (erp_parse_tlvs(tlvs, end, &parse, 0) < 0) 965 goto fail; 966 967 wpa_printf(MSG_DEBUG, "EAP: ERP key %s SEQ updated to %u", 968 erp->keyname_nai, seq); 969 erp->recv_seq = seq; 970 resp_flags &= ~0x80; /* R=0 - success */ 971 972 report_error: 973 erp_send_finish_reauth(sm, erp, ehdr->identifier, resp_flags, seq, nai); 974 return; 975 976 fail: 977 sm->ignore = TRUE; 978 } 979 980 #endif /* CONFIG_ERP */ 981 982 983 SM_STATE(EAP, INITIALIZE_PASSTHROUGH) 984 { 985 SM_ENTRY(EAP, INITIALIZE_PASSTHROUGH); 986 987 wpabuf_free(sm->eap_if.aaaEapRespData); 988 sm->eap_if.aaaEapRespData = NULL; 989 sm->try_initiate_reauth = FALSE; 990 } 991 992 993 SM_STATE(EAP, IDLE2) 994 { 995 SM_ENTRY(EAP, IDLE2); 996 997 sm->eap_if.retransWhile = eap_sm_calculateTimeout( 998 sm, sm->retransCount, sm->eap_if.eapSRTT, sm->eap_if.eapRTTVAR, 999 sm->methodTimeout); 1000 } 1001 1002 1003 SM_STATE(EAP, RETRANSMIT2) 1004 { 1005 SM_ENTRY(EAP, RETRANSMIT2); 1006 1007 sm->retransCount++; 1008 if (sm->retransCount <= sm->MaxRetrans && sm->lastReqData) { 1009 if (eap_copy_buf(&sm->eap_if.eapReqData, sm->lastReqData) == 0) 1010 sm->eap_if.eapReq = TRUE; 1011 } 1012 } 1013 1014 1015 SM_STATE(EAP, RECEIVED2) 1016 { 1017 SM_ENTRY(EAP, RECEIVED2); 1018 1019 /* parse rxResp, respId, respMethod */ 1020 eap_sm_parseEapResp(sm, sm->eap_if.eapRespData); 1021 } 1022 1023 1024 SM_STATE(EAP, DISCARD2) 1025 { 1026 SM_ENTRY(EAP, DISCARD2); 1027 sm->eap_if.eapResp = FALSE; 1028 sm->eap_if.eapNoReq = TRUE; 1029 } 1030 1031 1032 SM_STATE(EAP, SEND_REQUEST2) 1033 { 1034 SM_ENTRY(EAP, SEND_REQUEST2); 1035 1036 sm->retransCount = 0; 1037 if (sm->eap_if.eapReqData) { 1038 if (eap_copy_buf(&sm->lastReqData, sm->eap_if.eapReqData) == 0) 1039 { 1040 sm->eap_if.eapResp = FALSE; 1041 sm->eap_if.eapReq = TRUE; 1042 } else { 1043 sm->eap_if.eapResp = FALSE; 1044 sm->eap_if.eapReq = FALSE; 1045 } 1046 } else { 1047 wpa_printf(MSG_INFO, "EAP: SEND_REQUEST2 - no eapReqData"); 1048 sm->eap_if.eapResp = FALSE; 1049 sm->eap_if.eapReq = FALSE; 1050 sm->eap_if.eapNoReq = TRUE; 1051 } 1052 } 1053 1054 1055 SM_STATE(EAP, AAA_REQUEST) 1056 { 1057 SM_ENTRY(EAP, AAA_REQUEST); 1058 1059 if (sm->eap_if.eapRespData == NULL) { 1060 wpa_printf(MSG_INFO, "EAP: AAA_REQUEST - no eapRespData"); 1061 return; 1062 } 1063 1064 /* 1065 * if (respMethod == IDENTITY) 1066 * aaaIdentity = eapRespData 1067 * This is already taken care of by the EAP-Identity method which 1068 * stores the identity into sm->identity. 1069 */ 1070 1071 eap_copy_buf(&sm->eap_if.aaaEapRespData, sm->eap_if.eapRespData); 1072 } 1073 1074 1075 SM_STATE(EAP, AAA_RESPONSE) 1076 { 1077 SM_ENTRY(EAP, AAA_RESPONSE); 1078 1079 eap_copy_buf(&sm->eap_if.eapReqData, sm->eap_if.aaaEapReqData); 1080 sm->currentId = eap_sm_getId(sm->eap_if.eapReqData); 1081 sm->methodTimeout = sm->eap_if.aaaMethodTimeout; 1082 } 1083 1084 1085 SM_STATE(EAP, AAA_IDLE) 1086 { 1087 SM_ENTRY(EAP, AAA_IDLE); 1088 1089 sm->eap_if.aaaFail = FALSE; 1090 sm->eap_if.aaaSuccess = FALSE; 1091 sm->eap_if.aaaEapReq = FALSE; 1092 sm->eap_if.aaaEapNoReq = FALSE; 1093 sm->eap_if.aaaEapResp = TRUE; 1094 } 1095 1096 1097 SM_STATE(EAP, TIMEOUT_FAILURE2) 1098 { 1099 SM_ENTRY(EAP, TIMEOUT_FAILURE2); 1100 1101 sm->eap_if.eapTimeout = TRUE; 1102 } 1103 1104 1105 SM_STATE(EAP, FAILURE2) 1106 { 1107 SM_ENTRY(EAP, FAILURE2); 1108 1109 eap_copy_buf(&sm->eap_if.eapReqData, sm->eap_if.aaaEapReqData); 1110 sm->eap_if.eapFail = TRUE; 1111 } 1112 1113 1114 SM_STATE(EAP, SUCCESS2) 1115 { 1116 SM_ENTRY(EAP, SUCCESS2); 1117 1118 eap_copy_buf(&sm->eap_if.eapReqData, sm->eap_if.aaaEapReqData); 1119 1120 sm->eap_if.eapKeyAvailable = sm->eap_if.aaaEapKeyAvailable; 1121 if (sm->eap_if.aaaEapKeyAvailable) { 1122 EAP_COPY(&sm->eap_if.eapKeyData, sm->eap_if.aaaEapKeyData); 1123 } else { 1124 bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen); 1125 sm->eap_if.eapKeyData = NULL; 1126 sm->eap_if.eapKeyDataLen = 0; 1127 } 1128 1129 sm->eap_if.eapSuccess = TRUE; 1130 1131 /* 1132 * Start reauthentication with identity request even though we know the 1133 * previously used identity. This is needed to get reauthentication 1134 * started properly. 1135 */ 1136 sm->start_reauth = TRUE; 1137 } 1138 1139 1140 SM_STEP(EAP) 1141 { 1142 if (sm->eap_if.eapRestart && sm->eap_if.portEnabled) 1143 SM_ENTER_GLOBAL(EAP, INITIALIZE); 1144 else if (!sm->eap_if.portEnabled) 1145 SM_ENTER_GLOBAL(EAP, DISABLED); 1146 else if (sm->num_rounds > EAP_MAX_AUTH_ROUNDS) { 1147 if (sm->num_rounds == EAP_MAX_AUTH_ROUNDS + 1) { 1148 wpa_printf(MSG_DEBUG, "EAP: more than %d " 1149 "authentication rounds - abort", 1150 EAP_MAX_AUTH_ROUNDS); 1151 sm->num_rounds++; 1152 SM_ENTER_GLOBAL(EAP, FAILURE); 1153 } 1154 } else switch (sm->EAP_state) { 1155 case EAP_INITIALIZE: 1156 if (sm->backend_auth) { 1157 if (!sm->rxResp) 1158 SM_ENTER(EAP, SELECT_ACTION); 1159 else if (sm->rxResp && 1160 (sm->respMethod == EAP_TYPE_NAK || 1161 (sm->respMethod == EAP_TYPE_EXPANDED && 1162 sm->respVendor == EAP_VENDOR_IETF && 1163 sm->respVendorMethod == EAP_TYPE_NAK))) 1164 SM_ENTER(EAP, NAK); 1165 else 1166 SM_ENTER(EAP, PICK_UP_METHOD); 1167 } else { 1168 SM_ENTER(EAP, SELECT_ACTION); 1169 } 1170 break; 1171 case EAP_PICK_UP_METHOD: 1172 if (sm->currentMethod == EAP_TYPE_NONE) { 1173 SM_ENTER(EAP, SELECT_ACTION); 1174 } else { 1175 SM_ENTER(EAP, METHOD_RESPONSE); 1176 } 1177 break; 1178 case EAP_DISABLED: 1179 if (sm->eap_if.portEnabled) 1180 SM_ENTER(EAP, INITIALIZE); 1181 break; 1182 case EAP_IDLE: 1183 if (sm->eap_if.retransWhile == 0) { 1184 if (sm->try_initiate_reauth) { 1185 sm->try_initiate_reauth = FALSE; 1186 SM_ENTER(EAP, SELECT_ACTION); 1187 } else { 1188 SM_ENTER(EAP, RETRANSMIT); 1189 } 1190 } else if (sm->eap_if.eapResp) 1191 SM_ENTER(EAP, RECEIVED); 1192 break; 1193 case EAP_RETRANSMIT: 1194 if (sm->retransCount > sm->MaxRetrans) 1195 SM_ENTER(EAP, TIMEOUT_FAILURE); 1196 else 1197 SM_ENTER(EAP, IDLE); 1198 break; 1199 case EAP_RECEIVED: 1200 if (sm->rxResp && (sm->respId == sm->currentId) && 1201 (sm->respMethod == EAP_TYPE_NAK || 1202 (sm->respMethod == EAP_TYPE_EXPANDED && 1203 sm->respVendor == EAP_VENDOR_IETF && 1204 sm->respVendorMethod == EAP_TYPE_NAK)) 1205 && (sm->methodState == METHOD_PROPOSED)) 1206 SM_ENTER(EAP, NAK); 1207 else if (sm->rxResp && (sm->respId == sm->currentId) && 1208 ((sm->respMethod == sm->currentMethod) || 1209 (sm->respMethod == EAP_TYPE_EXPANDED && 1210 sm->respVendor == EAP_VENDOR_IETF && 1211 sm->respVendorMethod == sm->currentMethod))) 1212 SM_ENTER(EAP, INTEGRITY_CHECK); 1213 #ifdef CONFIG_ERP 1214 else if (sm->rxInitiate) 1215 SM_ENTER(EAP, INITIATE_RECEIVED); 1216 #endif /* CONFIG_ERP */ 1217 else { 1218 wpa_printf(MSG_DEBUG, "EAP: RECEIVED->DISCARD: " 1219 "rxResp=%d respId=%d currentId=%d " 1220 "respMethod=%d currentMethod=%d", 1221 sm->rxResp, sm->respId, sm->currentId, 1222 sm->respMethod, sm->currentMethod); 1223 eap_log_msg(sm, "Discard received EAP message"); 1224 SM_ENTER(EAP, DISCARD); 1225 } 1226 break; 1227 case EAP_DISCARD: 1228 SM_ENTER(EAP, IDLE); 1229 break; 1230 case EAP_SEND_REQUEST: 1231 SM_ENTER(EAP, IDLE); 1232 break; 1233 case EAP_INTEGRITY_CHECK: 1234 if (sm->ignore) 1235 SM_ENTER(EAP, DISCARD); 1236 else 1237 SM_ENTER(EAP, METHOD_RESPONSE); 1238 break; 1239 case EAP_METHOD_REQUEST: 1240 if (sm->m == NULL) { 1241 /* 1242 * This transition is not mentioned in RFC 4137, but it 1243 * is needed to handle cleanly a case where EAP method 1244 * initialization fails. 1245 */ 1246 SM_ENTER(EAP, FAILURE); 1247 break; 1248 } 1249 SM_ENTER(EAP, SEND_REQUEST); 1250 if (sm->eap_if.eapNoReq && !sm->eap_if.eapReq) { 1251 /* 1252 * This transition is not mentioned in RFC 4137, but it 1253 * is needed to handle cleanly a case where EAP method 1254 * buildReq fails. 1255 */ 1256 wpa_printf(MSG_DEBUG, 1257 "EAP: Method did not return a request"); 1258 SM_ENTER(EAP, FAILURE); 1259 break; 1260 } 1261 break; 1262 case EAP_METHOD_RESPONSE: 1263 /* 1264 * Note: Mechanism to allow EAP methods to wait while going 1265 * through pending processing is an extension to RFC 4137 1266 * which only defines the transits to SELECT_ACTION and 1267 * METHOD_REQUEST from this METHOD_RESPONSE state. 1268 */ 1269 if (sm->methodState == METHOD_END) 1270 SM_ENTER(EAP, SELECT_ACTION); 1271 else if (sm->method_pending == METHOD_PENDING_WAIT) { 1272 wpa_printf(MSG_DEBUG, "EAP: Method has pending " 1273 "processing - wait before proceeding to " 1274 "METHOD_REQUEST state"); 1275 } else if (sm->method_pending == METHOD_PENDING_CONT) { 1276 wpa_printf(MSG_DEBUG, "EAP: Method has completed " 1277 "pending processing - reprocess pending " 1278 "EAP message"); 1279 sm->method_pending = METHOD_PENDING_NONE; 1280 SM_ENTER(EAP, METHOD_RESPONSE); 1281 } else 1282 SM_ENTER(EAP, METHOD_REQUEST); 1283 break; 1284 case EAP_PROPOSE_METHOD: 1285 /* 1286 * Note: Mechanism to allow EAP methods to wait while going 1287 * through pending processing is an extension to RFC 4137 1288 * which only defines the transit to METHOD_REQUEST from this 1289 * PROPOSE_METHOD state. 1290 */ 1291 if (sm->method_pending == METHOD_PENDING_WAIT) { 1292 wpa_printf(MSG_DEBUG, "EAP: Method has pending " 1293 "processing - wait before proceeding to " 1294 "METHOD_REQUEST state"); 1295 if (sm->user_eap_method_index > 0) 1296 sm->user_eap_method_index--; 1297 } else if (sm->method_pending == METHOD_PENDING_CONT) { 1298 wpa_printf(MSG_DEBUG, "EAP: Method has completed " 1299 "pending processing - reprocess pending " 1300 "EAP message"); 1301 sm->method_pending = METHOD_PENDING_NONE; 1302 SM_ENTER(EAP, PROPOSE_METHOD); 1303 } else 1304 SM_ENTER(EAP, METHOD_REQUEST); 1305 break; 1306 case EAP_NAK: 1307 SM_ENTER(EAP, SELECT_ACTION); 1308 break; 1309 case EAP_SELECT_ACTION: 1310 if (sm->decision == DECISION_FAILURE) 1311 SM_ENTER(EAP, FAILURE); 1312 else if (sm->decision == DECISION_SUCCESS) 1313 SM_ENTER(EAP, SUCCESS); 1314 else if (sm->decision == DECISION_PASSTHROUGH) 1315 SM_ENTER(EAP, INITIALIZE_PASSTHROUGH); 1316 else if (sm->decision == DECISION_INITIATE_REAUTH_START) 1317 SM_ENTER(EAP, INITIATE_REAUTH_START); 1318 #ifdef CONFIG_ERP 1319 else if (sm->eap_server && sm->erp && sm->rxInitiate) 1320 SM_ENTER(EAP, INITIATE_RECEIVED); 1321 #endif /* CONFIG_ERP */ 1322 else 1323 SM_ENTER(EAP, PROPOSE_METHOD); 1324 break; 1325 case EAP_INITIATE_REAUTH_START: 1326 SM_ENTER(EAP, SEND_REQUEST); 1327 break; 1328 case EAP_INITIATE_RECEIVED: 1329 if (!sm->eap_server) 1330 SM_ENTER(EAP, SELECT_ACTION); 1331 break; 1332 case EAP_TIMEOUT_FAILURE: 1333 break; 1334 case EAP_FAILURE: 1335 break; 1336 case EAP_SUCCESS: 1337 break; 1338 1339 case EAP_INITIALIZE_PASSTHROUGH: 1340 if (sm->currentId == -1) 1341 SM_ENTER(EAP, AAA_IDLE); 1342 else 1343 SM_ENTER(EAP, AAA_REQUEST); 1344 break; 1345 case EAP_IDLE2: 1346 if (sm->eap_if.eapResp) 1347 SM_ENTER(EAP, RECEIVED2); 1348 else if (sm->eap_if.retransWhile == 0) 1349 SM_ENTER(EAP, RETRANSMIT2); 1350 break; 1351 case EAP_RETRANSMIT2: 1352 if (sm->retransCount > sm->MaxRetrans) 1353 SM_ENTER(EAP, TIMEOUT_FAILURE2); 1354 else 1355 SM_ENTER(EAP, IDLE2); 1356 break; 1357 case EAP_RECEIVED2: 1358 if (sm->rxResp && (sm->respId == sm->currentId)) 1359 SM_ENTER(EAP, AAA_REQUEST); 1360 else 1361 SM_ENTER(EAP, DISCARD2); 1362 break; 1363 case EAP_DISCARD2: 1364 SM_ENTER(EAP, IDLE2); 1365 break; 1366 case EAP_SEND_REQUEST2: 1367 SM_ENTER(EAP, IDLE2); 1368 break; 1369 case EAP_AAA_REQUEST: 1370 SM_ENTER(EAP, AAA_IDLE); 1371 break; 1372 case EAP_AAA_RESPONSE: 1373 SM_ENTER(EAP, SEND_REQUEST2); 1374 break; 1375 case EAP_AAA_IDLE: 1376 if (sm->eap_if.aaaFail) 1377 SM_ENTER(EAP, FAILURE2); 1378 else if (sm->eap_if.aaaSuccess) 1379 SM_ENTER(EAP, SUCCESS2); 1380 else if (sm->eap_if.aaaEapReq) 1381 SM_ENTER(EAP, AAA_RESPONSE); 1382 else if (sm->eap_if.aaaTimeout) 1383 SM_ENTER(EAP, TIMEOUT_FAILURE2); 1384 break; 1385 case EAP_TIMEOUT_FAILURE2: 1386 break; 1387 case EAP_FAILURE2: 1388 break; 1389 case EAP_SUCCESS2: 1390 break; 1391 } 1392 } 1393 1394 1395 static int eap_sm_calculateTimeout(struct eap_sm *sm, int retransCount, 1396 int eapSRTT, int eapRTTVAR, 1397 int methodTimeout) 1398 { 1399 int rto, i; 1400 1401 if (sm->try_initiate_reauth) { 1402 wpa_printf(MSG_DEBUG, 1403 "EAP: retransmit timeout 1 second for EAP-Initiate-Re-auth-Start"); 1404 return 1; 1405 } 1406 1407 if (methodTimeout) { 1408 /* 1409 * EAP method (either internal or through AAA server, provided 1410 * timeout hint. Use that as-is as a timeout for retransmitting 1411 * the EAP request if no response is received. 1412 */ 1413 wpa_printf(MSG_DEBUG, "EAP: retransmit timeout %d seconds " 1414 "(from EAP method hint)", methodTimeout); 1415 return methodTimeout; 1416 } 1417 1418 /* 1419 * RFC 3748 recommends algorithms described in RFC 2988 for estimation 1420 * of the retransmission timeout. This should be implemented once 1421 * round-trip time measurements are available. For nowm a simple 1422 * backoff mechanism is used instead if there are no EAP method 1423 * specific hints. 1424 * 1425 * SRTT = smoothed round-trip time 1426 * RTTVAR = round-trip time variation 1427 * RTO = retransmission timeout 1428 */ 1429 1430 /* 1431 * RFC 2988, 2.1: before RTT measurement, set RTO to 3 seconds for 1432 * initial retransmission and then double the RTO to provide back off 1433 * per 5.5. Limit the maximum RTO to 20 seconds per RFC 3748, 4.3 1434 * modified RTOmax. 1435 */ 1436 rto = 3; 1437 for (i = 0; i < retransCount; i++) { 1438 rto *= 2; 1439 if (rto >= 20) { 1440 rto = 20; 1441 break; 1442 } 1443 } 1444 1445 wpa_printf(MSG_DEBUG, "EAP: retransmit timeout %d seconds " 1446 "(from dynamic back off; retransCount=%d)", 1447 rto, retransCount); 1448 1449 return rto; 1450 } 1451 1452 1453 static void eap_sm_parseEapResp(struct eap_sm *sm, const struct wpabuf *resp) 1454 { 1455 const struct eap_hdr *hdr; 1456 size_t plen; 1457 1458 /* parse rxResp, respId, respMethod */ 1459 sm->rxResp = FALSE; 1460 sm->rxInitiate = FALSE; 1461 sm->respId = -1; 1462 sm->respMethod = EAP_TYPE_NONE; 1463 sm->respVendor = EAP_VENDOR_IETF; 1464 sm->respVendorMethod = EAP_TYPE_NONE; 1465 1466 if (resp == NULL || wpabuf_len(resp) < sizeof(*hdr)) { 1467 wpa_printf(MSG_DEBUG, "EAP: parseEapResp: invalid resp=%p " 1468 "len=%lu", resp, 1469 resp ? (unsigned long) wpabuf_len(resp) : 0); 1470 return; 1471 } 1472 1473 hdr = wpabuf_head(resp); 1474 plen = be_to_host16(hdr->length); 1475 if (plen > wpabuf_len(resp)) { 1476 wpa_printf(MSG_DEBUG, "EAP: Ignored truncated EAP-Packet " 1477 "(len=%lu plen=%lu)", 1478 (unsigned long) wpabuf_len(resp), 1479 (unsigned long) plen); 1480 return; 1481 } 1482 1483 sm->respId = hdr->identifier; 1484 1485 if (hdr->code == EAP_CODE_RESPONSE) 1486 sm->rxResp = TRUE; 1487 else if (hdr->code == EAP_CODE_INITIATE) 1488 sm->rxInitiate = TRUE; 1489 1490 if (plen > sizeof(*hdr)) { 1491 u8 *pos = (u8 *) (hdr + 1); 1492 sm->respMethod = *pos++; 1493 if (sm->respMethod == EAP_TYPE_EXPANDED) { 1494 if (plen < sizeof(*hdr) + 8) { 1495 wpa_printf(MSG_DEBUG, "EAP: Ignored truncated " 1496 "expanded EAP-Packet (plen=%lu)", 1497 (unsigned long) plen); 1498 return; 1499 } 1500 sm->respVendor = WPA_GET_BE24(pos); 1501 pos += 3; 1502 sm->respVendorMethod = WPA_GET_BE32(pos); 1503 } 1504 } 1505 1506 wpa_printf(MSG_DEBUG, 1507 "EAP: parseEapResp: rxResp=%d rxInitiate=%d respId=%d respMethod=%u respVendor=%u respVendorMethod=%u", 1508 sm->rxResp, sm->rxInitiate, sm->respId, sm->respMethod, 1509 sm->respVendor, sm->respVendorMethod); 1510 } 1511 1512 1513 static int eap_sm_getId(const struct wpabuf *data) 1514 { 1515 const struct eap_hdr *hdr; 1516 1517 if (data == NULL || wpabuf_len(data) < sizeof(*hdr)) 1518 return -1; 1519 1520 hdr = wpabuf_head(data); 1521 wpa_printf(MSG_DEBUG, "EAP: getId: id=%d", hdr->identifier); 1522 return hdr->identifier; 1523 } 1524 1525 1526 static struct wpabuf * eap_sm_buildSuccess(struct eap_sm *sm, u8 id) 1527 { 1528 struct wpabuf *msg; 1529 struct eap_hdr *resp; 1530 wpa_printf(MSG_DEBUG, "EAP: Building EAP-Success (id=%d)", id); 1531 1532 msg = wpabuf_alloc(sizeof(*resp)); 1533 if (msg == NULL) 1534 return NULL; 1535 resp = wpabuf_put(msg, sizeof(*resp)); 1536 resp->code = EAP_CODE_SUCCESS; 1537 resp->identifier = id; 1538 resp->length = host_to_be16(sizeof(*resp)); 1539 1540 return msg; 1541 } 1542 1543 1544 static struct wpabuf * eap_sm_buildFailure(struct eap_sm *sm, u8 id) 1545 { 1546 struct wpabuf *msg; 1547 struct eap_hdr *resp; 1548 wpa_printf(MSG_DEBUG, "EAP: Building EAP-Failure (id=%d)", id); 1549 1550 msg = wpabuf_alloc(sizeof(*resp)); 1551 if (msg == NULL) 1552 return NULL; 1553 resp = wpabuf_put(msg, sizeof(*resp)); 1554 resp->code = EAP_CODE_FAILURE; 1555 resp->identifier = id; 1556 resp->length = host_to_be16(sizeof(*resp)); 1557 1558 return msg; 1559 } 1560 1561 1562 static int eap_sm_nextId(struct eap_sm *sm, int id) 1563 { 1564 if (id < 0) { 1565 /* RFC 3748 Ch 4.1: recommended to initialize Identifier with a 1566 * random number */ 1567 id = rand() & 0xff; 1568 if (id != sm->lastId) 1569 return id; 1570 } 1571 return (id + 1) & 0xff; 1572 } 1573 1574 1575 /** 1576 * eap_sm_process_nak - Process EAP-Response/Nak 1577 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init() 1578 * @nak_list: Nak list (allowed methods) from the supplicant 1579 * @len: Length of nak_list in bytes 1580 * 1581 * This function is called when EAP-Response/Nak is received from the 1582 * supplicant. This can happen for both phase 1 and phase 2 authentications. 1583 */ 1584 void eap_sm_process_nak(struct eap_sm *sm, const u8 *nak_list, size_t len) 1585 { 1586 int i; 1587 size_t j; 1588 1589 if (sm->user == NULL) 1590 return; 1591 1592 wpa_printf(MSG_MSGDUMP, "EAP: processing NAK (current EAP method " 1593 "index %d)", sm->user_eap_method_index); 1594 1595 wpa_hexdump(MSG_MSGDUMP, "EAP: configured methods", 1596 (u8 *) sm->user->methods, 1597 EAP_MAX_METHODS * sizeof(sm->user->methods[0])); 1598 wpa_hexdump(MSG_MSGDUMP, "EAP: list of methods supported by the peer", 1599 nak_list, len); 1600 1601 i = sm->user_eap_method_index; 1602 while (i < EAP_MAX_METHODS && 1603 (sm->user->methods[i].vendor != EAP_VENDOR_IETF || 1604 sm->user->methods[i].method != EAP_TYPE_NONE)) { 1605 if (sm->user->methods[i].vendor != EAP_VENDOR_IETF) 1606 goto not_found; 1607 for (j = 0; j < len; j++) { 1608 if (nak_list[j] == sm->user->methods[i].method) { 1609 break; 1610 } 1611 } 1612 1613 if (j < len) { 1614 /* found */ 1615 i++; 1616 continue; 1617 } 1618 1619 not_found: 1620 /* not found - remove from the list */ 1621 if (i + 1 < EAP_MAX_METHODS) { 1622 os_memmove(&sm->user->methods[i], 1623 &sm->user->methods[i + 1], 1624 (EAP_MAX_METHODS - i - 1) * 1625 sizeof(sm->user->methods[0])); 1626 } 1627 sm->user->methods[EAP_MAX_METHODS - 1].vendor = 1628 EAP_VENDOR_IETF; 1629 sm->user->methods[EAP_MAX_METHODS - 1].method = EAP_TYPE_NONE; 1630 } 1631 1632 wpa_hexdump(MSG_MSGDUMP, "EAP: new list of configured methods", 1633 (u8 *) sm->user->methods, EAP_MAX_METHODS * 1634 sizeof(sm->user->methods[0])); 1635 } 1636 1637 1638 static void eap_sm_Policy_update(struct eap_sm *sm, const u8 *nak_list, 1639 size_t len) 1640 { 1641 if (nak_list == NULL || sm == NULL || sm->user == NULL) 1642 return; 1643 1644 if (sm->user->phase2) { 1645 wpa_printf(MSG_DEBUG, "EAP: EAP-Nak received after Phase2 user" 1646 " info was selected - reject"); 1647 sm->decision = DECISION_FAILURE; 1648 return; 1649 } 1650 1651 eap_sm_process_nak(sm, nak_list, len); 1652 } 1653 1654 1655 static EapType eap_sm_Policy_getNextMethod(struct eap_sm *sm, int *vendor) 1656 { 1657 EapType next; 1658 int idx = sm->user_eap_method_index; 1659 1660 /* In theory, there should be no problems with starting 1661 * re-authentication with something else than EAP-Request/Identity and 1662 * this does indeed work with wpa_supplicant. However, at least Funk 1663 * Supplicant seemed to ignore re-auth if it skipped 1664 * EAP-Request/Identity. 1665 * Re-auth sets currentId == -1, so that can be used here to select 1666 * whether Identity needs to be requested again. */ 1667 if (sm->identity == NULL || sm->currentId == -1) { 1668 *vendor = EAP_VENDOR_IETF; 1669 next = EAP_TYPE_IDENTITY; 1670 sm->update_user = TRUE; 1671 } else if (sm->user && idx < EAP_MAX_METHODS && 1672 (sm->user->methods[idx].vendor != EAP_VENDOR_IETF || 1673 sm->user->methods[idx].method != EAP_TYPE_NONE)) { 1674 *vendor = sm->user->methods[idx].vendor; 1675 next = sm->user->methods[idx].method; 1676 sm->user_eap_method_index++; 1677 } else { 1678 *vendor = EAP_VENDOR_IETF; 1679 next = EAP_TYPE_NONE; 1680 } 1681 wpa_printf(MSG_DEBUG, "EAP: getNextMethod: vendor %d type %d", 1682 *vendor, next); 1683 return next; 1684 } 1685 1686 1687 static int eap_sm_Policy_getDecision(struct eap_sm *sm) 1688 { 1689 if (!sm->eap_server && sm->identity && !sm->start_reauth) { 1690 wpa_printf(MSG_DEBUG, "EAP: getDecision: -> PASSTHROUGH"); 1691 return DECISION_PASSTHROUGH; 1692 } 1693 1694 if (sm->m && sm->currentMethod != EAP_TYPE_IDENTITY && 1695 sm->m->isSuccess(sm, sm->eap_method_priv)) { 1696 wpa_printf(MSG_DEBUG, "EAP: getDecision: method succeeded -> " 1697 "SUCCESS"); 1698 sm->update_user = TRUE; 1699 return DECISION_SUCCESS; 1700 } 1701 1702 if (sm->m && sm->m->isDone(sm, sm->eap_method_priv) && 1703 !sm->m->isSuccess(sm, sm->eap_method_priv)) { 1704 wpa_printf(MSG_DEBUG, "EAP: getDecision: method failed -> " 1705 "FAILURE"); 1706 sm->update_user = TRUE; 1707 return DECISION_FAILURE; 1708 } 1709 1710 if ((sm->user == NULL || sm->update_user) && sm->identity && 1711 !sm->start_reauth) { 1712 /* 1713 * Allow Identity method to be started once to allow identity 1714 * selection hint to be sent from the authentication server, 1715 * but prevent a loop of Identity requests by only allowing 1716 * this to happen once. 1717 */ 1718 int id_req = 0; 1719 if (sm->user && sm->currentMethod == EAP_TYPE_IDENTITY && 1720 sm->user->methods[0].vendor == EAP_VENDOR_IETF && 1721 sm->user->methods[0].method == EAP_TYPE_IDENTITY) 1722 id_req = 1; 1723 if (eap_user_get(sm, sm->identity, sm->identity_len, 0) != 0) { 1724 wpa_printf(MSG_DEBUG, "EAP: getDecision: user not " 1725 "found from database -> FAILURE"); 1726 return DECISION_FAILURE; 1727 } 1728 if (id_req && sm->user && 1729 sm->user->methods[0].vendor == EAP_VENDOR_IETF && 1730 sm->user->methods[0].method == EAP_TYPE_IDENTITY) { 1731 wpa_printf(MSG_DEBUG, "EAP: getDecision: stop " 1732 "identity request loop -> FAILURE"); 1733 sm->update_user = TRUE; 1734 return DECISION_FAILURE; 1735 } 1736 sm->update_user = FALSE; 1737 } 1738 sm->start_reauth = FALSE; 1739 1740 if (sm->user && sm->user_eap_method_index < EAP_MAX_METHODS && 1741 (sm->user->methods[sm->user_eap_method_index].vendor != 1742 EAP_VENDOR_IETF || 1743 sm->user->methods[sm->user_eap_method_index].method != 1744 EAP_TYPE_NONE)) { 1745 wpa_printf(MSG_DEBUG, "EAP: getDecision: another method " 1746 "available -> CONTINUE"); 1747 return DECISION_CONTINUE; 1748 } 1749 1750 if (!sm->identity && eap_get_erp_send_reauth_start(sm) && 1751 !sm->initiate_reauth_start_sent) { 1752 wpa_printf(MSG_DEBUG, 1753 "EAP: getDecision: send EAP-Initiate/Re-auth-Start"); 1754 return DECISION_INITIATE_REAUTH_START; 1755 } 1756 1757 if (sm->identity == NULL || sm->currentId == -1) { 1758 wpa_printf(MSG_DEBUG, "EAP: getDecision: no identity known " 1759 "yet -> CONTINUE"); 1760 return DECISION_CONTINUE; 1761 } 1762 1763 wpa_printf(MSG_DEBUG, "EAP: getDecision: no more methods available -> " 1764 "FAILURE"); 1765 return DECISION_FAILURE; 1766 } 1767 1768 1769 static Boolean eap_sm_Policy_doPickUp(struct eap_sm *sm, EapType method) 1770 { 1771 return method == EAP_TYPE_IDENTITY ? TRUE : FALSE; 1772 } 1773 1774 1775 /** 1776 * eap_server_sm_step - Step EAP server state machine 1777 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init() 1778 * Returns: 1 if EAP state was changed or 0 if not 1779 * 1780 * This function advances EAP state machine to a new state to match with the 1781 * current variables. This should be called whenever variables used by the EAP 1782 * state machine have changed. 1783 */ 1784 int eap_server_sm_step(struct eap_sm *sm) 1785 { 1786 int res = 0; 1787 do { 1788 sm->changed = FALSE; 1789 SM_STEP_RUN(EAP); 1790 if (sm->changed) 1791 res = 1; 1792 } while (sm->changed); 1793 return res; 1794 } 1795 1796 1797 static void eap_user_free(struct eap_user *user) 1798 { 1799 if (user == NULL) 1800 return; 1801 bin_clear_free(user->password, user->password_len); 1802 user->password = NULL; 1803 os_free(user); 1804 } 1805 1806 1807 /** 1808 * eap_server_sm_init - Allocate and initialize EAP server state machine 1809 * @eapol_ctx: Context data to be used with eapol_cb calls 1810 * @eapol_cb: Pointer to EAPOL callback functions 1811 * @conf: EAP configuration 1812 * Returns: Pointer to the allocated EAP state machine or %NULL on failure 1813 * 1814 * This function allocates and initializes an EAP state machine. 1815 */ 1816 struct eap_sm * eap_server_sm_init(void *eapol_ctx, 1817 const struct eapol_callbacks *eapol_cb, 1818 struct eap_config *conf) 1819 { 1820 struct eap_sm *sm; 1821 1822 sm = os_zalloc(sizeof(*sm)); 1823 if (sm == NULL) 1824 return NULL; 1825 sm->eapol_ctx = eapol_ctx; 1826 sm->eapol_cb = eapol_cb; 1827 sm->MaxRetrans = 5; /* RFC 3748: max 3-5 retransmissions suggested */ 1828 sm->ssl_ctx = conf->ssl_ctx; 1829 sm->msg_ctx = conf->msg_ctx; 1830 sm->eap_sim_db_priv = conf->eap_sim_db_priv; 1831 sm->backend_auth = conf->backend_auth; 1832 sm->eap_server = conf->eap_server; 1833 if (conf->pac_opaque_encr_key) { 1834 sm->pac_opaque_encr_key = os_malloc(16); 1835 if (sm->pac_opaque_encr_key) { 1836 os_memcpy(sm->pac_opaque_encr_key, 1837 conf->pac_opaque_encr_key, 16); 1838 } 1839 } 1840 if (conf->eap_fast_a_id) { 1841 sm->eap_fast_a_id = os_malloc(conf->eap_fast_a_id_len); 1842 if (sm->eap_fast_a_id) { 1843 os_memcpy(sm->eap_fast_a_id, conf->eap_fast_a_id, 1844 conf->eap_fast_a_id_len); 1845 sm->eap_fast_a_id_len = conf->eap_fast_a_id_len; 1846 } 1847 } 1848 if (conf->eap_fast_a_id_info) 1849 sm->eap_fast_a_id_info = os_strdup(conf->eap_fast_a_id_info); 1850 sm->eap_fast_prov = conf->eap_fast_prov; 1851 sm->pac_key_lifetime = conf->pac_key_lifetime; 1852 sm->pac_key_refresh_time = conf->pac_key_refresh_time; 1853 sm->eap_sim_aka_result_ind = conf->eap_sim_aka_result_ind; 1854 sm->tnc = conf->tnc; 1855 sm->wps = conf->wps; 1856 if (conf->assoc_wps_ie) 1857 sm->assoc_wps_ie = wpabuf_dup(conf->assoc_wps_ie); 1858 if (conf->assoc_p2p_ie) 1859 sm->assoc_p2p_ie = wpabuf_dup(conf->assoc_p2p_ie); 1860 if (conf->peer_addr) 1861 os_memcpy(sm->peer_addr, conf->peer_addr, ETH_ALEN); 1862 sm->fragment_size = conf->fragment_size; 1863 sm->pwd_group = conf->pwd_group; 1864 sm->pbc_in_m1 = conf->pbc_in_m1; 1865 sm->server_id = conf->server_id; 1866 sm->server_id_len = conf->server_id_len; 1867 sm->erp = conf->erp; 1868 sm->tls_session_lifetime = conf->tls_session_lifetime; 1869 1870 #ifdef CONFIG_TESTING_OPTIONS 1871 sm->tls_test_flags = conf->tls_test_flags; 1872 #endif /* CONFIG_TESTING_OPTIONS */ 1873 1874 wpa_printf(MSG_DEBUG, "EAP: Server state machine created"); 1875 1876 return sm; 1877 } 1878 1879 1880 /** 1881 * eap_server_sm_deinit - Deinitialize and free an EAP server state machine 1882 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init() 1883 * 1884 * This function deinitializes EAP state machine and frees all allocated 1885 * resources. 1886 */ 1887 void eap_server_sm_deinit(struct eap_sm *sm) 1888 { 1889 if (sm == NULL) 1890 return; 1891 wpa_printf(MSG_DEBUG, "EAP: Server state machine removed"); 1892 if (sm->m && sm->eap_method_priv) 1893 sm->m->reset(sm, sm->eap_method_priv); 1894 wpabuf_free(sm->eap_if.eapReqData); 1895 bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen); 1896 os_free(sm->eap_if.eapSessionId); 1897 wpabuf_free(sm->lastReqData); 1898 wpabuf_free(sm->eap_if.eapRespData); 1899 os_free(sm->identity); 1900 os_free(sm->pac_opaque_encr_key); 1901 os_free(sm->eap_fast_a_id); 1902 os_free(sm->eap_fast_a_id_info); 1903 wpabuf_free(sm->eap_if.aaaEapReqData); 1904 wpabuf_free(sm->eap_if.aaaEapRespData); 1905 bin_clear_free(sm->eap_if.aaaEapKeyData, sm->eap_if.aaaEapKeyDataLen); 1906 eap_user_free(sm->user); 1907 wpabuf_free(sm->assoc_wps_ie); 1908 wpabuf_free(sm->assoc_p2p_ie); 1909 os_free(sm); 1910 } 1911 1912 1913 /** 1914 * eap_sm_notify_cached - Notify EAP state machine of cached PMK 1915 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init() 1916 * 1917 * This function is called when PMKSA caching is used to skip EAP 1918 * authentication. 1919 */ 1920 void eap_sm_notify_cached(struct eap_sm *sm) 1921 { 1922 if (sm == NULL) 1923 return; 1924 1925 sm->EAP_state = EAP_SUCCESS; 1926 } 1927 1928 1929 /** 1930 * eap_sm_pending_cb - EAP state machine callback for a pending EAP request 1931 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init() 1932 * 1933 * This function is called when data for a pending EAP-Request is received. 1934 */ 1935 void eap_sm_pending_cb(struct eap_sm *sm) 1936 { 1937 if (sm == NULL) 1938 return; 1939 wpa_printf(MSG_DEBUG, "EAP: Callback for pending request received"); 1940 if (sm->method_pending == METHOD_PENDING_WAIT) 1941 sm->method_pending = METHOD_PENDING_CONT; 1942 } 1943 1944 1945 /** 1946 * eap_sm_method_pending - Query whether EAP method is waiting for pending data 1947 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init() 1948 * Returns: 1 if method is waiting for pending data or 0 if not 1949 */ 1950 int eap_sm_method_pending(struct eap_sm *sm) 1951 { 1952 if (sm == NULL) 1953 return 0; 1954 return sm->method_pending == METHOD_PENDING_WAIT; 1955 } 1956 1957 1958 /** 1959 * eap_get_identity - Get the user identity (from EAP-Response/Identity) 1960 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init() 1961 * @len: Buffer for returning identity length 1962 * Returns: Pointer to the user identity or %NULL if not available 1963 */ 1964 const u8 * eap_get_identity(struct eap_sm *sm, size_t *len) 1965 { 1966 *len = sm->identity_len; 1967 return sm->identity; 1968 } 1969 1970 1971 /** 1972 * eap_get_interface - Get pointer to EAP-EAPOL interface data 1973 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init() 1974 * Returns: Pointer to the EAP-EAPOL interface data 1975 */ 1976 struct eap_eapol_interface * eap_get_interface(struct eap_sm *sm) 1977 { 1978 return &sm->eap_if; 1979 } 1980 1981 1982 /** 1983 * eap_server_clear_identity - Clear EAP identity information 1984 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init() 1985 * 1986 * This function can be used to clear the EAP identity information in the EAP 1987 * server context. This allows the EAP/Identity method to be used again after 1988 * EAPOL-Start or EAPOL-Logoff. 1989 */ 1990 void eap_server_clear_identity(struct eap_sm *sm) 1991 { 1992 os_free(sm->identity); 1993 sm->identity = NULL; 1994 } 1995 1996 1997 #ifdef CONFIG_TESTING_OPTIONS 1998 void eap_server_mschap_rx_callback(struct eap_sm *sm, const char *source, 1999 const u8 *username, size_t username_len, 2000 const u8 *challenge, const u8 *response) 2001 { 2002 char hex_challenge[30], hex_response[90], user[100]; 2003 2004 /* Print out Challenge and Response in format supported by asleap. */ 2005 if (username) 2006 printf_encode(user, sizeof(user), username, username_len); 2007 else 2008 user[0] = '\0'; 2009 wpa_snprintf_hex_sep(hex_challenge, sizeof(hex_challenge), 2010 challenge, sizeof(challenge), ':'); 2011 wpa_snprintf_hex_sep(hex_response, sizeof(hex_response), response, 24, 2012 ':'); 2013 wpa_printf(MSG_DEBUG, "[%s/user=%s] asleap -C %s -R %s", 2014 source, user, hex_challenge, hex_response); 2015 } 2016 #endif /* CONFIG_TESTING_OPTIONS */ 2017