pppd/chap_ms.c

   1 /*
   2  * chap_ms.c - Microsoft MS-CHAP compatible implementation.
   3  *
   4  * Copyright (c) 1995 Eric Rosenquist.  All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  *
  18  * 3. The name(s) of the authors of this software must not be used to
  19  *    endorse or promote products derived from this software without
  20  *    prior written permission.
  21  *
  22  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
  23  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  24  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
  25  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  26  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  27  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  28  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  29  */
  30
  31 /*
  32  * Modifications by Lauri Pesonen / lpesonen@clinet.fi, april 1997
  33  *
  34  *   Implemented LANManager type password response to MS-CHAP challenges.
  35  *   Now pppd provides both NT style and LANMan style blocks, and the
  36  *   prefered is set by option "ms-lanman". Default is to use NT.
  37  *   The hash text (StdText) was taken from Win95 RASAPI32.DLL.
  38  *
  39  *   You should also use DOMAIN\\USERNAME as described in README.MSCHAP80
  40  */
  41
  42 /*
  43  * Modifications by Frank Cusack, frank@google.com, March 2002.
  44  *
  45  *   Implemented MS-CHAPv2 functionality, heavily based on sample
  46  *   implementation in RFC 2759.  Implemented MPPE functionality,
  47  *   heavily based on sample implementation in RFC 3079.
  48  *
  49  * Copyright (c) 2002 Google, Inc.  All rights reserved.
  50  *
  51  * Redistribution and use in source and binary forms, with or without
  52  * modification, are permitted provided that the following conditions
  53  * are met:
  54  *
  55  * 1. Redistributions of source code must retain the above copyright
  56  *    notice, this list of conditions and the following disclaimer.
  57  *
  58  * 2. Redistributions in binary form must reproduce the above copyright
  59  *    notice, this list of conditions and the following disclaimer in
  60  *    the documentation and/or other materials provided with the
  61  *    distribution.
  62  *
  63  * 3. The name(s) of the authors of this software must not be used to
  64  *    endorse or promote products derived from this software without
  65  *    prior written permission.
  66  *
  67  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
  68  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  69  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
  70  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  71  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  72  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  73  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  74  *
  75  */
  76
  77 #define RCSID   "$Id: chap_ms.c,v 1.38 2007/12/01 20:10:51 carlsonj Exp $"
  78
  79 #ifdef HAVE_CONFIG_H
  80 #include "config.h"
  81 #endif
  82
  83 #include <stdio.h>
  84 #include <stdlib.h>
  85 #include <string.h>
  86 #include <ctype.h>
  87 #include <sys/types.h>
  88 #include <sys/time.h>
  89 #include <unistd.h>
  90 #if defined(SOL2)
  91 #include <net/ppp-comp.h>
  92 #else
  93 #include <linux/ppp-comp.h>
  94 #endif
  95
  96 #include "pppd-private.h"
  97 #include "options.h"
  98 #include "chap.h"
  99 #include "chap_ms.h"
 100 #include "magic.h"
 101 #include "mppe.h"
 102 #include "crypto.h"
 103 #include "crypto_ms.h"
 104
 105 #ifdef UNIT_TEST
 106 #undef PPP_WITH_MPPE
 107 #endif
 108
 109 static void     ascii2unicode (char[], int, u_char[]);
 110 static void     NTPasswordHash (u_char *, int, unsigned char *);
 111 static int      ChallengeResponse (u_char *, u_char *, u_char*);
 112 static void     ChapMS_NT (u_char *, char *, int, u_char[24]);
 113 static void     ChapMS2_NT (u_char *, u_char[16], char *, char *, int,
 114                                 u_char[24]);
 115 static void     GenerateAuthenticatorResponsePlain
 116                         (char*, int, u_char[24], u_char[16], u_char *,
 117                          char *, u_char[41]);
 118 #ifdef PPP_WITH_MSLANMAN
 119 static void     ChapMS_LANMan (u_char *, char *, int, u_char *);
 120 #endif
 121
 122 #ifdef PPP_WITH_MSLANMAN
 123 bool    ms_lanman = 0;          /* Use LanMan password instead of NT */
 124                                 /* Has meaning only with MS-CHAP challenges */
 125 #endif
 126
 127 #ifdef PPP_WITH_MPPE
 128 #ifdef DEBUGMPPEKEY
 129 /* For MPPE debug */
 130 /* Use "[]|}{?/><,`!2&&(" (sans quotes) for RFC 3079 MS-CHAPv2 test value */
 131 static char *mschap_challenge = NULL;
 132 /* Use "!@\#$%^&*()_+:3|~" (sans quotes, backslash is to escape #) for ... */
 133 static char *mschap2_peer_challenge = NULL;
 134 #endif
 135
 136 #include "fsm.h"                /* Need to poke MPPE options */
 137 #include "ccp.h"
 138 #endif
 139
 140 /*
 141  * Command-line options.
 142  */
 143 static struct option chapms_option_list[] = {
 144 #ifdef PPP_WITH_MSLANMAN
 145         { "ms-lanman", o_bool, &ms_lanman,
 146           "Use LanMan passwd when using MS-CHAP", 1 },
 147 #endif
 148 #ifdef DEBUGMPPEKEY
 149         { "mschap-challenge", o_string, &mschap_challenge,
 150           "specify CHAP challenge" },
 151         { "mschap2-peer-challenge", o_string, &mschap2_peer_challenge,
 152           "specify CHAP peer challenge" },
 153 #endif
 154         { NULL }
 155 };
 156
 157 /*
 158  * chapms_generate_challenge - generate a challenge for MS-CHAP.
 159  * For MS-CHAP the challenge length is fixed at 8 bytes.
 160  * The length goes in challenge[0] and the actual challenge starts
 161  * at challenge[1].
 162  */
 163 static void
 164 chapms_generate_challenge(unsigned char *challenge)
 165 {
 166         *challenge++ = 8;
 167 #ifdef DEBUGMPPEKEY
 168         if (mschap_challenge && strlen(mschap_challenge) == 8)
 169                 memcpy(challenge, mschap_challenge, 8);
 170         else
 171 #endif
 172                 random_bytes(challenge, 8);
 173 }
 174
 175 static void
 176 chapms2_generate_challenge(unsigned char *challenge)
 177 {
 178         *challenge++ = 16;
 179 #ifdef DEBUGMPPEKEY
 180         if (mschap_challenge && strlen(mschap_challenge) == 16)
 181                 memcpy(challenge, mschap_challenge, 16);
 182         else
 183 #endif
 184                 random_bytes(challenge, 16);
 185 }
 186
 187 static int
 188 chapms_verify_response(int id, char *name,
 189                        unsigned char *secret, int secret_len,
 190                        unsigned char *challenge, unsigned char *response,
 191                        char *message, int message_space)
 192 {
 193         unsigned char md[MS_CHAP_RESPONSE_LEN];
 194         int diff;
 195         int challenge_len, response_len;
 196
 197         challenge_len = *challenge++;   /* skip length, is 8 */
 198         response_len = *response++;
 199         if (response_len != MS_CHAP_RESPONSE_LEN)
 200                 goto bad;
 201
 202 #ifndef PPP_WITH_MSLANMAN
 203         if (!response[MS_CHAP_USENT]) {
 204                 /* Should really propagate this into the error packet. */
 205                 notice("Peer request for LANMAN auth not supported");
 206                 goto bad;
 207         }
 208 #endif
 209
 210         /* Generate the expected response. */
 211         ChapMS(challenge, (char *)secret, secret_len, md);
 212
 213 #ifdef PPP_WITH_MSLANMAN
 214         /* Determine which part of response to verify against */
 215         if (!response[MS_CHAP_USENT])
 216                 diff = memcmp(&response[MS_CHAP_LANMANRESP],
 217                               &md[MS_CHAP_LANMANRESP], MS_CHAP_LANMANRESP_LEN);
 218         else
 219 #endif
 220                 diff = memcmp(&response[MS_CHAP_NTRESP], &md[MS_CHAP_NTRESP],
 221                               MS_CHAP_NTRESP_LEN);
 222
 223         if (diff == 0) {
 224                 slprintf(message, message_space, "Access granted");
 225                 return 1;
 226         }
 227
 228  bad:
 229         /* See comments below for MS-CHAP V2 */
 230         slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0",
 231                  challenge_len, challenge);
 232         return 0;
 233 }
 234
 235 static int
 236 chapms2_verify_response(int id, char *name,
 237                         unsigned char *secret, int secret_len,
 238                         unsigned char *challenge, unsigned char *response,
 239                         char *message, int message_space)
 240 {
 241         unsigned char md[MS_CHAP2_RESPONSE_LEN];
 242         char saresponse[MS_AUTH_RESPONSE_LENGTH+1];
 243         int challenge_len, response_len;
 244
 245         challenge_len = *challenge++;   /* skip length, is 16 */
 246         response_len = *response++;
 247         if (response_len != MS_CHAP2_RESPONSE_LEN)
 248                 goto bad;       /* not even the right length */
 249
 250         /* Generate the expected response and our mutual auth. */
 251         ChapMS2(challenge, &response[MS_CHAP2_PEER_CHALLENGE], name,
 252                 (char *)secret, secret_len, md,
 253                 (unsigned char *)saresponse, MS_CHAP2_AUTHENTICATOR);
 254
 255         /* compare MDs and send the appropriate status */
 256         /*
 257          * Per RFC 2759, success message must be formatted as
 258          *     "S=<auth_string> M=<message>"
 259          * where
 260          *     <auth_string> is the Authenticator Response (mutual auth)
 261          *     <message> is a text message
 262          *
 263          * However, some versions of Windows (win98 tested) do not know
 264          * about the M=<message> part (required per RFC 2759) and flag
 265          * it as an error (reported incorrectly as an encryption error
 266          * to the user).  Since the RFC requires it, and it can be
 267          * useful information, we supply it if the peer is a conforming
 268          * system.  Luckily (?), win98 sets the Flags field to 0x04
 269          * (contrary to RFC requirements) so we can use that to
 270          * distinguish between conforming and non-conforming systems.
 271          *
 272          * Special thanks to Alex Swiridov <say@real.kharkov.ua> for
 273          * help debugging this.
 274          */
 275         if (memcmp(&md[MS_CHAP2_NTRESP], &response[MS_CHAP2_NTRESP],
 276                    MS_CHAP2_NTRESP_LEN) == 0) {
 277                 if (response[MS_CHAP2_FLAGS])
 278                         slprintf(message, message_space, "S=%s", saresponse);
 279                 else
 280                         slprintf(message, message_space, "S=%s M=%s",
 281                                  saresponse, "Access granted");
 282                 return 1;
 283         }
 284
 285  bad:
 286         /*
 287          * Failure message must be formatted as
 288          *     "E=e R=r C=c V=v M=m"
 289          * where
 290          *     e = error code (we use 691, ERROR_AUTHENTICATION_FAILURE)
 291          *     r = retry (we use 1, ok to retry)
 292          *     c = challenge to use for next response, we reuse previous
 293          *     v = Change Password version supported, we use 0
 294          *     m = text message
 295          *
 296          * The M=m part is only for MS-CHAPv2.  Neither win2k nor
 297          * win98 (others untested) display the message to the user anyway.
 298          * They also both ignore the E=e code.
 299          *
 300          * Note that it's safe to reuse the same challenge as we don't
 301          * actually accept another response based on the error message
 302          * (and no clients try to resend a response anyway).
 303          *
 304          * Basically, this whole bit is useless code, even the small
 305          * implementation here is only because of overspecification.
 306          */
 307         slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0 M=%s",
 308                  challenge_len, challenge, "Access denied");
 309         return 0;
 310 }
 311
 312 static void
 313 chapms_make_response(unsigned char *response, int id, char *our_name,
 314                      unsigned char *challenge, char *secret, int secret_len,
 315                      unsigned char *private)
 316 {
 317         challenge++;    /* skip length, should be 8 */
 318         *response++ = MS_CHAP_RESPONSE_LEN;
 319         ChapMS(challenge, secret, secret_len, response);
 320 }
 321
 322 struct chapms2_response_cache_entry {
 323         int id;
 324         unsigned char challenge[16];
 325         unsigned char response[MS_CHAP2_RESPONSE_LEN];
 326         unsigned char auth_response[MS_AUTH_RESPONSE_LENGTH];
 327 };
 328
 329 #define CHAPMS2_MAX_RESPONSE_CACHE_SIZE 10
 330 static struct chapms2_response_cache_entry
 331     chapms2_response_cache[CHAPMS2_MAX_RESPONSE_CACHE_SIZE];
 332 static int chapms2_response_cache_next_index = 0;
 333 static int chapms2_response_cache_size = 0;
 334
 335 static void
 336 chapms2_add_to_response_cache(int id, unsigned char *challenge,
 337                               unsigned char *response,
 338                               unsigned char *auth_response)
 339 {
 340         int i = chapms2_response_cache_next_index;
 341
 342         chapms2_response_cache[i].id = id;
 343         memcpy(chapms2_response_cache[i].challenge, challenge, 16);
 344         memcpy(chapms2_response_cache[i].response, response,
 345                MS_CHAP2_RESPONSE_LEN);
 346         memcpy(chapms2_response_cache[i].auth_response,
 347                auth_response, MS_AUTH_RESPONSE_LENGTH);
 348         chapms2_response_cache_next_index =
 349                 (i + 1) % CHAPMS2_MAX_RESPONSE_CACHE_SIZE;
 350         if (chapms2_response_cache_next_index > chapms2_response_cache_size)
 351                 chapms2_response_cache_size = chapms2_response_cache_next_index;
 352         dbglog("added response cache entry %d", i);
 353 }
 354
 355 static struct chapms2_response_cache_entry*
 356 chapms2_find_in_response_cache(int id, unsigned char *challenge,
 357                       unsigned char *auth_response)
 358 {
 359         int i;
 360
 361         for (i = 0; i < chapms2_response_cache_size; i++) {
 362                 if (id == chapms2_response_cache[i].id
 363                     && (!challenge
 364                         || memcmp(challenge,
 365                                   chapms2_response_cache[i].challenge,
 366                                   16) == 0)
 367                     && (!auth_response
 368                         || memcmp(auth_response,
 369                                   chapms2_response_cache[i].auth_response,
 370                                   MS_AUTH_RESPONSE_LENGTH) == 0)) {
 371                         dbglog("response found in cache (entry %d)", i);
 372                         return &chapms2_response_cache[i];
 373                 }
 374         }
 375         return NULL;  /* not found */
 376 }
 377
 378 static void
 379 chapms2_make_response(unsigned char *response, int id, char *our_name,
 380                       unsigned char *challenge, char *secret, int secret_len,
 381                       unsigned char *private)
 382 {
 383         const struct chapms2_response_cache_entry *cache_entry;
 384         unsigned char auth_response[MS_AUTH_RESPONSE_LENGTH+1];
 385
 386         challenge++;    /* skip length, should be 16 */
 387         *response++ = MS_CHAP2_RESPONSE_LEN;
 388         cache_entry = chapms2_find_in_response_cache(id, challenge, NULL);
 389         if (cache_entry) {
 390                 memcpy(response, cache_entry->response, MS_CHAP2_RESPONSE_LEN);
 391                 return;
 392         }
 393         ChapMS2(challenge,
 394 #ifdef DEBUGMPPEKEY
 395                 mschap2_peer_challenge,
 396 #else
 397                 NULL,
 398 #endif
 399                 our_name, secret, secret_len, response, auth_response,
 400                 MS_CHAP2_AUTHENTICATEE);
 401         chapms2_add_to_response_cache(id, challenge, response, auth_response);
 402 }
 403
 404 static int
 405 chapms2_check_success(int id, unsigned char *msg, int len)
 406 {
 407         if ((len < MS_AUTH_RESPONSE_LENGTH + 2) ||
 408             strncmp((char *)msg, "S=", 2) != 0) {
 409                 /* Packet does not start with "S=" */
 410                 error("MS-CHAPv2 Success packet is badly formed.");
 411                 return 0;
 412         }
 413         msg += 2;
 414         len -= 2;
 415         if (len < MS_AUTH_RESPONSE_LENGTH
 416             || !chapms2_find_in_response_cache(id, NULL /* challenge */, msg)) {
 417                 /* Authenticator Response did not match expected. */
 418                 error("MS-CHAPv2 mutual authentication failed.");
 419                 return 0;
 420         }
 421         /* Authenticator Response matches. */
 422         msg += MS_AUTH_RESPONSE_LENGTH; /* Eat it */
 423         len -= MS_AUTH_RESPONSE_LENGTH;
 424         if ((len >= 3) && !strncmp((char *)msg, " M=", 3)) {
 425                 msg += 3; /* Eat the delimiter */
 426         } else  if ((len >= 2) && !strncmp((char *)msg, "M=", 2)) {
 427                 msg += 2; /* Eat the delimiter */
 428         } else if (len) {
 429                 /* Packet has extra text which does not begin " M=" */
 430                 error("MS-CHAPv2 Success packet is badly formed.");
 431                 return 0;
 432         }
 433         return 1;
 434 }
 435
 436 static void
 437 chapms_handle_failure(unsigned char *inp, int len)
 438 {
 439         int err;
 440         char *p, *msg;
 441
 442         /* We want a null-terminated string for strxxx(). */
 443         msg = malloc(len + 1);
 444         if (!msg) {
 445                 notice("Out of memory in chapms_handle_failure");
 446                 return;
 447         }
 448         BCOPY(inp, msg, len);
 449         msg[len] = 0;
 450         p = msg;
 451
 452         /*
 453          * Deal with MS-CHAP formatted failure messages; just print the
 454          * M=<message> part (if any).  For MS-CHAP we're not really supposed
 455          * to use M=<message>, but it shouldn't hurt.  See
 456          * chapms[2]_verify_response.
 457          */
 458         if (!strncmp(p, "E=", 2))
 459                 err = strtol(p+2, NULL, 10); /* Remember the error code. */
 460         else
 461                 goto print_msg; /* Message is badly formatted. */
 462
 463         if (len && ((p = strstr(p, " M=")) != NULL)) {
 464                 /* M=<message> field found. */
 465                 p += 3;
 466         } else {
 467                 /* No M=<message>; use the error code. */
 468                 switch (err) {
 469                 case MS_CHAP_ERROR_RESTRICTED_LOGON_HOURS:
 470                         p = "E=646 Restricted logon hours";
 471                         break;
 472
 473                 case MS_CHAP_ERROR_ACCT_DISABLED:
 474                         p = "E=647 Account disabled";
 475                         break;
 476
 477                 case MS_CHAP_ERROR_PASSWD_EXPIRED:
 478                         p = "E=648 Password expired";
 479                         break;
 480
 481                 case MS_CHAP_ERROR_NO_DIALIN_PERMISSION:
 482                         p = "E=649 No dialin permission";
 483                         break;
 484
 485                 case MS_CHAP_ERROR_AUTHENTICATION_FAILURE:
 486                         p = "E=691 Authentication failure";
 487                         break;
 488
 489                 case MS_CHAP_ERROR_CHANGING_PASSWORD:
 490                         /* Should never see this, we don't support Change Password. */
 491                         p = "E=709 Error changing password";
 492                         break;
 493
 494                 default:
 495                         free(msg);
 496                         error("Unknown MS-CHAP authentication failure: %.*v",
 497                               len, inp);
 498                         return;
 499                 }
 500         }
 501 print_msg:
 502         if (p != NULL)
 503                 error("MS-CHAP authentication failed: %v", p);
 504         free(msg);
 505 }
 506
 507 static int
 508 ChallengeResponse(u_char *challenge,
 509                   u_char *PasswordHash,
 510                   u_char *response)
 511 {
 512     u_char ZPasswordHash[24];
 513     PPP_CIPHER_CTX *ctx;
 514
 515     BZERO(ZPasswordHash, sizeof(ZPasswordHash));
 516     BCOPY(PasswordHash, ZPasswordHash, MD4_DIGEST_LENGTH);
 517
 518 #if 0
 519     dbglog("ChallengeResponse - ZPasswordHash %.*B",
 520            sizeof(ZPasswordHash), ZPasswordHash);
 521 #endif
 522
 523     if (DesEncrypt(challenge, ZPasswordHash + 0,  response + 0) &&
 524         DesEncrypt(challenge, ZPasswordHash + 7,  response + 8) &&
 525         DesEncrypt(challenge, ZPasswordHash + 14, response + 16))
 526         return 1;
 527
 528 #if 0
 529     dbglog("ChallengeResponse - response %.24B", response);
 530 #endif
 531     return 0;
 532 }
 533
 534 void
 535 ChallengeHash(u_char PeerChallenge[16], u_char *rchallenge,
 536               char *username, u_char Challenge[8])
 537
 538 {
 539     PPP_MD_CTX* ctx;
 540     u_char      hash[SHA_DIGEST_LENGTH];
 541     int     hash_len;
 542     const char *user;
 543
 544     /* remove domain from "domain\username" */
 545     if ((user = strrchr(username, '\\')) != NULL)
 546         ++user;
 547     else
 548         user = username;
 549
 550     ctx = PPP_MD_CTX_new();
 551     if (ctx != NULL) {
 552
 553         if (PPP_DigestInit(ctx, PPP_sha1())) {
 554
 555             if (PPP_DigestUpdate(ctx, PeerChallenge, 16)) {
 556
 557                 if (PPP_DigestUpdate(ctx, rchallenge, 16)) {
 558
 559                     if (PPP_DigestUpdate(ctx, user, strlen(user))) {
 560
 561                         hash_len = SHA_DIGEST_LENGTH;
 562                         if (PPP_DigestFinal(ctx, hash, &hash_len)) {
 563
 564                             BCOPY(hash, Challenge, 8);
 565                         }
 566                     }
 567                 }
 568             }
 569         }
 570
 571         PPP_MD_CTX_free(ctx);
 572     }
 573 }
 574
 575 /*
 576  * Convert the ASCII version of the password to Unicode.
 577  * This implicitly supports 8-bit ISO8859/1 characters.
 578  * This gives us the little-endian representation, which
 579  * is assumed by all M$ CHAP RFCs.  (Unicode byte ordering
 580  * is machine-dependent.)
 581  */
 582 static void
 583 ascii2unicode(char ascii[], int ascii_len, u_char unicode[])
 584 {
 585     int i;
 586
 587     BZERO(unicode, ascii_len * 2);
 588     for (i = 0; i < ascii_len; i++)
 589         unicode[i * 2] = (u_char) ascii[i];
 590 }
 591
 592 static void
 593 NTPasswordHash(u_char *secret, int secret_len, unsigned char* hash)
 594 {
 595     PPP_MD_CTX* ctx = PPP_MD_CTX_new();
 596     if (ctx != NULL) {
 597
 598         if (PPP_DigestInit(ctx, PPP_md4())) {
 599
 600             if (PPP_DigestUpdate(ctx, secret, secret_len)) {
 601
 602                 int hash_len = MD4_DIGEST_LENGTH;
 603                 PPP_DigestFinal(ctx, hash, &hash_len);
 604             }
 605         }
 606
 607         PPP_MD_CTX_free(ctx);
 608     }
 609 }
 610
 611 static void
 612 ChapMS_NT(u_char *rchallenge, char *secret, int secret_len,
 613           u_char NTResponse[24])
 614 {
 615     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
 616     u_char      PasswordHash[MD4_DIGEST_LENGTH];
 617
 618     /* Hash the Unicode version of the secret (== password). */
 619     ascii2unicode(secret, secret_len, unicodePassword);
 620     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
 621
 622     ChallengeResponse(rchallenge, PasswordHash, NTResponse);
 623 }
 624
 625 static void
 626 ChapMS2_NT(u_char *rchallenge, u_char PeerChallenge[16], char *username,
 627            char *secret, int secret_len, u_char NTResponse[24])
 628 {
 629     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
 630     u_char      PasswordHash[MD4_DIGEST_LENGTH];
 631     u_char      Challenge[8];
 632
 633     ChallengeHash(PeerChallenge, rchallenge, username, Challenge);
 634
 635     /* Hash the Unicode version of the secret (== password). */
 636     ascii2unicode(secret, secret_len, unicodePassword);
 637     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
 638
 639     ChallengeResponse(Challenge, PasswordHash, NTResponse);
 640 }
 641
 642 #ifdef PPP_WITH_MSLANMAN
 643 static u_char *StdText = (u_char *)"KGS!@#$%"; /* key from rasapi32.dll */
 644
 645 static void
 646 ChapMS_LANMan(u_char *rchallenge, char *secret, int secret_len,
 647               unsigned char *response)
 648 {
 649     int                 i;
 650     u_char              UcasePassword[MAX_NT_PASSWORD]; /* max is actually 14 */
 651     u_char              PasswordHash[MD4_DIGEST_LENGTH];
 652
 653     /* LANMan password is case insensitive */
 654     BZERO(UcasePassword, sizeof(UcasePassword));
 655     for (i = 0; i < secret_len; i++)
 656        UcasePassword[i] = (u_char)toupper(secret[i]);
 657
 658     if (DesEncrypt(StdText, UcasePassword + 0, PasswordHash + 0) &&
 659         DesEncrypt(StdText, UcasePassword + 7, PasswordHash + 8)) {
 660
 661         ChallengeResponse(rchallenge, PasswordHash, &response[MS_CHAP_LANMANRESP]);
 662     }
 663 }
 664 #endif
 665
 666
 667 void
 668 GenerateAuthenticatorResponse(unsigned char* PasswordHashHash,
 669                               unsigned char *NTResponse, unsigned char *PeerChallenge,
 670                               unsigned char *rchallenge, char *username,
 671                               unsigned char *authResponse)
 672 {
 673     /*
 674      * "Magic" constants used in response generation, from RFC 2759.
 675      */
 676     u_char Magic1[39] = /* "Magic server to client signing constant" */
 677         { 0x4D, 0x61, 0x67, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76,
 678           0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6C, 0x69, 0x65,
 679           0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67,
 680           0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74 };
 681     u_char Magic2[41] = /* "Pad to make it do more than one iteration" */
 682         { 0x50, 0x61, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B,
 683           0x65, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6D, 0x6F,
 684           0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E,
 685           0x65, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F,
 686           0x6E };
 687
 688     int         i;
 689     PPP_MD_CTX *ctx;
 690     u_char      Digest[SHA_DIGEST_LENGTH] = {};
 691     int     hash_len;
 692     u_char      Challenge[8];
 693
 694     ctx = PPP_MD_CTX_new();
 695     if (ctx != NULL) {
 696
 697         if (PPP_DigestInit(ctx, PPP_sha1())) {
 698
 699             if (PPP_DigestUpdate(ctx, PasswordHashHash, MD4_DIGEST_LENGTH)) {
 700
 701                 if (PPP_DigestUpdate(ctx, NTResponse, 24)) {
 702
 703                     if (PPP_DigestUpdate(ctx, Magic1, sizeof(Magic1))) {
 704
 705                         hash_len = sizeof(Digest);
 706                         PPP_DigestFinal(ctx, Digest, &hash_len);
 707                     }
 708                 }
 709             }
 710         }
 711         PPP_MD_CTX_free(ctx);
 712     }
 713
 714     ChallengeHash(PeerChallenge, rchallenge, username, Challenge);
 715
 716     ctx = PPP_MD_CTX_new();
 717     if (ctx != NULL) {
 718
 719         if (PPP_DigestInit(ctx, PPP_sha1())) {
 720
 721             if (PPP_DigestUpdate(ctx, Digest, sizeof(Digest))) {
 722
 723                 if (PPP_DigestUpdate(ctx, Challenge, sizeof(Challenge))) {
 724
 725                     if (PPP_DigestUpdate(ctx, Magic2, sizeof(Magic2))) {
 726
 727                         hash_len = sizeof(Digest);
 728                         PPP_DigestFinal(ctx, Digest, &hash_len);
 729                     }
 730                 }
 731             }
 732         }
 733
 734         PPP_MD_CTX_free(ctx);
 735     }
 736
 737     /* Convert to ASCII hex string. */
 738     for (i = 0; i < MAX((MS_AUTH_RESPONSE_LENGTH / 2), sizeof(Digest)); i++) {
 739         sprintf((char *)&authResponse[i * 2], "%02X", Digest[i]);
 740     }
 741 }
 742
 743
 744 static void
 745 GenerateAuthenticatorResponsePlain
 746                 (char *secret, int secret_len,
 747                  u_char NTResponse[24], u_char PeerChallenge[16],
 748                  u_char *rchallenge, char *username,
 749                  u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1])
 750 {
 751     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
 752     u_char      PasswordHash[MD4_DIGEST_LENGTH];
 753     u_char      PasswordHashHash[MD4_DIGEST_LENGTH];
 754
 755     /* Hash (x2) the Unicode version of the secret (== password). */
 756     ascii2unicode(secret, secret_len, unicodePassword);
 757     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
 758     NTPasswordHash(PasswordHash, sizeof(PasswordHash),
 759                    PasswordHashHash);
 760
 761     GenerateAuthenticatorResponse(PasswordHashHash, NTResponse, PeerChallenge,
 762                                   rchallenge, username, authResponse);
 763 }
 764
 765
 766 #ifdef PPP_WITH_MPPE
 767
 768 /*
 769  * Set mppe_xxxx_key from MS-CHAP credentials. (see RFC 3079)
 770  */
 771 static void
 772 Set_Start_Key(u_char *rchallenge, char *secret, int secret_len)
 773 {
 774     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
 775     u_char      PasswordHash[MD4_DIGEST_LENGTH];
 776     u_char      PasswordHashHash[MD4_DIGEST_LENGTH];
 777
 778     /* Hash (x2) the Unicode version of the secret (== password). */
 779     ascii2unicode(secret, secret_len, unicodePassword);
 780     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
 781     NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);
 782
 783     mppe_set_chapv1(rchallenge, PasswordHashHash);
 784 }
 785
 786 /*
 787  * Set mppe_xxxx_key from MS-CHAPv2 credentials. (see RFC 3079)
 788  */
 789 static void
 790 SetMasterKeys(char *secret, int secret_len, u_char NTResponse[24], int IsServer)
 791 {
 792     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
 793     u_char      PasswordHash[MD4_DIGEST_LENGTH];
 794     u_char      PasswordHashHash[MD4_DIGEST_LENGTH];
 795     /* Hash (x2) the Unicode version of the secret (== password). */
 796     ascii2unicode(secret, secret_len, unicodePassword);
 797     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
 798     NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);
 799     mppe_set_chapv2(PasswordHashHash, NTResponse, IsServer);
 800 }
 801
 802 #endif /* PPP_WITH_MPPE */
 803
 804
 805 void
 806 ChapMS(u_char *rchallenge, char *secret, int secret_len,
 807        unsigned char *response)
 808 {
 809     BZERO(response, MS_CHAP_RESPONSE_LEN);
 810
 811     ChapMS_NT(rchallenge, secret, secret_len, &response[MS_CHAP_NTRESP]);
 812
 813 #ifdef PPP_WITH_MSLANMAN
 814     ChapMS_LANMan(rchallenge, secret, secret_len,
 815                   &response[MS_CHAP_LANMANRESP]);
 816
 817     /* preferred method is set by option  */
 818     response[MS_CHAP_USENT] = !ms_lanman;
 819 #else
 820     response[MS_CHAP_USENT] = 1;
 821 #endif
 822
 823 #ifdef PPP_WITH_MPPE
 824     Set_Start_Key(rchallenge, secret, secret_len);
 825 #endif
 826 }
 827
 828
 829 /*
 830  * If PeerChallenge is NULL, one is generated and the PeerChallenge
 831  * field of response is filled in.  Call this way when generating a response.
 832  * If PeerChallenge is supplied, it is copied into the PeerChallenge field.
 833  * Call this way when verifying a response (or debugging).
 834  * Do not call with PeerChallenge = response.
 835  *
 836  * The PeerChallenge field of response is then used for calculation of the
 837  * Authenticator Response.
 838  */
 839 void
 840 ChapMS2(unsigned char *rchallenge, unsigned char *PeerChallenge,
 841         char *user, char *secret, int secret_len, unsigned char *response,
 842         u_char authResponse[], int authenticator)
 843 {
 844     /* ARGSUSED */
 845     u_char *p = &response[MS_CHAP2_PEER_CHALLENGE];
 846     int i;
 847
 848     BZERO(response, MS_CHAP2_RESPONSE_LEN);
 849
 850     /* Generate the Peer-Challenge if requested, or copy it if supplied. */
 851     if (!PeerChallenge)
 852         for (i = 0; i < MS_CHAP2_PEER_CHAL_LEN; i++)
 853             *p++ = (u_char) (drand48() * 0xff);
 854     else
 855         BCOPY(PeerChallenge, &response[MS_CHAP2_PEER_CHALLENGE],
 856               MS_CHAP2_PEER_CHAL_LEN);
 857
 858     /* Generate the NT-Response */
 859     ChapMS2_NT(rchallenge, &response[MS_CHAP2_PEER_CHALLENGE], user,
 860                secret, secret_len, &response[MS_CHAP2_NTRESP]);
 861
 862     /* Generate the Authenticator Response. */
 863     GenerateAuthenticatorResponsePlain(secret, secret_len,
 864                                        &response[MS_CHAP2_NTRESP],
 865                                        &response[MS_CHAP2_PEER_CHALLENGE],
 866                                        rchallenge, user, authResponse);
 867
 868 #ifdef PPP_WITH_MPPE
 869     SetMasterKeys(secret, secret_len,
 870                   &response[MS_CHAP2_NTRESP], authenticator);
 871 #endif
 872 }
 873
 874
 875 static struct chap_digest_type chapms_digest = {
 876         CHAP_MICROSOFT,         /* code */
 877         chapms_generate_challenge,
 878         chapms_verify_response,
 879         chapms_make_response,
 880         NULL,                   /* check_success */
 881         chapms_handle_failure,
 882 };
 883
 884 static struct chap_digest_type chapms2_digest = {
 885         CHAP_MICROSOFT_V2,      /* code */
 886         chapms2_generate_challenge,
 887         chapms2_verify_response,
 888         chapms2_make_response,
 889         chapms2_check_success,
 890         chapms_handle_failure,
 891 };
 892
 893 #ifndef UNIT_TEST
 894 void
 895 chapms_init(void)
 896 {
 897         chap_register_digest(&chapms_digest);
 898         chap_register_digest(&chapms2_digest);
 899         ppp_add_options(chapms_option_list);
 900 }
 901 #else
 902
 903 #include <time.h>
 904
 905 int debug = 1;
 906 int error_count = 0;
 907 int unsuccess = 0;
 908
 909 void random_bytes(unsigned char *bytes, int len)
 910 {
 911     int i = 0;
 912     srand(time(NULL));
 913     while (i < len) {
 914         bytes[i++] = (unsigned char) rand();
 915     }
 916 }
 917
 918
 919 int test_chap_v1(void) {
 920     char *secret = "MyPw";
 921
 922     unsigned char challenge[8] = {
 923         0x10, 0x2D, 0xB5, 0xDF, 0x08, 0x5D, 0x30, 0x41
 924     };
 925     unsigned char response[MS_CHAP_RESPONSE_LEN] = {
 926     };
 927     unsigned char result[MS_CHAP_RESPONSE_LEN] = {
 928         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 929         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 930         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 931
 932         0x4E, 0x9D, 0x3C, 0x8F, 0x9C, 0xFD, 0x38, 0x5D,
 933         0x5B, 0xF4, 0xD3, 0x24, 0x67, 0x91, 0x95, 0x6C,
 934         0xA4, 0xC3, 0x51, 0xAB, 0x40, 0x9A, 0x3D, 0x61,
 935
 936         0x01
 937     };
 938
 939     ChapMS(challenge, secret, strlen(secret), response);
 940     return memcmp(response, result, MS_CHAP_RESPONSE_LEN);
 941 }
 942
 943 int test_chap_v2(void) {
 944     char *secret = "clientPass";
 945     char *name = "User";
 946
 947     char saresponse[MS_AUTH_RESPONSE_LENGTH+1];
 948     char *saresult = "407A5589115FD0D6209F510FE9C04566932CDA56";
 949
 950     unsigned char authenticator[16] = {
 951         0x5B, 0x5D, 0x7C, 0x7D, 0x7B, 0x3F, 0x2F, 0x3E,
 952         0x3C, 0x2C, 0x60, 0x21, 0x32, 0x26, 0x26, 0x28
 953     };
 954     unsigned char peerchallenge[16] = {
 955         0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A,
 956         0x28, 0x29, 0x5F, 0x2B, 0x3A, 0x33, 0x7C, 0x7E
 957     };
 958     unsigned char result[MS_CHAP_NTRESP_LEN] = {
 959         0x82, 0x30, 0x9E, 0xCD, 0x8D, 0x70, 0x8B, 0x5E,
 960         0xA0, 0x8F, 0xAA, 0x39, 0x81, 0xCD, 0x83, 0x54,
 961         0x42, 0x33, 0x11, 0x4A, 0x3D, 0x85, 0xD6, 0xDF
 962     };
 963
 964     unsigned char response[MS_CHAP2_RESPONSE_LEN] = {
 965     };
 966
 967         ChapMS2(authenticator, peerchallenge, name,
 968                 secret, strlen(secret), response,
 969                 (unsigned char *)saresponse, MS_CHAP2_AUTHENTICATOR);
 970
 971     return memcmp(&response[MS_CHAP2_NTRESP], result, MS_CHAP2_NTRESP_LEN) ||
 972         strncmp(saresponse, saresult, MS_AUTH_RESPONSE_LENGTH);
 973 }
 974
 975 int main(int argc, char *argv[]) {
 976
 977     PPP_crypto_init();
 978
 979     if (test_chap_v1()) {
 980         printf("CHAPv1 failed\n");
 981         return -1;
 982     }
 983
 984     if (test_chap_v2()) {
 985         printf("CHAPv2 failed\n");
 986         return -1;
 987     }
 988
 989     PPP_crypto_deinit();
 990
 991     printf("Success\n");
 992     return 0;
 993 }
 994
 995 #endif  /* UNIT_TEST */
 996