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 CHAPMS
  80
  81 #include <stdio.h>
  82 #include <stdlib.h>
  83 #include <string.h>
  84 #include <ctype.h>
  85 #include <sys/types.h>
  86 #include <sys/time.h>
  87 #include <unistd.h>
  88
  89 #include "pppd.h"
  90 #include "chap-new.h"
  91 #include "chap_ms.h"
  92 #include "md4.h"
  93 #include "sha1.h"
  94 #include "pppcrypt.h"
  95 #include "magic.h"
  96
  97
  98
  99 static void     ascii2unicode __P((char[], int, u_char[]));
 100 static void     NTPasswordHash __P((u_char *, int, u_char[MD4_SIGNATURE_SIZE]));
 101 static void     ChallengeResponse __P((u_char *, u_char *, u_char[24]));
 102 static void     ChapMS_NT __P((u_char *, char *, int, u_char[24]));
 103 static void     ChapMS2_NT __P((u_char *, u_char[16], char *, char *, int,
 104                                 u_char[24]));
 105 static void     GenerateAuthenticatorResponsePlain
 106                         __P((char*, int, u_char[24], u_char[16], u_char *,
 107                              char *, u_char[41]));
 108 #ifdef MSLANMAN
 109 static void     ChapMS_LANMan __P((u_char *, char *, int, u_char *));
 110 #endif
 111
 112 #ifdef MPPE
 113 static void     Set_Start_Key __P((u_char *, char *, int));
 114 static void     SetMasterKeys __P((char *, int, u_char[24], int));
 115 #endif
 116
 117 #ifdef MSLANMAN
 118 bool    ms_lanman = 0;          /* Use LanMan password instead of NT */
 119                                 /* Has meaning only with MS-CHAP challenges */
 120 #endif
 121
 122 #ifdef MPPE
 123 u_char mppe_send_key[MPPE_MAX_KEY_LEN];
 124 u_char mppe_recv_key[MPPE_MAX_KEY_LEN];
 125 int mppe_keys_set = 0;          /* Have the MPPE keys been set? */
 126
 127 #ifdef DEBUGMPPEKEY
 128 /* For MPPE debug */
 129 /* Use "[]|}{?/><,`!2&&(" (sans quotes) for RFC 3079 MS-CHAPv2 test value */
 130 static char *mschap_challenge = NULL;
 131 /* Use "!@\#$%^&*()_+:3|~" (sans quotes, backslash is to escape #) for ... */
 132 static char *mschap2_peer_challenge = NULL;
 133 #endif
 134
 135 #include "fsm.h"                /* Need to poke MPPE options */
 136 #include "ccp.h"
 137 #include <net/ppp-comp.h>
 138 #endif
 139
 140 /*
 141  * Command-line options.
 142  */
 143 static option_t chapms_option_list[] = {
 144 #ifdef 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 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 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 void
 508 ChallengeResponse(u_char *challenge,
 509                   u_char PasswordHash[MD4_SIGNATURE_SIZE],
 510                   u_char response[24])
 511 {
 512     u_char    ZPasswordHash[21];
 513
 514     BZERO(ZPasswordHash, sizeof(ZPasswordHash));
 515     BCOPY(PasswordHash, ZPasswordHash, MD4_SIGNATURE_SIZE);
 516
 517 #if 0
 518     dbglog("ChallengeResponse - ZPasswordHash %.*B",
 519            sizeof(ZPasswordHash), ZPasswordHash);
 520 #endif
 521
 522     (void) DesSetkey(ZPasswordHash + 0);
 523     DesEncrypt(challenge, response + 0);
 524     (void) DesSetkey(ZPasswordHash + 7);
 525     DesEncrypt(challenge, response + 8);
 526     (void) DesSetkey(ZPasswordHash + 14);
 527     DesEncrypt(challenge, response + 16);
 528
 529 #if 0
 530     dbglog("ChallengeResponse - response %.24B", response);
 531 #endif
 532 }
 533
 534 void
 535 ChallengeHash(u_char PeerChallenge[16], u_char *rchallenge,
 536               char *username, u_char Challenge[8])
 537
 538 {
 539     SHA1_CTX    sha1Context;
 540     u_char      sha1Hash[SHA1_SIGNATURE_SIZE];
 541     char        *user;
 542
 543     /* remove domain from "domain\username" */
 544     if ((user = strrchr(username, '\\')) != NULL)
 545         ++user;
 546     else
 547         user = username;
 548
 549     SHA1_Init(&sha1Context);
 550     SHA1_Update(&sha1Context, PeerChallenge, 16);
 551     SHA1_Update(&sha1Context, rchallenge, 16);
 552     SHA1_Update(&sha1Context, (unsigned char *)user, strlen(user));
 553     SHA1_Final(sha1Hash, &sha1Context);
 554
 555     BCOPY(sha1Hash, Challenge, 8);
 556 }
 557
 558 /*
 559  * Convert the ASCII version of the password to Unicode.
 560  * This implicitly supports 8-bit ISO8859/1 characters.
 561  * This gives us the little-endian representation, which
 562  * is assumed by all M$ CHAP RFCs.  (Unicode byte ordering
 563  * is machine-dependent.)
 564  */
 565 static void
 566 ascii2unicode(char ascii[], int ascii_len, u_char unicode[])
 567 {
 568     int i;
 569
 570     BZERO(unicode, ascii_len * 2);
 571     for (i = 0; i < ascii_len; i++)
 572         unicode[i * 2] = (u_char) ascii[i];
 573 }
 574
 575 static void
 576 NTPasswordHash(u_char *secret, int secret_len, u_char hash[MD4_SIGNATURE_SIZE])
 577 {
 578 #ifdef __NetBSD__
 579     /* NetBSD uses the libc md4 routines which take bytes instead of bits */
 580     int                 mdlen = secret_len;
 581 #else
 582     int                 mdlen = secret_len * 8;
 583 #endif
 584     MD4_CTX             md4Context;
 585
 586     MD4Init(&md4Context);
 587     /* MD4Update can take at most 64 bytes at a time */
 588     while (mdlen > 512) {
 589         MD4Update(&md4Context, secret, 512);
 590         secret += 64;
 591         mdlen -= 512;
 592     }
 593     MD4Update(&md4Context, secret, mdlen);
 594     MD4Final(hash, &md4Context);
 595
 596 }
 597
 598 static void
 599 ChapMS_NT(u_char *rchallenge, char *secret, int secret_len,
 600           u_char NTResponse[24])
 601 {
 602     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
 603     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
 604
 605     /* Hash the Unicode version of the secret (== password). */
 606     ascii2unicode(secret, secret_len, unicodePassword);
 607     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
 608
 609     ChallengeResponse(rchallenge, PasswordHash, NTResponse);
 610 }
 611
 612 static void
 613 ChapMS2_NT(u_char *rchallenge, u_char PeerChallenge[16], char *username,
 614            char *secret, int secret_len, u_char NTResponse[24])
 615 {
 616     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
 617     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
 618     u_char      Challenge[8];
 619
 620     ChallengeHash(PeerChallenge, rchallenge, username, Challenge);
 621
 622     /* Hash the Unicode version of the secret (== password). */
 623     ascii2unicode(secret, secret_len, unicodePassword);
 624     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
 625
 626     ChallengeResponse(Challenge, PasswordHash, NTResponse);
 627 }
 628
 629 #ifdef MSLANMAN
 630 static u_char *StdText = (u_char *)"KGS!@#$%"; /* key from rasapi32.dll */
 631
 632 static void
 633 ChapMS_LANMan(u_char *rchallenge, char *secret, int secret_len,
 634               unsigned char *response)
 635 {
 636     int                 i;
 637     u_char              UcasePassword[MAX_NT_PASSWORD]; /* max is actually 14 */
 638     u_char              PasswordHash[MD4_SIGNATURE_SIZE];
 639
 640     /* LANMan password is case insensitive */
 641     BZERO(UcasePassword, sizeof(UcasePassword));
 642     for (i = 0; i < secret_len; i++)
 643        UcasePassword[i] = (u_char)toupper(secret[i]);
 644     (void) DesSetkey(UcasePassword + 0);
 645     DesEncrypt( StdText, PasswordHash + 0 );
 646     (void) DesSetkey(UcasePassword + 7);
 647     DesEncrypt( StdText, PasswordHash + 8 );
 648     ChallengeResponse(rchallenge, PasswordHash, &response[MS_CHAP_LANMANRESP]);
 649 }
 650 #endif
 651
 652
 653 void
 654 GenerateAuthenticatorResponse(u_char PasswordHashHash[MD4_SIGNATURE_SIZE],
 655                               u_char NTResponse[24], u_char PeerChallenge[16],
 656                               u_char *rchallenge, char *username,
 657                               u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1])
 658 {
 659     /*
 660      * "Magic" constants used in response generation, from RFC 2759.
 661      */
 662     u_char Magic1[39] = /* "Magic server to client signing constant" */
 663         { 0x4D, 0x61, 0x67, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76,
 664           0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6C, 0x69, 0x65,
 665           0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67,
 666           0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74 };
 667     u_char Magic2[41] = /* "Pad to make it do more than one iteration" */
 668         { 0x50, 0x61, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B,
 669           0x65, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6D, 0x6F,
 670           0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E,
 671           0x65, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F,
 672           0x6E };
 673
 674     int         i;
 675     SHA1_CTX    sha1Context;
 676     u_char      Digest[SHA1_SIGNATURE_SIZE];
 677     u_char      Challenge[8];
 678
 679     SHA1_Init(&sha1Context);
 680     SHA1_Update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
 681     SHA1_Update(&sha1Context, NTResponse, 24);
 682     SHA1_Update(&sha1Context, Magic1, sizeof(Magic1));
 683     SHA1_Final(Digest, &sha1Context);
 684
 685     ChallengeHash(PeerChallenge, rchallenge, username, Challenge);
 686
 687     SHA1_Init(&sha1Context);
 688     SHA1_Update(&sha1Context, Digest, sizeof(Digest));
 689     SHA1_Update(&sha1Context, Challenge, sizeof(Challenge));
 690     SHA1_Update(&sha1Context, Magic2, sizeof(Magic2));
 691     SHA1_Final(Digest, &sha1Context);
 692
 693     /* Convert to ASCII hex string. */
 694     for (i = 0; i < MAX((MS_AUTH_RESPONSE_LENGTH / 2), sizeof(Digest)); i++)
 695         sprintf((char *)&authResponse[i * 2], "%02X", Digest[i]);
 696 }
 697
 698
 699 static void
 700 GenerateAuthenticatorResponsePlain
 701                 (char *secret, int secret_len,
 702                  u_char NTResponse[24], u_char PeerChallenge[16],
 703                  u_char *rchallenge, char *username,
 704                  u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1])
 705 {
 706     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
 707     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
 708     u_char      PasswordHashHash[MD4_SIGNATURE_SIZE];
 709
 710     /* Hash (x2) the Unicode version of the secret (== password). */
 711     ascii2unicode(secret, secret_len, unicodePassword);
 712     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
 713     NTPasswordHash(PasswordHash, sizeof(PasswordHash),
 714                    PasswordHashHash);
 715
 716     GenerateAuthenticatorResponse(PasswordHashHash, NTResponse, PeerChallenge,
 717                                   rchallenge, username, authResponse);
 718 }
 719
 720
 721 #ifdef MPPE
 722 /*
 723  * Set mppe_xxxx_key from the NTPasswordHashHash.
 724  * RFC 2548 (RADIUS support) requires us to export this function (ugh).
 725  */
 726 void
 727 mppe_set_keys(u_char *rchallenge, u_char PasswordHashHash[MD4_SIGNATURE_SIZE])
 728 {
 729     SHA1_CTX    sha1Context;
 730     u_char      Digest[SHA1_SIGNATURE_SIZE];    /* >= MPPE_MAX_KEY_LEN */
 731
 732     SHA1_Init(&sha1Context);
 733     SHA1_Update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
 734     SHA1_Update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
 735     SHA1_Update(&sha1Context, rchallenge, 8);
 736     SHA1_Final(Digest, &sha1Context);
 737
 738     /* Same key in both directions. */
 739     BCOPY(Digest, mppe_send_key, sizeof(mppe_send_key));
 740     BCOPY(Digest, mppe_recv_key, sizeof(mppe_recv_key));
 741
 742     mppe_keys_set = 1;
 743 }
 744
 745 /*
 746  * Set mppe_xxxx_key from MS-CHAP credentials. (see RFC 3079)
 747  */
 748 static void
 749 Set_Start_Key(u_char *rchallenge, char *secret, int secret_len)
 750 {
 751     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
 752     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
 753     u_char      PasswordHashHash[MD4_SIGNATURE_SIZE];
 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), PasswordHashHash);
 759
 760     mppe_set_keys(rchallenge, PasswordHashHash);
 761 }
 762
 763 /*
 764  * Set mppe_xxxx_key from MS-CHAPv2 credentials. (see RFC 3079)
 765  *
 766  * This helper function used in the Winbind module, which gets the
 767  * NTHashHash from the server.
 768  */
 769 void
 770 mppe_set_keys2(u_char PasswordHashHash[MD4_SIGNATURE_SIZE],
 771                u_char NTResponse[24], int IsServer)
 772 {
 773     SHA1_CTX    sha1Context;
 774     u_char      MasterKey[SHA1_SIGNATURE_SIZE]; /* >= MPPE_MAX_KEY_LEN */
 775     u_char      Digest[SHA1_SIGNATURE_SIZE];    /* >= MPPE_MAX_KEY_LEN */
 776
 777     u_char SHApad1[40] =
 778         { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 779           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 780           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 781           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 782     u_char SHApad2[40] =
 783         { 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
 784           0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
 785           0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
 786           0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2 };
 787
 788     /* "This is the MPPE Master Key" */
 789     u_char Magic1[27] =
 790         { 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74,
 791           0x68, 0x65, 0x20, 0x4d, 0x50, 0x50, 0x45, 0x20, 0x4d,
 792           0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x4b, 0x65, 0x79 };
 793     /* "On the client side, this is the send key; "
 794        "on the server side, it is the receive key." */
 795     u_char Magic2[84] =
 796         { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
 797           0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
 798           0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
 799           0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x6b, 0x65, 0x79,
 800           0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73,
 801           0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x69, 0x64, 0x65,
 802           0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
 803           0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
 804           0x6b, 0x65, 0x79, 0x2e };
 805     /* "On the client side, this is the receive key; "
 806        "on the server side, it is the send key." */
 807     u_char Magic3[84] =
 808         { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
 809           0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
 810           0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
 811           0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
 812           0x6b, 0x65, 0x79, 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68,
 813           0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73,
 814           0x69, 0x64, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73,
 815           0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20,
 816           0x6b, 0x65, 0x79, 0x2e };
 817     u_char *s;
 818
 819     SHA1_Init(&sha1Context);
 820     SHA1_Update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
 821     SHA1_Update(&sha1Context, NTResponse, 24);
 822     SHA1_Update(&sha1Context, Magic1, sizeof(Magic1));
 823     SHA1_Final(MasterKey, &sha1Context);
 824
 825     /*
 826      * generate send key
 827      */
 828     if (IsServer)
 829         s = Magic3;
 830     else
 831         s = Magic2;
 832     SHA1_Init(&sha1Context);
 833     SHA1_Update(&sha1Context, MasterKey, 16);
 834     SHA1_Update(&sha1Context, SHApad1, sizeof(SHApad1));
 835     SHA1_Update(&sha1Context, s, 84);
 836     SHA1_Update(&sha1Context, SHApad2, sizeof(SHApad2));
 837     SHA1_Final(Digest, &sha1Context);
 838
 839     BCOPY(Digest, mppe_send_key, sizeof(mppe_send_key));
 840
 841     /*
 842      * generate recv key
 843      */
 844     if (IsServer)
 845         s = Magic2;
 846     else
 847         s = Magic3;
 848     SHA1_Init(&sha1Context);
 849     SHA1_Update(&sha1Context, MasterKey, 16);
 850     SHA1_Update(&sha1Context, SHApad1, sizeof(SHApad1));
 851     SHA1_Update(&sha1Context, s, 84);
 852     SHA1_Update(&sha1Context, SHApad2, sizeof(SHApad2));
 853     SHA1_Final(Digest, &sha1Context);
 854
 855     BCOPY(Digest, mppe_recv_key, sizeof(mppe_recv_key));
 856
 857     mppe_keys_set = 1;
 858 }
 859
 860 /*
 861  * Set mppe_xxxx_key from MS-CHAPv2 credentials. (see RFC 3079)
 862  */
 863 static void
 864 SetMasterKeys(char *secret, int secret_len, u_char NTResponse[24], int IsServer)
 865 {
 866     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
 867     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
 868     u_char      PasswordHashHash[MD4_SIGNATURE_SIZE];
 869     /* Hash (x2) the Unicode version of the secret (== password). */
 870     ascii2unicode(secret, secret_len, unicodePassword);
 871     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
 872     NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);
 873     mppe_set_keys2(PasswordHashHash, NTResponse, IsServer);
 874 }
 875
 876 #endif /* MPPE */
 877
 878
 879 void
 880 ChapMS(u_char *rchallenge, char *secret, int secret_len,
 881        unsigned char *response)
 882 {
 883     BZERO(response, MS_CHAP_RESPONSE_LEN);
 884
 885     ChapMS_NT(rchallenge, secret, secret_len, &response[MS_CHAP_NTRESP]);
 886
 887 #ifdef MSLANMAN
 888     ChapMS_LANMan(rchallenge, secret, secret_len,
 889                   &response[MS_CHAP_LANMANRESP]);
 890
 891     /* preferred method is set by option  */
 892     response[MS_CHAP_USENT] = !ms_lanman;
 893 #else
 894     response[MS_CHAP_USENT] = 1;
 895 #endif
 896
 897 #ifdef MPPE
 898     Set_Start_Key(rchallenge, secret, secret_len);
 899 #endif
 900 }
 901
 902
 903 /*
 904  * If PeerChallenge is NULL, one is generated and the PeerChallenge
 905  * field of response is filled in.  Call this way when generating a response.
 906  * If PeerChallenge is supplied, it is copied into the PeerChallenge field.
 907  * Call this way when verifying a response (or debugging).
 908  * Do not call with PeerChallenge = response.
 909  *
 910  * The PeerChallenge field of response is then used for calculation of the
 911  * Authenticator Response.
 912  */
 913 void
 914 ChapMS2(u_char *rchallenge, u_char *PeerChallenge,
 915         char *user, char *secret, int secret_len, unsigned char *response,
 916         u_char authResponse[], int authenticator)
 917 {
 918     /* ARGSUSED */
 919     u_char *p = &response[MS_CHAP2_PEER_CHALLENGE];
 920     int i;
 921
 922     BZERO(response, MS_CHAP2_RESPONSE_LEN);
 923
 924     /* Generate the Peer-Challenge if requested, or copy it if supplied. */
 925     if (!PeerChallenge)
 926         for (i = 0; i < MS_CHAP2_PEER_CHAL_LEN; i++)
 927             *p++ = (u_char) (drand48() * 0xff);
 928     else
 929         BCOPY(PeerChallenge, &response[MS_CHAP2_PEER_CHALLENGE],
 930               MS_CHAP2_PEER_CHAL_LEN);
 931
 932     /* Generate the NT-Response */
 933     ChapMS2_NT(rchallenge, &response[MS_CHAP2_PEER_CHALLENGE], user,
 934                secret, secret_len, &response[MS_CHAP2_NTRESP]);
 935
 936     /* Generate the Authenticator Response. */
 937     GenerateAuthenticatorResponsePlain(secret, secret_len,
 938                                        &response[MS_CHAP2_NTRESP],
 939                                        &response[MS_CHAP2_PEER_CHALLENGE],
 940                                        rchallenge, user, authResponse);
 941
 942 #ifdef MPPE
 943     SetMasterKeys(secret, secret_len,
 944                   &response[MS_CHAP2_NTRESP], authenticator);
 945 #endif
 946 }
 947
 948 #ifdef MPPE
 949 /*
 950  * Set MPPE options from plugins.
 951  */
 952 void
 953 set_mppe_enc_types(int policy, int types)
 954 {
 955     /* Early exit for unknown policies. */
 956     if (policy != MPPE_ENC_POL_ENC_ALLOWED ||
 957         policy != MPPE_ENC_POL_ENC_REQUIRED)
 958         return;
 959
 960     /* Don't modify MPPE if it's optional and wasn't already configured. */
 961     if (policy == MPPE_ENC_POL_ENC_ALLOWED && !ccp_wantoptions[0].mppe)
 962         return;
 963
 964     /*
 965      * Disable undesirable encryption types.  Note that we don't ENABLE
 966      * any encryption types, to avoid overriding manual configuration.
 967      */
 968     switch(types) {
 969         case MPPE_ENC_TYPES_RC4_40:
 970             ccp_wantoptions[0].mppe &= ~MPPE_OPT_128;   /* disable 128-bit */
 971             break;
 972         case MPPE_ENC_TYPES_RC4_128:
 973             ccp_wantoptions[0].mppe &= ~MPPE_OPT_40;    /* disable 40-bit */
 974             break;
 975         default:
 976             break;
 977     }
 978 }
 979 #endif /* MPPE */
 980
 981 static struct chap_digest_type chapms_digest = {
 982         CHAP_MICROSOFT,         /* code */
 983         chapms_generate_challenge,
 984         chapms_verify_response,
 985         chapms_make_response,
 986         NULL,                   /* check_success */
 987         chapms_handle_failure,
 988 };
 989
 990 static struct chap_digest_type chapms2_digest = {
 991         CHAP_MICROSOFT_V2,      /* code */
 992         chapms2_generate_challenge,
 993         chapms2_verify_response,
 994         chapms2_make_response,
 995         chapms2_check_success,
 996         chapms_handle_failure,
 997 };
 998
 999 void
1000 chapms_init(void)
1001 {
1002         chap_register_digest(&chapms_digest);
1003         chap_register_digest(&chapms2_digest);
1004         add_options(chapms_option_list);
1005 }
1006
1007 #endif /* CHAPMS */