xref: /freebsd/contrib/wpa/src/eap_server/eap_server_sim.c (revision bb15ca603fa442c72dde3f3cb8b46db6970e3950)
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 
23 struct 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 
47 static 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 
68 static 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 
77 static 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 
95 static 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 
104 static 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 
134 static 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 
198 static 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 
228 static 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 
265 static 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 
304 static 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 
326 static 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 
383 static int eap_sim_supported_ver(struct eap_sim_data *data, int version)
384 {
385 	return version == EAP_SIM_VERSION;
386 }
387 
388 
389 static 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 
508 static 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 
558 static 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 
641 fail:
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 
649 static 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 
663 static 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 
676 static 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 
725 static 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 
732 static 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 
749 static 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 
766 static 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 
773 int 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