1/* 2 * hostapd / EAP-SIM (RFC 4186) 3 * Copyright (c) 2005-2008, Jouni Malinen <j@w1.fi> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 as 7 * published by the Free Software Foundation. 8 * 9 * Alternatively, this software may be distributed under the terms of BSD 10 * license. 11 * 12 * See README and COPYING for more details. 13 */ 14 15#include "includes.h" 16 17#include "common.h" 18#include "eap_server/eap_i.h" 19#include "eap_common/eap_sim_common.h" 20#include "eap_server/eap_sim_db.h" 21 22 23struct eap_sim_data { 24 u8 mk[EAP_SIM_MK_LEN]; 25 u8 nonce_mt[EAP_SIM_NONCE_MT_LEN]; 26 u8 nonce_s[EAP_SIM_NONCE_S_LEN]; 27 u8 k_aut[EAP_SIM_K_AUT_LEN]; 28 u8 k_encr[EAP_SIM_K_ENCR_LEN]; 29 u8 msk[EAP_SIM_KEYING_DATA_LEN]; 30 u8 emsk[EAP_EMSK_LEN]; 31 u8 kc[EAP_SIM_MAX_CHAL][EAP_SIM_KC_LEN]; 32 u8 sres[EAP_SIM_MAX_CHAL][EAP_SIM_SRES_LEN]; 33 u8 rand[EAP_SIM_MAX_CHAL][GSM_RAND_LEN]; 34 int num_chal; 35 enum { 36 START, CHALLENGE, REAUTH, NOTIFICATION, SUCCESS, FAILURE 37 } state; 38 char *next_pseudonym; 39 char *next_reauth_id; 40 u16 counter; 41 struct eap_sim_reauth *reauth; 42 u16 notification; 43 int use_result_ind; 44}; 45 46 47static const char * eap_sim_state_txt(int state) 48{ 49 switch (state) { 50 case START: 51 return "START"; 52 case CHALLENGE: 53 return "CHALLENGE"; 54 case REAUTH: 55 return "REAUTH"; 56 case SUCCESS: 57 return "SUCCESS"; 58 case FAILURE: 59 return "FAILURE"; 60 case NOTIFICATION: 61 return "NOTIFICATION"; 62 default: 63 return "Unknown?!"; 64 } 65} 66 67 68static void eap_sim_state(struct eap_sim_data *data, int state) 69{ 70 wpa_printf(MSG_DEBUG, "EAP-SIM: %s -> %s", 71 eap_sim_state_txt(data->state), 72 eap_sim_state_txt(state)); 73 data->state = state; 74} 75 76 77static void * eap_sim_init(struct eap_sm *sm) 78{ 79 struct eap_sim_data *data; 80 81 if (sm->eap_sim_db_priv == NULL) { 82 wpa_printf(MSG_WARNING, "EAP-SIM: eap_sim_db not configured"); 83 return NULL; 84 } 85 86 data = os_zalloc(sizeof(*data)); 87 if (data == NULL) 88 return NULL; 89 data->state = START; 90 91 return data; 92} 93 94 95static void eap_sim_reset(struct eap_sm *sm, void *priv) 96{ 97 struct eap_sim_data *data = priv; 98 os_free(data->next_pseudonym); 99 os_free(data->next_reauth_id); 100 os_free(data); 101} 102 103 104static struct wpabuf * eap_sim_build_start(struct eap_sm *sm, 105 struct eap_sim_data *data, u8 id) 106{ 107 struct eap_sim_msg *msg; 108 u8 ver[2]; 109 110 wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Start"); 111 msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM, 112 EAP_SIM_SUBTYPE_START); 113 if (eap_sim_db_identity_known(sm->eap_sim_db_priv, sm->identity, 114 sm->identity_len)) { 115 wpa_printf(MSG_DEBUG, " AT_PERMANENT_ID_REQ"); 116 eap_sim_msg_add(msg, EAP_SIM_AT_PERMANENT_ID_REQ, 0, NULL, 0); 117 } else { 118 /* 119 * RFC 4186, Chap. 4.2.4 recommends that identity from EAP is 120 * ignored and the SIM/Start is used to request the identity. 121 */ 122 wpa_printf(MSG_DEBUG, " AT_ANY_ID_REQ"); 123 eap_sim_msg_add(msg, EAP_SIM_AT_ANY_ID_REQ, 0, NULL, 0); 124 } 125 wpa_printf(MSG_DEBUG, " AT_VERSION_LIST"); 126 ver[0] = 0; 127 ver[1] = EAP_SIM_VERSION; 128 eap_sim_msg_add(msg, EAP_SIM_AT_VERSION_LIST, sizeof(ver), 129 ver, sizeof(ver)); 130 return eap_sim_msg_finish(msg, NULL, NULL, 0); 131} 132 133 134static int eap_sim_build_encr(struct eap_sm *sm, struct eap_sim_data *data, 135 struct eap_sim_msg *msg, u16 counter, 136 const u8 *nonce_s) 137{ 138 os_free(data->next_pseudonym); 139 data->next_pseudonym = 140 eap_sim_db_get_next_pseudonym(sm->eap_sim_db_priv, 0); 141 os_free(data->next_reauth_id); 142 if (data->counter <= EAP_SIM_MAX_FAST_REAUTHS) { 143 data->next_reauth_id = 144 eap_sim_db_get_next_reauth_id(sm->eap_sim_db_priv, 0); 145 } else { 146 wpa_printf(MSG_DEBUG, "EAP-SIM: Max fast re-authentication " 147 "count exceeded - force full authentication"); 148 data->next_reauth_id = NULL; 149 } 150 151 if (data->next_pseudonym == NULL && data->next_reauth_id == NULL && 152 counter == 0 && nonce_s == NULL) 153 return 0; 154 155 wpa_printf(MSG_DEBUG, " AT_IV"); 156 wpa_printf(MSG_DEBUG, " AT_ENCR_DATA"); 157 eap_sim_msg_add_encr_start(msg, EAP_SIM_AT_IV, EAP_SIM_AT_ENCR_DATA); 158 159 if (counter > 0) { 160 wpa_printf(MSG_DEBUG, " *AT_COUNTER (%u)", counter); 161 eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, counter, NULL, 0); 162 } 163 164 if (nonce_s) { 165 wpa_printf(MSG_DEBUG, " *AT_NONCE_S"); 166 eap_sim_msg_add(msg, EAP_SIM_AT_NONCE_S, 0, nonce_s, 167 EAP_SIM_NONCE_S_LEN); 168 } 169 170 if (data->next_pseudonym) { 171 wpa_printf(MSG_DEBUG, " *AT_NEXT_PSEUDONYM (%s)", 172 data->next_pseudonym); 173 eap_sim_msg_add(msg, EAP_SIM_AT_NEXT_PSEUDONYM, 174 os_strlen(data->next_pseudonym), 175 (u8 *) data->next_pseudonym, 176 os_strlen(data->next_pseudonym)); 177 } 178 179 if (data->next_reauth_id) { 180 wpa_printf(MSG_DEBUG, " *AT_NEXT_REAUTH_ID (%s)", 181 data->next_reauth_id); 182 eap_sim_msg_add(msg, EAP_SIM_AT_NEXT_REAUTH_ID, 183 os_strlen(data->next_reauth_id), 184 (u8 *) data->next_reauth_id, 185 os_strlen(data->next_reauth_id)); 186 } 187 188 if (eap_sim_msg_add_encr_end(msg, data->k_encr, EAP_SIM_AT_PADDING)) { 189 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to encrypt " 190 "AT_ENCR_DATA"); 191 return -1; 192 } 193 194 return 0; 195} 196 197 198static struct wpabuf * eap_sim_build_challenge(struct eap_sm *sm, 199 struct eap_sim_data *data, 200 u8 id) 201{ 202 struct eap_sim_msg *msg; 203 204 wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Challenge"); 205 msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM, 206 EAP_SIM_SUBTYPE_CHALLENGE); 207 wpa_printf(MSG_DEBUG, " AT_RAND"); 208 eap_sim_msg_add(msg, EAP_SIM_AT_RAND, 0, (u8 *) data->rand, 209 data->num_chal * GSM_RAND_LEN); 210 211 if (eap_sim_build_encr(sm, data, msg, 0, NULL)) { 212 eap_sim_msg_free(msg); 213 return NULL; 214 } 215 216 if (sm->eap_sim_aka_result_ind) { 217 wpa_printf(MSG_DEBUG, " AT_RESULT_IND"); 218 eap_sim_msg_add(msg, EAP_SIM_AT_RESULT_IND, 0, NULL, 0); 219 } 220 221 wpa_printf(MSG_DEBUG, " AT_MAC"); 222 eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC); 223 return eap_sim_msg_finish(msg, data->k_aut, data->nonce_mt, 224 EAP_SIM_NONCE_MT_LEN); 225} 226 227 228static struct wpabuf * eap_sim_build_reauth(struct eap_sm *sm, 229 struct eap_sim_data *data, u8 id) 230{ 231 struct eap_sim_msg *msg; 232 233 wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Re-authentication"); 234 235 if (os_get_random(data->nonce_s, EAP_SIM_NONCE_S_LEN)) 236 return NULL; 237 wpa_hexdump_key(MSG_MSGDUMP, "EAP-SIM: NONCE_S", 238 data->nonce_s, EAP_SIM_NONCE_S_LEN); 239 240 eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut, data->msk, 241 data->emsk); 242 eap_sim_derive_keys_reauth(data->counter, sm->identity, 243 sm->identity_len, data->nonce_s, data->mk, 244 data->msk, data->emsk); 245 246 msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM, 247 EAP_SIM_SUBTYPE_REAUTHENTICATION); 248 249 if (eap_sim_build_encr(sm, data, msg, data->counter, data->nonce_s)) { 250 eap_sim_msg_free(msg); 251 return NULL; 252 } 253 254 if (sm->eap_sim_aka_result_ind) { 255 wpa_printf(MSG_DEBUG, " AT_RESULT_IND"); 256 eap_sim_msg_add(msg, EAP_SIM_AT_RESULT_IND, 0, NULL, 0); 257 } 258 259 wpa_printf(MSG_DEBUG, " AT_MAC"); 260 eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC); 261 return eap_sim_msg_finish(msg, data->k_aut, NULL, 0); 262} 263 264 265static struct wpabuf * eap_sim_build_notification(struct eap_sm *sm, 266 struct eap_sim_data *data, 267 u8 id) 268{ 269 struct eap_sim_msg *msg; 270 271 wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Notification"); 272 msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM, 273 EAP_SIM_SUBTYPE_NOTIFICATION); 274 wpa_printf(MSG_DEBUG, " AT_NOTIFICATION (%d)", data->notification); 275 eap_sim_msg_add(msg, EAP_SIM_AT_NOTIFICATION, data->notification, 276 NULL, 0); 277 if (data->use_result_ind) { 278 if (data->reauth) { 279 wpa_printf(MSG_DEBUG, " AT_IV"); 280 wpa_printf(MSG_DEBUG, " AT_ENCR_DATA"); 281 eap_sim_msg_add_encr_start(msg, EAP_SIM_AT_IV, 282 EAP_SIM_AT_ENCR_DATA); 283 wpa_printf(MSG_DEBUG, " *AT_COUNTER (%u)", 284 data->counter); 285 eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, data->counter, 286 NULL, 0); 287 288 if (eap_sim_msg_add_encr_end(msg, data->k_encr, 289 EAP_SIM_AT_PADDING)) { 290 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to " 291 "encrypt AT_ENCR_DATA"); 292 eap_sim_msg_free(msg); 293 return NULL; 294 } 295 } 296 297 wpa_printf(MSG_DEBUG, " AT_MAC"); 298 eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC); 299 } 300 return eap_sim_msg_finish(msg, data->k_aut, NULL, 0); 301} 302 303 304static struct wpabuf * eap_sim_buildReq(struct eap_sm *sm, void *priv, u8 id) 305{ 306 struct eap_sim_data *data = priv; 307 308 switch (data->state) { 309 case START: 310 return eap_sim_build_start(sm, data, id); 311 case CHALLENGE: 312 return eap_sim_build_challenge(sm, data, id); 313 case REAUTH: 314 return eap_sim_build_reauth(sm, data, id); 315 case NOTIFICATION: 316 return eap_sim_build_notification(sm, data, id); 317 default: 318 wpa_printf(MSG_DEBUG, "EAP-SIM: Unknown state %d in " 319 "buildReq", data->state); 320 break; 321 } 322 return NULL; 323} 324 325 326static Boolean eap_sim_check(struct eap_sm *sm, void *priv, 327 struct wpabuf *respData) 328{ 329 struct eap_sim_data *data = priv; 330 const u8 *pos; 331 size_t len; 332 u8 subtype; 333 334 pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SIM, respData, &len); 335 if (pos == NULL || len < 3) { 336 wpa_printf(MSG_INFO, "EAP-SIM: Invalid frame"); 337 return TRUE; 338 } 339 subtype = *pos; 340 341 if (subtype == EAP_SIM_SUBTYPE_CLIENT_ERROR) 342 return FALSE; 343 344 switch (data->state) { 345 case START: 346 if (subtype != EAP_SIM_SUBTYPE_START) { 347 wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response " 348 "subtype %d", subtype); 349 return TRUE; 350 } 351 break; 352 case CHALLENGE: 353 if (subtype != EAP_SIM_SUBTYPE_CHALLENGE) { 354 wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response " 355 "subtype %d", subtype); 356 return TRUE; 357 } 358 break; 359 case REAUTH: 360 if (subtype != EAP_SIM_SUBTYPE_REAUTHENTICATION) { 361 wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response " 362 "subtype %d", subtype); 363 return TRUE; 364 } 365 break; 366 case NOTIFICATION: 367 if (subtype != EAP_SIM_SUBTYPE_NOTIFICATION) { 368 wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response " 369 "subtype %d", subtype); 370 return TRUE; 371 } 372 break; 373 default: 374 wpa_printf(MSG_INFO, "EAP-SIM: Unexpected state (%d) for " 375 "processing a response", data->state); 376 return TRUE; 377 } 378 379 return FALSE; 380} 381 382 383static int eap_sim_supported_ver(struct eap_sim_data *data, int version) 384{ 385 return version == EAP_SIM_VERSION; 386} 387 388 389static void eap_sim_process_start(struct eap_sm *sm, 390 struct eap_sim_data *data, 391 struct wpabuf *respData, 392 struct eap_sim_attrs *attr) 393{ 394 const u8 *identity; 395 size_t identity_len; 396 u8 ver_list[2]; 397 398 wpa_printf(MSG_DEBUG, "EAP-SIM: Receive start response"); 399 400 if (attr->identity) { 401 os_free(sm->identity); 402 sm->identity = os_malloc(attr->identity_len); 403 if (sm->identity) { 404 os_memcpy(sm->identity, attr->identity, 405 attr->identity_len); 406 sm->identity_len = attr->identity_len; 407 } 408 } 409 410 identity = NULL; 411 identity_len = 0; 412 413 if (sm->identity && sm->identity_len > 0 && 414 sm->identity[0] == EAP_SIM_PERMANENT_PREFIX) { 415 identity = sm->identity; 416 identity_len = sm->identity_len; 417 } else { 418 identity = eap_sim_db_get_permanent(sm->eap_sim_db_priv, 419 sm->identity, 420 sm->identity_len, 421 &identity_len); 422 if (identity == NULL) { 423 data->reauth = eap_sim_db_get_reauth_entry( 424 sm->eap_sim_db_priv, sm->identity, 425 sm->identity_len); 426 if (data->reauth) { 427 wpa_printf(MSG_DEBUG, "EAP-SIM: Using fast " 428 "re-authentication"); 429 identity = data->reauth->identity; 430 identity_len = data->reauth->identity_len; 431 data->counter = data->reauth->counter; 432 os_memcpy(data->mk, data->reauth->mk, 433 EAP_SIM_MK_LEN); 434 } 435 } 436 } 437 438 if (identity == NULL) { 439 wpa_printf(MSG_DEBUG, "EAP-SIM: Could not get proper permanent" 440 " user name"); 441 eap_sim_state(data, FAILURE); 442 return; 443 } 444 445 wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM: Identity", 446 identity, identity_len); 447 448 if (data->reauth) { 449 eap_sim_state(data, REAUTH); 450 return; 451 } 452 453 if (attr->nonce_mt == NULL || attr->selected_version < 0) { 454 wpa_printf(MSG_DEBUG, "EAP-SIM: Start/Response missing " 455 "required attributes"); 456 eap_sim_state(data, FAILURE); 457 return; 458 } 459 460 if (!eap_sim_supported_ver(data, attr->selected_version)) { 461 wpa_printf(MSG_DEBUG, "EAP-SIM: Peer selected unsupported " 462 "version %d", attr->selected_version); 463 eap_sim_state(data, FAILURE); 464 return; 465 } 466 467 data->counter = 0; /* reset re-auth counter since this is full auth */ 468 data->reauth = NULL; 469 470 data->num_chal = eap_sim_db_get_gsm_triplets( 471 sm->eap_sim_db_priv, identity, identity_len, 472 EAP_SIM_MAX_CHAL, 473 (u8 *) data->rand, (u8 *) data->kc, (u8 *) data->sres, sm); 474 if (data->num_chal == EAP_SIM_DB_PENDING) { 475 wpa_printf(MSG_DEBUG, "EAP-SIM: GSM authentication triplets " 476 "not yet available - pending request"); 477 sm->method_pending = METHOD_PENDING_WAIT; 478 return; 479 } 480 if (data->num_chal < 2) { 481 wpa_printf(MSG_INFO, "EAP-SIM: Failed to get GSM " 482 "authentication triplets for the peer"); 483 eap_sim_state(data, FAILURE); 484 return; 485 } 486 487 identity_len = sm->identity_len; 488 while (identity_len > 0 && sm->identity[identity_len - 1] == '\0') { 489 wpa_printf(MSG_DEBUG, "EAP-SIM: Workaround - drop last null " 490 "character from identity"); 491 identity_len--; 492 } 493 wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM: Identity for MK derivation", 494 sm->identity, identity_len); 495 496 os_memcpy(data->nonce_mt, attr->nonce_mt, EAP_SIM_NONCE_MT_LEN); 497 WPA_PUT_BE16(ver_list, EAP_SIM_VERSION); 498 eap_sim_derive_mk(sm->identity, identity_len, attr->nonce_mt, 499 attr->selected_version, ver_list, sizeof(ver_list), 500 data->num_chal, (const u8 *) data->kc, data->mk); 501 eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut, data->msk, 502 data->emsk); 503 504 eap_sim_state(data, CHALLENGE); 505} 506 507 508static void eap_sim_process_challenge(struct eap_sm *sm, 509 struct eap_sim_data *data, 510 struct wpabuf *respData, 511 struct eap_sim_attrs *attr) 512{ 513 const u8 *identity; 514 size_t identity_len; 515 516 if (attr->mac == NULL || 517 eap_sim_verify_mac(data->k_aut, respData, attr->mac, 518 (u8 *) data->sres, 519 data->num_chal * EAP_SIM_SRES_LEN)) { 520 wpa_printf(MSG_WARNING, "EAP-SIM: Challenge message " 521 "did not include valid AT_MAC"); 522 eap_sim_state(data, FAILURE); 523 return; 524 } 525 526 wpa_printf(MSG_DEBUG, "EAP-SIM: Challenge response includes the " 527 "correct AT_MAC"); 528 if (sm->eap_sim_aka_result_ind && attr->result_ind) { 529 data->use_result_ind = 1; 530 data->notification = EAP_SIM_SUCCESS; 531 eap_sim_state(data, NOTIFICATION); 532 } else 533 eap_sim_state(data, SUCCESS); 534 535 identity = eap_sim_db_get_permanent(sm->eap_sim_db_priv, sm->identity, 536 sm->identity_len, &identity_len); 537 if (identity == NULL) { 538 identity = sm->identity; 539 identity_len = sm->identity_len; 540 } 541 542 if (data->next_pseudonym) { 543 eap_sim_db_add_pseudonym(sm->eap_sim_db_priv, identity, 544 identity_len, 545 data->next_pseudonym); 546 data->next_pseudonym = NULL; 547 } 548 if (data->next_reauth_id) { 549 eap_sim_db_add_reauth(sm->eap_sim_db_priv, identity, 550 identity_len, 551 data->next_reauth_id, data->counter + 1, 552 data->mk); 553 data->next_reauth_id = NULL; 554 } 555} 556 557 558static void eap_sim_process_reauth(struct eap_sm *sm, 559 struct eap_sim_data *data, 560 struct wpabuf *respData, 561 struct eap_sim_attrs *attr) 562{ 563 struct eap_sim_attrs eattr; 564 u8 *decrypted = NULL; 565 const u8 *identity, *id2; 566 size_t identity_len, id2_len; 567 568 if (attr->mac == NULL || 569 eap_sim_verify_mac(data->k_aut, respData, attr->mac, data->nonce_s, 570 EAP_SIM_NONCE_S_LEN)) { 571 wpa_printf(MSG_WARNING, "EAP-SIM: Re-authentication message " 572 "did not include valid AT_MAC"); 573 goto fail; 574 } 575 576 if (attr->encr_data == NULL || attr->iv == NULL) { 577 wpa_printf(MSG_WARNING, "EAP-SIM: Reauthentication " 578 "message did not include encrypted data"); 579 goto fail; 580 } 581 582 decrypted = eap_sim_parse_encr(data->k_encr, attr->encr_data, 583 attr->encr_data_len, attr->iv, &eattr, 584 0); 585 if (decrypted == NULL) { 586 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to parse encrypted " 587 "data from reauthentication message"); 588 goto fail; 589 } 590 591 if (eattr.counter != data->counter) { 592 wpa_printf(MSG_WARNING, "EAP-SIM: Re-authentication message " 593 "used incorrect counter %u, expected %u", 594 eattr.counter, data->counter); 595 goto fail; 596 } 597 os_free(decrypted); 598 decrypted = NULL; 599 600 wpa_printf(MSG_DEBUG, "EAP-SIM: Re-authentication response includes " 601 "the correct AT_MAC"); 602 if (sm->eap_sim_aka_result_ind && attr->result_ind) { 603 data->use_result_ind = 1; 604 data->notification = EAP_SIM_SUCCESS; 605 eap_sim_state(data, NOTIFICATION); 606 } else 607 eap_sim_state(data, SUCCESS); 608 609 if (data->reauth) { 610 identity = data->reauth->identity; 611 identity_len = data->reauth->identity_len; 612 } else { 613 identity = sm->identity; 614 identity_len = sm->identity_len; 615 } 616 617 id2 = eap_sim_db_get_permanent(sm->eap_sim_db_priv, identity, 618 identity_len, &id2_len); 619 if (id2) { 620 identity = id2; 621 identity_len = id2_len; 622 } 623 624 if (data->next_pseudonym) { 625 eap_sim_db_add_pseudonym(sm->eap_sim_db_priv, identity, 626 identity_len, data->next_pseudonym); 627 data->next_pseudonym = NULL; 628 } 629 if (data->next_reauth_id) { 630 eap_sim_db_add_reauth(sm->eap_sim_db_priv, identity, 631 identity_len, data->next_reauth_id, 632 data->counter + 1, data->mk); 633 data->next_reauth_id = NULL; 634 } else { 635 eap_sim_db_remove_reauth(sm->eap_sim_db_priv, data->reauth); 636 data->reauth = NULL; 637 } 638 639 return; 640 641fail: 642 eap_sim_state(data, FAILURE); 643 eap_sim_db_remove_reauth(sm->eap_sim_db_priv, data->reauth); 644 data->reauth = NULL; 645 os_free(decrypted); 646} 647 648 649static void eap_sim_process_client_error(struct eap_sm *sm, 650 struct eap_sim_data *data, 651 struct wpabuf *respData, 652 struct eap_sim_attrs *attr) 653{ 654 wpa_printf(MSG_DEBUG, "EAP-SIM: Client reported error %d", 655 attr->client_error_code); 656 if (data->notification == EAP_SIM_SUCCESS && data->use_result_ind) 657 eap_sim_state(data, SUCCESS); 658 else 659 eap_sim_state(data, FAILURE); 660} 661 662 663static void eap_sim_process_notification(struct eap_sm *sm, 664 struct eap_sim_data *data, 665 struct wpabuf *respData, 666 struct eap_sim_attrs *attr) 667{ 668 wpa_printf(MSG_DEBUG, "EAP-SIM: Client replied to notification"); 669 if (data->notification == EAP_SIM_SUCCESS && data->use_result_ind) 670 eap_sim_state(data, SUCCESS); 671 else 672 eap_sim_state(data, FAILURE); 673} 674 675 676static void eap_sim_process(struct eap_sm *sm, void *priv, 677 struct wpabuf *respData) 678{ 679 struct eap_sim_data *data = priv; 680 const u8 *pos, *end; 681 u8 subtype; 682 size_t len; 683 struct eap_sim_attrs attr; 684 685 pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SIM, respData, &len); 686 if (pos == NULL || len < 3) 687 return; 688 689 end = pos + len; 690 subtype = *pos; 691 pos += 3; 692 693 if (eap_sim_parse_attr(pos, end, &attr, 0, 0)) { 694 wpa_printf(MSG_DEBUG, "EAP-SIM: Failed to parse attributes"); 695 eap_sim_state(data, FAILURE); 696 return; 697 } 698 699 if (subtype == EAP_SIM_SUBTYPE_CLIENT_ERROR) { 700 eap_sim_process_client_error(sm, data, respData, &attr); 701 return; 702 } 703 704 switch (data->state) { 705 case START: 706 eap_sim_process_start(sm, data, respData, &attr); 707 break; 708 case CHALLENGE: 709 eap_sim_process_challenge(sm, data, respData, &attr); 710 break; 711 case REAUTH: 712 eap_sim_process_reauth(sm, data, respData, &attr); 713 break; 714 case NOTIFICATION: 715 eap_sim_process_notification(sm, data, respData, &attr); 716 break; 717 default: 718 wpa_printf(MSG_DEBUG, "EAP-SIM: Unknown state %d in " 719 "process", data->state); 720 break; 721 } 722} 723 724 725static Boolean eap_sim_isDone(struct eap_sm *sm, void *priv) 726{ 727 struct eap_sim_data *data = priv; 728 return data->state == SUCCESS || data->state == FAILURE; 729} 730 731 732static u8 * eap_sim_getKey(struct eap_sm *sm, void *priv, size_t *len) 733{ 734 struct eap_sim_data *data = priv; 735 u8 *key; 736 737 if (data->state != SUCCESS) 738 return NULL; 739 740 key = os_malloc(EAP_SIM_KEYING_DATA_LEN); 741 if (key == NULL) 742 return NULL; 743 os_memcpy(key, data->msk, EAP_SIM_KEYING_DATA_LEN); 744 *len = EAP_SIM_KEYING_DATA_LEN; 745 return key; 746} 747 748 749static u8 * eap_sim_get_emsk(struct eap_sm *sm, void *priv, size_t *len) 750{ 751 struct eap_sim_data *data = priv; 752 u8 *key; 753 754 if (data->state != SUCCESS) 755 return NULL; 756 757 key = os_malloc(EAP_EMSK_LEN); 758 if (key == NULL) 759 return NULL; 760 os_memcpy(key, data->emsk, EAP_EMSK_LEN); 761 *len = EAP_EMSK_LEN; 762 return key; 763} 764 765 766static Boolean eap_sim_isSuccess(struct eap_sm *sm, void *priv) 767{ 768 struct eap_sim_data *data = priv; 769 return data->state == SUCCESS; 770} 771 772 773int eap_server_sim_register(void) 774{ 775 struct eap_method *eap; 776 int ret; 777 778 eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION, 779 EAP_VENDOR_IETF, EAP_TYPE_SIM, "SIM"); 780 if (eap == NULL) 781 return -1; 782 783 eap->init = eap_sim_init; 784 eap->reset = eap_sim_reset; 785 eap->buildReq = eap_sim_buildReq; 786 eap->check = eap_sim_check; 787 eap->process = eap_sim_process; 788 eap->isDone = eap_sim_isDone; 789 eap->getKey = eap_sim_getKey; 790 eap->isSuccess = eap_sim_isSuccess; 791 eap->get_emsk = eap_sim_get_emsk; 792 793 ret = eap_server_method_register(eap); 794 if (ret) 795 eap_server_method_free(eap); 796 return ret; 797} 798