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 	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 
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)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  */
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)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 
eap_mschapv2_check_config(struct eap_sm * sm)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 
eap_mschapv2_check_mslen(struct eap_sm * sm,size_t len,const struct eap_mschapv2_hdr * ms)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 
eap_mschapv2_copy_challenge(struct eap_mschapv2_data * data,const struct wpabuf * reqData)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  */
eap_mschapv2_process(struct eap_sm * sm,void * priv,struct eap_method_ret * ret,const struct wpabuf * reqData)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 
eap_mschapv2_isKeyAvailable(struct eap_sm * sm,void * priv)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 
eap_mschapv2_getKey(struct eap_sm * sm,void * priv,size_t * len)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  */
eap_peer_mschapv2_register(void)880 int eap_peer_mschapv2_register(void)
881 {
882 	struct eap_method *eap;
883 
884 	eap = eap_peer_method_alloc(EAP_PEER_METHOD_INTERFACE_VERSION,
885 				    EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2,
886 				    "MSCHAPV2");
887 	if (eap == NULL)
888 		return -1;
889 
890 	eap->init = eap_mschapv2_init;
891 	eap->deinit = eap_mschapv2_deinit;
892 	eap->process = eap_mschapv2_process;
893 	eap->isKeyAvailable = eap_mschapv2_isKeyAvailable;
894 	eap->getKey = eap_mschapv2_getKey;
895 
896 	return eap_peer_method_register(eap);
897 }
898