workbench/network/WirelessManager/src/eap_peer/eap_mschapv2.c

   1 /*
   2  * EAP peer method: EAP-MSCHAPV2 (draft-kamath-pppext-eap-mschapv2-00.txt)
   3  * Copyright (c) 2004-2008, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  *
  14  * This file implements EAP peer part of EAP-MSCHAPV2 method (EAP type 26).
  15  * draft-kamath-pppext-eap-mschapv2-00.txt defines the Microsoft EAP CHAP
  16  * Extensions Protocol, Version 2, for mutual authentication and key
  17  * derivation. This encapsulates MS-CHAP-v2 protocol which is defined in
  18  * RFC 2759. Use of EAP-MSCHAPV2 derived keys with MPPE cipher is described in
  19  * RFC 3079.
  20  */
  21
  22 #include "includes.h"
  23
  24 #include "common.h"
  25 #include "crypto/ms_funcs.h"
  26 #include "common/wpa_ctrl.h"
  27 #include "mschapv2.h"
  28 #include "eap_i.h"
  29 #include "eap_config.h"
  30
  31
  32 #ifdef _MSC_VER
  33 #pragma pack(push, 1)
  34 #endif /* _MSC_VER */
  35
  36 struct eap_mschapv2_hdr {
  37         u8 op_code; /* MSCHAPV2_OP_* */
  38         u8 mschapv2_id; /* usually same as EAP identifier; must be changed
  39                          * for challenges, but not for success/failure */
  40         u8 ms_length[2]; /* Note: misaligned; length - 5 */
  41         /* followed by data */
  42 } STRUCT_PACKED;
  43
  44 /* Response Data field */
  45 struct ms_response {
  46         u8 peer_challenge[MSCHAPV2_CHAL_LEN];
  47         u8 reserved[8];
  48         u8 nt_response[MSCHAPV2_NT_RESPONSE_LEN];
  49         u8 flags;
  50 } STRUCT_PACKED;
  51
  52 /* Change-Password Data field */
  53 struct ms_change_password {
  54         u8 encr_password[516];
  55         u8 encr_hash[16];
  56         u8 peer_challenge[MSCHAPV2_CHAL_LEN];
  57         u8 reserved[8];
  58         u8 nt_response[MSCHAPV2_NT_RESPONSE_LEN];
  59         u8 flags[2];
  60 } STRUCT_PACKED;
  61
  62 #ifdef _MSC_VER
  63 #pragma pack(pop)
  64 #endif /* _MSC_VER */
  65
  66 #define MSCHAPV2_OP_CHALLENGE 1
  67 #define MSCHAPV2_OP_RESPONSE 2
  68 #define MSCHAPV2_OP_SUCCESS 3
  69 #define MSCHAPV2_OP_FAILURE 4
  70 #define MSCHAPV2_OP_CHANGE_PASSWORD 7
  71
  72 #define ERROR_RESTRICTED_LOGON_HOURS 646
  73 #define ERROR_ACCT_DISABLED 647
  74 #define ERROR_PASSWD_EXPIRED 648
  75 #define ERROR_NO_DIALIN_PERMISSION 649
  76 #define ERROR_AUTHENTICATION_FAILURE 691
  77 #define ERROR_CHANGING_PASSWORD 709
  78
  79 #define PASSWD_CHANGE_CHAL_LEN 16
  80 #define MSCHAPV2_KEY_LEN 16
  81
  82
  83 struct eap_mschapv2_data {
  84         u8 auth_response[MSCHAPV2_AUTH_RESPONSE_LEN];
  85         int auth_response_valid;
  86
  87         int prev_error;
  88         u8 passwd_change_challenge[PASSWD_CHANGE_CHAL_LEN];
  89         int passwd_change_challenge_valid;
  90         int passwd_change_version;
  91
  92         /* Optional challenge values generated in EAP-FAST Phase 1 negotiation
  93          */
  94         u8 *peer_challenge;
  95         u8 *auth_challenge;
  96
  97         int phase2;
  98         u8 master_key[MSCHAPV2_MASTER_KEY_LEN];
  99         int master_key_valid;
 100         int success;
 101
 102         struct wpabuf *prev_challenge;
 103 };
 104
 105
 106 static void eap_mschapv2_deinit(struct eap_sm *sm, void *priv);
 107
 108
 109 static void * eap_mschapv2_init(struct eap_sm *sm)
 110 {
 111         struct eap_mschapv2_data *data;
 112         data = os_zalloc(sizeof(*data));
 113         if (data == NULL)
 114                 return NULL;
 115
 116         if (sm->peer_challenge) {
 117                 data->peer_challenge = os_malloc(MSCHAPV2_CHAL_LEN);
 118                 if (data->peer_challenge == NULL) {
 119                         eap_mschapv2_deinit(sm, data);
 120                         return NULL;
 121                 }
 122                 os_memcpy(data->peer_challenge, sm->peer_challenge,
 123                           MSCHAPV2_CHAL_LEN);
 124         }
 125
 126         if (sm->auth_challenge) {
 127                 data->auth_challenge = os_malloc(MSCHAPV2_CHAL_LEN);
 128                 if (data->auth_challenge == NULL) {
 129                         eap_mschapv2_deinit(sm, data);
 130                         return NULL;
 131                 }
 132                 os_memcpy(data->auth_challenge, sm->auth_challenge,
 133                           MSCHAPV2_CHAL_LEN);
 134         }
 135
 136         data->phase2 = sm->init_phase2;
 137
 138         return data;
 139 }
 140
 141
 142 static void eap_mschapv2_deinit(struct eap_sm *sm, void *priv)
 143 {
 144         struct eap_mschapv2_data *data = priv;
 145         os_free(data->peer_challenge);
 146         os_free(data->auth_challenge);
 147         wpabuf_free(data->prev_challenge);
 148         os_free(data);
 149 }
 150
 151
 152 static struct wpabuf * eap_mschapv2_challenge_reply(
 153         struct eap_sm *sm, struct eap_mschapv2_data *data, u8 id,
 154         u8 mschapv2_id, const u8 *auth_challenge)
 155 {
 156         struct wpabuf *resp;
 157         struct eap_mschapv2_hdr *ms;
 158         u8 *peer_challenge;
 159         int ms_len;
 160         struct ms_response *r;
 161         size_t identity_len, password_len;
 162         const u8 *identity, *password;
 163         int pwhash;
 164
 165         wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Generating Challenge Response");
 166
 167         identity = eap_get_config_identity(sm, &identity_len);
 168         password = eap_get_config_password2(sm, &password_len, &pwhash);
 169         if (identity == NULL || password == NULL)
 170                 return NULL;
 171
 172         ms_len = sizeof(*ms) + 1 + sizeof(*r) + identity_len;
 173         resp = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, ms_len,
 174                              EAP_CODE_RESPONSE, id);
 175         if (resp == NULL)
 176                 return NULL;
 177
 178         ms = wpabuf_put(resp, sizeof(*ms));
 179         ms->op_code = MSCHAPV2_OP_RESPONSE;
 180         ms->mschapv2_id = mschapv2_id;
 181         if (data->prev_error) {
 182                 /*
 183                  * TODO: this does not seem to be enough when processing two
 184                  * or more failure messages. IAS did not increment mschapv2_id
 185                  * in its own packets, but it seemed to expect the peer to
 186                  * increment this for all packets(?).
 187                  */
 188                 ms->mschapv2_id++;
 189         }
 190         WPA_PUT_BE16(ms->ms_length, ms_len);
 191
 192         wpabuf_put_u8(resp, sizeof(*r)); /* Value-Size */
 193
 194         /* Response */
 195         r = wpabuf_put(resp, sizeof(*r));
 196         peer_challenge = r->peer_challenge;
 197         if (data->peer_challenge) {
 198                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: peer_challenge generated "
 199                            "in Phase 1");
 200                 peer_challenge = data->peer_challenge;
 201                 os_memset(r->peer_challenge, 0, MSCHAPV2_CHAL_LEN);
 202         } else if (os_get_random(peer_challenge, MSCHAPV2_CHAL_LEN)) {
 203                 wpabuf_free(resp);
 204                 return NULL;
 205         }
 206         os_memset(r->reserved, 0, 8);
 207         if (data->auth_challenge) {
 208                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: auth_challenge generated "
 209                            "in Phase 1");
 210                 auth_challenge = data->auth_challenge;
 211         }
 212         if (mschapv2_derive_response(identity, identity_len, password,
 213                                      password_len, pwhash, auth_challenge,
 214                                      peer_challenge, r->nt_response,
 215                                      data->auth_response, data->master_key)) {
 216                 wpa_printf(MSG_ERROR, "EAP-MSCHAPV2: Failed to derive "
 217                            "response");
 218                 wpabuf_free(resp);
 219                 return NULL;
 220         }
 221         data->auth_response_valid = 1;
 222         data->master_key_valid = 1;
 223
 224         r->flags = 0; /* reserved, must be zero */
 225
 226         wpabuf_put_data(resp, identity, identity_len);
 227         wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: TX identifier %d mschapv2_id %d "
 228                    "(response)", id, ms->mschapv2_id);
 229         return resp;
 230 }
 231
 232
 233 /**
 234  * eap_mschapv2_process - Process an EAP-MSCHAPv2 challenge message
 235  * @sm: Pointer to EAP state machine allocated with eap_peer_sm_init()
 236  * @data: Pointer to private EAP method data from eap_mschapv2_init()
 237  * @ret: Return values from EAP request validation and processing
 238  * @req: Pointer to EAP-MSCHAPv2 header from the request
 239  * @req_len: Length of the EAP-MSCHAPv2 data
 240  * @id: EAP identifier used in the request
 241  * Returns: Pointer to allocated EAP response packet (eapRespData) or %NULL if
 242  * no reply available
 243  */
 244 static struct wpabuf * eap_mschapv2_challenge(
 245         struct eap_sm *sm, struct eap_mschapv2_data *data,
 246         struct eap_method_ret *ret, const struct eap_mschapv2_hdr *req,
 247         size_t req_len, u8 id)
 248 {
 249         size_t len, challenge_len;
 250         const u8 *pos, *challenge;
 251
 252         if (eap_get_config_identity(sm, &len) == NULL ||
 253             eap_get_config_password(sm, &len) == NULL)
 254                 return NULL;
 255
 256         wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Received challenge");
 257         if (req_len < sizeof(*req) + 1) {
 258                 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Too short challenge data "
 259                            "(len %lu)", (unsigned long) req_len);
 260                 ret->ignore = TRUE;
 261                 return NULL;
 262         }
 263         pos = (const u8 *) (req + 1);
 264         challenge_len = *pos++;
 265         len = req_len - sizeof(*req) - 1;
 266         if (challenge_len != MSCHAPV2_CHAL_LEN) {
 267                 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Invalid challenge length "
 268                            "%lu", (unsigned long) challenge_len);
 269                 ret->ignore = TRUE;
 270                 return NULL;
 271         }
 272
 273         if (len < challenge_len) {
 274                 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Too short challenge"
 275                            " packet: len=%lu challenge_len=%lu",
 276                            (unsigned long) len, (unsigned long) challenge_len);
 277                 ret->ignore = TRUE;
 278                 return NULL;
 279         }
 280
 281         if (data->passwd_change_challenge_valid) {
 282                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Using challenge from the "
 283                            "failure message");
 284                 challenge = data->passwd_change_challenge;
 285         } else
 286                 challenge = pos;
 287         pos += challenge_len;
 288         len -= challenge_len;
 289         wpa_hexdump_ascii(MSG_DEBUG, "EAP-MSCHAPV2: Authentication Servername",
 290                     pos, len);
 291
 292         ret->ignore = FALSE;
 293         ret->methodState = METHOD_MAY_CONT;
 294         ret->decision = DECISION_FAIL;
 295         ret->allowNotifications = TRUE;
 296
 297         return eap_mschapv2_challenge_reply(sm, data, id, req->mschapv2_id,
 298                                             challenge);
 299 }
 300
 301
 302 static void eap_mschapv2_password_changed(struct eap_sm *sm,
 303                                           struct eap_mschapv2_data *data)
 304 {
 305         struct eap_peer_config *config = eap_get_config(sm);
 306         if (config && config->new_password) {
 307                 wpa_msg(sm->msg_ctx, MSG_INFO,
 308                         WPA_EVENT_PASSWORD_CHANGED
 309                         "EAP-MSCHAPV2: Password changed successfully");
 310                 data->prev_error = 0;
 311                 os_free(config->password);
 312                 if (config->flags & EAP_CONFIG_FLAGS_PASSWORD_NTHASH) {
 313                         config->password = os_malloc(16);
 314                         config->password_len = 16;
 315                         if (config->password) {
 316                                 nt_password_hash(config->new_password,
 317                                                  config->new_password_len,
 318                                                  config->password);
 319                         }
 320                         os_free(config->new_password);
 321                 } else {
 322                         config->password = config->new_password;
 323                         config->password_len = config->new_password_len;
 324                 }
 325                 config->new_password = NULL;
 326                 config->new_password_len = 0;
 327         }
 328 }
 329
 330
 331 /**
 332  * eap_mschapv2_process - Process an EAP-MSCHAPv2 success message
 333  * @sm: Pointer to EAP state machine allocated with eap_peer_sm_init()
 334  * @data: Pointer to private EAP method data from eap_mschapv2_init()
 335  * @ret: Return values from EAP request validation and processing
 336  * @req: Pointer to EAP-MSCHAPv2 header from the request
 337  * @req_len: Length of the EAP-MSCHAPv2 data
 338  * @id: EAP identifier used in th erequest
 339  * Returns: Pointer to allocated EAP response packet (eapRespData) or %NULL if
 340  * no reply available
 341  */
 342 static struct wpabuf * eap_mschapv2_success(struct eap_sm *sm,
 343                                             struct eap_mschapv2_data *data,
 344                                             struct eap_method_ret *ret,
 345                                             const struct eap_mschapv2_hdr *req,
 346                                             size_t req_len, u8 id)
 347 {
 348         struct wpabuf *resp;
 349         const u8 *pos;
 350         size_t len;
 351
 352         wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Received success");
 353         len = req_len - sizeof(*req);
 354         pos = (const u8 *) (req + 1);
 355         if (!data->auth_response_valid ||
 356             mschapv2_verify_auth_response(data->auth_response, pos, len)) {
 357                 wpa_printf(MSG_WARNING, "EAP-MSCHAPV2: Invalid authenticator "
 358                            "response in success request");
 359                 ret->methodState = METHOD_DONE;
 360                 ret->decision = DECISION_FAIL;
 361                 return NULL;
 362         }
 363         pos += 2 + 2 * MSCHAPV2_AUTH_RESPONSE_LEN;
 364         len -= 2 + 2 * MSCHAPV2_AUTH_RESPONSE_LEN;
 365         while (len > 0 && *pos == ' ') {
 366                 pos++;
 367                 len--;
 368         }
 369         wpa_hexdump_ascii(MSG_DEBUG, "EAP-MSCHAPV2: Success message",
 370                           pos, len);
 371         wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Authentication succeeded");
 372
 373         /* Note: Only op_code of the EAP-MSCHAPV2 header is included in success
 374          * message. */
 375         resp = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, 1,
 376                              EAP_CODE_RESPONSE, id);
 377         if (resp == NULL) {
 378                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Failed to allocate "
 379                            "buffer for success response");
 380                 ret->ignore = TRUE;
 381                 return NULL;
 382         }
 383
 384         wpabuf_put_u8(resp, MSCHAPV2_OP_SUCCESS); /* op_code */
 385
 386         ret->methodState = METHOD_DONE;
 387         ret->decision = DECISION_UNCOND_SUCC;
 388         ret->allowNotifications = FALSE;
 389         data->success = 1;
 390
 391         if (data->prev_error == ERROR_PASSWD_EXPIRED)
 392                 eap_mschapv2_password_changed(sm, data);
 393
 394         return resp;
 395 }
 396
 397
 398 static int eap_mschapv2_failure_txt(struct eap_sm *sm,
 399                                     struct eap_mschapv2_data *data, char *txt)
 400 {
 401         char *pos, *msg = "";
 402         int retry = 1;
 403         struct eap_peer_config *config = eap_get_config(sm);
 404
 405         /* For example:
 406          * E=691 R=1 C=<32 octets hex challenge> V=3 M=Authentication Failure
 407          */
 408
 409         pos = txt;
 410
 411         if (pos && os_strncmp(pos, "E=", 2) == 0) {
 412                 pos += 2;
 413                 data->prev_error = atoi(pos);
 414                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: error %d",
 415                            data->prev_error);
 416                 pos = os_strchr(pos, ' ');
 417                 if (pos)
 418                         pos++;
 419         }
 420
 421         if (pos && os_strncmp(pos, "R=", 2) == 0) {
 422                 pos += 2;
 423                 retry = atoi(pos);
 424                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: retry is %sallowed",
 425                            retry == 1 ? "" : "not ");
 426                 pos = os_strchr(pos, ' ');
 427                 if (pos)
 428                         pos++;
 429         }
 430
 431         if (pos && os_strncmp(pos, "C=", 2) == 0) {
 432                 int hex_len;
 433                 pos += 2;
 434                 hex_len = os_strchr(pos, ' ') - (char *) pos;
 435                 if (hex_len == PASSWD_CHANGE_CHAL_LEN * 2) {
 436                         if (hexstr2bin(pos, data->passwd_change_challenge,
 437                                        PASSWD_CHANGE_CHAL_LEN)) {
 438                                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: invalid "
 439                                            "failure challenge");
 440                         } else {
 441                                 wpa_hexdump(MSG_DEBUG, "EAP-MSCHAPV2: failure "
 442                                             "challenge",
 443                                             data->passwd_change_challenge,
 444                                             PASSWD_CHANGE_CHAL_LEN);
 445                                 data->passwd_change_challenge_valid = 1;
 446                         }
 447                 } else {
 448                         wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: invalid failure "
 449                                    "challenge len %d", hex_len);
 450                 }
 451                 pos = os_strchr(pos, ' ');
 452                 if (pos)
 453                         pos++;
 454         } else {
 455                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: required challenge field "
 456                            "was not present in failure message");
 457         }
 458
 459         if (pos && os_strncmp(pos, "V=", 2) == 0) {
 460                 pos += 2;
 461                 data->passwd_change_version = atoi(pos);
 462                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: password changing "
 463                            "protocol version %d", data->passwd_change_version);
 464                 pos = os_strchr(pos, ' ');
 465                 if (pos)
 466                         pos++;
 467         }
 468
 469         if (pos && os_strncmp(pos, "M=", 2) == 0) {
 470                 pos += 2;
 471                 msg = pos;
 472         }
 473         wpa_msg(sm->msg_ctx, MSG_WARNING,
 474                 "EAP-MSCHAPV2: failure message: '%s' (retry %sallowed, error "
 475                 "%d)",
 476                 msg, retry == 1 ? "" : "not ", data->prev_error);
 477         if (data->prev_error == ERROR_PASSWD_EXPIRED &&
 478             data->passwd_change_version == 3 && config) {
 479                 if (config->new_password == NULL) {
 480                         wpa_msg(sm->msg_ctx, MSG_INFO,
 481                                 "EAP-MSCHAPV2: Password expired - password "
 482                                 "change required");
 483                         eap_sm_request_new_password(sm);
 484                 }
 485         } else if (retry == 1 && config) {
 486                 /* TODO: could prevent the current password from being used
 487                  * again at least for some period of time */
 488                 if (!config->mschapv2_retry)
 489                         eap_sm_request_identity(sm);
 490                 eap_sm_request_password(sm);
 491                 config->mschapv2_retry = 1;
 492         } else if (config) {
 493                 /* TODO: prevent retries using same username/password */
 494                 config->mschapv2_retry = 0;
 495         }
 496
 497         return retry == 1;
 498 }
 499
 500
 501 static struct wpabuf * eap_mschapv2_change_password(
 502         struct eap_sm *sm, struct eap_mschapv2_data *data,
 503         struct eap_method_ret *ret, const struct eap_mschapv2_hdr *req, u8 id)
 504 {
 505         struct wpabuf *resp;
 506         int ms_len;
 507         const u8 *username, *password, *new_password;
 508         size_t username_len, password_len, new_password_len;
 509         struct eap_mschapv2_hdr *ms;
 510         struct ms_change_password *cp;
 511         u8 password_hash[16], password_hash_hash[16];
 512         int pwhash;
 513
 514         username = eap_get_config_identity(sm, &username_len);
 515         password = eap_get_config_password2(sm, &password_len, &pwhash);
 516         new_password = eap_get_config_new_password(sm, &new_password_len);
 517         if (username == NULL || password == NULL || new_password == NULL)
 518                 return NULL;
 519
 520         username = mschapv2_remove_domain(username, &username_len);
 521
 522         ret->ignore = FALSE;
 523         ret->methodState = METHOD_MAY_CONT;
 524         ret->decision = DECISION_COND_SUCC;
 525         ret->allowNotifications = TRUE;
 526
 527         ms_len = sizeof(*ms) + sizeof(*cp);
 528         resp = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, ms_len,
 529                              EAP_CODE_RESPONSE, id);
 530         if (resp == NULL)
 531                 return NULL;
 532
 533         ms = wpabuf_put(resp, sizeof(*ms));
 534         ms->op_code = MSCHAPV2_OP_CHANGE_PASSWORD;
 535         ms->mschapv2_id = req->mschapv2_id + 1;
 536         WPA_PUT_BE16(ms->ms_length, ms_len);
 537         cp = wpabuf_put(resp, sizeof(*cp));
 538
 539         /* Encrypted-Password */
 540         if (pwhash) {
 541                 if (encrypt_pw_block_with_password_hash(
 542                             new_password, new_password_len,
 543                             password, cp->encr_password))
 544                         goto fail;
 545         } else {
 546                 if (new_password_encrypted_with_old_nt_password_hash(
 547                             new_password, new_password_len,
 548                             password, password_len, cp->encr_password))
 549                         goto fail;
 550         }
 551
 552         /* Encrypted-Hash */
 553         if (pwhash) {
 554                 u8 new_password_hash[16];
 555                 nt_password_hash(new_password, new_password_len,
 556                                  new_password_hash);
 557                 nt_password_hash_encrypted_with_block(password,
 558                                                       new_password_hash,
 559                                                       cp->encr_hash);
 560         } else {
 561                 old_nt_password_hash_encrypted_with_new_nt_password_hash(
 562                         new_password, new_password_len,
 563                         password, password_len, cp->encr_hash);
 564         }
 565
 566         /* Peer-Challenge */
 567         if (os_get_random(cp->peer_challenge, MSCHAPV2_CHAL_LEN))
 568                 goto fail;
 569
 570         /* Reserved, must be zero */
 571         os_memset(cp->reserved, 0, 8);
 572
 573         /* NT-Response */
 574         wpa_hexdump(MSG_DEBUG, "EAP-MSCHAPV2: auth_challenge",
 575                     data->passwd_change_challenge, PASSWD_CHANGE_CHAL_LEN);
 576         wpa_hexdump(MSG_DEBUG, "EAP-MSCHAPV2: peer_challenge",
 577                     cp->peer_challenge, MSCHAPV2_CHAL_LEN);
 578         wpa_hexdump_ascii(MSG_DEBUG, "EAP-MSCHAPV2: username",
 579                           username, username_len);
 580         wpa_hexdump_ascii_key(MSG_DEBUG, "EAP-MSCHAPV2: new password",
 581                               new_password, new_password_len);
 582         generate_nt_response(data->passwd_change_challenge, cp->peer_challenge,
 583                              username, username_len,
 584                              new_password, new_password_len,
 585                              cp->nt_response);
 586         wpa_hexdump(MSG_DEBUG, "EAP-MSCHAPV2: NT-Response",
 587                     cp->nt_response, MSCHAPV2_NT_RESPONSE_LEN);
 588
 589         /* Authenticator response is not really needed yet, but calculate it
 590          * here so that challenges need not be saved. */
 591         generate_authenticator_response(new_password, new_password_len,
 592                                         cp->peer_challenge,
 593                                         data->passwd_change_challenge,
 594                                         username, username_len,
 595                                         cp->nt_response, data->auth_response);
 596         data->auth_response_valid = 1;
 597
 598         /* Likewise, generate master_key here since we have the needed data
 599          * available. */
 600         nt_password_hash(new_password, new_password_len, password_hash);
 601         hash_nt_password_hash(password_hash, password_hash_hash);
 602         get_master_key(password_hash_hash, cp->nt_response, data->master_key);
 603         data->master_key_valid = 1;
 604
 605         /* Flags */
 606         os_memset(cp->flags, 0, 2);
 607
 608         wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: TX identifier %d mschapv2_id %d "
 609                    "(change pw)", id, ms->mschapv2_id);
 610
 611         return resp;
 612
 613 fail:
 614         wpabuf_free(resp);
 615         return NULL;
 616 }
 617
 618
 619 /**
 620  * eap_mschapv2_process - Process an EAP-MSCHAPv2 failure message
 621  * @sm: Pointer to EAP state machine allocated with eap_peer_sm_init()
 622  * @data: Pointer to private EAP method data from eap_mschapv2_init()
 623  * @ret: Return values from EAP request validation and processing
 624  * @req: Pointer to EAP-MSCHAPv2 header from the request
 625  * @req_len: Length of the EAP-MSCHAPv2 data
 626  * @id: EAP identifier used in th erequest
 627  * Returns: Pointer to allocated EAP response packet (eapRespData) or %NULL if
 628  * no reply available
 629  */
 630 static struct wpabuf * eap_mschapv2_failure(struct eap_sm *sm,
 631                                             struct eap_mschapv2_data *data,
 632                                             struct eap_method_ret *ret,
 633                                             const struct eap_mschapv2_hdr *req,
 634                                             size_t req_len, u8 id)
 635 {
 636         struct wpabuf *resp;
 637         const u8 *msdata = (const u8 *) (req + 1);
 638         char *buf;
 639         size_t len = req_len - sizeof(*req);
 640         int retry = 0;
 641
 642         wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Received failure");
 643         wpa_hexdump_ascii(MSG_DEBUG, "EAP-MSCHAPV2: Failure data",
 644                           msdata, len);
 645         /*
 646          * eap_mschapv2_failure_txt() expects a nul terminated string, so we
 647          * must allocate a large enough temporary buffer to create that since
 648          * the received message does not include nul termination.
 649          */
 650         buf = os_malloc(len + 1);
 651         if (buf) {
 652                 os_memcpy(buf, msdata, len);
 653                 buf[len] = '\0';
 654                 retry = eap_mschapv2_failure_txt(sm, data, buf);
 655                 os_free(buf);
 656         }
 657
 658         ret->ignore = FALSE;
 659         ret->methodState = METHOD_DONE;
 660         ret->decision = DECISION_FAIL;
 661         ret->allowNotifications = FALSE;
 662
 663         if (data->prev_error == ERROR_PASSWD_EXPIRED &&
 664             data->passwd_change_version == 3) {
 665                 struct eap_peer_config *config = eap_get_config(sm);
 666                 if (config && config->new_password)
 667                         return eap_mschapv2_change_password(sm, data, ret, req,
 668                                                             id);
 669                 if (config && config->pending_req_new_password)
 670                         return NULL;
 671         } else if (retry && data->prev_error == ERROR_AUTHENTICATION_FAILURE) {
 672                 /* TODO: could try to retry authentication, e.g, after having
 673                  * changed the username/password. In this case, EAP MS-CHAP-v2
 674                  * Failure Response would not be sent here. */
 675                 return NULL;
 676         }
 677
 678         /* Note: Only op_code of the EAP-MSCHAPV2 header is included in failure
 679          * message. */
 680         resp = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, 1,
 681                              EAP_CODE_RESPONSE, id);
 682         if (resp == NULL)
 683                 return NULL;
 684
 685         wpabuf_put_u8(resp, MSCHAPV2_OP_FAILURE); /* op_code */
 686
 687         return resp;
 688 }
 689
 690
 691 static int eap_mschapv2_check_config(struct eap_sm *sm)
 692 {
 693         size_t len;
 694
 695         if (eap_get_config_identity(sm, &len) == NULL) {
 696                 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Identity not configured");
 697                 eap_sm_request_identity(sm);
 698                 return -1;
 699         }
 700
 701         if (eap_get_config_password(sm, &len) == NULL) {
 702                 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Password not configured");
 703                 eap_sm_request_password(sm);
 704                 return -1;
 705         }
 706
 707         return 0;
 708 }
 709
 710
 711 static int eap_mschapv2_check_mslen(struct eap_sm *sm, size_t len,
 712                                     const struct eap_mschapv2_hdr *ms)
 713 {
 714         size_t ms_len = WPA_GET_BE16(ms->ms_length);
 715
 716         if (ms_len == len)
 717                 return 0;
 718
 719         wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Invalid header: len=%lu "
 720                    "ms_len=%lu", (unsigned long) len, (unsigned long) ms_len);
 721         if (sm->workaround) {
 722                 /* Some authentication servers use invalid ms_len,
 723                  * ignore it for interoperability. */
 724                 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: workaround, ignore"
 725                            " invalid ms_len %lu (len %lu)",
 726                            (unsigned long) ms_len,
 727                            (unsigned long) len);
 728                 return 0;
 729         }
 730
 731         return -1;
 732 }
 733
 734
 735 static void eap_mschapv2_copy_challenge(struct eap_mschapv2_data *data,
 736                                         const struct wpabuf *reqData)
 737 {
 738         /*
 739          * Store a copy of the challenge message, so that it can be processed
 740          * again in case retry is allowed after a possible failure.
 741          */
 742         wpabuf_free(data->prev_challenge);
 743         data->prev_challenge = wpabuf_dup(reqData);
 744 }
 745
 746
 747 /**
 748  * eap_mschapv2_process - Process an EAP-MSCHAPv2 request
 749  * @sm: Pointer to EAP state machine allocated with eap_peer_sm_init()
 750  * @priv: Pointer to private EAP method data from eap_mschapv2_init()
 751  * @ret: Return values from EAP request validation and processing
 752  * @reqData: EAP request to be processed (eapReqData)
 753  * Returns: Pointer to allocated EAP response packet (eapRespData) or %NULL if
 754  * no reply available
 755  */
 756 static struct wpabuf * eap_mschapv2_process(struct eap_sm *sm, void *priv,
 757                                             struct eap_method_ret *ret,
 758                                             const struct wpabuf *reqData)
 759 {
 760         struct eap_mschapv2_data *data = priv;
 761         struct eap_peer_config *config = eap_get_config(sm);
 762         const struct eap_mschapv2_hdr *ms;
 763         int using_prev_challenge = 0;
 764         const u8 *pos;
 765         size_t len;
 766         u8 id;
 767
 768         if (eap_mschapv2_check_config(sm)) {
 769                 ret->ignore = TRUE;
 770                 return NULL;
 771         }
 772
 773         if (config->mschapv2_retry && data->prev_challenge &&
 774             data->prev_error == ERROR_AUTHENTICATION_FAILURE) {
 775                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Replacing pending packet "
 776                            "with the previous challenge");
 777
 778                 reqData = data->prev_challenge;
 779                 using_prev_challenge = 1;
 780                 config->mschapv2_retry = 0;
 781         }
 782
 783         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, reqData,
 784                                &len);
 785         if (pos == NULL || len < sizeof(*ms) + 1) {
 786                 ret->ignore = TRUE;
 787                 return NULL;
 788         }
 789
 790         ms = (const struct eap_mschapv2_hdr *) pos;
 791         if (eap_mschapv2_check_mslen(sm, len, ms)) {
 792                 ret->ignore = TRUE;
 793                 return NULL;
 794         }
 795
 796         id = eap_get_id(reqData);
 797         wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: RX identifier %d mschapv2_id %d",
 798                    id, ms->mschapv2_id);
 799
 800         switch (ms->op_code) {
 801         case MSCHAPV2_OP_CHALLENGE:
 802                 if (!using_prev_challenge)
 803                         eap_mschapv2_copy_challenge(data, reqData);
 804                 return eap_mschapv2_challenge(sm, data, ret, ms, len, id);
 805         case MSCHAPV2_OP_SUCCESS:
 806                 return eap_mschapv2_success(sm, data, ret, ms, len, id);
 807         case MSCHAPV2_OP_FAILURE:
 808                 return eap_mschapv2_failure(sm, data, ret, ms, len, id);
 809         default:
 810                 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Unknown op %d - ignored",
 811                            ms->op_code);
 812                 ret->ignore = TRUE;
 813                 return NULL;
 814         }
 815 }
 816
 817
 818 static Boolean eap_mschapv2_isKeyAvailable(struct eap_sm *sm, void *priv)
 819 {
 820         struct eap_mschapv2_data *data = priv;
 821         return data->success && data->master_key_valid;
 822 }
 823
 824
 825 static u8 * eap_mschapv2_getKey(struct eap_sm *sm, void *priv, size_t *len)
 826 {
 827         struct eap_mschapv2_data *data = priv;
 828         u8 *key;
 829         int key_len;
 830
 831         if (!data->master_key_valid || !data->success)
 832                 return NULL;
 833
 834         key_len = 2 * MSCHAPV2_KEY_LEN;
 835
 836         key = os_malloc(key_len);
 837         if (key == NULL)
 838                 return NULL;
 839
 840         /* MSK = server MS-MPPE-Recv-Key | MS-MPPE-Send-Key, i.e.,
 841          *      peer MS-MPPE-Send-Key | MS-MPPE-Recv-Key */
 842         get_asymetric_start_key(data->master_key, key, MSCHAPV2_KEY_LEN, 1, 0);
 843         get_asymetric_start_key(data->master_key, key + MSCHAPV2_KEY_LEN,
 844                                 MSCHAPV2_KEY_LEN, 0, 0);
 845
 846         wpa_hexdump_key(MSG_DEBUG, "EAP-MSCHAPV2: Derived key",
 847                         key, key_len);
 848
 849         *len = key_len;
 850         return key;
 851 }
 852
 853
 854 /**
 855  * eap_peer_mschapv2_register - Register EAP-MSCHAPv2 peer method
 856  * Returns: 0 on success, -1 on failure
 857  *
 858  * This function is used to register EAP-MSCHAPv2 peer method into the EAP
 859  * method list.
 860  */
 861 int eap_peer_mschapv2_register(void)
 862 {
 863         struct eap_method *eap;
 864         int ret;
 865
 866         eap = eap_peer_method_alloc(EAP_PEER_METHOD_INTERFACE_VERSION,
 867                                     EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2,
 868                                     "MSCHAPV2");
 869         if (eap == NULL)
 870                 return -1;
 871
 872         eap->init = eap_mschapv2_init;
 873         eap->deinit = eap_mschapv2_deinit;
 874         eap->process = eap_mschapv2_process;
 875         eap->isKeyAvailable = eap_mschapv2_isKeyAvailable;
 876         eap->getKey = eap_mschapv2_getKey;
 877
 878         ret = eap_peer_method_register(eap);
 879         if (ret)
 880                 eap_peer_method_free(eap);
 881         return ret;
 882 }