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