]> git.ipfire.org Git - thirdparty/hostap.git/blob - src/eap_server/eap_server.c
projects / thirdparty / hostap.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
EAP server: Configurable maximum number of authentication message rounds
[thirdparty/hostap.git] / src / eap_server / eap_server.c
1 /*
2 * hostapd / EAP Full Authenticator state machine (RFC 4137)
3 * Copyright (c) 2004-2014, 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 * This state machine is based on the full authenticator state machine defined
9 * in RFC 4137. However, to support backend authentication in RADIUS
10 * authentication server functionality, parts of backend authenticator (also
11 * from RFC 4137) are mixed in. This functionality is enabled by setting
12 * backend_auth configuration variable to TRUE.
13 */
14
15 #include "includes.h"
16
17 #include "common.h"
18 #include "crypto/sha256.h"
19 #include "eap_i.h"
20 #include "state_machine.h"
21 #include "common/wpa_ctrl.h"
22
23 #define STATE_MACHINE_DATA struct eap_sm
24 #define STATE_MACHINE_DEBUG_PREFIX "EAP"
25
26 /* EAP state machines are described in RFC 4137 */
27
28 static int eap_sm_calculateTimeout(struct eap_sm *sm, int retransCount,
29 int eapSRTT, int eapRTTVAR,
30 int methodTimeout);
31 static void eap_sm_parseEapResp(struct eap_sm *sm, const struct wpabuf *resp);
32 static int eap_sm_getId(const struct wpabuf *data);
33 static struct wpabuf * eap_sm_buildSuccess(struct eap_sm *sm, u8 id);
34 static struct wpabuf * eap_sm_buildFailure(struct eap_sm *sm, u8 id);
35 static int eap_sm_nextId(struct eap_sm *sm, int id);
36 static void eap_sm_Policy_update(struct eap_sm *sm, const u8 *nak_list,
37 size_t len);
38 static enum eap_type eap_sm_Policy_getNextMethod(struct eap_sm *sm,
39 int *vendor);
40 static int eap_sm_Policy_getDecision(struct eap_sm *sm);
41 static Boolean eap_sm_Policy_doPickUp(struct eap_sm *sm, enum eap_type method);
42
43
44 static int eap_get_erp_send_reauth_start(struct eap_sm *sm)
45 {
46 if (sm->eapol_cb->get_erp_send_reauth_start)
47 return sm->eapol_cb->get_erp_send_reauth_start(sm->eapol_ctx);
48 return 0;
49 }
50
51
52 static const char * eap_get_erp_domain(struct eap_sm *sm)
53 {
54 if (sm->eapol_cb->get_erp_domain)
55 return sm->eapol_cb->get_erp_domain(sm->eapol_ctx);
56 return NULL;
57 }
58
59
60 #ifdef CONFIG_ERP
61
62 static struct eap_server_erp_key * eap_erp_get_key(struct eap_sm *sm,
63 const char *keyname)
64 {
65 if (sm->eapol_cb->erp_get_key)
66 return sm->eapol_cb->erp_get_key(sm->eapol_ctx, keyname);
67 return NULL;
68 }
69
70
71 static int eap_erp_add_key(struct eap_sm *sm, struct eap_server_erp_key *erp)
72 {
73 if (sm->eapol_cb->erp_add_key)
74 return sm->eapol_cb->erp_add_key(sm->eapol_ctx, erp);
75 return -1;
76 }
77
78 #endif /* CONFIG_ERP */
79
80
81 static struct wpabuf * eap_sm_buildInitiateReauthStart(struct eap_sm *sm,
82 u8 id)
83 {
84 const char *domain;
85 size_t plen = 1;
86 struct wpabuf *msg;
87 size_t domain_len = 0;
88
89 domain = eap_get_erp_domain(sm);
90 if (domain) {
91 domain_len = os_strlen(domain);
92 plen += 2 + domain_len;
93 }
94
95 msg = eap_msg_alloc(EAP_VENDOR_IETF,
96 (enum eap_type) EAP_ERP_TYPE_REAUTH_START, plen,
97 EAP_CODE_INITIATE, id);
98 if (msg == NULL)
99 return NULL;
100 wpabuf_put_u8(msg, 0); /* Reserved */
101 if (domain) {
102 /* Domain name TLV */
103 wpabuf_put_u8(msg, EAP_ERP_TLV_DOMAIN_NAME);
104 wpabuf_put_u8(msg, domain_len);
105 wpabuf_put_data(msg, domain, domain_len);
106 }
107
108 return msg;
109 }
110
111
112 static int eap_copy_buf(struct wpabuf **dst, const struct wpabuf *src)
113 {
114 if (src == NULL)
115 return -1;
116
117 wpabuf_free(*dst);
118 *dst = wpabuf_dup(src);
119 return *dst ? 0 : -1;
120 }
121
122
123 static int eap_copy_data(u8 **dst, size_t *dst_len,
124 const u8 *src, size_t src_len)
125 {
126 if (src == NULL)
127 return -1;
128
129 os_free(*dst);
130 *dst = os_malloc(src_len);
131 if (*dst) {
132 os_memcpy(*dst, src, src_len);
133 *dst_len = src_len;
134 return 0;
135 } else {
136 *dst_len = 0;
137 return -1;
138 }
139 }
140
141 #define EAP_COPY(dst, src) \
142 eap_copy_data((dst), (dst ## Len), (src), (src ## Len))
143
144
145 /**
146 * eap_user_get - Fetch user information from the database
147 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
148 * @identity: Identity (User-Name) of the user
149 * @identity_len: Length of identity in bytes
150 * @phase2: 0 = EAP phase1 user, 1 = EAP phase2 (tunneled) user
151 * Returns: 0 on success, or -1 on failure
152 *
153 * This function is used to fetch user information for EAP. The user will be
154 * selected based on the specified identity. sm->user and
155 * sm->user_eap_method_index are updated for the new user when a matching user
156 * is found. sm->user can be used to get user information (e.g., password).
157 */
158 int eap_user_get(struct eap_sm *sm, const u8 *identity, size_t identity_len,
159 int phase2)
160 {
161 struct eap_user *user;
162
163 if (sm == NULL || sm->eapol_cb == NULL ||
164 sm->eapol_cb->get_eap_user == NULL)
165 return -1;
166
167 eap_user_free(sm->user);
168 sm->user = NULL;
169
170 user = os_zalloc(sizeof(*user));
171 if (user == NULL)
172 return -1;
173
174 if (sm->eapol_cb->get_eap_user(sm->eapol_ctx, identity,
175 identity_len, phase2, user) != 0) {
176 eap_user_free(user);
177 return -1;
178 }
179
180 sm->user = user;
181 sm->user_eap_method_index = 0;
182
183 return 0;
184 }
185
186
187 void eap_log_msg(struct eap_sm *sm, const char *fmt, ...)
188 {
189 va_list ap;
190 char *buf;
191 int buflen;
192
193 if (sm == NULL || sm->eapol_cb == NULL || sm->eapol_cb->log_msg == NULL)
194 return;
195
196 va_start(ap, fmt);
197 buflen = vsnprintf(NULL, 0, fmt, ap) + 1;
198 va_end(ap);
199
200 buf = os_malloc(buflen);
201 if (buf == NULL)
202 return;
203 va_start(ap, fmt);
204 vsnprintf(buf, buflen, fmt, ap);
205 va_end(ap);
206
207 sm->eapol_cb->log_msg(sm->eapol_ctx, buf);
208
209 os_free(buf);
210 }
211
212
213 SM_STATE(EAP, DISABLED)
214 {
215 SM_ENTRY(EAP, DISABLED);
216 sm->num_rounds = 0;
217 sm->num_rounds_short = 0;
218 }
219
220
221 SM_STATE(EAP, INITIALIZE)
222 {
223 SM_ENTRY(EAP, INITIALIZE);
224
225 if (sm->eap_if.eapRestart && !sm->cfg->eap_server && sm->identity) {
226 /*
227 * Need to allow internal Identity method to be used instead
228 * of passthrough at the beginning of reauthentication.
229 */
230 eap_server_clear_identity(sm);
231 }
232
233 sm->try_initiate_reauth = FALSE;
234 sm->currentId = -1;
235 sm->eap_if.eapSuccess = FALSE;
236 sm->eap_if.eapFail = FALSE;
237 sm->eap_if.eapTimeout = FALSE;
238 bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen);
239 sm->eap_if.eapKeyData = NULL;
240 sm->eap_if.eapKeyDataLen = 0;
241 os_free(sm->eap_if.eapSessionId);
242 sm->eap_if.eapSessionId = NULL;
243 sm->eap_if.eapSessionIdLen = 0;
244 sm->eap_if.eapKeyAvailable = FALSE;
245 sm->eap_if.eapRestart = FALSE;
246
247 /*
248 * This is not defined in RFC 4137, but method state needs to be
249 * reseted here so that it does not remain in success state when
250 * re-authentication starts.
251 */
252 if (sm->m && sm->eap_method_priv) {
253 sm->m->reset(sm, sm->eap_method_priv);
254 sm->eap_method_priv = NULL;
255 }
256 sm->m = NULL;
257 sm->user_eap_method_index = 0;
258
259 if (sm->cfg->backend_auth) {
260 sm->currentMethod = EAP_TYPE_NONE;
261 /* parse rxResp, respId, respMethod */
262 eap_sm_parseEapResp(sm, sm->eap_if.eapRespData);
263 if (sm->rxResp) {
264 sm->currentId = sm->respId;
265 }
266 }
267 sm->num_rounds = 0;
268 sm->num_rounds_short = 0;
269 sm->method_pending = METHOD_PENDING_NONE;
270
271 wpa_msg(sm->cfg->msg_ctx, MSG_INFO, WPA_EVENT_EAP_STARTED
272 MACSTR, MAC2STR(sm->peer_addr));
273 }
274
275
276 SM_STATE(EAP, PICK_UP_METHOD)
277 {
278 SM_ENTRY(EAP, PICK_UP_METHOD);
279
280 if (eap_sm_Policy_doPickUp(sm, sm->respMethod)) {
281 sm->currentMethod = sm->respMethod;
282 if (sm->m && sm->eap_method_priv) {
283 sm->m->reset(sm, sm->eap_method_priv);
284 sm->eap_method_priv = NULL;
285 }
286 sm->m = eap_server_get_eap_method(EAP_VENDOR_IETF,
287 sm->currentMethod);
288 if (sm->m && sm->m->initPickUp) {
289 sm->eap_method_priv = sm->m->initPickUp(sm);
290 if (sm->eap_method_priv == NULL) {
291 wpa_printf(MSG_DEBUG, "EAP: Failed to "
292 "initialize EAP method %d",
293 sm->currentMethod);
294 sm->m = NULL;
295 sm->currentMethod = EAP_TYPE_NONE;
296 }
297 } else {
298 sm->m = NULL;
299 sm->currentMethod = EAP_TYPE_NONE;
300 }
301 }
302
303 wpa_msg(sm->cfg->msg_ctx, MSG_INFO, WPA_EVENT_EAP_PROPOSED_METHOD
304 "method=%u", sm->currentMethod);
305 }
306
307
308 SM_STATE(EAP, IDLE)
309 {
310 SM_ENTRY(EAP, IDLE);
311
312 sm->eap_if.retransWhile = eap_sm_calculateTimeout(
313 sm, sm->retransCount, sm->eap_if.eapSRTT, sm->eap_if.eapRTTVAR,
314 sm->methodTimeout);
315 }
316
317
318 SM_STATE(EAP, RETRANSMIT)
319 {
320 SM_ENTRY(EAP, RETRANSMIT);
321
322 sm->retransCount++;
323 if (sm->retransCount <= sm->MaxRetrans && sm->lastReqData) {
324 if (eap_copy_buf(&sm->eap_if.eapReqData, sm->lastReqData) == 0)
325 sm->eap_if.eapReq = TRUE;
326 }
327
328 wpa_msg(sm->cfg->msg_ctx, MSG_INFO, WPA_EVENT_EAP_RETRANSMIT MACSTR,
329 MAC2STR(sm->peer_addr));
330 }
331
332
333 SM_STATE(EAP, RECEIVED)
334 {
335 SM_ENTRY(EAP, RECEIVED);
336
337 /* parse rxResp, respId, respMethod */
338 eap_sm_parseEapResp(sm, sm->eap_if.eapRespData);
339 sm->num_rounds++;
340 if (!sm->eap_if.eapRespData || wpabuf_len(sm->eap_if.eapRespData) < 20)
341 sm->num_rounds_short++;
342 else
343 sm->num_rounds_short = 0;
344 }
345
346
347 SM_STATE(EAP, DISCARD)
348 {
349 SM_ENTRY(EAP, DISCARD);
350 sm->eap_if.eapResp = FALSE;
351 sm->eap_if.eapNoReq = TRUE;
352 }
353
354
355 SM_STATE(EAP, SEND_REQUEST)
356 {
357 SM_ENTRY(EAP, SEND_REQUEST);
358
359 sm->retransCount = 0;
360 if (sm->eap_if.eapReqData) {
361 if (wpabuf_len(sm->eap_if.eapReqData) >= 20)
362 sm->num_rounds_short = 0;
363 if (eap_copy_buf(&sm->lastReqData, sm->eap_if.eapReqData) == 0)
364 {
365 sm->eap_if.eapResp = FALSE;
366 sm->eap_if.eapReq = TRUE;
367 } else {
368 sm->eap_if.eapResp = FALSE;
369 sm->eap_if.eapReq = FALSE;
370 }
371 } else {
372 wpa_printf(MSG_INFO, "EAP: SEND_REQUEST - no eapReqData");
373 sm->eap_if.eapResp = FALSE;
374 sm->eap_if.eapReq = FALSE;
375 sm->eap_if.eapNoReq = TRUE;
376 }
377 }
378
379
380 SM_STATE(EAP, INTEGRITY_CHECK)
381 {
382 SM_ENTRY(EAP, INTEGRITY_CHECK);
383
384 if (!eap_hdr_len_valid(sm->eap_if.eapRespData, 1)) {
385 sm->ignore = TRUE;
386 return;
387 }
388
389 if (sm->m->check) {
390 sm->ignore = sm->m->check(sm, sm->eap_method_priv,
391 sm->eap_if.eapRespData);
392 }
393 }
394
395
396 SM_STATE(EAP, METHOD_REQUEST)
397 {
398 SM_ENTRY(EAP, METHOD_REQUEST);
399
400 if (sm->m == NULL) {
401 wpa_printf(MSG_DEBUG, "EAP: method not initialized");
402 return;
403 }
404
405 sm->currentId = eap_sm_nextId(sm, sm->currentId);
406 wpa_printf(MSG_DEBUG, "EAP: building EAP-Request: Identifier %d",
407 sm->currentId);
408 sm->lastId = sm->currentId;
409 wpabuf_free(sm->eap_if.eapReqData);
410 sm->eap_if.eapReqData = sm->m->buildReq(sm, sm->eap_method_priv,
411 sm->currentId);
412 if (sm->m->getTimeout)
413 sm->methodTimeout = sm->m->getTimeout(sm, sm->eap_method_priv);
414 else
415 sm->methodTimeout = 0;
416 }
417
418
419 static void eap_server_erp_init(struct eap_sm *sm)
420 {
421 #ifdef CONFIG_ERP
422 u8 *emsk = NULL;
423 size_t emsk_len = 0;
424 u8 EMSKname[EAP_EMSK_NAME_LEN];
425 u8 len[2], ctx[3];
426 const char *domain;
427 size_t domain_len, nai_buf_len;
428 struct eap_server_erp_key *erp = NULL;
429 int pos;
430
431 domain = eap_get_erp_domain(sm);
432 if (!domain)
433 return;
434
435 domain_len = os_strlen(domain);
436
437 nai_buf_len = 2 * EAP_EMSK_NAME_LEN + 1 + domain_len;
438 if (nai_buf_len > 253) {
439 /*
440 * keyName-NAI has a maximum length of 253 octet to fit in
441 * RADIUS attributes.
442 */
443 wpa_printf(MSG_DEBUG,
444 "EAP: Too long realm for ERP keyName-NAI maximum length");
445 return;
446 }
447 nai_buf_len++; /* null termination */
448 erp = os_zalloc(sizeof(*erp) + nai_buf_len);
449 if (erp == NULL)
450 goto fail;
451 erp->recv_seq = (u32) -1;
452
453 emsk = sm->m->get_emsk(sm, sm->eap_method_priv, &emsk_len);
454 if (!emsk || emsk_len == 0 || emsk_len > ERP_MAX_KEY_LEN) {
455 wpa_printf(MSG_DEBUG,
456 "EAP: No suitable EMSK available for ERP");
457 goto fail;
458 }
459
460 wpa_hexdump_key(MSG_DEBUG, "EAP: EMSK", emsk, emsk_len);
461
462 WPA_PUT_BE16(len, EAP_EMSK_NAME_LEN);
463 if (hmac_sha256_kdf(sm->eap_if.eapSessionId, sm->eap_if.eapSessionIdLen,
464 "EMSK", len, sizeof(len),
465 EMSKname, EAP_EMSK_NAME_LEN) < 0) {
466 wpa_printf(MSG_DEBUG, "EAP: Could not derive EMSKname");
467 goto fail;
468 }
469 wpa_hexdump(MSG_DEBUG, "EAP: EMSKname", EMSKname, EAP_EMSK_NAME_LEN);
470
471 pos = wpa_snprintf_hex(erp->keyname_nai, nai_buf_len,
472 EMSKname, EAP_EMSK_NAME_LEN);
473 erp->keyname_nai[pos] = '@';
474 os_memcpy(&erp->keyname_nai[pos + 1], domain, domain_len);
475
476 WPA_PUT_BE16(len, emsk_len);
477 if (hmac_sha256_kdf(emsk, emsk_len,
478 "EAP Re-authentication Root Key@ietf.org",
479 len, sizeof(len), erp->rRK, emsk_len) < 0) {
480 wpa_printf(MSG_DEBUG, "EAP: Could not derive rRK for ERP");
481 goto fail;
482 }
483 erp->rRK_len = emsk_len;
484 wpa_hexdump_key(MSG_DEBUG, "EAP: ERP rRK", erp->rRK, erp->rRK_len);
485
486 ctx[0] = EAP_ERP_CS_HMAC_SHA256_128;
487 WPA_PUT_BE16(&ctx[1], erp->rRK_len);
488 if (hmac_sha256_kdf(erp->rRK, erp->rRK_len,
489 "Re-authentication Integrity Key@ietf.org",
490 ctx, sizeof(ctx), erp->rIK, erp->rRK_len) < 0) {
491 wpa_printf(MSG_DEBUG, "EAP: Could not derive rIK for ERP");
492 goto fail;
493 }
494 erp->rIK_len = erp->rRK_len;
495 wpa_hexdump_key(MSG_DEBUG, "EAP: ERP rIK", erp->rIK, erp->rIK_len);
496
497 if (eap_erp_add_key(sm, erp) == 0) {
498 wpa_printf(MSG_DEBUG, "EAP: Stored ERP keys %s",
499 erp->keyname_nai);
500 erp = NULL;
501 }
502
503 fail:
504 bin_clear_free(emsk, emsk_len);
505 bin_clear_free(erp, sizeof(*erp));
506 #endif /* CONFIG_ERP */
507 }
508
509
510 SM_STATE(EAP, METHOD_RESPONSE)
511 {
512 SM_ENTRY(EAP, METHOD_RESPONSE);
513
514 if (!eap_hdr_len_valid(sm->eap_if.eapRespData, 1))
515 return;
516
517 sm->m->process(sm, sm->eap_method_priv, sm->eap_if.eapRespData);
518 if (sm->m->isDone(sm, sm->eap_method_priv)) {
519 eap_sm_Policy_update(sm, NULL, 0);
520 bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen);
521 if (sm->m->getKey) {
522 sm->eap_if.eapKeyData = sm->m->getKey(
523 sm, sm->eap_method_priv,
524 &sm->eap_if.eapKeyDataLen);
525 } else {
526 sm->eap_if.eapKeyData = NULL;
527 sm->eap_if.eapKeyDataLen = 0;
528 }
529 os_free(sm->eap_if.eapSessionId);
530 sm->eap_if.eapSessionId = NULL;
531 if (sm->m->getSessionId) {
532 sm->eap_if.eapSessionId = sm->m->getSessionId(
533 sm, sm->eap_method_priv,
534 &sm->eap_if.eapSessionIdLen);
535 wpa_hexdump(MSG_DEBUG, "EAP: Session-Id",
536 sm->eap_if.eapSessionId,
537 sm->eap_if.eapSessionIdLen);
538 }
539 if (sm->cfg->erp && sm->m->get_emsk && sm->eap_if.eapSessionId)
540 eap_server_erp_init(sm);
541 sm->methodState = METHOD_END;
542 } else {
543 sm->methodState = METHOD_CONTINUE;
544 }
545 }
546
547
548 SM_STATE(EAP, PROPOSE_METHOD)
549 {
550 int vendor;
551 enum eap_type type;
552
553 SM_ENTRY(EAP, PROPOSE_METHOD);
554
555 sm->try_initiate_reauth = FALSE;
556 try_another_method:
557 type = eap_sm_Policy_getNextMethod(sm, &vendor);
558 if (vendor == EAP_VENDOR_IETF)
559 sm->currentMethod = type;
560 else
561 sm->currentMethod = EAP_TYPE_EXPANDED;
562 if (sm->m && sm->eap_method_priv) {
563 sm->m->reset(sm, sm->eap_method_priv);
564 sm->eap_method_priv = NULL;
565 }
566 sm->m = eap_server_get_eap_method(vendor, type);
567 if (sm->m) {
568 sm->eap_method_priv = sm->m->init(sm);
569 if (sm->eap_method_priv == NULL) {
570 wpa_printf(MSG_DEBUG, "EAP: Failed to initialize EAP "
571 "method %d", sm->currentMethod);
572 sm->m = NULL;
573 sm->currentMethod = EAP_TYPE_NONE;
574 goto try_another_method;
575 }
576 }
577 if (sm->m == NULL) {
578 wpa_printf(MSG_DEBUG, "EAP: Could not find suitable EAP method");
579 eap_log_msg(sm, "Could not find suitable EAP method");
580 sm->decision = DECISION_FAILURE;
581 return;
582 }
583 if (sm->currentMethod == EAP_TYPE_IDENTITY ||
584 sm->currentMethod == EAP_TYPE_NOTIFICATION)
585 sm->methodState = METHOD_CONTINUE;
586 else
587 sm->methodState = METHOD_PROPOSED;
588
589 wpa_msg(sm->cfg->msg_ctx, MSG_INFO, WPA_EVENT_EAP_PROPOSED_METHOD
590 "vendor=%u method=%u", vendor, sm->currentMethod);
591 eap_log_msg(sm, "Propose EAP method vendor=%u method=%u",
592 vendor, sm->currentMethod);
593 }
594
595
596 SM_STATE(EAP, NAK)
597 {
598 const struct eap_hdr *nak;
599 size_t len = 0;
600 const u8 *pos;
601 const u8 *nak_list = NULL;
602
603 SM_ENTRY(EAP, NAK);
604
605 if (sm->eap_method_priv) {
606 sm->m->reset(sm, sm->eap_method_priv);
607 sm->eap_method_priv = NULL;
608 }
609 sm->m = NULL;
610
611 if (!eap_hdr_len_valid(sm->eap_if.eapRespData, 1))
612 return;
613
614 nak = wpabuf_head(sm->eap_if.eapRespData);
615 if (nak && wpabuf_len(sm->eap_if.eapRespData) > sizeof(*nak)) {
616 len = be_to_host16(nak->length);
617 if (len > wpabuf_len(sm->eap_if.eapRespData))
618 len = wpabuf_len(sm->eap_if.eapRespData);
619 pos = (const u8 *) (nak + 1);
620 len -= sizeof(*nak);
621 if (*pos == EAP_TYPE_NAK) {
622 pos++;
623 len--;
624 nak_list = pos;
625 }
626 }
627 eap_sm_Policy_update(sm, nak_list, len);
628 }
629
630
631 SM_STATE(EAP, SELECT_ACTION)
632 {
633 SM_ENTRY(EAP, SELECT_ACTION);
634
635 sm->decision = eap_sm_Policy_getDecision(sm);
636 }
637
638
639 SM_STATE(EAP, TIMEOUT_FAILURE)
640 {
641 SM_ENTRY(EAP, TIMEOUT_FAILURE);
642
643 sm->eap_if.eapTimeout = TRUE;
644
645 wpa_msg(sm->cfg->msg_ctx, MSG_INFO,
646 WPA_EVENT_EAP_TIMEOUT_FAILURE MACSTR, MAC2STR(sm->peer_addr));
647 }
648
649
650 SM_STATE(EAP, FAILURE)
651 {
652 SM_ENTRY(EAP, FAILURE);
653
654 wpabuf_free(sm->eap_if.eapReqData);
655 sm->eap_if.eapReqData = eap_sm_buildFailure(sm, sm->currentId);
656 wpabuf_free(sm->lastReqData);
657 sm->lastReqData = NULL;
658 sm->eap_if.eapFail = TRUE;
659
660 wpa_msg(sm->cfg->msg_ctx, MSG_INFO, WPA_EVENT_EAP_FAILURE
661 MACSTR, MAC2STR(sm->peer_addr));
662 }
663
664
665 SM_STATE(EAP, SUCCESS)
666 {
667 SM_ENTRY(EAP, SUCCESS);
668
669 wpabuf_free(sm->eap_if.eapReqData);
670 sm->eap_if.eapReqData = eap_sm_buildSuccess(sm, sm->currentId);
671 wpabuf_free(sm->lastReqData);
672 sm->lastReqData = NULL;
673 if (sm->eap_if.eapKeyData)
674 sm->eap_if.eapKeyAvailable = TRUE;
675 sm->eap_if.eapSuccess = TRUE;
676
677 wpa_msg(sm->cfg->msg_ctx, MSG_INFO, WPA_EVENT_EAP_SUCCESS
678 MACSTR, MAC2STR(sm->peer_addr));
679 }
680
681
682 SM_STATE(EAP, INITIATE_REAUTH_START)
683 {
684 SM_ENTRY(EAP, INITIATE_REAUTH_START);
685
686 sm->initiate_reauth_start_sent = TRUE;
687 sm->try_initiate_reauth = TRUE;
688 sm->currentId = eap_sm_nextId(sm, sm->currentId);
689 wpa_printf(MSG_DEBUG,
690 "EAP: building EAP-Initiate-Re-auth-Start: Identifier %d",
691 sm->currentId);
692 sm->lastId = sm->currentId;
693 wpabuf_free(sm->eap_if.eapReqData);
694 sm->eap_if.eapReqData = eap_sm_buildInitiateReauthStart(sm,
695 sm->currentId);
696 wpabuf_free(sm->lastReqData);
697 sm->lastReqData = NULL;
698 }
699
700
701 #ifdef CONFIG_ERP
702
703 static void erp_send_finish_reauth(struct eap_sm *sm,
704 struct eap_server_erp_key *erp, u8 id,
705 u8 flags, u16 seq, const char *nai)
706 {
707 size_t plen;
708 struct wpabuf *msg;
709 u8 hash[SHA256_MAC_LEN];
710 size_t hash_len;
711 u8 seed[4];
712
713 if (erp) {
714 switch (erp->cryptosuite) {
715 case EAP_ERP_CS_HMAC_SHA256_256:
716 hash_len = 32;
717 break;
718 case EAP_ERP_CS_HMAC_SHA256_128:
719 hash_len = 16;
720 break;
721 default:
722 return;
723 }
724 } else
725 hash_len = 0;
726
727 plen = 1 + 2 + 2 + os_strlen(nai);
728 if (hash_len)
729 plen += 1 + hash_len;
730 msg = eap_msg_alloc(EAP_VENDOR_IETF,
731 (enum eap_type) EAP_ERP_TYPE_REAUTH,
732 plen, EAP_CODE_FINISH, id);
733 if (msg == NULL)
734 return;
735 wpabuf_put_u8(msg, flags);
736 wpabuf_put_be16(msg, seq);
737
738 wpabuf_put_u8(msg, EAP_ERP_TLV_KEYNAME_NAI);
739 wpabuf_put_u8(msg, os_strlen(nai));
740 wpabuf_put_str(msg, nai);
741
742 if (erp) {
743 wpabuf_put_u8(msg, erp->cryptosuite);
744 if (hmac_sha256(erp->rIK, erp->rIK_len,
745 wpabuf_head(msg), wpabuf_len(msg), hash) < 0) {
746 wpabuf_free(msg);
747 return;
748 }
749 wpabuf_put_data(msg, hash, hash_len);
750 }
751
752 wpa_printf(MSG_DEBUG, "EAP: Send EAP-Finish/Re-auth (%s)",
753 flags & 0x80 ? "failure" : "success");
754
755 sm->lastId = sm->currentId;
756 sm->currentId = id;
757 wpabuf_free(sm->eap_if.eapReqData);
758 sm->eap_if.eapReqData = msg;
759 wpabuf_free(sm->lastReqData);
760 sm->lastReqData = NULL;
761
762 if ((flags & 0x80) || !erp) {
763 sm->eap_if.eapFail = TRUE;
764 wpa_msg(sm->cfg->msg_ctx, MSG_INFO, WPA_EVENT_EAP_FAILURE
765 MACSTR, MAC2STR(sm->peer_addr));
766 return;
767 }
768
769 bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen);
770 sm->eap_if.eapKeyDataLen = 0;
771 sm->eap_if.eapKeyData = os_malloc(erp->rRK_len);
772 if (!sm->eap_if.eapKeyData)
773 return;
774
775 WPA_PUT_BE16(seed, seq);
776 WPA_PUT_BE16(&seed[2], erp->rRK_len);
777 if (hmac_sha256_kdf(erp->rRK, erp->rRK_len,
778 "Re-authentication Master Session Key@ietf.org",
779 seed, sizeof(seed),
780 sm->eap_if.eapKeyData, erp->rRK_len) < 0) {
781 wpa_printf(MSG_DEBUG, "EAP: Could not derive rMSK for ERP");
782 bin_clear_free(sm->eap_if.eapKeyData, erp->rRK_len);
783 sm->eap_if.eapKeyData = NULL;
784 return;
785 }
786 sm->eap_if.eapKeyDataLen = erp->rRK_len;
787 sm->eap_if.eapKeyAvailable = TRUE;
788 wpa_hexdump_key(MSG_DEBUG, "EAP: ERP rMSK",
789 sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen);
790 sm->eap_if.eapSuccess = TRUE;
791
792 wpa_msg(sm->cfg->msg_ctx, MSG_INFO, WPA_EVENT_EAP_SUCCESS
793 MACSTR, MAC2STR(sm->peer_addr));
794 }
795
796
797 SM_STATE(EAP, INITIATE_RECEIVED)
798 {
799 const u8 *pos, *end, *start, *tlvs, *hdr;
800 const struct eap_hdr *ehdr;
801 size_t len;
802 u8 flags;
803 u16 seq;
804 char nai[254];
805 struct eap_server_erp_key *erp;
806 int max_len;
807 u8 hash[SHA256_MAC_LEN];
808 size_t hash_len;
809 struct erp_tlvs parse;
810 u8 resp_flags = 0x80; /* default to failure; cleared on success */
811
812 SM_ENTRY(EAP, INITIATE_RECEIVED);
813
814 sm->rxInitiate = FALSE;
815
816 pos = eap_hdr_validate(EAP_VENDOR_IETF,
817 (enum eap_type) EAP_ERP_TYPE_REAUTH,
818 sm->eap_if.eapRespData, &len);
819 if (pos == NULL) {
820 wpa_printf(MSG_INFO, "EAP-Initiate: Invalid frame");
821 goto fail;
822 }
823 hdr = wpabuf_head(sm->eap_if.eapRespData);
824 ehdr = wpabuf_head(sm->eap_if.eapRespData);
825
826 wpa_hexdump(MSG_DEBUG, "EAP: EAP-Initiate/Re-Auth", pos, len);
827 if (len < 4) {
828 wpa_printf(MSG_INFO, "EAP: Too short EAP-Initiate/Re-auth");
829 goto fail;
830 }
831 end = pos + len;
832
833 flags = *pos++;
834 seq = WPA_GET_BE16(pos);
835 pos += 2;
836 wpa_printf(MSG_DEBUG, "EAP: Flags=0x%x SEQ=%u", flags, seq);
837 tlvs = pos;
838
839 /*
840 * Parse TVs/TLVs. Since we do not yet know the length of the
841 * Authentication Tag, stop parsing if an unknown TV/TLV is seen and
842 * just try to find the keyName-NAI first so that we can check the
843 * Authentication Tag.
844 */
845 if (erp_parse_tlvs(tlvs, end, &parse, 1) < 0)
846 goto fail;
847
848 if (!parse.keyname) {
849 wpa_printf(MSG_DEBUG,
850 "EAP: No keyName-NAI in EAP-Initiate/Re-auth Packet");
851 goto fail;
852 }
853
854 wpa_hexdump_ascii(MSG_DEBUG, "EAP: EAP-Initiate/Re-auth - keyName-NAI",
855 parse.keyname, parse.keyname_len);
856 if (parse.keyname_len > 253) {
857 wpa_printf(MSG_DEBUG,
858 "EAP: Too long keyName-NAI in EAP-Initiate/Re-auth");
859 goto fail;
860 }
861 os_memcpy(nai, parse.keyname, parse.keyname_len);
862 nai[parse.keyname_len] = '\0';
863
864 if (!sm->cfg->eap_server) {
865 /*
866 * In passthrough case, EAP-Initiate/Re-auth replaces
867 * EAP Identity exchange. Use keyName-NAI as the user identity
868 * and forward EAP-Initiate/Re-auth to the backend
869 * authentication server.
870 */
871 wpa_printf(MSG_DEBUG,
872 "EAP: Use keyName-NAI as user identity for backend authentication");
873 eap_server_clear_identity(sm);
874 sm->identity = (u8 *) dup_binstr(parse.keyname,
875 parse.keyname_len);
876 if (!sm->identity)
877 goto fail;
878 sm->identity_len = parse.keyname_len;
879 return;
880 }
881
882 erp = eap_erp_get_key(sm, nai);
883 if (!erp) {
884 wpa_printf(MSG_DEBUG, "EAP: No matching ERP key found for %s",
885 nai);
886 goto report_error;
887 }
888
889 if (erp->recv_seq != (u32) -1 && erp->recv_seq >= seq) {
890 wpa_printf(MSG_DEBUG,
891 "EAP: SEQ=%u replayed (already received SEQ=%u)",
892 seq, erp->recv_seq);
893 goto fail;
894 }
895
896 /* Is there enough room for Cryptosuite and Authentication Tag? */
897 start = parse.keyname + parse.keyname_len;
898 max_len = end - start;
899 if (max_len <
900 1 + (erp->cryptosuite == EAP_ERP_CS_HMAC_SHA256_256 ? 32 : 16)) {
901 wpa_printf(MSG_DEBUG,
902 "EAP: Not enough room for Authentication Tag");
903 goto fail;
904 }
905
906 switch (erp->cryptosuite) {
907 case EAP_ERP_CS_HMAC_SHA256_256:
908 if (end[-33] != erp->cryptosuite) {
909 wpa_printf(MSG_DEBUG,
910 "EAP: Different Cryptosuite used");
911 goto fail;
912 }
913 hash_len = 32;
914 break;
915 case EAP_ERP_CS_HMAC_SHA256_128:
916 if (end[-17] != erp->cryptosuite) {
917 wpa_printf(MSG_DEBUG,
918 "EAP: Different Cryptosuite used");
919 goto fail;
920 }
921 hash_len = 16;
922 break;
923 default:
924 hash_len = 0;
925 break;
926 }
927
928 if (hash_len) {
929 if (hmac_sha256(erp->rIK, erp->rIK_len, hdr,
930 end - hdr - hash_len, hash) < 0)
931 goto fail;
932 if (os_memcmp(end - hash_len, hash, hash_len) != 0) {
933 wpa_printf(MSG_DEBUG,
934 "EAP: Authentication Tag mismatch");
935 goto fail;
936 }
937 }
938
939 /* Check if any supported CS results in matching tag */
940 if (!hash_len && max_len >= 1 + 32 &&
941 end[-33] == EAP_ERP_CS_HMAC_SHA256_256) {
942 if (hmac_sha256(erp->rIK, erp->rIK_len, hdr,
943 end - hdr - 32, hash) < 0)
944 goto fail;
945 if (os_memcmp(end - 32, hash, 32) == 0) {
946 wpa_printf(MSG_DEBUG,
947 "EAP: Authentication Tag match using HMAC-SHA256-256");
948 hash_len = 32;
949 erp->cryptosuite = EAP_ERP_CS_HMAC_SHA256_256;
950 }
951 }
952
953 if (!hash_len && end[-17] == EAP_ERP_CS_HMAC_SHA256_128) {
954 if (hmac_sha256(erp->rIK, erp->rIK_len, hdr,
955 end - hdr - 16, hash) < 0)
956 goto fail;
957 if (os_memcmp(end - 16, hash, 16) == 0) {
958 wpa_printf(MSG_DEBUG,
959 "EAP: Authentication Tag match using HMAC-SHA256-128");
960 hash_len = 16;
961 erp->cryptosuite = EAP_ERP_CS_HMAC_SHA256_128;
962 }
963 }
964
965 if (!hash_len) {
966 wpa_printf(MSG_DEBUG,
967 "EAP: No supported cryptosuite matched Authentication Tag");
968 goto fail;
969 }
970 end -= 1 + hash_len;
971
972 /*
973 * Parse TVs/TLVs again now that we know the exact part of the buffer
974 * that contains them.
975 */
976 wpa_hexdump(MSG_DEBUG, "EAP: EAP-Initiate/Re-Auth TVs/TLVs",
977 tlvs, end - tlvs);
978 if (erp_parse_tlvs(tlvs, end, &parse, 0) < 0)
979 goto fail;
980
981 wpa_printf(MSG_DEBUG, "EAP: ERP key %s SEQ updated to %u",
982 erp->keyname_nai, seq);
983 erp->recv_seq = seq;
984 resp_flags &= ~0x80; /* R=0 - success */
985
986 report_error:
987 erp_send_finish_reauth(sm, erp, ehdr->identifier, resp_flags, seq, nai);
988 return;
989
990 fail:
991 sm->ignore = TRUE;
992 }
993
994 #endif /* CONFIG_ERP */
995
996
997 SM_STATE(EAP, INITIALIZE_PASSTHROUGH)
998 {
999 SM_ENTRY(EAP, INITIALIZE_PASSTHROUGH);
1000
1001 wpabuf_free(sm->eap_if.aaaEapRespData);
1002 sm->eap_if.aaaEapRespData = NULL;
1003 sm->try_initiate_reauth = FALSE;
1004 }
1005
1006
1007 SM_STATE(EAP, IDLE2)
1008 {
1009 SM_ENTRY(EAP, IDLE2);
1010
1011 sm->eap_if.retransWhile = eap_sm_calculateTimeout(
1012 sm, sm->retransCount, sm->eap_if.eapSRTT, sm->eap_if.eapRTTVAR,
1013 sm->methodTimeout);
1014 }
1015
1016
1017 SM_STATE(EAP, RETRANSMIT2)
1018 {
1019 SM_ENTRY(EAP, RETRANSMIT2);
1020
1021 sm->retransCount++;
1022 if (sm->retransCount <= sm->MaxRetrans && sm->lastReqData) {
1023 if (eap_copy_buf(&sm->eap_if.eapReqData, sm->lastReqData) == 0)
1024 sm->eap_if.eapReq = TRUE;
1025 }
1026
1027 wpa_msg(sm->cfg->msg_ctx, MSG_INFO, WPA_EVENT_EAP_RETRANSMIT2 MACSTR,
1028 MAC2STR(sm->peer_addr));
1029 }
1030
1031
1032 SM_STATE(EAP, RECEIVED2)
1033 {
1034 SM_ENTRY(EAP, RECEIVED2);
1035
1036 /* parse rxResp, respId, respMethod */
1037 eap_sm_parseEapResp(sm, sm->eap_if.eapRespData);
1038 }
1039
1040
1041 SM_STATE(EAP, DISCARD2)
1042 {
1043 SM_ENTRY(EAP, DISCARD2);
1044 sm->eap_if.eapResp = FALSE;
1045 sm->eap_if.eapNoReq = TRUE;
1046 }
1047
1048
1049 SM_STATE(EAP, SEND_REQUEST2)
1050 {
1051 SM_ENTRY(EAP, SEND_REQUEST2);
1052
1053 sm->retransCount = 0;
1054 if (sm->eap_if.eapReqData) {
1055 if (eap_copy_buf(&sm->lastReqData, sm->eap_if.eapReqData) == 0)
1056 {
1057 sm->eap_if.eapResp = FALSE;
1058 sm->eap_if.eapReq = TRUE;
1059 } else {
1060 sm->eap_if.eapResp = FALSE;
1061 sm->eap_if.eapReq = FALSE;
1062 }
1063 } else {
1064 wpa_printf(MSG_INFO, "EAP: SEND_REQUEST2 - no eapReqData");
1065 sm->eap_if.eapResp = FALSE;
1066 sm->eap_if.eapReq = FALSE;
1067 sm->eap_if.eapNoReq = TRUE;
1068 }
1069 }
1070
1071
1072 SM_STATE(EAP, AAA_REQUEST)
1073 {
1074 SM_ENTRY(EAP, AAA_REQUEST);
1075
1076 if (sm->eap_if.eapRespData == NULL) {
1077 wpa_printf(MSG_INFO, "EAP: AAA_REQUEST - no eapRespData");
1078 return;
1079 }
1080
1081 /*
1082 * if (respMethod == IDENTITY)
1083 * aaaIdentity = eapRespData
1084 * This is already taken care of by the EAP-Identity method which
1085 * stores the identity into sm->identity.
1086 */
1087
1088 eap_copy_buf(&sm->eap_if.aaaEapRespData, sm->eap_if.eapRespData);
1089 }
1090
1091
1092 SM_STATE(EAP, AAA_RESPONSE)
1093 {
1094 SM_ENTRY(EAP, AAA_RESPONSE);
1095
1096 eap_copy_buf(&sm->eap_if.eapReqData, sm->eap_if.aaaEapReqData);
1097 sm->currentId = eap_sm_getId(sm->eap_if.eapReqData);
1098 sm->methodTimeout = sm->eap_if.aaaMethodTimeout;
1099 }
1100
1101
1102 SM_STATE(EAP, AAA_IDLE)
1103 {
1104 SM_ENTRY(EAP, AAA_IDLE);
1105
1106 sm->eap_if.aaaFail = FALSE;
1107 sm->eap_if.aaaSuccess = FALSE;
1108 sm->eap_if.aaaEapReq = FALSE;
1109 sm->eap_if.aaaEapNoReq = FALSE;
1110 sm->eap_if.aaaEapResp = TRUE;
1111 }
1112
1113
1114 SM_STATE(EAP, TIMEOUT_FAILURE2)
1115 {
1116 SM_ENTRY(EAP, TIMEOUT_FAILURE2);
1117
1118 sm->eap_if.eapTimeout = TRUE;
1119
1120 wpa_msg(sm->cfg->msg_ctx, MSG_INFO,
1121 WPA_EVENT_EAP_TIMEOUT_FAILURE2 MACSTR, MAC2STR(sm->peer_addr));
1122 }
1123
1124
1125 SM_STATE(EAP, FAILURE2)
1126 {
1127 SM_ENTRY(EAP, FAILURE2);
1128
1129 eap_copy_buf(&sm->eap_if.eapReqData, sm->eap_if.aaaEapReqData);
1130 sm->eap_if.eapFail = TRUE;
1131
1132 wpa_msg(sm->cfg->msg_ctx, MSG_INFO, WPA_EVENT_EAP_FAILURE2 MACSTR,
1133 MAC2STR(sm->peer_addr));
1134 }
1135
1136
1137 SM_STATE(EAP, SUCCESS2)
1138 {
1139 SM_ENTRY(EAP, SUCCESS2);
1140
1141 eap_copy_buf(&sm->eap_if.eapReqData, sm->eap_if.aaaEapReqData);
1142
1143 sm->eap_if.eapKeyAvailable = sm->eap_if.aaaEapKeyAvailable;
1144 if (sm->eap_if.aaaEapKeyAvailable) {
1145 EAP_COPY(&sm->eap_if.eapKeyData, sm->eap_if.aaaEapKeyData);
1146 } else {
1147 bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen);
1148 sm->eap_if.eapKeyData = NULL;
1149 sm->eap_if.eapKeyDataLen = 0;
1150 }
1151
1152 sm->eap_if.eapSuccess = TRUE;
1153
1154 /*
1155 * Start reauthentication with identity request even though we know the
1156 * previously used identity. This is needed to get reauthentication
1157 * started properly.
1158 */
1159 sm->start_reauth = TRUE;
1160
1161 wpa_msg(sm->cfg->msg_ctx, MSG_INFO, WPA_EVENT_EAP_SUCCESS2 MACSTR,
1162 MAC2STR(sm->peer_addr));
1163 }
1164
1165
1166 SM_STEP(EAP)
1167 {
1168 if (sm->eap_if.eapRestart && sm->eap_if.portEnabled)
1169 SM_ENTER_GLOBAL(EAP, INITIALIZE);
1170 else if (!sm->eap_if.portEnabled)
1171 SM_ENTER_GLOBAL(EAP, DISABLED);
1172 else if (sm->num_rounds > sm->cfg->max_auth_rounds) {
1173 if (sm->num_rounds == sm->cfg->max_auth_rounds + 1) {
1174 wpa_printf(MSG_DEBUG, "EAP: more than %d "
1175 "authentication rounds - abort",
1176 sm->cfg->max_auth_rounds);
1177 sm->num_rounds++;
1178 SM_ENTER_GLOBAL(EAP, FAILURE);
1179 }
1180 } else if (sm->num_rounds_short > sm->cfg->max_auth_rounds_short) {
1181 if (sm->num_rounds_short ==
1182 sm->cfg->max_auth_rounds_short + 1) {
1183 wpa_printf(MSG_DEBUG,
1184 "EAP: more than %d authentication rounds (short) - abort",
1185 sm->cfg->max_auth_rounds_short);
1186 sm->num_rounds_short++;
1187 SM_ENTER_GLOBAL(EAP, FAILURE);
1188 }
1189 } else switch (sm->EAP_state) {
1190 case EAP_INITIALIZE:
1191 if (sm->cfg->backend_auth) {
1192 if (!sm->rxResp)
1193 SM_ENTER(EAP, SELECT_ACTION);
1194 else if (sm->rxResp &&
1195 (sm->respMethod == EAP_TYPE_NAK ||
1196 (sm->respMethod == EAP_TYPE_EXPANDED &&
1197 sm->respVendor == EAP_VENDOR_IETF &&
1198 sm->respVendorMethod == EAP_TYPE_NAK)))
1199 SM_ENTER(EAP, NAK);
1200 else
1201 SM_ENTER(EAP, PICK_UP_METHOD);
1202 } else {
1203 SM_ENTER(EAP, SELECT_ACTION);
1204 }
1205 break;
1206 case EAP_PICK_UP_METHOD:
1207 if (sm->currentMethod == EAP_TYPE_NONE) {
1208 SM_ENTER(EAP, SELECT_ACTION);
1209 } else {
1210 SM_ENTER(EAP, METHOD_RESPONSE);
1211 }
1212 break;
1213 case EAP_DISABLED:
1214 if (sm->eap_if.portEnabled)
1215 SM_ENTER(EAP, INITIALIZE);
1216 break;
1217 case EAP_IDLE:
1218 if (sm->eap_if.retransWhile == 0) {
1219 if (sm->try_initiate_reauth) {
1220 sm->try_initiate_reauth = FALSE;
1221 SM_ENTER(EAP, SELECT_ACTION);
1222 } else {
1223 SM_ENTER(EAP, RETRANSMIT);
1224 }
1225 } else if (sm->eap_if.eapResp)
1226 SM_ENTER(EAP, RECEIVED);
1227 break;
1228 case EAP_RETRANSMIT:
1229 if (sm->retransCount > sm->MaxRetrans)
1230 SM_ENTER(EAP, TIMEOUT_FAILURE);
1231 else
1232 SM_ENTER(EAP, IDLE);
1233 break;
1234 case EAP_RECEIVED:
1235 if (sm->rxResp && (sm->respId == sm->currentId) &&
1236 (sm->respMethod == EAP_TYPE_NAK ||
1237 (sm->respMethod == EAP_TYPE_EXPANDED &&
1238 sm->respVendor == EAP_VENDOR_IETF &&
1239 sm->respVendorMethod == EAP_TYPE_NAK))
1240 && (sm->methodState == METHOD_PROPOSED))
1241 SM_ENTER(EAP, NAK);
1242 else if (sm->rxResp && (sm->respId == sm->currentId) &&
1243 ((sm->respMethod == sm->currentMethod) ||
1244 (sm->respMethod == EAP_TYPE_EXPANDED &&
1245 sm->respVendor == EAP_VENDOR_IETF &&
1246 sm->respVendorMethod == sm->currentMethod)))
1247 SM_ENTER(EAP, INTEGRITY_CHECK);
1248 #ifdef CONFIG_ERP
1249 else if (sm->rxInitiate)
1250 SM_ENTER(EAP, INITIATE_RECEIVED);
1251 #endif /* CONFIG_ERP */
1252 else {
1253 wpa_printf(MSG_DEBUG, "EAP: RECEIVED->DISCARD: "
1254 "rxResp=%d respId=%d currentId=%d "
1255 "respMethod=%d currentMethod=%d",
1256 sm->rxResp, sm->respId, sm->currentId,
1257 sm->respMethod, sm->currentMethod);
1258 eap_log_msg(sm, "Discard received EAP message");
1259 SM_ENTER(EAP, DISCARD);
1260 }
1261 break;
1262 case EAP_DISCARD:
1263 SM_ENTER(EAP, IDLE);
1264 break;
1265 case EAP_SEND_REQUEST:
1266 SM_ENTER(EAP, IDLE);
1267 break;
1268 case EAP_INTEGRITY_CHECK:
1269 if (sm->ignore)
1270 SM_ENTER(EAP, DISCARD);
1271 else
1272 SM_ENTER(EAP, METHOD_RESPONSE);
1273 break;
1274 case EAP_METHOD_REQUEST:
1275 if (sm->m == NULL) {
1276 /*
1277 * This transition is not mentioned in RFC 4137, but it
1278 * is needed to handle cleanly a case where EAP method
1279 * initialization fails.
1280 */
1281 SM_ENTER(EAP, FAILURE);
1282 break;
1283 }
1284 SM_ENTER(EAP, SEND_REQUEST);
1285 if (sm->eap_if.eapNoReq && !sm->eap_if.eapReq) {
1286 /*
1287 * This transition is not mentioned in RFC 4137, but it
1288 * is needed to handle cleanly a case where EAP method
1289 * buildReq fails.
1290 */
1291 wpa_printf(MSG_DEBUG,
1292 "EAP: Method did not return a request");
1293 SM_ENTER(EAP, FAILURE);
1294 break;
1295 }
1296 break;
1297 case EAP_METHOD_RESPONSE:
1298 /*
1299 * Note: Mechanism to allow EAP methods to wait while going
1300 * through pending processing is an extension to RFC 4137
1301 * which only defines the transits to SELECT_ACTION and
1302 * METHOD_REQUEST from this METHOD_RESPONSE state.
1303 */
1304 if (sm->methodState == METHOD_END)
1305 SM_ENTER(EAP, SELECT_ACTION);
1306 else if (sm->method_pending == METHOD_PENDING_WAIT) {
1307 wpa_printf(MSG_DEBUG, "EAP: Method has pending "
1308 "processing - wait before proceeding to "
1309 "METHOD_REQUEST state");
1310 } else if (sm->method_pending == METHOD_PENDING_CONT) {
1311 wpa_printf(MSG_DEBUG, "EAP: Method has completed "
1312 "pending processing - reprocess pending "
1313 "EAP message");
1314 sm->method_pending = METHOD_PENDING_NONE;
1315 SM_ENTER(EAP, METHOD_RESPONSE);
1316 } else
1317 SM_ENTER(EAP, METHOD_REQUEST);
1318 break;
1319 case EAP_PROPOSE_METHOD:
1320 /*
1321 * Note: Mechanism to allow EAP methods to wait while going
1322 * through pending processing is an extension to RFC 4137
1323 * which only defines the transit to METHOD_REQUEST from this
1324 * PROPOSE_METHOD state.
1325 */
1326 if (sm->method_pending == METHOD_PENDING_WAIT) {
1327 wpa_printf(MSG_DEBUG, "EAP: Method has pending "
1328 "processing - wait before proceeding to "
1329 "METHOD_REQUEST state");
1330 if (sm->user_eap_method_index > 0)
1331 sm->user_eap_method_index--;
1332 } else if (sm->method_pending == METHOD_PENDING_CONT) {
1333 wpa_printf(MSG_DEBUG, "EAP: Method has completed "
1334 "pending processing - reprocess pending "
1335 "EAP message");
1336 sm->method_pending = METHOD_PENDING_NONE;
1337 SM_ENTER(EAP, PROPOSE_METHOD);
1338 } else
1339 SM_ENTER(EAP, METHOD_REQUEST);
1340 break;
1341 case EAP_NAK:
1342 SM_ENTER(EAP, SELECT_ACTION);
1343 break;
1344 case EAP_SELECT_ACTION:
1345 if (sm->decision == DECISION_FAILURE)
1346 SM_ENTER(EAP, FAILURE);
1347 else if (sm->decision == DECISION_SUCCESS)
1348 SM_ENTER(EAP, SUCCESS);
1349 else if (sm->decision == DECISION_PASSTHROUGH)
1350 SM_ENTER(EAP, INITIALIZE_PASSTHROUGH);
1351 else if (sm->decision == DECISION_INITIATE_REAUTH_START)
1352 SM_ENTER(EAP, INITIATE_REAUTH_START);
1353 #ifdef CONFIG_ERP
1354 else if (sm->cfg->eap_server && sm->cfg->erp && sm->rxInitiate)
1355 SM_ENTER(EAP, INITIATE_RECEIVED);
1356 #endif /* CONFIG_ERP */
1357 else
1358 SM_ENTER(EAP, PROPOSE_METHOD);
1359 break;
1360 case EAP_INITIATE_REAUTH_START:
1361 SM_ENTER(EAP, SEND_REQUEST);
1362 break;
1363 case EAP_INITIATE_RECEIVED:
1364 if (!sm->cfg->eap_server)
1365 SM_ENTER(EAP, SELECT_ACTION);
1366 break;
1367 case EAP_TIMEOUT_FAILURE:
1368 break;
1369 case EAP_FAILURE:
1370 break;
1371 case EAP_SUCCESS:
1372 break;
1373
1374 case EAP_INITIALIZE_PASSTHROUGH:
1375 if (sm->currentId == -1)
1376 SM_ENTER(EAP, AAA_IDLE);
1377 else
1378 SM_ENTER(EAP, AAA_REQUEST);
1379 break;
1380 case EAP_IDLE2:
1381 if (sm->eap_if.eapResp)
1382 SM_ENTER(EAP, RECEIVED2);
1383 else if (sm->eap_if.retransWhile == 0)
1384 SM_ENTER(EAP, RETRANSMIT2);
1385 break;
1386 case EAP_RETRANSMIT2:
1387 if (sm->retransCount > sm->MaxRetrans)
1388 SM_ENTER(EAP, TIMEOUT_FAILURE2);
1389 else
1390 SM_ENTER(EAP, IDLE2);
1391 break;
1392 case EAP_RECEIVED2:
1393 if (sm->rxResp && (sm->respId == sm->currentId))
1394 SM_ENTER(EAP, AAA_REQUEST);
1395 else
1396 SM_ENTER(EAP, DISCARD2);
1397 break;
1398 case EAP_DISCARD2:
1399 SM_ENTER(EAP, IDLE2);
1400 break;
1401 case EAP_SEND_REQUEST2:
1402 SM_ENTER(EAP, IDLE2);
1403 break;
1404 case EAP_AAA_REQUEST:
1405 SM_ENTER(EAP, AAA_IDLE);
1406 break;
1407 case EAP_AAA_RESPONSE:
1408 SM_ENTER(EAP, SEND_REQUEST2);
1409 break;
1410 case EAP_AAA_IDLE:
1411 if (sm->eap_if.aaaFail)
1412 SM_ENTER(EAP, FAILURE2);
1413 else if (sm->eap_if.aaaSuccess)
1414 SM_ENTER(EAP, SUCCESS2);
1415 else if (sm->eap_if.aaaEapReq)
1416 SM_ENTER(EAP, AAA_RESPONSE);
1417 else if (sm->eap_if.aaaTimeout)
1418 SM_ENTER(EAP, TIMEOUT_FAILURE2);
1419 break;
1420 case EAP_TIMEOUT_FAILURE2:
1421 break;
1422 case EAP_FAILURE2:
1423 break;
1424 case EAP_SUCCESS2:
1425 break;
1426 }
1427 }
1428
1429
1430 static int eap_sm_calculateTimeout(struct eap_sm *sm, int retransCount,
1431 int eapSRTT, int eapRTTVAR,
1432 int methodTimeout)
1433 {
1434 int rto, i;
1435
1436 if (sm->try_initiate_reauth) {
1437 wpa_printf(MSG_DEBUG,
1438 "EAP: retransmit timeout 1 second for EAP-Initiate-Re-auth-Start");
1439 return 1;
1440 }
1441
1442 if (methodTimeout) {
1443 /*
1444 * EAP method (either internal or through AAA server, provided
1445 * timeout hint. Use that as-is as a timeout for retransmitting
1446 * the EAP request if no response is received.
1447 */
1448 wpa_printf(MSG_DEBUG, "EAP: retransmit timeout %d seconds "
1449 "(from EAP method hint)", methodTimeout);
1450 return methodTimeout;
1451 }
1452
1453 /*
1454 * RFC 3748 recommends algorithms described in RFC 2988 for estimation
1455 * of the retransmission timeout. This should be implemented once
1456 * round-trip time measurements are available. For nowm a simple
1457 * backoff mechanism is used instead if there are no EAP method
1458 * specific hints.
1459 *
1460 * SRTT = smoothed round-trip time
1461 * RTTVAR = round-trip time variation
1462 * RTO = retransmission timeout
1463 */
1464
1465 /*
1466 * RFC 2988, 2.1: before RTT measurement, set RTO to 3 seconds for
1467 * initial retransmission and then double the RTO to provide back off
1468 * per 5.5. Limit the maximum RTO to 20 seconds per RFC 3748, 4.3
1469 * modified RTOmax.
1470 */
1471 rto = 3;
1472 for (i = 0; i < retransCount; i++) {
1473 rto *= 2;
1474 if (rto >= 20) {
1475 rto = 20;
1476 break;
1477 }
1478 }
1479
1480 wpa_printf(MSG_DEBUG, "EAP: retransmit timeout %d seconds "
1481 "(from dynamic back off; retransCount=%d)",
1482 rto, retransCount);
1483
1484 return rto;
1485 }
1486
1487
1488 static void eap_sm_parseEapResp(struct eap_sm *sm, const struct wpabuf *resp)
1489 {
1490 const struct eap_hdr *hdr;
1491 size_t plen;
1492
1493 /* parse rxResp, respId, respMethod */
1494 sm->rxResp = FALSE;
1495 sm->rxInitiate = FALSE;
1496 sm->respId = -1;
1497 sm->respMethod = EAP_TYPE_NONE;
1498 sm->respVendor = EAP_VENDOR_IETF;
1499 sm->respVendorMethod = EAP_TYPE_NONE;
1500
1501 if (resp == NULL || wpabuf_len(resp) < sizeof(*hdr)) {
1502 wpa_printf(MSG_DEBUG, "EAP: parseEapResp: invalid resp=%p "
1503 "len=%lu", resp,
1504 resp ? (unsigned long) wpabuf_len(resp) : 0);
1505 return;
1506 }
1507
1508 hdr = wpabuf_head(resp);
1509 plen = be_to_host16(hdr->length);
1510 if (plen > wpabuf_len(resp)) {
1511 wpa_printf(MSG_DEBUG, "EAP: Ignored truncated EAP-Packet "
1512 "(len=%lu plen=%lu)",
1513 (unsigned long) wpabuf_len(resp),
1514 (unsigned long) plen);
1515 return;
1516 }
1517
1518 sm->respId = hdr->identifier;
1519
1520 if (hdr->code == EAP_CODE_RESPONSE)
1521 sm->rxResp = TRUE;
1522 else if (hdr->code == EAP_CODE_INITIATE)
1523 sm->rxInitiate = TRUE;
1524
1525 if (plen > sizeof(*hdr)) {
1526 u8 *pos = (u8 *) (hdr + 1);
1527 sm->respMethod = *pos++;
1528 if (sm->respMethod == EAP_TYPE_EXPANDED) {
1529 if (plen < sizeof(*hdr) + 8) {
1530 wpa_printf(MSG_DEBUG, "EAP: Ignored truncated "
1531 "expanded EAP-Packet (plen=%lu)",
1532 (unsigned long) plen);
1533 return;
1534 }
1535 sm->respVendor = WPA_GET_BE24(pos);
1536 pos += 3;
1537 sm->respVendorMethod = WPA_GET_BE32(pos);
1538 }
1539 }
1540
1541 wpa_printf(MSG_DEBUG,
1542 "EAP: parseEapResp: rxResp=%d rxInitiate=%d respId=%d respMethod=%u respVendor=%u respVendorMethod=%u",
1543 sm->rxResp, sm->rxInitiate, sm->respId, sm->respMethod,
1544 sm->respVendor, sm->respVendorMethod);
1545 }
1546
1547
1548 static int eap_sm_getId(const struct wpabuf *data)
1549 {
1550 const struct eap_hdr *hdr;
1551
1552 if (data == NULL || wpabuf_len(data) < sizeof(*hdr))
1553 return -1;
1554
1555 hdr = wpabuf_head(data);
1556 wpa_printf(MSG_DEBUG, "EAP: getId: id=%d", hdr->identifier);
1557 return hdr->identifier;
1558 }
1559
1560
1561 static struct wpabuf * eap_sm_buildSuccess(struct eap_sm *sm, u8 id)
1562 {
1563 struct wpabuf *msg;
1564 struct eap_hdr *resp;
1565 wpa_printf(MSG_DEBUG, "EAP: Building EAP-Success (id=%d)", id);
1566
1567 msg = wpabuf_alloc(sizeof(*resp));
1568 if (msg == NULL)
1569 return NULL;
1570 resp = wpabuf_put(msg, sizeof(*resp));
1571 resp->code = EAP_CODE_SUCCESS;
1572 resp->identifier = id;
1573 resp->length = host_to_be16(sizeof(*resp));
1574
1575 return msg;
1576 }
1577
1578
1579 static struct wpabuf * eap_sm_buildFailure(struct eap_sm *sm, u8 id)
1580 {
1581 struct wpabuf *msg;
1582 struct eap_hdr *resp;
1583 wpa_printf(MSG_DEBUG, "EAP: Building EAP-Failure (id=%d)", id);
1584
1585 msg = wpabuf_alloc(sizeof(*resp));
1586 if (msg == NULL)
1587 return NULL;
1588 resp = wpabuf_put(msg, sizeof(*resp));
1589 resp->code = EAP_CODE_FAILURE;
1590 resp->identifier = id;
1591 resp->length = host_to_be16(sizeof(*resp));
1592
1593 return msg;
1594 }
1595
1596
1597 static int eap_sm_nextId(struct eap_sm *sm, int id)
1598 {
1599 if (id < 0) {
1600 /* RFC 3748 Ch 4.1: recommended to initialize Identifier with a
1601 * random number */
1602 id = rand() & 0xff;
1603 if (id != sm->lastId)
1604 return id;
1605 }
1606 return (id + 1) & 0xff;
1607 }
1608
1609
1610 /**
1611 * eap_sm_process_nak - Process EAP-Response/Nak
1612 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
1613 * @nak_list: Nak list (allowed methods) from the supplicant
1614 * @len: Length of nak_list in bytes
1615 *
1616 * This function is called when EAP-Response/Nak is received from the
1617 * supplicant. This can happen for both phase 1 and phase 2 authentications.
1618 */
1619 void eap_sm_process_nak(struct eap_sm *sm, const u8 *nak_list, size_t len)
1620 {
1621 int i;
1622 size_t j;
1623
1624 if (sm->user == NULL)
1625 return;
1626
1627 wpa_printf(MSG_MSGDUMP, "EAP: processing NAK (current EAP method "
1628 "index %d)", sm->user_eap_method_index);
1629
1630 wpa_hexdump(MSG_MSGDUMP, "EAP: configured methods",
1631 (u8 *) sm->user->methods,
1632 EAP_MAX_METHODS * sizeof(sm->user->methods[0]));
1633 wpa_hexdump(MSG_MSGDUMP, "EAP: list of methods supported by the peer",
1634 nak_list, len);
1635
1636 i = sm->user_eap_method_index;
1637 while (i < EAP_MAX_METHODS &&
1638 (sm->user->methods[i].vendor != EAP_VENDOR_IETF ||
1639 sm->user->methods[i].method != EAP_TYPE_NONE)) {
1640 if (sm->user->methods[i].vendor != EAP_VENDOR_IETF)
1641 goto not_found;
1642 for (j = 0; j < len; j++) {
1643 if (nak_list[j] == sm->user->methods[i].method) {
1644 break;
1645 }
1646 }
1647
1648 if (j < len) {
1649 /* found */
1650 i++;
1651 continue;
1652 }
1653
1654 not_found:
1655 /* not found - remove from the list */
1656 if (i + 1 < EAP_MAX_METHODS) {
1657 os_memmove(&sm->user->methods[i],
1658 &sm->user->methods[i + 1],
1659 (EAP_MAX_METHODS - i - 1) *
1660 sizeof(sm->user->methods[0]));
1661 }
1662 sm->user->methods[EAP_MAX_METHODS - 1].vendor =
1663 EAP_VENDOR_IETF;
1664 sm->user->methods[EAP_MAX_METHODS - 1].method = EAP_TYPE_NONE;
1665 }
1666
1667 wpa_hexdump(MSG_MSGDUMP, "EAP: new list of configured methods",
1668 (u8 *) sm->user->methods, EAP_MAX_METHODS *
1669 sizeof(sm->user->methods[0]));
1670 }
1671
1672
1673 static void eap_sm_Policy_update(struct eap_sm *sm, const u8 *nak_list,
1674 size_t len)
1675 {
1676 if (nak_list == NULL || sm == NULL || sm->user == NULL)
1677 return;
1678
1679 if (sm->user->phase2) {
1680 wpa_printf(MSG_DEBUG, "EAP: EAP-Nak received after Phase2 user"
1681 " info was selected - reject");
1682 sm->decision = DECISION_FAILURE;
1683 return;
1684 }
1685
1686 eap_sm_process_nak(sm, nak_list, len);
1687 }
1688
1689
1690 static enum eap_type eap_sm_Policy_getNextMethod(struct eap_sm *sm, int *vendor)
1691 {
1692 enum eap_type next;
1693 int idx = sm->user_eap_method_index;
1694
1695 /* In theory, there should be no problems with starting
1696 * re-authentication with something else than EAP-Request/Identity and
1697 * this does indeed work with wpa_supplicant. However, at least Funk
1698 * Supplicant seemed to ignore re-auth if it skipped
1699 * EAP-Request/Identity.
1700 * Re-auth sets currentId == -1, so that can be used here to select
1701 * whether Identity needs to be requested again. */
1702 if (sm->identity == NULL || sm->currentId == -1) {
1703 *vendor = EAP_VENDOR_IETF;
1704 next = EAP_TYPE_IDENTITY;
1705 sm->update_user = TRUE;
1706 } else if (sm->user && idx < EAP_MAX_METHODS &&
1707 (sm->user->methods[idx].vendor != EAP_VENDOR_IETF ||
1708 sm->user->methods[idx].method != EAP_TYPE_NONE)) {
1709 *vendor = sm->user->methods[idx].vendor;
1710 next = sm->user->methods[idx].method;
1711 sm->user_eap_method_index++;
1712 } else {
1713 *vendor = EAP_VENDOR_IETF;
1714 next = EAP_TYPE_NONE;
1715 }
1716 wpa_printf(MSG_DEBUG, "EAP: getNextMethod: vendor %d type %d",
1717 *vendor, next);
1718 return next;
1719 }
1720
1721
1722 static int eap_sm_Policy_getDecision(struct eap_sm *sm)
1723 {
1724 if (!sm->cfg->eap_server && sm->identity && !sm->start_reauth) {
1725 wpa_printf(MSG_DEBUG, "EAP: getDecision: -> PASSTHROUGH");
1726 return DECISION_PASSTHROUGH;
1727 }
1728
1729 if (sm->m && sm->currentMethod != EAP_TYPE_IDENTITY &&
1730 sm->m->isSuccess(sm, sm->eap_method_priv)) {
1731 wpa_printf(MSG_DEBUG, "EAP: getDecision: method succeeded -> "
1732 "SUCCESS");
1733 sm->update_user = TRUE;
1734 return DECISION_SUCCESS;
1735 }
1736
1737 if (sm->m && sm->m->isDone(sm, sm->eap_method_priv) &&
1738 !sm->m->isSuccess(sm, sm->eap_method_priv)) {
1739 wpa_printf(MSG_DEBUG, "EAP: getDecision: method failed -> "
1740 "FAILURE");
1741 sm->update_user = TRUE;
1742 return DECISION_FAILURE;
1743 }
1744
1745 if ((sm->user == NULL || sm->update_user) && sm->identity &&
1746 !sm->start_reauth) {
1747 /*
1748 * Allow Identity method to be started once to allow identity
1749 * selection hint to be sent from the authentication server,
1750 * but prevent a loop of Identity requests by only allowing
1751 * this to happen once.
1752 */
1753 int id_req = 0;
1754 if (sm->user && sm->currentMethod == EAP_TYPE_IDENTITY &&
1755 sm->user->methods[0].vendor == EAP_VENDOR_IETF &&
1756 sm->user->methods[0].method == EAP_TYPE_IDENTITY)
1757 id_req = 1;
1758 if (eap_user_get(sm, sm->identity, sm->identity_len, 0) != 0) {
1759 wpa_printf(MSG_DEBUG, "EAP: getDecision: user not "
1760 "found from database -> FAILURE");
1761 return DECISION_FAILURE;
1762 }
1763 if (id_req && sm->user &&
1764 sm->user->methods[0].vendor == EAP_VENDOR_IETF &&
1765 sm->user->methods[0].method == EAP_TYPE_IDENTITY) {
1766 wpa_printf(MSG_DEBUG, "EAP: getDecision: stop "
1767 "identity request loop -> FAILURE");
1768 sm->update_user = TRUE;
1769 return DECISION_FAILURE;
1770 }
1771 sm->update_user = FALSE;
1772 }
1773 sm->start_reauth = FALSE;
1774
1775 if (sm->user && sm->user_eap_method_index < EAP_MAX_METHODS &&
1776 (sm->user->methods[sm->user_eap_method_index].vendor !=
1777 EAP_VENDOR_IETF ||
1778 sm->user->methods[sm->user_eap_method_index].method !=
1779 EAP_TYPE_NONE)) {
1780 wpa_printf(MSG_DEBUG, "EAP: getDecision: another method "
1781 "available -> CONTINUE");
1782 return DECISION_CONTINUE;
1783 }
1784
1785 if (!sm->identity && eap_get_erp_send_reauth_start(sm) &&
1786 !sm->initiate_reauth_start_sent) {
1787 wpa_printf(MSG_DEBUG,
1788 "EAP: getDecision: send EAP-Initiate/Re-auth-Start");
1789 return DECISION_INITIATE_REAUTH_START;
1790 }
1791
1792 if (sm->identity == NULL || sm->currentId == -1) {
1793 wpa_printf(MSG_DEBUG, "EAP: getDecision: no identity known "
1794 "yet -> CONTINUE");
1795 return DECISION_CONTINUE;
1796 }
1797
1798 wpa_printf(MSG_DEBUG, "EAP: getDecision: no more methods available -> "
1799 "FAILURE");
1800 return DECISION_FAILURE;
1801 }
1802
1803
1804 static Boolean eap_sm_Policy_doPickUp(struct eap_sm *sm, enum eap_type method)
1805 {
1806 return method == EAP_TYPE_IDENTITY ? TRUE : FALSE;
1807 }
1808
1809
1810 /**
1811 * eap_server_sm_step - Step EAP server state machine
1812 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
1813 * Returns: 1 if EAP state was changed or 0 if not
1814 *
1815 * This function advances EAP state machine to a new state to match with the
1816 * current variables. This should be called whenever variables used by the EAP
1817 * state machine have changed.
1818 */
1819 int eap_server_sm_step(struct eap_sm *sm)
1820 {
1821 int res = 0;
1822 do {
1823 sm->changed = FALSE;
1824 SM_STEP_RUN(EAP);
1825 if (sm->changed)
1826 res = 1;
1827 } while (sm->changed);
1828 return res;
1829 }
1830
1831
1832 void eap_user_free(struct eap_user *user)
1833 {
1834 if (user == NULL)
1835 return;
1836 bin_clear_free(user->password, user->password_len);
1837 user->password = NULL;
1838 bin_clear_free(user->salt, user->salt_len);
1839 user->salt = NULL;
1840 os_free(user);
1841 }
1842
1843
1844 /**
1845 * eap_server_sm_init - Allocate and initialize EAP server state machine
1846 * @eapol_ctx: Context data to be used with eapol_cb calls
1847 * @eapol_cb: Pointer to EAPOL callback functions
1848 * @conf: EAP configuration
1849 * Returns: Pointer to the allocated EAP state machine or %NULL on failure
1850 *
1851 * This function allocates and initializes an EAP state machine.
1852 */
1853 struct eap_sm * eap_server_sm_init(void *eapol_ctx,
1854 const struct eapol_callbacks *eapol_cb,
1855 const struct eap_config *conf,
1856 const struct eap_session_data *sess)
1857 {
1858 struct eap_sm *sm;
1859
1860 sm = os_zalloc(sizeof(*sm));
1861 if (sm == NULL)
1862 return NULL;
1863 sm->eapol_ctx = eapol_ctx;
1864 sm->eapol_cb = eapol_cb;
1865 sm->MaxRetrans = 5; /* RFC 3748: max 3-5 retransmissions suggested */
1866 sm->cfg = conf;
1867 if (sess->assoc_wps_ie)
1868 sm->assoc_wps_ie = wpabuf_dup(sess->assoc_wps_ie);
1869 if (sess->assoc_p2p_ie)
1870 sm->assoc_p2p_ie = wpabuf_dup(sess->assoc_p2p_ie);
1871 if (sess->peer_addr)
1872 os_memcpy(sm->peer_addr, sess->peer_addr, ETH_ALEN);
1873 #ifdef CONFIG_TESTING_OPTIONS
1874 sm->tls_test_flags = sess->tls_test_flags;
1875 #endif /* CONFIG_TESTING_OPTIONS */
1876
1877 wpa_printf(MSG_DEBUG, "EAP: Server state machine created");
1878
1879 return sm;
1880 }
1881
1882
1883 /**
1884 * eap_server_sm_deinit - Deinitialize and free an EAP server state machine
1885 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
1886 *
1887 * This function deinitializes EAP state machine and frees all allocated
1888 * resources.
1889 */
1890 void eap_server_sm_deinit(struct eap_sm *sm)
1891 {
1892 if (sm == NULL)
1893 return;
1894 wpa_printf(MSG_DEBUG, "EAP: Server state machine removed");
1895 if (sm->m && sm->eap_method_priv)
1896 sm->m->reset(sm, sm->eap_method_priv);
1897 wpabuf_free(sm->eap_if.eapReqData);
1898 bin_clear_free(sm->eap_if.eapKeyData, sm->eap_if.eapKeyDataLen);
1899 os_free(sm->eap_if.eapSessionId);
1900 wpabuf_free(sm->lastReqData);
1901 wpabuf_free(sm->eap_if.eapRespData);
1902 os_free(sm->identity);
1903 os_free(sm->serial_num);
1904 wpabuf_free(sm->eap_if.aaaEapReqData);
1905 wpabuf_free(sm->eap_if.aaaEapRespData);
1906 bin_clear_free(sm->eap_if.aaaEapKeyData, sm->eap_if.aaaEapKeyDataLen);
1907 eap_user_free(sm->user);
1908 wpabuf_free(sm->assoc_wps_ie);
1909 wpabuf_free(sm->assoc_p2p_ie);
1910 os_free(sm);
1911 }
1912
1913
1914 /**
1915 * eap_sm_notify_cached - Notify EAP state machine of cached PMK
1916 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
1917 *
1918 * This function is called when PMKSA caching is used to skip EAP
1919 * authentication.
1920 */
1921 void eap_sm_notify_cached(struct eap_sm *sm)
1922 {
1923 if (sm == NULL)
1924 return;
1925
1926 sm->EAP_state = EAP_SUCCESS;
1927 }
1928
1929
1930 /**
1931 * eap_sm_pending_cb - EAP state machine callback for a pending EAP request
1932 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
1933 *
1934 * This function is called when data for a pending EAP-Request is received.
1935 */
1936 void eap_sm_pending_cb(struct eap_sm *sm)
1937 {
1938 if (sm == NULL)
1939 return;
1940 wpa_printf(MSG_DEBUG, "EAP: Callback for pending request received");
1941 if (sm->method_pending == METHOD_PENDING_WAIT)
1942 sm->method_pending = METHOD_PENDING_CONT;
1943 }
1944
1945
1946 /**
1947 * eap_sm_method_pending - Query whether EAP method is waiting for pending data
1948 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
1949 * Returns: 1 if method is waiting for pending data or 0 if not
1950 */
1951 int eap_sm_method_pending(struct eap_sm *sm)
1952 {
1953 if (sm == NULL)
1954 return 0;
1955 return sm->method_pending == METHOD_PENDING_WAIT;
1956 }
1957
1958
1959 /**
1960 * eap_get_identity - Get the user identity (from EAP-Response/Identity)
1961 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
1962 * @len: Buffer for returning identity length
1963 * Returns: Pointer to the user identity or %NULL if not available
1964 */
1965 const u8 * eap_get_identity(struct eap_sm *sm, size_t *len)
1966 {
1967 *len = sm->identity_len;
1968 return sm->identity;
1969 }
1970
1971
1972 /**
1973 * eap_get_serial_num - Get the serial number of user certificate
1974 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
1975 * Returns: Pointer to the serial number or %NULL if not available
1976 */
1977 const char * eap_get_serial_num(struct eap_sm *sm)
1978 {
1979 return sm->serial_num;
1980 }
1981
1982
1983 /**
1984 * eap_get_method - Get the used EAP method
1985 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
1986 * Returns: Pointer to the method name or %NULL if not available
1987 */
1988 const char * eap_get_method(struct eap_sm *sm)
1989 {
1990 if (!sm || !sm->m)
1991 return NULL;
1992 return sm->m->name;
1993 }
1994
1995
1996 /**
1997 * eap_get_imsi - Get IMSI of the user
1998 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
1999 * Returns: Pointer to IMSI or %NULL if not available
2000 */
2001 const char * eap_get_imsi(struct eap_sm *sm)
2002 {
2003 if (!sm || sm->imsi[0] == '\0')
2004 return NULL;
2005 return sm->imsi;
2006 }
2007
2008
2009 void eap_erp_update_identity(struct eap_sm *sm, const u8 *eap, size_t len)
2010 {
2011 #ifdef CONFIG_ERP
2012 const struct eap_hdr *hdr;
2013 const u8 *pos, *end;
2014 struct erp_tlvs parse;
2015
2016 if (len < sizeof(*hdr) + 1)
2017 return;
2018 hdr = (const struct eap_hdr *) eap;
2019 end = eap + len;
2020 pos = (const u8 *) (hdr + 1);
2021 if (hdr->code != EAP_CODE_INITIATE || *pos != EAP_ERP_TYPE_REAUTH)
2022 return;
2023 pos++;
2024 if (pos + 3 > end)
2025 return;
2026
2027 /* Skip Flags and SEQ */
2028 pos += 3;
2029
2030 if (erp_parse_tlvs(pos, end, &parse, 1) < 0 || !parse.keyname)
2031 return;
2032 wpa_hexdump_ascii(MSG_DEBUG,
2033 "EAP: Update identity based on EAP-Initiate/Re-auth keyName-NAI",
2034 parse.keyname, parse.keyname_len);
2035 os_free(sm->identity);
2036 sm->identity = os_malloc(parse.keyname_len);
2037 if (sm->identity) {
2038 os_memcpy(sm->identity, parse.keyname, parse.keyname_len);
2039 sm->identity_len = parse.keyname_len;
2040 } else {
2041 sm->identity_len = 0;
2042 }
2043 #endif /* CONFIG_ERP */
2044 }
2045
2046
2047 /**
2048 * eap_get_interface - Get pointer to EAP-EAPOL interface data
2049 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
2050 * Returns: Pointer to the EAP-EAPOL interface data
2051 */
2052 struct eap_eapol_interface * eap_get_interface(struct eap_sm *sm)
2053 {
2054 return &sm->eap_if;
2055 }
2056
2057
2058 /**
2059 * eap_server_clear_identity - Clear EAP identity information
2060 * @sm: Pointer to EAP state machine allocated with eap_server_sm_init()
2061 *
2062 * This function can be used to clear the EAP identity information in the EAP
2063 * server context. This allows the EAP/Identity method to be used again after
2064 * EAPOL-Start or EAPOL-Logoff.
2065 */
2066 void eap_server_clear_identity(struct eap_sm *sm)
2067 {
2068 os_free(sm->identity);
2069 sm->identity = NULL;
2070 }
2071
2072
2073 #ifdef CONFIG_TESTING_OPTIONS
2074 void eap_server_mschap_rx_callback(struct eap_sm *sm, const char *source,
2075 const u8 *username, size_t username_len,
2076 const u8 *challenge, const u8 *response)
2077 {
2078 char hex_challenge[30], hex_response[90], user[100];
2079
2080 /* Print out Challenge and Response in format supported by asleap. */
2081 if (username)
2082 printf_encode(user, sizeof(user), username, username_len);
2083 else
2084 user[0] = '\0';
2085 wpa_snprintf_hex_sep(hex_challenge, sizeof(hex_challenge),
2086 challenge, sizeof(challenge), ':');
2087 wpa_snprintf_hex_sep(hex_response, sizeof(hex_response), response, 24,
2088 ':');
2089 wpa_printf(MSG_DEBUG, "[%s/user=%s] asleap -C %s -R %s",
2090 source, user, hex_challenge, hex_response);
2091 }
2092 #endif /* CONFIG_TESTING_OPTIONS */
2093
2094
2095 void eap_server_config_free(struct eap_config *cfg)
2096 {
2097 if (!cfg)
2098 return;
2099 os_free(cfg->pac_opaque_encr_key);
2100 os_free(cfg->eap_fast_a_id);
2101 os_free(cfg->eap_fast_a_id_info);
2102 os_free(cfg->server_id);
2103 os_free(cfg);
2104 }
Unnamed repository; edit this file 'description' to name the repository.