Lines Matching full:data
79 static void eap_sim_state(struct eap_sim_data *data, int state)
82 eap_sim_state_txt(data->state),
84 data->state = state;
90 struct eap_sim_data *data;
93 data = os_zalloc(sizeof(*data));
94 if (data == NULL)
97 if (random_get_bytes(data->nonce_mt, EAP_SIM_NONCE_MT_LEN)) {
98 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to get random data "
100 os_free(data);
106 data->imsi_privacy_key = crypto_rsa_key_read(
108 if (!data->imsi_privacy_key) {
112 os_free(data);
118 os_free(data);
124 data->error_code = NO_EAP_METHOD_ERROR;
126 data->min_num_chal = 2;
130 data->min_num_chal = atoi(pos + 17);
131 if (data->min_num_chal < 2 || data->min_num_chal > 3) {
135 (unsigned long) data->min_num_chal);
137 crypto_rsa_key_free(data->imsi_privacy_key);
139 os_free(data);
144 (unsigned long) data->min_num_chal);
147 data->result_ind = os_strstr(config->phase1, "result_ind=1") !=
151 data->use_pseudonym = !sm->init_phase2;
152 if (config && config->anonymous_identity && data->use_pseudonym) {
153 data->pseudonym = os_malloc(config->anonymous_identity_len);
154 if (data->pseudonym) {
155 os_memcpy(data->pseudonym, config->anonymous_identity,
157 data->pseudonym_len = config->anonymous_identity_len;
164 data->mk_identity = os_memdup(sm->identity, sm->identity_len);
165 data->mk_identity_len = sm->identity_len;
168 eap_sim_state(data, CONTINUE);
170 return data;
174 static void eap_sim_clear_keys(struct eap_sim_data *data, int reauth)
177 os_memset(data->mk, 0, EAP_SIM_MK_LEN);
178 os_memset(data->k_aut, 0, EAP_SIM_K_AUT_LEN);
179 os_memset(data->k_encr, 0, EAP_SIM_K_ENCR_LEN);
181 os_memset(data->kc, 0, 3 * EAP_SIM_KC_LEN);
182 os_memset(data->sres, 0, 3 * EAP_SIM_SRES_LEN);
183 os_memset(data->msk, 0, EAP_SIM_KEYING_DATA_LEN);
184 os_memset(data->emsk, 0, EAP_EMSK_LEN);
190 struct eap_sim_data *data = priv;
191 if (data) {
192 os_free(data->ver_list);
193 os_free(data->pseudonym);
194 os_free(data->reauth_id);
195 os_free(data->mk_identity);
196 eap_sim_clear_keys(data, 0);
198 crypto_rsa_key_free(data->imsi_privacy_key);
200 os_free(data);
205 static int eap_sim_ext_sim_req(struct eap_sm *sm, struct eap_sim_data *data)
214 for (i = 0; i < data->num_chal; i++) {
216 pos += wpa_snprintf_hex(pos, end - pos, data->rand[i],
225 static int eap_sim_ext_sim_result(struct eap_sm *sm, struct eap_sim_data *data,
244 for (i = 0; i < data->num_chal; i++) {
246 data->rand[i], GSM_RAND_LEN);
248 if (hexstr2bin(pos, data->kc[i], EAP_SIM_KC_LEN) < 0)
251 data->kc[i], EAP_SIM_KC_LEN);
257 if (hexstr2bin(pos, data->sres[i], EAP_SIM_SRES_LEN) < 0)
260 data->sres[i], EAP_SIM_SRES_LEN);
262 if (i + 1 < data->num_chal) {
279 static int eap_sim_gsm_auth(struct eap_sm *sm, struct eap_sim_data *data)
291 return eap_sim_ext_sim_result(sm, data, conf);
293 return eap_sim_ext_sim_req(sm, data);
298 if (scard_gsm_auth(sm->scard_ctx, data->rand[0],
299 data->sres[0], data->kc[0]) ||
300 scard_gsm_auth(sm->scard_ctx, data->rand[1],
301 data->sres[1], data->kc[1]) ||
302 (data->num_chal > 2 &&
303 scard_gsm_auth(sm->scard_ctx, data->rand[2],
304 data->sres[2], data->kc[2]))) {
336 for (i = 0; i < data->num_chal; i++) {
337 if (gsm_milenage(opc, k, data->rand[i],
338 data->sres[i], data->kc[i])) {
345 data->rand[i], GSM_RAND_LEN);
347 data->sres[i], EAP_SIM_SRES_LEN);
349 data->kc[i], EAP_SIM_KC_LEN);
366 for (i = 0; i < data->num_chal; i++) {
367 if (data->rand[i][0] == 0xaa) {
368 os_memcpy(data->kc[i],
371 os_memcpy(data->sres[i], "\xd1\xd2\xd3\xd4",
373 } else if (data->rand[i][0] == 0xbb) {
374 os_memcpy(data->kc[i],
377 os_memcpy(data->sres[i], "\xe1\xe2\xe3\xe4",
380 os_memcpy(data->kc[i],
383 os_memcpy(data->sres[i], "\xf1\xf2\xf3\xf4",
411 struct eap_sim_data *data, int id)
413 if ((id & CLEAR_PSEUDONYM) && data->pseudonym) {
415 os_free(data->pseudonym);
416 data->pseudonym = NULL;
417 data->pseudonym_len = 0;
418 if (data->use_pseudonym)
421 if ((id & CLEAR_REAUTH_ID) && data->reauth_id) {
423 os_free(data->reauth_id);
424 data->reauth_id = NULL;
425 data->reauth_id_len = 0;
430 static int eap_sim_learn_ids(struct eap_sm *sm, struct eap_sim_data *data,
443 os_free(data->pseudonym);
453 data->pseudonym = os_malloc(attr->next_pseudonym_len +
455 if (data->pseudonym == NULL) {
458 data->pseudonym_len = 0;
461 os_memcpy(data->pseudonym, attr->next_pseudonym,
464 os_memcpy(data->pseudonym + attr->next_pseudonym_len,
467 data->pseudonym_len = attr->next_pseudonym_len + realm_len;
468 if (data->use_pseudonym)
469 eap_set_anon_id(sm, data->pseudonym,
470 data->pseudonym_len);
474 os_free(data->reauth_id);
475 data->reauth_id = os_memdup(attr->next_reauth_id,
477 if (data->reauth_id == NULL) {
480 data->reauth_id_len = 0;
483 data->reauth_id_len = attr->next_reauth_id_len;
486 data->reauth_id,
487 data->reauth_id_len);
494 static struct wpabuf * eap_sim_client_error(struct eap_sim_data *data, u8 id,
499 eap_sim_state(data, FAILURE);
500 data->num_id_req = 0;
501 data->num_notification = 0;
562 struct eap_sim_data *data, u8 id,
573 data->reauth = 0;
574 if (id_req == ANY_ID && data->reauth_id) {
575 identity = data->reauth_id;
576 identity_len = data->reauth_id_len;
577 data->reauth = 1;
579 data->pseudonym &&
580 !eap_sim_anonymous_username(data->pseudonym,
581 data->pseudonym_len)) {
582 identity = data->pseudonym;
583 identity_len = data->pseudonym_len;
584 eap_sim_clear_identities(sm, data, CLEAR_REAUTH_ID);
590 if (data->pseudonym &&
591 eap_sim_anonymous_username(data->pseudonym,
592 data->pseudonym_len))
594 eap_sim_clear_identities(sm, data, ids);
601 if (identity && data->imsi_privacy_key) {
608 data->imsi_privacy_key,
614 data, id,
619 os_free(data->mk_identity);
620 data->mk_identity = os_memdup(identity, identity_len);
621 data->mk_identity_len = identity_len;
640 os_free(data->mk_identity);
641 data->mk_identity = os_memdup(
644 data->mk_identity_len = config->imsi_identity_len;
648 os_free(data->mk_identity);
649 data->mk_identity = os_memdup(identity, identity_len);
650 data->mk_identity_len = identity_len;
654 if (!data->reauth) {
656 data->nonce_mt, EAP_SIM_NONCE_MT_LEN);
658 data->nonce_mt, EAP_SIM_NONCE_MT_LEN);
660 data->selected_version);
662 data->selected_version, NULL, 0);
667 eap_sim_state(data, START_DONE);
672 static struct wpabuf * eap_sim_response_challenge(struct eap_sim_data *data,
680 if (data->use_result_ind) {
686 return eap_sim_msg_finish(msg, EAP_TYPE_SIM, data->k_aut,
687 (u8 *) data->sres,
688 data->num_chal * EAP_SIM_SRES_LEN);
692 static struct wpabuf * eap_sim_response_reauth(struct eap_sim_data *data,
710 counter = data->counter_too_small;
712 counter = data->counter;
717 if (eap_sim_msg_add_encr_end(msg, data->k_encr, EAP_SIM_AT_PADDING)) {
723 if (data->use_result_ind) {
729 return eap_sim_msg_finish(msg, EAP_TYPE_SIM, data->k_aut, nonce_s,
734 static struct wpabuf * eap_sim_response_notification(struct eap_sim_data *data,
738 u8 *k_aut = (notification & 0x4000) == 0 ? data->k_aut : NULL;
743 if (k_aut && data->reauth) {
748 wpa_printf(MSG_DEBUG, " *AT_COUNTER %d", data->counter);
749 eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, data->counter,
751 if (eap_sim_msg_add_encr_end(msg, data->k_encr,
768 struct eap_sim_data *data, u8 id,
779 return eap_sim_client_error(data, id,
783 os_free(data->ver_list);
784 data->ver_list = os_memdup(attr->version_list, attr->version_list_len);
785 if (data->ver_list == NULL) {
788 return eap_sim_client_error(data, id,
791 data->ver_list_len = attr->version_list_len;
792 pos = data->ver_list;
793 for (i = 0; i < data->ver_list_len / 2; i++) {
804 return eap_sim_client_error(data, id,
809 data->selected_version = selected_version;
816 if (data->num_id_req > 0)
818 data->num_id_req++;
821 if (data->num_id_req > 1)
823 data->num_id_req++;
826 if (data->num_id_req > 2)
828 data->num_id_req++;
834 return eap_sim_client_error(data, id,
838 return eap_sim_response_start(sm, data, id, attr->id_req);
843 struct eap_sim_data *data,
854 if (data->state != START_DONE) {
857 eap_sim_state_txt(data->state));
858 return eap_sim_client_error(data, id,
861 data->reauth = 0;
867 return eap_sim_client_error(data, id,
873 if (attr->num_chal < data->min_num_chal) {
876 return eap_sim_client_error(data, id,
882 return eap_sim_client_error(data, id,
896 return eap_sim_client_error(data, id,
900 os_memcpy(data->rand, attr->rand, attr->num_chal * GSM_RAND_LEN);
901 data->num_chal = attr->num_chal;
903 res = eap_sim_gsm_auth(sm, data);
910 return eap_sim_client_error(data, id,
914 identity = data->mk_identity;
915 identity_len = data->mk_identity_len;
918 eap_sim_derive_mk(identity, identity_len, data->nonce_mt,
919 data->selected_version, data->ver_list,
920 data->ver_list_len, data->num_chal,
921 (const u8 *) data->kc, data->mk);
922 eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut, data->msk,
923 data->emsk);
924 if (eap_sim_verify_mac(data->k_aut, reqData, attr->mac, data->nonce_mt,
932 return eap_sim_client_error(data, id,
941 eap_sim_clear_identities(sm, data, CLEAR_REAUTH_ID);
945 decrypted = eap_sim_parse_encr(data->k_encr, attr->encr_data,
950 data, id, EAP_SIM_UNABLE_TO_PROCESS_PACKET);
952 eap_sim_learn_ids(sm, data, &eattr);
956 if (data->result_ind && attr->result_ind)
957 data->use_result_ind = 1;
959 if (data->state != FAILURE) {
960 eap_sim_state(data, data->use_result_ind ?
964 data->num_id_req = 0;
965 data->num_notification = 0;
969 data->counter = 0;
970 return eap_sim_response_challenge(data, id);
974 static int eap_sim_process_notification_reauth(struct eap_sim_data *data,
982 "reauth did not include encrypted data");
986 decrypted = eap_sim_parse_encr(data->k_encr, attr->encr_data,
991 "data from notification message");
995 if (eattr.counter < 0 || (size_t) eattr.counter != data->counter) {
1008 static int eap_sim_process_notification_auth(struct eap_sim_data *data,
1018 if (eap_sim_verify_mac(data->k_aut, reqData, attr->mac, (u8 *) "", 0))
1025 if (data->reauth &&
1026 eap_sim_process_notification_reauth(data, attr)) {
1037 struct eap_sm *sm, struct eap_sim_data *data, u8 id,
1041 if (data->num_notification > 0) {
1044 return eap_sim_client_error(data, id,
1047 data->num_notification++;
1051 return eap_sim_client_error(data, id,
1056 eap_sim_process_notification_auth(data, reqData, attr)) {
1057 return eap_sim_client_error(data, id,
1063 data->error_code = attr->notification;
1064 eap_sim_state(data, FAILURE);
1066 data->state == RESULT_SUCCESS)
1067 eap_sim_state(data, SUCCESS);
1068 return eap_sim_response_notification(data, id, attr->notification);
1073 struct eap_sm *sm, struct eap_sim_data *data, u8 id,
1081 if (data->reauth_id == NULL) {
1084 return eap_sim_client_error(data, id,
1088 data->reauth = 1;
1089 if (eap_sim_verify_mac(data->k_aut, reqData, attr->mac, (u8 *) "", 0))
1097 return eap_sim_client_error(data, id,
1108 os_memcpy(data->reauth_mac, attr->mac, EAP_SIM_MAC_LEN);
1110 os_memset(data->reauth_mac, 0x12, EAP_SIM_MAC_LEN);
1112 os_memcpy(data->reauth_mac, attr->mac, EAP_SIM_MAC_LEN);
1115 data->reauth_mac, EAP_SIM_MAC_LEN);
1119 "message did not include encrypted data");
1120 return eap_sim_client_error(data, id,
1124 decrypted = eap_sim_parse_encr(data->k_encr, attr->encr_data,
1129 "data from reauthentication message");
1130 return eap_sim_client_error(data, id,
1139 return eap_sim_client_error(data, id,
1143 if (eattr.counter < 0 || (size_t) eattr.counter <= data->counter) {
1146 "(%d <= %d)", eattr.counter, data->counter);
1147 data->counter_too_small = eattr.counter;
1152 eap_sim_clear_identities(sm, data, CLEAR_REAUTH_ID);
1154 res = eap_sim_response_reauth(data, id, 1, eattr.nonce_s);
1159 data->counter = eattr.counter;
1161 os_memcpy(data->nonce_s, eattr.nonce_s, EAP_SIM_NONCE_S_LEN);
1163 data->nonce_s, EAP_SIM_NONCE_S_LEN);
1165 eap_sim_derive_keys_reauth(data->counter,
1166 data->reauth_id, data->reauth_id_len,
1167 data->nonce_s, data->mk, data->msk,
1168 data->emsk);
1169 eap_sim_clear_identities(sm, data, CLEAR_REAUTH_ID);
1170 eap_sim_learn_ids(sm, data, &eattr);
1172 if (data->result_ind && attr->result_ind)
1173 data->use_result_ind = 1;
1175 if (data->state != FAILURE) {
1176 eap_sim_state(data, data->use_result_ind ?
1180 data->num_id_req = 0;
1181 data->num_notification = 0;
1182 if (data->counter > EAP_SIM_MAX_FAST_REAUTHS) {
1185 eap_sim_clear_identities(sm, data, CLEAR_REAUTH_ID);
1188 return eap_sim_response_reauth(data, id, 0, data->nonce_s);
1196 struct eap_sim_data *data = priv;
1204 wpa_hexdump_buf(MSG_DEBUG, "EAP-SIM: EAP data", reqData);
1232 res = eap_sim_client_error(data, id,
1239 res = eap_sim_process_start(sm, data, id, &attr);
1242 res = eap_sim_process_challenge(sm, data, id, reqData, &attr);
1245 res = eap_sim_process_notification(sm, data, id, reqData,
1249 res = eap_sim_process_reauthentication(sm, data, id, reqData,
1254 res = eap_sim_client_error(data, id,
1259 res = eap_sim_client_error(data, id,
1265 if (data->state == FAILURE) {
1268 } else if (data->state == SUCCESS) {
1269 ret->decision = data->use_result_ind ?
1271 ret->methodState = data->use_result_ind ?
1273 } else if (data->state == RESULT_SUCCESS)
1286 struct eap_sim_data *data = priv;
1287 return data->pseudonym || data->reauth_id;
1293 struct eap_sim_data *data = priv;
1295 os_free(data->mk_identity);
1296 data->mk_identity = NULL;
1297 data->mk_identity_len = 0;
1298 data->use_result_ind = 0;
1299 eap_sim_clear_keys(data, 1);
1305 struct eap_sim_data *data = priv;
1306 if (random_get_bytes(data->nonce_mt, EAP_SIM_NONCE_MT_LEN)) {
1307 wpa_printf(MSG_WARNING, "EAP-SIM: Failed to get random data "
1309 eap_sim_deinit(sm, data);
1316 os_free(data->mk_identity);
1317 data->mk_identity = os_memdup(sm->identity, sm->identity_len);
1318 data->mk_identity_len = sm->identity_len;
1321 data->num_id_req = 0;
1322 data->num_notification = 0;
1323 eap_sim_state(data, CONTINUE);
1331 struct eap_sim_data *data = priv;
1333 if (data->reauth_id) {
1334 *len = data->reauth_id_len;
1335 return data->reauth_id;
1338 if (data->pseudonym) {
1339 *len = data->pseudonym_len;
1340 return data->pseudonym;
1349 struct eap_sim_data *data = priv;
1350 return data->state == SUCCESS;
1356 struct eap_sim_data *data = priv;
1359 if (data->state != SUCCESS)
1362 key = os_memdup(data->msk, EAP_SIM_KEYING_DATA_LEN);
1374 struct eap_sim_data *data = priv;
1377 if (data->state != SUCCESS)
1380 if (!data->reauth)
1381 *len = 1 + data->num_chal * GSM_RAND_LEN + EAP_SIM_NONCE_MT_LEN;
1389 if (!data->reauth) {
1390 os_memcpy(id + 1, data->rand, data->num_chal * GSM_RAND_LEN);
1391 os_memcpy(id + 1 + data->num_chal * GSM_RAND_LEN,
1392 data->nonce_mt, EAP_SIM_NONCE_MT_LEN);
1394 os_memcpy(id + 1, data->nonce_s, EAP_SIM_NONCE_S_LEN);
1395 os_memcpy(id + 1 + EAP_SIM_NONCE_S_LEN, data->reauth_mac,
1406 struct eap_sim_data *data = priv;
1409 if (data->state != SUCCESS)
1412 key = os_memdup(data->emsk, EAP_EMSK_LEN);
1424 struct eap_sim_data *data = priv;
1427 if (!data)
1430 current_data_error = data->error_code;
1433 data->error_code = NO_EAP_METHOD_ERROR;