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