contrib/wpa/src/eap_peer/eap_ttls.c

   1 /*
   2  * EAP peer method: EAP-TTLS (RFC 5281)
   3  * Copyright (c) 2004-2015, 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_common/chap.h"
  16 #include "eap_common/eap_ttls.h"
  17 #include "mschapv2.h"
  18 #include "eap_i.h"
  19 #include "eap_tls_common.h"
  20 #include "eap_config.h"
  21
  22
  23 #define EAP_TTLS_VERSION 0
  24
  25
  26 static void eap_ttls_deinit(struct eap_sm *sm, void *priv);
  27
  28
  29 struct eap_ttls_data {
  30         struct eap_ssl_data ssl;
  31
  32         int ttls_version;
  33
  34         const struct eap_method *phase2_method;
  35         void *phase2_priv;
  36         int phase2_success;
  37         int phase2_start;
  38         EapDecision decision_succ;
  39
  40         enum phase2_types {
  41                 EAP_TTLS_PHASE2_EAP,
  42                 EAP_TTLS_PHASE2_MSCHAPV2,
  43                 EAP_TTLS_PHASE2_MSCHAP,
  44                 EAP_TTLS_PHASE2_PAP,
  45                 EAP_TTLS_PHASE2_CHAP
  46         } phase2_type;
  47         struct eap_method_type phase2_eap_type;
  48         struct eap_method_type *phase2_eap_types;
  49         size_t num_phase2_eap_types;
  50
  51         u8 auth_response[MSCHAPV2_AUTH_RESPONSE_LEN];
  52         int auth_response_valid;
  53         u8 master_key[MSCHAPV2_MASTER_KEY_LEN]; /* MSCHAPv2 master key */
  54         u8 ident;
  55         int resuming; /* starting a resumed session */
  56         int reauth; /* reauthentication */
  57         u8 *key_data;
  58         u8 *session_id;
  59         size_t id_len;
  60
  61         struct wpabuf *pending_phase2_req;
  62         struct wpabuf *pending_resp;
  63
  64 #ifdef EAP_TNC
  65         int ready_for_tnc;
  66         int tnc_started;
  67 #endif /* EAP_TNC */
  68 };
  69
  70
  71 static void * eap_ttls_init(struct eap_sm *sm)
  72 {
  73         struct eap_ttls_data *data;
  74         struct eap_peer_config *config = eap_get_config(sm);
  75         int selected_non_eap;
  76         char *selected;
  77
  78         data = os_zalloc(sizeof(*data));
  79         if (data == NULL)
  80                 return NULL;
  81         data->ttls_version = EAP_TTLS_VERSION;
  82         selected = "EAP";
  83         selected_non_eap = 0;
  84         data->phase2_type = EAP_TTLS_PHASE2_EAP;
  85
  86         /*
  87          * Either one auth= type or one or more autheap= methods can be
  88          * specified.
  89          */
  90         if (config && config->phase2) {
  91                 const char *token, *last = NULL;
  92
  93                 while ((token = cstr_token(config->phase2, " \t", &last))) {
  94                         if (os_strncmp(token, "auth=", 5) != 0)
  95                                 continue;
  96                         token += 5;
  97
  98                         if (last - token == 8 &&
  99                             os_strncmp(token, "MSCHAPV2", 8) == 0) {
 100                                 selected = "MSCHAPV2";
 101                                 data->phase2_type = EAP_TTLS_PHASE2_MSCHAPV2;
 102                         } else if (last - token == 6 &&
 103                                    os_strncmp(token, "MSCHAP", 6) == 0) {
 104                                 selected = "MSCHAP";
 105                                 data->phase2_type = EAP_TTLS_PHASE2_MSCHAP;
 106                         } else if (last - token == 3 &&
 107                                    os_strncmp(token, "PAP", 3) == 0) {
 108                                 selected = "PAP";
 109                                 data->phase2_type = EAP_TTLS_PHASE2_PAP;
 110                         } else if (last - token == 4 &&
 111                                    os_strncmp(token, "CHAP", 4) == 0) {
 112                                 selected = "CHAP";
 113                                 data->phase2_type = EAP_TTLS_PHASE2_CHAP;
 114                         } else {
 115                                 wpa_printf(MSG_ERROR,
 116                                            "EAP-TTLS: Unsupported Phase2 type '%s'",
 117                                            token);
 118                                 eap_ttls_deinit(sm, data);
 119                                 return NULL;
 120                         }
 121
 122                         if (selected_non_eap) {
 123                                 wpa_printf(MSG_ERROR,
 124                                            "EAP-TTLS: Only one Phase2 type can be specified");
 125                                 eap_ttls_deinit(sm, data);
 126                                 return NULL;
 127                         }
 128
 129                         selected_non_eap = 1;
 130                 }
 131
 132                 if (os_strstr(config->phase2, "autheap=")) {
 133                         if (selected_non_eap) {
 134                                 wpa_printf(MSG_ERROR,
 135                                            "EAP-TTLS: Both auth= and autheap= params cannot be specified");
 136                                 eap_ttls_deinit(sm, data);
 137                                 return NULL;
 138                         }
 139                         selected = "EAP";
 140                         data->phase2_type = EAP_TTLS_PHASE2_EAP;
 141                 }
 142         }
 143
 144         wpa_printf(MSG_DEBUG, "EAP-TTLS: Phase2 type: %s", selected);
 145
 146         if (data->phase2_type == EAP_TTLS_PHASE2_EAP) {
 147                 if (eap_peer_select_phase2_methods(config, "autheap=",
 148                                                    &data->phase2_eap_types,
 149                                                    &data->num_phase2_eap_types)
 150                     < 0) {
 151                         eap_ttls_deinit(sm, data);
 152                         return NULL;
 153                 }
 154
 155                 data->phase2_eap_type.vendor = EAP_VENDOR_IETF;
 156                 data->phase2_eap_type.method = EAP_TYPE_NONE;
 157         }
 158
 159         if (eap_peer_tls_ssl_init(sm, &data->ssl, config, EAP_TYPE_TTLS)) {
 160                 wpa_printf(MSG_INFO, "EAP-TTLS: Failed to initialize SSL.");
 161                 eap_ttls_deinit(sm, data);
 162                 return NULL;
 163         }
 164
 165         return data;
 166 }
 167
 168
 169 static void eap_ttls_phase2_eap_deinit(struct eap_sm *sm,
 170                                        struct eap_ttls_data *data)
 171 {
 172         if (data->phase2_priv && data->phase2_method) {
 173                 data->phase2_method->deinit(sm, data->phase2_priv);
 174                 data->phase2_method = NULL;
 175                 data->phase2_priv = NULL;
 176         }
 177 }
 178
 179
 180 static void eap_ttls_free_key(struct eap_ttls_data *data)
 181 {
 182         if (data->key_data) {
 183                 bin_clear_free(data->key_data, EAP_TLS_KEY_LEN + EAP_EMSK_LEN);
 184                 data->key_data = NULL;
 185         }
 186 }
 187
 188
 189 static void eap_ttls_deinit(struct eap_sm *sm, void *priv)
 190 {
 191         struct eap_ttls_data *data = priv;
 192         if (data == NULL)
 193                 return;
 194         eap_ttls_phase2_eap_deinit(sm, data);
 195         os_free(data->phase2_eap_types);
 196         eap_peer_tls_ssl_deinit(sm, &data->ssl);
 197         eap_ttls_free_key(data);
 198         os_free(data->session_id);
 199         wpabuf_clear_free(data->pending_phase2_req);
 200         wpabuf_clear_free(data->pending_resp);
 201         os_free(data);
 202 }
 203
 204
 205 static u8 * eap_ttls_avp_hdr(u8 *avphdr, u32 avp_code, u32 vendor_id,
 206                              int mandatory, size_t len)
 207 {
 208         struct ttls_avp_vendor *avp;
 209         u8 flags;
 210         size_t hdrlen;
 211
 212         avp = (struct ttls_avp_vendor *) avphdr;
 213         flags = mandatory ? AVP_FLAGS_MANDATORY : 0;
 214         if (vendor_id) {
 215                 flags |= AVP_FLAGS_VENDOR;
 216                 hdrlen = sizeof(*avp);
 217                 avp->vendor_id = host_to_be32(vendor_id);
 218         } else {
 219                 hdrlen = sizeof(struct ttls_avp);
 220         }
 221
 222         avp->avp_code = host_to_be32(avp_code);
 223         avp->avp_length = host_to_be32(((u32) flags << 24) |
 224                                        (u32) (hdrlen + len));
 225
 226         return avphdr + hdrlen;
 227 }
 228
 229
 230 static u8 * eap_ttls_avp_add(u8 *start, u8 *avphdr, u32 avp_code,
 231                              u32 vendor_id, int mandatory,
 232                              const u8 *data, size_t len)
 233 {
 234         u8 *pos;
 235         pos = eap_ttls_avp_hdr(avphdr, avp_code, vendor_id, mandatory, len);
 236         os_memcpy(pos, data, len);
 237         pos += len;
 238         AVP_PAD(start, pos);
 239         return pos;
 240 }
 241
 242
 243 static int eap_ttls_avp_encapsulate(struct wpabuf **resp, u32 avp_code,
 244                                     int mandatory)
 245 {
 246         struct wpabuf *msg;
 247         u8 *avp, *pos;
 248
 249         msg = wpabuf_alloc(sizeof(struct ttls_avp) + wpabuf_len(*resp) + 4);
 250         if (msg == NULL) {
 251                 wpabuf_clear_free(*resp);
 252                 *resp = NULL;
 253                 return -1;
 254         }
 255
 256         avp = wpabuf_mhead(msg);
 257         pos = eap_ttls_avp_hdr(avp, avp_code, 0, mandatory, wpabuf_len(*resp));
 258         os_memcpy(pos, wpabuf_head(*resp), wpabuf_len(*resp));
 259         pos += wpabuf_len(*resp);
 260         AVP_PAD(avp, pos);
 261         wpabuf_clear_free(*resp);
 262         wpabuf_put(msg, pos - avp);
 263         *resp = msg;
 264         return 0;
 265 }
 266
 267
 268 static int eap_ttls_v0_derive_key(struct eap_sm *sm,
 269                                   struct eap_ttls_data *data)
 270 {
 271         eap_ttls_free_key(data);
 272         data->key_data = eap_peer_tls_derive_key(sm, &data->ssl,
 273                                                  "ttls keying material",
 274                                                  NULL, 0,
 275                                                  EAP_TLS_KEY_LEN +
 276                                                  EAP_EMSK_LEN);
 277         if (!data->key_data) {
 278                 wpa_printf(MSG_INFO, "EAP-TTLS: Failed to derive key");
 279                 return -1;
 280         }
 281
 282         wpa_hexdump_key(MSG_DEBUG, "EAP-TTLS: Derived key",
 283                         data->key_data, EAP_TLS_KEY_LEN);
 284         wpa_hexdump_key(MSG_DEBUG, "EAP-TTLS: Derived EMSK",
 285                         data->key_data + EAP_TLS_KEY_LEN,
 286                         EAP_EMSK_LEN);
 287
 288         os_free(data->session_id);
 289         data->session_id = eap_peer_tls_derive_session_id(sm, &data->ssl,
 290                                                           EAP_TYPE_TTLS,
 291                                                           &data->id_len);
 292         if (data->session_id) {
 293                 wpa_hexdump(MSG_DEBUG, "EAP-TTLS: Derived Session-Id",
 294                             data->session_id, data->id_len);
 295         } else {
 296                 wpa_printf(MSG_ERROR, "EAP-TTLS: Failed to derive Session-Id");
 297         }
 298
 299         return 0;
 300 }
 301
 302
 303 #ifndef CONFIG_FIPS
 304 static u8 * eap_ttls_implicit_challenge(struct eap_sm *sm,
 305                                         struct eap_ttls_data *data, size_t len)
 306 {
 307         return eap_peer_tls_derive_key(sm, &data->ssl, "ttls challenge",
 308                                        NULL, 0, len);
 309 }
 310 #endif /* CONFIG_FIPS */
 311
 312
 313 static void eap_ttls_phase2_select_eap_method(struct eap_ttls_data *data,
 314                                               u8 method)
 315 {
 316         size_t i;
 317         for (i = 0; i < data->num_phase2_eap_types; i++) {
 318                 if (data->phase2_eap_types[i].vendor != EAP_VENDOR_IETF ||
 319                     data->phase2_eap_types[i].method != method)
 320                         continue;
 321
 322                 data->phase2_eap_type.vendor =
 323                         data->phase2_eap_types[i].vendor;
 324                 data->phase2_eap_type.method =
 325                         data->phase2_eap_types[i].method;
 326                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Selected "
 327                            "Phase 2 EAP vendor %d method %d",
 328                            data->phase2_eap_type.vendor,
 329                            data->phase2_eap_type.method);
 330                 break;
 331         }
 332 }
 333
 334
 335 static int eap_ttls_phase2_eap_process(struct eap_sm *sm,
 336                                        struct eap_ttls_data *data,
 337                                        struct eap_method_ret *ret,
 338                                        struct eap_hdr *hdr, size_t len,
 339                                        struct wpabuf **resp)
 340 {
 341         struct wpabuf msg;
 342         struct eap_method_ret iret;
 343
 344         os_memset(&iret, 0, sizeof(iret));
 345         wpabuf_set(&msg, hdr, len);
 346         *resp = data->phase2_method->process(sm, data->phase2_priv, &iret,
 347                                              &msg);
 348         if ((iret.methodState == METHOD_DONE ||
 349              iret.methodState == METHOD_MAY_CONT) &&
 350             (iret.decision == DECISION_UNCOND_SUCC ||
 351              iret.decision == DECISION_COND_SUCC ||
 352              iret.decision == DECISION_FAIL)) {
 353                 ret->methodState = iret.methodState;
 354                 ret->decision = iret.decision;
 355         }
 356
 357         return 0;
 358 }
 359
 360
 361 static int eap_ttls_phase2_request_eap_method(struct eap_sm *sm,
 362                                               struct eap_ttls_data *data,
 363                                               struct eap_method_ret *ret,
 364                                               struct eap_hdr *hdr, size_t len,
 365                                               u8 method, struct wpabuf **resp)
 366 {
 367 #ifdef EAP_TNC
 368         if (data->tnc_started && data->phase2_method &&
 369             data->phase2_priv && method == EAP_TYPE_TNC &&
 370             data->phase2_eap_type.method == EAP_TYPE_TNC)
 371                 return eap_ttls_phase2_eap_process(sm, data, ret, hdr, len,
 372                                                    resp);
 373
 374         if (data->ready_for_tnc && !data->tnc_started &&
 375             method == EAP_TYPE_TNC) {
 376                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Start TNC after completed "
 377                            "EAP method");
 378                 data->tnc_started = 1;
 379         }
 380
 381         if (data->tnc_started) {
 382                 if (data->phase2_eap_type.vendor != EAP_VENDOR_IETF ||
 383                     data->phase2_eap_type.method == EAP_TYPE_TNC) {
 384                         wpa_printf(MSG_DEBUG, "EAP-TTLS: Unexpected EAP "
 385                                    "type %d for TNC", method);
 386                         return -1;
 387                 }
 388
 389                 data->phase2_eap_type.vendor = EAP_VENDOR_IETF;
 390                 data->phase2_eap_type.method = method;
 391                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Selected "
 392                            "Phase 2 EAP vendor %d method %d (TNC)",
 393                            data->phase2_eap_type.vendor,
 394                            data->phase2_eap_type.method);
 395
 396                 if (data->phase2_type == EAP_TTLS_PHASE2_EAP)
 397                         eap_ttls_phase2_eap_deinit(sm, data);
 398         }
 399 #endif /* EAP_TNC */
 400
 401         if (data->phase2_eap_type.vendor == EAP_VENDOR_IETF &&
 402             data->phase2_eap_type.method == EAP_TYPE_NONE)
 403                 eap_ttls_phase2_select_eap_method(data, method);
 404
 405         if (method != data->phase2_eap_type.method || method == EAP_TYPE_NONE)
 406         {
 407                 if (eap_peer_tls_phase2_nak(data->phase2_eap_types,
 408                                             data->num_phase2_eap_types,
 409                                             hdr, resp))
 410                         return -1;
 411                 return 0;
 412         }
 413
 414         if (data->phase2_priv == NULL) {
 415                 data->phase2_method = eap_peer_get_eap_method(
 416                         EAP_VENDOR_IETF, method);
 417                 if (data->phase2_method) {
 418                         sm->init_phase2 = 1;
 419                         data->phase2_priv = data->phase2_method->init(sm);
 420                         sm->init_phase2 = 0;
 421                 }
 422         }
 423         if (data->phase2_priv == NULL || data->phase2_method == NULL) {
 424                 wpa_printf(MSG_INFO, "EAP-TTLS: failed to initialize "
 425                            "Phase 2 EAP method %d", method);
 426                 return -1;
 427         }
 428
 429         return eap_ttls_phase2_eap_process(sm, data, ret, hdr, len, resp);
 430 }
 431
 432
 433 static int eap_ttls_phase2_request_eap(struct eap_sm *sm,
 434                                        struct eap_ttls_data *data,
 435                                        struct eap_method_ret *ret,
 436                                        struct eap_hdr *hdr,
 437                                        struct wpabuf **resp)
 438 {
 439         size_t len = be_to_host16(hdr->length);
 440         u8 *pos;
 441         struct eap_peer_config *config = eap_get_config(sm);
 442
 443         if (len <= sizeof(struct eap_hdr)) {
 444                 wpa_printf(MSG_INFO, "EAP-TTLS: too short "
 445                            "Phase 2 request (len=%lu)", (unsigned long) len);
 446                 return -1;
 447         }
 448         pos = (u8 *) (hdr + 1);
 449         wpa_printf(MSG_DEBUG, "EAP-TTLS: Phase 2 EAP Request: type=%d", *pos);
 450         switch (*pos) {
 451         case EAP_TYPE_IDENTITY:
 452                 *resp = eap_sm_buildIdentity(sm, hdr->identifier, 1);
 453                 break;
 454         default:
 455                 if (eap_ttls_phase2_request_eap_method(sm, data, ret, hdr, len,
 456                                                        *pos, resp) < 0)
 457                         return -1;
 458                 break;
 459         }
 460
 461         if (*resp == NULL &&
 462             (config->pending_req_identity || config->pending_req_password ||
 463              config->pending_req_otp || config->pending_req_sim)) {
 464                 return 0;
 465         }
 466
 467         if (*resp == NULL)
 468                 return -1;
 469
 470         wpa_hexdump_buf(MSG_DEBUG, "EAP-TTLS: AVP encapsulate EAP Response",
 471                         *resp);
 472         return eap_ttls_avp_encapsulate(resp, RADIUS_ATTR_EAP_MESSAGE, 1);
 473 }
 474
 475
 476 static int eap_ttls_phase2_request_mschapv2(struct eap_sm *sm,
 477                                             struct eap_ttls_data *data,
 478                                             struct eap_method_ret *ret,
 479                                             struct wpabuf **resp)
 480 {
 481 #ifdef CONFIG_FIPS
 482         wpa_printf(MSG_ERROR, "EAP-TTLS: MSCHAPV2 not supported in FIPS build");
 483         return -1;
 484 #else /* CONFIG_FIPS */
 485 #ifdef EAP_MSCHAPv2
 486         struct wpabuf *msg;
 487         u8 *buf, *pos, *challenge, *peer_challenge;
 488         const u8 *identity, *password;
 489         size_t identity_len, password_len;
 490         int pwhash;
 491
 492         wpa_printf(MSG_DEBUG, "EAP-TTLS: Phase 2 MSCHAPV2 Request");
 493
 494         identity = eap_get_config_identity(sm, &identity_len);
 495         password = eap_get_config_password2(sm, &password_len, &pwhash);
 496         if (identity == NULL || password == NULL)
 497                 return -1;
 498
 499         msg = wpabuf_alloc(identity_len + 1000);
 500         if (msg == NULL) {
 501                 wpa_printf(MSG_ERROR,
 502                            "EAP-TTLS/MSCHAPV2: Failed to allocate memory");
 503                 return -1;
 504         }
 505         pos = buf = wpabuf_mhead(msg);
 506
 507         /* User-Name */
 508         pos = eap_ttls_avp_add(buf, pos, RADIUS_ATTR_USER_NAME, 0, 1,
 509                                identity, identity_len);
 510
 511         /* MS-CHAP-Challenge */
 512         challenge = eap_ttls_implicit_challenge(
 513                 sm, data, EAP_TTLS_MSCHAPV2_CHALLENGE_LEN + 1);
 514         if (challenge == NULL) {
 515                 wpabuf_clear_free(msg);
 516                 wpa_printf(MSG_ERROR, "EAP-TTLS/MSCHAPV2: Failed to derive "
 517                            "implicit challenge");
 518                 return -1;
 519         }
 520
 521         pos = eap_ttls_avp_add(buf, pos, RADIUS_ATTR_MS_CHAP_CHALLENGE,
 522                                RADIUS_VENDOR_ID_MICROSOFT, 1,
 523                                challenge, EAP_TTLS_MSCHAPV2_CHALLENGE_LEN);
 524
 525         /* MS-CHAP2-Response */
 526         pos = eap_ttls_avp_hdr(pos, RADIUS_ATTR_MS_CHAP2_RESPONSE,
 527                                RADIUS_VENDOR_ID_MICROSOFT, 1,
 528                                EAP_TTLS_MSCHAPV2_RESPONSE_LEN);
 529         data->ident = challenge[EAP_TTLS_MSCHAPV2_CHALLENGE_LEN];
 530         *pos++ = data->ident;
 531         *pos++ = 0; /* Flags */
 532         if (os_get_random(pos, EAP_TTLS_MSCHAPV2_CHALLENGE_LEN) < 0) {
 533                 os_free(challenge);
 534                 wpabuf_clear_free(msg);
 535                 wpa_printf(MSG_ERROR, "EAP-TTLS/MSCHAPV2: Failed to get "
 536                            "random data for peer challenge");
 537                 return -1;
 538         }
 539         peer_challenge = pos;
 540         pos += EAP_TTLS_MSCHAPV2_CHALLENGE_LEN;
 541         os_memset(pos, 0, 8); /* Reserved, must be zero */
 542         pos += 8;
 543         if (mschapv2_derive_response(identity, identity_len, password,
 544                                      password_len, pwhash, challenge,
 545                                      peer_challenge, pos, data->auth_response,
 546                                      data->master_key)) {
 547                 os_free(challenge);
 548                 wpabuf_clear_free(msg);
 549                 wpa_printf(MSG_ERROR, "EAP-TTLS/MSCHAPV2: Failed to derive "
 550                            "response");
 551                 return -1;
 552         }
 553         data->auth_response_valid = 1;
 554
 555         pos += 24;
 556         os_free(challenge);
 557         AVP_PAD(buf, pos);
 558
 559         wpabuf_put(msg, pos - buf);
 560         *resp = msg;
 561
 562         return 0;
 563 #else /* EAP_MSCHAPv2 */
 564         wpa_printf(MSG_ERROR, "EAP-TTLS: MSCHAPv2 not included in the build");
 565         return -1;
 566 #endif /* EAP_MSCHAPv2 */
 567 #endif /* CONFIG_FIPS */
 568 }
 569
 570
 571 static int eap_ttls_phase2_request_mschap(struct eap_sm *sm,
 572                                           struct eap_ttls_data *data,
 573                                           struct eap_method_ret *ret,
 574                                           struct wpabuf **resp)
 575 {
 576 #ifdef CONFIG_FIPS
 577         wpa_printf(MSG_ERROR, "EAP-TTLS: MSCHAP not supported in FIPS build");
 578         return -1;
 579 #else /* CONFIG_FIPS */
 580         struct wpabuf *msg;
 581         u8 *buf, *pos, *challenge;
 582         const u8 *identity, *password;
 583         size_t identity_len, password_len;
 584         int pwhash;
 585
 586         wpa_printf(MSG_DEBUG, "EAP-TTLS: Phase 2 MSCHAP Request");
 587
 588         identity = eap_get_config_identity(sm, &identity_len);
 589         password = eap_get_config_password2(sm, &password_len, &pwhash);
 590         if (identity == NULL || password == NULL)
 591                 return -1;
 592
 593         msg = wpabuf_alloc(identity_len + 1000);
 594         if (msg == NULL) {
 595                 wpa_printf(MSG_ERROR,
 596                            "EAP-TTLS/MSCHAP: Failed to allocate memory");
 597                 return -1;
 598         }
 599         pos = buf = wpabuf_mhead(msg);
 600
 601         /* User-Name */
 602         pos = eap_ttls_avp_add(buf, pos, RADIUS_ATTR_USER_NAME, 0, 1,
 603                                identity, identity_len);
 604
 605         /* MS-CHAP-Challenge */
 606         challenge = eap_ttls_implicit_challenge(
 607                 sm, data, EAP_TTLS_MSCHAP_CHALLENGE_LEN + 1);
 608         if (challenge == NULL) {
 609                 wpabuf_clear_free(msg);
 610                 wpa_printf(MSG_ERROR, "EAP-TTLS/MSCHAP: Failed to derive "
 611                            "implicit challenge");
 612                 return -1;
 613         }
 614
 615         pos = eap_ttls_avp_add(buf, pos, RADIUS_ATTR_MS_CHAP_CHALLENGE,
 616                                RADIUS_VENDOR_ID_MICROSOFT, 1,
 617                                challenge, EAP_TTLS_MSCHAP_CHALLENGE_LEN);
 618
 619         /* MS-CHAP-Response */
 620         pos = eap_ttls_avp_hdr(pos, RADIUS_ATTR_MS_CHAP_RESPONSE,
 621                                RADIUS_VENDOR_ID_MICROSOFT, 1,
 622                                EAP_TTLS_MSCHAP_RESPONSE_LEN);
 623         data->ident = challenge[EAP_TTLS_MSCHAP_CHALLENGE_LEN];
 624         *pos++ = data->ident;
 625         *pos++ = 1; /* Flags: Use NT style passwords */
 626         os_memset(pos, 0, 24); /* LM-Response */
 627         pos += 24;
 628         if (pwhash) {
 629                 /* NT-Response */
 630                 if (challenge_response(challenge, password, pos)) {
 631                         wpa_printf(MSG_ERROR,
 632                                    "EAP-TTLS/MSCHAP: Failed derive password hash");
 633                         wpabuf_clear_free(msg);
 634                         os_free(challenge);
 635                         return -1;
 636                 }
 637
 638                 wpa_hexdump_key(MSG_DEBUG, "EAP-TTLS: MSCHAP password hash",
 639                                 password, 16);
 640         } else {
 641                 /* NT-Response */
 642                 if (nt_challenge_response(challenge, password, password_len,
 643                                           pos)) {
 644                         wpa_printf(MSG_ERROR,
 645                                    "EAP-TTLS/MSCHAP: Failed derive password");
 646                         wpabuf_clear_free(msg);
 647                         os_free(challenge);
 648                         return -1;
 649                 }
 650
 651                 wpa_hexdump_ascii_key(MSG_DEBUG, "EAP-TTLS: MSCHAP password",
 652                                       password, password_len);
 653         }
 654         wpa_hexdump(MSG_DEBUG, "EAP-TTLS: MSCHAP implicit challenge",
 655                     challenge, EAP_TTLS_MSCHAP_CHALLENGE_LEN);
 656         wpa_hexdump(MSG_DEBUG, "EAP-TTLS: MSCHAP response", pos, 24);
 657         pos += 24;
 658         os_free(challenge);
 659         AVP_PAD(buf, pos);
 660
 661         wpabuf_put(msg, pos - buf);
 662         *resp = msg;
 663
 664         /* EAP-TTLS/MSCHAP does not provide tunneled success
 665          * notification, so assume that Phase2 succeeds. */
 666         ret->methodState = METHOD_DONE;
 667         ret->decision = DECISION_COND_SUCC;
 668
 669         return 0;
 670 #endif /* CONFIG_FIPS */
 671 }
 672
 673
 674 static int eap_ttls_phase2_request_pap(struct eap_sm *sm,
 675                                        struct eap_ttls_data *data,
 676                                        struct eap_method_ret *ret,
 677                                        struct wpabuf **resp)
 678 {
 679         struct wpabuf *msg;
 680         u8 *buf, *pos;
 681         size_t pad;
 682         const u8 *identity, *password;
 683         size_t identity_len, password_len;
 684
 685         wpa_printf(MSG_DEBUG, "EAP-TTLS: Phase 2 PAP Request");
 686
 687         identity = eap_get_config_identity(sm, &identity_len);
 688         password = eap_get_config_password(sm, &password_len);
 689         if (identity == NULL || password == NULL)
 690                 return -1;
 691
 692         msg = wpabuf_alloc(identity_len + password_len + 100);
 693         if (msg == NULL) {
 694                 wpa_printf(MSG_ERROR,
 695                            "EAP-TTLS/PAP: Failed to allocate memory");
 696                 return -1;
 697         }
 698         pos = buf = wpabuf_mhead(msg);
 699
 700         /* User-Name */
 701         pos = eap_ttls_avp_add(buf, pos, RADIUS_ATTR_USER_NAME, 0, 1,
 702                                identity, identity_len);
 703
 704         /* User-Password; in RADIUS, this is encrypted, but EAP-TTLS encrypts
 705          * the data, so no separate encryption is used in the AVP itself.
 706          * However, the password is padded to obfuscate its length. */
 707         pad = password_len == 0 ? 16 : (16 - (password_len & 15)) & 15;
 708         pos = eap_ttls_avp_hdr(pos, RADIUS_ATTR_USER_PASSWORD, 0, 1,
 709                                password_len + pad);
 710         os_memcpy(pos, password, password_len);
 711         pos += password_len;
 712         os_memset(pos, 0, pad);
 713         pos += pad;
 714         AVP_PAD(buf, pos);
 715
 716         wpabuf_put(msg, pos - buf);
 717         *resp = msg;
 718
 719         /* EAP-TTLS/PAP does not provide tunneled success notification,
 720          * so assume that Phase2 succeeds. */
 721         ret->methodState = METHOD_DONE;
 722         ret->decision = DECISION_COND_SUCC;
 723
 724         return 0;
 725 }
 726
 727
 728 static int eap_ttls_phase2_request_chap(struct eap_sm *sm,
 729                                         struct eap_ttls_data *data,
 730                                         struct eap_method_ret *ret,
 731                                         struct wpabuf **resp)
 732 {
 733 #ifdef CONFIG_FIPS
 734         wpa_printf(MSG_ERROR, "EAP-TTLS: CHAP not supported in FIPS build");
 735         return -1;
 736 #else /* CONFIG_FIPS */
 737         struct wpabuf *msg;
 738         u8 *buf, *pos, *challenge;
 739         const u8 *identity, *password;
 740         size_t identity_len, password_len;
 741
 742         wpa_printf(MSG_DEBUG, "EAP-TTLS: Phase 2 CHAP Request");
 743
 744         identity = eap_get_config_identity(sm, &identity_len);
 745         password = eap_get_config_password(sm, &password_len);
 746         if (identity == NULL || password == NULL)
 747                 return -1;
 748
 749         msg = wpabuf_alloc(identity_len + 1000);
 750         if (msg == NULL) {
 751                 wpa_printf(MSG_ERROR,
 752                            "EAP-TTLS/CHAP: Failed to allocate memory");
 753                 return -1;
 754         }
 755         pos = buf = wpabuf_mhead(msg);
 756
 757         /* User-Name */
 758         pos = eap_ttls_avp_add(buf, pos, RADIUS_ATTR_USER_NAME, 0, 1,
 759                                identity, identity_len);
 760
 761         /* CHAP-Challenge */
 762         challenge = eap_ttls_implicit_challenge(
 763                 sm, data, EAP_TTLS_CHAP_CHALLENGE_LEN + 1);
 764         if (challenge == NULL) {
 765                 wpabuf_clear_free(msg);
 766                 wpa_printf(MSG_ERROR, "EAP-TTLS/CHAP: Failed to derive "
 767                            "implicit challenge");
 768                 return -1;
 769         }
 770
 771         pos = eap_ttls_avp_add(buf, pos, RADIUS_ATTR_CHAP_CHALLENGE, 0, 1,
 772                                challenge, EAP_TTLS_CHAP_CHALLENGE_LEN);
 773
 774         /* CHAP-Password */
 775         pos = eap_ttls_avp_hdr(pos, RADIUS_ATTR_CHAP_PASSWORD, 0, 1,
 776                                1 + EAP_TTLS_CHAP_PASSWORD_LEN);
 777         data->ident = challenge[EAP_TTLS_CHAP_CHALLENGE_LEN];
 778         *pos++ = data->ident;
 779
 780         /* MD5(Ident + Password + Challenge) */
 781         chap_md5(data->ident, password, password_len, challenge,
 782                  EAP_TTLS_CHAP_CHALLENGE_LEN, pos);
 783
 784         wpa_hexdump_ascii(MSG_DEBUG, "EAP-TTLS: CHAP username",
 785                           identity, identity_len);
 786         wpa_hexdump_ascii_key(MSG_DEBUG, "EAP-TTLS: CHAP password",
 787                               password, password_len);
 788         wpa_hexdump(MSG_DEBUG, "EAP-TTLS: CHAP implicit challenge",
 789                     challenge, EAP_TTLS_CHAP_CHALLENGE_LEN);
 790         wpa_hexdump(MSG_DEBUG, "EAP-TTLS: CHAP password",
 791                     pos, EAP_TTLS_CHAP_PASSWORD_LEN);
 792         pos += EAP_TTLS_CHAP_PASSWORD_LEN;
 793         os_free(challenge);
 794         AVP_PAD(buf, pos);
 795
 796         wpabuf_put(msg, pos - buf);
 797         *resp = msg;
 798
 799         /* EAP-TTLS/CHAP does not provide tunneled success
 800          * notification, so assume that Phase2 succeeds. */
 801         ret->methodState = METHOD_DONE;
 802         ret->decision = DECISION_COND_SUCC;
 803
 804         return 0;
 805 #endif /* CONFIG_FIPS */
 806 }
 807
 808
 809 static int eap_ttls_phase2_request(struct eap_sm *sm,
 810                                    struct eap_ttls_data *data,
 811                                    struct eap_method_ret *ret,
 812                                    struct eap_hdr *hdr,
 813                                    struct wpabuf **resp)
 814 {
 815         int res = 0;
 816         size_t len;
 817         enum phase2_types phase2_type = data->phase2_type;
 818
 819 #ifdef EAP_TNC
 820         if (data->tnc_started) {
 821                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Processing TNC");
 822                 phase2_type = EAP_TTLS_PHASE2_EAP;
 823         }
 824 #endif /* EAP_TNC */
 825
 826         if (phase2_type == EAP_TTLS_PHASE2_MSCHAPV2 ||
 827             phase2_type == EAP_TTLS_PHASE2_MSCHAP ||
 828             phase2_type == EAP_TTLS_PHASE2_PAP ||
 829             phase2_type == EAP_TTLS_PHASE2_CHAP) {
 830                 if (eap_get_config_identity(sm, &len) == NULL) {
 831                         wpa_printf(MSG_INFO,
 832                                    "EAP-TTLS: Identity not configured");
 833                         eap_sm_request_identity(sm);
 834                         if (eap_get_config_password(sm, &len) == NULL)
 835                                 eap_sm_request_password(sm);
 836                         return 0;
 837                 }
 838
 839                 if (eap_get_config_password(sm, &len) == NULL) {
 840                         wpa_printf(MSG_INFO,
 841                                    "EAP-TTLS: Password not configured");
 842                         eap_sm_request_password(sm);
 843                         return 0;
 844                 }
 845         }
 846
 847         switch (phase2_type) {
 848         case EAP_TTLS_PHASE2_EAP:
 849                 res = eap_ttls_phase2_request_eap(sm, data, ret, hdr, resp);
 850                 break;
 851         case EAP_TTLS_PHASE2_MSCHAPV2:
 852                 res = eap_ttls_phase2_request_mschapv2(sm, data, ret, resp);
 853                 break;
 854         case EAP_TTLS_PHASE2_MSCHAP:
 855                 res = eap_ttls_phase2_request_mschap(sm, data, ret, resp);
 856                 break;
 857         case EAP_TTLS_PHASE2_PAP:
 858                 res = eap_ttls_phase2_request_pap(sm, data, ret, resp);
 859                 break;
 860         case EAP_TTLS_PHASE2_CHAP:
 861                 res = eap_ttls_phase2_request_chap(sm, data, ret, resp);
 862                 break;
 863         default:
 864                 wpa_printf(MSG_ERROR, "EAP-TTLS: Phase 2 - Unknown");
 865                 res = -1;
 866                 break;
 867         }
 868
 869         if (res < 0) {
 870                 ret->methodState = METHOD_DONE;
 871                 ret->decision = DECISION_FAIL;
 872         }
 873
 874         return res;
 875 }
 876
 877
 878 struct ttls_parse_avp {
 879         u8 *mschapv2;
 880         u8 *eapdata;
 881         size_t eap_len;
 882         int mschapv2_error;
 883 };
 884
 885
 886 static int eap_ttls_parse_attr_eap(const u8 *dpos, size_t dlen,
 887                                    struct ttls_parse_avp *parse)
 888 {
 889         wpa_printf(MSG_DEBUG, "EAP-TTLS: AVP - EAP Message");
 890         if (parse->eapdata == NULL) {
 891                 parse->eapdata = os_memdup(dpos, dlen);
 892                 if (parse->eapdata == NULL) {
 893                         wpa_printf(MSG_WARNING, "EAP-TTLS: Failed to allocate "
 894                                    "memory for Phase 2 EAP data");
 895                         return -1;
 896                 }
 897                 parse->eap_len = dlen;
 898         } else {
 899                 u8 *neweap = os_realloc(parse->eapdata, parse->eap_len + dlen);
 900                 if (neweap == NULL) {
 901                         wpa_printf(MSG_WARNING, "EAP-TTLS: Failed to allocate "
 902                                    "memory for Phase 2 EAP data");
 903                         return -1;
 904                 }
 905                 os_memcpy(neweap + parse->eap_len, dpos, dlen);
 906                 parse->eapdata = neweap;
 907                 parse->eap_len += dlen;
 908         }
 909
 910         return 0;
 911 }
 912
 913
 914 static int eap_ttls_parse_avp(u8 *pos, size_t left,
 915                               struct ttls_parse_avp *parse)
 916 {
 917         struct ttls_avp *avp;
 918         u32 avp_code, avp_length, vendor_id = 0;
 919         u8 avp_flags, *dpos;
 920         size_t dlen;
 921
 922         avp = (struct ttls_avp *) pos;
 923         avp_code = be_to_host32(avp->avp_code);
 924         avp_length = be_to_host32(avp->avp_length);
 925         avp_flags = (avp_length >> 24) & 0xff;
 926         avp_length &= 0xffffff;
 927         wpa_printf(MSG_DEBUG, "EAP-TTLS: AVP: code=%d flags=0x%02x "
 928                    "length=%d", (int) avp_code, avp_flags,
 929                    (int) avp_length);
 930
 931         if (avp_length > left) {
 932                 wpa_printf(MSG_WARNING, "EAP-TTLS: AVP overflow "
 933                            "(len=%d, left=%lu) - dropped",
 934                            (int) avp_length, (unsigned long) left);
 935                 return -1;
 936         }
 937
 938         if (avp_length < sizeof(*avp)) {
 939                 wpa_printf(MSG_WARNING, "EAP-TTLS: Invalid AVP length %d",
 940                            avp_length);
 941                 return -1;
 942         }
 943
 944         dpos = (u8 *) (avp + 1);
 945         dlen = avp_length - sizeof(*avp);
 946         if (avp_flags & AVP_FLAGS_VENDOR) {
 947                 if (dlen < 4) {
 948                         wpa_printf(MSG_WARNING, "EAP-TTLS: Vendor AVP "
 949                                    "underflow");
 950                         return -1;
 951                 }
 952                 vendor_id = WPA_GET_BE32(dpos);
 953                 wpa_printf(MSG_DEBUG, "EAP-TTLS: AVP vendor_id %d",
 954                            (int) vendor_id);
 955                 dpos += 4;
 956                 dlen -= 4;
 957         }
 958
 959         wpa_hexdump(MSG_DEBUG, "EAP-TTLS: AVP data", dpos, dlen);
 960
 961         if (vendor_id == 0 && avp_code == RADIUS_ATTR_EAP_MESSAGE) {
 962                 if (eap_ttls_parse_attr_eap(dpos, dlen, parse) < 0)
 963                         return -1;
 964         } else if (vendor_id == 0 && avp_code == RADIUS_ATTR_REPLY_MESSAGE) {
 965                 /* This is an optional message that can be displayed to
 966                  * the user. */
 967                 wpa_hexdump_ascii(MSG_DEBUG, "EAP-TTLS: AVP - Reply-Message",
 968                                   dpos, dlen);
 969         } else if (vendor_id == RADIUS_VENDOR_ID_MICROSOFT &&
 970                    avp_code == RADIUS_ATTR_MS_CHAP2_SUCCESS) {
 971                 wpa_hexdump_ascii(MSG_DEBUG, "EAP-TTLS: MS-CHAP2-Success",
 972                                   dpos, dlen);
 973                 if (dlen != 43) {
 974                         wpa_printf(MSG_WARNING, "EAP-TTLS: Unexpected "
 975                                    "MS-CHAP2-Success length "
 976                                    "(len=%lu, expected 43)",
 977                                    (unsigned long) dlen);
 978                         return -1;
 979                 }
 980                 parse->mschapv2 = dpos;
 981         } else if (vendor_id == RADIUS_VENDOR_ID_MICROSOFT &&
 982                    avp_code == RADIUS_ATTR_MS_CHAP_ERROR) {
 983                 wpa_hexdump_ascii(MSG_DEBUG, "EAP-TTLS: MS-CHAP-Error",
 984                                   dpos, dlen);
 985                 parse->mschapv2_error = 1;
 986         } else if (avp_flags & AVP_FLAGS_MANDATORY) {
 987                 wpa_printf(MSG_WARNING, "EAP-TTLS: Unsupported mandatory AVP "
 988                            "code %d vendor_id %d - dropped",
 989                            (int) avp_code, (int) vendor_id);
 990                 return -1;
 991         } else {
 992                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Ignoring unsupported AVP "
 993                            "code %d vendor_id %d",
 994                            (int) avp_code, (int) vendor_id);
 995         }
 996
 997         return avp_length;
 998 }
 999
1000
1001 static int eap_ttls_parse_avps(struct wpabuf *in_decrypted,
1002                                struct ttls_parse_avp *parse)
1003 {
1004         u8 *pos;
1005         size_t left, pad;
1006         int avp_length;
1007
1008         pos = wpabuf_mhead(in_decrypted);
1009         left = wpabuf_len(in_decrypted);
1010         wpa_hexdump(MSG_DEBUG, "EAP-TTLS: Decrypted Phase 2 AVPs", pos, left);
1011         if (left < sizeof(struct ttls_avp)) {
1012                 wpa_printf(MSG_WARNING, "EAP-TTLS: Too short Phase 2 AVP frame"
1013                            " len=%lu expected %lu or more - dropped",
1014                            (unsigned long) left,
1015                            (unsigned long) sizeof(struct ttls_avp));
1016                 return -1;
1017         }
1018
1019         /* Parse AVPs */
1020         os_memset(parse, 0, sizeof(*parse));
1021
1022         while (left > 0) {
1023                 avp_length = eap_ttls_parse_avp(pos, left, parse);
1024                 if (avp_length < 0)
1025                         return -1;
1026
1027                 pad = (4 - (avp_length & 3)) & 3;
1028                 pos += avp_length + pad;
1029                 if (left < avp_length + pad)
1030                         left = 0;
1031                 else
1032                         left -= avp_length + pad;
1033         }
1034
1035         return 0;
1036 }
1037
1038
1039 static u8 * eap_ttls_fake_identity_request(void)
1040 {
1041         struct eap_hdr *hdr;
1042         u8 *buf;
1043
1044         wpa_printf(MSG_DEBUG, "EAP-TTLS: empty data in beginning of "
1045                    "Phase 2 - use fake EAP-Request Identity");
1046         buf = os_malloc(sizeof(*hdr) + 1);
1047         if (buf == NULL) {
1048                 wpa_printf(MSG_WARNING, "EAP-TTLS: failed to allocate "
1049                            "memory for fake EAP-Identity Request");
1050                 return NULL;
1051         }
1052
1053         hdr = (struct eap_hdr *) buf;
1054         hdr->code = EAP_CODE_REQUEST;
1055         hdr->identifier = 0;
1056         hdr->length = host_to_be16(sizeof(*hdr) + 1);
1057         buf[sizeof(*hdr)] = EAP_TYPE_IDENTITY;
1058
1059         return buf;
1060 }
1061
1062
1063 static int eap_ttls_encrypt_response(struct eap_sm *sm,
1064                                      struct eap_ttls_data *data,
1065                                      struct wpabuf *resp, u8 identifier,
1066                                      struct wpabuf **out_data)
1067 {
1068         if (resp == NULL)
1069                 return 0;
1070
1071         wpa_hexdump_buf_key(MSG_DEBUG, "EAP-TTLS: Encrypting Phase 2 data",
1072                             resp);
1073         if (eap_peer_tls_encrypt(sm, &data->ssl, EAP_TYPE_TTLS,
1074                                  data->ttls_version, identifier,
1075                                  resp, out_data)) {
1076                 wpa_printf(MSG_INFO, "EAP-TTLS: Failed to encrypt a Phase 2 "
1077                            "frame");
1078                 wpabuf_clear_free(resp);
1079                 return -1;
1080         }
1081         wpabuf_clear_free(resp);
1082
1083         return 0;
1084 }
1085
1086
1087 static int eap_ttls_process_phase2_eap(struct eap_sm *sm,
1088                                        struct eap_ttls_data *data,
1089                                        struct eap_method_ret *ret,
1090                                        struct ttls_parse_avp *parse,
1091                                        struct wpabuf **resp)
1092 {
1093         struct eap_hdr *hdr;
1094         size_t len;
1095
1096         if (parse->eapdata == NULL) {
1097                 wpa_printf(MSG_WARNING, "EAP-TTLS: No EAP Message in the "
1098                            "packet - dropped");
1099                 return -1;
1100         }
1101
1102         wpa_hexdump(MSG_DEBUG, "EAP-TTLS: Phase 2 EAP",
1103                     parse->eapdata, parse->eap_len);
1104         hdr = (struct eap_hdr *) parse->eapdata;
1105
1106         if (parse->eap_len < sizeof(*hdr)) {
1107                 wpa_printf(MSG_WARNING, "EAP-TTLS: Too short Phase 2 EAP "
1108                            "frame (len=%lu, expected %lu or more) - dropped",
1109                            (unsigned long) parse->eap_len,
1110                            (unsigned long) sizeof(*hdr));
1111                 return -1;
1112         }
1113         len = be_to_host16(hdr->length);
1114         if (len > parse->eap_len) {
1115                 wpa_printf(MSG_INFO, "EAP-TTLS: Length mismatch in Phase 2 "
1116                            "EAP frame (EAP hdr len=%lu, EAP data len in "
1117                            "AVP=%lu)",
1118                            (unsigned long) len,
1119                            (unsigned long) parse->eap_len);
1120                 return -1;
1121         }
1122         wpa_printf(MSG_DEBUG, "EAP-TTLS: received Phase 2: code=%d "
1123                    "identifier=%d length=%lu",
1124                    hdr->code, hdr->identifier, (unsigned long) len);
1125         switch (hdr->code) {
1126         case EAP_CODE_REQUEST:
1127                 if (eap_ttls_phase2_request(sm, data, ret, hdr, resp)) {
1128                         wpa_printf(MSG_INFO, "EAP-TTLS: Phase2 Request "
1129                                    "processing failed");
1130                         return -1;
1131                 }
1132                 break;
1133         default:
1134                 wpa_printf(MSG_INFO, "EAP-TTLS: Unexpected code=%d in "
1135                            "Phase 2 EAP header", hdr->code);
1136                 return -1;
1137         }
1138
1139         return 0;
1140 }
1141
1142
1143 static int eap_ttls_process_phase2_mschapv2(struct eap_sm *sm,
1144                                             struct eap_ttls_data *data,
1145                                             struct eap_method_ret *ret,
1146                                             struct ttls_parse_avp *parse)
1147 {
1148 #ifdef EAP_MSCHAPv2
1149         if (parse->mschapv2_error) {
1150                 wpa_printf(MSG_DEBUG, "EAP-TTLS/MSCHAPV2: Received "
1151                            "MS-CHAP-Error - failed");
1152                 ret->methodState = METHOD_DONE;
1153                 ret->decision = DECISION_FAIL;
1154                 /* Reply with empty data to ACK error */
1155                 return 1;
1156         }
1157
1158         if (parse->mschapv2 == NULL) {
1159 #ifdef EAP_TNC
1160                 if (data->phase2_success && parse->eapdata) {
1161                         /*
1162                          * Allow EAP-TNC to be started after successfully
1163                          * completed MSCHAPV2.
1164                          */
1165                         return 1;
1166                 }
1167 #endif /* EAP_TNC */
1168                 wpa_printf(MSG_WARNING, "EAP-TTLS: no MS-CHAP2-Success AVP "
1169                            "received for Phase2 MSCHAPV2");
1170                 return -1;
1171         }
1172         if (parse->mschapv2[0] != data->ident) {
1173                 wpa_printf(MSG_WARNING, "EAP-TTLS: Ident mismatch for Phase 2 "
1174                            "MSCHAPV2 (received Ident 0x%02x, expected 0x%02x)",
1175                            parse->mschapv2[0], data->ident);
1176                 return -1;
1177         }
1178         if (!data->auth_response_valid ||
1179             mschapv2_verify_auth_response(data->auth_response,
1180                                           parse->mschapv2 + 1, 42)) {
1181                 wpa_printf(MSG_WARNING, "EAP-TTLS: Invalid authenticator "
1182                            "response in Phase 2 MSCHAPV2 success request");
1183                 return -1;
1184         }
1185
1186         wpa_printf(MSG_INFO, "EAP-TTLS: Phase 2 MSCHAPV2 "
1187                    "authentication succeeded");
1188         ret->methodState = METHOD_DONE;
1189         ret->decision = DECISION_UNCOND_SUCC;
1190         data->phase2_success = 1;
1191
1192         /*
1193          * Reply with empty data; authentication server will reply
1194          * with EAP-Success after this.
1195          */
1196         return 1;
1197 #else /* EAP_MSCHAPv2 */
1198         wpa_printf(MSG_ERROR, "EAP-TTLS: MSCHAPv2 not included in the build");
1199         return -1;
1200 #endif /* EAP_MSCHAPv2 */
1201 }
1202
1203
1204 #ifdef EAP_TNC
1205 static int eap_ttls_process_tnc_start(struct eap_sm *sm,
1206                                       struct eap_ttls_data *data,
1207                                       struct eap_method_ret *ret,
1208                                       struct ttls_parse_avp *parse,
1209                                       struct wpabuf **resp)
1210 {
1211         /* TNC uses inner EAP method after non-EAP TTLS phase 2. */
1212         if (parse->eapdata == NULL) {
1213                 wpa_printf(MSG_INFO, "EAP-TTLS: Phase 2 received "
1214                            "unexpected tunneled data (no EAP)");
1215                 return -1;
1216         }
1217
1218         if (!data->ready_for_tnc) {
1219                 wpa_printf(MSG_INFO, "EAP-TTLS: Phase 2 received "
1220                            "EAP after non-EAP, but not ready for TNC");
1221                 return -1;
1222         }
1223
1224         wpa_printf(MSG_DEBUG, "EAP-TTLS: Start TNC after completed "
1225                    "non-EAP method");
1226         data->tnc_started = 1;
1227
1228         if (eap_ttls_process_phase2_eap(sm, data, ret, parse, resp) < 0)
1229                 return -1;
1230
1231         return 0;
1232 }
1233 #endif /* EAP_TNC */
1234
1235
1236 static int eap_ttls_process_decrypted(struct eap_sm *sm,
1237                                       struct eap_ttls_data *data,
1238                                       struct eap_method_ret *ret,
1239                                       u8 identifier,
1240                                       struct ttls_parse_avp *parse,
1241                                       struct wpabuf *in_decrypted,
1242                                       struct wpabuf **out_data)
1243 {
1244         struct wpabuf *resp = NULL;
1245         struct eap_peer_config *config = eap_get_config(sm);
1246         int res;
1247         enum phase2_types phase2_type = data->phase2_type;
1248
1249 #ifdef EAP_TNC
1250         if (data->tnc_started)
1251                 phase2_type = EAP_TTLS_PHASE2_EAP;
1252 #endif /* EAP_TNC */
1253
1254         switch (phase2_type) {
1255         case EAP_TTLS_PHASE2_EAP:
1256                 if (eap_ttls_process_phase2_eap(sm, data, ret, parse, &resp) <
1257                     0)
1258                         return -1;
1259                 break;
1260         case EAP_TTLS_PHASE2_MSCHAPV2:
1261                 res = eap_ttls_process_phase2_mschapv2(sm, data, ret, parse);
1262 #ifdef EAP_TNC
1263                 if (res == 1 && parse->eapdata && data->phase2_success) {
1264                         /*
1265                          * TNC may be required as the next
1266                          * authentication method within the tunnel.
1267                          */
1268                         ret->methodState = METHOD_MAY_CONT;
1269                         data->ready_for_tnc = 1;
1270                         if (eap_ttls_process_tnc_start(sm, data, ret, parse,
1271                                                        &resp) == 0)
1272                                 break;
1273                 }
1274 #endif /* EAP_TNC */
1275                 return res;
1276         case EAP_TTLS_PHASE2_MSCHAP:
1277         case EAP_TTLS_PHASE2_PAP:
1278         case EAP_TTLS_PHASE2_CHAP:
1279 #ifdef EAP_TNC
1280                 if (eap_ttls_process_tnc_start(sm, data, ret, parse, &resp) <
1281                     0)
1282                         return -1;
1283                 break;
1284 #else /* EAP_TNC */
1285                 /* EAP-TTLS/{MSCHAP,PAP,CHAP} should not send any TLS tunneled
1286                  * requests to the supplicant */
1287                 wpa_printf(MSG_INFO, "EAP-TTLS: Phase 2 received unexpected "
1288                            "tunneled data");
1289                 return -1;
1290 #endif /* EAP_TNC */
1291         }
1292
1293         if (resp) {
1294                 if (eap_ttls_encrypt_response(sm, data, resp, identifier,
1295                                               out_data) < 0)
1296                         return -1;
1297         } else if (config->pending_req_identity ||
1298                    config->pending_req_password ||
1299                    config->pending_req_otp ||
1300                    config->pending_req_new_password ||
1301                    config->pending_req_sim) {
1302                 wpabuf_clear_free(data->pending_phase2_req);
1303                 data->pending_phase2_req = wpabuf_dup(in_decrypted);
1304         }
1305
1306         return 0;
1307 }
1308
1309
1310 static int eap_ttls_implicit_identity_request(struct eap_sm *sm,
1311                                               struct eap_ttls_data *data,
1312                                               struct eap_method_ret *ret,
1313                                               u8 identifier,
1314                                               struct wpabuf **out_data)
1315 {
1316         int retval = 0;
1317         struct eap_hdr *hdr;
1318         struct wpabuf *resp;
1319
1320         hdr = (struct eap_hdr *) eap_ttls_fake_identity_request();
1321         if (hdr == NULL) {
1322                 ret->methodState = METHOD_DONE;
1323                 ret->decision = DECISION_FAIL;
1324                 return -1;
1325         }
1326
1327         resp = NULL;
1328         if (eap_ttls_phase2_request(sm, data, ret, hdr, &resp)) {
1329                 wpa_printf(MSG_INFO, "EAP-TTLS: Phase2 Request "
1330                            "processing failed");
1331                 retval = -1;
1332         } else {
1333                 struct eap_peer_config *config = eap_get_config(sm);
1334                 if (resp == NULL &&
1335                     (config->pending_req_identity ||
1336                      config->pending_req_password ||
1337                      config->pending_req_otp ||
1338                      config->pending_req_new_password ||
1339                      config->pending_req_sim)) {
1340                         /*
1341                          * Use empty buffer to force implicit request
1342                          * processing when EAP request is re-processed after
1343                          * user input.
1344                          */
1345                         wpabuf_clear_free(data->pending_phase2_req);
1346                         data->pending_phase2_req = wpabuf_alloc(0);
1347                 }
1348
1349                 retval = eap_ttls_encrypt_response(sm, data, resp, identifier,
1350                                                    out_data);
1351         }
1352
1353         os_free(hdr);
1354
1355         if (retval < 0) {
1356                 ret->methodState = METHOD_DONE;
1357                 ret->decision = DECISION_FAIL;
1358         }
1359
1360         return retval;
1361 }
1362
1363
1364 static int eap_ttls_phase2_start(struct eap_sm *sm, struct eap_ttls_data *data,
1365                                  struct eap_method_ret *ret, u8 identifier,
1366                                  struct wpabuf **out_data)
1367 {
1368         data->phase2_start = 0;
1369
1370         /*
1371          * EAP-TTLS does not use Phase2 on fast re-auth; this must be done only
1372          * if TLS part was indeed resuming a previous session. Most
1373          * Authentication Servers terminate EAP-TTLS before reaching this
1374          * point, but some do not. Make wpa_supplicant stop phase 2 here, if
1375          * needed.
1376          */
1377         if (data->reauth &&
1378             tls_connection_resumed(sm->ssl_ctx, data->ssl.conn)) {
1379                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Session resumption - "
1380                            "skip phase 2");
1381                 *out_data = eap_peer_tls_build_ack(identifier, EAP_TYPE_TTLS,
1382                                                    data->ttls_version);
1383                 ret->methodState = METHOD_DONE;
1384                 ret->decision = DECISION_UNCOND_SUCC;
1385                 data->phase2_success = 1;
1386                 return 0;
1387         }
1388
1389         return eap_ttls_implicit_identity_request(sm, data, ret, identifier,
1390                                                   out_data);
1391 }
1392
1393
1394 static int eap_ttls_decrypt(struct eap_sm *sm, struct eap_ttls_data *data,
1395                             struct eap_method_ret *ret, u8 identifier,
1396                             const struct wpabuf *in_data,
1397                             struct wpabuf **out_data)
1398 {
1399         struct wpabuf *in_decrypted = NULL;
1400         int retval = 0;
1401         struct ttls_parse_avp parse;
1402
1403         os_memset(&parse, 0, sizeof(parse));
1404
1405         wpa_printf(MSG_DEBUG, "EAP-TTLS: received %lu bytes encrypted data for"
1406                    " Phase 2",
1407                    in_data ? (unsigned long) wpabuf_len(in_data) : 0);
1408
1409         if (data->pending_phase2_req) {
1410                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Pending Phase 2 request - "
1411                            "skip decryption and use old data");
1412                 /* Clear TLS reassembly state. */
1413                 eap_peer_tls_reset_input(&data->ssl);
1414
1415                 in_decrypted = data->pending_phase2_req;
1416                 data->pending_phase2_req = NULL;
1417                 if (wpabuf_len(in_decrypted) == 0) {
1418                         wpabuf_clear_free(in_decrypted);
1419                         return eap_ttls_implicit_identity_request(
1420                                 sm, data, ret, identifier, out_data);
1421                 }
1422                 goto continue_req;
1423         }
1424
1425         if ((in_data == NULL || wpabuf_len(in_data) == 0) &&
1426             data->phase2_start) {
1427                 return eap_ttls_phase2_start(sm, data, ret, identifier,
1428                                              out_data);
1429         }
1430
1431         if (in_data == NULL || wpabuf_len(in_data) == 0) {
1432                 /* Received TLS ACK - requesting more fragments */
1433                 return eap_peer_tls_encrypt(sm, &data->ssl, EAP_TYPE_TTLS,
1434                                             data->ttls_version,
1435                                             identifier, NULL, out_data);
1436         }
1437
1438         retval = eap_peer_tls_decrypt(sm, &data->ssl, in_data, &in_decrypted);
1439         if (retval)
1440                 goto done;
1441
1442 continue_req:
1443         data->phase2_start = 0;
1444
1445         if (eap_ttls_parse_avps(in_decrypted, &parse) < 0) {
1446                 retval = -1;
1447                 goto done;
1448         }
1449
1450         retval = eap_ttls_process_decrypted(sm, data, ret, identifier,
1451                                             &parse, in_decrypted, out_data);
1452
1453 done:
1454         wpabuf_clear_free(in_decrypted);
1455         os_free(parse.eapdata);
1456
1457         if (retval < 0) {
1458                 ret->methodState = METHOD_DONE;
1459                 ret->decision = DECISION_FAIL;
1460         }
1461
1462         return retval;
1463 }
1464
1465
1466 static int eap_ttls_process_handshake(struct eap_sm *sm,
1467                                       struct eap_ttls_data *data,
1468                                       struct eap_method_ret *ret,
1469                                       u8 identifier,
1470                                       const struct wpabuf *in_data,
1471                                       struct wpabuf **out_data)
1472 {
1473         int res;
1474
1475         if (sm->waiting_ext_cert_check && data->pending_resp) {
1476                 struct eap_peer_config *config = eap_get_config(sm);
1477
1478                 if (config->pending_ext_cert_check == EXT_CERT_CHECK_GOOD) {
1479                         wpa_printf(MSG_DEBUG,
1480                                    "EAP-TTLS: External certificate check succeeded - continue handshake");
1481                         *out_data = data->pending_resp;
1482                         data->pending_resp = NULL;
1483                         sm->waiting_ext_cert_check = 0;
1484                         return 0;
1485                 }
1486
1487                 if (config->pending_ext_cert_check == EXT_CERT_CHECK_BAD) {
1488                         wpa_printf(MSG_DEBUG,
1489                                    "EAP-TTLS: External certificate check failed - force authentication failure");
1490                         ret->methodState = METHOD_DONE;
1491                         ret->decision = DECISION_FAIL;
1492                         sm->waiting_ext_cert_check = 0;
1493                         return 0;
1494                 }
1495
1496                 wpa_printf(MSG_DEBUG,
1497                            "EAP-TTLS: Continuing to wait external server certificate validation");
1498                 return 0;
1499         }
1500
1501         res = eap_peer_tls_process_helper(sm, &data->ssl, EAP_TYPE_TTLS,
1502                                           data->ttls_version, identifier,
1503                                           in_data, out_data);
1504         if (res < 0) {
1505                 wpa_printf(MSG_DEBUG, "EAP-TTLS: TLS processing failed");
1506                 ret->methodState = METHOD_DONE;
1507                 ret->decision = DECISION_FAIL;
1508                 return -1;
1509         }
1510
1511         if (sm->waiting_ext_cert_check) {
1512                 wpa_printf(MSG_DEBUG,
1513                            "EAP-TTLS: Waiting external server certificate validation");
1514                 wpabuf_clear_free(data->pending_resp);
1515                 data->pending_resp = *out_data;
1516                 *out_data = NULL;
1517                 return 0;
1518         }
1519
1520         if (tls_connection_established(sm->ssl_ctx, data->ssl.conn)) {
1521                 wpa_printf(MSG_DEBUG, "EAP-TTLS: TLS done, proceed to "
1522                            "Phase 2");
1523                 if (data->resuming) {
1524                         wpa_printf(MSG_DEBUG, "EAP-TTLS: fast reauth - may "
1525                                    "skip Phase 2");
1526                         ret->decision = DECISION_COND_SUCC;
1527                         ret->methodState = METHOD_MAY_CONT;
1528                 }
1529                 data->phase2_start = 1;
1530                 eap_ttls_v0_derive_key(sm, data);
1531
1532                 if (*out_data == NULL || wpabuf_len(*out_data) == 0) {
1533                         if (eap_ttls_decrypt(sm, data, ret, identifier,
1534                                              NULL, out_data)) {
1535                                 wpa_printf(MSG_WARNING, "EAP-TTLS: "
1536                                            "failed to process early "
1537                                            "start for Phase 2");
1538                         }
1539                         res = 0;
1540                 }
1541                 data->resuming = 0;
1542         }
1543
1544         if (res == 2) {
1545                 /*
1546                  * Application data included in the handshake message.
1547                  */
1548                 wpabuf_clear_free(data->pending_phase2_req);
1549                 data->pending_phase2_req = *out_data;
1550                 *out_data = NULL;
1551                 res = eap_ttls_decrypt(sm, data, ret, identifier, in_data,
1552                                        out_data);
1553         }
1554
1555         return res;
1556 }
1557
1558
1559 static void eap_ttls_check_auth_status(struct eap_sm *sm,
1560                                        struct eap_ttls_data *data,
1561                                        struct eap_method_ret *ret)
1562 {
1563         if (ret->methodState == METHOD_DONE) {
1564                 ret->allowNotifications = FALSE;
1565                 if (ret->decision == DECISION_UNCOND_SUCC ||
1566                     ret->decision == DECISION_COND_SUCC) {
1567                         wpa_printf(MSG_DEBUG, "EAP-TTLS: Authentication "
1568                                    "completed successfully");
1569                         data->phase2_success = 1;
1570                         data->decision_succ = ret->decision;
1571 #ifdef EAP_TNC
1572                         if (!data->ready_for_tnc && !data->tnc_started) {
1573                                 /*
1574                                  * TNC may be required as the next
1575                                  * authentication method within the tunnel.
1576                                  */
1577                                 ret->methodState = METHOD_MAY_CONT;
1578                                 data->ready_for_tnc = 1;
1579                         }
1580 #endif /* EAP_TNC */
1581                 }
1582         } else if (ret->methodState == METHOD_MAY_CONT &&
1583                    (ret->decision == DECISION_UNCOND_SUCC ||
1584                     ret->decision == DECISION_COND_SUCC)) {
1585                         wpa_printf(MSG_DEBUG, "EAP-TTLS: Authentication "
1586                                    "completed successfully (MAY_CONT)");
1587                         data->phase2_success = 1;
1588                         data->decision_succ = ret->decision;
1589         } else if (data->decision_succ != DECISION_FAIL &&
1590                    data->phase2_success &&
1591                    !data->ssl.tls_out) {
1592                 /*
1593                  * This is needed to cover the case where the final Phase 2
1594                  * message gets fragmented since fragmentation clears
1595                  * decision back to FAIL.
1596                  */
1597                 wpa_printf(MSG_DEBUG,
1598                            "EAP-TTLS: Restore success decision after fragmented frame sent completely");
1599                 ret->decision = data->decision_succ;
1600         }
1601 }
1602
1603
1604 static struct wpabuf * eap_ttls_process(struct eap_sm *sm, void *priv,
1605                                         struct eap_method_ret *ret,
1606                                         const struct wpabuf *reqData)
1607 {
1608         size_t left;
1609         int res;
1610         u8 flags, id;
1611         struct wpabuf *resp;
1612         const u8 *pos;
1613         struct eap_ttls_data *data = priv;
1614         struct wpabuf msg;
1615
1616         pos = eap_peer_tls_process_init(sm, &data->ssl, EAP_TYPE_TTLS, ret,
1617                                         reqData, &left, &flags);
1618         if (pos == NULL)
1619                 return NULL;
1620         id = eap_get_id(reqData);
1621
1622         if (flags & EAP_TLS_FLAGS_START) {
1623                 wpa_printf(MSG_DEBUG, "EAP-TTLS: Start (server ver=%d, own "
1624                            "ver=%d)", flags & EAP_TLS_VERSION_MASK,
1625                            data->ttls_version);
1626
1627                 /* RFC 5281, Ch. 9.2:
1628                  * "This packet MAY contain additional information in the form
1629                  * of AVPs, which may provide useful hints to the client"
1630                  * For now, ignore any potential extra data.
1631                  */
1632                 left = 0;
1633         }
1634
1635         wpabuf_set(&msg, pos, left);
1636
1637         resp = NULL;
1638         if (tls_connection_established(sm->ssl_ctx, data->ssl.conn) &&
1639             !data->resuming) {
1640                 res = eap_ttls_decrypt(sm, data, ret, id, &msg, &resp);
1641         } else {
1642                 res = eap_ttls_process_handshake(sm, data, ret, id,
1643                                                  &msg, &resp);
1644         }
1645
1646         eap_ttls_check_auth_status(sm, data, ret);
1647
1648         /* FIX: what about res == -1? Could just move all error processing into
1649          * the other functions and get rid of this res==1 case here. */
1650         if (res == 1) {
1651                 wpabuf_clear_free(resp);
1652                 return eap_peer_tls_build_ack(id, EAP_TYPE_TTLS,
1653                                               data->ttls_version);
1654         }
1655         return resp;
1656 }
1657
1658
1659 static Boolean eap_ttls_has_reauth_data(struct eap_sm *sm, void *priv)
1660 {
1661         struct eap_ttls_data *data = priv;
1662         return tls_connection_established(sm->ssl_ctx, data->ssl.conn) &&
1663                 data->phase2_success;
1664 }
1665
1666
1667 static void eap_ttls_deinit_for_reauth(struct eap_sm *sm, void *priv)
1668 {
1669         struct eap_ttls_data *data = priv;
1670
1671         if (data->phase2_priv && data->phase2_method &&
1672             data->phase2_method->deinit_for_reauth)
1673                 data->phase2_method->deinit_for_reauth(sm, data->phase2_priv);
1674         wpabuf_clear_free(data->pending_phase2_req);
1675         data->pending_phase2_req = NULL;
1676         wpabuf_clear_free(data->pending_resp);
1677         data->pending_resp = NULL;
1678         data->decision_succ = DECISION_FAIL;
1679 #ifdef EAP_TNC
1680         data->ready_for_tnc = 0;
1681         data->tnc_started = 0;
1682 #endif /* EAP_TNC */
1683 }
1684
1685
1686 static void * eap_ttls_init_for_reauth(struct eap_sm *sm, void *priv)
1687 {
1688         struct eap_ttls_data *data = priv;
1689         eap_ttls_free_key(data);
1690         os_free(data->session_id);
1691         data->session_id = NULL;
1692         if (eap_peer_tls_reauth_init(sm, &data->ssl)) {
1693                 os_free(data);
1694                 return NULL;
1695         }
1696         if (data->phase2_priv && data->phase2_method &&
1697             data->phase2_method->init_for_reauth)
1698                 data->phase2_method->init_for_reauth(sm, data->phase2_priv);
1699         data->phase2_start = 0;
1700         data->phase2_success = 0;
1701         data->resuming = 1;
1702         data->reauth = 1;
1703         return priv;
1704 }
1705
1706
1707 static int eap_ttls_get_status(struct eap_sm *sm, void *priv, char *buf,
1708                                size_t buflen, int verbose)
1709 {
1710         struct eap_ttls_data *data = priv;
1711         int len, ret;
1712
1713         len = eap_peer_tls_status(sm, &data->ssl, buf, buflen, verbose);
1714         ret = os_snprintf(buf + len, buflen - len,
1715                           "EAP-TTLSv%d Phase2 method=",
1716                           data->ttls_version);
1717         if (os_snprintf_error(buflen - len, ret))
1718                 return len;
1719         len += ret;
1720         switch (data->phase2_type) {
1721         case EAP_TTLS_PHASE2_EAP:
1722                 ret = os_snprintf(buf + len, buflen - len, "EAP-%s\n",
1723                                   data->phase2_method ?
1724                                   data->phase2_method->name : "?");
1725                 break;
1726         case EAP_TTLS_PHASE2_MSCHAPV2:
1727                 ret = os_snprintf(buf + len, buflen - len, "MSCHAPV2\n");
1728                 break;
1729         case EAP_TTLS_PHASE2_MSCHAP:
1730                 ret = os_snprintf(buf + len, buflen - len, "MSCHAP\n");
1731                 break;
1732         case EAP_TTLS_PHASE2_PAP:
1733                 ret = os_snprintf(buf + len, buflen - len, "PAP\n");
1734                 break;
1735         case EAP_TTLS_PHASE2_CHAP:
1736                 ret = os_snprintf(buf + len, buflen - len, "CHAP\n");
1737                 break;
1738         default:
1739                 ret = 0;
1740                 break;
1741         }
1742         if (os_snprintf_error(buflen - len, ret))
1743                 return len;
1744         len += ret;
1745
1746         return len;
1747 }
1748
1749
1750 static Boolean eap_ttls_isKeyAvailable(struct eap_sm *sm, void *priv)
1751 {
1752         struct eap_ttls_data *data = priv;
1753         return data->key_data != NULL && data->phase2_success;
1754 }
1755
1756
1757 static u8 * eap_ttls_getKey(struct eap_sm *sm, void *priv, size_t *len)
1758 {
1759         struct eap_ttls_data *data = priv;
1760         u8 *key;
1761
1762         if (data->key_data == NULL || !data->phase2_success)
1763                 return NULL;
1764
1765         key = os_memdup(data->key_data, EAP_TLS_KEY_LEN);
1766         if (key == NULL)
1767                 return NULL;
1768
1769         *len = EAP_TLS_KEY_LEN;
1770
1771         return key;
1772 }
1773
1774
1775 static u8 * eap_ttls_get_session_id(struct eap_sm *sm, void *priv, size_t *len)
1776 {
1777         struct eap_ttls_data *data = priv;
1778         u8 *id;
1779
1780         if (data->session_id == NULL || !data->phase2_success)
1781                 return NULL;
1782
1783         id = os_memdup(data->session_id, data->id_len);
1784         if (id == NULL)
1785                 return NULL;
1786
1787         *len = data->id_len;
1788
1789         return id;
1790 }
1791
1792
1793 static u8 * eap_ttls_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
1794 {
1795         struct eap_ttls_data *data = priv;
1796         u8 *key;
1797
1798         if (data->key_data == NULL)
1799                 return NULL;
1800
1801         key = os_memdup(data->key_data + EAP_TLS_KEY_LEN, EAP_EMSK_LEN);
1802         if (key == NULL)
1803                 return NULL;
1804
1805         *len = EAP_EMSK_LEN;
1806
1807         return key;
1808 }
1809
1810
1811 int eap_peer_ttls_register(void)
1812 {
1813         struct eap_method *eap;
1814
1815         eap = eap_peer_method_alloc(EAP_PEER_METHOD_INTERFACE_VERSION,
1816                                     EAP_VENDOR_IETF, EAP_TYPE_TTLS, "TTLS");
1817         if (eap == NULL)
1818                 return -1;
1819
1820         eap->init = eap_ttls_init;
1821         eap->deinit = eap_ttls_deinit;
1822         eap->process = eap_ttls_process;
1823         eap->isKeyAvailable = eap_ttls_isKeyAvailable;
1824         eap->getKey = eap_ttls_getKey;
1825         eap->getSessionId = eap_ttls_get_session_id;
1826         eap->get_status = eap_ttls_get_status;
1827         eap->has_reauth_data = eap_ttls_has_reauth_data;
1828         eap->deinit_for_reauth = eap_ttls_deinit_for_reauth;
1829         eap->init_for_reauth = eap_ttls_init_for_reauth;
1830         eap->get_emsk = eap_ttls_get_emsk;
1831
1832         return eap_peer_method_register(eap);
1833 }