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(REQUEST *request,
 712                            const char* name, const uint8_t * value, int len)
 713 {
 714        VALUE_PAIR *vp;
 715        vp = radius_pairmake(request, &request->reply->vps, name, "", T_OP_EQ);
 716        if (!vp) {
 717                DEBUG("rlm_mschap: mppe_add_reply failed to create attribute %s: %s\n", name, librad_errstr);
 718                return;
 719        }
 720
 721        memcpy(vp->vp_octets, value, len);
 722        vp->length = len;
 723 }
 724
 725
 726 /*
 727  *      Do the MS-CHAP stuff.
 728  *
 729  *      This function is here so that all of the MS-CHAP related
 730  *      authentication is in one place, and we can perhaps later replace
 731  *      it with code to call winbindd, or something similar.
 732  */
 733 static int do_mschap(rlm_mschap_t *inst,
 734                      REQUEST *request, VALUE_PAIR *password,
 735                      uint8_t *challenge, uint8_t *response,
 736                      uint8_t *nthashhash)
 737 {
 738         int             do_ntlm_auth = 0;
 739         uint8_t         calculated[24];
 740         VALUE_PAIR      *vp = NULL;
 741
 742         /*
 743          *      If we have ntlm_auth configured, use it unless told
 744          *      otherwise
 745          */
 746         if (inst->ntlm_auth) do_ntlm_auth = 1;
 747
 748         /*
 749          *      If we have an ntlm_auth configuration, then we may
 750          *      want to use it.
 751          */
 752         vp = pairfind(request->config_items,
 753                       PW_MS_CHAP_USE_NTLM_AUTH);
 754         if (vp) do_ntlm_auth = vp->vp_integer;
 755
 756         /*
 757          *      No ntlm_auth configured, attribute to tell us to
 758          *      use it exists, and we're told to use it.  We don't
 759          *      know what to do...
 760          */
 761         if (!inst->ntlm_auth && do_ntlm_auth) {
 762                 DEBUG2("  rlm_mschap: Asked to use ntlm_auth, but it was not configured in the mschap{} section.");
 763                 return -1;
 764         }
 765
 766         /*
 767          *      Do normal authentication.
 768          */
 769         if (!do_ntlm_auth) {
 770                 /*
 771                  *      No password: can't do authentication.
 772                  */
 773                 if (!password) {
 774                         DEBUG2("  rlm_mschap: FAILED: No NT/LM-Password.  Cannot perform authentication.");
 775                         return -1;
 776                 }
 777
 778                 smbdes_mschap(password->vp_strvalue, challenge, calculated);
 779                 if (memcmp(response, calculated, 24) != 0) {
 780                         return -1;
 781                 }
 782
 783                 /*
 784                  *      If the password exists, and is an NT-Password,
 785                  *      then calculate the hash of the NT hash.  Doing this
 786                  *      here minimizes work for later.
 787                  */
 788                 if (password && (password->attribute == PW_NT_PASSWORD)) {
 789                         fr_md4_calc(nthashhash, password->vp_octets, 16);
 790                 } else {
 791                         memset(nthashhash, 0, 16);
 792                 }
 793         } else {                /* run ntlm_auth */
 794                 int     result;
 795                 char    buffer[256];
 796
 797                 memset(nthashhash, 0, 16);
 798
 799                 /*
 800                  *      Run the program, and expect that we get 16
 801                  */
 802                 result = radius_exec_program(inst->ntlm_auth, request,
 803                                              TRUE, /* wait */
 804                                              buffer, sizeof(buffer),
 805                                              NULL, NULL, 1);
 806                 if (result != 0) {
 807                         DEBUG2("  rlm_mschap: External script failed.");
 808                         return -1;
 809                 }
 810
 811                 /*
 812                  *      Parse the answer as an nthashhash.
 813                  *
 814                  *      ntlm_auth currently returns:
 815                  *      NT_KEY: 000102030405060708090a0b0c0d0e0f
 816                  */
 817                 if (memcmp(buffer, "NT_KEY: ", 8) != 0) {
 818                         DEBUG2("  rlm_mschap: Invalid output from ntlm_auth: expecting NT_KEY");
 819                         return -1;
 820                 }
 821
 822                 /*
 823                  *      Check the length.  It should be at least 32,
 824                  *      with an LF at the end.
 825                  */
 826                 if (strlen(buffer + 8) < 32) {
 827                         DEBUG2("  rlm_mschap: Invalid output from ntlm_auth: NT_KEY has unexpected length");
 828                         return -1;
 829                 }
 830
 831                 /*
 832                  *      Update the NT hash hash, from the NT key.
 833                  */
 834                 if (fr_hex2bin(buffer + 8, nthashhash, 16) != 16) {
 835                         DEBUG2("  rlm_mschap: Invalid output from ntlm_auth: NT_KEY has non-hex values");
 836                         return -1;
 837                 }
 838         }
 839
 840         return 0;
 841 }
 842
 843
 844 /*
 845  *      Data for the hashes.
 846  */
 847 static const uint8_t SHSpad1[40] =
 848                { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 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
 853 static const uint8_t SHSpad2[40] =
 854                { 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
 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
 859 static const uint8_t magic1[27] =
 860                { 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74,
 861                  0x68, 0x65, 0x20, 0x4d, 0x50, 0x50, 0x45, 0x20, 0x4d,
 862                  0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x4b, 0x65, 0x79 };
 863
 864 static const uint8_t magic2[84] =
 865                { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
 866                  0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
 867                  0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
 868                  0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x6b, 0x65, 0x79,
 869                  0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73,
 870                  0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x69, 0x64, 0x65,
 871                  0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
 872                  0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
 873                  0x6b, 0x65, 0x79, 0x2e };
 874
 875 static const uint8_t magic3[84] =
 876                { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
 877                  0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
 878                  0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
 879                  0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
 880                  0x6b, 0x65, 0x79, 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68,
 881                  0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73,
 882                  0x69, 0x64, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73,
 883                  0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20,
 884                  0x6b, 0x65, 0x79, 0x2e };
 885
 886
 887 static void mppe_GetMasterKey(uint8_t *nt_hashhash,uint8_t *nt_response,
 888                               uint8_t *masterkey)
 889 {
 890        uint8_t digest[20];
 891        fr_SHA1_CTX Context;
 892
 893        fr_SHA1Init(&Context);
 894        fr_SHA1Update(&Context,nt_hashhash,16);
 895        fr_SHA1Update(&Context,nt_response,24);
 896        fr_SHA1Update(&Context,magic1,27);
 897        fr_SHA1Final(digest,&Context);
 898
 899        memcpy(masterkey,digest,16);
 900 }
 901
 902
 903 static void mppe_GetAsymmetricStartKey(uint8_t *masterkey,uint8_t *sesskey,
 904                                        int keylen,int issend)
 905 {
 906        uint8_t digest[20];
 907        const uint8_t *s;
 908        fr_SHA1_CTX Context;
 909
 910        memset(digest,0,20);
 911
 912        if(issend) {
 913                s = magic3;
 914        } else {
 915                s = magic2;
 916        }
 917
 918        fr_SHA1Init(&Context);
 919        fr_SHA1Update(&Context,masterkey,16);
 920        fr_SHA1Update(&Context,SHSpad1,40);
 921        fr_SHA1Update(&Context,s,84);
 922        fr_SHA1Update(&Context,SHSpad2,40);
 923        fr_SHA1Final(digest,&Context);
 924
 925        memcpy(sesskey,digest,keylen);
 926 }
 927
 928
 929 static void mppe_chap2_get_keys128(uint8_t *nt_hashhash,uint8_t *nt_response,
 930                                    uint8_t *sendkey,uint8_t *recvkey)
 931 {
 932        uint8_t masterkey[16];
 933
 934        mppe_GetMasterKey(nt_hashhash,nt_response,masterkey);
 935
 936        mppe_GetAsymmetricStartKey(masterkey,sendkey,16,1);
 937        mppe_GetAsymmetricStartKey(masterkey,recvkey,16,0);
 938 }
 939
 940 /*
 941  *      Generate MPPE keys.
 942  */
 943 static void mppe_chap2_gen_keys128(uint8_t *nt_hashhash,uint8_t *response,
 944                                    uint8_t *sendkey,uint8_t *recvkey)
 945 {
 946         uint8_t enckey1[16];
 947         uint8_t enckey2[16];
 948
 949         mppe_chap2_get_keys128(nt_hashhash,response,enckey1,enckey2);
 950
 951         /*
 952          *      dictionary.microsoft defines these attributes as
 953          *      'encrypt=2'.  The functions in src/lib/radius.c will
 954          *      take care of encrypting/decrypting them as appropriate,
 955          *      so that we don't have to.
 956          */
 957         memcpy (sendkey, enckey1, 16);
 958         memcpy (recvkey, enckey2, 16);
 959 }
 960
 961
 962 /*
 963  *      mschap_authorize() - authorize user if we can authenticate
 964  *      it later. Add Auth-Type attribute if present in module
 965  *      configuration (usually Auth-Type must be "MS-CHAP")
 966  */
 967 static int mschap_authorize(void * instance, REQUEST *request)
 968 {
 969 #define inst ((rlm_mschap_t *)instance)
 970         VALUE_PAIR *challenge = NULL, *response = NULL;
 971
 972         challenge = pairfind(request->packet->vps, PW_MSCHAP_CHALLENGE);
 973         if (!challenge) {
 974                 return RLM_MODULE_NOOP;
 975         }
 976
 977         response = pairfind(request->packet->vps, PW_MSCHAP_RESPONSE);
 978         if (!response)
 979                 response = pairfind(request->packet->vps, PW_MSCHAP2_RESPONSE);
 980
 981         /*
 982          *      Nothing we recognize.  Don't do anything.
 983          */
 984         if (!response) {
 985                 DEBUG2("  rlm_mschap: Found MS-CHAP-Challenge, but no MS-CHAP-Response.");
 986                 return RLM_MODULE_NOOP;
 987         }
 988
 989         if (pairfind(request->config_items, PW_AUTH_TYPE)) {
 990                 DEBUG2("  rlm_mschap: Found existing Auth-Type.  Not changing it.");
 991                 return RLM_MODULE_NOOP;
 992         }
 993
 994         DEBUG2("  rlm_mschap: Found MS-CHAP attributes.  Setting 'Auth-Type  = %s'", inst->xlat_name);
 995
 996         /*
 997          *      Set Auth-Type to MS-CHAP.  The authentication code
 998          *      will take care of turning clear-text passwords into
 999          *      NT/LM passwords.
1000          */
1001         if (!radius_pairmake(request, &request->config_items,
1002                              "Auth-Type", inst->auth_type, T_OP_EQ)) {
1003                 return RLM_MODULE_FAIL;
1004         }
1005
1006         return RLM_MODULE_OK;
1007 #undef inst
1008 }
1009
1010 /*
1011  *      mschap_authenticate() - authenticate user based on given
1012  *      attributes and configuration.
1013  *      We will try to find out password in configuration
1014  *      or in configured passwd file.
1015  *      If one is found we will check paraneters given by NAS.
1016  *
1017  *      If PW_SMB_ACCOUNT_CTRL is not set to ACB_PWNOTREQ we must have
1018  *      one of:
1019  *              PAP:      PW_USER_PASSWORD or
1020  *              MS-CHAP:  PW_MSCHAP_CHALLENGE and PW_MSCHAP_RESPONSE or
1021  *              MS-CHAP2: PW_MSCHAP_CHALLENGE and PW_MSCHAP2_RESPONSE
1022  *      In case of password mismatch or locked account we MAY return
1023  *      PW_MSCHAP_ERROR for MS-CHAP or MS-CHAP v2
1024  *      If MS-CHAP2 succeeds we MUST return
1025  *      PW_MSCHAP2_SUCCESS
1026  */
1027 static int mschap_authenticate(void * instance, REQUEST *request)
1028 {
1029 #define inst ((rlm_mschap_t *)instance)
1030         VALUE_PAIR *challenge = NULL;
1031         VALUE_PAIR *response = NULL;
1032         VALUE_PAIR *password = NULL;
1033         VALUE_PAIR *lm_password, *nt_password, *smb_ctrl;
1034         VALUE_PAIR *username;
1035         uint8_t nthashhash[16];
1036         char msch2resp[42];
1037         char *username_string;
1038         int chap = 0;
1039
1040         /*
1041          *      Find the SMB-Account-Ctrl attribute, or the
1042          *      SMB-Account-Ctrl-Text attribute.
1043          */
1044         smb_ctrl = pairfind(request->config_items, PW_SMB_ACCOUNT_CTRL);
1045         if (!smb_ctrl) {
1046                 password = pairfind(request->config_items,
1047                                     PW_SMB_ACCOUNT_CTRL_TEXT);
1048                 if (password) {
1049                         smb_ctrl = radius_pairmake(request,
1050                                                    &request->config_items,
1051                                                    "SMB-Account-CTRL", "0",
1052                                                    T_OP_SET);
1053                         if (smb_ctrl) {
1054                                 smb_ctrl->vp_integer = pdb_decode_acct_ctrl(password->vp_strvalue);
1055                         }
1056                 }
1057         }
1058
1059         /*
1060          *      We're configured to do MS-CHAP authentication.
1061          *      and account control information exists.  Enforce it.
1062          */
1063         if (smb_ctrl) {
1064                 /*
1065                  *      Password is not required.
1066                  */
1067                 if ((smb_ctrl->vp_integer & ACB_PWNOTREQ) != 0) {
1068                         DEBUG2("  rlm_mschap: SMB-Account-Ctrl says no password is required.");
1069                         return RLM_MODULE_OK;
1070                 }
1071         }
1072
1073         /*
1074          *      Decide how to get the passwords.
1075          */
1076         password = pairfind(request->config_items, PW_CLEARTEXT_PASSWORD);
1077
1078         /*
1079          *      We need an LM-Password.
1080          */
1081         lm_password = pairfind(request->config_items, PW_LM_PASSWORD);
1082         if (lm_password) {
1083                 /*
1084                  *      Allow raw octets.
1085                  */
1086                 if ((lm_password->length == 16) ||
1087                     ((lm_password->length == 32) &&
1088                      (fr_hex2bin(lm_password->vp_strvalue,
1089                                  lm_password->vp_octets, 16) == 16))) {
1090                         DEBUG2("  rlm_mschap: Found LM-Password");
1091                         lm_password->length = 16;
1092
1093                 } else {
1094                         radlog(L_ERR, "rlm_mschap: Invalid LM-Password");
1095                         lm_password = NULL;
1096                 }
1097
1098         } else if (!password) {
1099                 DEBUG2("  rlm_mschap: No Cleartext-Password configured.  Cannot create LM-Password.");
1100
1101         } else {                /* there is a configured Cleartext-Password */
1102                 lm_password = radius_pairmake(request, &request->config_items,
1103                                               "LM-Password", "", T_OP_EQ);
1104                 if (!lm_password) {
1105                         radlog(L_ERR, "No memory");
1106                 } else {
1107                         smbdes_lmpwdhash(password->vp_strvalue,
1108                                          lm_password->vp_octets);
1109                         lm_password->length = 16;
1110                 }
1111         }
1112
1113         /*
1114          *      We need an NT-Password.
1115          */
1116         nt_password = pairfind(request->config_items, PW_NT_PASSWORD);
1117         if (nt_password) {
1118                 if ((nt_password->length == 16) ||
1119                     ((nt_password->length == 32) &&
1120                      (fr_hex2bin(nt_password->vp_strvalue,
1121                                  nt_password->vp_octets, 16) == 16))) {
1122                         DEBUG2("  rlm_mschap: Found NT-Password");
1123                         nt_password->length = 16;
1124
1125                 } else {
1126                         radlog(L_ERR, "rlm_mschap: Invalid NT-Password");
1127                         nt_password = NULL;
1128                 }
1129         } else if (!password) {
1130                 DEBUG2("  rlm_mschap: No Cleartext-Password configured.  Cannot create NT-Password.");
1131
1132         } else {                /* there is a configured Cleartext-Password */
1133                 nt_password = radius_pairmake(request, &request->config_items,
1134                                               "NT-Password", "", T_OP_EQ);
1135                 if (!nt_password) {
1136                         radlog(L_ERR, "No memory");
1137                         return RLM_MODULE_FAIL;
1138                 } else {
1139                         ntpwdhash(nt_password->vp_octets,
1140                                   password->vp_strvalue);
1141                         nt_password->length = 16;
1142                 }
1143         }
1144
1145         challenge = pairfind(request->packet->vps, PW_MSCHAP_CHALLENGE);
1146         if (!challenge) {
1147                 DEBUG2("  rlm_mschap: No MS-CHAP-Challenge in the request");
1148                 return RLM_MODULE_REJECT;
1149         }
1150
1151         /*
1152          *      We also require an MS-CHAP-Response.
1153          */
1154         response = pairfind(request->packet->vps, PW_MSCHAP_RESPONSE);
1155
1156         /*
1157          *      MS-CHAP-Response, means MS-CHAPv1
1158          */
1159         if (response) {
1160                 int offset;
1161
1162                 /*
1163                  *      MS-CHAPv1 challenges are 8 octets.
1164                  */
1165                 if (challenge->length < 8) {
1166                         radlog(L_AUTH, "rlm_mschap: MS-CHAP-Challenge has the wrong format.");
1167                         return RLM_MODULE_INVALID;
1168                 }
1169
1170                 /*
1171                  *      Responses are 50 octets.
1172                  */
1173                 if (response->length < 50) {
1174                         radlog(L_AUTH, "rlm_mschap: MS-CHAP-Response has the wrong format.");
1175                         return RLM_MODULE_INVALID;
1176                 }
1177
1178                 /*
1179                  *      We are doing MS-CHAP.  Calculate the MS-CHAP
1180                  *      response
1181                  */
1182                 if (response->vp_octets[1] & 0x01) {
1183                         DEBUG2("  rlm_mschap: Told to do MS-CHAPv1 with NT-Password");
1184                         password = nt_password;
1185                         offset = 26;
1186                 } else {
1187                         DEBUG2("  rlm_mschap: Told to do MS-CHAPv1 with LM-Password");
1188                         password = lm_password;
1189                         offset = 2;
1190                 }
1191
1192                 /*
1193                  *      Do the MS-CHAP authentication.
1194                  */
1195                 if (do_mschap(inst, request, password, challenge->vp_octets,
1196                               response->vp_octets + offset, nthashhash) < 0) {
1197                         DEBUG2("  rlm_mschap: MS-CHAP-Response is incorrect.");
1198                         mschap_add_reply(&request->reply->vps,
1199                                          *response->vp_octets,
1200                                          "MS-CHAP-Error", "E=691 R=1", 9);
1201                         return RLM_MODULE_REJECT;
1202                 }
1203
1204                 chap = 1;
1205
1206         } else if ((response = pairfind(request->packet->vps, PW_MSCHAP2_RESPONSE)) != NULL) {
1207                 uint8_t mschapv1_challenge[16];
1208
1209                 /*
1210                  *      MS-CHAPv2 challenges are 16 octets.
1211                  */
1212                 if (challenge->length < 16) {
1213                         radlog(L_AUTH, "rlm_mschap: MS-CHAP-Challenge has the wrong format.");
1214                         return RLM_MODULE_INVALID;
1215                 }
1216
1217                 /*
1218                  *      Responses are 50 octets.
1219                  */
1220                 if (response->length < 50) {
1221                         radlog(L_AUTH, "rlm_mschap: MS-CHAP-Response has the wrong format.");
1222                         return RLM_MODULE_INVALID;
1223                 }
1224
1225                 /*
1226                  *      We also require a User-Name
1227                  */
1228                 username = pairfind(request->packet->vps, PW_USER_NAME);
1229                 if (!username) {
1230                         radlog(L_AUTH, "rlm_mschap: We require a User-Name for MS-CHAPv2");
1231                         return RLM_MODULE_INVALID;
1232                 }
1233
1234
1235                 /*
1236                  *      with_ntdomain_hack moved here
1237                  */
1238                 if ((username_string = strchr(username->vp_strvalue, '\\')) != NULL) {
1239                         if (inst->with_ntdomain_hack) {
1240                                 username_string++;
1241                         } else {
1242                                 DEBUG2("  rlm_mschap: NT Domain delimeter found, should we have enabled with_ntdomain_hack?");
1243                                 username_string = username->vp_strvalue;
1244                         }
1245                 } else {
1246                         username_string = username->vp_strvalue;
1247                 }
1248
1249 #ifdef __APPLE__
1250                 /*
1251                  *      No "known good" NT-Password attribute.  Try to do
1252                  *      OpenDirectory authentication.
1253                  */
1254                 if (!nt_password && inst->open_directory) {
1255                         DEBUG2("  rlm_mschap: No NT-Password configured. Trying DirectoryService Authentication.");
1256                         return od_mschap_auth(request, challenge, username);
1257                 }
1258 #endif
1259                 /*
1260                  *      The old "mschapv2" function has been moved to
1261                  *      here.
1262                  *
1263                  *      MS-CHAPv2 takes some additional data to create an
1264                  *      MS-CHAPv1 challenge, and then does MS-CHAPv1.
1265                  */
1266                 challenge_hash(response->vp_octets + 2, /* peer challenge */
1267                                challenge->vp_octets, /* our challenge */
1268                                username_string, /* user name */
1269                                mschapv1_challenge); /* resulting challenge */
1270
1271                 DEBUG2("  rlm_mschap: Told to do MS-CHAPv2 for %s with NT-Password",
1272                        username_string);
1273
1274                 if (do_mschap(inst, request, nt_password, mschapv1_challenge,
1275                               response->vp_octets + 26, nthashhash) < 0) {
1276                         DEBUG2("  rlm_mschap: FAILED: MS-CHAP2-Response is incorrect");
1277                         mschap_add_reply(&request->reply->vps,
1278                                          *response->vp_octets,
1279                                          "MS-CHAP-Error", "E=691 R=1", 9);
1280                         return RLM_MODULE_REJECT;
1281                 }
1282
1283                 /*
1284                  *      Get the NT-hash-hash, if necessary
1285                  */
1286                 if (nt_password) {
1287                 }
1288
1289                 auth_response(username_string, /* without the domain */
1290                               nthashhash, /* nt-hash-hash */
1291                               response->vp_octets + 26, /* peer response */
1292                               response->vp_octets + 2, /* peer challenge */
1293                               challenge->vp_octets, /* our challenge */
1294                               msch2resp); /* calculated MPPE key */
1295                 mschap_add_reply(&request->reply->vps, *response->vp_octets,
1296                                  "MS-CHAP2-Success", msch2resp, 42);
1297                 chap = 2;
1298
1299         } else {                /* Neither CHAPv1 or CHAPv2 response: die */
1300                 radlog(L_AUTH, "rlm_mschap: No MS-CHAP response found");
1301                 return RLM_MODULE_INVALID;
1302         }
1303
1304         /*
1305          *      We have a CHAP response, but the account may be
1306          *      disabled.  Reject the user with the same error code
1307          *      we use when their password is invalid.
1308          */
1309         if (smb_ctrl) {
1310                 /*
1311                  *      Account is disabled.
1312                  *
1313                  *      They're found, but they don't exist, so we
1314                  *      return 'not found'.
1315                  */
1316                 if (((smb_ctrl->vp_integer & ACB_DISABLED) != 0) ||
1317                     ((smb_ctrl->vp_integer & ACB_NORMAL) == 0)) {
1318                         DEBUG2("  rlm_mschap: SMB-Account-Ctrl says that the account is disabled, or is not a normal account.");
1319                         mschap_add_reply( &request->reply->vps,
1320                                           *response->vp_octets,
1321                                           "MS-CHAP-Error", "E=691 R=1", 9);
1322                         return RLM_MODULE_NOTFOUND;
1323                 }
1324
1325                 /*
1326                  *      User is locked out.
1327                  */
1328                 if ((smb_ctrl->vp_integer & ACB_AUTOLOCK) != 0) {
1329                         DEBUG2("  rlm_mschap: SMB-Account-Ctrl says that the account is locked out.");
1330                         mschap_add_reply( &request->reply->vps,
1331                                           *response->vp_octets,
1332                                           "MS-CHAP-Error", "E=647 R=0", 9);
1333                         return RLM_MODULE_USERLOCK;
1334                 }
1335         }
1336
1337         /* now create MPPE attributes */
1338         if (inst->use_mppe) {
1339                 uint8_t mppe_sendkey[34];
1340                 uint8_t mppe_recvkey[34];
1341
1342                 if (chap == 1){
1343                         DEBUG2("rlm_mschap: adding MS-CHAPv1 MPPE keys");
1344                         memset(mppe_sendkey, 0, 32);
1345                         if (lm_password) {
1346                                 memcpy(mppe_sendkey, lm_password->vp_octets, 8);
1347                         }
1348
1349                         /*
1350                          *      According to RFC 2548 we
1351                          *      should send NT hash.  But in
1352                          *      practice it doesn't work.
1353                          *      Instead, we should send nthashhash
1354                          *
1355                          *      This is an error on RFC 2548.
1356                          */
1357                         /*
1358                          *      do_mschap cares to zero nthashhash if NT hash
1359                          *      is not available.
1360                          */
1361                         memcpy(mppe_sendkey + 8,
1362                                nthashhash, 16);
1363                         mppe_add_reply(request,
1364                                        "MS-CHAP-MPPE-Keys",
1365                                        mppe_sendkey, 32);
1366                 } else if (chap == 2) {
1367                         DEBUG2("rlm_mschap: adding MS-CHAPv2 MPPE keys");
1368                         mppe_chap2_gen_keys128(nthashhash,
1369                                                response->vp_octets + 26,
1370                                                mppe_sendkey, mppe_recvkey);
1371
1372                         mppe_add_reply(request,
1373                                        "MS-MPPE-Recv-Key",
1374                                        mppe_recvkey, 16);
1375                         mppe_add_reply(request,
1376                                        "MS-MPPE-Send-Key",
1377                                        mppe_sendkey, 16);
1378
1379                 }
1380                 radius_pairmake(request, &request->reply->vps,
1381                                 "MS-MPPE-Encryption-Policy",
1382                                 (inst->require_encryption)? "0x00000002":"0x00000001",
1383                                 T_OP_EQ);
1384                 radius_pairmake(request, &request->reply->vps,
1385                                 "MS-MPPE-Encryption-Types",
1386                                 (inst->require_strong)? "0x00000004":"0x00000006",
1387                                 T_OP_EQ);
1388         } /* else we weren't asked to use MPPE */
1389
1390         return RLM_MODULE_OK;
1391 #undef inst
1392 }
1393
1394 module_t rlm_mschap = {
1395         RLM_MODULE_INIT,
1396         "MS-CHAP",
1397         RLM_TYPE_THREAD_SAFE,           /* type */
1398         mschap_instantiate,             /* instantiation */
1399         mschap_detach,          /* detach */
1400         {
1401                 mschap_authenticate,    /* authenticate */
1402                 mschap_authorize,       /* authorize */
1403                 NULL,                   /* pre-accounting */
1404                 NULL,                   /* accounting */
1405                 NULL,                   /* checksimul */
1406                 NULL,                   /* pre-proxy */
1407                 NULL,                   /* post-proxy */
1408                 NULL                    /* post-auth */
1409         },
1410 };