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
31struct 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 */
40struct 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 */
48struct 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
78struct 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
101static void eap_mschapv2_deinit(struct eap_sm *sm, void *priv);
102
103
104static 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
137static 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
147static 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 */
239static 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
297static 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 */
344static 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
400static 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
510static 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
633fail:
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 */
651static 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
710static 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
730static 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
754static 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 */
775static 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
837static 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
844static 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 */
880int 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