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