Corrected Linux MPPE kernel modules (Frank Cusack)
[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 sample
38  *   implementation in RFC 2759.  Implemented MPPE functionality,
39  *   heavily based on sample implementation in RFC 3079.
40  *   Copyright (c) 2002 Google, Inc.
41  */
42
43 #define RCSID   "$Id: chap_ms.c,v 1.20 2002/04/02 14:15:07 dfs Exp $"
44
45 #ifdef CHAPMS
46
47 #include <stdio.h>
48 #include <stdlib.h>
49 #include <string.h>
50 #include <ctype.h>
51 #include <sys/types.h>
52 #include <sys/time.h>
53 #include <unistd.h>
54 #ifdef HAVE_CRYPT_H
55 #include <crypt.h>
56 #endif
57
58 #include "pppd.h"
59 #include "chap.h"
60 #include "chap_ms.h"
61 #include "md4.h"
62 #include "sha1.h"
63
64 #ifndef USE_CRYPT
65 #include <des.h>
66 #endif
67
68 static const char rcsid[] = RCSID;
69
70
71 static void     ChallengeHash __P((u_char[16], u_char *, char *, u_char[8]));
72 static void     ascii2unicode __P((char[], int, u_char[]));
73 static void     NTPasswordHash __P((char *, int, u_char[MD4_SIGNATURE_SIZE]));
74 static void     ChallengeResponse __P((u_char *, u_char *, u_char[24]));
75 static void     DesEncrypt __P((u_char *, u_char *, u_char[8]));
76 static void     MakeKey __P((u_char *, u_char *));
77 static u_char   Get7Bits __P((u_char *, int));
78 static void     ChapMS_NT __P((u_char *, char *, int, u_char[24]));
79 static void     ChapMS2_NT __P((char *, u_char[16], char *, char *, int,
80                                 u_char[24]));
81 static void     GenerateAuthenticatorResponse __P((char*, int, u_char[24],
82                                                    u_char[16], u_char *,
83                                                    char *, u_char[41]));
84 #ifdef MSLANMAN
85 static void     ChapMS_LANMan __P((u_char *, char *, int, MS_ChapResponse *));
86 #endif
87
88 #ifdef USE_CRYPT
89 static void     Expand __P((u_char *, u_char *));
90 static void     Collapse __P((u_char *, u_char *));
91 #endif
92
93 #ifdef MPPE
94 static void     Set_Start_Key __P((u_char *, char *, int));
95 static void     SetMasterKeys __P((char *, int, u_char[24], int));
96 #endif
97
98 extern double drand48 __P((void));
99
100 #ifdef MSLANMAN
101 bool    ms_lanman = 0;          /* Use LanMan password instead of NT */
102                                 /* Has meaning only with MS-CHAP challenges */
103 #endif
104
105 #ifdef MPPE
106 u_char mppe_send_key[MPPE_MAX_KEY_LEN];
107 u_char mppe_recv_key[MPPE_MAX_KEY_LEN];
108 #endif
109
110 static void
111 ChallengeResponse(u_char *challenge,
112                   u_char PasswordHash[MD4_SIGNATURE_SIZE],
113                   u_char response[24])
114 {
115     char    ZPasswordHash[21];
116
117     BZERO(ZPasswordHash, sizeof(ZPasswordHash));
118     BCOPY(PasswordHash, ZPasswordHash, MD4_SIGNATURE_SIZE);
119
120 #if 0
121     dbglog("ChallengeResponse - ZPasswordHash %.*B",
122            sizeof(ZPasswordHash), ZPasswordHash);
123 #endif
124
125     DesEncrypt(challenge, ZPasswordHash +  0, &response[0]);
126     DesEncrypt(challenge, ZPasswordHash +  7, &response[8]);
127     DesEncrypt(challenge, ZPasswordHash + 14, &response[16]);
128
129 #if 0
130     dbglog("ChallengeResponse - response %.24B", response);
131 #endif
132 }
133
134
135 #ifdef USE_CRYPT
136 static void
137 DesEncrypt(u_char *clear, u_char *key, u_char cipher[8])
138 {
139     u_char des_key[8];
140     u_char crypt_key[66];
141     u_char des_input[66];
142
143     MakeKey(key, des_key);
144
145     Expand(des_key, crypt_key);
146     setkey(crypt_key);
147
148 #if 0
149     CHAPDEBUG((LOG_INFO, "DesEncrypt: 8 octet input : %.8B", clear));
150 #endif
151
152     Expand(clear, des_input);
153     encrypt(des_input, 0);
154     Collapse(des_input, cipher);
155
156 #if 0
157     CHAPDEBUG((LOG_INFO, "DesEncrypt: 8 octet output: %.8B", cipher));
158 #endif
159 }
160
161 #else /* USE_CRYPT */
162
163 static void
164 DesEncrypt(u_char *clear, u_char *key, u_char cipher[8])
165 {
166     des_cblock          des_key;
167     des_key_schedule    key_schedule;
168
169     MakeKey(key, des_key);
170
171     des_set_key(&des_key, key_schedule);
172
173 #if 0
174     CHAPDEBUG((LOG_INFO, "DesEncrypt: 8 octet input : %.8B", clear));
175 #endif
176
177     des_ecb_encrypt((des_cblock *)clear, (des_cblock *)cipher, key_schedule, 1);
178
179 #if 0
180     CHAPDEBUG((LOG_INFO, "DesEncrypt: 8 octet output: %.8B", cipher));
181 #endif
182 }
183
184 #endif /* USE_CRYPT */
185
186
187 static u_char Get7Bits(u_char *input, int startBit)
188 {
189     register unsigned int       word;
190
191     word  = (unsigned)input[startBit / 8] << 8;
192     word |= (unsigned)input[startBit / 8 + 1];
193
194     word >>= 15 - (startBit % 8 + 7);
195
196     return word & 0xFE;
197 }
198
199 #ifdef USE_CRYPT
200
201 /* in == 8-byte string (expanded version of the 56-bit key)
202  * out == 64-byte string where each byte is either 1 or 0
203  * Note that the low-order "bit" is always ignored by by setkey()
204  */
205 static void Expand(u_char *in, u_char *out)
206 {
207         int j, c;
208         int i;
209
210         for(i = 0; i < 64; in++){
211                 c = *in;
212                 for(j = 7; j >= 0; j--)
213                         *out++ = (c >> j) & 01;
214                 i += 8;
215         }
216 }
217
218 /* The inverse of Expand
219  */
220 static void Collapse(u_char *in, u_char *out)
221 {
222         int j;
223         int i;
224         unsigned int c;
225
226         for (i = 0; i < 64; i += 8, out++) {
227             c = 0;
228             for (j = 7; j >= 0; j--, in++)
229                 c |= *in << j;
230             *out = c & 0xff;
231         }
232 }
233 #endif
234
235 static void MakeKey(u_char *key, u_char *des_key)
236 {
237     des_key[0] = Get7Bits(key,  0);
238     des_key[1] = Get7Bits(key,  7);
239     des_key[2] = Get7Bits(key, 14);
240     des_key[3] = Get7Bits(key, 21);
241     des_key[4] = Get7Bits(key, 28);
242     des_key[5] = Get7Bits(key, 35);
243     des_key[6] = Get7Bits(key, 42);
244     des_key[7] = Get7Bits(key, 49);
245
246 #ifndef USE_CRYPT
247     des_set_odd_parity((des_cblock *)des_key);
248 #endif
249
250 #if 0
251     CHAPDEBUG((LOG_INFO, "MakeKey: 56-bit input : %.7B", key));
252     CHAPDEBUG((LOG_INFO, "MakeKey: 64-bit output: %.8B", des_key));
253 #endif
254 }
255
256
257 static void
258 ChallengeHash(u_char PeerChallenge[16], u_char *rchallenge,
259               char *username, u_char Challenge[8])
260     
261 {
262     SHA1_CTX    sha1Context;
263     u_char      sha1Hash[SHA1_SIGNATURE_SIZE];
264     char        *user;
265
266     /* remove domain from "domain\username" */
267     if ((user = strrchr(username, '\\')) != NULL)
268         ++user;
269     else
270         user = username;
271
272     SHA1_Init(&sha1Context);
273     SHA1_Update(&sha1Context, PeerChallenge, 16);
274     SHA1_Update(&sha1Context, rchallenge, 16);
275     SHA1_Update(&sha1Context, user, strlen(user));
276     SHA1_Final(sha1Hash, &sha1Context);
277
278     BCOPY(sha1Hash, Challenge, 8);
279 }
280
281 /*
282  * Convert the ASCII version of the password to Unicode.
283  * This implicitly supports 8-bit ISO8859/1 characters.
284  * This gives us the little-endian representation, which
285  * is assumed by all M$ CHAP RFCs.  (Unicode byte ordering
286  * is machine-dependent.)
287  */
288 static void
289 ascii2unicode(char ascii[], int ascii_len, u_char unicode[])
290 {
291     int i;
292
293     BZERO(unicode, ascii_len * 2);
294     for (i = 0; i < ascii_len; i++)
295         unicode[i * 2] = (u_char) ascii[i];
296 }
297
298 static void
299 NTPasswordHash(char *secret, int secret_len, u_char hash[MD4_SIGNATURE_SIZE])
300 {
301 #ifdef __NetBSD__
302     /* NetBSD uses the libc md4 routines which take bytes instead of bits */
303     int                 mdlen = secret_len;
304 #else
305     int                 mdlen = secret_len * 8;
306 #endif
307     MD4_CTX             md4Context;
308
309     MD4Init(&md4Context);
310     MD4Update(&md4Context, secret, mdlen);
311     MD4Final(hash, &md4Context);
312
313 }
314
315 static void
316 ChapMS_NT(u_char *rchallenge, char *secret, int secret_len,
317           u_char NTResponse[24])
318 {
319     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
320     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
321
322     /* Hash the Unicode version of the secret (== password). */
323     ascii2unicode(secret, secret_len, unicodePassword);
324     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
325
326     ChallengeResponse(rchallenge, PasswordHash, NTResponse);
327 }
328
329 static void
330 ChapMS2_NT(char *rchallenge, u_char PeerChallenge[16], char *username,
331            char *secret, int secret_len, u_char NTResponse[24])
332 {
333     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
334     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
335     u_char      Challenge[8];
336
337     ChallengeHash(PeerChallenge, rchallenge, username, Challenge);
338
339     /* Hash the Unicode version of the secret (== password). */
340     ascii2unicode(secret, secret_len, unicodePassword);
341     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
342
343     ChallengeResponse(Challenge, PasswordHash, NTResponse);
344 }
345
346 #ifdef MSLANMAN
347 static u_char *StdText = (u_char *)"KGS!@#$%"; /* key from rasapi32.dll */
348
349 static void
350 ChapMS_LANMan(u_char *rchallenge, char *secret, int secret_len,
351               u_char LMResponse[24])
352 {
353     int                 i;
354     u_char              UcasePassword[MAX_NT_PASSWORD]; /* max is actually 14 */
355     u_char              PasswordHash[MD4_SIGNATURE_SIZE];
356
357     /* LANMan password is case insensitive */
358     BZERO(UcasePassword, sizeof(UcasePassword));
359     for (i = 0; i < secret_len; i++)
360        UcasePassword[i] = (u_char)toupper(secret[i]);
361     DesEncrypt( StdText, UcasePassword + 0, PasswordHash + 0 );
362     DesEncrypt( StdText, UcasePassword + 7, PasswordHash + 8 );
363     ChallengeResponse(rchallenge, PasswordHash, LMResponse);
364 }
365 #endif
366
367
368 static void
369 GenerateAuthenticatorResponse(char *secret, int secret_len,
370                               u_char NTResponse[24], u_char PeerChallenge[16],
371                               u_char *rchallenge, char *username,
372                               u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1])
373 {
374     /*
375      * "Magic" constants used in response generation, from RFC 2759.
376      */
377     u_char Magic1[39] = /* "Magic server to client signing constant" */
378         { 0x4D, 0x61, 0x67, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76,
379           0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6C, 0x69, 0x65,
380           0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67,
381           0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74 };
382     u_char Magic2[41] = /* "Pad to make it do more than one iteration" */
383         { 0x50, 0x61, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B,
384           0x65, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6D, 0x6F,
385           0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E,
386           0x65, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F,
387           0x6E };
388
389     int         i;
390     SHA1_CTX    sha1Context;
391     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
392     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
393     u_char      PasswordHashHash[MD4_SIGNATURE_SIZE];
394     u_char      Digest[SHA1_SIGNATURE_SIZE];
395     u_char      Challenge[8];
396
397     /* Hash (x2) the Unicode version of the secret (== password). */
398     ascii2unicode(secret, secret_len, unicodePassword);
399     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
400     NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);
401
402     SHA1_Init(&sha1Context);
403     SHA1_Update(&sha1Context, PasswordHashHash, sizeof(PasswordHashHash));
404     SHA1_Update(&sha1Context, NTResponse, 24);
405     SHA1_Update(&sha1Context, Magic1, sizeof(Magic1));
406     SHA1_Final(Digest, &sha1Context);
407
408     ChallengeHash(PeerChallenge, rchallenge, username, Challenge);
409
410     SHA1_Init(&sha1Context);
411     SHA1_Update(&sha1Context, Digest, sizeof(Digest));
412     SHA1_Update(&sha1Context, Challenge, sizeof(Challenge));
413     SHA1_Update(&sha1Context, Magic2, sizeof(Magic2));
414     SHA1_Final(Digest, &sha1Context);
415
416     /* Convert to ASCII hex string. */
417     for (i = 0; i < MAX((MS_AUTH_RESPONSE_LENGTH / 2), sizeof(Digest)); i++)
418         sprintf(&authResponse[i * 2], "%02X", Digest[i]);
419 }
420
421
422 #ifdef MPPE
423 /*
424  * Set mppe_xxxx_key from the NTPasswordHashHash.
425  * RFC 2548 (RADIUS support) requires us to export this function (ugh).
426  */
427 void
428 mppe_set_keys(u_char *rchallenge, u_char PasswordHashHash[MD4_SIGNATURE_SIZE])
429 {
430     SHA1_CTX    sha1Context;
431     u_char      Digest[SHA1_SIGNATURE_SIZE];    /* >= MPPE_MAX_KEY_LEN */
432
433     SHA1_Init(&sha1Context);
434     SHA1_Update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
435     SHA1_Update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
436     SHA1_Update(&sha1Context, rchallenge, 8);
437     SHA1_Final(Digest, &sha1Context);
438
439     /* Same key in both directions. */
440     BCOPY(Digest, mppe_send_key, sizeof(mppe_send_key));
441     BCOPY(Digest, mppe_recv_key, sizeof(mppe_recv_key));
442 }
443
444 /*
445  * Set mppe_xxxx_key from MS-CHAP credentials. (see RFC 3079)
446  */
447 static void
448 Set_Start_Key(u_char *rchallenge, char *secret, int secret_len)
449 {
450     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
451     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
452     u_char      PasswordHashHash[MD4_SIGNATURE_SIZE];
453
454     /* Hash (x2) the Unicode version of the secret (== password). */
455     ascii2unicode(secret, secret_len, unicodePassword);
456     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
457     NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);
458
459     mppe_set_keys(rchallenge, PasswordHashHash);
460 }
461
462 /*
463  * Set mppe_xxxx_key from MS-CHAPv2 credentials. (see RFC 3079)
464  */
465 static void
466 SetMasterKeys(char *secret, int secret_len, u_char NTResponse[24], int IsServer)
467 {
468     SHA1_CTX    sha1Context;
469     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
470     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
471     u_char      PasswordHashHash[MD4_SIGNATURE_SIZE];
472     u_char      MasterKey[SHA1_SIGNATURE_SIZE]; /* >= MPPE_MAX_KEY_LEN */
473     u_char      Digest[SHA1_SIGNATURE_SIZE];    /* >= MPPE_MAX_KEY_LEN */
474
475     u_char SHApad1[40] =
476         { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
477           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
478           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
479           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
480     u_char SHApad2[40] =
481         { 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
482           0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
483           0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
484           0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2 };
485
486     /* "This is the MPPE Master Key" */
487     u_char Magic1[27] =
488         { 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74,
489           0x68, 0x65, 0x20, 0x4d, 0x50, 0x50, 0x45, 0x20, 0x4d,
490           0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x4b, 0x65, 0x79 };
491     /* "On the client side, this is the send key; "
492        "on the server side, it is the receive key." */
493     u_char Magic2[84] =
494         { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
495           0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
496           0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
497           0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x6b, 0x65, 0x79,
498           0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73,
499           0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x69, 0x64, 0x65,
500           0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
501           0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
502           0x6b, 0x65, 0x79, 0x2e };
503     /* "On the client side, this is the receive key; "
504        "on the server side, it is the send key." */
505     u_char Magic3[84] =
506         { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
507           0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
508           0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
509           0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
510           0x6b, 0x65, 0x79, 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68,
511           0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73,
512           0x69, 0x64, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73,
513           0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20,
514           0x6b, 0x65, 0x79, 0x2e };
515     u_char *s;
516
517     /* Hash (x2) the Unicode version of the secret (== password). */
518     ascii2unicode(secret, secret_len, unicodePassword);
519     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
520     NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);
521
522     SHA1_Init(&sha1Context);
523     SHA1_Update(&sha1Context, PasswordHashHash, sizeof(PasswordHashHash));
524     SHA1_Update(&sha1Context, NTResponse, 24);
525     SHA1_Update(&sha1Context, Magic1, sizeof(Magic1));
526     SHA1_Final(MasterKey, &sha1Context);
527
528     /*
529      * generate send key
530      */
531     if (IsServer)
532         s = Magic3;
533     else
534         s = Magic2;
535     SHA1_Init(&sha1Context);
536     SHA1_Update(&sha1Context, MasterKey, 16);
537     SHA1_Update(&sha1Context, SHApad1, sizeof(SHApad1));
538     SHA1_Update(&sha1Context, s, 84);
539     SHA1_Update(&sha1Context, SHApad2, sizeof(SHApad2));
540     SHA1_Final(Digest, &sha1Context);
541
542     BCOPY(Digest, mppe_send_key, sizeof(mppe_send_key));
543
544     /*
545      * generate recv key
546      */
547     if (IsServer)
548         s = Magic2;
549     else
550         s = Magic3;
551     SHA1_Init(&sha1Context);
552     SHA1_Update(&sha1Context, MasterKey, 16);
553     SHA1_Update(&sha1Context, SHApad1, sizeof(SHApad1));
554     SHA1_Update(&sha1Context, s, 84);
555     SHA1_Update(&sha1Context, SHApad2, sizeof(SHApad2));
556     SHA1_Final(Digest, &sha1Context);
557
558     BCOPY(Digest, mppe_recv_key, sizeof(mppe_recv_key));
559 }
560
561 #endif /* MPPE */
562
563
564 void
565 ChapMS(chap_state *cstate, u_char *rchallenge, char *secret, int secret_len,
566        MS_ChapResponse *response)
567 {
568 #if 0
569     CHAPDEBUG((LOG_INFO, "ChapMS: secret is '%.*s'", secret_len, secret));
570 #endif
571     BZERO(response, sizeof(*response));
572
573     /* Calculate both always */
574     ChapMS_NT(rchallenge, secret, secret_len, response->NTResp);
575
576 #ifdef MSLANMAN
577     ChapMS_LANMan(rchallenge, secret, secret_len, response);
578
579     /* prefered method is set by option  */
580     response->UseNT[0] = !ms_lanman;
581 #else
582     response->UseNT[0] = 1;
583 #endif
584
585 #ifdef MPPE
586     Set_Start_Key(rchallenge, secret, secret_len);
587 #endif
588 }
589
590
591 /*
592  * If PeerChallenge is NULL, one is generated and response->PeerChallenge
593  * is filled in.  Call this way when generating a response.
594  * If PeerChallenge is supplied, it is copied into response->PeerChallenge.
595  * Call this way when verifying a response (or debugging).
596  * Do not call with PeerChallenge = response->PeerChallenge.
597  *
598  * response->PeerChallenge is then used for calculation of the
599  * Authenticator Response.
600  */
601 void
602 ChapMS2(chap_state *cstate, u_char *rchallenge, u_char *PeerChallenge,
603         char *user, char *secret, int secret_len, MS_Chap2Response *response,
604         u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1], int authenticator)
605 {
606     /* ARGSUSED */
607     u_char *p = response->PeerChallenge;
608     int i;
609
610     BZERO(response, sizeof(*response));
611
612     /* Generate the Peer-Challenge if requested, or copy it if supplied. */
613     if (!PeerChallenge)
614         for (i = 0; i < sizeof(response->PeerChallenge); i++)
615             *p++ = (u_char) (drand48() * 0xff);
616     else
617         BCOPY(PeerChallenge, response->PeerChallenge,
618               sizeof(response->PeerChallenge));
619
620     /* Generate the NT-Response */
621     ChapMS2_NT(rchallenge, response->PeerChallenge, user,
622                secret, secret_len, response->NTResp);
623
624     /* Generate the Authenticator Response. */
625     GenerateAuthenticatorResponse(secret, secret_len, response->NTResp,
626                                   response->PeerChallenge, rchallenge,
627                                   user, authResponse);
628 #ifdef MPPE
629     SetMasterKeys(secret, secret_len, response->NTResp, authenticator);
630 #endif
631 }
632
633
634 #endif /* CHAPMS */