src/modules/rlm_mschap/rlm_mschap.c

   1 /*
   2  * rlm_mschap.c
   3  *
   4  * Version:     $Id$
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * Copyright 2000,2001  The FreeRADIUS server project
  21  */
  22
  23
  24 /*
  25  *  mschap.c    MS-CHAP module
  26  *
  27  *  This implements MS-CHAP, as described in RFC 2548
  28  *
  29  *  http://www.freeradius.org/rfc/rfc2548.txt
  30  *
  31  */
  32
  33 /*
  34  *  If you have any questions on NTLM (Samba) passwords
  35  *  support, LM authentication and MS-CHAP v2 support
  36  *  please contact
  37  *
  38  *  Vladimir Dubrovin   vlad@sandy.ru
  39  *  aka
  40  *  ZARAZA              3APA3A@security.nnov.ru
  41  */
  42
  43 /*  MPPE support from Takahiro Wagatsuma <waga@sic.shibaura-it.ac.jp> */
  44
  45 #include        "autoconf.h"
  46 #include        "libradius.h"
  47
  48 #include        <stdio.h>
  49 #include        <stdlib.h>
  50 #include        <string.h>
  51 #include        <ctype.h>
  52
  53 #include        "radiusd.h"
  54 #include        "modules.h"
  55
  56 #include        "md4.h"
  57 #include        "md5.h"
  58 #include        "sha1.h"
  59 #include        "rad_assert.h"
  60
  61 #include        "smbdes.h"
  62
  63 static const char rcsid[] = "$Id$";
  64
  65 static const char *letters = "0123456789ABCDEF";
  66
  67 /*
  68  *      hex2bin converts hexadecimal strings into binary
  69  */
  70 static int hex2bin (const char *szHex, unsigned char* szBin, int len)
  71 {
  72         char * c1, * c2;
  73         int i;
  74
  75         for (i = 0; i < len; i++) {
  76                 if( !(c1 = memchr(letters, toupper((int) szHex[i << 1]), 16)) ||
  77                     !(c2 = memchr(letters, toupper((int) szHex[(i << 1) + 1]), 16)))
  78                      break;
  79                  szBin[i] = ((c1-letters)<<4) + (c2-letters);
  80         }
  81         return i;
  82 }
  83
  84 /*
  85  *      bin2hex creates hexadecimal presentation
  86  *      of binary data
  87  */
  88 static void bin2hex (const unsigned char *szBin, char *szHex, int len)
  89 {
  90         int i;
  91         for (i = 0; i < len; i++) {
  92                 szHex[i<<1] = letters[szBin[i] >> 4];
  93                 szHex[(i<<1) + 1] = letters[szBin[i] & 0x0F];
  94         }
  95 }
  96
  97
  98 /* Allowable account control bits */
  99 #define ACB_DISABLED   0x0001  /* 1 = User account disabled */
 100 #define ACB_HOMDIRREQ  0x0002  /* 1 = Home directory required */
 101 #define ACB_PWNOTREQ   0x0004  /* 1 = User password not required */
 102 #define ACB_TEMPDUP    0x0008  /* 1 = Temporary duplicate account */
 103 #define ACB_NORMAL     0x0010  /* 1 = Normal user account */
 104 #define ACB_MNS        0x0020  /* 1 = MNS logon user account */
 105 #define ACB_DOMTRUST   0x0040  /* 1 = Interdomain trust account */
 106 #define ACB_WSTRUST    0x0080  /* 1 = Workstation trust account */
 107 #define ACB_SVRTRUST   0x0100  /* 1 = Server trust account */
 108 #define ACB_PWNOEXP    0x0200  /* 1 = User password does not expire */
 109 #define ACB_AUTOLOCK   0x0400  /* 1 = Account auto locked */
 110
 111 static int pdb_decode_acct_ctrl(const char *p)
 112 {
 113         int acct_ctrl = 0;
 114         int finished = 0;
 115
 116         /*
 117          * Check if the account type bits have been encoded after the
 118          * NT password (in the form [NDHTUWSLXI]).
 119          */
 120
 121         if (*p != '[') return 0;
 122
 123         for (p++; *p && !finished; p++) {
 124                 switch (*p) {
 125                         case 'N': /* 'N'o password. */
 126                           acct_ctrl |= ACB_PWNOTREQ;
 127                           break;
 128
 129                         case 'D':  /* 'D'isabled. */
 130                           acct_ctrl |= ACB_DISABLED ;
 131                           break;
 132
 133                         case 'H':  /* 'H'omedir required. */
 134                           acct_ctrl |= ACB_HOMDIRREQ;
 135                           break;
 136
 137                         case 'T': /* 'T'emp account. */
 138                           acct_ctrl |= ACB_TEMPDUP;
 139                           break;
 140
 141                         case 'U': /* 'U'ser account (normal). */
 142                           acct_ctrl |= ACB_NORMAL;
 143                           break;
 144
 145                         case 'M': /* 'M'NS logon user account. What is this? */
 146                           acct_ctrl |= ACB_MNS;
 147                           break;
 148
 149                         case 'W': /* 'W'orkstation account. */
 150                           acct_ctrl |= ACB_WSTRUST;
 151                           break;
 152
 153                         case 'S': /* 'S'erver account. */
 154                           acct_ctrl |= ACB_SVRTRUST;
 155                           break;
 156
 157                         case 'L': /* 'L'ocked account. */
 158                           acct_ctrl |= ACB_AUTOLOCK;
 159                           break;
 160
 161                         case 'X': /* No 'X'piry on password */
 162                           acct_ctrl |= ACB_PWNOEXP;
 163                           break;
 164
 165                         case 'I': /* 'I'nterdomain trust account. */
 166                           acct_ctrl |= ACB_DOMTRUST;
 167                           break;
 168
 169                         case ' ': /* ignore spaces */
 170                           break;
 171
 172                         case ':':
 173                         case '\n':
 174                         case '\0':
 175                         case ']':
 176                         default:
 177                           finished = 1;
 178                           break;
 179                 }
 180         }
 181
 182         return acct_ctrl;
 183 }
 184
 185
 186 /*
 187  *      ntpwdhash converts Unicode password to 16-byte NT hash
 188  *      with MD4
 189  */
 190 static void ntpwdhash (unsigned char *szHash, const char *szPassword)
 191 {
 192         char szUnicodePass[513];
 193         int nPasswordLen;
 194         int i;
 195
 196         /*
 197          *      NT passwords are unicode.  Convert plain text password
 198          *      to unicode by inserting a zero every other byte
 199          */
 200         nPasswordLen = strlen(szPassword);
 201         for (i = 0; i < nPasswordLen; i++) {
 202                 szUnicodePass[i << 1] = szPassword[i];
 203                 szUnicodePass[(i << 1) + 1] = 0;
 204         }
 205
 206         /* Encrypt Unicode password to a 16-byte MD4 hash */
 207         md4_calc(szHash, szUnicodePass, (nPasswordLen<<1) );
 208 }
 209
 210
 211 /*
 212  *      challenge_hash() is used by mschap2() and auth_response()
 213  *      implements RFC2759 ChallengeHash()
 214  *      generates 64 bit challenge
 215  */
 216 static void challenge_hash( const char *peer_challenge,
 217                             const char *auth_challenge,
 218                             const char *user_name, char *challenge )
 219 {
 220         SHA1_CTX Context;
 221         unsigned char hash[20];
 222
 223         SHA1Init(&Context);
 224         SHA1Update(&Context, peer_challenge, 16);
 225         SHA1Update(&Context, auth_challenge, 16);
 226         SHA1Update(&Context, user_name, strlen(user_name));
 227         SHA1Final(hash, &Context);
 228         memcpy(challenge, hash, 8);
 229 }
 230
 231 /*
 232  *      auth_response() generates MS-CHAP v2 SUCCESS response
 233  *      according to RFC 2759 GenerateAuthenticatorResponse()
 234  *      returns 42-octet response string
 235  */
 236 static void auth_response(const char *username,
 237                           const unsigned char *nt_hash_hash,
 238                           unsigned char *ntresponse,
 239                           char *peer_challenge, char *auth_challenge,
 240                           char *response)
 241 {
 242         SHA1_CTX Context;
 243         const unsigned char magic1[39] =
 244         {0x4D, 0x61, 0x67, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76,
 245          0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6C, 0x69, 0x65,
 246          0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67,
 247          0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74};
 248
 249         const unsigned char magic2[41] =
 250         {0x50, 0x61, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B,
 251          0x65, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6D, 0x6F,
 252          0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E,
 253          0x65, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F,
 254          0x6E};
 255
 256         char challenge[8];
 257         unsigned char digest[20];
 258
 259         SHA1Init(&Context);
 260         SHA1Update(&Context, nt_hash_hash, 16);
 261         SHA1Update(&Context, ntresponse, 24);
 262         SHA1Update(&Context, magic1, 39);
 263         SHA1Final(digest, &Context);
 264         challenge_hash(peer_challenge, auth_challenge, username, challenge);
 265         SHA1Init(&Context);
 266         SHA1Update(&Context, digest, 20);
 267         SHA1Update(&Context, challenge, 8);
 268         SHA1Update(&Context, magic2, 41);
 269         SHA1Final(digest, &Context);
 270
 271         /*
 272          *      Encode the value of 'Digest' as "S=" followed by
 273          *      40 ASCII hexadecimal digits and return it in
 274          *      AuthenticatorResponse.
 275          *      For example,
 276          *      "S=0123456789ABCDEF0123456789ABCDEF01234567"
 277          */
 278         response[0] = 'S';
 279         response[1] = '=';
 280         bin2hex(digest, response + 2, 20);
 281 }
 282
 283
 284 typedef struct rlm_mschap_t {
 285         int use_mppe;
 286         int require_encryption;
 287         int require_strong;
 288         int with_ntdomain_hack; /* this should be in another module */
 289         char *passwd_file;
 290         char *xlat_name;
 291         char *ntlm_auth;
 292         char *auth_type;
 293 } rlm_mschap_t;
 294
 295
 296 /*
 297  *      Does dynamic translation of strings.
 298  *
 299  *      Pulls NT-Response, LM-Response, or Challenge from MSCHAP
 300  *      attributes.
 301  */
 302 static int mschap_xlat(void *instance, REQUEST *request,
 303                        char *fmt, char *out, size_t outlen,
 304                        RADIUS_ESCAPE_STRING func)
 305 {
 306         int             i, data_len;
 307         uint8_t         *data = NULL;
 308         uint8_t         buffer[8];
 309         VALUE_PAIR      *user_name;
 310         VALUE_PAIR      *chap_challenge, *response;
 311         rlm_mschap_t    *inst = instance;
 312
 313         chap_challenge = response = NULL;
 314
 315         func = func;            /* -Wunused */
 316
 317         /*
 318          *      Challenge means MS-CHAPv1 challenge, or
 319          *      hash of MS-CHAPv2 challenge, and peer challenge.
 320          */
 321         if (strcasecmp(fmt, "Challenge") == 0) {
 322                 chap_challenge = pairfind(request->packet->vps,
 323                                           PW_MSCHAP_CHALLENGE);
 324                 if (!chap_challenge) {
 325                         DEBUG2("  rlm_mschap: No MS-CHAP-Challenge in the request.");
 326                         return 0;
 327                 }
 328
 329                 /*
 330                  *      MS-CHAP-Challenges are 8 octets,
 331                  *      for MS-CHAPv2
 332                  */
 333                 if (chap_challenge->length == 8) {
 334                         DEBUG2(" mschap1: %02x", chap_challenge->strvalue[0]);
 335                         data = chap_challenge->strvalue;
 336                         data_len = 8;
 337
 338                         /*
 339                          *      MS-CHAP-Challenges are 16 octets,
 340                          *      for MS-CHAPv2.
 341                          */
 342                 } else if (chap_challenge->length == 16) {
 343                         char *username_string;
 344
 345                         DEBUG2(" mschap2: %02x", chap_challenge->strvalue[0]);
 346                         response = pairfind(request->packet->vps,
 347                                             PW_MSCHAP2_RESPONSE);
 348                         if (!response) {
 349                                 DEBUG2("  rlm_mschap: MS-CHAP2-Response is required to calculate MS-CHAPv1 challenge.");
 350                                 return 0;
 351                         }
 352
 353                         /*
 354                          *      Responses are 50 octets.
 355                          */
 356                         if (response->length < 50) {
 357                                 radlog(L_AUTH, "rlm_mschap: MS-CHAP-Response has the wrong format.");
 358                                 return 0;
 359                         }
 360
 361                         user_name = pairfind(request->packet->vps,
 362                                              PW_USER_NAME);
 363                         if (!user_name) {
 364                                 DEBUG2("  rlm_mschap: User-Name is required to calculateMS-CHAPv1 Challenge.");
 365                                 return 0;
 366                         }
 367
 368                         /*
 369                          *      with_ntdomain_hack moved here, too.
 370                          */
 371                         if ((username_string = strchr(user_name->strvalue, '\\')) != NULL) {
 372                                 if (inst->with_ntdomain_hack) {
 373                                         username_string++;
 374                                 } else {
 375                                         DEBUG2("  rlm_mschap: NT Domain delimeter found, should we have enabled with_ntdomain_hack?");
 376                                         username_string = user_name->strvalue;
 377                                 }
 378                         } else {
 379                                 username_string = user_name->strvalue;
 380                         }
 381
 382                         /*
 383                          *      Get the MS-CHAPv1 challenge
 384                          *      from the MS-CHAPv2 peer challenge,
 385                          *      our challenge, and the user name.
 386                          */
 387                         challenge_hash(response->strvalue + 2,
 388                                        chap_challenge->strvalue,
 389                                        username_string, buffer);
 390                         data = buffer;
 391                         data_len = 8;
 392                 } else {
 393                         DEBUG2("  rlm_mschap: Invalid MS-CHAP challenge length");
 394                         return 0;
 395                 }
 396
 397                 /*
 398                  *      Get the MS-CHAPv1 response, or the MS-CHAPv2
 399                  *      response.
 400                  */
 401         } else if (strcasecmp(fmt, "NT-Response") == 0) {
 402                 response = pairfind(request->packet->vps,
 403                                     PW_MSCHAP_RESPONSE);
 404                 if (!response) response = pairfind(request->packet->vps,
 405                                                    PW_MSCHAP2_RESPONSE);
 406                 if (!response) {
 407                         DEBUG2("  rlm_mschap: No MS-CHAP-Response or MS-CHAP2-Response was found in the request.");
 408                         return 0;
 409                 }
 410
 411                 /*
 412                  *      For MS-CHAPv1, the NT-Response exists only
 413                  *      if the second octet says so.
 414                  */
 415                 if ((response->attribute == PW_MSCHAP_RESPONSE) &&
 416                     ((response->strvalue[1] & 0x01) == 0)) {
 417                         DEBUG2("  rlm_mschap: No NT-Response in MS-CHAP-Response");
 418                         return 0;
 419                 }
 420
 421                 /*
 422                  *      MS-CHAP-Response and MS-CHAP2-Response have
 423                  *      the NT-Response at the same offset, and are
 424                  *      the same length.
 425                  */
 426                 data = response->strvalue + 26;
 427                 data_len = 24;
 428
 429                 /*
 430                  *      LM-Response is deprecated, and exists only
 431                  *      in MS-CHAPv1, and not often there.
 432                  */
 433         } else if (strcasecmp(fmt, "LM-Response") == 0) {
 434                 response = pairfind(request->packet->vps,
 435                                     PW_MSCHAP_RESPONSE);
 436                 if (!response) {
 437                         DEBUG2("  rlm_mschap: No MS-CHAP-Response was found in the request.");
 438                         return 0;
 439                 }
 440
 441                 /*
 442                  *      For MS-CHAPv1, the NT-Response exists only
 443                  *      if the second octet says so.
 444                  */
 445                 if ((response->strvalue[1] & 0x01) != 0) {
 446                         DEBUG2("  rlm_mschap: No LM-Response in MS-CHAP-Response");
 447                         return 0;
 448                 }
 449                 data = response->strvalue + 2;
 450                 data_len = 24;
 451
 452                 /*
 453                  *      Pull the NT-Domain out of the User-Name, if it exists.
 454                  */
 455         } else if (strcasecmp(fmt, "NT-Domain") == 0) {
 456                 char *p, *q;
 457
 458                 user_name = pairfind(request->packet->vps, PW_USER_NAME);
 459                 if (!user_name) {
 460                         DEBUG2("  rlm_mschap: No User-Name was found in the request.");
 461                         return 0;
 462                 }
 463
 464                 /*
 465                  *      First check to see if this is a host/ style User-Name
 466                  *      (a la Kerberos host principal)
 467                  */
 468                 if (strncmp(user_name->strvalue, "host/", 5) == 0) {
 469                         /*
 470                          *      If we're getting a User-Name formatted in this way,
 471                          *      it's likely due to PEAP.  The Windows Domain will be
 472                          *      the first domain component following the hostname,
 473                          *      or the machine name itself if only a hostname is supplied
 474                          */
 475                         p = strchr(user_name->strvalue, '.');
 476                         if (!p) {
 477                                 DEBUG2("  rlm_mschap: setting NT-Domain to same as machine name");
 478                                 strNcpy(out, user_name->strvalue + 5, outlen);
 479                         } else {
 480                                 p++;    /* skip the period */
 481                                 q = strchr(p, '.');
 482                                 /*
 483                                  * use the same hack as below
 484                                  * only if another period was found
 485                                  */
 486                                 if (q) *q = '\0';
 487                                 strNcpy(out, p, outlen);
 488                                 if (q) *q = '.';
 489                         }
 490                 } else {
 491                         p = strchr(user_name->strvalue, '\\');
 492                         if (!p) {
 493                                 DEBUG2("  rlm_mschap: No NT-Domain was found in the User-Name.");
 494                                 return 0;
 495                         }
 496
 497                         /*
 498                          *      Hack.  This is simpler than the alternatives.
 499                          */
 500                         *p = '\0';
 501                         strNcpy(out, user_name->strvalue, outlen);
 502                         *p = '\\';
 503                 }
 504
 505                 return strlen(out);
 506
 507                 /*
 508                  *      Pull the User-Name out of the User-Name...
 509                  */
 510         } else if (strcasecmp(fmt, "User-Name") == 0) {
 511                 char *p;
 512
 513                 user_name = pairfind(request->packet->vps, PW_USER_NAME);
 514                 if (!user_name) {
 515                         DEBUG2("  rlm_mschap: No User-Name was found in the request.");
 516                         return 0;
 517                 }
 518
 519                 /*
 520                  *      First check to see if this is a host/ style User-Name
 521                  *      (a la Kerberos host principal)
 522                  */
 523                 if (strncmp(user_name->strvalue, "host/", 5) == 0) {
 524                         /*
 525                          *      If we're getting a User-Name formatted in this way,
 526                          *      it's likely due to PEAP.  When authenticating this against
 527                          *      a Domain, Windows will expect the User-Name to be in the
 528                          *      format of hostname$, the SAM version of the name, so we
 529                          *      have to convert it to that here.  We do so by stripping
 530                          *      off the first 5 characters (host/), and copying everything
 531                          *      from that point to the first period into a string and appending
 532                          *      a $ to the end.
 533                          */
 534                         p = strchr(user_name->strvalue, '.');
 535                         /*
 536                          * use the same hack as above
 537                          * only if a period was found
 538                          */
 539                         if (p) *p = '\0';
 540                         snprintf(out, outlen, "%s$", user_name->strvalue + 5);
 541                         if (p) *p = '.';
 542                 } else {
 543                         p = strchr(user_name->strvalue, '\\');
 544                         if (p) {
 545                                 p++;    /* skip the backslash */
 546                         } else {
 547                                 p = user_name->strvalue; /* use the whole User-Name */
 548                         }
 549                         strNcpy(out, p, outlen);
 550                 }
 551
 552                 return strlen(out);
 553
 554         } else {
 555                 DEBUG2("  rlm_mschap: Unknown expansion string \"%s\"",
 556                        fmt);
 557                 return 0;
 558         }
 559
 560         if (outlen == 0) return 0; /* nowhere to go, don't do anything */
 561
 562         /*
 563          *      Didn't set anything: this is bad.
 564          */
 565         if (!data) {
 566                 DEBUG2("  rlm_mschap: Failed to do anything intelligent");
 567                 return 0;
 568         }
 569
 570         /*
 571          *      Check the output length.
 572          */
 573         if (outlen < ((data_len * 2) + 1)) {
 574                 data_len = (outlen - 1) / 2;
 575         }
 576
 577         /*
 578          *
 579          */
 580         for (i = 0; i < data_len; i++) {
 581                 sprintf(out + (2 * i), "%02x", data[i]);
 582         }
 583         out[data_len * 2] = '\0';
 584
 585         return data_len * 2;
 586 }
 587
 588
 589 static CONF_PARSER module_config[] = {
 590         /*
 591          *      Cache the password by default.
 592          */
 593         { "use_mppe",    PW_TYPE_BOOLEAN,
 594           offsetof(rlm_mschap_t,use_mppe), NULL, "yes" },
 595         { "require_encryption",    PW_TYPE_BOOLEAN,
 596           offsetof(rlm_mschap_t,require_encryption), NULL, "no" },
 597         { "require_strong",    PW_TYPE_BOOLEAN,
 598           offsetof(rlm_mschap_t,require_strong), NULL, "no" },
 599         { "with_ntdomain_hack",     PW_TYPE_BOOLEAN,
 600           offsetof(rlm_mschap_t,with_ntdomain_hack), NULL, "no" },
 601         { "passwd",   PW_TYPE_STRING_PTR,
 602           offsetof(rlm_mschap_t, passwd_file), NULL,  NULL },
 603         { "ntlm_auth",   PW_TYPE_STRING_PTR,
 604           offsetof(rlm_mschap_t, ntlm_auth), NULL,  NULL },
 605
 606         { NULL, -1, 0, NULL, NULL }             /* end the list */
 607 };
 608
 609 /*
 610  *      deinstantiate module, free all memory allocated during
 611  *      mschap_instantiate()
 612  */
 613 static int mschap_detach(void *instance){
 614 #define inst ((rlm_mschap_t *)instance)
 615         free(inst->passwd_file);
 616         free(inst->ntlm_auth);
 617         if (inst->xlat_name) {
 618                 xlat_unregister(inst->xlat_name, mschap_xlat);
 619                 free(inst->xlat_name);
 620         }
 621         free(instance);
 622         return 0;
 623 #undef inst
 624 }
 625
 626 /*
 627  *      Create instance for our module. Allocate space for
 628  *      instance structure and read configuration parameters
 629  */
 630 static int mschap_instantiate(CONF_SECTION *conf, void **instance)
 631 {
 632         const char *xlat_name;
 633         rlm_mschap_t *inst;
 634
 635         inst = *instance = rad_malloc(sizeof(*inst));
 636         if (!inst) {
 637                 return -1;
 638         }
 639         memset(inst, 0, sizeof(*inst));
 640
 641         if (cf_section_parse(conf, inst, module_config) < 0) {
 642                 free(inst);
 643                 return -1;
 644         }
 645
 646         /*
 647          *      This module used to support SMB Password files, but it
 648          *      made it too complicated.  If the user tries to
 649          *      configure an SMB Password file, then die, with an
 650          *      error message.
 651          */
 652         if (inst->passwd_file) {
 653                 radlog(L_ERR, "rlm_mschap: SMB password file is no longer supported in this module.  Use rlm_passwd module instead");
 654                 mschap_detach(inst);
 655                 return -1;
 656         }
 657
 658         /*
 659          *      Create the dynamic translation.
 660          */
 661         xlat_name = cf_section_name2(conf);
 662         if (xlat_name == NULL)
 663                 xlat_name = cf_section_name1(conf);
 664         if (xlat_name){
 665                 inst->xlat_name = strdup(xlat_name);
 666                 xlat_register(xlat_name, mschap_xlat, inst);
 667         }
 668
 669         /*
 670          *      For backwards compatibility
 671          */
 672         if (!dict_valbyname(PW_AUTH_TYPE, inst->xlat_name)) {
 673                 inst->auth_type = "MS-CHAP";
 674         }
 675
 676         return 0;
 677 }
 678
 679 /*
 680  *      add_reply() adds either MS-CHAP2-Success or MS-CHAP-Error
 681  *      attribute to reply packet
 682  */
 683 static void add_reply(VALUE_PAIR** vp, unsigned char ident,
 684                       const char* name, const char* value, int len)
 685 {
 686         VALUE_PAIR *reply_attr;
 687         reply_attr = pairmake(name, "", T_OP_EQ);
 688         if (!reply_attr) {
 689                 DEBUG("  rlm_mschap: Failed to create attribute %s: %s\n", name, librad_errstr);
 690                 return;
 691         }
 692
 693         reply_attr->strvalue[0] = ident;
 694         memcpy(reply_attr->strvalue + 1, value, len);
 695         reply_attr->length = len + 1;
 696         pairadd(vp, reply_attr);
 697 }
 698
 699 /*
 700  *      Add MPPE attributes to the reply.
 701  */
 702 static void mppe_add_reply(VALUE_PAIR **vp,
 703                            const char* name, const char* value, int len)
 704 {
 705        VALUE_PAIR *reply_attr;
 706        reply_attr = pairmake(name, "", T_OP_EQ);
 707        if (!reply_attr) {
 708                DEBUG("rlm_mschap: mppe_add_reply failed to create attribute %s: %s\n", name, librad_errstr);
 709                return;
 710        }
 711
 712        memcpy(reply_attr->strvalue, value, len);
 713        reply_attr->length = len;
 714        pairadd(vp, reply_attr);
 715 }
 716
 717
 718 /*
 719  *      Do the MS-CHAP stuff.
 720  *
 721  *      This function is here so that all of the MS-CHAP related
 722  *      authentication is in one place, and we can perhaps later replace
 723  *      it with code to call winbindd, or something similar.
 724  */
 725 static int do_mschap(rlm_mschap_t *inst,
 726                      REQUEST *request, VALUE_PAIR *password,
 727                      uint8_t *challenge, uint8_t *response,
 728                      uint8_t *nthashhash)
 729 {
 730         int             do_ntlm_auth = 0;
 731         uint8_t         calculated[24];
 732         VALUE_PAIR      *vp = NULL;
 733
 734         /*
 735          *      If we have ntlm_auth configured, use it unless told
 736          *      otherwise
 737          */
 738         if (inst->ntlm_auth) do_ntlm_auth = 1;
 739
 740         /*
 741          *      If we have an ntlm_auth configuration, then we may
 742          *      want to use it.
 743          */
 744         vp = pairfind(request->config_items,
 745                       PW_MS_CHAP_USE_NTLM_AUTH);
 746         if (vp) do_ntlm_auth = vp->lvalue;
 747
 748         /*
 749          *      No ntlm_auth configured, attribute to tell us to
 750          *      use it exists, and we're told to use it.  We don't
 751          *      know what to do...
 752          */
 753         if (!inst->ntlm_auth && do_ntlm_auth) {
 754                 DEBUG2("  rlm_mschap: Asked to use ntlm_auth, but it was not configured in the mschap{} section.");
 755                 return -1;
 756         }
 757
 758         /*
 759          *      Do normal authentication.
 760          */
 761         if (!do_ntlm_auth) {
 762                 /*
 763                  *      No password: can't do authentication.
 764                  */
 765                 if (!password) {
 766                         DEBUG2("  rlm_mschap: FAILED: No NT/LM-Password.  Cannot perform authentication.");
 767                         return -1;
 768                 }
 769
 770                 smbdes_mschap(password->strvalue, challenge, calculated);
 771                 if (memcmp(response, calculated, 24) != 0) {
 772                         return -1;
 773                 }
 774
 775                 /*
 776                  *      If the password exists, and is an NT-Password,
 777                  *      then calculate the hash of the NT hash.  Doing this
 778                  *      here minimizes work for later.
 779                  */
 780                 if (password && (password->attribute == PW_NT_PASSWORD)) {
 781                         md4_calc(nthashhash, password->strvalue, 16);
 782                 } else {
 783                         memset(nthashhash, 0, 16);
 784                 }
 785         } else {                /* run ntlm_auth */
 786                 int     result;
 787                 char    buffer[256];
 788
 789                 memset(nthashhash, 0, 16);
 790
 791                 /*
 792                  *      Run the program, and expect that we get 16
 793                  */
 794                 result = radius_exec_program(inst->ntlm_auth, request,
 795                                              TRUE, /* wait */
 796                                              buffer, sizeof(buffer),
 797                                              NULL, NULL);
 798                 if (result != 0) {
 799                         DEBUG2("  rlm_mschap: External script failed.");
 800                         return -1;
 801                 }
 802
 803                 /*
 804                  *      Parse the answer as an nthashhash.
 805                  *
 806                  *      ntlm_auth currently returns:
 807                  *      NT_KEY: 000102030405060708090a0b0c0d0e0f
 808                  */
 809                 if (memcmp(buffer, "NT_KEY: ", 8) != 0) {
 810                         DEBUG2("  rlm_mschap: Invalid output from ntlm_auth: expecting NT_KEY");
 811                         return -1;
 812                 }
 813
 814                 /*
 815                  *      Check the length.  It should be at least 32,
 816                  *      with an LF at the end.
 817                  */
 818                 if (strlen(buffer + 8) < 32) {
 819                         DEBUG2("  rlm_mschap: Invalid output from ntlm_auth: NT_KEY has unexpected length");
 820                         return -1;
 821                 }
 822
 823                 /*
 824                  *      Update the NT hash hash, from the NT key.
 825                  */
 826                 if (hex2bin(buffer + 8, nthashhash, 16) != 16) {
 827                         DEBUG2("  rlm_mschap: Invalid output from ntlm_auth: NT_KEY has non-hex values");
 828                         return -1;
 829                 }
 830         }
 831
 832         return 0;
 833 }
 834
 835
 836 /*
 837  *      Data for the hashes.
 838  */
 839 static const uint8_t SHSpad1[40] =
 840                { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 841                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 842                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 843                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 844
 845 static const uint8_t SHSpad2[40] =
 846                { 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
 847                  0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
 848                  0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
 849                  0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2 };
 850
 851 static const uint8_t magic1[27] =
 852                { 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74,
 853                  0x68, 0x65, 0x20, 0x4d, 0x50, 0x50, 0x45, 0x20, 0x4d,
 854                  0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x4b, 0x65, 0x79 };
 855
 856 static const uint8_t magic2[84] =
 857                { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
 858                  0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
 859                  0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
 860                  0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x6b, 0x65, 0x79,
 861                  0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73,
 862                  0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x69, 0x64, 0x65,
 863                  0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
 864                  0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
 865                  0x6b, 0x65, 0x79, 0x2e };
 866
 867 static const uint8_t magic3[84] =
 868                { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
 869                  0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
 870                  0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
 871                  0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
 872                  0x6b, 0x65, 0x79, 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68,
 873                  0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73,
 874                  0x69, 0x64, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73,
 875                  0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20,
 876                  0x6b, 0x65, 0x79, 0x2e };
 877
 878
 879 static void mppe_GetMasterKey(uint8_t *nt_hashhash,uint8_t *nt_response,
 880                               uint8_t *masterkey)
 881 {
 882        uint8_t digest[20];
 883        SHA1_CTX Context;
 884
 885        SHA1Init(&Context);
 886        SHA1Update(&Context,nt_hashhash,16);
 887        SHA1Update(&Context,nt_response,24);
 888        SHA1Update(&Context,magic1,27);
 889        SHA1Final(digest,&Context);
 890
 891        memcpy(masterkey,digest,16);
 892 }
 893
 894
 895 static void mppe_GetAsymmetricStartKey(uint8_t *masterkey,uint8_t *sesskey,
 896                                        int keylen,int issend)
 897 {
 898        uint8_t digest[20];
 899        const uint8_t *s;
 900        SHA1_CTX Context;
 901
 902        memset(digest,0,20);
 903
 904        if(issend) {
 905                s = magic3;
 906        } else {
 907                s = magic2;
 908        }
 909
 910        SHA1Init(&Context);
 911        SHA1Update(&Context,masterkey,16);
 912        SHA1Update(&Context,SHSpad1,40);
 913        SHA1Update(&Context,s,84);
 914        SHA1Update(&Context,SHSpad2,40);
 915        SHA1Final(digest,&Context);
 916
 917        memcpy(sesskey,digest,keylen);
 918 }
 919
 920
 921 static void mppe_chap2_get_keys128(uint8_t *nt_hashhash,uint8_t *nt_response,
 922                                    uint8_t *sendkey,uint8_t *recvkey)
 923 {
 924        uint8_t masterkey[16];
 925
 926        mppe_GetMasterKey(nt_hashhash,nt_response,masterkey);
 927
 928        mppe_GetAsymmetricStartKey(masterkey,sendkey,16,1);
 929        mppe_GetAsymmetricStartKey(masterkey,recvkey,16,0);
 930 }
 931
 932 /*
 933  *      Generate MPPE keys.
 934  */
 935 static void mppe_chap2_gen_keys128(uint8_t *nt_hashhash,uint8_t *response,
 936                                    uint8_t *sendkey,uint8_t *recvkey)
 937 {
 938         uint8_t enckey1[16];
 939         uint8_t enckey2[16];
 940
 941         mppe_chap2_get_keys128(nt_hashhash,response,enckey1,enckey2);
 942
 943         /*
 944          *      dictionary.microsoft defines these attributes as
 945          *      'encrypt=2'.  The functions in src/lib/radius.c will
 946          *      take care of encrypting/decrypting them as appropriate,
 947          *      so that we don't have to.
 948          */
 949         memcpy (sendkey, enckey1, 16);
 950         memcpy (recvkey, enckey2, 16);
 951 }
 952
 953
 954 /*
 955  *      mschap_authorize() - authorize user if we can authenticate
 956  *      it later. Add Auth-Type attribute if present in module
 957  *      configuration (usually Auth-Type must be "MS-CHAP")
 958  */
 959 static int mschap_authorize(void * instance, REQUEST *request)
 960 {
 961 #define inst ((rlm_mschap_t *)instance)
 962         VALUE_PAIR *challenge = NULL;
 963         VALUE_PAIR *response = NULL;
 964         VALUE_PAIR *vp;
 965
 966         challenge = pairfind(request->packet->vps, PW_MSCHAP_CHALLENGE);
 967         if (!challenge) {
 968                 return RLM_MODULE_NOOP;
 969         }
 970
 971         response = pairfind(request->packet->vps, PW_MSCHAP_RESPONSE);
 972         if (!response)
 973                 response = pairfind(request->packet->vps, PW_MSCHAP2_RESPONSE);
 974
 975         /*
 976          *      Nothing we recognize.  Don't do anything.
 977          */
 978         if (!response) {
 979                 DEBUG2("  rlm_mschap: Found MS-CHAP-Challenge, but no MS-CHAP-Response.");
 980                 return RLM_MODULE_NOOP;
 981         }
 982
 983         DEBUG2("  rlm_mschap: Found MS-CHAP attributes.  Setting 'Auth-Type  = %s'", inst->xlat_name);
 984
 985         /*
 986          *      Set Auth-Type to MS-CHAP.  The authentication code
 987          *      will take care of turning clear-text passwords into
 988          *      NT/LM passwords.
 989          */
 990         vp = pairmake("Auth-Type", inst->auth_type, T_OP_EQ);
 991         if (!vp) return RLM_MODULE_FAIL;
 992         pairmove(&request->config_items, &vp);
 993         pairfree(&vp);          /* may be NULL */
 994
 995         return RLM_MODULE_OK;
 996 #undef inst
 997 }
 998
 999 /*
1000  *      mschap_authenticate() - authenticate user based on given
1001  *      attributes and configuration.
1002  *      We will try to find out password in configuration
1003  *      or in configured passwd file.
1004  *      If one is found we will check paraneters given by NAS.
1005  *
1006  *      If PW_SMB_ACCOUNT_CTRL is not set to ACB_PWNOTREQ we must have
1007  *      one of:
1008  *              PAP:      PW_PASSWORD or
1009  *              MS-CHAP:  PW_MSCHAP_CHALLENGE and PW_MSCHAP_RESPONSE or
1010  *              MS-CHAP2: PW_MSCHAP_CHALLENGE and PW_MSCHAP2_RESPONSE
1011  *      In case of password mismatch or locked account we MAY return
1012  *      PW_MSCHAP_ERROR for MS-CHAP or MS-CHAP v2
1013  *      If MS-CHAP2 succeeds we MUST return
1014  *      PW_MSCHAP2_SUCCESS
1015  */
1016 static int mschap_authenticate(void * instance, REQUEST *request)
1017 {
1018 #define inst ((rlm_mschap_t *)instance)
1019         VALUE_PAIR *challenge = NULL;
1020         VALUE_PAIR *response = NULL;
1021         VALUE_PAIR *password = NULL;
1022         VALUE_PAIR *lm_password, *nt_password, *smb_ctrl;
1023         VALUE_PAIR *username;
1024         VALUE_PAIR *reply_attr;
1025         uint8_t nthashhash[16];
1026         uint8_t msch2resp[42];
1027         char *username_string;
1028         int chap = 0;
1029
1030         /*
1031          *      Find the SMB-Account-Ctrl attribute, or the
1032          *      SMB-Account-Ctrl-Text attribute.
1033          */
1034         smb_ctrl = pairfind(request->config_items, PW_SMB_ACCOUNT_CTRL);
1035         if (!smb_ctrl) {
1036                 password = pairfind(request->config_items,
1037                                     PW_SMB_ACCOUNT_CTRL_TEXT);
1038                 if (password) {
1039                         smb_ctrl = pairmake("SMB-Account-CTRL", "0", T_OP_SET);
1040                         pairadd(&request->config_items, smb_ctrl);
1041                         smb_ctrl->lvalue = pdb_decode_acct_ctrl(password->strvalue);
1042                 }
1043         }
1044
1045         /*
1046          *      We're configured to do MS-CHAP authentication.
1047          *      and account control information exists.  Enforce it.
1048          */
1049         if (smb_ctrl) {
1050                 /*
1051                  *      Password is not required.
1052                  */
1053                 if ((smb_ctrl->lvalue & ACB_PWNOTREQ) != 0) {
1054                         DEBUG2("  rlm_mschap: SMB-Account-Ctrl says no password is required.");
1055                         return RLM_MODULE_OK;
1056                 }
1057         }
1058
1059         /*
1060          *      Decide how to get the passwords.
1061          */
1062         password = pairfind(request->config_items, PW_PASSWORD);
1063
1064         /*
1065          *      We need an LM-Password.
1066          */
1067         lm_password = pairfind(request->config_items, PW_LM_PASSWORD);
1068         if (lm_password) {
1069                 /*
1070                  *      Allow raw octets.
1071                  */
1072                 if ((lm_password->length == 16) ||
1073                     ((lm_password->length == 32) &&
1074                      (hex2bin(lm_password->strvalue,
1075                               lm_password->strvalue, 16) == 16))) {
1076                         DEBUG2("  rlm_mschap: Found LM-Password");
1077                         lm_password->length = 16;
1078
1079                 } else {
1080                         radlog(L_ERR, "rlm_mschap: Invalid LM-Password");
1081                         lm_password = NULL;
1082                 }
1083
1084         } else if (!password) {
1085                 DEBUG2("  rlm_mschap: No User-Password configured.  Cannot create LM-Password.");
1086
1087         } else {                /* there is a configured User-Password */
1088                 lm_password = pairmake("LM-Password", "", T_OP_EQ);
1089                 if (!lm_password) {
1090                         radlog(L_ERR, "No memory");
1091                 } else {
1092                         smbdes_lmpwdhash(password->strvalue,
1093                                        lm_password->strvalue);
1094                         lm_password->length = 16;
1095                         pairadd(&request->config_items, lm_password);
1096                 }
1097         }
1098
1099         /*
1100          *      We need an NT-Password.
1101          */
1102         nt_password = pairfind(request->config_items, PW_NT_PASSWORD);
1103         if (nt_password) {
1104                 if ((nt_password->length == 16) ||
1105                     ((nt_password->length == 32) &&
1106                      (hex2bin(nt_password->strvalue,
1107                               nt_password->strvalue, 16) == 16))) {
1108                         DEBUG2("  rlm_mschap: Found NT-Password");
1109                         nt_password->length = 16;
1110
1111                 } else {
1112                         radlog(L_ERR, "rlm_mschap: Invalid NT-Password");
1113                         nt_password = NULL;
1114                 }
1115         } else if (!password) {
1116                 DEBUG2("  rlm_mschap: No User-Password configured.  Cannot create NT-Password.");
1117
1118         } else {                /* there is a configured User-Password */
1119                 nt_password = pairmake("NT-Password", "", T_OP_EQ);
1120                 if (!nt_password) {
1121                         radlog(L_ERR, "No memory");
1122                         return RLM_MODULE_FAIL;
1123                 } else {
1124                         ntpwdhash(nt_password->strvalue, password->strvalue);
1125                         nt_password->length = 16;
1126                         pairadd(&request->config_items, nt_password);
1127                 }
1128         }
1129
1130         challenge = pairfind(request->packet->vps, PW_MSCHAP_CHALLENGE);
1131         if (!challenge) {
1132                 DEBUG2("  rlm_mschap: No MS-CHAP-Challenge in the request");
1133                 return RLM_MODULE_REJECT;
1134         }
1135
1136         /*
1137          *      We also require an MS-CHAP-Response.
1138          */
1139         response = pairfind(request->packet->vps, PW_MSCHAP_RESPONSE);
1140
1141         /*
1142          *      MS-CHAP-Response, means MS-CHAPv1
1143          */
1144         if (response) {
1145                 int offset;
1146
1147                 /*
1148                  *      MS-CHAPv1 challenges are 8 octets.
1149                  */
1150                 if (challenge->length < 8) {
1151                         radlog(L_AUTH, "rlm_mschap: MS-CHAP-Challenge has the wrong format.");
1152                         return RLM_MODULE_INVALID;
1153                 }
1154
1155                 /*
1156                  *      Responses are 50 octets.
1157                  */
1158                 if (response->length < 50) {
1159                         radlog(L_AUTH, "rlm_mschap: MS-CHAP-Response has the wrong format.");
1160                         return RLM_MODULE_INVALID;
1161                 }
1162
1163                 /*
1164                  *      We are doing MS-CHAP.  Calculate the MS-CHAP
1165                  *      response
1166                  */
1167                 if (response->strvalue[1] & 0x01) {
1168                         DEBUG2("  rlm_mschap: Told to do MS-CHAPv1 with NT-Password");
1169                         password = nt_password;
1170                         offset = 26;
1171                 } else {
1172                         DEBUG2("  rlm_mschap: Told to do MS-CHAPv1 with LM-Password");
1173                         password = lm_password;
1174                         offset = 2;
1175                 }
1176
1177                 /*
1178                  *      Do the MS-CHAP authentication.
1179                  */
1180                 if (do_mschap(inst, request, password, challenge->strvalue,
1181                               response->strvalue + offset, nthashhash) < 0) {
1182                         DEBUG2("  rlm_mschap: MS-CHAP-Response is incorrect.");
1183                         add_reply(&request->reply->vps, *response->strvalue,
1184                                   "MS-CHAP-Error", "E=691 R=1", 9);
1185                         return RLM_MODULE_REJECT;
1186                 }
1187
1188                 chap = 1;
1189
1190         } else if ((response = pairfind(request->packet->vps, PW_MSCHAP2_RESPONSE)) != NULL) {
1191                 uint8_t mschapv1_challenge[16];
1192
1193                 /*
1194                  *      MS-CHAPv2 challenges are 16 octets.
1195                  */
1196                 if (challenge->length < 16) {
1197                         radlog(L_AUTH, "rlm_mschap: MS-CHAP-Challenge has the wrong format.");
1198                         return RLM_MODULE_INVALID;
1199                 }
1200
1201                 /*
1202                  *      Responses are 50 octets.
1203                  */
1204                 if (response->length < 50) {
1205                         radlog(L_AUTH, "rlm_mschap: MS-CHAP-Response has the wrong format.");
1206                         return RLM_MODULE_INVALID;
1207                 }
1208
1209                 /*
1210                  *      We also require a User-Name
1211                  */
1212                 username = pairfind(request->packet->vps, PW_USER_NAME);
1213                 if (!username) {
1214                         radlog(L_AUTH, "rlm_mschap: We require a User-Name for MS-CHAPv2");
1215                         return RLM_MODULE_INVALID;
1216                 }
1217
1218
1219                 /*
1220                  *      with_ntdomain_hack moved here
1221                  */
1222                 if ((username_string = strchr(username->strvalue, '\\')) != NULL) {
1223                         if (inst->with_ntdomain_hack) {
1224                                 username_string++;
1225                         } else {
1226                                 DEBUG2("  rlm_mschap: NT Domain delimeter found, should we have enabled with_ntdomain_hack?");
1227                                 username_string = username->strvalue;
1228                         }
1229                 } else {
1230                         username_string = username->strvalue;
1231                 }
1232
1233                 /*
1234                  *      The old "mschapv2" function has been moved to
1235                  *      here.
1236                  *
1237                  *      MS-CHAPv2 takes some additional data to create an
1238                  *      MS-CHAPv1 challenge, and then does MS-CHAPv1.
1239                  */
1240                 challenge_hash(response->strvalue + 2, /* peer challenge */
1241                                challenge->strvalue, /* our challenge */
1242                                username_string, /* user name */
1243                                mschapv1_challenge); /* resulting challenge */
1244
1245                 DEBUG2("  rlm_mschap: Told to do MS-CHAPv2 for %s with NT-Password",
1246                        username_string);
1247
1248                 if (do_mschap(inst, request, nt_password, mschapv1_challenge,
1249                               response->strvalue + 26, nthashhash) < 0) {
1250                         DEBUG2("  rlm_mschap: FAILED: MS-CHAP2-Response is incorrect");
1251                         add_reply(&request->reply->vps, *response->strvalue,
1252                                   "MS-CHAP-Error", "E=691 R=1", 9);
1253                         return RLM_MODULE_REJECT;
1254                 }
1255
1256                 /*
1257                  *      Get the NT-hash-hash, if necessary
1258                  */
1259                 if (nt_password) {
1260                 }
1261
1262                 auth_response(username_string, /* without the domain */
1263                               nthashhash, /* nt-hash-hash */
1264                               response->strvalue + 26, /* peer response */
1265                               response->strvalue + 2, /* peer challenge */
1266                               challenge->strvalue, /* our challenge */
1267                               msch2resp); /* calculated MPPE key */
1268                 add_reply( &request->reply->vps, *response->strvalue,
1269                            "MS-CHAP2-Success", msch2resp, 42);
1270                 chap = 2;
1271
1272         } else {                /* Neither CHAPv1 or CHAPv2 response: die */
1273                 radlog(L_AUTH, "rlm_mschap: No MS-CHAP response found");
1274                 return RLM_MODULE_INVALID;
1275         }
1276
1277         /*
1278          *      We have a CHAP response, but the account may be
1279          *      disabled.  Reject the user with the same error code
1280          *      we use when their password is invalid.
1281          */
1282         if (smb_ctrl) {
1283                 /*
1284                  *      Account is disabled.
1285                  *
1286                  *      They're found, but they don't exist, so we
1287                  *      return 'not found'.
1288                  */
1289                 if (((smb_ctrl->lvalue & ACB_DISABLED) != 0) ||
1290                     ((smb_ctrl->lvalue & ACB_NORMAL) == 0)) {
1291                         DEBUG2("  rlm_mschap: SMB-Account-Ctrl says that the account is disabled, or is not a normal account.");
1292                         add_reply( &request->reply->vps, *response->strvalue,
1293                                    "MS-CHAP-Error", "E=691 R=1", 9);
1294                         return RLM_MODULE_NOTFOUND;
1295                 }
1296
1297                 /*
1298                  *      User is locked out.
1299                  */
1300                 if ((smb_ctrl->lvalue & ACB_AUTOLOCK) != 0) {
1301                         DEBUG2("  rlm_mschap: SMB-Account-Ctrl says that the account is locked out.");
1302                         add_reply( &request->reply->vps, *response->strvalue,
1303                                    "MS-CHAP-Error", "E=647 R=0", 9);
1304                         return RLM_MODULE_USERLOCK;
1305                 }
1306         }
1307
1308         /* now create MPPE attributes */
1309         if (inst->use_mppe) {
1310                 uint8_t mppe_sendkey[34];
1311                 uint8_t mppe_recvkey[34];
1312
1313                 if (chap == 1){
1314                         DEBUG2("rlm_mschap: adding MS-CHAPv1 MPPE keys");
1315                         memset(mppe_sendkey, 0, 32);
1316                         if (lm_password) {
1317                                 memcpy(mppe_sendkey, lm_password->strvalue, 8);
1318                         }
1319
1320                         /*
1321                          *      According to RFC 2548 we
1322                          *      should send NT hash.  But in
1323                          *      practice it doesn't work.
1324                          *      Instead, we should send nthashhash
1325                          *
1326                          *      This is an error on RFC 2548.
1327                          */
1328                         /*
1329                          *      do_mschap cares to zero nthashhash if NT hash
1330                          *      is not available.
1331                          */
1332                         memcpy(mppe_sendkey + 8,
1333                                nthashhash, 16);
1334                         mppe_add_reply(&request->reply->vps,
1335                                        "MS-CHAP-MPPE-Keys",
1336                                        mppe_sendkey, 32);
1337                 } else if (chap == 2) {
1338                         DEBUG2("rlm_mschap: adding MS-CHAPv2 MPPE keys");
1339                         mppe_chap2_gen_keys128(nthashhash,
1340                                                response->strvalue + 26,
1341                                                mppe_sendkey, mppe_recvkey);
1342
1343                         mppe_add_reply(&request->reply->vps,
1344                                        "MS-MPPE-Recv-Key",
1345                                        mppe_recvkey, 16);
1346                         mppe_add_reply(&request->reply->vps,
1347                                        "MS-MPPE-Send-Key",
1348                                        mppe_sendkey, 16);
1349
1350                 }
1351                 reply_attr = pairmake("MS-MPPE-Encryption-Policy",
1352                                       (inst->require_encryption)? "0x00000002":"0x00000001",
1353                                       T_OP_EQ);
1354                 rad_assert(reply_attr != NULL);
1355                 pairadd(&request->reply->vps, reply_attr);
1356                 reply_attr = pairmake("MS-MPPE-Encryption-Types",
1357                                       (inst->require_strong)? "0x00000004":"0x00000006",
1358                                       T_OP_EQ);
1359                 rad_assert(reply_attr != NULL);
1360                 pairadd(&request->reply->vps, reply_attr);
1361
1362         } /* else we weren't asked to use MPPE */
1363
1364         return RLM_MODULE_OK;
1365 #undef inst
1366 }
1367
1368 module_t rlm_mschap = {
1369   "MS-CHAP",
1370   RLM_TYPE_THREAD_SAFE,         /* type */
1371   NULL,                         /* initialize */
1372   mschap_instantiate,           /* instantiation */
1373   {
1374           mschap_authenticate,  /* authenticate */
1375           mschap_authorize,     /* authorize */
1376           NULL,                 /* pre-accounting */
1377           NULL,                 /* accounting */
1378           NULL,                 /* checksimul */
1379           NULL,                 /* pre-proxy */
1380           NULL,                 /* post-proxy */
1381           NULL                  /* post-auth */
1382   },
1383   mschap_detach,                /* detach */
1384   NULL,                         /* destroy */
1385 };