c2bd00f9c6f7ec0e3e3a5dd6b00c4153b6c41d25
[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 #define RCSID   "$Id: chap_ms.c,v 1.38 2007/12/01 20:10:51 carlsonj Exp $"
78
79 #ifdef CHAPMS
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
89 #include "pppd.h"
90 #include "chap-new.h"
91 #include "chap_ms.h"
92 #include "md4.h"
93 #include "sha1.h"
94 #include "pppcrypt.h"
95 #include "magic.h"
96
97 static const char rcsid[] = RCSID;
98
99
100 static void     ascii2unicode __P((char[], int, u_char[]));
101 static void     NTPasswordHash __P((u_char *, int, u_char[MD4_SIGNATURE_SIZE]));
102 static void     ChallengeResponse __P((u_char *, u_char *, u_char[24]));
103 static void     ChapMS_NT __P((u_char *, char *, int, u_char[24]));
104 static void     ChapMS2_NT __P((u_char *, u_char[16], char *, char *, int,
105                                 u_char[24]));
106 static void     GenerateAuthenticatorResponsePlain
107                         __P((char*, int, u_char[24], u_char[16], u_char *,
108                              char *, u_char[41]));
109 #ifdef MSLANMAN
110 static void     ChapMS_LANMan __P((u_char *, char *, int, u_char *));
111 #endif
112
113 #ifdef MPPE
114 static void     Set_Start_Key __P((u_char *, char *, int));
115 static void     SetMasterKeys __P((char *, int, u_char[24], int));
116 #endif
117
118 #ifdef MSLANMAN
119 bool    ms_lanman = 0;          /* Use LanMan password instead of NT */
120                                 /* Has meaning only with MS-CHAP challenges */
121 #endif
122
123 #ifdef MPPE
124 u_char mppe_send_key[MPPE_MAX_KEY_LEN];
125 u_char mppe_recv_key[MPPE_MAX_KEY_LEN];
126 int mppe_keys_set = 0;          /* Have the MPPE keys been set? */
127
128 #ifdef DEBUGMPPEKEY
129 /* For MPPE debug */
130 /* Use "[]|}{?/><,`!2&&(" (sans quotes) for RFC 3079 MS-CHAPv2 test value */
131 static char *mschap_challenge = NULL;
132 /* Use "!@\#$%^&*()_+:3|~" (sans quotes, backslash is to escape #) for ... */
133 static char *mschap2_peer_challenge = NULL;
134 #endif
135
136 #include "fsm.h"                /* Need to poke MPPE options */
137 #include "ccp.h"
138 #include <net/ppp-comp.h>
139 #endif
140
141 /*
142  * Command-line options.
143  */
144 static option_t chapms_option_list[] = {
145 #ifdef MSLANMAN
146         { "ms-lanman", o_bool, &ms_lanman,
147           "Use LanMan passwd when using MS-CHAP", 1 },
148 #endif
149 #ifdef DEBUGMPPEKEY
150         { "mschap-challenge", o_string, &mschap_challenge,
151           "specify CHAP challenge" },
152         { "mschap2-peer-challenge", o_string, &mschap2_peer_challenge,
153           "specify CHAP peer challenge" },
154 #endif
155         { NULL }
156 };
157
158 /*
159  * chapms_generate_challenge - generate a challenge for MS-CHAP.
160  * For MS-CHAP the challenge length is fixed at 8 bytes.
161  * The length goes in challenge[0] and the actual challenge starts
162  * at challenge[1].
163  */
164 static void
165 chapms_generate_challenge(unsigned char *challenge)
166 {
167         *challenge++ = 8;
168 #ifdef DEBUGMPPEKEY
169         if (mschap_challenge && strlen(mschap_challenge) == 8)
170                 memcpy(challenge, mschap_challenge, 8);
171         else
172 #endif
173                 random_bytes(challenge, 8);
174 }
175
176 static void
177 chapms2_generate_challenge(unsigned char *challenge)
178 {
179         *challenge++ = 16;
180 #ifdef DEBUGMPPEKEY
181         if (mschap_challenge && strlen(mschap_challenge) == 16)
182                 memcpy(challenge, mschap_challenge, 16);
183         else
184 #endif
185                 random_bytes(challenge, 16);
186 }
187
188 static int
189 chapms_verify_response(int id, char *name,
190                        unsigned char *secret, int secret_len,
191                        unsigned char *challenge, unsigned char *response,
192                        char *message, int message_space)
193 {
194         unsigned char md[MS_CHAP_RESPONSE_LEN];
195         int diff;
196         int challenge_len, response_len;
197
198         challenge_len = *challenge++;   /* skip length, is 8 */
199         response_len = *response++;
200         if (response_len != MS_CHAP_RESPONSE_LEN)
201                 goto bad;
202
203 #ifndef MSLANMAN
204         if (!response[MS_CHAP_USENT]) {
205                 /* Should really propagate this into the error packet. */
206                 notice("Peer request for LANMAN auth not supported");
207                 goto bad;
208         }
209 #endif
210
211         /* Generate the expected response. */
212         ChapMS(challenge, (char *)secret, secret_len, md);
213
214 #ifdef MSLANMAN
215         /* Determine which part of response to verify against */
216         if (!response[MS_CHAP_USENT])
217                 diff = memcmp(&response[MS_CHAP_LANMANRESP],
218                               &md[MS_CHAP_LANMANRESP], MS_CHAP_LANMANRESP_LEN);
219         else
220 #endif
221                 diff = memcmp(&response[MS_CHAP_NTRESP], &md[MS_CHAP_NTRESP],
222                               MS_CHAP_NTRESP_LEN);
223
224         if (diff == 0) {
225                 slprintf(message, message_space, "Access granted");
226                 return 1;
227         }
228
229  bad:
230         /* See comments below for MS-CHAP V2 */
231         slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0",
232                  challenge_len, challenge);
233         return 0;
234 }
235
236 static int
237 chapms2_verify_response(int id, char *name,
238                         unsigned char *secret, int secret_len,
239                         unsigned char *challenge, unsigned char *response,
240                         char *message, int message_space)
241 {
242         unsigned char md[MS_CHAP2_RESPONSE_LEN];
243         char saresponse[MS_AUTH_RESPONSE_LENGTH+1];
244         int challenge_len, response_len;
245
246         challenge_len = *challenge++;   /* skip length, is 16 */
247         response_len = *response++;
248         if (response_len != MS_CHAP2_RESPONSE_LEN)
249                 goto bad;       /* not even the right length */
250
251         /* Generate the expected response and our mutual auth. */
252         ChapMS2(challenge, &response[MS_CHAP2_PEER_CHALLENGE], name,
253                 (char *)secret, secret_len, md,
254                 (unsigned char *)saresponse, MS_CHAP2_AUTHENTICATOR);
255
256         /* compare MDs and send the appropriate status */
257         /*
258          * Per RFC 2759, success message must be formatted as
259          *     "S=<auth_string> M=<message>"
260          * where
261          *     <auth_string> is the Authenticator Response (mutual auth)
262          *     <message> is a text message
263          *
264          * However, some versions of Windows (win98 tested) do not know
265          * about the M=<message> part (required per RFC 2759) and flag
266          * it as an error (reported incorrectly as an encryption error
267          * to the user).  Since the RFC requires it, and it can be
268          * useful information, we supply it if the peer is a conforming
269          * system.  Luckily (?), win98 sets the Flags field to 0x04
270          * (contrary to RFC requirements) so we can use that to
271          * distinguish between conforming and non-conforming systems.
272          *
273          * Special thanks to Alex Swiridov <say@real.kharkov.ua> for
274          * help debugging this.
275          */
276         if (memcmp(&md[MS_CHAP2_NTRESP], &response[MS_CHAP2_NTRESP],
277                    MS_CHAP2_NTRESP_LEN) == 0) {
278                 if (response[MS_CHAP2_FLAGS])
279                         slprintf(message, message_space, "S=%s", saresponse);
280                 else
281                         slprintf(message, message_space, "S=%s M=%s",
282                                  saresponse, "Access granted");
283                 return 1;
284         }
285
286  bad:
287         /*
288          * Failure message must be formatted as
289          *     "E=e R=r C=c V=v M=m"
290          * where
291          *     e = error code (we use 691, ERROR_AUTHENTICATION_FAILURE)
292          *     r = retry (we use 1, ok to retry)
293          *     c = challenge to use for next response, we reuse previous
294          *     v = Change Password version supported, we use 0
295          *     m = text message
296          *
297          * The M=m part is only for MS-CHAPv2.  Neither win2k nor
298          * win98 (others untested) display the message to the user anyway.
299          * They also both ignore the E=e code.
300          *
301          * Note that it's safe to reuse the same challenge as we don't
302          * actually accept another response based on the error message
303          * (and no clients try to resend a response anyway).
304          *
305          * Basically, this whole bit is useless code, even the small
306          * implementation here is only because of overspecification.
307          */
308         slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0 M=%s",
309                  challenge_len, challenge, "Access denied");
310         return 0;
311 }
312
313 static void
314 chapms_make_response(unsigned char *response, int id, char *our_name,
315                      unsigned char *challenge, char *secret, int secret_len,
316                      unsigned char *private)
317 {
318         challenge++;    /* skip length, should be 8 */
319         *response++ = MS_CHAP_RESPONSE_LEN;
320         ChapMS(challenge, secret, secret_len, response);
321 }
322
323 struct chapms2_response_cache_entry {
324         int id;
325         unsigned char challenge[16];
326         unsigned char response[MS_CHAP2_RESPONSE_LEN];
327         unsigned char auth_response[MS_AUTH_RESPONSE_LENGTH];
328 };
329
330 #define CHAPMS2_MAX_RESPONSE_CACHE_SIZE 10
331 static struct chapms2_response_cache_entry
332     chapms2_response_cache[CHAPMS2_MAX_RESPONSE_CACHE_SIZE];
333 static int chapms2_response_cache_next_index = 0;
334 static int chapms2_response_cache_size = 0;
335
336 static void
337 chapms2_add_to_response_cache(int id, unsigned char *challenge,
338                               unsigned char *response,
339                               unsigned char *auth_response)
340 {
341         int i = chapms2_response_cache_next_index;
342
343         chapms2_response_cache[i].id = id;
344         memcpy(chapms2_response_cache[i].challenge, challenge, 16);
345         memcpy(chapms2_response_cache[i].response, response,
346                MS_CHAP2_RESPONSE_LEN);
347         memcpy(chapms2_response_cache[i].auth_response,
348                auth_response, MS_AUTH_RESPONSE_LENGTH);
349         chapms2_response_cache_next_index =
350                 (i + 1) % CHAPMS2_MAX_RESPONSE_CACHE_SIZE;
351         if (chapms2_response_cache_next_index > chapms2_response_cache_size)
352                 chapms2_response_cache_size = chapms2_response_cache_next_index;
353         dbglog("added response cache entry %d", i);
354 }
355
356 static struct chapms2_response_cache_entry*
357 chapms2_find_in_response_cache(int id, unsigned char *challenge,
358                       unsigned char *auth_response)
359 {
360         int i;
361
362         for (i = 0; i < chapms2_response_cache_size; i++) {
363                 if (id == chapms2_response_cache[i].id
364                     && (!challenge
365                         || memcmp(challenge,
366                                   chapms2_response_cache[i].challenge,
367                                   16) == 0)
368                     && (!auth_response
369                         || memcmp(auth_response,
370                                   chapms2_response_cache[i].auth_response,
371                                   MS_AUTH_RESPONSE_LENGTH) == 0)) {
372                         dbglog("response found in cache (entry %d)", i);
373                         return &chapms2_response_cache[i];
374                 }
375         }
376         return NULL;  /* not found */
377 }
378
379 static void
380 chapms2_make_response(unsigned char *response, int id, char *our_name,
381                       unsigned char *challenge, char *secret, int secret_len,
382                       unsigned char *private)
383 {
384         const struct chapms2_response_cache_entry *cache_entry;
385         unsigned char auth_response[MS_AUTH_RESPONSE_LENGTH+1];
386
387         challenge++;    /* skip length, should be 16 */
388         *response++ = MS_CHAP2_RESPONSE_LEN;
389         cache_entry = chapms2_find_in_response_cache(id, challenge, NULL);
390         if (cache_entry) {
391                 memcpy(response, cache_entry->response, MS_CHAP2_RESPONSE_LEN);
392                 return;
393         }
394         ChapMS2(challenge,
395 #ifdef DEBUGMPPEKEY
396                 mschap2_peer_challenge,
397 #else
398                 NULL,
399 #endif
400                 our_name, secret, secret_len, response, auth_response,
401                 MS_CHAP2_AUTHENTICATEE);
402         chapms2_add_to_response_cache(id, challenge, response, auth_response);
403 }
404
405 static int
406 chapms2_check_success(int id, unsigned char *msg, int len)
407 {
408         if ((len < MS_AUTH_RESPONSE_LENGTH + 2) ||
409             strncmp((char *)msg, "S=", 2) != 0) {
410                 /* Packet does not start with "S=" */
411                 error("MS-CHAPv2 Success packet is badly formed.");
412                 return 0;
413         }
414         msg += 2;
415         len -= 2;
416         if (len < MS_AUTH_RESPONSE_LENGTH
417             || !chapms2_find_in_response_cache(id, NULL /* challenge */, msg)) {
418                 /* Authenticator Response did not match expected. */
419                 error("MS-CHAPv2 mutual authentication failed.");
420                 return 0;
421         }
422         /* Authenticator Response matches. */
423         msg += MS_AUTH_RESPONSE_LENGTH; /* Eat it */
424         len -= MS_AUTH_RESPONSE_LENGTH;
425         if ((len >= 3) && !strncmp((char *)msg, " M=", 3)) {
426                 msg += 3; /* Eat the delimiter */
427         } else if (len) {
428                 /* Packet has extra text which does not begin " M=" */
429                 error("MS-CHAPv2 Success packet is badly formed.");
430                 return 0;
431         }
432         return 1;
433 }
434
435 static void
436 chapms_handle_failure(unsigned char *inp, int len)
437 {
438         int err;
439         char *p, *msg;
440
441         /* We want a null-terminated string for strxxx(). */
442         msg = malloc(len + 1);
443         if (!msg) {
444                 notice("Out of memory in chapms_handle_failure");
445                 return;
446         }
447         BCOPY(inp, msg, len);
448         msg[len] = 0;
449         p = msg;
450
451         /*
452          * Deal with MS-CHAP formatted failure messages; just print the
453          * M=<message> part (if any).  For MS-CHAP we're not really supposed
454          * to use M=<message>, but it shouldn't hurt.  See
455          * chapms[2]_verify_response.
456          */
457         if (!strncmp(p, "E=", 2))
458                 err = strtol(p+2, NULL, 10); /* Remember the error code. */
459         else
460                 goto print_msg; /* Message is badly formatted. */
461
462         if (len && ((p = strstr(p, " M=")) != NULL)) {
463                 /* M=<message> field found. */
464                 p += 3;
465         } else {
466                 /* No M=<message>; use the error code. */
467                 switch (err) {
468                 case MS_CHAP_ERROR_RESTRICTED_LOGON_HOURS:
469                         p = "E=646 Restricted logon hours";
470                         break;
471
472                 case MS_CHAP_ERROR_ACCT_DISABLED:
473                         p = "E=647 Account disabled";
474                         break;
475
476                 case MS_CHAP_ERROR_PASSWD_EXPIRED:
477                         p = "E=648 Password expired";
478                         break;
479
480                 case MS_CHAP_ERROR_NO_DIALIN_PERMISSION:
481                         p = "E=649 No dialin permission";
482                         break;
483
484                 case MS_CHAP_ERROR_AUTHENTICATION_FAILURE:
485                         p = "E=691 Authentication failure";
486                         break;
487
488                 case MS_CHAP_ERROR_CHANGING_PASSWORD:
489                         /* Should never see this, we don't support Change Password. */
490                         p = "E=709 Error changing password";
491                         break;
492
493                 default:
494                         free(msg);
495                         error("Unknown MS-CHAP authentication failure: %.*v",
496                               len, inp);
497                         return;
498                 }
499         }
500 print_msg:
501         if (p != NULL)
502                 error("MS-CHAP authentication failed: %v", p);
503         free(msg);
504 }
505
506 static void
507 ChallengeResponse(u_char *challenge,
508                   u_char PasswordHash[MD4_SIGNATURE_SIZE],
509                   u_char response[24])
510 {
511     u_char    ZPasswordHash[21];
512
513     BZERO(ZPasswordHash, sizeof(ZPasswordHash));
514     BCOPY(PasswordHash, ZPasswordHash, MD4_SIGNATURE_SIZE);
515
516 #if 0
517     dbglog("ChallengeResponse - ZPasswordHash %.*B",
518            sizeof(ZPasswordHash), ZPasswordHash);
519 #endif
520
521     (void) DesSetkey(ZPasswordHash + 0);
522     DesEncrypt(challenge, response + 0);
523     (void) DesSetkey(ZPasswordHash + 7);
524     DesEncrypt(challenge, response + 8);
525     (void) DesSetkey(ZPasswordHash + 14);
526     DesEncrypt(challenge, response + 16);
527
528 #if 0
529     dbglog("ChallengeResponse - response %.24B", response);
530 #endif
531 }
532
533 void
534 ChallengeHash(u_char PeerChallenge[16], u_char *rchallenge,
535               char *username, u_char Challenge[8])
536     
537 {
538     SHA1_CTX    sha1Context;
539     u_char      sha1Hash[SHA1_SIGNATURE_SIZE];
540     char        *user;
541
542     /* remove domain from "domain\username" */
543     if ((user = strrchr(username, '\\')) != NULL)
544         ++user;
545     else
546         user = username;
547
548     SHA1_Init(&sha1Context);
549     SHA1_Update(&sha1Context, PeerChallenge, 16);
550     SHA1_Update(&sha1Context, rchallenge, 16);
551     SHA1_Update(&sha1Context, (unsigned char *)user, strlen(user));
552     SHA1_Final(sha1Hash, &sha1Context);
553
554     BCOPY(sha1Hash, Challenge, 8);
555 }
556
557 /*
558  * Convert the ASCII version of the password to Unicode.
559  * This implicitly supports 8-bit ISO8859/1 characters.
560  * This gives us the little-endian representation, which
561  * is assumed by all M$ CHAP RFCs.  (Unicode byte ordering
562  * is machine-dependent.)
563  */
564 static void
565 ascii2unicode(char ascii[], int ascii_len, u_char unicode[])
566 {
567     int i;
568
569     BZERO(unicode, ascii_len * 2);
570     for (i = 0; i < ascii_len; i++)
571         unicode[i * 2] = (u_char) ascii[i];
572 }
573
574 static void
575 NTPasswordHash(u_char *secret, int secret_len, u_char hash[MD4_SIGNATURE_SIZE])
576 {
577 #ifdef __NetBSD__
578     /* NetBSD uses the libc md4 routines which take bytes instead of bits */
579     int                 mdlen = secret_len;
580 #else
581     int                 mdlen = secret_len * 8;
582 #endif
583     MD4_CTX             md4Context;
584
585     MD4Init(&md4Context);
586     /* MD4Update can take at most 64 bytes at a time */
587     while (mdlen > 512) {
588         MD4Update(&md4Context, secret, 512);
589         secret += 64;
590         mdlen -= 512;
591     }
592     MD4Update(&md4Context, secret, mdlen);
593     MD4Final(hash, &md4Context);
594
595 }
596
597 static void
598 ChapMS_NT(u_char *rchallenge, char *secret, int secret_len,
599           u_char NTResponse[24])
600 {
601     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
602     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
603
604     /* Hash the Unicode version of the secret (== password). */
605     ascii2unicode(secret, secret_len, unicodePassword);
606     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
607
608     ChallengeResponse(rchallenge, PasswordHash, NTResponse);
609 }
610
611 static void
612 ChapMS2_NT(u_char *rchallenge, u_char PeerChallenge[16], char *username,
613            char *secret, int secret_len, u_char NTResponse[24])
614 {
615     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
616     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
617     u_char      Challenge[8];
618
619     ChallengeHash(PeerChallenge, rchallenge, username, Challenge);
620
621     /* Hash the Unicode version of the secret (== password). */
622     ascii2unicode(secret, secret_len, unicodePassword);
623     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
624
625     ChallengeResponse(Challenge, PasswordHash, NTResponse);
626 }
627
628 #ifdef MSLANMAN
629 static u_char *StdText = (u_char *)"KGS!@#$%"; /* key from rasapi32.dll */
630
631 static void
632 ChapMS_LANMan(u_char *rchallenge, char *secret, int secret_len,
633               unsigned char *response)
634 {
635     int                 i;
636     u_char              UcasePassword[MAX_NT_PASSWORD]; /* max is actually 14 */
637     u_char              PasswordHash[MD4_SIGNATURE_SIZE];
638
639     /* LANMan password is case insensitive */
640     BZERO(UcasePassword, sizeof(UcasePassword));
641     for (i = 0; i < secret_len; i++)
642        UcasePassword[i] = (u_char)toupper(secret[i]);
643     (void) DesSetkey(UcasePassword + 0);
644     DesEncrypt( StdText, PasswordHash + 0 );
645     (void) DesSetkey(UcasePassword + 7);
646     DesEncrypt( StdText, PasswordHash + 8 );
647     ChallengeResponse(rchallenge, PasswordHash, &response[MS_CHAP_LANMANRESP]);
648 }
649 #endif
650
651
652 void
653 GenerateAuthenticatorResponse(u_char PasswordHashHash[MD4_SIGNATURE_SIZE],
654                               u_char NTResponse[24], u_char PeerChallenge[16],
655                               u_char *rchallenge, char *username,
656                               u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1])
657 {
658     /*
659      * "Magic" constants used in response generation, from RFC 2759.
660      */
661     u_char Magic1[39] = /* "Magic server to client signing constant" */
662         { 0x4D, 0x61, 0x67, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76,
663           0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6C, 0x69, 0x65,
664           0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67,
665           0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74 };
666     u_char Magic2[41] = /* "Pad to make it do more than one iteration" */
667         { 0x50, 0x61, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B,
668           0x65, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6D, 0x6F,
669           0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E,
670           0x65, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F,
671           0x6E };
672
673     int         i;
674     SHA1_CTX    sha1Context;
675     u_char      Digest[SHA1_SIGNATURE_SIZE];
676     u_char      Challenge[8];
677
678     SHA1_Init(&sha1Context);
679     SHA1_Update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
680     SHA1_Update(&sha1Context, NTResponse, 24);
681     SHA1_Update(&sha1Context, Magic1, sizeof(Magic1));
682     SHA1_Final(Digest, &sha1Context);
683
684     ChallengeHash(PeerChallenge, rchallenge, username, Challenge);
685
686     SHA1_Init(&sha1Context);
687     SHA1_Update(&sha1Context, Digest, sizeof(Digest));
688     SHA1_Update(&sha1Context, Challenge, sizeof(Challenge));
689     SHA1_Update(&sha1Context, Magic2, sizeof(Magic2));
690     SHA1_Final(Digest, &sha1Context);
691
692     /* Convert to ASCII hex string. */
693     for (i = 0; i < MAX((MS_AUTH_RESPONSE_LENGTH / 2), sizeof(Digest)); i++)
694         sprintf((char *)&authResponse[i * 2], "%02X", Digest[i]);
695 }
696
697
698 static void
699 GenerateAuthenticatorResponsePlain
700                 (char *secret, int secret_len,
701                  u_char NTResponse[24], u_char PeerChallenge[16],
702                  u_char *rchallenge, char *username,
703                  u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1])
704 {
705     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
706     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
707     u_char      PasswordHashHash[MD4_SIGNATURE_SIZE];
708
709     /* Hash (x2) the Unicode version of the secret (== password). */
710     ascii2unicode(secret, secret_len, unicodePassword);
711     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
712     NTPasswordHash(PasswordHash, sizeof(PasswordHash),
713                    PasswordHashHash);
714
715     GenerateAuthenticatorResponse(PasswordHashHash, NTResponse, PeerChallenge,
716                                   rchallenge, username, authResponse);
717 }
718
719
720 #ifdef MPPE
721 /*
722  * Set mppe_xxxx_key from the NTPasswordHashHash.
723  * RFC 2548 (RADIUS support) requires us to export this function (ugh).
724  */
725 void
726 mppe_set_keys(u_char *rchallenge, u_char PasswordHashHash[MD4_SIGNATURE_SIZE])
727 {
728     SHA1_CTX    sha1Context;
729     u_char      Digest[SHA1_SIGNATURE_SIZE];    /* >= MPPE_MAX_KEY_LEN */
730
731     SHA1_Init(&sha1Context);
732     SHA1_Update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
733     SHA1_Update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
734     SHA1_Update(&sha1Context, rchallenge, 8);
735     SHA1_Final(Digest, &sha1Context);
736
737     /* Same key in both directions. */
738     BCOPY(Digest, mppe_send_key, sizeof(mppe_send_key));
739     BCOPY(Digest, mppe_recv_key, sizeof(mppe_recv_key));
740
741     mppe_keys_set = 1;
742 }
743
744 /*
745  * Set mppe_xxxx_key from MS-CHAP credentials. (see RFC 3079)
746  */
747 static void
748 Set_Start_Key(u_char *rchallenge, char *secret, int secret_len)
749 {
750     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
751     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
752     u_char      PasswordHashHash[MD4_SIGNATURE_SIZE];
753
754     /* Hash (x2) the Unicode version of the secret (== password). */
755     ascii2unicode(secret, secret_len, unicodePassword);
756     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
757     NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);
758
759     mppe_set_keys(rchallenge, PasswordHashHash);
760 }
761
762 /*
763  * Set mppe_xxxx_key from MS-CHAPv2 credentials. (see RFC 3079)
764  *
765  * This helper function used in the Winbind module, which gets the
766  * NTHashHash from the server.
767  */
768 void
769 mppe_set_keys2(u_char PasswordHashHash[MD4_SIGNATURE_SIZE],
770                u_char NTResponse[24], int IsServer)
771 {
772     SHA1_CTX    sha1Context;
773     u_char      MasterKey[SHA1_SIGNATURE_SIZE]; /* >= MPPE_MAX_KEY_LEN */
774     u_char      Digest[SHA1_SIGNATURE_SIZE];    /* >= MPPE_MAX_KEY_LEN */
775
776     u_char SHApad1[40] =
777         { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
778           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
779           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
780           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
781     u_char SHApad2[40] =
782         { 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
783           0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
784           0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
785           0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2 };
786
787     /* "This is the MPPE Master Key" */
788     u_char Magic1[27] =
789         { 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74,
790           0x68, 0x65, 0x20, 0x4d, 0x50, 0x50, 0x45, 0x20, 0x4d,
791           0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x4b, 0x65, 0x79 };
792     /* "On the client side, this is the send key; "
793        "on the server side, it is the receive key." */
794     u_char Magic2[84] =
795         { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
796           0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
797           0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
798           0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x6b, 0x65, 0x79,
799           0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73,
800           0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x69, 0x64, 0x65,
801           0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
802           0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
803           0x6b, 0x65, 0x79, 0x2e };
804     /* "On the client side, this is the receive key; "
805        "on the server side, it is the send key." */
806     u_char Magic3[84] =
807         { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
808           0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
809           0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
810           0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
811           0x6b, 0x65, 0x79, 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68,
812           0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73,
813           0x69, 0x64, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73,
814           0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20,
815           0x6b, 0x65, 0x79, 0x2e };
816     u_char *s;
817
818     SHA1_Init(&sha1Context);
819     SHA1_Update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE);
820     SHA1_Update(&sha1Context, NTResponse, 24);
821     SHA1_Update(&sha1Context, Magic1, sizeof(Magic1));
822     SHA1_Final(MasterKey, &sha1Context);
823
824     /*
825      * generate send key
826      */
827     if (IsServer)
828         s = Magic3;
829     else
830         s = Magic2;
831     SHA1_Init(&sha1Context);
832     SHA1_Update(&sha1Context, MasterKey, 16);
833     SHA1_Update(&sha1Context, SHApad1, sizeof(SHApad1));
834     SHA1_Update(&sha1Context, s, 84);
835     SHA1_Update(&sha1Context, SHApad2, sizeof(SHApad2));
836     SHA1_Final(Digest, &sha1Context);
837
838     BCOPY(Digest, mppe_send_key, sizeof(mppe_send_key));
839
840     /*
841      * generate recv key
842      */
843     if (IsServer)
844         s = Magic2;
845     else
846         s = Magic3;
847     SHA1_Init(&sha1Context);
848     SHA1_Update(&sha1Context, MasterKey, 16);
849     SHA1_Update(&sha1Context, SHApad1, sizeof(SHApad1));
850     SHA1_Update(&sha1Context, s, 84);
851     SHA1_Update(&sha1Context, SHApad2, sizeof(SHApad2));
852     SHA1_Final(Digest, &sha1Context);
853
854     BCOPY(Digest, mppe_recv_key, sizeof(mppe_recv_key));
855
856     mppe_keys_set = 1;
857 }
858
859 /*
860  * Set mppe_xxxx_key from MS-CHAPv2 credentials. (see RFC 3079)
861  */
862 static void
863 SetMasterKeys(char *secret, int secret_len, u_char NTResponse[24], int IsServer)
864 {
865     u_char      unicodePassword[MAX_NT_PASSWORD * 2];
866     u_char      PasswordHash[MD4_SIGNATURE_SIZE];
867     u_char      PasswordHashHash[MD4_SIGNATURE_SIZE];
868     /* Hash (x2) the Unicode version of the secret (== password). */
869     ascii2unicode(secret, secret_len, unicodePassword);
870     NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash);
871     NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash);
872     mppe_set_keys2(PasswordHashHash, NTResponse, IsServer);
873 }
874
875 #endif /* MPPE */
876
877
878 void
879 ChapMS(u_char *rchallenge, char *secret, int secret_len,
880        unsigned char *response)
881 {
882     BZERO(response, MS_CHAP_RESPONSE_LEN);
883
884     ChapMS_NT(rchallenge, secret, secret_len, &response[MS_CHAP_NTRESP]);
885
886 #ifdef MSLANMAN
887     ChapMS_LANMan(rchallenge, secret, secret_len,
888                   &response[MS_CHAP_LANMANRESP]);
889
890     /* preferred method is set by option  */
891     response[MS_CHAP_USENT] = !ms_lanman;
892 #else
893     response[MS_CHAP_USENT] = 1;
894 #endif
895
896 #ifdef MPPE
897     Set_Start_Key(rchallenge, secret, secret_len);
898 #endif
899 }
900
901
902 /*
903  * If PeerChallenge is NULL, one is generated and the PeerChallenge
904  * field of response is filled in.  Call this way when generating a response.
905  * If PeerChallenge is supplied, it is copied into the PeerChallenge field.
906  * Call this way when verifying a response (or debugging).
907  * Do not call with PeerChallenge = response.
908  *
909  * The PeerChallenge field of response is then used for calculation of the
910  * Authenticator Response.
911  */
912 void
913 ChapMS2(u_char *rchallenge, u_char *PeerChallenge,
914         char *user, char *secret, int secret_len, unsigned char *response,
915         u_char authResponse[], int authenticator)
916 {
917     /* ARGSUSED */
918     u_char *p = &response[MS_CHAP2_PEER_CHALLENGE];
919     int i;
920
921     BZERO(response, MS_CHAP2_RESPONSE_LEN);
922
923     /* Generate the Peer-Challenge if requested, or copy it if supplied. */
924     if (!PeerChallenge)
925         for (i = 0; i < MS_CHAP2_PEER_CHAL_LEN; i++)
926             *p++ = (u_char) (drand48() * 0xff);
927     else
928         BCOPY(PeerChallenge, &response[MS_CHAP2_PEER_CHALLENGE],
929               MS_CHAP2_PEER_CHAL_LEN);
930
931     /* Generate the NT-Response */
932     ChapMS2_NT(rchallenge, &response[MS_CHAP2_PEER_CHALLENGE], user,
933                secret, secret_len, &response[MS_CHAP2_NTRESP]);
934
935     /* Generate the Authenticator Response. */
936     GenerateAuthenticatorResponsePlain(secret, secret_len,
937                                        &response[MS_CHAP2_NTRESP],
938                                        &response[MS_CHAP2_PEER_CHALLENGE],
939                                        rchallenge, user, authResponse);
940
941 #ifdef MPPE
942     SetMasterKeys(secret, secret_len,
943                   &response[MS_CHAP2_NTRESP], authenticator);
944 #endif
945 }
946
947 #ifdef MPPE
948 /*
949  * Set MPPE options from plugins.
950  */
951 void
952 set_mppe_enc_types(int policy, int types)
953 {
954     /* Early exit for unknown policies. */
955     if (policy != MPPE_ENC_POL_ENC_ALLOWED ||
956         policy != MPPE_ENC_POL_ENC_REQUIRED)
957         return;
958
959     /* Don't modify MPPE if it's optional and wasn't already configured. */
960     if (policy == MPPE_ENC_POL_ENC_ALLOWED && !ccp_wantoptions[0].mppe)
961         return;
962
963     /*
964      * Disable undesirable encryption types.  Note that we don't ENABLE
965      * any encryption types, to avoid overriding manual configuration.
966      */
967     switch(types) {
968         case MPPE_ENC_TYPES_RC4_40:
969             ccp_wantoptions[0].mppe &= ~MPPE_OPT_128;   /* disable 128-bit */
970             break;
971         case MPPE_ENC_TYPES_RC4_128:
972             ccp_wantoptions[0].mppe &= ~MPPE_OPT_40;    /* disable 40-bit */
973             break;
974         default:
975             break;
976     }
977 }
978 #endif /* MPPE */
979
980 static struct chap_digest_type chapms_digest = {
981         CHAP_MICROSOFT,         /* code */
982         chapms_generate_challenge,
983         chapms_verify_response,
984         chapms_make_response,
985         NULL,                   /* check_success */
986         chapms_handle_failure,
987 };
988
989 static struct chap_digest_type chapms2_digest = {
990         CHAP_MICROSOFT_V2,      /* code */
991         chapms2_generate_challenge,
992         chapms2_verify_response,
993         chapms2_make_response,
994         chapms2_check_success,
995         chapms_handle_failure,
996 };
997
998 void
999 chapms_init(void)
1000 {
1001         chap_register_digest(&chapms_digest);
1002         chap_register_digest(&chapms2_digest);
1003         add_options(chapms_option_list);
1004 }
1005
1006 #endif /* CHAPMS */