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
eap_mschapv2_init(struct eap_sm * sm)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
eap_mschapv2_deinit(struct eap_sm * sm,void * priv)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
eap_mschapv2_challenge_reply(struct eap_sm * sm,struct eap_mschapv2_data * data,u8 id,u8 mschapv2_id,const u8 * auth_challenge)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 */
eap_mschapv2_challenge(struct eap_sm * sm,struct eap_mschapv2_data * data,struct eap_method_ret * ret,const struct eap_mschapv2_hdr * req,size_t req_len,u8 id)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
eap_mschapv2_password_changed(struct eap_sm * sm,struct eap_mschapv2_data * data)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 */
eap_mschapv2_success(struct eap_sm * sm,struct eap_mschapv2_data * data,struct eap_method_ret * ret,const struct eap_mschapv2_hdr * req,size_t req_len,u8 id)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
eap_mschapv2_failure_txt(struct eap_sm * sm,struct eap_mschapv2_data * data,char * txt)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 wpa_msg(sm->msg_ctx, MSG_WARNING,
476 "EAP-MSCHAPV2: failure message: '%s' (retry %sallowed, error "
477 "%d)",
478 msg, retry == 1 ? "" : "not ", data->prev_error);
479 if (data->prev_error == ERROR_PASSWD_EXPIRED &&
480 data->passwd_change_version == 3 && config) {
481 if (config->new_password == NULL) {
482 wpa_msg(sm->msg_ctx, MSG_INFO,
483 "EAP-MSCHAPV2: Password expired - password "
484 "change required");
485 eap_sm_request_new_password(sm);
486 }
487 } else if (retry == 1 && config) {
488 /* TODO: could prevent the current password from being used
489 * again at least for some period of time */
490 if (!config->mschapv2_retry)
491 eap_sm_request_identity(sm);
492 eap_sm_request_password(sm);
493 config->mschapv2_retry = 1;
494 } else if (config) {
495 /* TODO: prevent retries using same username/password */
496 config->mschapv2_retry = 0;
497 }
498
499 return retry == 1;
500 }
501
502
eap_mschapv2_change_password(struct eap_sm * sm,struct eap_mschapv2_data * data,struct eap_method_ret * ret,const struct eap_mschapv2_hdr * req,u8 id)503 static struct wpabuf * eap_mschapv2_change_password(
504 struct eap_sm *sm, struct eap_mschapv2_data *data,
505 struct eap_method_ret *ret, const struct eap_mschapv2_hdr *req, u8 id)
506 {
507 struct wpabuf *resp;
508 int ms_len;
509 const u8 *username, *password, *new_password;
510 size_t username_len, password_len, new_password_len;
511 struct eap_mschapv2_hdr *ms;
512 struct ms_change_password *cp;
513 u8 password_hash[16], password_hash_hash[16];
514 int pwhash;
515
516 username = eap_get_config_identity(sm, &username_len);
517 password = eap_get_config_password2(sm, &password_len, &pwhash);
518 new_password = eap_get_config_new_password(sm, &new_password_len);
519 if (username == NULL || password == NULL || new_password == NULL)
520 return NULL;
521
522 username = mschapv2_remove_domain(username, &username_len);
523
524 ret->ignore = FALSE;
525 ret->methodState = METHOD_MAY_CONT;
526 ret->decision = DECISION_COND_SUCC;
527 ret->allowNotifications = TRUE;
528
529 ms_len = sizeof(*ms) + sizeof(*cp);
530 resp = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, ms_len,
531 EAP_CODE_RESPONSE, id);
532 if (resp == NULL)
533 return NULL;
534
535 ms = wpabuf_put(resp, sizeof(*ms));
536 ms->op_code = MSCHAPV2_OP_CHANGE_PASSWORD;
537 ms->mschapv2_id = req->mschapv2_id + 1;
538 WPA_PUT_BE16(ms->ms_length, ms_len);
539 cp = wpabuf_put(resp, sizeof(*cp));
540
541 /* Encrypted-Password */
542 if (pwhash) {
543 if (encrypt_pw_block_with_password_hash(
544 new_password, new_password_len,
545 password, cp->encr_password))
546 goto fail;
547 } else {
548 if (new_password_encrypted_with_old_nt_password_hash(
549 new_password, new_password_len,
550 password, password_len, cp->encr_password))
551 goto fail;
552 }
553
554 /* Encrypted-Hash */
555 if (pwhash) {
556 u8 new_password_hash[16];
557 if (nt_password_hash(new_password, new_password_len,
558 new_password_hash))
559 goto fail;
560 nt_password_hash_encrypted_with_block(password,
561 new_password_hash,
562 cp->encr_hash);
563 } else {
564 if (old_nt_password_hash_encrypted_with_new_nt_password_hash(
565 new_password, new_password_len,
566 password, password_len, cp->encr_hash))
567 goto fail;
568 }
569
570 /* Peer-Challenge */
571 if (random_get_bytes(cp->peer_challenge, MSCHAPV2_CHAL_LEN))
572 goto fail;
573
574 /* Reserved, must be zero */
575 os_memset(cp->reserved, 0, 8);
576
577 /* NT-Response */
578 wpa_hexdump(MSG_DEBUG, "EAP-MSCHAPV2: auth_challenge",
579 data->passwd_change_challenge, PASSWD_CHANGE_CHAL_LEN);
580 wpa_hexdump(MSG_DEBUG, "EAP-MSCHAPV2: peer_challenge",
581 cp->peer_challenge, MSCHAPV2_CHAL_LEN);
582 wpa_hexdump_ascii(MSG_DEBUG, "EAP-MSCHAPV2: username",
583 username, username_len);
584 wpa_hexdump_ascii_key(MSG_DEBUG, "EAP-MSCHAPV2: new password",
585 new_password, new_password_len);
586 generate_nt_response(data->passwd_change_challenge, cp->peer_challenge,
587 username, username_len,
588 new_password, new_password_len,
589 cp->nt_response);
590 wpa_hexdump(MSG_DEBUG, "EAP-MSCHAPV2: NT-Response",
591 cp->nt_response, MSCHAPV2_NT_RESPONSE_LEN);
592
593 /* Authenticator response is not really needed yet, but calculate it
594 * here so that challenges need not be saved. */
595 generate_authenticator_response(new_password, new_password_len,
596 cp->peer_challenge,
597 data->passwd_change_challenge,
598 username, username_len,
599 cp->nt_response, data->auth_response);
600 data->auth_response_valid = 1;
601
602 /* Likewise, generate master_key here since we have the needed data
603 * available. */
604 if (nt_password_hash(new_password, new_password_len, password_hash) ||
605 hash_nt_password_hash(password_hash, password_hash_hash) ||
606 get_master_key(password_hash_hash, cp->nt_response,
607 data->master_key)) {
608 data->auth_response_valid = 0;
609 goto fail;
610 }
611 data->master_key_valid = 1;
612
613 /* Flags */
614 os_memset(cp->flags, 0, 2);
615
616 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: TX identifier %d mschapv2_id %d "
617 "(change pw)", id, ms->mschapv2_id);
618
619 return resp;
620
621 fail:
622 wpabuf_free(resp);
623 return NULL;
624 }
625
626
627 /**
628 * eap_mschapv2_process - Process an EAP-MSCHAPv2 failure message
629 * @sm: Pointer to EAP state machine allocated with eap_peer_sm_init()
630 * @data: Pointer to private EAP method data from eap_mschapv2_init()
631 * @ret: Return values from EAP request validation and processing
632 * @req: Pointer to EAP-MSCHAPv2 header from the request
633 * @req_len: Length of the EAP-MSCHAPv2 data
634 * @id: EAP identifier used in th erequest
635 * Returns: Pointer to allocated EAP response packet (eapRespData) or %NULL if
636 * no reply available
637 */
eap_mschapv2_failure(struct eap_sm * sm,struct eap_mschapv2_data * data,struct eap_method_ret * ret,const struct eap_mschapv2_hdr * req,size_t req_len,u8 id)638 static struct wpabuf * eap_mschapv2_failure(struct eap_sm *sm,
639 struct eap_mschapv2_data *data,
640 struct eap_method_ret *ret,
641 const struct eap_mschapv2_hdr *req,
642 size_t req_len, u8 id)
643 {
644 struct wpabuf *resp;
645 const u8 *msdata = (const u8 *) (req + 1);
646 char *buf;
647 size_t len = req_len - sizeof(*req);
648 int retry = 0;
649
650 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Received failure");
651 wpa_hexdump_ascii(MSG_DEBUG, "EAP-MSCHAPV2: Failure data",
652 msdata, len);
653 /*
654 * eap_mschapv2_failure_txt() expects a nul terminated string, so we
655 * must allocate a large enough temporary buffer to create that since
656 * the received message does not include nul termination.
657 */
658 buf = dup_binstr(msdata, len);
659 if (buf) {
660 retry = eap_mschapv2_failure_txt(sm, data, buf);
661 os_free(buf);
662 }
663
664 ret->ignore = FALSE;
665 ret->methodState = METHOD_DONE;
666 ret->decision = DECISION_FAIL;
667 ret->allowNotifications = FALSE;
668
669 if (data->prev_error == ERROR_PASSWD_EXPIRED &&
670 data->passwd_change_version == 3) {
671 struct eap_peer_config *config = eap_get_config(sm);
672 if (config && config->new_password)
673 return eap_mschapv2_change_password(sm, data, ret, req,
674 id);
675 if (config && config->pending_req_new_password)
676 return NULL;
677 } else if (retry && data->prev_error == ERROR_AUTHENTICATION_FAILURE) {
678 /* TODO: could try to retry authentication, e.g, after having
679 * changed the username/password. In this case, EAP MS-CHAP-v2
680 * Failure Response would not be sent here. */
681 return NULL;
682 }
683
684 /* Note: Only op_code of the EAP-MSCHAPV2 header is included in failure
685 * message. */
686 resp = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, 1,
687 EAP_CODE_RESPONSE, id);
688 if (resp == NULL)
689 return NULL;
690
691 wpabuf_put_u8(resp, MSCHAPV2_OP_FAILURE); /* op_code */
692
693 return resp;
694 }
695
696
eap_mschapv2_check_config(struct eap_sm * sm)697 static int eap_mschapv2_check_config(struct eap_sm *sm)
698 {
699 size_t len;
700
701 if (eap_get_config_identity(sm, &len) == NULL) {
702 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Identity not configured");
703 eap_sm_request_identity(sm);
704 return -1;
705 }
706
707 if (eap_get_config_password(sm, &len) == NULL) {
708 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Password not configured");
709 eap_sm_request_password(sm);
710 return -1;
711 }
712
713 return 0;
714 }
715
716
eap_mschapv2_check_mslen(struct eap_sm * sm,size_t len,const struct eap_mschapv2_hdr * ms)717 static int eap_mschapv2_check_mslen(struct eap_sm *sm, size_t len,
718 const struct eap_mschapv2_hdr *ms)
719 {
720 size_t ms_len = WPA_GET_BE16(ms->ms_length);
721
722 if (ms_len == len)
723 return 0;
724
725 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Invalid header: len=%lu "
726 "ms_len=%lu", (unsigned long) len, (unsigned long) ms_len);
727 if (sm->workaround) {
728 /* Some authentication servers use invalid ms_len,
729 * ignore it for interoperability. */
730 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: workaround, ignore"
731 " invalid ms_len %lu (len %lu)",
732 (unsigned long) ms_len,
733 (unsigned long) len);
734 return 0;
735 }
736
737 return -1;
738 }
739
740
eap_mschapv2_copy_challenge(struct eap_mschapv2_data * data,const struct wpabuf * reqData)741 static void eap_mschapv2_copy_challenge(struct eap_mschapv2_data *data,
742 const struct wpabuf *reqData)
743 {
744 /*
745 * Store a copy of the challenge message, so that it can be processed
746 * again in case retry is allowed after a possible failure.
747 */
748 wpabuf_free(data->prev_challenge);
749 data->prev_challenge = wpabuf_dup(reqData);
750 }
751
752
753 /**
754 * eap_mschapv2_process - Process an EAP-MSCHAPv2 request
755 * @sm: Pointer to EAP state machine allocated with eap_peer_sm_init()
756 * @priv: Pointer to private EAP method data from eap_mschapv2_init()
757 * @ret: Return values from EAP request validation and processing
758 * @reqData: EAP request to be processed (eapReqData)
759 * Returns: Pointer to allocated EAP response packet (eapRespData) or %NULL if
760 * no reply available
761 */
eap_mschapv2_process(struct eap_sm * sm,void * priv,struct eap_method_ret * ret,const struct wpabuf * reqData)762 static struct wpabuf * eap_mschapv2_process(struct eap_sm *sm, void *priv,
763 struct eap_method_ret *ret,
764 const struct wpabuf *reqData)
765 {
766 struct eap_mschapv2_data *data = priv;
767 struct eap_peer_config *config = eap_get_config(sm);
768 const struct eap_mschapv2_hdr *ms;
769 int using_prev_challenge = 0;
770 const u8 *pos;
771 size_t len;
772 u8 id;
773
774 if (eap_mschapv2_check_config(sm)) {
775 ret->ignore = TRUE;
776 return NULL;
777 }
778
779 if (config->mschapv2_retry && data->prev_challenge &&
780 data->prev_error == ERROR_AUTHENTICATION_FAILURE) {
781 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Replacing pending packet "
782 "with the previous challenge");
783
784 reqData = data->prev_challenge;
785 using_prev_challenge = 1;
786 config->mschapv2_retry = 0;
787 }
788
789 pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, reqData,
790 &len);
791 if (pos == NULL || len < sizeof(*ms) + 1) {
792 ret->ignore = TRUE;
793 return NULL;
794 }
795
796 ms = (const struct eap_mschapv2_hdr *) pos;
797 if (eap_mschapv2_check_mslen(sm, len, ms)) {
798 ret->ignore = TRUE;
799 return NULL;
800 }
801
802 id = eap_get_id(reqData);
803 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: RX identifier %d mschapv2_id %d",
804 id, ms->mschapv2_id);
805
806 switch (ms->op_code) {
807 case MSCHAPV2_OP_CHALLENGE:
808 if (!using_prev_challenge)
809 eap_mschapv2_copy_challenge(data, reqData);
810 return eap_mschapv2_challenge(sm, data, ret, ms, len, id);
811 case MSCHAPV2_OP_SUCCESS:
812 return eap_mschapv2_success(sm, data, ret, ms, len, id);
813 case MSCHAPV2_OP_FAILURE:
814 return eap_mschapv2_failure(sm, data, ret, ms, len, id);
815 default:
816 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Unknown op %d - ignored",
817 ms->op_code);
818 ret->ignore = TRUE;
819 return NULL;
820 }
821 }
822
823
eap_mschapv2_isKeyAvailable(struct eap_sm * sm,void * priv)824 static Boolean eap_mschapv2_isKeyAvailable(struct eap_sm *sm, void *priv)
825 {
826 struct eap_mschapv2_data *data = priv;
827 return data->success && data->master_key_valid;
828 }
829
830
eap_mschapv2_getKey(struct eap_sm * sm,void * priv,size_t * len)831 static u8 * eap_mschapv2_getKey(struct eap_sm *sm, void *priv, size_t *len)
832 {
833 struct eap_mschapv2_data *data = priv;
834 u8 *key;
835 int key_len;
836
837 if (!data->master_key_valid || !data->success)
838 return NULL;
839
840 key_len = 2 * MSCHAPV2_KEY_LEN;
841
842 key = os_malloc(key_len);
843 if (key == NULL)
844 return NULL;
845
846 /* MSK = server MS-MPPE-Recv-Key | MS-MPPE-Send-Key, i.e.,
847 * peer MS-MPPE-Send-Key | MS-MPPE-Recv-Key */
848 get_asymetric_start_key(data->master_key, key, MSCHAPV2_KEY_LEN, 1, 0);
849 get_asymetric_start_key(data->master_key, key + MSCHAPV2_KEY_LEN,
850 MSCHAPV2_KEY_LEN, 0, 0);
851
852 wpa_hexdump_key(MSG_DEBUG, "EAP-MSCHAPV2: Derived key",
853 key, key_len);
854
855 *len = key_len;
856 return key;
857 }
858
859
860 /**
861 * eap_peer_mschapv2_register - Register EAP-MSCHAPv2 peer method
862 * Returns: 0 on success, -1 on failure
863 *
864 * This function is used to register EAP-MSCHAPv2 peer method into the EAP
865 * method list.
866 */
eap_peer_mschapv2_register(void)867 int eap_peer_mschapv2_register(void)
868 {
869 struct eap_method *eap;
870 int ret;
871
872 eap = eap_peer_method_alloc(EAP_PEER_METHOD_INTERFACE_VERSION,
873 EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2,
874 "MSCHAPV2");
875 if (eap == NULL)
876 return -1;
877
878 eap->init = eap_mschapv2_init;
879 eap->deinit = eap_mschapv2_deinit;
880 eap->process = eap_mschapv2_process;
881 eap->isKeyAvailable = eap_mschapv2_isKeyAvailable;
882 eap->getKey = eap_mschapv2_getKey;
883
884 ret = eap_peer_method_register(eap);
885 if (ret)
886 eap_peer_method_free(eap);
887 return ret;
888 }
889