]> git.ozlabs.org Git - ppp.git/blob - pppd/chap_ms.c
config: Include some extra files in the tarball
[ppp.git] / pppd / chap_ms.c
1 /*
2  * chap_ms.c - Microsoft MS-CHAP compatible implementation.
3  *
4  * Copyright (c) 1995 Eric Rosenquist.  All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  *
18  * 3. The name(s) of the authors of this software must not be used to
19  *    endorse or promote products derived from this software without
20  *    prior written permission.
21  *
22  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
23  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
24  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
25  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
26  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
27  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
28  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
29  */
30
31 /*
32  * Modifications by Lauri Pesonen / lpesonen@clinet.fi, april 1997
33  *
34  *   Implemented LANManager type password response to MS-CHAP challenges.
35  *   Now pppd provides both NT style and LANMan style blocks, and the
36  *   prefered is set by option "ms-lanman". Default is to use NT.
37  *   The hash text (StdText) was taken from Win95 RASAPI32.DLL.
38  *
39  *   You should also use DOMAIN\\USERNAME as described in README.MSCHAP80
40  */
41
42 /*
43  * Modifications by Frank Cusack, frank@google.com, March 2002.
44  *
45  *   Implemented MS-CHAPv2 functionality, heavily based on sample
46  *   implementation in RFC 2759.  Implemented MPPE functionality,
47  *   heavily based on sample implementation in RFC 3079.
48  *
49  * Copyright (c) 2002 Google, Inc.  All rights reserved.
50  *
51  * Redistribution and use in source and binary forms, with or without
52  * modification, are permitted provided that the following conditions
53  * are met:
54  *
55  * 1. Redistributions of source code must retain the above copyright
56  *    notice, this list of conditions and the following disclaimer.
57  *
58  * 2. Redistributions in binary form must reproduce the above copyright
59  *    notice, this list of conditions and the following disclaimer in
60  *    the documentation and/or other materials provided with the
61  *    distribution.
62  *
63  * 3. The name(s) of the authors of this software must not be used to
64  *    endorse or promote products derived from this software without
65  *    prior written permission.
66  *
67  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
68  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
69  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
70  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
71  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
72  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
73  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
74  *
75  */
76
77 #ifdef HAVE_CONFIG_H
78 #include "config.h"
79 #endif
80
81 #include <stdio.h>
82 #include <stdlib.h>
83 #include <string.h>
84 #include <ctype.h>
85 #include <sys/types.h>
86 #include <sys/time.h>
87 #include <unistd.h>
88 #if defined(SOL2)
89 #include <net/ppp-comp.h>
90 #else
91 #include <linux/ppp-comp.h>
92 #endif
93
94 #include "pppd-private.h"
95 #include "options.h"
96 #include "chap.h"
97 #include "chap_ms.h"
98 #include "magic.h"
99 #include "mppe.h"
100 #include "crypto.h"
101 #include "crypto_ms.h"
102
103 #ifdef UNIT_TEST
104 #undef PPP_WITH_MPPE
105 #endif
106
107 static void     ascii2unicode (char[], int, u_char[]);
108 static void     NTPasswordHash (u_char *, int, unsigned char *);
109 static int      ChallengeResponse (u_char *, u_char *, u_char*);
110 static void     ChapMS_NT (u_char *, char *, int, u_char[24]);
111 static void     ChapMS2_NT (u_char *, u_char[16], char *, char *, int,
112                                 u_char[24]);
113 static void     GenerateAuthenticatorResponsePlain
114                         (char*, int, u_char[24], u_char[16], u_char *,
115                          char *, u_char[41]);
116 #ifdef PPP_WITH_MSLANMAN
117 static void     ChapMS_LANMan (u_char *, char *, int, u_char *);
118 #endif
119
120 #ifdef PPP_WITH_MSLANMAN
121 bool    ms_lanman = 0;          /* Use LanMan password instead of NT */
122                                 /* Has meaning only with MS-CHAP challenges */
123 #endif
124
125 #ifdef PPP_WITH_MPPE
126 #ifdef DEBUGMPPEKEY
127 /* For MPPE debug */
128 /* Use "[]|}{?/><,`!2&&(" (sans quotes) for RFC 3079 MS-CHAPv2 test value */
129 static char *mschap_challenge = NULL;
130 /* Use "!@\#$%^&*()_+:3|~" (sans quotes, backslash is to escape #) for ... */
131 static char *mschap2_peer_challenge = NULL;
132 #endif
133
134 #include "fsm.h"                /* Need to poke MPPE options */
135 #include "ccp.h"
136 #endif
137
138 /*
139  * Command-line options.
140  */
141 static struct option chapms_option_list[] = {
142 #ifdef PPP_WITH_MSLANMAN
143         { "ms-lanman", o_bool, &ms_lanman,
144           "Use LanMan passwd when using MS-CHAP", 1 },
145 #endif
146 #ifdef DEBUGMPPEKEY
147         { "mschap-challenge", o_string, &mschap_challenge,
148           "specify CHAP challenge" },
149         { "mschap2-peer-challenge", o_string, &mschap2_peer_challenge,
150           "specify CHAP peer challenge" },
151 #endif
152         { NULL }
153 };
154
155 /*
156  * chapms_generate_challenge - generate a challenge for MS-CHAP.
157  * For MS-CHAP the challenge length is fixed at 8 bytes.
158  * The length goes in challenge[0] and the actual challenge starts
159  * at challenge[1].
160  */
161 static void
162 chapms_generate_challenge(unsigned char *challenge)
163 {
164         *challenge++ = 8;
165 #ifdef DEBUGMPPEKEY
166         if (mschap_challenge && strlen(mschap_challenge) == 8)
167                 memcpy(challenge, mschap_challenge, 8);
168         else
169 #endif
170                 random_bytes(challenge, 8);
171 }
172
173 static void
174 chapms2_generate_challenge(unsigned char *challenge)
175 {
176         *challenge++ = 16;
177 #ifdef DEBUGMPPEKEY
178         if (mschap_challenge && strlen(mschap_challenge) == 16)
179                 memcpy(challenge, mschap_challenge, 16);
180         else
181 #endif
182                 random_bytes(challenge, 16);
183 }
184
185 static int
186 chapms_verify_response(int id, char *name,
187                        unsigned char *secret, int secret_len,
188                        unsigned char *challenge, unsigned char *response,
189                        char *message, int message_space)
190 {
191         unsigned char md[MS_CHAP_RESPONSE_LEN];
192         int diff;
193         int challenge_len, response_len;
194
195         challenge_len = *challenge++;   /* skip length, is 8 */
196         response_len = *response++;
197         if (response_len != MS_CHAP_RESPONSE_LEN)
198                 goto bad;
199
200 #ifndef PPP_WITH_MSLANMAN
201         if (!response[MS_CHAP_USENT]) {
202                 /* Should really propagate this into the error packet. */
203                 notice("Peer request for LANMAN auth not supported");
204                 goto bad;
205         }
206 #endif
207
208         /* Generate the expected response. */
209         ChapMS(challenge, (char *)secret, secret_len, md);
210
211 #ifdef PPP_WITH_MSLANMAN
212         /* Determine which part of response to verify against */
213         if (!response[MS_CHAP_USENT])
214                 diff = memcmp(&response[MS_CHAP_LANMANRESP],
215                               &md[MS_CHAP_LANMANRESP], MS_CHAP_LANMANRESP_LEN);
216         else
217 #endif
218                 diff = memcmp(&response[MS_CHAP_NTRESP], &md[MS_CHAP_NTRESP],
219                               MS_CHAP_NTRESP_LEN);
220
221         if (diff == 0) {
222                 slprintf(message, message_space, "Access granted");
223                 return 1;
224         }
225
226  bad:
227         /* See comments below for MS-CHAP V2 */
228         slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0",
229                  challenge_len, challenge);
230         return 0;
231 }
232
233 static int
234 chapms2_verify_response(int id, char *name,
235                         unsigned char *secret, int secret_len,
236                         unsigned char *challenge, unsigned char *response,
237                         char *message, int message_space)
238 {
239         unsigned char md[MS_CHAP2_RESPONSE_LEN];
240         char saresponse[MS_AUTH_RESPONSE_LENGTH+1];
241         int challenge_len, response_len;
242
243         challenge_len = *challenge++;   /* skip length, is 16 */
244         response_len = *response++;
245         if (response_len != MS_CHAP2_RESPONSE_LEN)
246                 goto bad;       /* not even the right length */
247
248         /* Generate the expected response and our mutual auth. */
249         ChapMS2(challenge, &response[MS_CHAP2_PEER_CHALLENGE], name,
250                 (char *)secret, secret_len, md,
251                 (unsigned char *)saresponse, MS_CHAP2_AUTHENTICATOR);
252
253         /* compare MDs and send the appropriate status */
254         /*
255          * Per RFC 2759, success message must be formatted as
256          *     "S=<auth_string> M=<message>"
257          * where
258          *     <auth_string> is the Authenticator Response (mutual auth)
259          *     <message> is a text message
260          *
261          * However, some versions of Windows (win98 tested) do not know
262          * about the M=<message> part (required per RFC 2759) and flag
263          * it as an error (reported incorrectly as an encryption error
264          * to the user).  Since the RFC requires it, and it can be
265          * useful information, we supply it if the peer is a conforming
266          * system.  Luckily (?), win98 sets the Flags field to 0x04
267          * (contrary to RFC requirements) so we can use that to
268          * distinguish between conforming and non-conforming systems.
269          *
270          * Special thanks to Alex Swiridov <say@real.kharkov.ua> for
271          * help debugging this.
272          */
273         if (memcmp(&md[MS_CHAP2_NTRESP], &response[MS_CHAP2_NTRESP],
274                    MS_CHAP2_NTRESP_LEN) == 0) {
275                 if (response[MS_CHAP2_FLAGS])
276                         slprintf(message, message_space, "S=%s", saresponse);
277                 else
278                         slprintf(message, message_space, "S=%s M=%s",
279                                  saresponse, "Access granted");
280                 return 1;
281         }
282
283  bad:
284         /*
285          * Failure message must be formatted as
286          *     "E=e R=r C=c V=v M=m"
287          * where
288          *     e = error code (we use 691, ERROR_AUTHENTICATION_FAILURE)
289          *     r = retry (we use 1, ok to retry)
290          *     c = challenge to use for next response, we reuse previous
291          *     v = Change Password version supported, we use 0
292          *     m = text message
293          *
294          * The M=m part is only for MS-CHAPv2.  Neither win2k nor
295          * win98 (others untested) display the message to the user anyway.
296          * They also both ignore the E=e code.
297          *
298          * Note that it's safe to reuse the same challenge as we don't
299          * actually accept another response based on the error message
300          * (and no clients try to resend a response anyway).
301          *
302          * Basically, this whole bit is useless code, even the small
303          * implementation here is only because of overspecification.
304          */
305         slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0 M=%s",
306                  challenge_len, challenge, "Access denied");
307         return 0;
308 }
309
310 static void
311 chapms_make_response(unsigned char *response, int id, char *our_name,
312                      unsigned char *challenge, char *secret, int secret_len,
313                      unsigned char *private)
314 {
315         challenge++;    /* skip length, should be 8 */
316         *response++ = MS_CHAP_RESPONSE_LEN;
317         ChapMS(challenge, secret, secret_len, response);
318 }
319
320 struct chapms2_response_cache_entry {
321         int id;
322         unsigned char challenge[16];
323         unsigned char response[MS_CHAP2_RESPONSE_LEN];
324         unsigned char auth_response[MS_AUTH_RESPONSE_LENGTH];
325 };
326
327 #define CHAPMS2_MAX_RESPONSE_CACHE_SIZE 10
328 static struct chapms2_response_cache_entry
329     chapms2_response_cache[CHAPMS2_MAX_RESPONSE_CACHE_SIZE];
330 static int chapms2_response_cache_next_index = 0;
331 static int chapms2_response_cache_size = 0;
332
333 static void
334 chapms2_add_to_response_cache(int id, unsigned char *challenge,
335                               unsigned char *response,
336                               unsigned char *auth_response)
337 {
338         int i = chapms2_response_cache_next_index;
339
340         chapms2_response_cache[i].id = id;
341         memcpy(chapms2_response_cache[i].challenge, challenge, 16);
342         memcpy(chapms2_response_cache[i].response, response,
343                MS_CHAP2_RESPONSE_LEN);
344         memcpy(chapms2_response_cache[i].auth_response,
345                auth_response, MS_AUTH_RESPONSE_LENGTH);
346         chapms2_response_cache_next_index =
347                 (i + 1) % CHAPMS2_MAX_RESPONSE_CACHE_SIZE;
348         if (chapms2_response_cache_next_index > chapms2_response_cache_size)
349                 chapms2_response_cache_size = chapms2_response_cache_next_index;
350         dbglog("added response cache entry %d", i);
351 }
352
353 static struct chapms2_response_cache_entry*
354 chapms2_find_in_response_cache(int id, unsigned char *challenge,
355                       unsigned char *auth_response)
356 {
357         int i;
358
359         for (i = 0; i < chapms2_response_cache_size; i++) {
360                 if (id == chapms2_response_cache[i].id
361                     && (!challenge
362                         || memcmp(challenge,
363                                   chapms2_response_cache[i].challenge,
364                                   16) == 0)
365                     && (!auth_response
366                         || memcmp(auth_response,
367                                   chapms2_response_cache[i].auth_response,
368                                   MS_AUTH_RESPONSE_LENGTH) == 0)) {
369                         dbglog("response found in cache (entry %d)", i);
370                         return &chapms2_response_cache[i];
371                 }
372         }
373         return NULL;  /* not found */
374 }
375
376 static void
377 chapms2_make_response(unsigned char *response, int id, char *our_name,
378                       unsigned char *challenge, char *secret, int secret_len,
379                       unsigned char *private)
380 {
381         const struct chapms2_response_cache_entry *cache_entry;
382         unsigned char auth_response[MS_AUTH_RESPONSE_LENGTH+1];
383
384         challenge++;    /* skip length, should be 16 */
385         *response++ = MS_CHAP2_RESPONSE_LEN;
386         cache_entry = chapms2_find_in_response_cache(id, challenge, NULL);
387         if (cache_entry) {
388                 memcpy(response, cache_entry->response, MS_CHAP2_RESPONSE_LEN);
389                 return;
390         }
391         ChapMS2(challenge,
392 #ifdef DEBUGMPPEKEY
393                 mschap2_peer_challenge,
394 #else
395                 NULL,
396 #endif
397                 our_name, secret, secret_len, response, auth_response,
398                 MS_CHAP2_AUTHENTICATEE);
399         chapms2_add_to_response_cache(id, challenge, response, auth_response);
400 }
401
402 static int
403 chapms2_check_success(int id, unsigned char *msg, int len)
404 {
405         if ((len < MS_AUTH_RESPONSE_LENGTH + 2) ||
406             strncmp((char *)msg, "S=", 2) != 0) {
407                 /* Packet does not start with "S=" */
408                 error("MS-CHAPv2 Success packet is badly formed.");
409                 return 0;
410         }
411         msg += 2;
412         len -= 2;
413         if (len < MS_AUTH_RESPONSE_LENGTH
414             || !chapms2_find_in_response_cache(id, NULL /* challenge */, msg)) {
415                 /* Authenticator Response did not match expected. */
416                 error("MS-CHAPv2 mutual authentication failed.");
417                 return 0;
418         }
419         /* Authenticator Response matches. */
420         msg += MS_AUTH_RESPONSE_LENGTH; /* Eat it */
421         len -= MS_AUTH_RESPONSE_LENGTH;
422         if ((len >= 3) && !strncmp((char *)msg, " M=", 3)) {
423                 msg += 3; /* Eat the delimiter */
424         } else  if ((len >= 2) && !strncmp((char *)msg, "M=", 2)) {
425                 msg += 2; /* Eat the delimiter */
426         } else if (len) {
427                 /* Packet has extra text which does not begin " M=" */
428                 error("MS-CHAPv2 Success packet is badly formed.");
429                 return 0;
430         }
431         return 1;
432 }
433
434 static void
435 chapms_handle_failure(unsigned char *inp, int len)
436 {
437         int err;
438         char *p, *msg;
439
440         /* We want a null-terminated string for strxxx(). */
441         msg = malloc(len + 1);
442         if (!msg) {
443                 notice("Out of memory in chapms_handle_failure");
444                 return;
445         }
446         BCOPY(inp, msg, len);
447         msg[len] = 0;
448         p = msg;
449
450         /*
451          * Deal with MS-CHAP formatted failure messages; just print the
452          * M=<message> part (if any).  For MS-CHAP we're not really supposed
453          * to use M=<message>, but it shouldn't hurt.  See
454          * chapms[2]_verify_response.
455          */
456         if (!strncmp(p, "E=", 2))
457                 err = strtol(p+2, NULL, 10); /* Remember the error code. */
458         else
459                 goto print_msg; /* Message is badly formatted. */
460
461         if (len && ((p = strstr(p, " M=")) != NULL)) {
462                 /* M=<message> field found. */
463                 p += 3;
464         } else {
465                 /* No M=<message>; use the error code. */
466                 switch (err) {
467                 case MS_CHAP_ERROR_RESTRICTED_LOGON_HOURS:
468                         p = "E=646 Restricted logon hours";
469                         break;
470
471                 case MS_CHAP_ERROR_ACCT_DISABLED:
472                         p = "E=647 Account disabled";
473                         break;
474
475                 case MS_CHAP_ERROR_PASSWD_EXPIRED:
476                         p = "E=648 Password expired";
477                         break;
478
479                 case MS_CHAP_ERROR_NO_DIALIN_PERMISSION:
480                         p = "E=649 No dialin permission";
481                         break;
482
483                 case MS_CHAP_ERROR_AUTHENTICATION_FAILURE:
484                         p = "E=691 Authentication failure";
485                         break;
486
487                 case MS_CHAP_ERROR_CHANGING_PASSWORD:
488                         /* Should never see this, we don't support Change Password. */
489                         p = "E=709 Error changing password";
490                         break;
491
492                 default:
493                         free(msg);
494                         error("Unknown MS-CHAP authentication failure: %.*v",
495                               len, inp);
496                         return;
497                 }
498         }
499 print_msg:
500         if (p != NULL)
501                 error("MS-CHAP authentication failed: %v", p);
502         free(msg);
503 }
504
505 static int
506 ChallengeResponse(u_char *challenge,
507                   u_char *PasswordHash,
508                   u_char *response)
509 {
510     u_char ZPasswordHash[24];
511     PPP_CIPHER_CTX *ctx;
512
513     BZERO(ZPasswordHash, sizeof(ZPasswordHash));
514     BCOPY(PasswordHash, ZPasswordHash, MD4_DIGEST_LENGTH);
515
516 #if 0
517     dbglog("ChallengeResponse - ZPasswordHash %.*B",
518            sizeof(ZPasswordHash), ZPasswordHash);
519 #endif
520
521     if (DesEncrypt(challenge, ZPasswordHash + 0,  response + 0) &&
522         DesEncrypt(challenge, ZPasswordHash + 7,  response + 8) &&
523         DesEncrypt(challenge, ZPasswordHash + 14, response + 16))
524         return 1;
525
526 #if 0
527     dbglog("ChallengeResponse - response %.24B", response);
528 #endif
529     return 0;
530 }
531
532 void
533 ChallengeHash(u_char PeerChallenge[16], u_char *rchallenge,
534               char *username, u_char Challenge[8])
535     
536 {
537     PPP_MD_CTX* ctx;
538     u_char      hash[SHA_DIGEST_LENGTH];
539     int     hash_len;
540     const char *user;
541
542     /* remove domain from "domain\username" */
543     if ((user = strrchr(username, '\\')) != NULL)
544         ++user;
545     else
546         user = username;
547     
548     ctx = PPP_MD_CTX_new();
549     if (ctx != NULL) {
550
551         if (PPP_DigestInit(ctx, PPP_sha1())) {
552
553             if (PPP_DigestUpdate(ctx, PeerChallenge, 16)) {
554
555                 if (PPP_DigestUpdate(ctx, rchallenge, 16)) {
556
557                     if (PPP_DigestUpdate(ctx, user, strlen(user))) {
558                         
559                         hash_len = SHA_DIGEST_LENGTH;
560                         if (PPP_DigestFinal(ctx, hash, &hash_len)) {
561
562                             BCOPY(hash, Challenge, 8);
563                         }
564                     }
565                 }
566             }
567         }
568
569         PPP_MD_CTX_free(ctx);
570     }
571 }
572
573 /*
574  * Convert the ASCII version of the password to Unicode.
575  * This implicitly supports 8-bit ISO8859/1 characters.
576  * This gives us the little-endian representation, which
577  * is assumed by all M$ CHAP RFCs.  (Unicode byte ordering
578  * is machine-dependent.)
579  */
580 static void
581 ascii2unicode(char ascii[], int ascii_len, u_char unicode[])
582 {
583     int i;
584
585     BZERO(unicode, ascii_len * 2);
586     for (i = 0; i < ascii_len; i++)
587         unicode[i * 2] = (u_char) ascii[i];
588 }
589
590 static void
591 NTPasswordHash(u_char *secret, int secret_len, unsigned char* hash)
592 {
593     PPP_MD_CTX* ctx = PPP_MD_CTX_new();
594     if (ctx != NULL) {
595
596         if (PPP_DigestInit(ctx, PPP_md4())) {
597
598             if (PPP_DigestUpdate(ctx, secret, secret_len)) {
599
600                 int hash_len = MD4_DIGEST_LENGTH;
601                 PPP_DigestFinal(ctx, hash, &hash_len);
602             }
603         }
604         
605         PPP_MD_CTX_free(ctx);
606     }
607 }
608
609 static void
610 ChapMS_NT(u_char *rchallenge, char *secret, int secret_len,
611           u_char NTResponse[24])
612 {
613     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
614     u_char      PasswordHash[MD4_DIGEST_LENGTH];
615
616     /* Hash the Unicode version of the secret (== password). */
617     ascii2unicode(secret, secret_len, unicodePassword);
618     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
619
620     ChallengeResponse(rchallenge, PasswordHash, NTResponse);
621 }
622
623 static void
624 ChapMS2_NT(u_char *rchallenge, u_char PeerChallenge[16], char *username,
625            char *secret, int secret_len, u_char NTResponse[24])
626 {
627     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
628     u_char      PasswordHash[MD4_DIGEST_LENGTH];
629     u_char      Challenge[8];
630
631     ChallengeHash(PeerChallenge, rchallenge, username, Challenge);
632
633     /* Hash the Unicode version of the secret (== password). */
634     ascii2unicode(secret, secret_len, unicodePassword);
635     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
636
637     ChallengeResponse(Challenge, PasswordHash, NTResponse);
638 }
639
640 #ifdef PPP_WITH_MSLANMAN
641 static u_char *StdText = (u_char *)"KGS!@#$%"; /* key from rasapi32.dll */
642
643 static void
644 ChapMS_LANMan(u_char *rchallenge, char *secret, int secret_len,
645               unsigned char *response)
646 {
647     int                 i;
648     u_char              UcasePassword[MAX_NT_PASSWORD]; /* max is actually 14 */
649     u_char              PasswordHash[MD4_DIGEST_LENGTH];
650
651     /* LANMan password is case insensitive */
652     BZERO(UcasePassword, sizeof(UcasePassword));
653     for (i = 0; i < secret_len; i++)
654        UcasePassword[i] = (u_char)toupper(secret[i]);
655
656     if (DesEncrypt(StdText, UcasePassword + 0, PasswordHash + 0) &&
657         DesEncrypt(StdText, UcasePassword + 7, PasswordHash + 8)) {
658
659         ChallengeResponse(rchallenge, PasswordHash, &response[MS_CHAP_LANMANRESP]);
660     }
661 }
662 #endif
663
664
665 void
666 GenerateAuthenticatorResponse(unsigned char* PasswordHashHash,
667                               unsigned char *NTResponse, unsigned char *PeerChallenge,
668                               unsigned char *rchallenge, char *username,
669                               unsigned char *authResponse)
670 {
671     /*
672      * "Magic" constants used in response generation, from RFC 2759.
673      */
674     u_char Magic1[39] = /* "Magic server to client signing constant" */
675         { 0x4D, 0x61, 0x67, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76,
676           0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6C, 0x69, 0x65,
677           0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67,
678           0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74 };
679     u_char Magic2[41] = /* "Pad to make it do more than one iteration" */
680         { 0x50, 0x61, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B,
681           0x65, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6D, 0x6F,
682           0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E,
683           0x65, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F,
684           0x6E };
685
686     int         i;
687     PPP_MD_CTX *ctx;
688     u_char      Digest[SHA_DIGEST_LENGTH] = {};
689     int     hash_len;
690     u_char      Challenge[8];
691
692     ctx = PPP_MD_CTX_new();
693     if (ctx != NULL) {
694
695         if (PPP_DigestInit(ctx, PPP_sha1())) {
696
697             if (PPP_DigestUpdate(ctx, PasswordHashHash, MD4_DIGEST_LENGTH)) {
698
699                 if (PPP_DigestUpdate(ctx, NTResponse, 24)) {
700
701                     if (PPP_DigestUpdate(ctx, Magic1, sizeof(Magic1))) {
702                         
703                         hash_len = sizeof(Digest);
704                         PPP_DigestFinal(ctx, Digest, &hash_len);
705                     }
706                 }
707             }
708         }
709         PPP_MD_CTX_free(ctx);
710     }
711     
712     ChallengeHash(PeerChallenge, rchallenge, username, Challenge);
713
714     ctx = PPP_MD_CTX_new();
715     if (ctx != NULL) {
716
717         if (PPP_DigestInit(ctx, PPP_sha1())) {
718
719             if (PPP_DigestUpdate(ctx, Digest, sizeof(Digest))) {
720
721                 if (PPP_DigestUpdate(ctx, Challenge, sizeof(Challenge))) {
722
723                     if (PPP_DigestUpdate(ctx, Magic2, sizeof(Magic2))) {
724                         
725                         hash_len = sizeof(Digest);
726                         PPP_DigestFinal(ctx, Digest, &hash_len);
727                     }
728                 }
729             }
730         }
731
732         PPP_MD_CTX_free(ctx);
733     }
734
735     /* Convert to ASCII hex string. */
736     for (i = 0; i < MAX((MS_AUTH_RESPONSE_LENGTH / 2), sizeof(Digest)); i++) {
737         sprintf((char *)&authResponse[i * 2], "%02X", Digest[i]);
738     }
739 }
740
741
742 static void
743 GenerateAuthenticatorResponsePlain
744                 (char *secret, int secret_len,
745                  u_char NTResponse[24], u_char PeerChallenge[16],
746                  u_char *rchallenge, char *username,
747                  u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1])
748 {
749     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
750     u_char      PasswordHash[MD4_DIGEST_LENGTH];
751     u_char      PasswordHashHash[MD4_DIGEST_LENGTH];
752
753     /* Hash (x2) the Unicode version of the secret (== password). */
754     ascii2unicode(secret, secret_len, unicodePassword);
755     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
756     NTPasswordHash(PasswordHash, sizeof(PasswordHash),
757                    PasswordHashHash);
758
759     GenerateAuthenticatorResponse(PasswordHashHash, NTResponse, PeerChallenge,
760                                   rchallenge, username, authResponse);
761 }
762
763
764 #ifdef PPP_WITH_MPPE
765
766 /*
767  * Set mppe_xxxx_key from MS-CHAP credentials. (see RFC 3079)
768  */
769 static void
770 Set_Start_Key(u_char *rchallenge, char *secret, int secret_len)
771 {
772     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
773     u_char      PasswordHash[MD4_DIGEST_LENGTH];
774     u_char      PasswordHashHash[MD4_DIGEST_LENGTH];
775
776     /* Hash (x2) the Unicode version of the secret (== password). */
777     ascii2unicode(secret, secret_len, unicodePassword);
778     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
779     NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);
780
781     mppe_set_chapv1(rchallenge, PasswordHashHash);
782 }
783
784 /*
785  * Set mppe_xxxx_key from MS-CHAPv2 credentials. (see RFC 3079)
786  */
787 static void
788 SetMasterKeys(char *secret, int secret_len, u_char NTResponse[24], int IsServer)
789 {
790     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
791     u_char      PasswordHash[MD4_DIGEST_LENGTH];
792     u_char      PasswordHashHash[MD4_DIGEST_LENGTH];
793     /* Hash (x2) the Unicode version of the secret (== password). */
794     ascii2unicode(secret, secret_len, unicodePassword);
795     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
796     NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);
797     mppe_set_chapv2(PasswordHashHash, NTResponse, IsServer);
798 }
799
800 #endif /* PPP_WITH_MPPE */
801
802
803 void
804 ChapMS(u_char *rchallenge, char *secret, int secret_len,
805        unsigned char *response)
806 {
807     BZERO(response, MS_CHAP_RESPONSE_LEN);
808
809     ChapMS_NT(rchallenge, secret, secret_len, &response[MS_CHAP_NTRESP]);
810
811 #ifdef PPP_WITH_MSLANMAN
812     ChapMS_LANMan(rchallenge, secret, secret_len,
813                   &response[MS_CHAP_LANMANRESP]);
814
815     /* preferred method is set by option  */
816     response[MS_CHAP_USENT] = !ms_lanman;
817 #else
818     response[MS_CHAP_USENT] = 1;
819 #endif
820
821 #ifdef PPP_WITH_MPPE
822     Set_Start_Key(rchallenge, secret, secret_len);
823 #endif
824 }
825
826
827 /*
828  * If PeerChallenge is NULL, one is generated and the PeerChallenge
829  * field of response is filled in.  Call this way when generating a response.
830  * If PeerChallenge is supplied, it is copied into the PeerChallenge field.
831  * Call this way when verifying a response (or debugging).
832  * Do not call with PeerChallenge = response.
833  *
834  * The PeerChallenge field of response is then used for calculation of the
835  * Authenticator Response.
836  */
837 void
838 ChapMS2(unsigned char *rchallenge, unsigned char *PeerChallenge,
839         char *user, char *secret, int secret_len, unsigned char *response,
840         u_char authResponse[], int authenticator)
841 {
842     /* ARGSUSED */
843     u_char *p = &response[MS_CHAP2_PEER_CHALLENGE];
844     int i;
845
846     BZERO(response, MS_CHAP2_RESPONSE_LEN);
847
848     /* Generate the Peer-Challenge if requested, or copy it if supplied. */
849     if (!PeerChallenge)
850         for (i = 0; i < MS_CHAP2_PEER_CHAL_LEN; i++)
851             *p++ = (u_char) (drand48() * 0xff);
852     else
853         BCOPY(PeerChallenge, &response[MS_CHAP2_PEER_CHALLENGE],
854               MS_CHAP2_PEER_CHAL_LEN);
855
856     /* Generate the NT-Response */
857     ChapMS2_NT(rchallenge, &response[MS_CHAP2_PEER_CHALLENGE], user,
858                secret, secret_len, &response[MS_CHAP2_NTRESP]);
859
860     /* Generate the Authenticator Response. */
861     GenerateAuthenticatorResponsePlain(secret, secret_len,
862                                        &response[MS_CHAP2_NTRESP],
863                                        &response[MS_CHAP2_PEER_CHALLENGE],
864                                        rchallenge, user, authResponse);
865
866 #ifdef PPP_WITH_MPPE
867     SetMasterKeys(secret, secret_len,
868                   &response[MS_CHAP2_NTRESP], authenticator);
869 #endif
870 }
871
872
873 static struct chap_digest_type chapms_digest = {
874         CHAP_MICROSOFT,         /* code */
875         chapms_generate_challenge,
876         chapms_verify_response,
877         chapms_make_response,
878         NULL,                   /* check_success */
879         chapms_handle_failure,
880 };
881
882 static struct chap_digest_type chapms2_digest = {
883         CHAP_MICROSOFT_V2,      /* code */
884         chapms2_generate_challenge,
885         chapms2_verify_response,
886         chapms2_make_response,
887         chapms2_check_success,
888         chapms_handle_failure,
889 };
890
891 #ifndef UNIT_TEST
892 void
893 chapms_init(void)
894 {
895         chap_register_digest(&chapms_digest);
896         chap_register_digest(&chapms2_digest);
897         ppp_add_options(chapms_option_list);
898 }
899 #else
900
901 #include <time.h>
902
903 int debug = 1;
904 int error_count = 0;
905 int unsuccess = 0;
906
907 void random_bytes(unsigned char *bytes, int len)
908 {
909     int i = 0;
910     srand(time(NULL));
911     while (i < len) {
912         bytes[i++] = (unsigned char) rand();
913     }
914 }
915
916
917 int test_chap_v1(void) {
918     char *secret = "MyPw";
919
920     unsigned char challenge[8] = {
921         0x10, 0x2D, 0xB5, 0xDF, 0x08, 0x5D, 0x30, 0x41
922     };
923     unsigned char response[MS_CHAP_RESPONSE_LEN] = {
924     };
925     unsigned char result[MS_CHAP_RESPONSE_LEN] = {
926         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
927         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
928         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
929
930         0x4E, 0x9D, 0x3C, 0x8F, 0x9C, 0xFD, 0x38, 0x5D,
931         0x5B, 0xF4, 0xD3, 0x24, 0x67, 0x91, 0x95, 0x6C,
932         0xA4, 0xC3, 0x51, 0xAB, 0x40, 0x9A, 0x3D, 0x61,
933
934         0x01
935     };
936
937     ChapMS(challenge, secret, strlen(secret), response);
938     return memcmp(response, result, MS_CHAP_RESPONSE_LEN);
939 }
940
941 int test_chap_v2(void) {
942     char *secret = "clientPass";
943     char *name = "User";
944
945     char saresponse[MS_AUTH_RESPONSE_LENGTH+1];
946     char *saresult = "407A5589115FD0D6209F510FE9C04566932CDA56";
947
948     unsigned char authenticator[16] = {
949         0x5B, 0x5D, 0x7C, 0x7D, 0x7B, 0x3F, 0x2F, 0x3E,
950         0x3C, 0x2C, 0x60, 0x21, 0x32, 0x26, 0x26, 0x28
951     };
952     unsigned char peerchallenge[16] = {
953         0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A,
954         0x28, 0x29, 0x5F, 0x2B, 0x3A, 0x33, 0x7C, 0x7E
955     };
956     unsigned char result[MS_CHAP_NTRESP_LEN] = {
957         0x82, 0x30, 0x9E, 0xCD, 0x8D, 0x70, 0x8B, 0x5E,
958         0xA0, 0x8F, 0xAA, 0x39, 0x81, 0xCD, 0x83, 0x54,
959         0x42, 0x33, 0x11, 0x4A, 0x3D, 0x85, 0xD6, 0xDF
960     };
961
962     unsigned char response[MS_CHAP2_RESPONSE_LEN] = {
963     };
964
965         ChapMS2(authenticator, peerchallenge, name,
966                 secret, strlen(secret), response,
967                 (unsigned char *)saresponse, MS_CHAP2_AUTHENTICATOR);
968
969     return memcmp(&response[MS_CHAP2_NTRESP], result, MS_CHAP2_NTRESP_LEN) ||
970         strncmp(saresponse, saresult, MS_AUTH_RESPONSE_LENGTH);
971 }
972
973 int main(int argc, char *argv[]) {
974     
975     PPP_crypto_init();
976
977     if (test_chap_v1()) {
978         printf("CHAPv1 failed\n");
979         return -1;
980     }
981
982     if (test_chap_v2()) {
983         printf("CHAPv2 failed\n");
984         return -1;
985     }
986
987     PPP_crypto_deinit();
988
989     printf("Success\n");
990     return 0;
991 }
992
993 #endif  /* UNIT_TEST */
994