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