2 * EAP peer method: EAP-PEAP (draft-josefsson-pppext-eap-tls-eap-07.txt)
3 * Copyright (c) 2004-2006, Jouni Malinen <j@w1.fi>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
9 * Alternatively, this software may be distributed under the terms of BSD
12 * See README and COPYING for more details.
19 #include "eap_tls_common.h"
20 #include "config_ssid.h"
25 /* Maximum supported PEAP version
26 * 0 = Microsoft's PEAP version 0; draft-kamath-pppext-peapv0-00.txt
27 * 1 = draft-josefsson-ppext-eap-tls-eap-05.txt
28 * 2 = draft-josefsson-ppext-eap-tls-eap-07.txt
30 #define EAP_PEAP_VERSION 1
33 static void eap_peap_deinit(struct eap_sm *sm, void *priv);
36 struct eap_peap_data {
37 struct eap_ssl_data ssl;
39 int peap_version, force_peap_version, force_new_label;
41 const struct eap_method *phase2_method;
45 struct eap_method_type phase2_type;
46 struct eap_method_type *phase2_types;
47 size_t num_phase2_types;
49 int peap_outer_success; /* 0 = PEAP terminated on Phase 2 inner
51 * 1 = reply with tunneled EAP-Success to inner
52 * EAP-Success and expect AS to send outer
53 * (unencrypted) EAP-Success after this
54 * 2 = reply with PEAP/TLS ACK to inner
55 * EAP-Success and expect AS to send outer
56 * (unencrypted) EAP-Success after this */
57 int resuming; /* starting a resumed session */
60 u8 *pending_phase2_req;
61 size_t pending_phase2_req_len;
65 static void * eap_peap_init(struct eap_sm *sm)
67 struct eap_peap_data *data;
68 struct wpa_ssid *config = eap_get_config(sm);
70 data = os_zalloc(sizeof(*data));
73 sm->peap_done = FALSE;
74 data->peap_version = EAP_PEAP_VERSION;
75 data->force_peap_version = -1;
76 data->peap_outer_success = 2;
78 if (config && config->phase1) {
79 char *pos = os_strstr(config->phase1, "peapver=");
81 data->force_peap_version = atoi(pos + 8);
82 data->peap_version = data->force_peap_version;
83 wpa_printf(MSG_DEBUG, "EAP-PEAP: Forced PEAP version "
84 "%d", data->force_peap_version);
87 if (os_strstr(config->phase1, "peaplabel=1")) {
88 data->force_new_label = 1;
89 wpa_printf(MSG_DEBUG, "EAP-PEAP: Force new label for "
93 if (os_strstr(config->phase1, "peap_outer_success=0")) {
94 data->peap_outer_success = 0;
95 wpa_printf(MSG_DEBUG, "EAP-PEAP: terminate "
96 "authentication on tunneled EAP-Success");
97 } else if (os_strstr(config->phase1, "peap_outer_success=1")) {
98 data->peap_outer_success = 1;
99 wpa_printf(MSG_DEBUG, "EAP-PEAP: send tunneled "
100 "EAP-Success after receiving tunneled "
102 } else if (os_strstr(config->phase1, "peap_outer_success=2")) {
103 data->peap_outer_success = 2;
104 wpa_printf(MSG_DEBUG, "EAP-PEAP: send PEAP/TLS ACK "
105 "after receiving tunneled EAP-Success");
109 if (config && config->phase2) {
110 char *start, *pos, *buf;
111 struct eap_method_type *methods = NULL, *_methods;
113 size_t num_methods = 0;
114 start = buf = os_strdup(config->phase2);
116 eap_peap_deinit(sm, data);
119 while (start && *start != '\0') {
121 pos = os_strstr(start, "auth=");
124 if (start != pos && *(pos - 1) != ' ') {
130 pos = os_strchr(start, ' ');
133 method = eap_get_phase2_type(start, &vendor);
134 if (vendor == EAP_VENDOR_IETF &&
135 method == EAP_TYPE_NONE) {
136 wpa_printf(MSG_ERROR, "EAP-PEAP: Unsupported "
137 "Phase2 method '%s'", start);
140 _methods = os_realloc(
142 num_methods * sizeof(*methods));
143 if (_methods == NULL) {
146 eap_peap_deinit(sm, data);
150 methods[num_methods - 1].vendor = vendor;
151 methods[num_methods - 1].method = method;
157 data->phase2_types = methods;
158 data->num_phase2_types = num_methods;
160 if (data->phase2_types == NULL) {
162 eap_get_phase2_types(config, &data->num_phase2_types);
164 if (data->phase2_types == NULL) {
165 wpa_printf(MSG_ERROR, "EAP-PEAP: No Phase2 method available");
166 eap_peap_deinit(sm, data);
169 wpa_hexdump(MSG_DEBUG, "EAP-PEAP: Phase2 EAP types",
170 (u8 *) data->phase2_types,
171 data->num_phase2_types * sizeof(struct eap_method_type));
172 data->phase2_type.vendor = EAP_VENDOR_IETF;
173 data->phase2_type.method = EAP_TYPE_NONE;
175 if (eap_tls_ssl_init(sm, &data->ssl, config)) {
176 wpa_printf(MSG_INFO, "EAP-PEAP: Failed to initialize SSL.");
177 eap_peap_deinit(sm, data);
185 static void eap_peap_deinit(struct eap_sm *sm, void *priv)
187 struct eap_peap_data *data = priv;
190 if (data->phase2_priv && data->phase2_method)
191 data->phase2_method->deinit(sm, data->phase2_priv);
192 os_free(data->phase2_types);
193 eap_tls_ssl_deinit(sm, &data->ssl);
194 os_free(data->key_data);
195 os_free(data->pending_phase2_req);
200 static int eap_peap_encrypt(struct eap_sm *sm, struct eap_peap_data *data,
201 int id, const u8 *plain, size_t plain_len,
202 u8 **out_data, size_t *out_len)
206 struct eap_hdr *resp;
208 /* TODO: add support for fragmentation, if needed. This will need to
209 * add TLS Message Length field, if the frame is fragmented.
210 * Note: Microsoft IAS did not seem to like TLS Message Length with
212 resp = os_malloc(sizeof(struct eap_hdr) + 2 + data->ssl.tls_out_limit);
216 resp->code = EAP_CODE_RESPONSE;
217 resp->identifier = id;
219 pos = (u8 *) (resp + 1);
220 *pos++ = EAP_TYPE_PEAP;
221 *pos++ = data->peap_version;
223 res = tls_connection_encrypt(sm->ssl_ctx, data->ssl.conn,
225 pos, data->ssl.tls_out_limit);
227 wpa_printf(MSG_INFO, "EAP-PEAP: Failed to encrypt Phase 2 "
233 *out_len = sizeof(struct eap_hdr) + 2 + res;
234 resp->length = host_to_be16(*out_len);
235 *out_data = (u8 *) resp;
240 static int eap_peap_phase2_nak(struct eap_peap_data *data, struct eap_hdr *hdr,
241 u8 **resp, size_t *resp_len)
243 struct eap_hdr *resp_hdr;
244 u8 *pos = (u8 *) (hdr + 1);
247 /* TODO: add support for expanded Nak */
248 wpa_printf(MSG_DEBUG, "EAP-PEAP: Phase 2 Request: Nak type=%d", *pos);
249 wpa_hexdump(MSG_DEBUG, "EAP-PEAP: Allowed Phase2 EAP types",
250 (u8 *) data->phase2_types,
251 data->num_phase2_types * sizeof(struct eap_method_type));
252 *resp_len = sizeof(struct eap_hdr) + 1;
253 *resp = os_malloc(*resp_len + data->num_phase2_types);
257 resp_hdr = (struct eap_hdr *) (*resp);
258 resp_hdr->code = EAP_CODE_RESPONSE;
259 resp_hdr->identifier = hdr->identifier;
260 pos = (u8 *) (resp_hdr + 1);
261 *pos++ = EAP_TYPE_NAK;
262 for (i = 0; i < data->num_phase2_types; i++) {
263 if (data->phase2_types[i].vendor == EAP_VENDOR_IETF &&
264 data->phase2_types[i].method < 256) {
266 *pos++ = data->phase2_types[i].method;
269 resp_hdr->length = host_to_be16(*resp_len);
275 static int eap_peap_phase2_request(struct eap_sm *sm,
276 struct eap_peap_data *data,
277 struct eap_method_ret *ret,
279 u8 **resp, size_t *resp_len)
281 size_t len = be_to_host16(hdr->length);
283 struct eap_method_ret iret;
284 struct wpa_ssid *config = eap_get_config(sm);
286 if (len <= sizeof(struct eap_hdr)) {
287 wpa_printf(MSG_INFO, "EAP-PEAP: too short "
288 "Phase 2 request (len=%lu)", (unsigned long) len);
291 pos = (u8 *) (hdr + 1);
292 wpa_printf(MSG_DEBUG, "EAP-PEAP: Phase 2 Request: type=%d", *pos);
294 case EAP_TYPE_IDENTITY:
295 *resp = eap_sm_buildIdentity(sm, hdr->identifier, resp_len, 1);
298 os_memset(&iret, 0, sizeof(iret));
299 if (eap_tlv_process(sm, &iret, hdr, resp, resp_len)) {
300 ret->methodState = METHOD_DONE;
301 ret->decision = DECISION_FAIL;
304 if (iret.methodState == METHOD_DONE ||
305 iret.methodState == METHOD_MAY_CONT) {
306 ret->methodState = iret.methodState;
307 ret->decision = iret.decision;
308 data->phase2_success = 1;
312 if (data->phase2_type.vendor == EAP_VENDOR_IETF &&
313 data->phase2_type.method == EAP_TYPE_NONE) {
315 for (i = 0; i < data->num_phase2_types; i++) {
316 if (data->phase2_types[i].vendor !=
318 data->phase2_types[i].method != *pos)
321 data->phase2_type.vendor =
322 data->phase2_types[i].vendor;
323 data->phase2_type.method =
324 data->phase2_types[i].method;
325 wpa_printf(MSG_DEBUG, "EAP-PEAP: Selected "
326 "Phase 2 EAP vendor %d method %d",
327 data->phase2_type.vendor,
328 data->phase2_type.method);
332 if (*pos != data->phase2_type.method ||
333 *pos == EAP_TYPE_NONE) {
334 if (eap_peap_phase2_nak(data, hdr, resp, resp_len))
339 if (data->phase2_priv == NULL) {
340 data->phase2_method = eap_sm_get_eap_methods(
341 data->phase2_type.vendor,
342 data->phase2_type.method);
343 if (data->phase2_method) {
346 data->phase2_method->init(sm);
350 if (data->phase2_priv == NULL || data->phase2_method == NULL) {
351 wpa_printf(MSG_INFO, "EAP-PEAP: failed to initialize "
352 "Phase 2 EAP method %d", *pos);
353 ret->methodState = METHOD_DONE;
354 ret->decision = DECISION_FAIL;
357 os_memset(&iret, 0, sizeof(iret));
358 *resp = data->phase2_method->process(sm, data->phase2_priv,
359 &iret, (u8 *) hdr, len,
361 if ((iret.methodState == METHOD_DONE ||
362 iret.methodState == METHOD_MAY_CONT) &&
363 (iret.decision == DECISION_UNCOND_SUCC ||
364 iret.decision == DECISION_COND_SUCC)) {
365 data->phase2_success = 1;
371 (config->pending_req_identity || config->pending_req_password ||
372 config->pending_req_otp || config->pending_req_new_password)) {
373 os_free(data->pending_phase2_req);
374 data->pending_phase2_req = os_malloc(len);
375 if (data->pending_phase2_req) {
376 os_memcpy(data->pending_phase2_req, hdr, len);
377 data->pending_phase2_req_len = len;
385 static int eap_peap_decrypt(struct eap_sm *sm, struct eap_peap_data *data,
386 struct eap_method_ret *ret,
387 const struct eap_hdr *req,
388 const u8 *in_data, size_t in_len,
389 u8 **out_data, size_t *out_len)
392 int res, skip_change = 0;
393 struct eap_hdr *hdr, *rhdr;
395 size_t resp_len, len_decrypted, len, buf_len;
400 wpa_printf(MSG_DEBUG, "EAP-PEAP: received %lu bytes encrypted data for"
401 " Phase 2", (unsigned long) in_len);
403 if (data->pending_phase2_req) {
404 wpa_printf(MSG_DEBUG, "EAP-PEAP: Pending Phase 2 request - "
405 "skip decryption and use old data");
406 /* Clear TLS reassembly state. */
407 os_free(data->ssl.tls_in);
408 data->ssl.tls_in = NULL;
409 data->ssl.tls_in_len = 0;
410 data->ssl.tls_in_left = 0;
411 data->ssl.tls_in_total = 0;
412 in_decrypted = data->pending_phase2_req;
413 data->pending_phase2_req = NULL;
414 len_decrypted = data->pending_phase2_req_len;
419 msg = eap_tls_data_reassemble(sm, &data->ssl, in_data, in_len,
420 &msg_len, &need_more_input);
422 return need_more_input ? 1 : -1;
424 if (in_len == 0 && sm->workaround && data->phase2_success) {
426 * Cisco ACS seems to be using TLS ACK to terminate
427 * EAP-PEAPv0/GTC. Try to reply with TLS ACK.
429 wpa_printf(MSG_DEBUG, "EAP-PEAP: Received TLS ACK, but "
430 "expected data - acknowledge with TLS ACK since "
431 "Phase 2 has been completed");
432 ret->decision = DECISION_COND_SUCC;
433 ret->methodState = METHOD_DONE;
438 if (data->ssl.tls_in_total > buf_len)
439 buf_len = data->ssl.tls_in_total;
440 in_decrypted = os_malloc(buf_len);
441 if (in_decrypted == NULL) {
442 os_free(data->ssl.tls_in);
443 data->ssl.tls_in = NULL;
444 data->ssl.tls_in_len = 0;
445 wpa_printf(MSG_WARNING, "EAP-PEAP: failed to allocate memory "
450 res = tls_connection_decrypt(sm->ssl_ctx, data->ssl.conn,
451 msg, msg_len, in_decrypted, buf_len);
452 os_free(data->ssl.tls_in);
453 data->ssl.tls_in = NULL;
454 data->ssl.tls_in_len = 0;
456 wpa_printf(MSG_INFO, "EAP-PEAP: Failed to decrypt Phase 2 "
458 os_free(in_decrypted);
464 wpa_hexdump(MSG_DEBUG, "EAP-PEAP: Decrypted Phase 2 EAP", in_decrypted,
467 hdr = (struct eap_hdr *) in_decrypted;
468 if (len_decrypted == 5 && hdr->code == EAP_CODE_REQUEST &&
469 be_to_host16(hdr->length) == 5 &&
470 in_decrypted[4] == EAP_TYPE_IDENTITY) {
471 /* At least FreeRADIUS seems to send full EAP header with
472 * EAP Request Identity */
475 if (len_decrypted >= 5 && hdr->code == EAP_CODE_REQUEST &&
476 in_decrypted[4] == EAP_TYPE_TLV) {
480 if (data->peap_version == 0 && !skip_change) {
481 struct eap_hdr *nhdr = os_malloc(sizeof(struct eap_hdr) +
484 os_free(in_decrypted);
487 os_memcpy((u8 *) (nhdr + 1), in_decrypted, len_decrypted);
488 os_free(in_decrypted);
489 nhdr->code = req->code;
490 nhdr->identifier = req->identifier;
491 nhdr->length = host_to_be16(sizeof(struct eap_hdr) +
494 len_decrypted += sizeof(struct eap_hdr);
495 in_decrypted = (u8 *) nhdr;
497 hdr = (struct eap_hdr *) in_decrypted;
498 if (len_decrypted < sizeof(*hdr)) {
499 os_free(in_decrypted);
500 wpa_printf(MSG_INFO, "EAP-PEAP: Too short Phase 2 "
501 "EAP frame (len=%lu)",
502 (unsigned long) len_decrypted);
505 len = be_to_host16(hdr->length);
506 if (len > len_decrypted) {
507 os_free(in_decrypted);
508 wpa_printf(MSG_INFO, "EAP-PEAP: Length mismatch in "
509 "Phase 2 EAP frame (len=%lu hdr->length=%lu)",
510 (unsigned long) len_decrypted, (unsigned long) len);
513 if (len < len_decrypted) {
514 wpa_printf(MSG_INFO, "EAP-PEAP: Odd.. Phase 2 EAP header has "
515 "shorter length than full decrypted data "
517 (unsigned long) len, (unsigned long) len_decrypted);
518 if (sm->workaround && len == 4 && len_decrypted == 5 &&
519 in_decrypted[4] == EAP_TYPE_IDENTITY) {
520 /* Radiator 3.9 seems to set Phase 2 EAP header to use
521 * incorrect length for the EAP-Request Identity
522 * packet, so fix the inner header to interoperate..
523 * This was fixed in 2004-06-23 patch for Radiator and
524 * this workaround can be removed at some point. */
525 wpa_printf(MSG_INFO, "EAP-PEAP: workaround -> replace "
526 "Phase 2 EAP header len (%lu) with real "
527 "decrypted len (%lu)",
529 (unsigned long) len_decrypted);
531 hdr->length = host_to_be16(len);
534 wpa_printf(MSG_DEBUG, "EAP-PEAP: received Phase 2: code=%d "
535 "identifier=%d length=%lu", hdr->code, hdr->identifier,
536 (unsigned long) len);
538 case EAP_CODE_REQUEST:
539 if (eap_peap_phase2_request(sm, data, ret, hdr,
541 os_free(in_decrypted);
542 wpa_printf(MSG_INFO, "EAP-PEAP: Phase2 Request "
543 "processing failed");
547 case EAP_CODE_SUCCESS:
548 wpa_printf(MSG_DEBUG, "EAP-PEAP: Phase 2 Success");
549 if (data->peap_version == 1) {
550 /* EAP-Success within TLS tunnel is used to indicate
551 * shutdown of the TLS channel. The authentication has
553 wpa_printf(MSG_DEBUG, "EAP-PEAP: Version 1 - "
554 "EAP-Success within TLS tunnel - "
555 "authentication completed");
556 ret->decision = DECISION_UNCOND_SUCC;
557 ret->methodState = METHOD_DONE;
558 data->phase2_success = 1;
559 if (data->peap_outer_success == 2) {
560 os_free(in_decrypted);
561 wpa_printf(MSG_DEBUG, "EAP-PEAP: Use TLS ACK "
562 "to finish authentication");
564 } else if (data->peap_outer_success == 1) {
565 /* Reply with EAP-Success within the TLS
566 * channel to complete the authentication. */
567 resp_len = sizeof(struct eap_hdr);
568 resp = os_zalloc(resp_len);
570 rhdr = (struct eap_hdr *) resp;
571 rhdr->code = EAP_CODE_SUCCESS;
572 rhdr->identifier = hdr->identifier;
573 rhdr->length = host_to_be16(resp_len);
576 /* No EAP-Success expected for Phase 1 (outer,
577 * unencrypted auth), so force EAP state
578 * machine to SUCCESS state. */
579 sm->peap_done = TRUE;
585 case EAP_CODE_FAILURE:
586 wpa_printf(MSG_DEBUG, "EAP-PEAP: Phase 2 Failure");
587 ret->decision = DECISION_FAIL;
588 ret->methodState = METHOD_MAY_CONT;
589 ret->allowNotifications = FALSE;
590 /* Reply with EAP-Failure within the TLS channel to complete
591 * failure reporting. */
592 resp_len = sizeof(struct eap_hdr);
593 resp = os_zalloc(resp_len);
595 rhdr = (struct eap_hdr *) resp;
596 rhdr->code = EAP_CODE_FAILURE;
597 rhdr->identifier = hdr->identifier;
598 rhdr->length = host_to_be16(resp_len);
602 wpa_printf(MSG_INFO, "EAP-PEAP: Unexpected code=%d in "
603 "Phase 2 EAP header", hdr->code);
607 os_free(in_decrypted);
611 size_t resp_send_len;
612 int skip_change2 = 0;
614 wpa_hexdump_key(MSG_DEBUG, "EAP-PEAP: Encrypting Phase 2 data",
616 /* PEAP version changes */
617 if (resp_len >= 5 && resp[0] == EAP_CODE_RESPONSE &&
618 resp[4] == EAP_TYPE_TLV)
620 if (data->peap_version == 0 && !skip_change2) {
621 resp_pos = resp + sizeof(struct eap_hdr);
622 resp_send_len = resp_len - sizeof(struct eap_hdr);
625 resp_send_len = resp_len;
628 if (eap_peap_encrypt(sm, data, req->identifier,
629 resp_pos, resp_send_len,
630 out_data, out_len)) {
631 wpa_printf(MSG_INFO, "EAP-PEAP: Failed to encrypt "
641 static u8 * eap_peap_process(struct eap_sm *sm, void *priv,
642 struct eap_method_ret *ret,
643 const u8 *reqData, size_t reqDataLen,
646 const struct eap_hdr *req;
651 struct eap_peap_data *data = priv;
653 pos = eap_tls_process_init(sm, &data->ssl, EAP_TYPE_PEAP, ret,
654 reqData, reqDataLen, &left, &flags);
657 req = (const struct eap_hdr *) reqData;
658 id = req->identifier;
660 if (flags & EAP_TLS_FLAGS_START) {
661 wpa_printf(MSG_DEBUG, "EAP-PEAP: Start (server ver=%d, own "
662 "ver=%d)", flags & EAP_PEAP_VERSION_MASK,
664 if ((flags & EAP_PEAP_VERSION_MASK) < data->peap_version)
665 data->peap_version = flags & EAP_PEAP_VERSION_MASK;
666 if (data->force_peap_version >= 0 &&
667 data->force_peap_version != data->peap_version) {
668 wpa_printf(MSG_WARNING, "EAP-PEAP: Failed to select "
669 "forced PEAP version %d",
670 data->force_peap_version);
671 ret->methodState = METHOD_DONE;
672 ret->decision = DECISION_FAIL;
673 ret->allowNotifications = FALSE;
676 wpa_printf(MSG_DEBUG, "EAP-PEAP: Using PEAP version %d",
678 left = 0; /* make sure that this frame is empty, even though it
679 * should always be, anyway */
683 if (tls_connection_established(sm->ssl_ctx, data->ssl.conn) &&
685 res = eap_peap_decrypt(sm, data, ret, req, pos, left,
688 res = eap_tls_process_helper(sm, &data->ssl, EAP_TYPE_PEAP,
689 data->peap_version, id, pos, left,
692 if (tls_connection_established(sm->ssl_ctx, data->ssl.conn)) {
694 wpa_printf(MSG_DEBUG,
695 "EAP-PEAP: TLS done, proceed to Phase 2");
696 os_free(data->key_data);
697 /* draft-josefsson-ppext-eap-tls-eap-05.txt
698 * specifies that PEAPv1 would use "client PEAP
699 * encryption" as the label. However, most existing
700 * PEAPv1 implementations seem to be using the old
701 * label, "client EAP encryption", instead. Use the old
702 * label by default, but allow it to be configured with
703 * phase1 parameter peaplabel=1. */
704 if (data->peap_version > 1 || data->force_new_label)
705 label = "client PEAP encryption";
707 label = "client EAP encryption";
708 wpa_printf(MSG_DEBUG, "EAP-PEAP: using label '%s' in "
709 "key derivation", label);
711 eap_tls_derive_key(sm, &data->ssl, label,
713 if (data->key_data) {
714 wpa_hexdump_key(MSG_DEBUG,
715 "EAP-PEAP: Derived key",
719 wpa_printf(MSG_DEBUG, "EAP-PEAP: Failed to "
723 if (sm->workaround && data->resuming) {
725 * At least few RADIUS servers (Aegis v1.1.6;
726 * but not v1.1.4; and Cisco ACS) seem to be
727 * terminating PEAPv1 (Aegis) or PEAPv0 (Cisco
728 * ACS) session resumption with outer
729 * EAP-Success. This does not seem to follow
730 * draft-josefsson-pppext-eap-tls-eap-05.txt
731 * section 4.2, so only allow this if EAP
732 * workarounds are enabled.
734 wpa_printf(MSG_DEBUG, "EAP-PEAP: Workaround - "
735 "allow outer EAP-Success to "
736 "terminate PEAP resumption");
737 ret->decision = DECISION_COND_SUCC;
738 data->phase2_success = 1;
746 * Application data included in the handshake message.
748 os_free(data->pending_phase2_req);
749 data->pending_phase2_req = resp;
750 data->pending_phase2_req_len = *respDataLen;
753 res = eap_peap_decrypt(sm, data, ret, req, pos, left,
758 if (ret->methodState == METHOD_DONE) {
759 ret->allowNotifications = FALSE;
763 return eap_tls_build_ack(&data->ssl, respDataLen, id,
764 EAP_TYPE_PEAP, data->peap_version);
771 static Boolean eap_peap_has_reauth_data(struct eap_sm *sm, void *priv)
773 struct eap_peap_data *data = priv;
774 return tls_connection_established(sm->ssl_ctx, data->ssl.conn) &&
775 data->phase2_success;
779 static void eap_peap_deinit_for_reauth(struct eap_sm *sm, void *priv)
781 struct eap_peap_data *data = priv;
782 os_free(data->pending_phase2_req);
783 data->pending_phase2_req = NULL;
787 static void * eap_peap_init_for_reauth(struct eap_sm *sm, void *priv)
789 struct eap_peap_data *data = priv;
790 os_free(data->key_data);
791 data->key_data = NULL;
792 if (eap_tls_reauth_init(sm, &data->ssl)) {
796 if (data->phase2_priv && data->phase2_method &&
797 data->phase2_method->init_for_reauth)
798 data->phase2_method->init_for_reauth(sm, data->phase2_priv);
799 data->phase2_success = 0;
801 sm->peap_done = FALSE;
806 static int eap_peap_get_status(struct eap_sm *sm, void *priv, char *buf,
807 size_t buflen, int verbose)
809 struct eap_peap_data *data = priv;
812 len = eap_tls_status(sm, &data->ssl, buf, buflen, verbose);
813 if (data->phase2_method) {
814 ret = os_snprintf(buf + len, buflen - len,
815 "EAP-PEAPv%d Phase2 method=%s\n",
817 data->phase2_method->name);
818 if (ret < 0 || (size_t) ret >= buflen - len)
826 static Boolean eap_peap_isKeyAvailable(struct eap_sm *sm, void *priv)
828 struct eap_peap_data *data = priv;
829 return data->key_data != NULL && data->phase2_success;
833 static u8 * eap_peap_getKey(struct eap_sm *sm, void *priv, size_t *len)
835 struct eap_peap_data *data = priv;
838 if (data->key_data == NULL || !data->phase2_success)
841 key = os_malloc(EAP_TLS_KEY_LEN);
845 *len = EAP_TLS_KEY_LEN;
846 os_memcpy(key, data->key_data, EAP_TLS_KEY_LEN);
852 int eap_peer_peap_register(void)
854 struct eap_method *eap;
857 eap = eap_peer_method_alloc(EAP_PEER_METHOD_INTERFACE_VERSION,
858 EAP_VENDOR_IETF, EAP_TYPE_PEAP, "PEAP");
862 eap->init = eap_peap_init;
863 eap->deinit = eap_peap_deinit;
864 eap->process = eap_peap_process;
865 eap->isKeyAvailable = eap_peap_isKeyAvailable;
866 eap->getKey = eap_peap_getKey;
867 eap->get_status = eap_peap_get_status;
868 eap->has_reauth_data = eap_peap_has_reauth_data;
869 eap->deinit_for_reauth = eap_peap_deinit_for_reauth;
870 eap->init_for_reauth = eap_peap_init_for_reauth;
872 ret = eap_peer_method_register(eap);
874 eap_peer_method_free(eap);