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