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