libeap/src/eap_server/eap_server_mschapv2.c

   1 /*
   2  * hostapd / EAP-MSCHAPv2 (draft-kamath-pppext-eap-mschapv2-00.txt) server
   3  * Copyright (c) 2004-2007, 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
   9 #include "includes.h"
  10
  11 #include "common.h"
  12 #include "crypto/ms_funcs.h"
  13 #include "crypto/random.h"
  14 #include "eap_i.h"
  15
  16
  17 struct eap_mschapv2_hdr {
  18         u8 op_code; /* MSCHAPV2_OP_* */
  19         u8 mschapv2_id; /* must be changed for challenges, but not for
  20                          * success/failure */
  21         u8 ms_length[2]; /* Note: misaligned; length - 5 */
  22         /* followed by data */
  23 } STRUCT_PACKED;
  24
  25 #define MSCHAPV2_OP_CHALLENGE 1
  26 #define MSCHAPV2_OP_RESPONSE 2
  27 #define MSCHAPV2_OP_SUCCESS 3
  28 #define MSCHAPV2_OP_FAILURE 4
  29 #define MSCHAPV2_OP_CHANGE_PASSWORD 7
  30
  31 #define MSCHAPV2_RESP_LEN 49
  32
  33 #define ERROR_RESTRICTED_LOGON_HOURS 646
  34 #define ERROR_ACCT_DISABLED 647
  35 #define ERROR_PASSWD_EXPIRED 648
  36 #define ERROR_NO_DIALIN_PERMISSION 649
  37 #define ERROR_AUTHENTICATION_FAILURE 691
  38 #define ERROR_CHANGING_PASSWORD 709
  39
  40 #define PASSWD_CHANGE_CHAL_LEN 16
  41 #define MSCHAPV2_KEY_LEN 16
  42
  43
  44 #define CHALLENGE_LEN 16
  45
  46 struct eap_mschapv2_data {
  47         u8 auth_challenge[CHALLENGE_LEN];
  48         int auth_challenge_from_tls;
  49         u8 *peer_challenge;
  50         u8 auth_response[20];
  51         enum { CHALLENGE, SUCCESS_REQ, FAILURE_REQ, SUCCESS, FAILURE } state;
  52         u8 resp_mschapv2_id;
  53         u8 master_key[16];
  54         int master_key_valid;
  55 };
  56
  57
  58 static void * eap_mschapv2_init(struct eap_sm *sm)
  59 {
  60         struct eap_mschapv2_data *data;
  61
  62         data = os_zalloc(sizeof(*data));
  63         if (data == NULL)
  64                 return NULL;
  65         data->state = CHALLENGE;
  66
  67         if (sm->auth_challenge) {
  68                 os_memcpy(data->auth_challenge, sm->auth_challenge,
  69                           CHALLENGE_LEN);
  70                 data->auth_challenge_from_tls = 1;
  71         }
  72
  73         if (sm->peer_challenge) {
  74                 data->peer_challenge = os_malloc(CHALLENGE_LEN);
  75                 if (data->peer_challenge == NULL) {
  76                         os_free(data);
  77                         return NULL;
  78                 }
  79                 os_memcpy(data->peer_challenge, sm->peer_challenge,
  80                           CHALLENGE_LEN);
  81         }
  82
  83         return data;
  84 }
  85
  86
  87 static void eap_mschapv2_reset(struct eap_sm *sm, void *priv)
  88 {
  89         struct eap_mschapv2_data *data = priv;
  90         if (data == NULL)
  91                 return;
  92
  93         os_free(data->peer_challenge);
  94         bin_clear_free(data, sizeof(*data));
  95 }
  96
  97
  98 static struct wpabuf * eap_mschapv2_build_challenge(
  99         struct eap_sm *sm, struct eap_mschapv2_data *data, u8 id)
 100 {
 101         struct wpabuf *req;
 102         struct eap_mschapv2_hdr *ms;
 103         size_t ms_len;
 104
 105         if (!data->auth_challenge_from_tls &&
 106             random_get_bytes(data->auth_challenge, CHALLENGE_LEN)) {
 107                 wpa_printf(MSG_ERROR, "EAP-MSCHAPV2: Failed to get random "
 108                            "data");
 109                 data->state = FAILURE;
 110                 return NULL;
 111         }
 112
 113         ms_len = sizeof(*ms) + 1 + CHALLENGE_LEN + sm->server_id_len;
 114         req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, ms_len,
 115                             EAP_CODE_REQUEST, id);
 116         if (req == NULL) {
 117                 wpa_printf(MSG_ERROR, "EAP-MSCHAPV2: Failed to allocate memory"
 118                            " for request");
 119                 data->state = FAILURE;
 120                 return NULL;
 121         }
 122
 123         ms = wpabuf_put(req, sizeof(*ms));
 124         ms->op_code = MSCHAPV2_OP_CHALLENGE;
 125         ms->mschapv2_id = id;
 126         WPA_PUT_BE16(ms->ms_length, ms_len);
 127
 128         wpabuf_put_u8(req, CHALLENGE_LEN);
 129         if (!data->auth_challenge_from_tls)
 130                 wpabuf_put_data(req, data->auth_challenge, CHALLENGE_LEN);
 131         else
 132                 wpabuf_put(req, CHALLENGE_LEN);
 133         wpa_hexdump(MSG_MSGDUMP, "EAP-MSCHAPV2: Challenge",
 134                     data->auth_challenge, CHALLENGE_LEN);
 135         wpabuf_put_data(req, sm->server_id, sm->server_id_len);
 136
 137         return req;
 138 }
 139
 140
 141 static struct wpabuf * eap_mschapv2_build_success_req(
 142         struct eap_sm *sm, struct eap_mschapv2_data *data, u8 id)
 143 {
 144         struct wpabuf *req;
 145         struct eap_mschapv2_hdr *ms;
 146         u8 *msg;
 147         char *message = "OK";
 148         size_t ms_len;
 149
 150         ms_len = sizeof(*ms) + 2 + 2 * sizeof(data->auth_response) + 1 + 2 +
 151                 os_strlen(message);
 152         req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, ms_len,
 153                             EAP_CODE_REQUEST, id);
 154         if (req == NULL) {
 155                 wpa_printf(MSG_ERROR, "EAP-MSCHAPV2: Failed to allocate memory"
 156                            " for request");
 157                 data->state = FAILURE;
 158                 return NULL;
 159         }
 160
 161         ms = wpabuf_put(req, sizeof(*ms));
 162         ms->op_code = MSCHAPV2_OP_SUCCESS;
 163         ms->mschapv2_id = data->resp_mschapv2_id;
 164         WPA_PUT_BE16(ms->ms_length, ms_len);
 165         msg = (u8 *) (ms + 1);
 166
 167         wpabuf_put_u8(req, 'S');
 168         wpabuf_put_u8(req, '=');
 169         wpa_snprintf_hex_uppercase(
 170                 wpabuf_put(req, sizeof(data->auth_response) * 2),
 171                 sizeof(data->auth_response) * 2 + 1,
 172                 data->auth_response, sizeof(data->auth_response));
 173         wpabuf_put_u8(req, ' ');
 174         wpabuf_put_u8(req, 'M');
 175         wpabuf_put_u8(req, '=');
 176         wpabuf_put_data(req, message, os_strlen(message));
 177
 178         wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-MSCHAPV2: Success Request Message",
 179                           msg, ms_len - sizeof(*ms));
 180
 181         return req;
 182 }
 183
 184
 185 static struct wpabuf * eap_mschapv2_build_failure_req(
 186         struct eap_sm *sm, struct eap_mschapv2_data *data, u8 id)
 187 {
 188         struct wpabuf *req;
 189         struct eap_mschapv2_hdr *ms;
 190         char *message = "E=691 R=0 C=00000000000000000000000000000000 V=3 "
 191                 "M=FAILED";
 192         size_t ms_len;
 193
 194         ms_len = sizeof(*ms) + os_strlen(message);
 195         req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, ms_len,
 196                             EAP_CODE_REQUEST, id);
 197         if (req == NULL) {
 198                 wpa_printf(MSG_ERROR, "EAP-MSCHAPV2: Failed to allocate memory"
 199                            " for request");
 200                 data->state = FAILURE;
 201                 return NULL;
 202         }
 203
 204         ms = wpabuf_put(req, sizeof(*ms));
 205         ms->op_code = MSCHAPV2_OP_FAILURE;
 206         ms->mschapv2_id = data->resp_mschapv2_id;
 207         WPA_PUT_BE16(ms->ms_length, ms_len);
 208
 209         wpabuf_put_data(req, message, os_strlen(message));
 210
 211         wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-MSCHAPV2: Failure Request Message",
 212                           (u8 *) message, os_strlen(message));
 213
 214         return req;
 215 }
 216
 217
 218 static struct wpabuf * eap_mschapv2_buildReq(struct eap_sm *sm, void *priv,
 219                                              u8 id)
 220 {
 221         struct eap_mschapv2_data *data = priv;
 222
 223         switch (data->state) {
 224         case CHALLENGE:
 225                 return eap_mschapv2_build_challenge(sm, data, id);
 226         case SUCCESS_REQ:
 227                 return eap_mschapv2_build_success_req(sm, data, id);
 228         case FAILURE_REQ:
 229                 return eap_mschapv2_build_failure_req(sm, data, id);
 230         default:
 231                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Unknown state %d in "
 232                            "buildReq", data->state);
 233                 break;
 234         }
 235         return NULL;
 236 }
 237
 238
 239 static Boolean eap_mschapv2_check(struct eap_sm *sm, void *priv,
 240                                   struct wpabuf *respData)
 241 {
 242         struct eap_mschapv2_data *data = priv;
 243         struct eap_mschapv2_hdr *resp;
 244         const u8 *pos;
 245         size_t len;
 246
 247         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, respData,
 248                                &len);
 249         if (pos == NULL || len < 1) {
 250                 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Invalid frame");
 251                 return TRUE;
 252         }
 253
 254         resp = (struct eap_mschapv2_hdr *) pos;
 255         if (data->state == CHALLENGE &&
 256             resp->op_code != MSCHAPV2_OP_RESPONSE) {
 257                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Expected Response - "
 258                            "ignore op %d", resp->op_code);
 259                 return TRUE;
 260         }
 261
 262         if (data->state == SUCCESS_REQ &&
 263             resp->op_code != MSCHAPV2_OP_SUCCESS &&
 264             resp->op_code != MSCHAPV2_OP_FAILURE) {
 265                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Expected Success or "
 266                            "Failure - ignore op %d", resp->op_code);
 267                 return TRUE;
 268         }
 269
 270         if (data->state == FAILURE_REQ &&
 271             resp->op_code != MSCHAPV2_OP_FAILURE) {
 272                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Expected Failure "
 273                            "- ignore op %d", resp->op_code);
 274                 return TRUE;
 275         }
 276
 277         return FALSE;
 278 }
 279
 280
 281 static void eap_mschapv2_process_response(struct eap_sm *sm,
 282                                           struct eap_mschapv2_data *data,
 283                                           struct wpabuf *respData)
 284 {
 285         struct eap_mschapv2_hdr *resp;
 286         const u8 *pos, *end, *peer_challenge, *nt_response, *name;
 287         u8 flags;
 288         size_t len, name_len, i;
 289         u8 expected[24];
 290         const u8 *username, *user;
 291         size_t username_len, user_len;
 292         int res;
 293         char *buf;
 294
 295         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, respData,
 296                                &len);
 297         if (pos == NULL || len < 1)
 298                 return; /* Should not happen - frame already validated */
 299
 300         end = pos + len;
 301         resp = (struct eap_mschapv2_hdr *) pos;
 302         pos = (u8 *) (resp + 1);
 303
 304         if (len < sizeof(*resp) + 1 + 49 ||
 305             resp->op_code != MSCHAPV2_OP_RESPONSE ||
 306             pos[0] != 49) {
 307                 wpa_hexdump_buf(MSG_DEBUG, "EAP-MSCHAPV2: Invalid response",
 308                                 respData);
 309                 data->state = FAILURE;
 310                 return;
 311         }
 312         data->resp_mschapv2_id = resp->mschapv2_id;
 313         pos++;
 314         peer_challenge = pos;
 315         pos += 16 + 8;
 316         nt_response = pos;
 317         pos += 24;
 318         flags = *pos++;
 319         name = pos;
 320         name_len = end - name;
 321
 322         if (data->peer_challenge) {
 323                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Using pre-configured "
 324                            "Peer-Challenge");
 325                 peer_challenge = data->peer_challenge;
 326         }
 327         wpa_hexdump(MSG_MSGDUMP, "EAP-MSCHAPV2: Peer-Challenge",
 328                     peer_challenge, 16);
 329         wpa_hexdump(MSG_MSGDUMP, "EAP-MSCHAPV2: NT-Response", nt_response, 24);
 330         wpa_printf(MSG_MSGDUMP, "EAP-MSCHAPV2: Flags 0x%x", flags);
 331         wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-MSCHAPV2: Name", name, name_len);
 332
 333         buf = os_malloc(name_len * 4 + 1);
 334         if (buf) {
 335                 printf_encode(buf, name_len * 4 + 1, name, name_len);
 336                 eap_log_msg(sm, "EAP-MSCHAPV2 Name '%s'", buf);
 337                 os_free(buf);
 338         }
 339
 340         /* MSCHAPv2 does not include optional domain name in the
 341          * challenge-response calculation, so remove domain prefix
 342          * (if present). */
 343         username = sm->identity;
 344         username_len = sm->identity_len;
 345         for (i = 0; i < username_len; i++) {
 346                 if (username[i] == '\\') {
 347                         username_len -= i + 1;
 348                         username += i + 1;
 349                         break;
 350                 }
 351         }
 352
 353         user = name;
 354         user_len = name_len;
 355         for (i = 0; i < user_len; i++) {
 356                 if (user[i] == '\\') {
 357                         user_len -= i + 1;
 358                         user += i + 1;
 359                         break;
 360                 }
 361         }
 362
 363 #ifdef CONFIG_TESTING_OPTIONS
 364         {
 365                 u8 challenge[8];
 366
 367                 if (challenge_hash(peer_challenge, data->auth_challenge,
 368                                    username, username_len, challenge) == 0) {
 369                         eap_server_mschap_rx_callback(sm, "EAP-MSCHAPV2",
 370                                                       username, username_len,
 371                                                       challenge, nt_response);
 372                 }
 373         }
 374 #endif /* CONFIG_TESTING_OPTIONS */
 375
 376         if (username_len != user_len ||
 377             os_memcmp(username, user, username_len) != 0) {
 378                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Mismatch in user names");
 379                 wpa_hexdump_ascii(MSG_DEBUG, "EAP-MSCHAPV2: Expected user "
 380                                   "name", username, username_len);
 381                 wpa_hexdump_ascii(MSG_DEBUG, "EAP-MSCHAPV2: Received user "
 382                                   "name", user, user_len);
 383                 data->state = FAILURE;
 384                 return;
 385         }
 386
 387         wpa_hexdump_ascii(MSG_MSGDUMP, "EAP-MSCHAPV2: User name",
 388                           username, username_len);
 389
 390         if (sm->user->password_hash) {
 391                 res = generate_nt_response_pwhash(data->auth_challenge,
 392                                                   peer_challenge,
 393                                                   username, username_len,
 394                                                   sm->user->password,
 395                                                   expected);
 396         } else {
 397                 res = generate_nt_response(data->auth_challenge,
 398                                            peer_challenge,
 399                                            username, username_len,
 400                                            sm->user->password,
 401                                            sm->user->password_len,
 402                                            expected);
 403         }
 404         if (res) {
 405                 data->state = FAILURE;
 406                 return;
 407         }
 408
 409         if (os_memcmp_const(nt_response, expected, 24) == 0) {
 410                 const u8 *pw_hash;
 411                 u8 pw_hash_buf[16], pw_hash_hash[16];
 412
 413                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Correct NT-Response");
 414                 data->state = SUCCESS_REQ;
 415
 416                 /* Authenticator response is not really needed yet, but
 417                  * calculate it here so that peer_challenge and username need
 418                  * not be saved. */
 419                 if (sm->user->password_hash) {
 420                         pw_hash = sm->user->password;
 421                 } else {
 422                         if (nt_password_hash(sm->user->password,
 423                                              sm->user->password_len,
 424                                              pw_hash_buf) < 0) {
 425                                 data->state = FAILURE;
 426                                 return;
 427                         }
 428                         pw_hash = pw_hash_buf;
 429                 }
 430                 if (generate_authenticator_response_pwhash(
 431                             pw_hash, peer_challenge, data->auth_challenge,
 432                             username, username_len, nt_response,
 433                             data->auth_response) < 0 ||
 434                     hash_nt_password_hash(pw_hash, pw_hash_hash) < 0 ||
 435                     get_master_key(pw_hash_hash, nt_response,
 436                                    data->master_key)) {
 437                         data->state = FAILURE;
 438                         return;
 439                 }
 440                 data->master_key_valid = 1;
 441                 wpa_hexdump_key(MSG_DEBUG, "EAP-MSCHAPV2: Derived Master Key",
 442                                 data->master_key, MSCHAPV2_KEY_LEN);
 443         } else {
 444                 wpa_hexdump(MSG_MSGDUMP, "EAP-MSCHAPV2: Expected NT-Response",
 445                             expected, 24);
 446                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Invalid NT-Response");
 447                 data->state = FAILURE_REQ;
 448         }
 449 }
 450
 451
 452 static void eap_mschapv2_process_success_resp(struct eap_sm *sm,
 453                                               struct eap_mschapv2_data *data,
 454                                               struct wpabuf *respData)
 455 {
 456         struct eap_mschapv2_hdr *resp;
 457         const u8 *pos;
 458         size_t len;
 459
 460         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, respData,
 461                                &len);
 462         if (pos == NULL || len < 1)
 463                 return; /* Should not happen - frame already validated */
 464
 465         resp = (struct eap_mschapv2_hdr *) pos;
 466
 467         if (resp->op_code == MSCHAPV2_OP_SUCCESS) {
 468                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Received Success Response"
 469                            " - authentication completed successfully");
 470                 data->state = SUCCESS;
 471         } else {
 472                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Did not receive Success "
 473                            "Response - peer rejected authentication");
 474                 data->state = FAILURE;
 475         }
 476 }
 477
 478
 479 static void eap_mschapv2_process_failure_resp(struct eap_sm *sm,
 480                                               struct eap_mschapv2_data *data,
 481                                               struct wpabuf *respData)
 482 {
 483         struct eap_mschapv2_hdr *resp;
 484         const u8 *pos;
 485         size_t len;
 486
 487         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2, respData,
 488                                &len);
 489         if (pos == NULL || len < 1)
 490                 return; /* Should not happen - frame already validated */
 491
 492         resp = (struct eap_mschapv2_hdr *) pos;
 493
 494         if (resp->op_code == MSCHAPV2_OP_FAILURE) {
 495                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Received Failure Response"
 496                            " - authentication failed");
 497         } else {
 498                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Did not receive Failure "
 499                            "Response - authentication failed");
 500         }
 501
 502         data->state = FAILURE;
 503 }
 504
 505
 506 static void eap_mschapv2_process(struct eap_sm *sm, void *priv,
 507                                  struct wpabuf *respData)
 508 {
 509         struct eap_mschapv2_data *data = priv;
 510
 511         if (sm->user == NULL || sm->user->password == NULL) {
 512                 wpa_printf(MSG_INFO, "EAP-MSCHAPV2: Password not configured");
 513                 data->state = FAILURE;
 514                 return;
 515         }
 516
 517         switch (data->state) {
 518         case CHALLENGE:
 519                 eap_mschapv2_process_response(sm, data, respData);
 520                 break;
 521         case SUCCESS_REQ:
 522                 eap_mschapv2_process_success_resp(sm, data, respData);
 523                 break;
 524         case FAILURE_REQ:
 525                 eap_mschapv2_process_failure_resp(sm, data, respData);
 526                 break;
 527         default:
 528                 wpa_printf(MSG_DEBUG, "EAP-MSCHAPV2: Unknown state %d in "
 529                            "process", data->state);
 530                 break;
 531         }
 532 }
 533
 534
 535 static Boolean eap_mschapv2_isDone(struct eap_sm *sm, void *priv)
 536 {
 537         struct eap_mschapv2_data *data = priv;
 538         return data->state == SUCCESS || data->state == FAILURE;
 539 }
 540
 541
 542 static u8 * eap_mschapv2_getKey(struct eap_sm *sm, void *priv, size_t *len)
 543 {
 544         struct eap_mschapv2_data *data = priv;
 545         u8 *key;
 546
 547         if (data->state != SUCCESS || !data->master_key_valid)
 548                 return NULL;
 549
 550         *len = 2 * MSCHAPV2_KEY_LEN;
 551         key = os_malloc(*len);
 552         if (key == NULL)
 553                 return NULL;
 554         /* MSK = server MS-MPPE-Recv-Key | MS-MPPE-Send-Key */
 555         get_asymetric_start_key(data->master_key, key, MSCHAPV2_KEY_LEN, 0, 1);
 556         get_asymetric_start_key(data->master_key, key + MSCHAPV2_KEY_LEN,
 557                                 MSCHAPV2_KEY_LEN, 1, 1);
 558         wpa_hexdump_key(MSG_DEBUG, "EAP-MSCHAPV2: Derived key", key, *len);
 559
 560         return key;
 561 }
 562
 563
 564 static Boolean eap_mschapv2_isSuccess(struct eap_sm *sm, void *priv)
 565 {
 566         struct eap_mschapv2_data *data = priv;
 567         return data->state == SUCCESS;
 568 }
 569
 570
 571 int eap_server_mschapv2_register(void)
 572 {
 573         struct eap_method *eap;
 574         int ret;
 575
 576         eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
 577                                       EAP_VENDOR_IETF, EAP_TYPE_MSCHAPV2,
 578                                       "MSCHAPV2");
 579         if (eap == NULL)
 580                 return -1;
 581
 582         eap->init = eap_mschapv2_init;
 583         eap->reset = eap_mschapv2_reset;
 584         eap->buildReq = eap_mschapv2_buildReq;
 585         eap->check = eap_mschapv2_check;
 586         eap->process = eap_mschapv2_process;
 587         eap->isDone = eap_mschapv2_isDone;
 588         eap->getKey = eap_mschapv2_getKey;
 589         eap->isSuccess = eap_mschapv2_isSuccess;
 590
 591         ret = eap_server_method_register(eap);
 592         if (ret)
 593                 eap_server_method_free(eap);
 594         return ret;
 595 }