Patch from Frank Cusack to add support for MSCHAPv2.
[ppp.git] / pppd / chap_ms.c
1 /*
2  * chap_ms.c - Microsoft MS-CHAP compatible implementation.
3  *
4  * Copyright (c) 1995 Eric Rosenquist, Strata Software Limited.
5  * http://www.strataware.com/
6  *
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms are permitted
10  * provided that the above copyright notice and this paragraph are
11  * duplicated in all such forms and that any documentation,
12  * advertising materials, and other materials related to such
13  * distribution and use acknowledge that the software was developed
14  * by Eric Rosenquist.  The name of the author may not be used to
15  * endorse or promote products derived from this software without
16  * specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
19  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
20  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21  */
22
23 /*
24  * Modifications by Lauri Pesonen / lpesonen@clinet.fi, april 1997
25  *
26  *   Implemented LANManager type password response to MS-CHAP challenges.
27  *   Now pppd provides both NT style and LANMan style blocks, and the
28  *   prefered is set by option "ms-lanman". Default is to use NT.
29  *   The hash text (StdText) was taken from Win95 RASAPI32.DLL.
30  *
31  *   You should also use DOMAIN\\USERNAME as described in README.MSCHAP80
32  */
33
34 /*
35  * Modifications by Frank Cusack, frank@google.com, March 2002.
36  *
37  *   Implemented MS-CHAPv2 functionality.  Heavily based on
38  *   sample implementation in RFC 2759.
39  */
40
41 #define RCSID   "$Id: chap_ms.c,v 1.18 2002/03/05 15:14:04 dfs Exp $"
42
43 #ifdef CHAPMS
44
45 #include <stdio.h>
46 #include <stdlib.h>
47 #include <string.h>
48 #include <ctype.h>
49 #include <sys/types.h>
50 #include <sys/time.h>
51 #include <unistd.h>
52 #ifdef HAVE_CRYPT_H
53 #include <crypt.h>
54 #endif
55
56 #include "pppd.h"
57 #include "chap.h"
58 #include "chap_ms.h"
59 #include "md4.h"
60 #include "sha1.h"
61
62 #ifndef USE_CRYPT
63 #include <des.h>
64 #endif
65
66 static const char rcsid[] = RCSID;
67
68
69 static void     ChallengeHash __P((u_char[16], u_char *, char *, u_char[8]));
70 static void     ascii2unicode __P((char[], int, u_char[]));
71 static void     NTPasswordHash __P((char *, int, u_char[MD4_SIGNATURE_SIZE]));
72 static void     ChallengeResponse __P((u_char *, u_char *, u_char[24]));
73 static void     DesEncrypt __P((u_char *, u_char *, u_char[8]));
74 static void     MakeKey __P((u_char *, u_char *));
75 static u_char   Get7Bits __P((u_char *, int));
76 static void     ChapMS_NT __P((u_char *, char *, int, u_char[24]));
77 static void     ChapMS2_NT __P((char *, u_char[16], char *, char *, int,
78                                 u_char[24]));
79 static void     GenerateAuthenticatorResponse __P((char*, int, u_char[24],
80                                                    u_char[16], u_char *,
81                                                    char *, u_char[41]));
82 #ifdef MSLANMAN
83 static void     ChapMS_LANMan __P((u_char *, char *, int, MS_ChapResponse *));
84 #endif
85
86 #ifdef USE_CRYPT
87 static void     Expand __P((u_char *, u_char *));
88 static void     Collapse __P((u_char *, u_char *));
89 #endif
90
91 extern double drand48 __P((void));
92
93 #ifdef MSLANMAN
94 bool    ms_lanman = 0;          /* Use LanMan password instead of NT */
95                                 /* Has meaning only with MS-CHAP challenges */
96 #endif
97
98 static void
99 ChallengeResponse(u_char *challenge,
100                   u_char PasswordHash[MD4_SIGNATURE_SIZE],
101                   u_char response[24])
102 {
103     char    ZPasswordHash[21];
104
105     BZERO(ZPasswordHash, sizeof(ZPasswordHash));
106     BCOPY(PasswordHash, ZPasswordHash, MD4_SIGNATURE_SIZE);
107
108 #if 0
109     dbglog("ChallengeResponse - ZPasswordHash %.*B",
110            sizeof(ZPasswordHash), ZPasswordHash);
111 #endif
112
113     DesEncrypt(challenge, ZPasswordHash +  0, &response[0]);
114     DesEncrypt(challenge, ZPasswordHash +  7, &response[8]);
115     DesEncrypt(challenge, ZPasswordHash + 14, &response[16]);
116
117 #if 0
118     dbglog("ChallengeResponse - response %.24B", response);
119 #endif
120 }
121
122
123 #ifdef USE_CRYPT
124 static void
125 DesEncrypt(u_char *clear, u_char *key, u_char cipher[8])
126 {
127     u_char des_key[8];
128     u_char crypt_key[66];
129     u_char des_input[66];
130
131     MakeKey(key, des_key);
132
133     Expand(des_key, crypt_key);
134     setkey(crypt_key);
135
136 #if 0
137     CHAPDEBUG((LOG_INFO, "DesEncrypt: 8 octet input : %.8B", clear));
138 #endif
139
140     Expand(clear, des_input);
141     encrypt(des_input, 0);
142     Collapse(des_input, cipher);
143
144 #if 0
145     CHAPDEBUG((LOG_INFO, "DesEncrypt: 8 octet output: %.8B", cipher));
146 #endif
147 }
148
149 #else /* USE_CRYPT */
150
151 static void
152 DesEncrypt(u_char *clear, u_char *key, u_char cipher[8])
153 {
154     des_cblock          des_key;
155     des_key_schedule    key_schedule;
156
157     MakeKey(key, des_key);
158
159     des_set_key(&des_key, key_schedule);
160
161 #if 0
162     CHAPDEBUG((LOG_INFO, "DesEncrypt: 8 octet input : %.8B", clear));
163 #endif
164
165     des_ecb_encrypt((des_cblock *)clear, (des_cblock *)cipher, key_schedule, 1);
166
167 #if 0
168     CHAPDEBUG((LOG_INFO, "DesEncrypt: 8 octet output: %.8B", cipher));
169 #endif
170 }
171
172 #endif /* USE_CRYPT */
173
174
175 static u_char Get7Bits(u_char *input, int startBit)
176 {
177     register unsigned int       word;
178
179     word  = (unsigned)input[startBit / 8] << 8;
180     word |= (unsigned)input[startBit / 8 + 1];
181
182     word >>= 15 - (startBit % 8 + 7);
183
184     return word & 0xFE;
185 }
186
187 #ifdef USE_CRYPT
188
189 /* in == 8-byte string (expanded version of the 56-bit key)
190  * out == 64-byte string where each byte is either 1 or 0
191  * Note that the low-order "bit" is always ignored by by setkey()
192  */
193 static void Expand(u_char *in, u_char *out)
194 {
195         int j, c;
196         int i;
197
198         for(i = 0; i < 64; in++){
199                 c = *in;
200                 for(j = 7; j >= 0; j--)
201                         *out++ = (c >> j) & 01;
202                 i += 8;
203         }
204 }
205
206 /* The inverse of Expand
207  */
208 static void Collapse(u_char *in, u_char *out)
209 {
210         int j;
211         int i;
212         unsigned int c;
213
214         for (i = 0; i < 64; i += 8, out++) {
215             c = 0;
216             for (j = 7; j >= 0; j--, in++)
217                 c |= *in << j;
218             *out = c & 0xff;
219         }
220 }
221 #endif
222
223 static void MakeKey(u_char *key, u_char *des_key)
224 {
225     des_key[0] = Get7Bits(key,  0);
226     des_key[1] = Get7Bits(key,  7);
227     des_key[2] = Get7Bits(key, 14);
228     des_key[3] = Get7Bits(key, 21);
229     des_key[4] = Get7Bits(key, 28);
230     des_key[5] = Get7Bits(key, 35);
231     des_key[6] = Get7Bits(key, 42);
232     des_key[7] = Get7Bits(key, 49);
233
234 #ifndef USE_CRYPT
235     des_set_odd_parity((des_cblock *)des_key);
236 #endif
237
238 #if 0
239     CHAPDEBUG((LOG_INFO, "MakeKey: 56-bit input : %.7B", key));
240     CHAPDEBUG((LOG_INFO, "MakeKey: 64-bit output: %.8B", des_key));
241 #endif
242 }
243
244
245 static void
246 ChallengeHash(u_char PeerChallenge[16], u_char *rchallenge,
247               char *username, u_char Challenge[8])
248     
249 {
250     SHA1_CTX    sha1Context;
251     u_char      sha1Hash[SHA1_SIGNATURE_SIZE];
252
253     SHA1_Init(&sha1Context);
254     SHA1_Update(&sha1Context, PeerChallenge, 16);
255     SHA1_Update(&sha1Context, rchallenge, 16);
256     SHA1_Update(&sha1Context, username, strlen(username));
257     SHA1_Final(sha1Hash, &sha1Context);
258
259     BCOPY(sha1Hash, Challenge, 8);
260 }
261
262 /*
263  * Convert the ASCII version of the password to Unicode.
264  * This implicitly supports 8-bit ISO8859/1 characters.
265  * This gives us the little-endian representation, which
266  * is assumed by all M$ CHAP RFCs.  (Unicode byte ordering
267  * is machine-dependent.)
268  */
269 static void
270 ascii2unicode(char ascii[], int ascii_len, u_char unicode[])
271 {
272     int i;
273
274     BZERO(unicode, ascii_len * 2);
275     for (i = 0; i < ascii_len; i++)
276         unicode[i * 2] = (u_char) ascii[i];
277 }
278
279 static void
280 NTPasswordHash(char *secret, int secret_len, u_char hash[MD4_SIGNATURE_SIZE])
281 {
282 #ifdef __NetBSD__
283     /* NetBSD uses the libc md4 routines which take bytes instead of bits */
284     int                 mdlen = secret_len;
285 #else
286     int                 mdlen = secret_len * 8;
287 #endif
288     MD4_CTX             md4Context;
289
290     MD4Init(&md4Context);
291     MD4Update(&md4Context, secret, mdlen);
292     MD4Final(hash, &md4Context);
293
294 }
295
296 static void
297 ChapMS_NT(u_char *rchallenge, char *secret, int secret_len,
298           u_char NTResponse[24])
299 {
300     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
301     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
302
303     /* Hash the Unicode version of the secret (== password). */
304     ascii2unicode(secret, secret_len, unicodePassword);
305     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
306
307     ChallengeResponse(rchallenge, PasswordHash, NTResponse);
308 }
309
310 static void
311 ChapMS2_NT(char *rchallenge, u_char PeerChallenge[16], char *username,
312            char *secret, int secret_len, u_char NTResponse[24])
313 {
314     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
315     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
316     u_char      Challenge[8];
317
318     ChallengeHash(PeerChallenge, rchallenge, username, Challenge);
319
320     /* Hash the Unicode version of the secret (== password). */
321     ascii2unicode(secret, secret_len, unicodePassword);
322     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
323
324     ChallengeResponse(Challenge, PasswordHash, NTResponse);
325 }
326
327 #ifdef MSLANMAN
328 static u_char *StdText = (u_char *)"KGS!@#$%"; /* key from rasapi32.dll */
329
330 static void
331 ChapMS_LANMan(u_char *rchallenge, char *secret, int secret_len,
332               u_char LMResponse[24])
333 {
334     int                 i;
335     u_char              UcasePassword[MAX_NT_PASSWORD]; /* max is actually 14 */
336     u_char              PasswordHash[MD4_SIGNATURE_SIZE];
337
338     /* LANMan password is case insensitive */
339     BZERO(UcasePassword, sizeof(UcasePassword));
340     for (i = 0; i < secret_len; i++)
341        UcasePassword[i] = (u_char)toupper(secret[i]);
342     DesEncrypt( StdText, UcasePassword + 0, PasswordHash + 0 );
343     DesEncrypt( StdText, UcasePassword + 7, PasswordHash + 8 );
344     ChallengeResponse(rchallenge, PasswordHash, LMResponse);
345 }
346 #endif
347
348
349 static void
350 GenerateAuthenticatorResponse(char *secret, int secret_len,
351                               u_char NTResponse[24], u_char PeerChallenge[16],
352                               u_char *rchallenge, char *username,
353                               u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1])
354 {
355     /*
356      * "Magic" constants used in response generation, from RFC 2759.
357      */
358     u_char Magic1[39] = /* "Magic server to client signing constant" */
359         {0x4D, 0x61, 0x67, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76,
360          0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6C, 0x69, 0x65,
361          0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67,
362          0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74};
363     u_char Magic2[41] = /* "Pad to make it do more than one iteration" */
364         {0x50, 0x61, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B,
365          0x65, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6D, 0x6F,
366          0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E,
367          0x65, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F,
368          0x6E};
369
370     int         i;
371     SHA1_CTX    sha1Context;
372     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
373     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
374     u_char      PasswordHashHash[MD4_SIGNATURE_SIZE];
375     u_char      Digest[SHA1_SIGNATURE_SIZE];
376     u_char      Challenge[8];
377
378     /* Hash (x2) the Unicode version of the secret (== password). */
379     ascii2unicode(secret, secret_len, unicodePassword);
380     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
381     NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);
382
383     SHA1_Init(&sha1Context);
384     SHA1_Update(&sha1Context, PasswordHashHash, sizeof(PasswordHashHash));
385     SHA1_Update(&sha1Context, NTResponse, 24);
386     SHA1_Update(&sha1Context, Magic1, sizeof(Magic1));
387     SHA1_Final(Digest, &sha1Context);
388
389     ChallengeHash(PeerChallenge, rchallenge, username, Challenge);
390
391     SHA1_Init(&sha1Context);
392     SHA1_Update(&sha1Context, Digest, sizeof(Digest));
393     SHA1_Update(&sha1Context, Challenge, sizeof(Challenge));
394     SHA1_Update(&sha1Context, Magic2, sizeof(Magic2));
395     SHA1_Final(Digest, &sha1Context);
396
397     /* Convert to ASCII hex string. */
398     for (i = 0; i < MAX((MS_AUTH_RESPONSE_LENGTH / 2), sizeof(Digest)); i++)
399         sprintf(&authResponse[i * 2], "%02X", Digest[i]);
400 }
401
402
403 void
404 ChapMS(chap_state *cstate, u_char *rchallenge, char *secret, int secret_len,
405        MS_ChapResponse *response)
406 {
407 #if 0
408     CHAPDEBUG((LOG_INFO, "ChapMS: secret is '%.*s'", secret_len, secret));
409 #endif
410     BZERO(response, sizeof(response));
411
412     /* Calculate both always */
413     ChapMS_NT(rchallenge, secret, secret_len, response->NTResp);
414
415 #ifdef MSLANMAN
416     ChapMS_LANMan(rchallenge, secret, secret_len, response);
417
418     /* prefered method is set by option  */
419     response->UseNT[0] = !ms_lanman;
420 #else
421     response->UseNT[0] = 1;
422 #endif
423
424 }
425
426
427 /*
428  * If PeerChallenge is NULL, one is generated and response->PeerChallenge
429  * is filled in.  Call this way when generating a response.
430  * If PeerChallenge is supplied, it is copied into response->PeerChallenge.
431  * Call this way when verifying a response.
432  *
433  * response->PeerChallenge is then used for calculation of the
434  * Authenticator Response.
435  */
436 void
437 ChapMS2(chap_state *cstate, u_char *rchallenge, u_char *PeerChallenge,
438         char *user, char *secret, int secret_len, MS_Chap2Response *response,
439         u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1])
440 {
441     u_char *p = response->PeerChallenge;
442     int i;
443
444     BZERO(response, sizeof(response));
445
446     /* Generate the Peer-Challenge if requested, or copy it if supplied. */
447     if (!PeerChallenge)
448         for (i = 0; i < sizeof(response->PeerChallenge); i++)
449             *p++ = (u_char) (drand48() * 0xff);
450     else
451         BCOPY(PeerChallenge, response->PeerChallenge,
452               sizeof(response->PeerChallenge));
453
454     /* Generate the NT-Response */
455     ChapMS2_NT(rchallenge, response->PeerChallenge, user,
456                secret, secret_len, response->NTResp);
457
458     /* Generate the Authenticator Response. */
459     GenerateAuthenticatorResponse(secret, secret_len, response->NTResp,
460                                   response->PeerChallenge, rchallenge,
461                                   user, authResponse);
462 }
463
464
465 #endif /* CHAPMS */