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