1/* 2 * EAP peer method: EAP-SIM (RFC 4186) 3 * Copyright (c) 2004-2012, Jouni Malinen <j@w1.fi> 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 7 */ 8 9#include "includes.h" 10 11#include "common.h" 12#include "pcsc_funcs.h" 13#include "crypto/milenage.h" 14#include "crypto/random.h" 15#include "eap_peer/eap_i.h" 16#include "eap_config.h" 17#include "eap_common/eap_sim_common.h" 18 19 20struct eap_sim_data { 21 u8 *ver_list; 22 size_t ver_list_len; 23 int selected_version; 24 size_t min_num_chal, num_chal; 25 26 u8 kc[3][EAP_SIM_KC_LEN]; 27 u8 sres[3][EAP_SIM_SRES_LEN]; 28 u8 nonce_mt[EAP_SIM_NONCE_MT_LEN], nonce_s[EAP_SIM_NONCE_S_LEN]; 29 u8 mk[EAP_SIM_MK_LEN]; 30 u8 k_aut[EAP_SIM_K_AUT_LEN]; 31 u8 k_encr[EAP_SIM_K_ENCR_LEN]; 32 u8 msk[EAP_SIM_KEYING_DATA_LEN]; 33 u8 emsk[EAP_EMSK_LEN]; 34 u8 rand[3][GSM_RAND_LEN]; 35 36 int num_id_req, num_notification; 37 u8 *pseudonym; 38 size_t pseudonym_len; 39 u8 *reauth_id; 40 size_t reauth_id_len; 41 int reauth; 42 unsigned int counter, counter_too_small; 43 u8 *last_eap_identity; 44 size_t last_eap_identity_len; 45 enum { 46 CONTINUE, RESULT_SUCCESS, SUCCESS, FAILURE 47 } state; 48 int result_ind, use_result_ind; 49}; 50 51 52#ifndef CONFIG_NO_STDOUT_DEBUG 53static const char * eap_sim_state_txt(int state) 54{ 55 switch (state) { 56 case CONTINUE: 57 return "CONTINUE"; 58 case RESULT_SUCCESS: 59 return "RESULT_SUCCESS"; 60 case SUCCESS: 61 return "SUCCESS"; 62 case FAILURE: 63 return "FAILURE"; 64 default: 65 return "?"; 66 } 67} 68#endif /* CONFIG_NO_STDOUT_DEBUG */ 69 70 71static void eap_sim_state(struct eap_sim_data *data, int state) 72{ 73 wpa_printf(MSG_DEBUG, "EAP-SIM: %s -> %s", 74 eap_sim_state_txt(data->state), 75 eap_sim_state_txt(state)); 76 data->state = state; 77} 78 79 80static void * eap_sim_init(struct eap_sm *sm) 81{ 82 struct eap_sim_data *data; 83 struct eap_peer_config *config = eap_get_config(sm); 84 85 data = os_zalloc(sizeof(*data)); 86 if (data == NULL) 87 return NULL; 88 89 if (random_get_bytes(data->nonce_mt, EAP_SIM_NONCE_MT_LEN)) { 90 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to get random data " 91 "for NONCE_MT"); 92 os_free(data); 93 return NULL; 94 } 95 96 data->min_num_chal = 2; 97 if (config && config->phase1) { 98 char *pos = os_strstr(config->phase1, "sim_min_num_chal="); 99 if (pos) { 100 data->min_num_chal = atoi(pos + 17); 101 if (data->min_num_chal < 2 || data->min_num_chal > 3) { 102 wpa_printf(MSG_WARNING, "EAP-SIM: Invalid " 103 "sim_min_num_chal configuration " 104 "(%lu, expected 2 or 3)", 105 (unsigned long) data->min_num_chal); 106 os_free(data); 107 return NULL; 108 } 109 wpa_printf(MSG_DEBUG, "EAP-SIM: Set minimum number of " 110 "challenges to %lu", 111 (unsigned long) data->min_num_chal); 112 } 113 114 data->result_ind = os_strstr(config->phase1, "result_ind=1") != 115 NULL; 116 } 117 118 if (config && config->anonymous_identity) { 119 data->pseudonym = os_malloc(config->anonymous_identity_len); 120 if (data->pseudonym) { 121 os_memcpy(data->pseudonym, config->anonymous_identity, 122 config->anonymous_identity_len); 123 data->pseudonym_len = config->anonymous_identity_len; 124 } 125 } 126 127 eap_sim_state(data, CONTINUE); 128 129 return data; 130} 131 132 133static void eap_sim_clear_keys(struct eap_sim_data *data, int reauth) 134{ 135 if (!reauth) { 136 os_memset(data->mk, 0, EAP_SIM_MK_LEN); 137 os_memset(data->k_aut, 0, EAP_SIM_K_AUT_LEN); 138 os_memset(data->k_encr, 0, EAP_SIM_K_ENCR_LEN); 139 } 140 os_memset(data->kc, 0, 3 * EAP_SIM_KC_LEN); 141 os_memset(data->sres, 0, 3 * EAP_SIM_SRES_LEN); 142 os_memset(data->msk, 0, EAP_SIM_KEYING_DATA_LEN); 143 os_memset(data->emsk, 0, EAP_EMSK_LEN); 144} 145 146 147static void eap_sim_deinit(struct eap_sm *sm, void *priv) 148{ 149 struct eap_sim_data *data = priv; 150 if (data) { 151 os_free(data->ver_list); 152 os_free(data->pseudonym); 153 os_free(data->reauth_id); 154 os_free(data->last_eap_identity); 155 eap_sim_clear_keys(data, 0); 156 os_free(data); 157 } 158} 159 160 161static int eap_sim_ext_sim_req(struct eap_sm *sm, struct eap_sim_data *data) 162{ 163 char req[200], *pos, *end; 164 size_t i; 165 166 wpa_printf(MSG_DEBUG, "EAP-SIM: Use external SIM processing"); 167 pos = req; 168 end = pos + sizeof(req); 169 pos += os_snprintf(pos, end - pos, "GSM-AUTH"); 170 for (i = 0; i < data->num_chal; i++) { 171 pos += os_snprintf(pos, end - pos, ":"); 172 pos += wpa_snprintf_hex(pos, end - pos, data->rand[i], 173 GSM_RAND_LEN); 174 } 175 176 eap_sm_request_sim(sm, req); 177 return 1; 178} 179 180 181static int eap_sim_ext_sim_result(struct eap_sm *sm, struct eap_sim_data *data, 182 struct eap_peer_config *conf) 183{ 184 char *resp, *pos; 185 size_t i; 186 187 wpa_printf(MSG_DEBUG, 188 "EAP-SIM: Use result from external SIM processing"); 189 190 resp = conf->external_sim_resp; 191 conf->external_sim_resp = NULL; 192 193 if (os_strncmp(resp, "GSM-AUTH:", 9) != 0) { 194 wpa_printf(MSG_DEBUG, "EAP-SIM: Unrecognized external SIM processing response"); 195 os_free(resp); 196 return -1; 197 } 198 199 pos = resp + 9; 200 for (i = 0; i < data->num_chal; i++) { 201 wpa_hexdump(MSG_DEBUG, "EAP-SIM: RAND", 202 data->rand[i], GSM_RAND_LEN); 203 204 if (hexstr2bin(pos, data->kc[i], EAP_SIM_KC_LEN) < 0) 205 goto invalid; 206 wpa_hexdump_key(MSG_DEBUG, "EAP-SIM: Kc", 207 data->kc[i], EAP_SIM_KC_LEN); 208 pos += EAP_SIM_KC_LEN * 2; 209 if (*pos != ':') 210 goto invalid; 211 pos++; 212 213 if (hexstr2bin(pos, data->sres[i], EAP_SIM_SRES_LEN) < 0) 214 goto invalid; 215 wpa_hexdump_key(MSG_DEBUG, "EAP-SIM: SRES", 216 data->sres[i], EAP_SIM_SRES_LEN); 217 pos += EAP_SIM_SRES_LEN * 2; 218 if (i + 1 < data->num_chal) { 219 if (*pos != ':') 220 goto invalid; 221 pos++; 222 } 223 } 224 225 os_free(resp); 226 return 0; 227 228invalid: 229 wpa_printf(MSG_DEBUG, "EAP-SIM: Invalid external SIM processing GSM-AUTH response"); 230 os_free(resp); 231 return -1; 232} 233 234 235static int eap_sim_gsm_auth(struct eap_sm *sm, struct eap_sim_data *data) 236{ 237 struct eap_peer_config *conf; 238 239 wpa_printf(MSG_DEBUG, "EAP-SIM: GSM authentication algorithm"); 240 241 conf = eap_get_config(sm); 242 if (conf == NULL) 243 return -1; 244 245 if (sm->external_sim) { 246 if (conf->external_sim_resp) 247 return eap_sim_ext_sim_result(sm, data, conf); 248 else 249 return eap_sim_ext_sim_req(sm, data); 250 } 251 252#ifdef PCSC_FUNCS 253 if (conf->pcsc) { 254 if (scard_gsm_auth(sm->scard_ctx, data->rand[0], 255 data->sres[0], data->kc[0]) || 256 scard_gsm_auth(sm->scard_ctx, data->rand[1], 257 data->sres[1], data->kc[1]) || 258 (data->num_chal > 2 && 259 scard_gsm_auth(sm->scard_ctx, data->rand[2], 260 data->sres[2], data->kc[2]))) { 261 wpa_printf(MSG_DEBUG, "EAP-SIM: GSM SIM " 262 "authentication could not be completed"); 263 return -1; 264 } 265 return 0; 266 } 267#endif /* PCSC_FUNCS */ 268 269#ifdef CONFIG_SIM_SIMULATOR 270 if (conf->password) { 271 u8 opc[16], k[16]; 272 const char *pos; 273 size_t i; 274 wpa_printf(MSG_DEBUG, "EAP-SIM: Use internal GSM-Milenage " 275 "implementation for authentication"); 276 if (conf->password_len < 65) { 277 wpa_printf(MSG_DEBUG, "EAP-SIM: invalid GSM-Milenage " 278 "password"); 279 return -1; 280 } 281 pos = (const char *) conf->password; 282 if (hexstr2bin(pos, k, 16)) 283 return -1; 284 pos += 32; 285 if (*pos != ':') 286 return -1; 287 pos++; 288 289 if (hexstr2bin(pos, opc, 16)) 290 return -1; 291 292 for (i = 0; i < data->num_chal; i++) { 293 if (gsm_milenage(opc, k, data->rand[i], 294 data->sres[i], data->kc[i])) { 295 wpa_printf(MSG_DEBUG, "EAP-SIM: " 296 "GSM-Milenage authentication " 297 "could not be completed"); 298 return -1; 299 } 300 wpa_hexdump(MSG_DEBUG, "EAP-SIM: RAND", 301 data->rand[i], GSM_RAND_LEN); 302 wpa_hexdump_key(MSG_DEBUG, "EAP-SIM: SRES", 303 data->sres[i], EAP_SIM_SRES_LEN); 304 wpa_hexdump_key(MSG_DEBUG, "EAP-SIM: Kc", 305 data->kc[i], EAP_SIM_KC_LEN); 306 } 307 return 0; 308 } 309#endif /* CONFIG_SIM_SIMULATOR */ 310 311#ifdef CONFIG_SIM_HARDCODED 312 /* These hardcoded Kc and SRES values are used for testing. RAND to 313 * KC/SREC mapping is very bogus as far as real authentication is 314 * concerned, but it is quite useful for cases where the AS is rotating 315 * the order of pre-configured values. */ 316 { 317 size_t i; 318 319 wpa_printf(MSG_DEBUG, "EAP-SIM: Use hardcoded Kc and SRES " 320 "values for testing"); 321 322 for (i = 0; i < data->num_chal; i++) { 323 if (data->rand[i][0] == 0xaa) { 324 os_memcpy(data->kc[i], 325 "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7", 326 EAP_SIM_KC_LEN); 327 os_memcpy(data->sres[i], "\xd1\xd2\xd3\xd4", 328 EAP_SIM_SRES_LEN); 329 } else if (data->rand[i][0] == 0xbb) { 330 os_memcpy(data->kc[i], 331 "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7", 332 EAP_SIM_KC_LEN); 333 os_memcpy(data->sres[i], "\xe1\xe2\xe3\xe4", 334 EAP_SIM_SRES_LEN); 335 } else { 336 os_memcpy(data->kc[i], 337 "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7", 338 EAP_SIM_KC_LEN); 339 os_memcpy(data->sres[i], "\xf1\xf2\xf3\xf4", 340 EAP_SIM_SRES_LEN); 341 } 342 } 343 } 344 345 return 0; 346 347#else /* CONFIG_SIM_HARDCODED */ 348 349 wpa_printf(MSG_DEBUG, "EAP-SIM: No GSM authentication algorithm " 350 "enabled"); 351 return -1; 352 353#endif /* CONFIG_SIM_HARDCODED */ 354} 355 356 357static int eap_sim_supported_ver(int version) 358{ 359 return version == EAP_SIM_VERSION; 360} 361 362 363#define CLEAR_PSEUDONYM 0x01 364#define CLEAR_REAUTH_ID 0x02 365#define CLEAR_EAP_ID 0x04 366 367static void eap_sim_clear_identities(struct eap_sm *sm, 368 struct eap_sim_data *data, int id) 369{ 370 if ((id & CLEAR_PSEUDONYM) && data->pseudonym) { 371 wpa_printf(MSG_DEBUG, "EAP-SIM: forgetting old pseudonym"); 372 os_free(data->pseudonym); 373 data->pseudonym = NULL; 374 data->pseudonym_len = 0; 375 eap_set_anon_id(sm, NULL, 0); 376 } 377 if ((id & CLEAR_REAUTH_ID) && data->reauth_id) { 378 wpa_printf(MSG_DEBUG, "EAP-SIM: forgetting old reauth_id"); 379 os_free(data->reauth_id); 380 data->reauth_id = NULL; 381 data->reauth_id_len = 0; 382 } 383 if ((id & CLEAR_EAP_ID) && data->last_eap_identity) { 384 wpa_printf(MSG_DEBUG, "EAP-SIM: forgetting old eap_id"); 385 os_free(data->last_eap_identity); 386 data->last_eap_identity = NULL; 387 data->last_eap_identity_len = 0; 388 } 389} 390 391 392static int eap_sim_learn_ids(struct eap_sm *sm, struct eap_sim_data *data, 393 struct eap_sim_attrs *attr) 394{ 395 if (attr->next_pseudonym) { 396 const u8 *identity = NULL; 397 size_t identity_len = 0; 398 const u8 *realm = NULL; 399 size_t realm_len = 0; 400 401 wpa_hexdump_ascii(MSG_DEBUG, 402 "EAP-SIM: (encr) AT_NEXT_PSEUDONYM", 403 attr->next_pseudonym, 404 attr->next_pseudonym_len); 405 os_free(data->pseudonym); 406 /* Look for the realm of the permanent identity */ 407 identity = eap_get_config_identity(sm, &identity_len); 408 if (identity) { 409 for (realm = identity, realm_len = identity_len; 410 realm_len > 0; realm_len--, realm++) { 411 if (*realm == '@') 412 break; 413 } 414 } 415 data->pseudonym = os_malloc(attr->next_pseudonym_len + 416 realm_len); 417 if (data->pseudonym == NULL) { 418 wpa_printf(MSG_INFO, "EAP-SIM: (encr) No memory for " 419 "next pseudonym"); 420 data->pseudonym_len = 0; 421 return -1; 422 } 423 os_memcpy(data->pseudonym, attr->next_pseudonym, 424 attr->next_pseudonym_len); 425 if (realm_len) { 426 os_memcpy(data->pseudonym + attr->next_pseudonym_len, 427 realm, realm_len); 428 } 429 data->pseudonym_len = attr->next_pseudonym_len + realm_len; 430 eap_set_anon_id(sm, data->pseudonym, data->pseudonym_len); 431 } 432 433 if (attr->next_reauth_id) { 434 os_free(data->reauth_id); 435 data->reauth_id = os_malloc(attr->next_reauth_id_len); 436 if (data->reauth_id == NULL) { 437 wpa_printf(MSG_INFO, "EAP-SIM: (encr) No memory for " 438 "next reauth_id"); 439 data->reauth_id_len = 0; 440 return -1; 441 } 442 os_memcpy(data->reauth_id, attr->next_reauth_id, 443 attr->next_reauth_id_len); 444 data->reauth_id_len = attr->next_reauth_id_len; 445 wpa_hexdump_ascii(MSG_DEBUG, 446 "EAP-SIM: (encr) AT_NEXT_REAUTH_ID", 447 data->reauth_id, 448 data->reauth_id_len); 449 } 450 451 return 0; 452} 453 454 455static struct wpabuf * eap_sim_client_error(struct eap_sim_data *data, u8 id, 456 int err) 457{ 458 struct eap_sim_msg *msg; 459 460 eap_sim_state(data, FAILURE); 461 data->num_id_req = 0; 462 data->num_notification = 0; 463 464 wpa_printf(MSG_DEBUG, "EAP-SIM: Send Client-Error (error code %d)", 465 err); 466 msg = eap_sim_msg_init(EAP_CODE_RESPONSE, id, EAP_TYPE_SIM, 467 EAP_SIM_SUBTYPE_CLIENT_ERROR); 468 eap_sim_msg_add(msg, EAP_SIM_AT_CLIENT_ERROR_CODE, err, NULL, 0); 469 return eap_sim_msg_finish(msg, EAP_TYPE_SIM, NULL, NULL, 0); 470} 471 472 473static struct wpabuf * eap_sim_response_start(struct eap_sm *sm, 474 struct eap_sim_data *data, u8 id, 475 enum eap_sim_id_req id_req) 476{ 477 const u8 *identity = NULL; 478 size_t identity_len = 0; 479 struct eap_sim_msg *msg; 480 481 data->reauth = 0; 482 if (id_req == ANY_ID && data->reauth_id) { 483 identity = data->reauth_id; 484 identity_len = data->reauth_id_len; 485 data->reauth = 1; 486 } else if ((id_req == ANY_ID || id_req == FULLAUTH_ID) && 487 data->pseudonym) { 488 identity = data->pseudonym; 489 identity_len = data->pseudonym_len; 490 eap_sim_clear_identities(sm, data, CLEAR_REAUTH_ID); 491 } else if (id_req != NO_ID_REQ) { 492 identity = eap_get_config_identity(sm, &identity_len); 493 if (identity) { 494 eap_sim_clear_identities(sm, data, CLEAR_PSEUDONYM | 495 CLEAR_REAUTH_ID); 496 } 497 } 498 if (id_req != NO_ID_REQ) 499 eap_sim_clear_identities(sm, data, CLEAR_EAP_ID); 500 501 wpa_printf(MSG_DEBUG, "Generating EAP-SIM Start (id=%d)", id); 502 msg = eap_sim_msg_init(EAP_CODE_RESPONSE, id, 503 EAP_TYPE_SIM, EAP_SIM_SUBTYPE_START); 504 if (!data->reauth) { 505 wpa_hexdump(MSG_DEBUG, " AT_NONCE_MT", 506 data->nonce_mt, EAP_SIM_NONCE_MT_LEN); 507 eap_sim_msg_add(msg, EAP_SIM_AT_NONCE_MT, 0, 508 data->nonce_mt, EAP_SIM_NONCE_MT_LEN); 509 wpa_printf(MSG_DEBUG, " AT_SELECTED_VERSION %d", 510 data->selected_version); 511 eap_sim_msg_add(msg, EAP_SIM_AT_SELECTED_VERSION, 512 data->selected_version, NULL, 0); 513 } 514 515 if (identity) { 516 wpa_hexdump_ascii(MSG_DEBUG, " AT_IDENTITY", 517 identity, identity_len); 518 eap_sim_msg_add(msg, EAP_SIM_AT_IDENTITY, identity_len, 519 identity, identity_len); 520 } 521 522 return eap_sim_msg_finish(msg, EAP_TYPE_SIM, NULL, NULL, 0); 523} 524 525 526static struct wpabuf * eap_sim_response_challenge(struct eap_sim_data *data, 527 u8 id) 528{ 529 struct eap_sim_msg *msg; 530 531 wpa_printf(MSG_DEBUG, "Generating EAP-SIM Challenge (id=%d)", id); 532 msg = eap_sim_msg_init(EAP_CODE_RESPONSE, id, EAP_TYPE_SIM, 533 EAP_SIM_SUBTYPE_CHALLENGE); 534 if (data->use_result_ind) { 535 wpa_printf(MSG_DEBUG, " AT_RESULT_IND"); 536 eap_sim_msg_add(msg, EAP_SIM_AT_RESULT_IND, 0, NULL, 0); 537 } 538 wpa_printf(MSG_DEBUG, " AT_MAC"); 539 eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC); 540 return eap_sim_msg_finish(msg, EAP_TYPE_SIM, data->k_aut, 541 (u8 *) data->sres, 542 data->num_chal * EAP_SIM_SRES_LEN); 543} 544 545 546static struct wpabuf * eap_sim_response_reauth(struct eap_sim_data *data, 547 u8 id, int counter_too_small, 548 const u8 *nonce_s) 549{ 550 struct eap_sim_msg *msg; 551 unsigned int counter; 552 553 wpa_printf(MSG_DEBUG, "Generating EAP-SIM Reauthentication (id=%d)", 554 id); 555 msg = eap_sim_msg_init(EAP_CODE_RESPONSE, id, EAP_TYPE_SIM, 556 EAP_SIM_SUBTYPE_REAUTHENTICATION); 557 wpa_printf(MSG_DEBUG, " AT_IV"); 558 wpa_printf(MSG_DEBUG, " AT_ENCR_DATA"); 559 eap_sim_msg_add_encr_start(msg, EAP_SIM_AT_IV, EAP_SIM_AT_ENCR_DATA); 560 561 if (counter_too_small) { 562 wpa_printf(MSG_DEBUG, " *AT_COUNTER_TOO_SMALL"); 563 eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER_TOO_SMALL, 0, NULL, 0); 564 counter = data->counter_too_small; 565 } else 566 counter = data->counter; 567 568 wpa_printf(MSG_DEBUG, " *AT_COUNTER %d", counter); 569 eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, counter, NULL, 0); 570 571 if (eap_sim_msg_add_encr_end(msg, data->k_encr, EAP_SIM_AT_PADDING)) { 572 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to encrypt " 573 "AT_ENCR_DATA"); 574 eap_sim_msg_free(msg); 575 return NULL; 576 } 577 if (data->use_result_ind) { 578 wpa_printf(MSG_DEBUG, " AT_RESULT_IND"); 579 eap_sim_msg_add(msg, EAP_SIM_AT_RESULT_IND, 0, NULL, 0); 580 } 581 wpa_printf(MSG_DEBUG, " AT_MAC"); 582 eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC); 583 return eap_sim_msg_finish(msg, EAP_TYPE_SIM, data->k_aut, nonce_s, 584 EAP_SIM_NONCE_S_LEN); 585} 586 587 588static struct wpabuf * eap_sim_response_notification(struct eap_sim_data *data, 589 u8 id, u16 notification) 590{ 591 struct eap_sim_msg *msg; 592 u8 *k_aut = (notification & 0x4000) == 0 ? data->k_aut : NULL; 593 594 wpa_printf(MSG_DEBUG, "Generating EAP-SIM Notification (id=%d)", id); 595 msg = eap_sim_msg_init(EAP_CODE_RESPONSE, id, 596 EAP_TYPE_SIM, EAP_SIM_SUBTYPE_NOTIFICATION); 597 if (k_aut && data->reauth) { 598 wpa_printf(MSG_DEBUG, " AT_IV"); 599 wpa_printf(MSG_DEBUG, " AT_ENCR_DATA"); 600 eap_sim_msg_add_encr_start(msg, EAP_SIM_AT_IV, 601 EAP_SIM_AT_ENCR_DATA); 602 wpa_printf(MSG_DEBUG, " *AT_COUNTER %d", data->counter); 603 eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, data->counter, 604 NULL, 0); 605 if (eap_sim_msg_add_encr_end(msg, data->k_encr, 606 EAP_SIM_AT_PADDING)) { 607 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to encrypt " 608 "AT_ENCR_DATA"); 609 eap_sim_msg_free(msg); 610 return NULL; 611 } 612 } 613 if (k_aut) { 614 wpa_printf(MSG_DEBUG, " AT_MAC"); 615 eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC); 616 } 617 return eap_sim_msg_finish(msg, EAP_TYPE_SIM, k_aut, (u8 *) "", 0); 618} 619 620 621static struct wpabuf * eap_sim_process_start(struct eap_sm *sm, 622 struct eap_sim_data *data, u8 id, 623 struct eap_sim_attrs *attr) 624{ 625 int selected_version = -1, id_error; 626 size_t i; 627 u8 *pos; 628 629 wpa_printf(MSG_DEBUG, "EAP-SIM: subtype Start"); 630 if (attr->version_list == NULL) { 631 wpa_printf(MSG_INFO, "EAP-SIM: No AT_VERSION_LIST in " 632 "SIM/Start"); 633 return eap_sim_client_error(data, id, 634 EAP_SIM_UNSUPPORTED_VERSION); 635 } 636 637 os_free(data->ver_list); 638 data->ver_list = os_malloc(attr->version_list_len); 639 if (data->ver_list == NULL) { 640 wpa_printf(MSG_DEBUG, "EAP-SIM: Failed to allocate " 641 "memory for version list"); 642 return eap_sim_client_error(data, id, 643 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 644 } 645 os_memcpy(data->ver_list, attr->version_list, attr->version_list_len); 646 data->ver_list_len = attr->version_list_len; 647 pos = data->ver_list; 648 for (i = 0; i < data->ver_list_len / 2; i++) { 649 int ver = pos[0] * 256 + pos[1]; 650 pos += 2; 651 if (eap_sim_supported_ver(ver)) { 652 selected_version = ver; 653 break; 654 } 655 } 656 if (selected_version < 0) { 657 wpa_printf(MSG_INFO, "EAP-SIM: Could not find a supported " 658 "version"); 659 return eap_sim_client_error(data, id, 660 EAP_SIM_UNSUPPORTED_VERSION); 661 } 662 wpa_printf(MSG_DEBUG, "EAP-SIM: Selected Version %d", 663 selected_version); 664 data->selected_version = selected_version; 665 666 id_error = 0; 667 switch (attr->id_req) { 668 case NO_ID_REQ: 669 break; 670 case ANY_ID: 671 if (data->num_id_req > 0) 672 id_error++; 673 data->num_id_req++; 674 break; 675 case FULLAUTH_ID: 676 if (data->num_id_req > 1) 677 id_error++; 678 data->num_id_req++; 679 break; 680 case PERMANENT_ID: 681 if (data->num_id_req > 2) 682 id_error++; 683 data->num_id_req++; 684 break; 685 } 686 if (id_error) { 687 wpa_printf(MSG_INFO, "EAP-SIM: Too many ID requests " 688 "used within one authentication"); 689 return eap_sim_client_error(data, id, 690 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 691 } 692 693 return eap_sim_response_start(sm, data, id, attr->id_req); 694} 695 696 697static struct wpabuf * eap_sim_process_challenge(struct eap_sm *sm, 698 struct eap_sim_data *data, 699 u8 id, 700 const struct wpabuf *reqData, 701 struct eap_sim_attrs *attr) 702{ 703 const u8 *identity; 704 size_t identity_len; 705 struct eap_sim_attrs eattr; 706 int res; 707 708 wpa_printf(MSG_DEBUG, "EAP-SIM: subtype Challenge"); 709 data->reauth = 0; 710 if (!attr->mac || !attr->rand) { 711 wpa_printf(MSG_WARNING, "EAP-SIM: Challenge message " 712 "did not include%s%s", 713 !attr->mac ? " AT_MAC" : "", 714 !attr->rand ? " AT_RAND" : ""); 715 return eap_sim_client_error(data, id, 716 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 717 } 718 719 wpa_printf(MSG_DEBUG, "EAP-SIM: %lu challenges", 720 (unsigned long) attr->num_chal); 721 if (attr->num_chal < data->min_num_chal) { 722 wpa_printf(MSG_INFO, "EAP-SIM: Insufficient number of " 723 "challenges (%lu)", (unsigned long) attr->num_chal); 724 return eap_sim_client_error(data, id, 725 EAP_SIM_INSUFFICIENT_NUM_OF_CHAL); 726 } 727 if (attr->num_chal > 3) { 728 wpa_printf(MSG_INFO, "EAP-SIM: Too many challenges " 729 "(%lu)", (unsigned long) attr->num_chal); 730 return eap_sim_client_error(data, id, 731 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 732 } 733 734 /* Verify that RANDs are different */ 735 if (os_memcmp(attr->rand, attr->rand + GSM_RAND_LEN, 736 GSM_RAND_LEN) == 0 || 737 (attr->num_chal > 2 && 738 (os_memcmp(attr->rand, attr->rand + 2 * GSM_RAND_LEN, 739 GSM_RAND_LEN) == 0 || 740 os_memcmp(attr->rand + GSM_RAND_LEN, 741 attr->rand + 2 * GSM_RAND_LEN, 742 GSM_RAND_LEN) == 0))) { 743 wpa_printf(MSG_INFO, "EAP-SIM: Same RAND used multiple times"); 744 return eap_sim_client_error(data, id, 745 EAP_SIM_RAND_NOT_FRESH); 746 } 747 748 os_memcpy(data->rand, attr->rand, attr->num_chal * GSM_RAND_LEN); 749 data->num_chal = attr->num_chal; 750 751 res = eap_sim_gsm_auth(sm, data); 752 if (res > 0) { 753 wpa_printf(MSG_DEBUG, "EAP-SIM: Wait for external SIM processing"); 754 return NULL; 755 } 756 if (res) { 757 wpa_printf(MSG_WARNING, "EAP-SIM: GSM authentication failed"); 758 return eap_sim_client_error(data, id, 759 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 760 } 761 if (data->last_eap_identity) { 762 identity = data->last_eap_identity; 763 identity_len = data->last_eap_identity_len; 764 } else if (data->pseudonym) { 765 identity = data->pseudonym; 766 identity_len = data->pseudonym_len; 767 } else 768 identity = eap_get_config_identity(sm, &identity_len); 769 wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM: Selected identity for MK " 770 "derivation", identity, identity_len); 771 eap_sim_derive_mk(identity, identity_len, data->nonce_mt, 772 data->selected_version, data->ver_list, 773 data->ver_list_len, data->num_chal, 774 (const u8 *) data->kc, data->mk); 775 eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut, data->msk, 776 data->emsk); 777 if (eap_sim_verify_mac(data->k_aut, reqData, attr->mac, data->nonce_mt, 778 EAP_SIM_NONCE_MT_LEN)) { 779 wpa_printf(MSG_WARNING, "EAP-SIM: Challenge message " 780 "used invalid AT_MAC"); 781 return eap_sim_client_error(data, id, 782 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 783 } 784 785 /* Old reauthentication identity must not be used anymore. In 786 * other words, if no new reauth identity is received, full 787 * authentication will be used on next reauthentication (using 788 * pseudonym identity or permanent identity). */ 789 eap_sim_clear_identities(sm, data, CLEAR_REAUTH_ID | CLEAR_EAP_ID); 790 791 if (attr->encr_data) { 792 u8 *decrypted; 793 decrypted = eap_sim_parse_encr(data->k_encr, attr->encr_data, 794 attr->encr_data_len, attr->iv, 795 &eattr, 0); 796 if (decrypted == NULL) { 797 return eap_sim_client_error( 798 data, id, EAP_SIM_UNABLE_TO_PROCESS_PACKET); 799 } 800 eap_sim_learn_ids(sm, data, &eattr); 801 os_free(decrypted); 802 } 803 804 if (data->result_ind && attr->result_ind) 805 data->use_result_ind = 1; 806 807 if (data->state != FAILURE) { 808 eap_sim_state(data, data->use_result_ind ? 809 RESULT_SUCCESS : SUCCESS); 810 } 811 812 data->num_id_req = 0; 813 data->num_notification = 0; 814 /* RFC 4186 specifies that counter is initialized to one after 815 * fullauth, but initializing it to zero makes it easier to implement 816 * reauth verification. */ 817 data->counter = 0; 818 return eap_sim_response_challenge(data, id); 819} 820 821 822static int eap_sim_process_notification_reauth(struct eap_sim_data *data, 823 struct eap_sim_attrs *attr) 824{ 825 struct eap_sim_attrs eattr; 826 u8 *decrypted; 827 828 if (attr->encr_data == NULL || attr->iv == NULL) { 829 wpa_printf(MSG_WARNING, "EAP-SIM: Notification message after " 830 "reauth did not include encrypted data"); 831 return -1; 832 } 833 834 decrypted = eap_sim_parse_encr(data->k_encr, attr->encr_data, 835 attr->encr_data_len, attr->iv, &eattr, 836 0); 837 if (decrypted == NULL) { 838 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to parse encrypted " 839 "data from notification message"); 840 return -1; 841 } 842 843 if (eattr.counter < 0 || (size_t) eattr.counter != data->counter) { 844 wpa_printf(MSG_WARNING, "EAP-SIM: Counter in notification " 845 "message does not match with counter in reauth " 846 "message"); 847 os_free(decrypted); 848 return -1; 849 } 850 851 os_free(decrypted); 852 return 0; 853} 854 855 856static int eap_sim_process_notification_auth(struct eap_sim_data *data, 857 const struct wpabuf *reqData, 858 struct eap_sim_attrs *attr) 859{ 860 if (attr->mac == NULL) { 861 wpa_printf(MSG_INFO, "EAP-SIM: no AT_MAC in after_auth " 862 "Notification message"); 863 return -1; 864 } 865 866 if (eap_sim_verify_mac(data->k_aut, reqData, attr->mac, (u8 *) "", 0)) 867 { 868 wpa_printf(MSG_WARNING, "EAP-SIM: Notification message " 869 "used invalid AT_MAC"); 870 return -1; 871 } 872 873 if (data->reauth && 874 eap_sim_process_notification_reauth(data, attr)) { 875 wpa_printf(MSG_WARNING, "EAP-SIM: Invalid notification " 876 "message after reauth"); 877 return -1; 878 } 879 880 return 0; 881} 882 883 884static struct wpabuf * eap_sim_process_notification( 885 struct eap_sm *sm, struct eap_sim_data *data, u8 id, 886 const struct wpabuf *reqData, struct eap_sim_attrs *attr) 887{ 888 wpa_printf(MSG_DEBUG, "EAP-SIM: subtype Notification"); 889 if (data->num_notification > 0) { 890 wpa_printf(MSG_INFO, "EAP-SIM: too many notification " 891 "rounds (only one allowed)"); 892 return eap_sim_client_error(data, id, 893 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 894 } 895 data->num_notification++; 896 if (attr->notification == -1) { 897 wpa_printf(MSG_INFO, "EAP-SIM: no AT_NOTIFICATION in " 898 "Notification message"); 899 return eap_sim_client_error(data, id, 900 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 901 } 902 903 if ((attr->notification & 0x4000) == 0 && 904 eap_sim_process_notification_auth(data, reqData, attr)) { 905 return eap_sim_client_error(data, id, 906 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 907 } 908 909 eap_sim_report_notification(sm->msg_ctx, attr->notification, 0); 910 if (attr->notification >= 0 && attr->notification < 32768) { 911 eap_sim_state(data, FAILURE); 912 } else if (attr->notification == EAP_SIM_SUCCESS && 913 data->state == RESULT_SUCCESS) 914 eap_sim_state(data, SUCCESS); 915 return eap_sim_response_notification(data, id, attr->notification); 916} 917 918 919static struct wpabuf * eap_sim_process_reauthentication( 920 struct eap_sm *sm, struct eap_sim_data *data, u8 id, 921 const struct wpabuf *reqData, struct eap_sim_attrs *attr) 922{ 923 struct eap_sim_attrs eattr; 924 u8 *decrypted; 925 926 wpa_printf(MSG_DEBUG, "EAP-SIM: subtype Reauthentication"); 927 928 if (data->reauth_id == NULL) { 929 wpa_printf(MSG_WARNING, "EAP-SIM: Server is trying " 930 "reauthentication, but no reauth_id available"); 931 return eap_sim_client_error(data, id, 932 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 933 } 934 935 data->reauth = 1; 936 if (eap_sim_verify_mac(data->k_aut, reqData, attr->mac, (u8 *) "", 0)) 937 { 938 wpa_printf(MSG_WARNING, "EAP-SIM: Reauthentication " 939 "did not have valid AT_MAC"); 940 return eap_sim_client_error(data, id, 941 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 942 } 943 944 if (attr->encr_data == NULL || attr->iv == NULL) { 945 wpa_printf(MSG_WARNING, "EAP-SIM: Reauthentication " 946 "message did not include encrypted data"); 947 return eap_sim_client_error(data, id, 948 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 949 } 950 951 decrypted = eap_sim_parse_encr(data->k_encr, attr->encr_data, 952 attr->encr_data_len, attr->iv, &eattr, 953 0); 954 if (decrypted == NULL) { 955 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to parse encrypted " 956 "data from reauthentication message"); 957 return eap_sim_client_error(data, id, 958 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 959 } 960 961 if (eattr.nonce_s == NULL || eattr.counter < 0) { 962 wpa_printf(MSG_INFO, "EAP-SIM: (encr) No%s%s in reauth packet", 963 !eattr.nonce_s ? " AT_NONCE_S" : "", 964 eattr.counter < 0 ? " AT_COUNTER" : ""); 965 os_free(decrypted); 966 return eap_sim_client_error(data, id, 967 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 968 } 969 970 if (eattr.counter < 0 || (size_t) eattr.counter <= data->counter) { 971 struct wpabuf *res; 972 wpa_printf(MSG_INFO, "EAP-SIM: (encr) Invalid counter " 973 "(%d <= %d)", eattr.counter, data->counter); 974 data->counter_too_small = eattr.counter; 975 976 /* Reply using Re-auth w/ AT_COUNTER_TOO_SMALL. The current 977 * reauth_id must not be used to start a new reauthentication. 978 * However, since it was used in the last EAP-Response-Identity 979 * packet, it has to saved for the following fullauth to be 980 * used in MK derivation. */ 981 os_free(data->last_eap_identity); 982 data->last_eap_identity = data->reauth_id; 983 data->last_eap_identity_len = data->reauth_id_len; 984 data->reauth_id = NULL; 985 data->reauth_id_len = 0; 986 987 res = eap_sim_response_reauth(data, id, 1, eattr.nonce_s); 988 os_free(decrypted); 989 990 return res; 991 } 992 data->counter = eattr.counter; 993 994 os_memcpy(data->nonce_s, eattr.nonce_s, EAP_SIM_NONCE_S_LEN); 995 wpa_hexdump(MSG_DEBUG, "EAP-SIM: (encr) AT_NONCE_S", 996 data->nonce_s, EAP_SIM_NONCE_S_LEN); 997 998 eap_sim_derive_keys_reauth(data->counter, 999 data->reauth_id, data->reauth_id_len, 1000 data->nonce_s, data->mk, data->msk, 1001 data->emsk); 1002 eap_sim_clear_identities(sm, data, CLEAR_REAUTH_ID | CLEAR_EAP_ID); 1003 eap_sim_learn_ids(sm, data, &eattr); 1004 1005 if (data->result_ind && attr->result_ind) 1006 data->use_result_ind = 1; 1007 1008 if (data->state != FAILURE) { 1009 eap_sim_state(data, data->use_result_ind ? 1010 RESULT_SUCCESS : SUCCESS); 1011 } 1012 1013 data->num_id_req = 0; 1014 data->num_notification = 0; 1015 if (data->counter > EAP_SIM_MAX_FAST_REAUTHS) { 1016 wpa_printf(MSG_DEBUG, "EAP-SIM: Maximum number of " 1017 "fast reauths performed - force fullauth"); 1018 eap_sim_clear_identities(sm, data, 1019 CLEAR_REAUTH_ID | CLEAR_EAP_ID); 1020 } 1021 os_free(decrypted); 1022 return eap_sim_response_reauth(data, id, 0, data->nonce_s); 1023} 1024 1025 1026static struct wpabuf * eap_sim_process(struct eap_sm *sm, void *priv, 1027 struct eap_method_ret *ret, 1028 const struct wpabuf *reqData) 1029{ 1030 struct eap_sim_data *data = priv; 1031 const struct eap_hdr *req; 1032 u8 subtype, id; 1033 struct wpabuf *res; 1034 const u8 *pos; 1035 struct eap_sim_attrs attr; 1036 size_t len; 1037 1038 wpa_hexdump_buf(MSG_DEBUG, "EAP-SIM: EAP data", reqData); 1039 if (eap_get_config_identity(sm, &len) == NULL) { 1040 wpa_printf(MSG_INFO, "EAP-SIM: Identity not configured"); 1041 eap_sm_request_identity(sm); 1042 ret->ignore = TRUE; 1043 return NULL; 1044 } 1045 1046 pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SIM, reqData, &len); 1047 if (pos == NULL || len < 3) { 1048 ret->ignore = TRUE; 1049 return NULL; 1050 } 1051 req = wpabuf_head(reqData); 1052 id = req->identifier; 1053 len = be_to_host16(req->length); 1054 1055 ret->ignore = FALSE; 1056 ret->methodState = METHOD_MAY_CONT; 1057 ret->decision = DECISION_FAIL; 1058 ret->allowNotifications = TRUE; 1059 1060 subtype = *pos++; 1061 wpa_printf(MSG_DEBUG, "EAP-SIM: Subtype=%d", subtype); 1062 pos += 2; /* Reserved */ 1063 1064 if (eap_sim_parse_attr(pos, wpabuf_head_u8(reqData) + len, &attr, 0, 1065 0)) { 1066 res = eap_sim_client_error(data, id, 1067 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 1068 goto done; 1069 } 1070 1071 switch (subtype) { 1072 case EAP_SIM_SUBTYPE_START: 1073 res = eap_sim_process_start(sm, data, id, &attr); 1074 break; 1075 case EAP_SIM_SUBTYPE_CHALLENGE: 1076 res = eap_sim_process_challenge(sm, data, id, reqData, &attr); 1077 break; 1078 case EAP_SIM_SUBTYPE_NOTIFICATION: 1079 res = eap_sim_process_notification(sm, data, id, reqData, 1080 &attr); 1081 break; 1082 case EAP_SIM_SUBTYPE_REAUTHENTICATION: 1083 res = eap_sim_process_reauthentication(sm, data, id, reqData, 1084 &attr); 1085 break; 1086 case EAP_SIM_SUBTYPE_CLIENT_ERROR: 1087 wpa_printf(MSG_DEBUG, "EAP-SIM: subtype Client-Error"); 1088 res = eap_sim_client_error(data, id, 1089 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 1090 break; 1091 default: 1092 wpa_printf(MSG_DEBUG, "EAP-SIM: Unknown subtype=%d", subtype); 1093 res = eap_sim_client_error(data, id, 1094 EAP_SIM_UNABLE_TO_PROCESS_PACKET); 1095 break; 1096 } 1097 1098done: 1099 if (data->state == FAILURE) { 1100 ret->decision = DECISION_FAIL; 1101 ret->methodState = METHOD_DONE; 1102 } else if (data->state == SUCCESS) { 1103 ret->decision = data->use_result_ind ? 1104 DECISION_UNCOND_SUCC : DECISION_COND_SUCC; 1105 ret->methodState = data->use_result_ind ? 1106 METHOD_DONE : METHOD_MAY_CONT; 1107 } else if (data->state == RESULT_SUCCESS) 1108 ret->methodState = METHOD_CONT; 1109 1110 if (ret->methodState == METHOD_DONE) { 1111 ret->allowNotifications = FALSE; 1112 } 1113 1114 return res; 1115} 1116 1117 1118static Boolean eap_sim_has_reauth_data(struct eap_sm *sm, void *priv) 1119{ 1120 struct eap_sim_data *data = priv; 1121 return data->pseudonym || data->reauth_id; 1122} 1123 1124 1125static void eap_sim_deinit_for_reauth(struct eap_sm *sm, void *priv) 1126{ 1127 struct eap_sim_data *data = priv; 1128 eap_sim_clear_identities(sm, data, CLEAR_EAP_ID); 1129 data->use_result_ind = 0; 1130 eap_sim_clear_keys(data, 1); 1131} 1132 1133 1134static void * eap_sim_init_for_reauth(struct eap_sm *sm, void *priv) 1135{ 1136 struct eap_sim_data *data = priv; 1137 if (random_get_bytes(data->nonce_mt, EAP_SIM_NONCE_MT_LEN)) { 1138 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to get random data " 1139 "for NONCE_MT"); 1140 eap_sim_deinit(sm, data); 1141 return NULL; 1142 } 1143 data->num_id_req = 0; 1144 data->num_notification = 0; 1145 eap_sim_state(data, CONTINUE); 1146 return priv; 1147} 1148 1149 1150static const u8 * eap_sim_get_identity(struct eap_sm *sm, void *priv, 1151 size_t *len) 1152{ 1153 struct eap_sim_data *data = priv; 1154 1155 if (data->reauth_id) { 1156 *len = data->reauth_id_len; 1157 return data->reauth_id; 1158 } 1159 1160 if (data->pseudonym) { 1161 *len = data->pseudonym_len; 1162 return data->pseudonym; 1163 } 1164 1165 return NULL; 1166} 1167 1168 1169static Boolean eap_sim_isKeyAvailable(struct eap_sm *sm, void *priv) 1170{ 1171 struct eap_sim_data *data = priv; 1172 return data->state == SUCCESS; 1173} 1174 1175 1176static u8 * eap_sim_getKey(struct eap_sm *sm, void *priv, size_t *len) 1177{ 1178 struct eap_sim_data *data = priv; 1179 u8 *key; 1180 1181 if (data->state != SUCCESS) 1182 return NULL; 1183 1184 key = os_malloc(EAP_SIM_KEYING_DATA_LEN); 1185 if (key == NULL) 1186 return NULL; 1187 1188 *len = EAP_SIM_KEYING_DATA_LEN; 1189 os_memcpy(key, data->msk, EAP_SIM_KEYING_DATA_LEN); 1190 1191 return key; 1192} 1193 1194 1195static u8 * eap_sim_get_session_id(struct eap_sm *sm, void *priv, size_t *len) 1196{ 1197 struct eap_sim_data *data = priv; 1198 u8 *id; 1199 1200 if (data->state != SUCCESS) 1201 return NULL; 1202 1203 *len = 1 + data->num_chal * GSM_RAND_LEN + EAP_SIM_NONCE_MT_LEN; 1204 id = os_malloc(*len); 1205 if (id == NULL) 1206 return NULL; 1207 1208 id[0] = EAP_TYPE_SIM; 1209 os_memcpy(id + 1, data->rand, data->num_chal * GSM_RAND_LEN); 1210 os_memcpy(id + 1 + data->num_chal * GSM_RAND_LEN, data->nonce_mt, 1211 EAP_SIM_NONCE_MT_LEN); 1212 wpa_hexdump(MSG_DEBUG, "EAP-SIM: Derived Session-Id", id, *len); 1213 1214 return id; 1215} 1216 1217 1218static u8 * eap_sim_get_emsk(struct eap_sm *sm, void *priv, size_t *len) 1219{ 1220 struct eap_sim_data *data = priv; 1221 u8 *key; 1222 1223 if (data->state != SUCCESS) 1224 return NULL; 1225 1226 key = os_malloc(EAP_EMSK_LEN); 1227 if (key == NULL) 1228 return NULL; 1229 1230 *len = EAP_EMSK_LEN; 1231 os_memcpy(key, data->emsk, EAP_EMSK_LEN); 1232 1233 return key; 1234} 1235 1236 1237int eap_peer_sim_register(void) 1238{ 1239 struct eap_method *eap; 1240 1241 eap = eap_peer_method_alloc(EAP_PEER_METHOD_INTERFACE_VERSION, 1242 EAP_VENDOR_IETF, EAP_TYPE_SIM, "SIM"); 1243 if (eap == NULL) 1244 return -1; 1245 1246 eap->init = eap_sim_init; 1247 eap->deinit = eap_sim_deinit; 1248 eap->process = eap_sim_process; 1249 eap->isKeyAvailable = eap_sim_isKeyAvailable; 1250 eap->getKey = eap_sim_getKey; 1251 eap->getSessionId = eap_sim_get_session_id; 1252 eap->has_reauth_data = eap_sim_has_reauth_data; 1253 eap->deinit_for_reauth = eap_sim_deinit_for_reauth; 1254 eap->init_for_reauth = eap_sim_init_for_reauth; 1255 eap->get_identity = eap_sim_get_identity; 1256 eap->get_emsk = eap_sim_get_emsk; 1257 1258 return eap_peer_method_register(eap); 1259} 1260