LCOV - code coverage report
Current view: top level - eap_server - eap_server_ttls.c (source / functions) Hit Total Coverage
Test: hostapd hwsim test run 1401872338 Lines: 395 590 66.9 %
Date: 2014-06-04 Functions: 29 29 100.0 %

          Line data    Source code
       1             : /*
       2             :  * hostapd / EAP-TTLS (RFC 5281)
       3             :  * Copyright (c) 2004-2011, Jouni Malinen <j@w1.fi>
       4             :  *
       5             :  * This software may be distributed under the terms of the BSD license.
       6             :  * See README for more details.
       7             :  */
       8             : 
       9             : #include "includes.h"
      10             : 
      11             : #include "common.h"
      12             : #include "crypto/ms_funcs.h"
      13             : #include "crypto/sha1.h"
      14             : #include "crypto/tls.h"
      15             : #include "eap_server/eap_i.h"
      16             : #include "eap_server/eap_tls_common.h"
      17             : #include "eap_common/chap.h"
      18             : #include "eap_common/eap_ttls.h"
      19             : 
      20             : 
      21             : #define EAP_TTLS_VERSION 0
      22             : 
      23             : 
      24             : static void eap_ttls_reset(struct eap_sm *sm, void *priv);
      25             : 
      26             : 
      27             : struct eap_ttls_data {
      28             :         struct eap_ssl_data ssl;
      29             :         enum {
      30             :                 START, PHASE1, PHASE2_START, PHASE2_METHOD,
      31             :                 PHASE2_MSCHAPV2_RESP, SUCCESS, FAILURE
      32             :         } state;
      33             : 
      34             :         int ttls_version;
      35             :         const struct eap_method *phase2_method;
      36             :         void *phase2_priv;
      37             :         int mschapv2_resp_ok;
      38             :         u8 mschapv2_auth_response[20];
      39             :         u8 mschapv2_ident;
      40             :         struct wpabuf *pending_phase2_eap_resp;
      41             :         int tnc_started;
      42             : };
      43             : 
      44             : 
      45         100 : static const char * eap_ttls_state_txt(int state)
      46             : {
      47         100 :         switch (state) {
      48             :         case START:
      49          22 :                 return "START";
      50             :         case PHASE1:
      51          35 :                 return "PHASE1";
      52             :         case PHASE2_START:
      53          21 :                 return "PHASE2_START";
      54             :         case PHASE2_METHOD:
      55           2 :                 return "PHASE2_METHOD";
      56             :         case PHASE2_MSCHAPV2_RESP:
      57           6 :                 return "PHASE2_MSCHAPV2_RESP";
      58             :         case SUCCESS:
      59          11 :                 return "SUCCESS";
      60             :         case FAILURE:
      61           3 :                 return "FAILURE";
      62             :         default:
      63           0 :                 return "Unknown?!";
      64             :         }
      65             : }
      66             : 
      67             : 
      68          50 : static void eap_ttls_state(struct eap_ttls_data *data, int state)
      69             : {
      70         100 :         wpa_printf(MSG_DEBUG, "EAP-TTLS: %s -> %s",
      71          50 :                    eap_ttls_state_txt(data->state),
      72             :                    eap_ttls_state_txt(state));
      73          50 :         data->state = state;
      74          50 : }
      75             : 
      76             : 
      77           6 : static u8 * eap_ttls_avp_hdr(u8 *avphdr, u32 avp_code, u32 vendor_id,
      78             :                              int mandatory, size_t len)
      79             : {
      80             :         struct ttls_avp_vendor *avp;
      81             :         u8 flags;
      82             :         size_t hdrlen;
      83             : 
      84           6 :         avp = (struct ttls_avp_vendor *) avphdr;
      85           6 :         flags = mandatory ? AVP_FLAGS_MANDATORY : 0;
      86           6 :         if (vendor_id) {
      87           3 :                 flags |= AVP_FLAGS_VENDOR;
      88           3 :                 hdrlen = sizeof(*avp);
      89           3 :                 avp->vendor_id = host_to_be32(vendor_id);
      90             :         } else {
      91           3 :                 hdrlen = sizeof(struct ttls_avp);
      92             :         }
      93             : 
      94           6 :         avp->avp_code = host_to_be32(avp_code);
      95           6 :         avp->avp_length = host_to_be32(((u32) flags << 24) |
      96             :                                        ((u32) (hdrlen + len)));
      97             : 
      98           6 :         return avphdr + hdrlen;
      99             : }
     100             : 
     101             : 
     102           3 : static struct wpabuf * eap_ttls_avp_encapsulate(struct wpabuf *resp,
     103             :                                                 u32 avp_code, int mandatory)
     104             : {
     105             :         struct wpabuf *avp;
     106             :         u8 *pos;
     107             : 
     108           3 :         avp = wpabuf_alloc(sizeof(struct ttls_avp) + wpabuf_len(resp) + 4);
     109           3 :         if (avp == NULL) {
     110           0 :                 wpabuf_free(resp);
     111           0 :                 return NULL;
     112             :         }
     113             : 
     114           3 :         pos = eap_ttls_avp_hdr(wpabuf_mhead(avp), avp_code, 0, mandatory,
     115             :                                wpabuf_len(resp));
     116           3 :         os_memcpy(pos, wpabuf_head(resp), wpabuf_len(resp));
     117           3 :         pos += wpabuf_len(resp);
     118           3 :         AVP_PAD((const u8 *) wpabuf_head(avp), pos);
     119           3 :         wpabuf_free(resp);
     120           3 :         wpabuf_put(avp, pos - (u8 *) wpabuf_head(avp));
     121           3 :         return avp;
     122             : }
     123             : 
     124             : 
     125             : struct eap_ttls_avp {
     126             :          /* Note: eap is allocated memory; caller is responsible for freeing
     127             :           * it. All the other pointers are pointing to the packet data, i.e.,
     128             :           * they must not be freed separately. */
     129             :         u8 *eap;
     130             :         size_t eap_len;
     131             :         u8 *user_name;
     132             :         size_t user_name_len;
     133             :         u8 *user_password;
     134             :         size_t user_password_len;
     135             :         u8 *chap_challenge;
     136             :         size_t chap_challenge_len;
     137             :         u8 *chap_password;
     138             :         size_t chap_password_len;
     139             :         u8 *mschap_challenge;
     140             :         size_t mschap_challenge_len;
     141             :         u8 *mschap_response;
     142             :         size_t mschap_response_len;
     143             :         u8 *mschap2_response;
     144             :         size_t mschap2_response_len;
     145             : };
     146             : 
     147             : 
     148          13 : static int eap_ttls_avp_parse(struct wpabuf *buf, struct eap_ttls_avp *parse)
     149             : {
     150             :         struct ttls_avp *avp;
     151             :         u8 *pos;
     152             :         int left;
     153             : 
     154          13 :         pos = wpabuf_mhead(buf);
     155          13 :         left = wpabuf_len(buf);
     156          13 :         os_memset(parse, 0, sizeof(*parse));
     157             : 
     158          56 :         while (left > 0) {
     159          30 :                 u32 avp_code, avp_length, vendor_id = 0;
     160             :                 u8 avp_flags, *dpos;
     161             :                 size_t pad, dlen;
     162          30 :                 avp = (struct ttls_avp *) pos;
     163          30 :                 avp_code = be_to_host32(avp->avp_code);
     164          30 :                 avp_length = be_to_host32(avp->avp_length);
     165          30 :                 avp_flags = (avp_length >> 24) & 0xff;
     166          30 :                 avp_length &= 0xffffff;
     167          30 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS: AVP: code=%d flags=0x%02x "
     168             :                            "length=%d", (int) avp_code, avp_flags,
     169             :                            (int) avp_length);
     170          30 :                 if ((int) avp_length > left) {
     171           0 :                         wpa_printf(MSG_WARNING, "EAP-TTLS: AVP overflow "
     172             :                                    "(len=%d, left=%d) - dropped",
     173             :                                    (int) avp_length, left);
     174           0 :                         goto fail;
     175             :                 }
     176          30 :                 if (avp_length < sizeof(*avp)) {
     177           0 :                         wpa_printf(MSG_WARNING, "EAP-TTLS: Invalid AVP length "
     178             :                                    "%d", avp_length);
     179           0 :                         goto fail;
     180             :                 }
     181          30 :                 dpos = (u8 *) (avp + 1);
     182          30 :                 dlen = avp_length - sizeof(*avp);
     183          30 :                 if (avp_flags & AVP_FLAGS_VENDOR) {
     184          14 :                         if (dlen < 4) {
     185           0 :                                 wpa_printf(MSG_WARNING, "EAP-TTLS: vendor AVP "
     186             :                                            "underflow");
     187           0 :                                 goto fail;
     188             :                         }
     189          14 :                         vendor_id = be_to_host32(* (be32 *) dpos);
     190          14 :                         wpa_printf(MSG_DEBUG, "EAP-TTLS: AVP vendor_id %d",
     191             :                                    (int) vendor_id);
     192          14 :                         dpos += 4;
     193          14 :                         dlen -= 4;
     194             :                 }
     195             : 
     196          30 :                 wpa_hexdump(MSG_DEBUG, "EAP-TTLS: AVP data", dpos, dlen);
     197             : 
     198          30 :                 if (vendor_id == 0 && avp_code == RADIUS_ATTR_EAP_MESSAGE) {
     199           4 :                         wpa_printf(MSG_DEBUG, "EAP-TTLS: AVP - EAP Message");
     200           8 :                         if (parse->eap == NULL) {
     201           4 :                                 parse->eap = os_malloc(dlen);
     202           4 :                                 if (parse->eap == NULL) {
     203           0 :                                         wpa_printf(MSG_WARNING, "EAP-TTLS: "
     204             :                                                    "failed to allocate memory "
     205             :                                                    "for Phase 2 EAP data");
     206           0 :                                         goto fail;
     207             :                                 }
     208           4 :                                 os_memcpy(parse->eap, dpos, dlen);
     209           4 :                                 parse->eap_len = dlen;
     210             :                         } else {
     211           0 :                                 u8 *neweap = os_realloc(parse->eap,
     212           0 :                                                         parse->eap_len + dlen);
     213           0 :                                 if (neweap == NULL) {
     214           0 :                                         wpa_printf(MSG_WARNING, "EAP-TTLS: "
     215             :                                                    "failed to allocate memory "
     216             :                                                    "for Phase 2 EAP data");
     217           0 :                                         goto fail;
     218             :                                 }
     219           0 :                                 os_memcpy(neweap + parse->eap_len, dpos, dlen);
     220           0 :                                 parse->eap = neweap;
     221           0 :                                 parse->eap_len += dlen;
     222             :                         }
     223          26 :                 } else if (vendor_id == 0 &&
     224             :                            avp_code == RADIUS_ATTR_USER_NAME) {
     225           9 :                         wpa_hexdump_ascii(MSG_DEBUG, "EAP-TTLS: User-Name",
     226             :                                           dpos, dlen);
     227           9 :                         parse->user_name = dpos;
     228           9 :                         parse->user_name_len = dlen;
     229          17 :                 } else if (vendor_id == 0 &&
     230           1 :                            avp_code == RADIUS_ATTR_USER_PASSWORD) {
     231           1 :                         u8 *password = dpos;
     232           1 :                         size_t password_len = dlen;
     233          19 :                         while (password_len > 0 &&
     234           9 :                                password[password_len - 1] == '\0') {
     235           8 :                                 password_len--;
     236             :                         }
     237           1 :                         wpa_hexdump_ascii_key(MSG_DEBUG, "EAP-TTLS: "
     238             :                                               "User-Password (PAP)",
     239             :                                               password, password_len);
     240           1 :                         parse->user_password = password;
     241           1 :                         parse->user_password_len = password_len;
     242          16 :                 } else if (vendor_id == 0 &&
     243             :                            avp_code == RADIUS_ATTR_CHAP_CHALLENGE) {
     244           1 :                         wpa_hexdump(MSG_DEBUG,
     245             :                                     "EAP-TTLS: CHAP-Challenge (CHAP)",
     246             :                                     dpos, dlen);
     247           1 :                         parse->chap_challenge = dpos;
     248           1 :                         parse->chap_challenge_len = dlen;
     249          15 :                 } else if (vendor_id == 0 &&
     250             :                            avp_code == RADIUS_ATTR_CHAP_PASSWORD) {
     251           1 :                         wpa_hexdump(MSG_DEBUG,
     252             :                                     "EAP-TTLS: CHAP-Password (CHAP)",
     253             :                                     dpos, dlen);
     254           1 :                         parse->chap_password = dpos;
     255           1 :                         parse->chap_password_len = dlen;
     256          14 :                 } else if (vendor_id == RADIUS_VENDOR_ID_MICROSOFT &&
     257             :                            avp_code == RADIUS_ATTR_MS_CHAP_CHALLENGE) {
     258           7 :                         wpa_hexdump(MSG_DEBUG,
     259             :                                     "EAP-TTLS: MS-CHAP-Challenge",
     260             :                                     dpos, dlen);
     261           7 :                         parse->mschap_challenge = dpos;
     262           7 :                         parse->mschap_challenge_len = dlen;
     263           7 :                 } else if (vendor_id == RADIUS_VENDOR_ID_MICROSOFT &&
     264             :                            avp_code == RADIUS_ATTR_MS_CHAP_RESPONSE) {
     265           4 :                         wpa_hexdump(MSG_DEBUG,
     266             :                                     "EAP-TTLS: MS-CHAP-Response (MSCHAP)",
     267             :                                     dpos, dlen);
     268           4 :                         parse->mschap_response = dpos;
     269           4 :                         parse->mschap_response_len = dlen;
     270           3 :                 } else if (vendor_id == RADIUS_VENDOR_ID_MICROSOFT &&
     271             :                            avp_code == RADIUS_ATTR_MS_CHAP2_RESPONSE) {
     272           3 :                         wpa_hexdump(MSG_DEBUG,
     273             :                                     "EAP-TTLS: MS-CHAP2-Response (MSCHAPV2)",
     274             :                                     dpos, dlen);
     275           3 :                         parse->mschap2_response = dpos;
     276           3 :                         parse->mschap2_response_len = dlen;
     277           0 :                 } else if (avp_flags & AVP_FLAGS_MANDATORY) {
     278           0 :                         wpa_printf(MSG_WARNING, "EAP-TTLS: Unsupported "
     279             :                                    "mandatory AVP code %d vendor_id %d - "
     280             :                                    "dropped", (int) avp_code, (int) vendor_id);
     281           0 :                         goto fail;
     282             :                 } else {
     283           0 :                         wpa_printf(MSG_DEBUG, "EAP-TTLS: Ignoring unsupported "
     284             :                                    "AVP code %d vendor_id %d",
     285             :                                    (int) avp_code, (int) vendor_id);
     286             :                 }
     287             : 
     288          30 :                 pad = (4 - (avp_length & 3)) & 3;
     289          30 :                 pos += avp_length + pad;
     290          30 :                 left -= avp_length + pad;
     291             :         }
     292             : 
     293          13 :         return 0;
     294             : 
     295             : fail:
     296           0 :         os_free(parse->eap);
     297           0 :         parse->eap = NULL;
     298           0 :         return -1;
     299             : }
     300             : 
     301             : 
     302           8 : static u8 * eap_ttls_implicit_challenge(struct eap_sm *sm,
     303             :                                         struct eap_ttls_data *data, size_t len)
     304             : {
     305           8 :         return eap_server_tls_derive_key(sm, &data->ssl, "ttls challenge",
     306             :                                          len);
     307             : }
     308             : 
     309             : 
     310          22 : static void * eap_ttls_init(struct eap_sm *sm)
     311             : {
     312             :         struct eap_ttls_data *data;
     313             : 
     314          22 :         data = os_zalloc(sizeof(*data));
     315          22 :         if (data == NULL)
     316           0 :                 return NULL;
     317          22 :         data->ttls_version = EAP_TTLS_VERSION;
     318          22 :         data->state = START;
     319             : 
     320          22 :         if (eap_server_tls_ssl_init(sm, &data->ssl, 0)) {
     321           0 :                 wpa_printf(MSG_INFO, "EAP-TTLS: Failed to initialize SSL.");
     322           0 :                 eap_ttls_reset(sm, data);
     323           0 :                 return NULL;
     324             :         }
     325             : 
     326          22 :         return data;
     327             : }
     328             : 
     329             : 
     330          22 : static void eap_ttls_reset(struct eap_sm *sm, void *priv)
     331             : {
     332          22 :         struct eap_ttls_data *data = priv;
     333          22 :         if (data == NULL)
     334          22 :                 return;
     335          22 :         if (data->phase2_priv && data->phase2_method)
     336           2 :                 data->phase2_method->reset(sm, data->phase2_priv);
     337          22 :         eap_server_tls_ssl_deinit(sm, &data->ssl);
     338          22 :         wpabuf_free(data->pending_phase2_eap_resp);
     339          22 :         os_free(data);
     340             : }
     341             : 
     342             : 
     343          22 : static struct wpabuf * eap_ttls_build_start(struct eap_sm *sm,
     344             :                                             struct eap_ttls_data *data, u8 id)
     345             : {       
     346             :         struct wpabuf *req;
     347             : 
     348          22 :         req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_TTLS, 1,
     349             :                             EAP_CODE_REQUEST, id);
     350          22 :         if (req == NULL) {
     351           0 :                 wpa_printf(MSG_ERROR, "EAP-TTLS: Failed to allocate memory for"
     352             :                            " request");
     353           0 :                 eap_ttls_state(data, FAILURE);
     354           0 :                 return NULL;
     355             :         }
     356             : 
     357          22 :         wpabuf_put_u8(req, EAP_TLS_FLAGS_START | data->ttls_version);
     358             : 
     359          22 :         eap_ttls_state(data, PHASE1);
     360             : 
     361          22 :         return req;
     362             : }
     363             : 
     364             : 
     365           3 : static struct wpabuf * eap_ttls_build_phase2_eap_req(
     366             :         struct eap_sm *sm, struct eap_ttls_data *data, u8 id)
     367             : {
     368             :         struct wpabuf *buf, *encr_req;
     369             : 
     370             : 
     371           3 :         buf = data->phase2_method->buildReq(sm, data->phase2_priv, id);
     372           3 :         if (buf == NULL)
     373           0 :                 return NULL;
     374             : 
     375           3 :         wpa_hexdump_buf_key(MSG_DEBUG,
     376             :                             "EAP-TTLS/EAP: Encapsulate Phase 2 data", buf);
     377             : 
     378           3 :         buf = eap_ttls_avp_encapsulate(buf, RADIUS_ATTR_EAP_MESSAGE, 1);
     379           3 :         if (buf == NULL) {
     380           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: Failed to encapsulate "
     381             :                            "packet");
     382           0 :                 return NULL;
     383             :         }
     384             : 
     385           3 :         wpa_hexdump_buf_key(MSG_DEBUG, "EAP-TTLS/EAP: Encrypt encapsulated "
     386             :                             "Phase 2 data", buf);
     387             : 
     388           3 :         encr_req = eap_server_tls_encrypt(sm, &data->ssl, buf);
     389           3 :         wpabuf_free(buf);
     390             : 
     391           3 :         return encr_req;
     392             : }
     393             : 
     394             : 
     395           3 : static struct wpabuf * eap_ttls_build_phase2_mschapv2(
     396             :         struct eap_sm *sm, struct eap_ttls_data *data)
     397             : {
     398             :         struct wpabuf *encr_req, msgbuf;
     399             :         u8 *req, *pos, *end;
     400             :         int ret;
     401             : 
     402           3 :         pos = req = os_malloc(100);
     403           3 :         if (req == NULL)
     404           0 :                 return NULL;
     405           3 :         end = req + 100;
     406             : 
     407           3 :         if (data->mschapv2_resp_ok) {
     408           3 :                 pos = eap_ttls_avp_hdr(pos, RADIUS_ATTR_MS_CHAP2_SUCCESS,
     409             :                                        RADIUS_VENDOR_ID_MICROSOFT, 1, 43);
     410           3 :                 *pos++ = data->mschapv2_ident;
     411           3 :                 ret = os_snprintf((char *) pos, end - pos, "S=");
     412           3 :                 if (ret >= 0 && ret < end - pos)
     413           3 :                         pos += ret;
     414           3 :                 pos += wpa_snprintf_hex_uppercase(
     415           3 :                         (char *) pos, end - pos, data->mschapv2_auth_response,
     416             :                         sizeof(data->mschapv2_auth_response));
     417             :         } else {
     418           0 :                 pos = eap_ttls_avp_hdr(pos, RADIUS_ATTR_MS_CHAP_ERROR,
     419             :                                        RADIUS_VENDOR_ID_MICROSOFT, 1, 6);
     420           0 :                 os_memcpy(pos, "Failed", 6);
     421           0 :                 pos += 6;
     422           0 :                 AVP_PAD(req, pos);
     423             :         }
     424             : 
     425           3 :         wpabuf_set(&msgbuf, req, pos - req);
     426           3 :         wpa_hexdump_buf_key(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Encrypting Phase 2 "
     427             :                             "data", &msgbuf);
     428             : 
     429           3 :         encr_req = eap_server_tls_encrypt(sm, &data->ssl, &msgbuf);
     430           3 :         os_free(req);
     431             : 
     432           3 :         return encr_req;
     433             : }
     434             : 
     435             : 
     436          53 : static struct wpabuf * eap_ttls_buildReq(struct eap_sm *sm, void *priv, u8 id)
     437             : {
     438          53 :         struct eap_ttls_data *data = priv;
     439             : 
     440          53 :         if (data->ssl.state == FRAG_ACK) {
     441           0 :                 return eap_server_tls_build_ack(id, EAP_TYPE_TTLS,
     442             :                                                 data->ttls_version);
     443             :         }
     444             : 
     445          53 :         if (data->ssl.state == WAIT_FRAG_ACK) {
     446           1 :                 return eap_server_tls_build_msg(&data->ssl, EAP_TYPE_TTLS,
     447             :                                                 data->ttls_version, id);
     448             :         }
     449             : 
     450          52 :         switch (data->state) {
     451             :         case START:
     452          22 :                 return eap_ttls_build_start(sm, data, id);
     453             :         case PHASE1:
     454          24 :                 if (tls_connection_established(sm->ssl_ctx, data->ssl.conn)) {
     455          11 :                         wpa_printf(MSG_DEBUG, "EAP-TTLS: Phase1 done, "
     456             :                                    "starting Phase2");
     457          11 :                         eap_ttls_state(data, PHASE2_START);
     458             :                 }
     459          24 :                 break;
     460             :         case PHASE2_METHOD:
     461           3 :                 wpabuf_free(data->ssl.tls_out);
     462           3 :                 data->ssl.tls_out_pos = 0;
     463           3 :                 data->ssl.tls_out = eap_ttls_build_phase2_eap_req(sm, data,
     464             :                                                                   id);
     465           3 :                 break;
     466             :         case PHASE2_MSCHAPV2_RESP:
     467           3 :                 wpabuf_free(data->ssl.tls_out);
     468           3 :                 data->ssl.tls_out_pos = 0;
     469           3 :                 data->ssl.tls_out = eap_ttls_build_phase2_mschapv2(sm, data);
     470           3 :                 break;
     471             :         default:
     472           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS: %s - unexpected state %d",
     473           0 :                            __func__, data->state);
     474           0 :                 return NULL;
     475             :         }
     476             : 
     477          30 :         return eap_server_tls_build_msg(&data->ssl, EAP_TYPE_TTLS,
     478             :                                         data->ttls_version, id);
     479             : }
     480             : 
     481             : 
     482          43 : static Boolean eap_ttls_check(struct eap_sm *sm, void *priv,
     483             :                               struct wpabuf *respData)
     484             : {
     485             :         const u8 *pos;
     486             :         size_t len;
     487             : 
     488          43 :         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_TTLS, respData, &len);
     489          43 :         if (pos == NULL || len < 1) {
     490           0 :                 wpa_printf(MSG_INFO, "EAP-TTLS: Invalid frame");
     491           0 :                 return TRUE;
     492             :         }
     493             : 
     494          43 :         return FALSE;
     495             : }
     496             : 
     497             : 
     498           1 : static void eap_ttls_process_phase2_pap(struct eap_sm *sm,
     499             :                                         struct eap_ttls_data *data,
     500             :                                         const u8 *user_password,
     501             :                                         size_t user_password_len)
     502             : {
     503           2 :         if (!sm->user || !sm->user->password || sm->user->password_hash ||
     504           1 :             !(sm->user->ttls_auth & EAP_TTLS_AUTH_PAP)) {
     505           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/PAP: No plaintext user "
     506             :                            "password configured");
     507           0 :                 eap_ttls_state(data, FAILURE);
     508           0 :                 return;
     509             :         }
     510             : 
     511           2 :         if (sm->user->password_len != user_password_len ||
     512           1 :             os_memcmp(sm->user->password, user_password, user_password_len) !=
     513             :             0) {
     514           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/PAP: Invalid user password");
     515           0 :                 eap_ttls_state(data, FAILURE);
     516           0 :                 return;
     517             :         }
     518             : 
     519           1 :         wpa_printf(MSG_DEBUG, "EAP-TTLS/PAP: Correct user password");
     520           1 :         eap_ttls_state(data, SUCCESS);
     521             : }
     522             : 
     523             : 
     524           1 : static void eap_ttls_process_phase2_chap(struct eap_sm *sm,
     525             :                                          struct eap_ttls_data *data,
     526             :                                          const u8 *challenge,
     527             :                                          size_t challenge_len,
     528             :                                          const u8 *password,
     529             :                                          size_t password_len)
     530             : {
     531             :         u8 *chal, hash[CHAP_MD5_LEN];
     532             : 
     533           1 :         if (challenge == NULL || password == NULL ||
     534           1 :             challenge_len != EAP_TTLS_CHAP_CHALLENGE_LEN ||
     535             :             password_len != 1 + EAP_TTLS_CHAP_PASSWORD_LEN) {
     536           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/CHAP: Invalid CHAP attributes "
     537             :                            "(challenge len %lu password len %lu)",
     538             :                            (unsigned long) challenge_len,
     539             :                            (unsigned long) password_len);
     540           0 :                 eap_ttls_state(data, FAILURE);
     541           0 :                 return;
     542             :         }
     543             : 
     544           2 :         if (!sm->user || !sm->user->password || sm->user->password_hash ||
     545           1 :             !(sm->user->ttls_auth & EAP_TTLS_AUTH_CHAP)) {
     546           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/CHAP: No plaintext user "
     547             :                            "password configured");
     548           0 :                 eap_ttls_state(data, FAILURE);
     549           0 :                 return;
     550             :         }
     551             : 
     552           1 :         chal = eap_ttls_implicit_challenge(sm, data,
     553             :                                            EAP_TTLS_CHAP_CHALLENGE_LEN + 1);
     554           1 :         if (chal == NULL) {
     555           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/CHAP: Failed to generate "
     556             :                            "challenge from TLS data");
     557           0 :                 eap_ttls_state(data, FAILURE);
     558           0 :                 return;
     559             :         }
     560             : 
     561           2 :         if (os_memcmp(challenge, chal, EAP_TTLS_CHAP_CHALLENGE_LEN) != 0 ||
     562           1 :             password[0] != chal[EAP_TTLS_CHAP_CHALLENGE_LEN]) {
     563           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/CHAP: Challenge mismatch");
     564           0 :                 os_free(chal);
     565           0 :                 eap_ttls_state(data, FAILURE);
     566           0 :                 return;
     567             :         }
     568           1 :         os_free(chal);
     569             : 
     570             :         /* MD5(Ident + Password + Challenge) */
     571           1 :         chap_md5(password[0], sm->user->password, sm->user->password_len,
     572             :                  challenge, challenge_len, hash);
     573             : 
     574           1 :         if (os_memcmp(hash, password + 1, EAP_TTLS_CHAP_PASSWORD_LEN) == 0) {
     575           1 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/CHAP: Correct user password");
     576           1 :                 eap_ttls_state(data, SUCCESS);
     577             :         } else {
     578           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/CHAP: Invalid user password");
     579           0 :                 eap_ttls_state(data, FAILURE);
     580             :         }
     581             : }
     582             : 
     583             : 
     584           4 : static void eap_ttls_process_phase2_mschap(struct eap_sm *sm,
     585             :                                            struct eap_ttls_data *data,
     586             :                                            u8 *challenge, size_t challenge_len,
     587             :                                            u8 *response, size_t response_len)
     588             : {
     589             :         u8 *chal, nt_response[24];
     590             : 
     591           4 :         if (challenge == NULL || response == NULL ||
     592           4 :             challenge_len != EAP_TTLS_MSCHAP_CHALLENGE_LEN ||
     593             :             response_len != EAP_TTLS_MSCHAP_RESPONSE_LEN) {
     594           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAP: Invalid MS-CHAP "
     595             :                            "attributes (challenge len %lu response len %lu)",
     596             :                            (unsigned long) challenge_len,
     597             :                            (unsigned long) response_len);
     598           0 :                 eap_ttls_state(data, FAILURE);
     599           0 :                 return;
     600             :         }
     601             : 
     602           8 :         if (!sm->user || !sm->user->password ||
     603           4 :             !(sm->user->ttls_auth & EAP_TTLS_AUTH_MSCHAP)) {
     604           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAP: No user password "
     605             :                            "configured");
     606           0 :                 eap_ttls_state(data, FAILURE);
     607           0 :                 return;
     608             :         }
     609             : 
     610           4 :         chal = eap_ttls_implicit_challenge(sm, data,
     611             :                                            EAP_TTLS_MSCHAP_CHALLENGE_LEN + 1);
     612           4 :         if (chal == NULL) {
     613           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAP: Failed to generate "
     614             :                            "challenge from TLS data");
     615           0 :                 eap_ttls_state(data, FAILURE);
     616           0 :                 return;
     617             :         }
     618             : 
     619           8 :         if (os_memcmp(challenge, chal, EAP_TTLS_MSCHAP_CHALLENGE_LEN) != 0 ||
     620           4 :             response[0] != chal[EAP_TTLS_MSCHAP_CHALLENGE_LEN]) {
     621           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAP: Challenge mismatch");
     622           0 :                 os_free(chal);
     623           0 :                 eap_ttls_state(data, FAILURE);
     624           0 :                 return;
     625             :         }
     626           4 :         os_free(chal);
     627             : 
     628           4 :         if (sm->user->password_hash)
     629           0 :                 challenge_response(challenge, sm->user->password, nt_response);
     630             :         else
     631           4 :                 nt_challenge_response(challenge, sm->user->password,
     632           4 :                                       sm->user->password_len, nt_response);
     633             : 
     634           4 :         if (os_memcmp(nt_response, response + 2 + 24, 24) == 0) {
     635           4 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAP: Correct response");
     636           4 :                 eap_ttls_state(data, SUCCESS);
     637             :         } else {
     638           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAP: Invalid NT-Response");
     639           0 :                 wpa_hexdump(MSG_MSGDUMP, "EAP-TTLS/MSCHAP: Received",
     640             :                             response + 2 + 24, 24);
     641           0 :                 wpa_hexdump(MSG_MSGDUMP, "EAP-TTLS/MSCHAP: Expected",
     642             :                             nt_response, 24);
     643           0 :                 eap_ttls_state(data, FAILURE);
     644             :         }
     645             : }
     646             : 
     647             : 
     648           3 : static void eap_ttls_process_phase2_mschapv2(struct eap_sm *sm,
     649             :                                              struct eap_ttls_data *data,
     650             :                                              u8 *challenge,
     651             :                                              size_t challenge_len,
     652             :                                              u8 *response, size_t response_len)
     653             : {
     654             :         u8 *chal, *username, nt_response[24], *rx_resp, *peer_challenge,
     655             :                 *auth_challenge;
     656             :         size_t username_len, i;
     657             : 
     658           3 :         if (challenge == NULL || response == NULL ||
     659           3 :             challenge_len != EAP_TTLS_MSCHAPV2_CHALLENGE_LEN ||
     660             :             response_len != EAP_TTLS_MSCHAPV2_RESPONSE_LEN) {
     661           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Invalid MS-CHAP2 "
     662             :                            "attributes (challenge len %lu response len %lu)",
     663             :                            (unsigned long) challenge_len,
     664             :                            (unsigned long) response_len);
     665           0 :                 eap_ttls_state(data, FAILURE);
     666           0 :                 return;
     667             :         }
     668             : 
     669           6 :         if (!sm->user || !sm->user->password ||
     670           3 :             !(sm->user->ttls_auth & EAP_TTLS_AUTH_MSCHAPV2)) {
     671           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: No user password "
     672             :                            "configured");
     673           0 :                 eap_ttls_state(data, FAILURE);
     674           0 :                 return;
     675             :         }
     676             : 
     677           3 :         if (sm->identity == NULL) {
     678           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: No user identity "
     679             :                            "known");
     680           0 :                 eap_ttls_state(data, FAILURE);
     681           0 :                 return;
     682             :         }
     683             : 
     684             :         /* MSCHAPv2 does not include optional domain name in the
     685             :          * challenge-response calculation, so remove domain prefix
     686             :          * (if present). */
     687           3 :         username = sm->identity;
     688           3 :         username_len = sm->identity_len;
     689          35 :         for (i = 0; i < username_len; i++) {
     690          33 :                 if (username[i] == '\\') {
     691           1 :                         username_len -= i + 1;
     692           1 :                         username += i + 1;
     693           1 :                         break;
     694             :                 }
     695             :         }
     696             : 
     697           3 :         chal = eap_ttls_implicit_challenge(
     698             :                 sm, data, EAP_TTLS_MSCHAPV2_CHALLENGE_LEN + 1);
     699           3 :         if (chal == NULL) {
     700           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Failed to generate "
     701             :                            "challenge from TLS data");
     702           0 :                 eap_ttls_state(data, FAILURE);
     703           0 :                 return;
     704             :         }
     705             : 
     706           6 :         if (os_memcmp(challenge, chal, EAP_TTLS_MSCHAPV2_CHALLENGE_LEN) != 0 ||
     707           3 :             response[0] != chal[EAP_TTLS_MSCHAPV2_CHALLENGE_LEN]) {
     708           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Challenge mismatch");
     709           0 :                 os_free(chal);
     710           0 :                 eap_ttls_state(data, FAILURE);
     711           0 :                 return;
     712             :         }
     713           3 :         os_free(chal);
     714             : 
     715           3 :         auth_challenge = challenge;
     716           3 :         peer_challenge = response + 2;
     717             : 
     718           3 :         wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-TTLS/MSCHAPV2: User",
     719             :                           username, username_len);
     720           3 :         wpa_hexdump(MSG_MSGDUMP, "EAP-TTLS/MSCHAPV2: auth_challenge",
     721             :                     auth_challenge, EAP_TTLS_MSCHAPV2_CHALLENGE_LEN);
     722           3 :         wpa_hexdump(MSG_MSGDUMP, "EAP-TTLS/MSCHAPV2: peer_challenge",
     723             :                     peer_challenge, EAP_TTLS_MSCHAPV2_CHALLENGE_LEN);
     724             : 
     725           3 :         if (sm->user->password_hash) {
     726           1 :                 generate_nt_response_pwhash(auth_challenge, peer_challenge,
     727             :                                             username, username_len,
     728           1 :                                             sm->user->password,
     729             :                                             nt_response);
     730             :         } else {
     731           4 :                 generate_nt_response(auth_challenge, peer_challenge,
     732             :                                      username, username_len,
     733           2 :                                      sm->user->password,
     734           2 :                                      sm->user->password_len,
     735             :                                      nt_response);
     736             :         }
     737             : 
     738           3 :         rx_resp = response + 2 + EAP_TTLS_MSCHAPV2_CHALLENGE_LEN + 8;
     739           3 :         if (os_memcmp(nt_response, rx_resp, 24) == 0) {
     740           3 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Correct "
     741             :                            "NT-Response");
     742           3 :                 data->mschapv2_resp_ok = 1;
     743             : 
     744           3 :                 if (sm->user->password_hash) {
     745           1 :                         generate_authenticator_response_pwhash(
     746           1 :                                 sm->user->password,
     747             :                                 peer_challenge, auth_challenge,
     748             :                                 username, username_len, nt_response,
     749           1 :                                 data->mschapv2_auth_response);
     750             :                 } else {
     751           4 :                         generate_authenticator_response(
     752           4 :                                 sm->user->password, sm->user->password_len,
     753             :                                 peer_challenge, auth_challenge,
     754             :                                 username, username_len, nt_response,
     755           2 :                                 data->mschapv2_auth_response);
     756             :                 }
     757             :         } else {
     758           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Invalid "
     759             :                            "NT-Response");
     760           0 :                 wpa_hexdump(MSG_MSGDUMP, "EAP-TTLS/MSCHAPV2: Received",
     761             :                             rx_resp, 24);
     762           0 :                 wpa_hexdump(MSG_MSGDUMP, "EAP-TTLS/MSCHAPV2: Expected",
     763             :                             nt_response, 24);
     764           0 :                 data->mschapv2_resp_ok = 0;
     765             :         }
     766           3 :         eap_ttls_state(data, PHASE2_MSCHAPV2_RESP);
     767           3 :         data->mschapv2_ident = response[0];
     768             : }
     769             : 
     770             : 
     771           2 : static int eap_ttls_phase2_eap_init(struct eap_sm *sm,
     772             :                                     struct eap_ttls_data *data,
     773             :                                     EapType eap_type)
     774             : {
     775           2 :         if (data->phase2_priv && data->phase2_method) {
     776           0 :                 data->phase2_method->reset(sm, data->phase2_priv);
     777           0 :                 data->phase2_method = NULL;
     778           0 :                 data->phase2_priv = NULL;
     779             :         }
     780           2 :         data->phase2_method = eap_server_get_eap_method(EAP_VENDOR_IETF,
     781             :                                                         eap_type);
     782           2 :         if (!data->phase2_method)
     783           0 :                 return -1;
     784             : 
     785           2 :         sm->init_phase2 = 1;
     786           2 :         data->phase2_priv = data->phase2_method->init(sm);
     787           2 :         sm->init_phase2 = 0;
     788           2 :         return data->phase2_priv == NULL ? -1 : 0;
     789             : }
     790             : 
     791             : 
     792           4 : static void eap_ttls_process_phase2_eap_response(struct eap_sm *sm,
     793             :                                                  struct eap_ttls_data *data,
     794             :                                                  u8 *in_data, size_t in_len)
     795             : {
     796           4 :         u8 next_type = EAP_TYPE_NONE;
     797             :         struct eap_hdr *hdr;
     798             :         u8 *pos;
     799             :         size_t left;
     800             :         struct wpabuf buf;
     801           4 :         const struct eap_method *m = data->phase2_method;
     802           4 :         void *priv = data->phase2_priv;
     803             : 
     804           4 :         if (priv == NULL) {
     805           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: %s - Phase2 not "
     806             :                            "initialized?!", __func__);
     807           0 :                 return;
     808             :         }
     809             : 
     810           4 :         hdr = (struct eap_hdr *) in_data;
     811           4 :         pos = (u8 *) (hdr + 1);
     812             : 
     813           4 :         if (in_len > sizeof(*hdr) && *pos == EAP_TYPE_NAK) {
     814           0 :                 left = in_len - sizeof(*hdr);
     815           0 :                 wpa_hexdump(MSG_DEBUG, "EAP-TTLS/EAP: Phase2 type Nak'ed; "
     816             :                             "allowed types", pos + 1, left - 1);
     817           0 :                 eap_sm_process_nak(sm, pos + 1, left - 1);
     818           0 :                 if (sm->user && sm->user_eap_method_index < EAP_MAX_METHODS &&
     819           0 :                     sm->user->methods[sm->user_eap_method_index].method !=
     820             :                     EAP_TYPE_NONE) {
     821           0 :                         next_type = sm->user->methods[
     822           0 :                                 sm->user_eap_method_index++].method;
     823           0 :                         wpa_printf(MSG_DEBUG, "EAP-TTLS: try EAP type %d",
     824             :                                    next_type);
     825           0 :                         if (eap_ttls_phase2_eap_init(sm, data, next_type)) {
     826           0 :                                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Failed to "
     827             :                                            "initialize EAP type %d",
     828             :                                            next_type);
     829           0 :                                 eap_ttls_state(data, FAILURE);
     830           0 :                                 return;
     831             :                         }
     832             :                 } else {
     833           0 :                         eap_ttls_state(data, FAILURE);
     834             :                 }
     835           0 :                 return;
     836             :         }
     837             : 
     838           4 :         wpabuf_set(&buf, in_data, in_len);
     839             : 
     840           4 :         if (m->check(sm, priv, &buf)) {
     841           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: Phase2 check() asked to "
     842             :                            "ignore the packet");
     843           0 :                 return;
     844             :         }
     845             : 
     846           4 :         m->process(sm, priv, &buf);
     847             : 
     848           4 :         if (sm->method_pending == METHOD_PENDING_WAIT) {
     849           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: Phase2 method is in "
     850             :                            "pending wait state - save decrypted response");
     851           0 :                 wpabuf_free(data->pending_phase2_eap_resp);
     852           0 :                 data->pending_phase2_eap_resp = wpabuf_dup(&buf);
     853             :         }
     854             : 
     855           4 :         if (!m->isDone(sm, priv))
     856           2 :                 return;
     857             : 
     858           2 :         if (!m->isSuccess(sm, priv)) {
     859           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: Phase2 method failed");
     860           0 :                 eap_ttls_state(data, FAILURE);
     861           0 :                 return;
     862             :         }
     863             : 
     864           2 :         switch (data->state) {
     865             :         case PHASE2_START:
     866           1 :                 if (eap_user_get(sm, sm->identity, sm->identity_len, 1) != 0) {
     867           2 :                         wpa_hexdump_ascii(MSG_DEBUG, "EAP_TTLS: Phase2 "
     868             :                                           "Identity not found in the user "
     869             :                                           "database",
     870           1 :                                           sm->identity, sm->identity_len);
     871           1 :                         eap_ttls_state(data, FAILURE);
     872           1 :                         break;
     873             :                 }
     874             : 
     875           0 :                 eap_ttls_state(data, PHASE2_METHOD);
     876           0 :                 next_type = sm->user->methods[0].method;
     877           0 :                 sm->user_eap_method_index = 1;
     878           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS: try EAP type %d", next_type);
     879           0 :                 if (eap_ttls_phase2_eap_init(sm, data, next_type)) {
     880           0 :                         wpa_printf(MSG_DEBUG, "EAP-TTLS: Failed to initialize "
     881             :                                    "EAP type %d", next_type);
     882           0 :                         eap_ttls_state(data, FAILURE);
     883             :                 }
     884           0 :                 break;
     885             :         case PHASE2_METHOD:
     886           1 :                 eap_ttls_state(data, SUCCESS);
     887           1 :                 break;
     888             :         case FAILURE:
     889           0 :                 break;
     890             :         default:
     891           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS: %s - unexpected state %d",
     892           0 :                            __func__, data->state);
     893           0 :                 break;
     894             :         }
     895             : }
     896             : 
     897             : 
     898           4 : static void eap_ttls_process_phase2_eap(struct eap_sm *sm,
     899             :                                         struct eap_ttls_data *data,
     900             :                                         const u8 *eap, size_t eap_len)
     901             : {
     902             :         struct eap_hdr *hdr;
     903             :         size_t len;
     904             : 
     905           4 :         if (data->state == PHASE2_START) {
     906           1 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: initializing Phase 2");
     907           1 :                 if (eap_ttls_phase2_eap_init(sm, data, EAP_TYPE_IDENTITY) < 0)
     908             :                 {
     909           0 :                         wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: failed to "
     910             :                                    "initialize EAP-Identity");
     911           0 :                         return;
     912             :                 }
     913             :         }
     914             : 
     915           4 :         if (eap_len < sizeof(*hdr)) {
     916           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: too short Phase 2 EAP "
     917             :                            "packet (len=%lu)", (unsigned long) eap_len);
     918           0 :                 return;
     919             :         }
     920             : 
     921           4 :         hdr = (struct eap_hdr *) eap;
     922           4 :         len = be_to_host16(hdr->length);
     923           8 :         wpa_printf(MSG_DEBUG, "EAP-TTLS/EAP: received Phase 2 EAP: code=%d "
     924           8 :                    "identifier=%d length=%lu", hdr->code, hdr->identifier,
     925             :                    (unsigned long) len);
     926           4 :         if (len > eap_len) {
     927           0 :                 wpa_printf(MSG_INFO, "EAP-TTLS/EAP: Length mismatch in Phase 2"
     928             :                            " EAP frame (hdr len=%lu, data len in AVP=%lu)",
     929             :                            (unsigned long) len, (unsigned long) eap_len);
     930           0 :                 return;
     931             :         }
     932             : 
     933           4 :         switch (hdr->code) {
     934             :         case EAP_CODE_RESPONSE:
     935           4 :                 eap_ttls_process_phase2_eap_response(sm, data, (u8 *) hdr,
     936             :                                                      len);
     937           4 :                 break;
     938             :         default:
     939           0 :                 wpa_printf(MSG_INFO, "EAP-TTLS/EAP: Unexpected code=%d in "
     940           0 :                            "Phase 2 EAP header", hdr->code);
     941           0 :                 break;
     942             :         }
     943             : }
     944             : 
     945             : 
     946          13 : static void eap_ttls_process_phase2(struct eap_sm *sm,
     947             :                                     struct eap_ttls_data *data,
     948             :                                     struct wpabuf *in_buf)
     949             : {
     950             :         struct wpabuf *in_decrypted;
     951             :         struct eap_ttls_avp parse;
     952             : 
     953          13 :         wpa_printf(MSG_DEBUG, "EAP-TTLS: received %lu bytes encrypted data for"
     954             :                    " Phase 2", (unsigned long) wpabuf_len(in_buf));
     955             : 
     956          13 :         if (data->pending_phase2_eap_resp) {
     957           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Pending Phase 2 EAP response "
     958             :                            "- skip decryption and use old data");
     959           0 :                 eap_ttls_process_phase2_eap(
     960           0 :                         sm, data, wpabuf_head(data->pending_phase2_eap_resp),
     961           0 :                         wpabuf_len(data->pending_phase2_eap_resp));
     962           0 :                 wpabuf_free(data->pending_phase2_eap_resp);
     963           0 :                 data->pending_phase2_eap_resp = NULL;
     964           0 :                 return;
     965             :         }
     966             : 
     967          13 :         in_decrypted = tls_connection_decrypt(sm->ssl_ctx, data->ssl.conn,
     968             :                                               in_buf);
     969          13 :         if (in_decrypted == NULL) {
     970           0 :                 wpa_printf(MSG_INFO, "EAP-TTLS: Failed to decrypt Phase 2 "
     971             :                            "data");
     972           0 :                 eap_ttls_state(data, FAILURE);
     973           0 :                 return;
     974             :         }
     975             : 
     976          13 :         wpa_hexdump_buf_key(MSG_DEBUG, "EAP-TTLS: Decrypted Phase 2 EAP",
     977             :                             in_decrypted);
     978             : 
     979          13 :         if (eap_ttls_avp_parse(in_decrypted, &parse) < 0) {
     980           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Failed to parse AVPs");
     981           0 :                 wpabuf_free(in_decrypted);
     982           0 :                 eap_ttls_state(data, FAILURE);
     983           0 :                 return;
     984             :         }
     985             : 
     986          13 :         if (parse.user_name) {
     987             :                 char *nbuf;
     988           9 :                 nbuf = os_malloc(parse.user_name_len * 4 + 1);
     989           9 :                 if (nbuf) {
     990          18 :                         printf_encode(nbuf, parse.user_name_len * 4 + 1,
     991           9 :                                       parse.user_name,
     992             :                                       parse.user_name_len);
     993           9 :                         eap_log_msg(sm, "TTLS-User-Name '%s'", nbuf);
     994           9 :                         os_free(nbuf);
     995             :                 }
     996             : 
     997           9 :                 os_free(sm->identity);
     998           9 :                 sm->identity = os_malloc(parse.user_name_len);
     999           9 :                 if (sm->identity == NULL) {
    1000           0 :                         eap_ttls_state(data, FAILURE);
    1001           0 :                         goto done;
    1002             :                 }
    1003           9 :                 os_memcpy(sm->identity, parse.user_name, parse.user_name_len);
    1004           9 :                 sm->identity_len = parse.user_name_len;
    1005           9 :                 if (eap_user_get(sm, parse.user_name, parse.user_name_len, 1)
    1006             :                     != 0) {
    1007           0 :                         wpa_printf(MSG_DEBUG, "EAP-TTLS: Phase2 Identity not "
    1008             :                                    "found in the user database");
    1009           0 :                         eap_ttls_state(data, FAILURE);
    1010           0 :                         goto done;
    1011             :                 }
    1012             :         }
    1013             : 
    1014             : #ifdef EAP_SERVER_TNC
    1015          13 :         if (data->tnc_started && parse.eap == NULL) {
    1016           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS: TNC started but no EAP "
    1017             :                            "response from peer");
    1018           0 :                 eap_ttls_state(data, FAILURE);
    1019           0 :                 goto done;
    1020             :         }
    1021             : #endif /* EAP_SERVER_TNC */
    1022             : 
    1023          13 :         if (parse.eap) {
    1024           4 :                 eap_ttls_process_phase2_eap(sm, data, parse.eap,
    1025             :                                             parse.eap_len);
    1026           9 :         } else if (parse.user_password) {
    1027           1 :                 eap_ttls_process_phase2_pap(sm, data, parse.user_password,
    1028             :                                             parse.user_password_len);
    1029           8 :         } else if (parse.chap_password) {
    1030           3 :                 eap_ttls_process_phase2_chap(sm, data,
    1031           1 :                                              parse.chap_challenge,
    1032             :                                              parse.chap_challenge_len,
    1033           1 :                                              parse.chap_password,
    1034             :                                              parse.chap_password_len);
    1035           7 :         } else if (parse.mschap_response) {
    1036           4 :                 eap_ttls_process_phase2_mschap(sm, data,
    1037             :                                                parse.mschap_challenge,
    1038             :                                                parse.mschap_challenge_len,
    1039             :                                                parse.mschap_response,
    1040             :                                                parse.mschap_response_len);
    1041           3 :         } else if (parse.mschap2_response) {
    1042           3 :                 eap_ttls_process_phase2_mschapv2(sm, data,
    1043             :                                                  parse.mschap_challenge,
    1044             :                                                  parse.mschap_challenge_len,
    1045             :                                                  parse.mschap2_response,
    1046             :                                                  parse.mschap2_response_len);
    1047             :         }
    1048             : 
    1049             : done:
    1050          13 :         wpabuf_free(in_decrypted);
    1051          13 :         os_free(parse.eap);
    1052             : }
    1053             : 
    1054             : 
    1055          16 : static void eap_ttls_start_tnc(struct eap_sm *sm, struct eap_ttls_data *data)
    1056             : {
    1057             : #ifdef EAP_SERVER_TNC
    1058          16 :         if (!sm->tnc || data->state != SUCCESS || data->tnc_started)
    1059          15 :                 return;
    1060             : 
    1061           1 :         wpa_printf(MSG_DEBUG, "EAP-TTLS: Initialize TNC");
    1062           1 :         if (eap_ttls_phase2_eap_init(sm, data, EAP_TYPE_TNC)) {
    1063           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Failed to initialize TNC");
    1064           0 :                 eap_ttls_state(data, FAILURE);
    1065           0 :                 return;
    1066             :         }
    1067             : 
    1068           1 :         data->tnc_started = 1;
    1069           1 :         eap_ttls_state(data, PHASE2_METHOD);
    1070             : #endif /* EAP_SERVER_TNC */
    1071             : }
    1072             : 
    1073             : 
    1074          43 : static int eap_ttls_process_version(struct eap_sm *sm, void *priv,
    1075             :                                     int peer_version)
    1076             : {
    1077          43 :         struct eap_ttls_data *data = priv;
    1078          43 :         if (peer_version < data->ttls_version) {
    1079           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS: peer ver=%d, own ver=%d; "
    1080             :                            "use version %d",
    1081             :                            peer_version, data->ttls_version, peer_version);
    1082           0 :                 data->ttls_version = peer_version;
    1083             :         }
    1084             : 
    1085          43 :         return 0;
    1086             : }
    1087             : 
    1088             : 
    1089          42 : static void eap_ttls_process_msg(struct eap_sm *sm, void *priv,
    1090             :                                  const struct wpabuf *respData)
    1091             : {
    1092          42 :         struct eap_ttls_data *data = priv;
    1093             : 
    1094          42 :         switch (data->state) {
    1095             :         case PHASE1:
    1096          26 :                 if (eap_server_tls_phase1(sm, &data->ssl) < 0)
    1097           2 :                         eap_ttls_state(data, FAILURE);
    1098          26 :                 break;
    1099             :         case PHASE2_START:
    1100             :         case PHASE2_METHOD:
    1101          13 :                 eap_ttls_process_phase2(sm, data, data->ssl.tls_in);
    1102          13 :                 eap_ttls_start_tnc(sm, data);
    1103          13 :                 break;
    1104             :         case PHASE2_MSCHAPV2_RESP:
    1105           3 :                 if (data->mschapv2_resp_ok && wpabuf_len(data->ssl.tls_in) ==
    1106             :                     0) {
    1107           3 :                         wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Peer "
    1108             :                                    "acknowledged response");
    1109           3 :                         eap_ttls_state(data, SUCCESS);
    1110           0 :                 } else if (!data->mschapv2_resp_ok) {
    1111           0 :                         wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Peer "
    1112             :                                    "acknowledged error");
    1113           0 :                         eap_ttls_state(data, FAILURE);
    1114             :                 } else {
    1115           0 :                         wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Unexpected "
    1116             :                                    "frame from peer (payload len %lu, "
    1117             :                                    "expected empty frame)",
    1118             :                                    (unsigned long)
    1119           0 :                                    wpabuf_len(data->ssl.tls_in));
    1120           0 :                         eap_ttls_state(data, FAILURE);
    1121             :                 }
    1122           3 :                 eap_ttls_start_tnc(sm, data);
    1123           3 :                 break;
    1124             :         default:
    1125           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Unexpected state %d in %s",
    1126           0 :                            data->state, __func__);
    1127           0 :                 break;
    1128             :         }
    1129          42 : }
    1130             : 
    1131             : 
    1132          43 : static void eap_ttls_process(struct eap_sm *sm, void *priv,
    1133             :                              struct wpabuf *respData)
    1134             : {
    1135          43 :         struct eap_ttls_data *data = priv;
    1136          43 :         if (eap_server_tls_process(sm, &data->ssl, respData, data,
    1137             :                                    EAP_TYPE_TTLS, eap_ttls_process_version,
    1138             :                                    eap_ttls_process_msg) < 0)
    1139           0 :                 eap_ttls_state(data, FAILURE);
    1140          43 : }
    1141             : 
    1142             : 
    1143          46 : static Boolean eap_ttls_isDone(struct eap_sm *sm, void *priv)
    1144             : {
    1145          46 :         struct eap_ttls_data *data = priv;
    1146          46 :         return data->state == SUCCESS || data->state == FAILURE;
    1147             : }
    1148             : 
    1149             : 
    1150          12 : static u8 * eap_ttls_getKey(struct eap_sm *sm, void *priv, size_t *len)
    1151             : {
    1152          12 :         struct eap_ttls_data *data = priv;
    1153             :         u8 *eapKeyData;
    1154             : 
    1155          12 :         if (data->state != SUCCESS)
    1156           3 :                 return NULL;
    1157             : 
    1158           9 :         eapKeyData = eap_server_tls_derive_key(sm, &data->ssl,
    1159             :                                                "ttls keying material",
    1160             :                                                EAP_TLS_KEY_LEN);
    1161           9 :         if (eapKeyData) {
    1162           9 :                 *len = EAP_TLS_KEY_LEN;
    1163           9 :                 wpa_hexdump_key(MSG_DEBUG, "EAP-TTLS: Derived key",
    1164             :                                 eapKeyData, EAP_TLS_KEY_LEN);
    1165             :         } else {
    1166           0 :                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Failed to derive key");
    1167             :         }
    1168             : 
    1169           9 :         return eapKeyData;
    1170             : }
    1171             : 
    1172             : 
    1173          15 : static Boolean eap_ttls_isSuccess(struct eap_sm *sm, void *priv)
    1174             : {
    1175          15 :         struct eap_ttls_data *data = priv;
    1176          15 :         return data->state == SUCCESS;
    1177             : }
    1178             : 
    1179             : 
    1180           1 : int eap_server_ttls_register(void)
    1181             : {
    1182             :         struct eap_method *eap;
    1183             :         int ret;
    1184             : 
    1185           1 :         eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
    1186             :                                       EAP_VENDOR_IETF, EAP_TYPE_TTLS, "TTLS");
    1187           1 :         if (eap == NULL)
    1188           0 :                 return -1;
    1189             : 
    1190           1 :         eap->init = eap_ttls_init;
    1191           1 :         eap->reset = eap_ttls_reset;
    1192           1 :         eap->buildReq = eap_ttls_buildReq;
    1193           1 :         eap->check = eap_ttls_check;
    1194           1 :         eap->process = eap_ttls_process;
    1195           1 :         eap->isDone = eap_ttls_isDone;
    1196           1 :         eap->getKey = eap_ttls_getKey;
    1197           1 :         eap->isSuccess = eap_ttls_isSuccess;
    1198             : 
    1199           1 :         ret = eap_server_method_register(eap);
    1200           1 :         if (ret)
    1201           0 :                 eap_server_method_free(eap);
    1202           1 :         return ret;
    1203             : }

Generated by: LCOV version 1.10