git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/lwIP_MCF5235_GCC/lwip/src/netif/ppp/chpms.c

   1 /*** WARNING - THIS CODE HAS NOT BEEN FINISHED! ***/\r
   2 /*****************************************************************************\r
   3 * chpms.c - Network MicroSoft Challenge Handshake Authentication Protocol program file.\r
   4 *\r
   5 * Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc.\r
   6 * Copyright (c) 1997 by Global Election Systems Inc.  All rights reserved.\r
   7 *\r
   8 * The authors hereby grant permission to use, copy, modify, distribute,\r
   9 * and license this software and its documentation for any purpose, provided\r
  10 * that existing copyright notices are retained in all copies and that this\r
  11 * notice and the following disclaimer are included verbatim in any \r
  12 * distributions. No written agreement, license, or royalty fee is required\r
  13 * for any of the authorized uses.\r
  14 *\r
  15 * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR\r
  16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\r
  17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \r
  18 * IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,\r
  19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
  20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
  21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
  22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
  23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\r
  24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  25 *\r
  26 ******************************************************************************\r
  27 * REVISION HISTORY\r
  28 *\r
  29 * 03-01-01 Marc Boucher <marc@mbsi.ca>\r
  30 *   Ported to lwIP.\r
  31 * 97-12-08 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc.\r
  32 *       Original based on BSD chap_ms.c.\r
  33 *****************************************************************************/\r
  34 /*\r
  35  * chap_ms.c - Microsoft MS-CHAP compatible implementation.\r
  36  *\r
  37  * Copyright (c) 1995 Eric Rosenquist, Strata Software Limited.\r
  38  * http://www.strataware.com/\r
  39  *\r
  40  * All rights reserved.\r
  41  *\r
  42  * Redistribution and use in source and binary forms are permitted\r
  43  * provided that the above copyright notice and this paragraph are\r
  44  * duplicated in all such forms and that any documentation,\r
  45  * advertising materials, and other materials related to such\r
  46  * distribution and use acknowledge that the software was developed\r
  47  * by Eric Rosenquist.  The name of the author may not be used to\r
  48  * endorse or promote products derived from this software without\r
  49  * specific prior written permission.\r
  50  *\r
  51  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR\r
  52  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED\r
  53  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.\r
  54  */\r
  55 \r
  56 /*\r
  57  * Modifications by Lauri Pesonen / lpesonen@clinet.fi, april 1997\r
  58  *\r
  59  *   Implemented LANManager type password response to MS-CHAP challenges.\r
  60  *   Now pppd provides both NT style and LANMan style blocks, and the\r
  61  *   prefered is set by option "ms-lanman". Default is to use NT.\r
  62  *   The hash text (StdText) was taken from Win95 RASAPI32.DLL.\r
  63  *\r
  64  *   You should also use DOMAIN\\USERNAME as described in README.MSCHAP80\r
  65  */\r
  66 \r
  67 #define USE_CRYPT\r
  68 \r
  69 \r
  70 #include "ppp.h"\r
  71 \r
  72 #if MSCHAP_SUPPORT > 0\r
  73 \r
  74 #include "md4.h"\r
  75 #ifndef USE_CRYPT\r
  76 #include "des.h"\r
  77 #endif\r
  78 #include "chap.h"\r
  79 #include "chpms.h"\r
  80 #include "pppdebug.h"\r
  81 \r
  82 \r
  83 /*************************/\r
  84 /*** LOCAL DEFINITIONS ***/\r
  85 /*************************/\r
  86 \r
  87 \r
  88 /************************/\r
  89 /*** LOCAL DATA TYPES ***/\r
  90 /************************/\r
  91 typedef struct {\r
  92     u_char LANManResp[24];\r
  93     u_char NTResp[24];\r
  94     u_char UseNT;               /* If 1, ignore the LANMan response field */\r
  95 } MS_ChapResponse;\r
  96 /* We use MS_CHAP_RESPONSE_LEN, rather than sizeof(MS_ChapResponse),\r
  97    in case this struct gets padded. */\r
  98 \r
  99 \r
 100 \r
 101 /***********************************/\r
 102 /*** LOCAL FUNCTION DECLARATIONS ***/\r
 103 /***********************************/\r
 104 \r
 105 /* XXX Don't know what to do with these. */\r
 106 extern void setkey(const char *);\r
 107 extern void encrypt(char *, int);\r
 108 \r
 109 static void     DesEncrypt (u_char *, u_char *, u_char *);\r
 110 static void     MakeKey (u_char *, u_char *);\r
 111 \r
 112 #ifdef USE_CRYPT\r
 113 static void     Expand (u_char *, u_char *);\r
 114 static void     Collapse (u_char *, u_char *);\r
 115 #endif\r
 116 \r
 117 static void ChallengeResponse(\r
 118         u_char *challenge,      /* IN   8 octets */\r
 119         u_char *pwHash,         /* IN  16 octets */\r
 120         u_char *response        /* OUT 24 octets */\r
 121 );\r
 122 static void ChapMS_NT(\r
 123         char *rchallenge,\r
 124         int rchallenge_len,\r
 125         char *secret,\r
 126         int secret_len,\r
 127         MS_ChapResponse *response\r
 128 );\r
 129 static u_char Get7Bits(\r
 130         u_char *input,\r
 131         int startBit\r
 132 );\r
 133 \r
 134 \r
 135 /***********************************/\r
 136 /*** PUBLIC FUNCTION DEFINITIONS ***/\r
 137 /***********************************/\r
 138 void ChapMS(\r
 139         chap_state *cstate,\r
 140         char *rchallenge,\r
 141         int rchallenge_len,\r
 142         char *secret,\r
 143         int secret_len\r
 144 )\r
 145 {\r
 146         MS_ChapResponse response;\r
 147 #ifdef MSLANMAN\r
 148         extern int ms_lanman;\r
 149 #endif\r
 150         \r
 151 #if 0\r
 152         CHAPDEBUG((LOG_INFO, "ChapMS: secret is '%.*s'\n", secret_len, secret));\r
 153 #endif\r
 154         BZERO(&response, sizeof(response));\r
 155         \r
 156         /* Calculate both always */\r
 157         ChapMS_NT(rchallenge, rchallenge_len, secret, secret_len, &response);\r
 158         \r
 159 #ifdef MSLANMAN\r
 160         ChapMS_LANMan(rchallenge, rchallenge_len, secret, secret_len, &response);\r
 161         \r
 162         /* prefered method is set by option  */\r
 163         response.UseNT = !ms_lanman;\r
 164 #else\r
 165         response.UseNT = 1;\r
 166 #endif\r
 167         \r
 168         BCOPY(&response, cstate->response, MS_CHAP_RESPONSE_LEN);\r
 169         cstate->resp_length = MS_CHAP_RESPONSE_LEN;\r
 170 }\r
 171 \r
 172 \r
 173 /**********************************/\r
 174 /*** LOCAL FUNCTION DEFINITIONS ***/\r
 175 /**********************************/\r
 176 static void ChallengeResponse(\r
 177         u_char *challenge,      /* IN   8 octets */\r
 178         u_char *pwHash,         /* IN  16 octets */\r
 179         u_char *response        /* OUT 24 octets */\r
 180 )\r
 181 {\r
 182         char    ZPasswordHash[21];\r
 183         \r
 184         BZERO(ZPasswordHash, sizeof(ZPasswordHash));\r
 185         BCOPY(pwHash, ZPasswordHash, 16);\r
 186         \r
 187 #if 0\r
 188         log_packet(ZPasswordHash, sizeof(ZPasswordHash), "ChallengeResponse - ZPasswordHash", LOG_DEBUG);\r
 189 #endif\r
 190         \r
 191         DesEncrypt(challenge, ZPasswordHash +  0, response + 0);\r
 192         DesEncrypt(challenge, ZPasswordHash +  7, response + 8);\r
 193         DesEncrypt(challenge, ZPasswordHash + 14, response + 16);\r
 194         \r
 195 #if 0\r
 196         log_packet(response, 24, "ChallengeResponse - response", LOG_DEBUG);\r
 197 #endif\r
 198 }\r
 199 \r
 200 \r
 201 #ifdef USE_CRYPT\r
 202 static void DesEncrypt(\r
 203         u_char *clear,  /* IN  8 octets */\r
 204         u_char *key,    /* IN  7 octets */\r
 205         u_char *cipher  /* OUT 8 octets */\r
 206 )\r
 207 {\r
 208         u_char des_key[8];\r
 209         u_char crypt_key[66];\r
 210         u_char des_input[66];\r
 211         \r
 212         MakeKey(key, des_key);\r
 213         \r
 214         Expand(des_key, crypt_key);\r
 215         setkey(crypt_key);\r
 216         \r
 217 #if 0\r
 218         CHAPDEBUG((LOG_INFO, "DesEncrypt: 8 octet input : %02X%02X%02X%02X%02X%02X%02X%02X\n",\r
 219                clear[0], clear[1], clear[2], clear[3], clear[4], clear[5], clear[6], clear[7]));\r
 220 #endif\r
 221         \r
 222         Expand(clear, des_input);\r
 223         encrypt(des_input, 0);\r
 224         Collapse(des_input, cipher);\r
 225         \r
 226 #if 0\r
 227         CHAPDEBUG((LOG_INFO, "DesEncrypt: 8 octet output: %02X%02X%02X%02X%02X%02X%02X%02X\n",\r
 228                cipher[0], cipher[1], cipher[2], cipher[3], cipher[4], cipher[5], cipher[6], cipher[7]));\r
 229 #endif\r
 230 }\r
 231 \r
 232 #else /* USE_CRYPT */\r
 233 \r
 234 static void DesEncrypt(\r
 235         u_char *clear,  /* IN  8 octets */\r
 236         u_char *key,    /* IN  7 octets */\r
 237         u_char *cipher  /* OUT 8 octets */\r
 238 )\r
 239 {\r
 240         des_cblock              des_key;\r
 241         des_key_schedule        key_schedule;\r
 242         \r
 243         MakeKey(key, des_key);\r
 244         \r
 245         des_set_key(&des_key, key_schedule);\r
 246         \r
 247 #if 0\r
 248         CHAPDEBUG((LOG_INFO, "DesEncrypt: 8 octet input : %02X%02X%02X%02X%02X%02X%02X%02X\n",\r
 249                clear[0], clear[1], clear[2], clear[3], clear[4], clear[5], clear[6], clear[7]));\r
 250 #endif\r
 251         \r
 252         des_ecb_encrypt((des_cblock *)clear, (des_cblock *)cipher, key_schedule, 1);\r
 253         \r
 254 #if 0\r
 255         CHAPDEBUG((LOG_INFO, "DesEncrypt: 8 octet output: %02X%02X%02X%02X%02X%02X%02X%02X\n",\r
 256                cipher[0], cipher[1], cipher[2], cipher[3], cipher[4], cipher[5], cipher[6], cipher[7]));\r
 257 #endif\r
 258 }\r
 259 \r
 260 #endif /* USE_CRYPT */\r
 261 \r
 262 \r
 263 static u_char Get7Bits(\r
 264         u_char *input,\r
 265         int startBit\r
 266 )\r
 267 {\r
 268         register unsigned int   word;\r
 269         \r
 270         word  = (unsigned)input[startBit / 8] << 8;\r
 271         word |= (unsigned)input[startBit / 8 + 1];\r
 272         \r
 273         word >>= 15 - (startBit % 8 + 7);\r
 274         \r
 275         return word & 0xFE;\r
 276 }\r
 277 \r
 278 #ifdef USE_CRYPT\r
 279 \r
 280 /* in == 8-byte string (expanded version of the 56-bit key)\r
 281  * out == 64-byte string where each byte is either 1 or 0\r
 282  * Note that the low-order "bit" is always ignored by by setkey()\r
 283  */\r
 284 static void Expand(u_char *in, u_char *out)\r
 285 {\r
 286         int j, c;\r
 287         int i;\r
 288         \r
 289         for(i = 0; i < 64; in++){\r
 290                 c = *in;\r
 291                 for(j = 7; j >= 0; j--)\r
 292                         *out++ = (c >> j) & 01;\r
 293                 i += 8;\r
 294         }\r
 295 }\r
 296 \r
 297 /* The inverse of Expand\r
 298  */\r
 299 static void Collapse(u_char *in, u_char *out)\r
 300 {\r
 301         int j;\r
 302         int i;\r
 303         unsigned int c;\r
 304         \r
 305         for (i = 0; i < 64; i += 8, out++) {\r
 306                 c = 0;\r
 307                 for (j = 7; j >= 0; j--, in++)\r
 308                         c |= *in << j;\r
 309                 *out = c & 0xff;\r
 310         }\r
 311 }\r
 312 #endif\r
 313 \r
 314 static void MakeKey(\r
 315         u_char *key,            /* IN  56 bit DES key missing parity bits */\r
 316         u_char *des_key         /* OUT 64 bit DES key with parity bits added */\r
 317 )\r
 318 {\r
 319         des_key[0] = Get7Bits(key,  0);\r
 320         des_key[1] = Get7Bits(key,  7);\r
 321         des_key[2] = Get7Bits(key, 14);\r
 322         des_key[3] = Get7Bits(key, 21);\r
 323         des_key[4] = Get7Bits(key, 28);\r
 324         des_key[5] = Get7Bits(key, 35);\r
 325         des_key[6] = Get7Bits(key, 42);\r
 326         des_key[7] = Get7Bits(key, 49);\r
 327         \r
 328 #ifndef USE_CRYPT\r
 329         des_set_odd_parity((des_cblock *)des_key);\r
 330 #endif\r
 331         \r
 332 #if 0\r
 333         CHAPDEBUG((LOG_INFO, "MakeKey: 56-bit input : %02X%02X%02X%02X%02X%02X%02X\n",\r
 334                key[0], key[1], key[2], key[3], key[4], key[5], key[6]));\r
 335         CHAPDEBUG((LOG_INFO, "MakeKey: 64-bit output: %02X%02X%02X%02X%02X%02X%02X%02X\n",\r
 336                des_key[0], des_key[1], des_key[2], des_key[3], des_key[4], des_key[5], des_key[6], des_key[7]));\r
 337 #endif\r
 338 }\r
 339 \r
 340 static void ChapMS_NT(\r
 341         char *rchallenge,\r
 342         int rchallenge_len,\r
 343         char *secret,\r
 344         int secret_len,\r
 345         MS_ChapResponse *response\r
 346 )\r
 347 {\r
 348         int                     i;\r
 349         MDstruct        md4Context;\r
 350         u_char          unicodePassword[MAX_NT_PASSWORD * 2];\r
 351         static int      low_byte_first = -1;\r
 352         \r
 353         /* Initialize the Unicode version of the secret (== password). */\r
 354         /* This implicitly supports 8-bit ISO8859/1 characters. */\r
 355         BZERO(unicodePassword, sizeof(unicodePassword));\r
 356         for (i = 0; i < secret_len; i++)\r
 357                 unicodePassword[i * 2] = (u_char)secret[i];\r
 358         \r
 359         MDbegin(&md4Context);\r
 360         MDupdate(&md4Context, unicodePassword, secret_len * 2 * 8);     /* Unicode is 2 bytes/char, *8 for bit count */\r
 361         \r
 362         if (low_byte_first == -1)\r
 363                 low_byte_first = (htons((unsigned short int)1) != 1);\r
 364         if (low_byte_first == 0)\r
 365                 MDreverse((u_long *)&md4Context);  /*  sfb 961105 */\r
 366         \r
 367         MDupdate(&md4Context, NULL, 0); /* Tell MD4 we're done */\r
 368         \r
 369         ChallengeResponse(rchallenge, (char *)md4Context.buffer, response->NTResp);\r
 370 }\r
 371 \r
 372 #ifdef MSLANMAN\r
 373 static u_char *StdText = (u_char *)"KGS!@#$%"; /* key from rasapi32.dll */\r
 374 \r
 375 static ChapMS_LANMan(\r
 376         char *rchallenge,\r
 377         int rchallenge_len,\r
 378         char *secret,\r
 379         int secret_len,\r
 380         MS_ChapResponse *response\r
 381 )\r
 382 {\r
 383         int                     i;\r
 384         u_char          UcasePassword[MAX_NT_PASSWORD]; /* max is actually 14 */\r
 385         u_char          PasswordHash[16];\r
 386         \r
 387         /* LANMan password is case insensitive */\r
 388         BZERO(UcasePassword, sizeof(UcasePassword));\r
 389         for (i = 0; i < secret_len; i++)\r
 390                 UcasePassword[i] = (u_char)toupper(secret[i]);\r
 391         DesEncrypt( StdText, UcasePassword + 0, PasswordHash + 0 );\r
 392         DesEncrypt( StdText, UcasePassword + 7, PasswordHash + 8 );\r
 393         ChallengeResponse(rchallenge, PasswordHash, response->LANManResp);\r
 394 }\r
 395 #endif\r
 396 \r
 397 #endif /* MSCHAP_SUPPORT */\r
 398 \r