usr.sbin/ppp/chap_ms.c

   1 /*-
   2  * Copyright (c) 1997        Gabor Kincses <gabor@acm.org>
   3  *               1997 - 2001 Brian Somers <brian@Awfulhak.org>
   4  *          based on work by Eric Rosenquist
   5  *                           Strata Software Limited.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD: src/usr.sbin/ppp/chap_ms.c,v 1.9.2.6 2002/09/01 02:12:23 brian Exp $
  30  * $DragonFly: src/usr.sbin/ppp/chap_ms.c,v 1.4 2004/03/27 01:39:13 cpressey Exp $
  31  */
  32
  33 #include <ctype.h>
  34 #ifdef __DragonFly__
  35 #include <openssl/des.h>
  36 #include <sha.h>
  37 #else
  38 #include <sys/types.h>
  39 #include <stdlib.h>
  40 #ifdef __NetBSD__
  41 #include <openssl/des.h>
  42 #else
  43 #include <des.h>
  44 #endif
  45 #include <openssl/sha.h>
  46 #endif
  47 #include <md4.h>
  48 #include <string.h>
  49
  50 #include "chap_ms.h"
  51
  52 /*
  53  * Documentation & specifications:
  54  *
  55  * MS-CHAP (CHAP80)     rfc2433
  56  * MS-CHAP-V2 (CHAP81)  rfc2759
  57  * MPPE key management  draft-ietf-pppext-mppe-keys-02.txt
  58  */
  59
  60 static char SHA1_Pad1[40] =
  61   {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  62    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  63    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  64    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  65
  66 static char SHA1_Pad2[40] =
  67   {0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2,
  68    0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2,
  69    0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2,
  70    0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2, 0xF2};
  71
  72 /* unused, for documentation only */
  73 /* only NTResp is filled in for FreeBSD */
  74 struct MS_ChapResponse {
  75     u_char LANManResp[24];
  76     u_char NTResp[24];
  77     u_char UseNT;       /* If 1, ignore the LANMan response field */
  78 };
  79
  80 static u_char
  81 Get7Bits(u_char *input, int startBit)
  82 {
  83     unsigned int word;
  84
  85     word  = (unsigned)input[startBit / 8] << 8;
  86     word |= (unsigned)input[startBit / 8 + 1];
  87
  88     word >>= 15 - (startBit % 8 + 7);
  89
  90     return word & 0xFE;
  91 }
  92
  93 /* IN  56 bit DES key missing parity bits
  94    OUT 64 bit DES key with parity bits added */
  95 static void
  96 MakeKey(u_char *key, u_char *des_key)
  97 {
  98     des_key[0] = Get7Bits(key,  0);
  99     des_key[1] = Get7Bits(key,  7);
 100     des_key[2] = Get7Bits(key, 14);
 101     des_key[3] = Get7Bits(key, 21);
 102     des_key[4] = Get7Bits(key, 28);
 103     des_key[5] = Get7Bits(key, 35);
 104     des_key[6] = Get7Bits(key, 42);
 105     des_key[7] = Get7Bits(key, 49);
 106
 107     des_set_odd_parity((des_cblock *)des_key);
 108 }
 109
 110 static void /* IN 8 octets IN 7 octest OUT 8 octets */
 111 DesEncrypt(u_char *clear, u_char *key, u_char *cipher)
 112 {
 113     des_cblock          des_key;
 114     des_key_schedule    key_schedule;
 115
 116     MakeKey(key, des_key);
 117     des_set_key(&des_key, key_schedule);
 118     des_ecb_encrypt((des_cblock *)clear, (des_cblock *)cipher, key_schedule, 1);
 119 }
 120
 121 static void      /* IN 8 octets      IN 16 octets     OUT 24 octets */
 122 ChallengeResponse(u_char *challenge, u_char *pwHash, u_char *response)
 123 {
 124     char    ZPasswordHash[21];
 125
 126     memset(ZPasswordHash, '\0', sizeof ZPasswordHash);
 127     memcpy(ZPasswordHash, pwHash, 16);
 128
 129     DesEncrypt(challenge, ZPasswordHash +  0, response + 0);
 130     DesEncrypt(challenge, ZPasswordHash +  7, response + 8);
 131     DesEncrypt(challenge, ZPasswordHash + 14, response + 16);
 132 }
 133
 134 void
 135 NtPasswordHash(char *key, int keylen, char *hash)
 136 {
 137   MD4_CTX MD4context;
 138
 139   MD4Init(&MD4context);
 140   MD4Update(&MD4context, key, keylen);
 141   MD4Final(hash, &MD4context);
 142 }
 143
 144 void
 145 HashNtPasswordHash(char *hash, char *hashhash)
 146 {
 147   MD4_CTX MD4context;
 148
 149   MD4Init(&MD4context);
 150   MD4Update(&MD4context, hash, 16);
 151   MD4Final(hashhash, &MD4context);
 152 }
 153
 154 void
 155 ChallengeHash(char *PeerChallenge, char *AuthenticatorChallenge,
 156               char *UserName, int UserNameLen, char *Challenge)
 157 {
 158   SHA_CTX Context;
 159   char Digest[SHA_DIGEST_LENGTH];
 160   char *Name;
 161
 162   Name = strrchr(UserName, '\\');
 163   if(NULL == Name)
 164     Name = UserName;
 165   else
 166     Name++;
 167
 168   SHA1_Init(&Context);
 169
 170   SHA1_Update(&Context, PeerChallenge, 16);
 171   SHA1_Update(&Context, AuthenticatorChallenge, 16);
 172   SHA1_Update(&Context, Name, strlen(Name));
 173
 174   SHA1_Final(Digest, &Context);
 175   memcpy(Challenge, Digest, 8);
 176 }
 177
 178 void
 179 GenerateNTResponse(char *AuthenticatorChallenge, char *PeerChallenge,
 180                    char *UserName, int UserNameLen, char *Password,
 181                    int PasswordLen, char *Response)
 182 {
 183   char Challenge[8];
 184   char PasswordHash[16];
 185
 186   ChallengeHash(PeerChallenge, AuthenticatorChallenge, UserName, UserNameLen,
 187                 Challenge);
 188   NtPasswordHash(Password, PasswordLen, PasswordHash);
 189   ChallengeResponse(Challenge, PasswordHash, Response);
 190 }
 191
 192 #ifndef __DragonFly__
 193 #define LENGTH 20
 194 static char *
 195 SHA1_End(SHA_CTX *ctx, char *buf)
 196 {
 197     int i;
 198     unsigned char digest[LENGTH];
 199     static const char hex[]="0123456789abcdef";
 200
 201     if (!buf)
 202         buf = malloc(2*LENGTH + 1);
 203     if (!buf)
 204         return 0;
 205     SHA1_Final(digest, ctx);
 206     for (i = 0; i < LENGTH; i++) {
 207         buf[i+i] = hex[digest[i] >> 4];
 208         buf[i+i+1] = hex[digest[i] & 0x0f];
 209     }
 210     buf[i+i] = '\0';
 211     return buf;
 212 }
 213 #endif
 214
 215 void
 216 GenerateAuthenticatorResponse(char *Password, int PasswordLen,
 217                               char *NTResponse, char *PeerChallenge,
 218                               char *AuthenticatorChallenge, char *UserName,
 219                               int UserNameLen, char *AuthenticatorResponse)
 220 {
 221   SHA_CTX Context;
 222   char PasswordHash[16];
 223   char PasswordHashHash[16];
 224   char Challenge[8];
 225   u_char Digest[SHA_DIGEST_LENGTH];
 226   int i;
 227
 228       /*
 229        * "Magic" constants used in response generation
 230        */
 231   char Magic1[39] =
 232          {0x4D, 0x61, 0x67, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76,
 233           0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6C, 0x69, 0x65,
 234           0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67,
 235           0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74};
 236
 237
 238   char Magic2[41] =
 239          {0x50, 0x61, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B,
 240           0x65, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6D, 0x6F,
 241           0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E,
 242           0x65, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F,
 243           0x6E};
 244       /*
 245        * Hash the password with MD4
 246        */
 247   NtPasswordHash(Password, PasswordLen, PasswordHash);
 248       /*
 249        * Now hash the hash
 250        */
 251   HashNtPasswordHash(PasswordHash, PasswordHashHash);
 252
 253   SHA1_Init(&Context);
 254   SHA1_Update(&Context, PasswordHashHash, 16);
 255   SHA1_Update(&Context, NTResponse, 24);
 256   SHA1_Update(&Context, Magic1, 39);
 257   SHA1_Final(Digest, &Context);
 258   ChallengeHash(PeerChallenge, AuthenticatorChallenge, UserName, UserNameLen,
 259                 Challenge);
 260   SHA1_Init(&Context);
 261   SHA1_Update(&Context, Digest, 20);
 262   SHA1_Update(&Context, Challenge, 8);
 263   SHA1_Update(&Context, Magic2, 41);
 264
 265       /*
 266        * Encode the value of 'Digest' as "S=" followed by
 267        * 40 ASCII hexadecimal digits and return it in
 268        * AuthenticatorResponse.
 269        * For example,
 270        *   "S=0123456789ABCDEF0123456789ABCDEF01234567"
 271        */
 272   AuthenticatorResponse[0] = 'S';
 273   AuthenticatorResponse[1] = '=';
 274   SHA1_End(&Context, AuthenticatorResponse + 2);
 275   for (i=2; i<42; i++)
 276     AuthenticatorResponse[i] = toupper(AuthenticatorResponse[i]);
 277
 278 }
 279
 280 void
 281 GetMasterKey(char *PasswordHashHash, char *NTResponse, char *MasterKey)
 282 {
 283   char Digest[SHA_DIGEST_LENGTH];
 284   SHA_CTX Context;
 285   static char Magic1[27] =
 286       {0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74,
 287        0x68, 0x65, 0x20, 0x4d, 0x50, 0x50, 0x45, 0x20, 0x4d,
 288        0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x4b, 0x65, 0x79};
 289
 290   SHA1_Init(&Context);
 291   SHA1_Update(&Context, PasswordHashHash, 16);
 292   SHA1_Update(&Context, NTResponse, 24);
 293   SHA1_Update(&Context, Magic1, 27);
 294   SHA1_Final(Digest, &Context);
 295   memcpy(MasterKey, Digest, 16);
 296 }
 297
 298 void
 299 GetAsymetricStartKey(char *MasterKey, char *SessionKey, int SessionKeyLength,
 300                      int IsSend, int IsServer)
 301 {
 302   char Digest[SHA_DIGEST_LENGTH];
 303   SHA_CTX Context;
 304   char *s;
 305
 306   static char Magic2[84] =
 307       {0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
 308        0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
 309        0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
 310        0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x6b, 0x65, 0x79,
 311        0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73,
 312        0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x69, 0x64, 0x65,
 313        0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
 314        0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
 315        0x6b, 0x65, 0x79, 0x2e};
 316
 317   static char Magic3[84] =
 318       {0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
 319        0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
 320        0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
 321        0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
 322        0x6b, 0x65, 0x79, 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68,
 323        0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73,
 324        0x69, 0x64, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73,
 325        0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20,
 326        0x6b, 0x65, 0x79, 0x2e};
 327
 328   if (IsSend) {
 329      if (IsServer) {
 330         s = Magic3;
 331      } else {
 332         s = Magic2;
 333      }
 334   } else {
 335      if (IsServer) {
 336         s = Magic2;
 337      } else {
 338         s = Magic3;
 339      }
 340   }
 341
 342   SHA1_Init(&Context);
 343   SHA1_Update(&Context, MasterKey, 16);
 344   SHA1_Update(&Context, SHA1_Pad1, 40);
 345   SHA1_Update(&Context, s, 84);
 346   SHA1_Update(&Context, SHA1_Pad2, 40);
 347   SHA1_Final(Digest, &Context);
 348
 349   memcpy(SessionKey, Digest, SessionKeyLength);
 350 }
 351
 352 void
 353 GetNewKeyFromSHA(char *StartKey, char *SessionKey, long SessionKeyLength,
 354                  char *InterimKey)
 355 {
 356   SHA_CTX Context;
 357   char Digest[SHA_DIGEST_LENGTH];
 358
 359   SHA1_Init(&Context);
 360   SHA1_Update(&Context, StartKey, SessionKeyLength);
 361   SHA1_Update(&Context, SHA1_Pad1, 40);
 362   SHA1_Update(&Context, SessionKey, SessionKeyLength);
 363   SHA1_Update(&Context, SHA1_Pad2, 40);
 364   SHA1_Final(Digest, &Context);
 365
 366   memcpy(InterimKey, Digest, SessionKeyLength);
 367 }
 368
 369 #if 0
 370 static void
 371 Get_Key(char *InitialSessionKey, char *CurrentSessionKey,
 372         int LengthOfDesiredKey)
 373 {
 374   SHA_CTX Context;
 375   char Digest[SHA_DIGEST_LENGTH];
 376
 377   SHA1_Init(&Context);
 378   SHA1_Update(&Context, InitialSessionKey, LengthOfDesiredKey);
 379   SHA1_Update(&Context, SHA1_Pad1, 40);
 380   SHA1_Update(&Context, CurrentSessionKey, LengthOfDesiredKey);
 381   SHA1_Update(&Context, SHA1_Pad2, 40);
 382   SHA1_Final(Digest, &Context);
 383
 384   memcpy(CurrentSessionKey, Digest, LengthOfDesiredKey);
 385 }
 386 #endif
 387
 388 /* passwordHash 16-bytes MD4 hashed password
 389    challenge    8-bytes peer CHAP challenge
 390    since passwordHash is in a 24-byte buffer, response is written in there */
 391 void
 392 mschap_NT(char *passwordHash, char *challenge)
 393 {
 394     u_char response[24];
 395
 396     ChallengeResponse(challenge, passwordHash, response);
 397     memcpy(passwordHash, response, 24);
 398     passwordHash[24] = 1;               /* NT-style response */
 399 }
 400
 401 void
 402 mschap_LANMan(char *digest, char *challenge, char *secret)
 403 {
 404   static u_char salt[] = "KGS!@#$%";    /* RASAPI32.dll */
 405   char SECRET[14], *ptr, *end;
 406   u_char hash[16];
 407
 408   end = SECRET + sizeof SECRET;
 409   for (ptr = SECRET; *secret && ptr < end; ptr++, secret++)
 410     *ptr = toupper(*secret);
 411   if (ptr < end)
 412     memset(ptr, '\0', end - ptr);
 413
 414   DesEncrypt(salt, SECRET, hash);
 415   DesEncrypt(salt, SECRET + 7, hash + 8);
 416
 417   ChallengeResponse(challenge, hash, digest);
 418 }