From 71d3de90eae52087b405e962ca650b71cec79c67 Mon Sep 17 00:00:00 2001 From: Paul Mackerras Date: Wed, 11 Jun 2003 23:56:26 +0000 Subject: [PATCH] New CHAP implementation, rewritten from scratch to avoid the code copyrighted by the uncontactable Gregory Christy. The new code is much cleaner and splits out all the digest-specific code to separate files. Thus the CHAP-MD5 stuff is now in chap-md5.c and all the CHAP-MS and CHAP-MSv2 stuff has moved into chap_ms.c, instead of having half of it in chap.c. There are a few minor differences in this implementation; we don't retransmit responses, but instead just wait for a new challenge. The success/failure messages are more boring as well. In fact the digest code now sets the success/failure message. CHAP_DIGEST_MD5 has been renamed to CHAP_MD5 for consistency. There is a new function random_bytes() in magic.c, which generates a string of random bytes. --- pppd/Makefile.linux | 15 +- pppd/auth.c | 18 +- pppd/chap-md5.c | 122 +++++++++ pppd/chap-md5.h | 36 +++ pppd/chap-new.c | 636 ++++++++++++++++++++++++++++++++++++++++++++ pppd/chap-new.h | 138 ++++++++++ pppd/chap_ms.c | 341 +++++++++++++++++++++++- pppd/chap_ms.h | 11 +- pppd/eap.c | 4 +- pppd/eap.h | 6 +- pppd/lcp.c | 6 +- pppd/magic.c | 15 +- pppd/magic.h | 5 +- pppd/main.c | 4 +- 14 files changed, 1318 insertions(+), 39 deletions(-) create mode 100644 pppd/chap-md5.c create mode 100644 pppd/chap-md5.h create mode 100644 pppd/chap-new.c create mode 100644 pppd/chap-new.h diff --git a/pppd/Makefile.linux b/pppd/Makefile.linux index 0ab8c76..85113d0 100644 --- a/pppd/Makefile.linux +++ b/pppd/Makefile.linux @@ -1,6 +1,6 @@ # # pppd makefile for Linux -# $Id: Makefile.linux,v 1.58 2003/05/12 08:18:54 fcusack Exp $ +# $Id: Makefile.linux,v 1.59 2003/06/11 23:56:26 paulus Exp $ # # Default installation locations @@ -10,17 +10,18 @@ INCDIR = $(DESTDIR)/usr/include TARGETS = pppd -PPPDSRCS = main.c magic.c fsm.c lcp.c ipcp.c upap.c chap.c md5.c ccp.c ecp.c \ - ipxcp.c auth.c options.c sys-linux.c md4.c chap_ms.c \ - demand.c utils.c tty.c eap.c +PPPDSRCS = main.c magic.c fsm.c lcp.c ipcp.c upap.c chap-new.c md5.c ccp.c \ + ecp.c ipxcp.c auth.c options.c sys-linux.c md4.c chap_ms.c \ + demand.c utils.c tty.c eap.c chap-md5.c -HEADERS = ccp.h chap.h ecp.h fsm.h ipcp.h \ +HEADERS = ccp.h chap-new.h ecp.h fsm.h ipcp.h \ ipxcp.h lcp.h magic.h md5.h patchlevel.h pathnames.h pppd.h \ upap.h eap.h MANPAGES = pppd.8 -PPPDOBJS = main.o magic.o fsm.o lcp.o ipcp.o upap.o chap.o md5.o ccp.o ecp.o \ - auth.o options.o demand.o utils.o sys-linux.o ipxcp.o tty.o eap.o +PPPDOBJS = main.o magic.o fsm.o lcp.o ipcp.o upap.o chap-new.o md5.o ccp.o \ + ecp.o auth.o options.o demand.o utils.o sys-linux.o ipxcp.o tty.o \ + eap.o chap-md5.o # # include dependencies if present diff --git a/pppd/auth.c b/pppd/auth.c index b0bcdcf..002ec85 100644 --- a/pppd/auth.c +++ b/pppd/auth.c @@ -73,7 +73,7 @@ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#define RCSID "$Id: auth.c,v 1.94 2003/03/09 09:52:19 etbe Exp $" +#define RCSID "$Id: auth.c,v 1.95 2003/06/11 23:56:26 paulus Exp $" #include #include @@ -114,7 +114,7 @@ #include "ecp.h" #include "ipcp.h" #include "upap.h" -#include "chap.h" +#include "chap-new.h" #include "eap.h" #ifdef CBCP_SUPPORT #include "cbcp.h" @@ -186,6 +186,12 @@ void (*pap_logout_hook) __P((void)) = NULL; /* Hook for a plugin to get the PAP password for authenticating us */ int (*pap_passwd_hook) __P((char *user, char *passwd)) = NULL; +/* Hook for a plugin to say if we can possibly authenticate a peer using CHAP */ +int (*chap_check_hook) __P((void)) = NULL; + +/* Hook for a plugin to get the CHAP password for authenticating us */ +int (*chap_passwd_hook) __P((char *user, char *passwd)) = NULL; + /* Hook for a plugin to say whether it is OK if the peer refuses to authenticate. */ int (*null_auth_hook) __P((struct wordlist **paddrs, @@ -634,7 +640,7 @@ link_established(unit) eap_authpeer(unit, our_name); auth |= EAP_PEER; } else if (go->neg_chap) { - ChapAuthPeer(unit, our_name, CHAP_DIGEST(go->chap_mdtype)); + chap_auth_peer(unit, our_name, CHAP_DIGEST(go->chap_mdtype)); auth |= CHAP_PEER; } else if (go->neg_upap) { upap_authpeer(unit); @@ -644,7 +650,7 @@ link_established(unit) eap_authwithpeer(unit, user); auth |= EAP_WITHPEER; } else if (ho->neg_chap) { - ChapAuthWithPeer(unit, user, CHAP_DIGEST(ho->chap_mdtype)); + chap_auth_with_peer(unit, user, CHAP_DIGEST(ho->chap_mdtype)); auth |= CHAP_WITHPEER; } else if (ho->neg_upap) { if (passwd[0] == 0) { @@ -800,7 +806,7 @@ auth_peer_success(unit, protocol, prot_flavor, name, namelen) case PPP_CHAP: bit = CHAP_PEER; switch (prot_flavor) { - case CHAP_DIGEST_MD5: + case CHAP_MD5: bit |= CHAP_MD5_PEER; break; #ifdef CHAPMS @@ -876,7 +882,7 @@ auth_withpeer_success(unit, protocol, prot_flavor) case PPP_CHAP: bit = CHAP_WITHPEER; switch (prot_flavor) { - case CHAP_DIGEST_MD5: + case CHAP_MD5: bit |= CHAP_MD5_WITHPEER; break; #ifdef CHAPMS diff --git a/pppd/chap-md5.c b/pppd/chap-md5.c new file mode 100644 index 0000000..2529f4e --- /dev/null +++ b/pppd/chap-md5.c @@ -0,0 +1,122 @@ +/* + * chap-md5.c - New CHAP/MD5 implementation. + * + * Copyright (c) 2003 Paul Mackerras. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#define RCSID "$Id" + +#include +#include +#include "pppd.h" +#include "chap-new.h" +#include "chap-md5.h" +#include "magic.h" +#include "md5.h" + +#define MD5_HASH_SIZE 16 +#define MD5_MIN_CHALLENGE 16 +#define MD5_MAX_CHALLENGE 24 + +static void +chap_md5_generate_challenge(unsigned char *cp) +{ + int clen; + + clen = (int)(drand48() * (MD5_MAX_CHALLENGE - MD5_MIN_CHALLENGE)) + + MD5_MIN_CHALLENGE; + *cp++ = clen; + random_bytes(cp, clen); +} + +static int +chap_md5_verify_response(int id, char *name, + unsigned char *secret, int secret_len, + unsigned char *challenge, unsigned char *response, + char *message, int message_space) +{ + MD5_CTX ctx; + unsigned char idbyte = id; + unsigned char hash[MD5_HASH_SIZE]; + int challenge_len, response_len; + + challenge_len = *challenge++; + response_len = *response++; + if (response_len == MD5_HASH_SIZE) { + /* Generate hash of ID, secret, challenge */ + MD5Init(&ctx); + MD5Update(&ctx, &idbyte, 1); + MD5Update(&ctx, secret, secret_len); + MD5Update(&ctx, challenge, challenge_len); + MD5Final(hash, &ctx); + + /* Test if our hash matches the peer's response */ + if (memcmp(hash, response, MD5_HASH_SIZE) == 0) { + slprintf(message, message_space, "Access granted"); + return 1; + } + } + slprintf(message, message_space, "Access denied"); + return 0; +} + +static void +chap_md5_make_response(unsigned char *response, int id, char *our_name, + unsigned char *challenge, char *secret, int secret_len, + unsigned char *private) +{ + MD5_CTX ctx; + unsigned char idbyte = id; + int challenge_len = *challenge++; + + MD5Init(&ctx); + MD5Update(&ctx, &idbyte, 1); + MD5Update(&ctx, secret, secret_len); + MD5Update(&ctx, challenge, challenge_len); + MD5Final(&response[1], &ctx); + response[0] = MD5_HASH_SIZE; +} + +static struct chap_digest_type md5_digest = { + CHAP_MD5, /* code */ + chap_md5_generate_challenge, + chap_md5_verify_response, + chap_md5_make_response, + NULL, /* check_success */ + NULL, /* handle_failure */ +}; + +void +chap_md5_init(void) +{ + chap_register_digest(&md5_digest); +} diff --git a/pppd/chap-md5.h b/pppd/chap-md5.h new file mode 100644 index 0000000..d63a43f --- /dev/null +++ b/pppd/chap-md5.h @@ -0,0 +1,36 @@ +/* + * chap-md5.h - New CHAP/MD5 implementation. + * + * Copyright (c) 2003 Paul Mackerras. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +extern void chap_md5_init(void); diff --git a/pppd/chap-new.c b/pppd/chap-new.c new file mode 100644 index 0000000..ef002d1 --- /dev/null +++ b/pppd/chap-new.c @@ -0,0 +1,636 @@ +/* + * chap-new.c - New CHAP implementation. + * + * Copyright (c) 2003 Paul Mackerras. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#define RCSID "$Id" + +#include +#include +#include "pppd.h" +#include "chap-new.h" +#include "chap-md5.h" + +#ifdef CHAPMS +#include "chap_ms.h" +#endif + +/* Hook for a plugin to validate CHAP challenge */ +int (*chap_verify_hook)(char *name, char *ourname, int id, + struct chap_digest_type *digest, + unsigned char *challenge, unsigned char *response, + unsigned char *message, int message_space) = NULL; + +/* + * Option variables. + */ +int chap_timeout_time = 3; +int chap_max_transmits = 10; +int chap_rechallenge_time = 0; + +/* + * Command-line options. + */ +static option_t chap_option_list[] = { + { "chap-restart", o_int, &chap_timeout_time, + "Set timeout for CHAP", OPT_PRIO }, + { "chap-max-challenge", o_int, &chap_max_transmits, + "Set max #xmits for challenge", OPT_PRIO }, + { "chap-interval", o_int, &chap_rechallenge_time, + "Set interval for rechallenge", OPT_PRIO }, + { NULL } +}; + +/* + * Internal state. + */ +static struct chap_client_state { + int flags; + char *name; + struct chap_digest_type *digest; + unsigned char priv[64]; /* private area for digest's use */ +} client; + +/* + * These limits apply to challenge and response packets we send. + * The +4 is the +1 that we actually need rounded up. + */ +#define CHAL_MAX_PKTLEN (PPP_HDRLEN + CHAP_HDRLEN + 4 + MAX_CHALLENGE_LEN + MAXNAMELEN) +#define RESP_MAX_PKTLEN (PPP_HDRLEN + CHAP_HDRLEN + 4 + MAX_RESPONSE_LEN + MAXNAMELEN) + +static struct chap_server_state { + int flags; + int id; + char *name; + struct chap_digest_type *digest; + int challenge_xmits; + int challenge_pktlen; + unsigned char challenge[CHAL_MAX_PKTLEN]; +} server; + +/* Values for flags in chap_client_state and chap_server_state */ +#define LOWERUP 1 +#define AUTH_STARTED 2 +#define AUTH_DONE 4 +#define AUTH_FAILED 8 +#define TIMEOUT_PENDING 0x10 +#define CHALLENGE_VALID 0x20 + +/* + * Prototypes. + */ +static void chap_init(int unit); +static void chap_lowerup(int unit); +static void chap_lowerdown(int unit); +static void chap_timeout(void *arg); +static void chap_generate_challenge(struct chap_server_state *ss); +static void chap_handle_response(struct chap_server_state *ss, int code, + unsigned char *pkt, int len); +static int chap_verify_response(char *name, char *ourname, int id, + struct chap_digest_type *digest, + unsigned char *challenge, unsigned char *response, + unsigned char *message, int message_space); +static void chap_respond(struct chap_client_state *cs, int id, + unsigned char *pkt, int len); +static void chap_handle_status(struct chap_client_state *cs, int code, int id, + unsigned char *pkt, int len); +static void chap_protrej(int unit); +static void chap_input(int unit, unsigned char *pkt, int pktlen); +static int chap_print_pkt(unsigned char *p, int plen, + void (*printer) __P((void *, char *, ...)), void *arg); + +/* List of digest types that we know about */ +static struct chap_digest_type *chap_digests; + +/* + * chap_init - reset to initial state. + */ +static void +chap_init(int unit) +{ + memset(&client, 0, sizeof(client)); + memset(&server, 0, sizeof(server)); + + chap_md5_init(); +#ifdef CHAPMS + chapms_init(); +#endif +} + +/* + * Add a new digest type to the list. + */ +void +chap_register_digest(struct chap_digest_type *dp) +{ + dp->next = chap_digests; + chap_digests = dp; +} + +/* + * chap_lowerup - we can start doing stuff now. + */ +static void +chap_lowerup(int unit) +{ + struct chap_client_state *cs = &client; + struct chap_server_state *ss = &server; + + cs->flags |= LOWERUP; + ss->flags |= LOWERUP; + if (ss->flags & AUTH_STARTED) + chap_timeout(ss); +} + +static void +chap_lowerdown(int unit) +{ + struct chap_client_state *cs = &client; + struct chap_server_state *ss = &server; + + cs->flags = 0; + if (ss->flags & TIMEOUT_PENDING) + UNTIMEOUT(chap_timeout, ss); + ss->flags = 0; +} + +/* + * chap_auth_peer - Start authenticating the peer. + * If the lower layer is already up, we start sending challenges, + * otherwise we wait for the lower layer to come up. + */ +void +chap_auth_peer(int unit, char *our_name, int digest_code) +{ + struct chap_server_state *ss = &server; + struct chap_digest_type *dp; + + if (ss->flags & AUTH_STARTED) { + error("CHAP: peer authentication already started!"); + return; + } + for (dp = chap_digests; dp != NULL; dp = dp->next) + if (dp->code == digest_code) + break; + if (dp == NULL) + fatal("CHAP digest 0x%x requested but not available", + digest_code); + + ss->digest = dp; + ss->name = our_name; + /* Start with a random ID value */ + ss->id = (unsigned char)(drand48() * 256); + ss->flags |= AUTH_STARTED; + if (ss->flags & LOWERUP) + chap_timeout(ss); +} + +/* + * chap_auth_peer - Prepare to authenticate ourselves to the peer. + * There isn't much to do until we receive a challenge. + */ +void +chap_auth_with_peer(int unit, char *our_name, int digest_code) +{ + struct chap_client_state *cs = &client; + struct chap_digest_type *dp; + + if (cs->flags & AUTH_STARTED) { + error("CHAP: authentication with peer already started!"); + return; + } + for (dp = chap_digests; dp != NULL; dp = dp->next) + if (dp->code == digest_code) + break; + if (dp == NULL) + fatal("CHAP digest 0x%x requested but not available", + digest_code); + + cs->digest = dp; + cs->name = our_name; + cs->flags |= AUTH_STARTED; +} + +/* + * chap_timeout - It's time to send another challenge to the peer. + * This could be either a retransmission of a previous challenge, + * or a new challenge to start re-authentication. + */ +static void +chap_timeout(void *arg) +{ + struct chap_server_state *ss = arg; + + ss->flags &= ~TIMEOUT_PENDING; + if ((ss->flags & CHALLENGE_VALID) == 0) { + ss->challenge_xmits = 0; + chap_generate_challenge(ss); + ss->flags |= CHALLENGE_VALID; + } else if (ss->challenge_xmits >= chap_max_transmits) { + ss->flags &= ~CHALLENGE_VALID; + ss->flags |= AUTH_DONE | AUTH_FAILED; + auth_peer_fail(0, PPP_CHAP); + return; + } + + output(0, ss->challenge, ss->challenge_pktlen); + ++ss->challenge_xmits; + ss->flags |= TIMEOUT_PENDING; + TIMEOUT(chap_timeout, arg, chap_timeout_time); +} + +/* + * chap_generate_challenge - generate a challenge string and format + * the challenge packet in ss->challenge_pkt. + */ +static void +chap_generate_challenge(struct chap_server_state *ss) +{ + int clen = 1, nlen, len; + unsigned char *p; + + p = ss->challenge; + MAKEHEADER(p, PPP_CHAP); + p += CHAP_HDRLEN; + ss->digest->generate_challenge(p); + clen = *p; + nlen = strlen(ss->name); + memcpy(p + 1 + clen, ss->name, nlen); + + len = CHAP_HDRLEN + 1 + clen + nlen; + ss->challenge_pktlen = PPP_HDRLEN + len; + + p = ss->challenge + PPP_HDRLEN; + p[0] = CHAP_CHALLENGE; + p[1] = ++ss->id; + p[2] = len >> 8; + p[3] = len; +} + +/* + * chap_handle_response - check the response to our challenge. + */ +static void +chap_handle_response(struct chap_server_state *ss, int id, + unsigned char *pkt, int len) +{ + int response_len, ok, mlen; + unsigned char *response, *p; + unsigned char *name = NULL; /* initialized to shut gcc up */ + int (*verifier)(char *, char *, int, struct chap_digest_type *, + unsigned char *, unsigned char *, unsigned char *, int); + char rname[MAXNAMELEN+1]; + unsigned char message[256]; + + if ((ss->flags & LOWERUP) == 0) + return; + if (id != ss->challenge[PPP_HDRLEN+1] || len < 2) + return; + if ((ss->flags & AUTH_DONE) == 0) { + if ((ss->flags & CHALLENGE_VALID) == 0) + return; + response = pkt; + GETCHAR(response_len, pkt); + len -= response_len + 1; /* length of name */ + name = pkt + response_len; + if (len < 0) + return; + + ss->flags &= ~CHALLENGE_VALID; + if (ss->flags & TIMEOUT_PENDING) { + ss->flags &= ~TIMEOUT_PENDING; + UNTIMEOUT(chap_timeout, ss); + } + + if (explicit_remote) { + name = remote_name; + } else { + /* Null terminate and clean remote name. */ + slprintf(rname, sizeof(rname), "%.*v", len, name); + name = rname; + } + + if (chap_verify_hook) + verifier = chap_verify_hook; + else + verifier = chap_verify_response; + ok = (*verifier)(name, ss->name, id, ss->digest, + ss->challenge + PPP_HDRLEN + CHAP_HDRLEN, + response, message, sizeof(message)); + if (!ok || !auth_number()) { + ss->flags |= AUTH_FAILED; + warn("Peer %q failed CHAP authentication", name); + } + } + + /* send the response */ + p = outpacket_buf; + MAKEHEADER(p, PPP_CHAP); + mlen = strlen(message); + len = CHAP_HDRLEN + mlen; + p[0] = (ss->flags & AUTH_FAILED)? CHAP_FAILURE: CHAP_SUCCESS; + p[1] = id; + p[2] = len >> 8; + p[3] = len; + if (mlen > 0) + memcpy(p + CHAP_HDRLEN, message, mlen); + output(0, outpacket_buf, PPP_HDRLEN + len); + + if ((ss->flags & AUTH_DONE) == 0) { + ss->flags |= AUTH_DONE; + if (ss->flags & AUTH_FAILED) { + auth_peer_fail(0, PPP_CHAP); + } else { + auth_peer_success(0, PPP_CHAP, ss->digest->code, + name, strlen(name)); + if (chap_rechallenge_time) { + ss->flags |= TIMEOUT_PENDING; + TIMEOUT(chap_timeout, ss, + chap_rechallenge_time); + } + } + } +} + +/* + * chap_verify_response - check whether the peer's response matches + * what we think it should be. Returns 1 if it does (authentication + * succeeded), or 0 if it doesn't. + */ +static int +chap_verify_response(char *name, char *ourname, int id, + struct chap_digest_type *digest, + unsigned char *challenge, unsigned char *response, + unsigned char *message, int message_space) +{ + int ok; + char secret[MAXSECRETLEN]; + int secret_len; + + /* Get the secret that the peer is supposed to know */ + if (!get_secret(0, name, ourname, secret, &secret_len, 1)) { + error("No CHAP secret found for authenticating %q", name); + return 0; + } + + ok = digest->verify_response(id, name, secret, secret_len, challenge, + response, message, message_space); + memset(secret, 0, sizeof(secret)); + + return ok; +} + +/* + * chap_respond - Generate and send a response to a challenge. + */ +static void +chap_respond(struct chap_client_state *cs, int id, + unsigned char *pkt, int len) +{ + int clen, nlen; + int secret_len; + unsigned char *p; + unsigned char response[RESP_MAX_PKTLEN]; + char rname[MAXNAMELEN+1]; + char secret[MAXSECRETLEN+1]; + + if ((cs->flags & (LOWERUP | AUTH_STARTED)) != (LOWERUP | AUTH_STARTED)) + return; /* not ready */ + if (len < 2 || len < pkt[0] + 1) + return; /* too short */ + clen = pkt[0]; + nlen = len - (clen + 1); + + /* Null terminate and clean remote name. */ + slprintf(rname, sizeof(rname), "%.*v", nlen, pkt + clen + 1); + + /* Microsoft doesn't send their name back in the PPP packet */ + if (explicit_remote || (remote_name[0] != 0 && rname[0] == 0)) + strlcpy(rname, remote_name, sizeof(rname)); + + /* get secret for authenticating ourselves with the specified host */ + if (!get_secret(0, cs->name, rname, secret, &secret_len, 0)) { + secret_len = 0; /* assume null secret if can't find one */ + warn("No CHAP secret found for authenticating us to %q", rname); + } + + p = response; + MAKEHEADER(p, PPP_CHAP); + p += CHAP_HDRLEN; + + cs->digest->make_response(p, id, cs->name, pkt, + secret, secret_len, cs->priv); + memset(secret, 0, secret_len); + + clen = *p; + nlen = strlen(cs->name); + memcpy(p + clen + 1, cs->name, nlen); + + p = response + PPP_HDRLEN; + len = CHAP_HDRLEN + clen + 1 + nlen; + p[0] = CHAP_RESPONSE; + p[1] = id; + p[2] = len >> 8; + p[3] = len; + + output(0, response, PPP_HDRLEN + len); +} + +static void +chap_handle_status(struct chap_client_state *cs, int code, int id, + unsigned char *pkt, int len) +{ + const char *msg = NULL; + + if ((cs->flags & (AUTH_DONE|AUTH_STARTED|LOWERUP)) + != (AUTH_STARTED|LOWERUP)) + return; + cs->flags |= AUTH_DONE; + + if (code == CHAP_SUCCESS) { + /* used for MS-CHAP v2 mutual auth, yuck */ + if (cs->digest->check_success != NULL) { + if (!(*cs->digest->check_success)(pkt, len, cs->priv)) + code = CHAP_FAILURE; + } else + msg = "CHAP authentication succeeded"; + } else { + if (cs->digest->handle_failure != NULL) + (*cs->digest->handle_failure)(pkt, len); + else + msg = "CHAP authentication failed"; + } + if (msg) { + if (len > 0) + info("%s: %.*v", msg, len, pkt); + else + info("%s", msg); + } + if (code == CHAP_SUCCESS) + auth_withpeer_success(0, PPP_CHAP, cs->digest->code); + else { + cs->flags |= AUTH_FAILED; + auth_withpeer_fail(0, PPP_CHAP); + } +} + +static void +chap_input(int unit, unsigned char *pkt, int pktlen) +{ + struct chap_client_state *cs = &client; + struct chap_server_state *ss = &server; + unsigned char code, id; + int len; + + if (pktlen < CHAP_HDRLEN) + return; + GETCHAR(code, pkt); + GETCHAR(id, pkt); + GETSHORT(len, pkt); + if (len < CHAP_HDRLEN || len > pktlen) + return; + len -= CHAP_HDRLEN; + + switch (code) { + case CHAP_CHALLENGE: + chap_respond(cs, id, pkt, len); + break; + case CHAP_RESPONSE: + chap_handle_response(ss, id, pkt, len); + break; + case CHAP_FAILURE: + case CHAP_SUCCESS: + chap_handle_status(cs, code, id, pkt, len); + break; + } +} + +static void +chap_protrej(int unit) +{ + struct chap_client_state *cs = &client; + struct chap_server_state *ss = &server; + + if (ss->flags & TIMEOUT_PENDING) { + ss->flags &= ~TIMEOUT_PENDING; + UNTIMEOUT(chap_timeout, ss); + } + if (ss->flags & AUTH_STARTED) { + ss->flags = 0; + auth_peer_fail(0, PPP_CHAP); + } + if ((cs->flags & (AUTH_STARTED|AUTH_DONE)) == AUTH_STARTED) { + cs->flags &= ~AUTH_STARTED; + auth_withpeer_fail(0, PPP_CHAP); + } +} + +/* + * chap_print_pkt - print the contents of a CHAP packet. + */ +static char *chap_code_names[] = { + "Challenge", "Response", "Success", "Failure" +}; + +static int +chap_print_pkt(unsigned char *p, int plen, + void (*printer) __P((void *, char *, ...)), void *arg) +{ + int code, id, len; + int clen, nlen; + unsigned char x; + + if (plen < CHAP_HDRLEN) + return 0; + GETCHAR(code, p); + GETCHAR(id, p); + GETSHORT(len, p); + if (len < CHAP_HDRLEN || len > plen) + return 0; + + if (code >= 1 && code <= sizeof(chap_code_names) / sizeof(char *)) + printer(arg, " %s", chap_code_names[code-1]); + else + printer(arg, " code=0x%x", code); + printer(arg, " id=0x%x", id); + len -= CHAP_HDRLEN; + switch (code) { + case CHAP_CHALLENGE: + case CHAP_RESPONSE: + if (len < 1) + break; + clen = p[0]; + if (len < clen + 1) + break; + ++p; + nlen = len - clen - 1; + printer(arg, " <"); + for (; clen > 0; --clen) { + GETCHAR(x, p); + printer(arg, "%.2x", x); + } + printer(arg, ">, name = "); + print_string((char *)p, nlen, printer, arg); + break; + case CHAP_FAILURE: + case CHAP_SUCCESS: + printer(arg, " "); + print_string((char *)p, len, printer, arg); + break; + default: + for (clen = len; clen > 0; --clen) { + GETCHAR(x, p); + printer(arg, " %.2x", x); + } + } + + return len + CHAP_HDRLEN; +} + +struct protent chap_protent = { + PPP_CHAP, + chap_init, + chap_input, + chap_protrej, + chap_lowerup, + chap_lowerdown, + NULL, /* open */ + NULL, /* close */ + chap_print_pkt, + NULL, /* datainput */ + 1, /* enabled_flag */ + "CHAP", /* name */ + NULL, /* data_name */ + chap_option_list, + NULL, /* check_options */ +}; diff --git a/pppd/chap-new.h b/pppd/chap-new.h new file mode 100644 index 0000000..141667b --- /dev/null +++ b/pppd/chap-new.h @@ -0,0 +1,138 @@ +/* + * chap-new.c - New CHAP implementation. + * + * Copyright (c) 2003 Paul Mackerras. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * CHAP packets begin with a standard header with code, id, len (2 bytes). + */ +#define CHAP_HDRLEN 4 + +/* + * Values for the code field. + */ +#define CHAP_CHALLENGE 1 +#define CHAP_RESPONSE 2 +#define CHAP_SUCCESS 3 +#define CHAP_FAILURE 4 + +/* + * CHAP digest codes. + */ +#define CHAP_MD5 5 +#define CHAP_MICROSOFT 0x80 +#define CHAP_MICROSOFT_V2 0x81 + +/* + * Semi-arbitrary limits on challenge and response fields. + */ +#define MAX_CHALLENGE_LEN 64 +#define MAX_RESPONSE_LEN 64 + +/* bitmask of supported algorithms */ +#define MDTYPE_MICROSOFT_V2 0x1 +#define MDTYPE_MICROSOFT 0x2 +#define MDTYPE_MD5 0x4 + +#ifdef CHAPMS +#define MDTYPE_ALL (MDTYPE_MICROSOFT_V2 | MDTYPE_MICROSOFT | MDTYPE_MD5) +#else +#define MDTYPE_ALL (MDTYPE_MD5) +#endif +#define MDTYPE_NONE 0 + +/* Return the digest alg. ID for the most preferred digest type. */ +#define CHAP_DIGEST(mdtype) \ + ((mdtype) & MDTYPE_MICROSOFT_V2)? CHAP_MICROSOFT_V2: \ + ((mdtype) & MDTYPE_MICROSOFT)? CHAP_MICROSOFT: \ + ((mdtype) & MDTYPE_MD5)? CHAP_MD5: \ + 0 + +/* Return the bit flag (lsb set) for our most preferred digest type. */ +#define CHAP_MDTYPE(mdtype) ((mdtype) ^ ((mdtype) - 1)) & (mdtype) + +/* Return the bit flag for a given digest algorithm ID. */ +#define CHAP_MDTYPE_D(digest) \ + ((digest) == CHAP_MICROSOFT_V2)? MDTYPE_MICROSOFT_V2: \ + ((digest) == CHAP_MICROSOFT)? MDTYPE_MICROSOFT: \ + ((digest) == CHAP_MD5)? MDTYPE_MD5: \ + 0 + +/* Can we do the requested digest? */ +#define CHAP_CANDIGEST(mdtype, digest) \ + ((digest) == CHAP_MICROSOFT_V2)? (mdtype) & MDTYPE_MICROSOFT_V2: \ + ((digest) == CHAP_MICROSOFT)? (mdtype) & MDTYPE_MICROSOFT: \ + ((digest) == CHAP_MD5)? (mdtype) & MDTYPE_MD5: \ + 0 + +/* + * The code for each digest type has to supply one of these. + */ +struct chap_digest_type { + int code; + + /* + * Note: challenge and response arguments below are formatted as + * a length byte followed by the actual challenge/response data. + */ + void (*generate_challenge)(unsigned char *challenge); + int (*verify_response)(int id, char *name, + unsigned char *secret, int secret_len, + unsigned char *challenge, unsigned char *response, + char *message, int message_space); + void (*make_response)(unsigned char *response, int id, char *our_name, + unsigned char *challenge, char *secret, int secret_len, + unsigned char *priv); + int (*check_success)(unsigned char *pkt, int len, unsigned char *priv); + void (*handle_failure)(unsigned char *pkt, int len); + + struct chap_digest_type *next; +}; + +/* Hook for a plugin to validate CHAP challenge */ +extern int (*chap_verify_hook)(char *name, char *ourname, int id, + struct chap_digest_type *digest, + unsigned char *challenge, unsigned char *response, + unsigned char *message, int message_space); + +/* Called by digest code to register a digest type */ +extern void chap_register_digest(struct chap_digest_type *); + +/* Called by authentication code to start authenticating the peer. */ +extern void chap_auth_peer(int unit, char *our_name, int digest_code); + +/* Called by auth. code to start authenticating us to the peer. */ +extern void chap_auth_with_peer(int unit, char *our_name, int digest_code); + +/* Represents the CHAP protocol to the main pppd code */ +extern struct protent chap_protent; diff --git a/pppd/chap_ms.c b/pppd/chap_ms.c index 69b2982..a489cc0 100644 --- a/pppd/chap_ms.c +++ b/pppd/chap_ms.c @@ -74,7 +74,7 @@ * */ -#define RCSID "$Id: chap_ms.c,v 1.28 2003/01/10 07:12:36 fcusack Exp $" +#define RCSID "$Id: chap_ms.c,v 1.29 2003/06/11 23:56:26 paulus Exp $" #ifdef CHAPMS @@ -87,11 +87,12 @@ #include #include "pppd.h" -#include "chap.h" +#include "chap-new.h" #include "chap_ms.h" #include "md4.h" #include "sha1.h" #include "pppcrypt.h" +#include "magic.h" static const char rcsid[] = RCSID; @@ -115,8 +116,6 @@ static void Set_Start_Key __P((u_char *, char *, int)); static void SetMasterKeys __P((char *, int, u_char[24], int)); #endif -extern double drand48 __P((void)); - #ifdef MSLANMAN bool ms_lanman = 0; /* Use LanMan password instead of NT */ /* Has meaning only with MS-CHAP challenges */ @@ -127,11 +126,309 @@ u_char mppe_send_key[MPPE_MAX_KEY_LEN]; u_char mppe_recv_key[MPPE_MAX_KEY_LEN]; int mppe_keys_set = 0; /* Have the MPPE keys been set? */ +/* For MPPE debug */ +/* Use "[]|}{?/><,`!2&&(" (sans quotes) for RFC 3079 MS-CHAPv2 test value */ +static char *mschap_challenge = NULL; +/* Use "!@\#$%^&*()_+:3|~" (sans quotes, backslash is to escape #) for ... */ +static char *mschap2_peer_challenge = NULL; + #include "fsm.h" /* Need to poke MPPE options */ #include "ccp.h" #include #endif +/* + * Command-line options. + */ +static option_t chapms_option_list[] = { +#ifdef MSLANMAN + { "ms-lanman", o_bool, &ms_lanman, + "Use LanMan passwd when using MS-CHAP", 1 }, +#endif +#ifdef DEBUGMPPEKEY + { "mschap-challenge", o_string, &mschap_challenge, + "specify CHAP challenge" }, + { "mschap2-peer-challenge", o_string, &mschap2_peer_challenge, + "specify CHAP peer challenge" }, +#endif + { NULL } +}; + +/* + * chapms_generate_challenge - generate a challenge for MS-CHAP. + * For MS-CHAP the challenge length is fixed at 8 bytes. + * The length goes in challenge[0] and the actual challenge starts + * at challenge[1]. + */ +static void +chapms_generate_challenge(unsigned char *challenge) +{ + *challenge++ = 8; + if (mschap_challenge && strlen(mschap_challenge) == 8) + memcpy(challenge, mschap_challenge, 8); + else + random_bytes(challenge, 8); +} + +static void +chapms2_generate_challenge(unsigned char *challenge) +{ + *challenge++ = 16; + if (mschap_challenge && strlen(mschap_challenge) == 16) + memcpy(challenge, mschap_challenge, 16); + else + random_bytes(challenge, 16); +} + +static int +chapms_verify_response(int id, char *name, + unsigned char *secret, int secret_len, + unsigned char *challenge, unsigned char *response, + char *message, int message_space) +{ + MS_ChapResponse *rmd = (MS_ChapResponse *) response; + MS_ChapResponse md; + int diff; + int challenge_len, response_len; + + challenge_len = *challenge++; /* skip length, is 8 */ + + response_len = *response++; + if (response_len != MS_CHAP_RESPONSE_LEN) + goto bad; + +#ifndef MSLANMAN + if (!rmd->UseNT[0]) { + /* Should really propagate this into the error packet. */ + notice("Peer request for LANMAN auth not supported"); + goto bad; + } +#endif + + /* Generate the expected response. */ + ChapMS(challenge, secret, secret_len, &md); + +#ifdef MSLANMAN + /* Determine which part of response to verify against */ + if (!rmd->UseNT[0]) + diff = memcmp(&rmd->LANManResp, &md.LANManResp, + sizeof(md.LANManResp)); + else +#endif + diff = memcmp(&rmd->NTResp, &md.NTResp, sizeof(md.NTResp)); + + if (diff == 0) { + slprintf(message, message_space, "Access granted"); + return 1; + } + + bad: + /* See comments below for MS-CHAP V2 */ + slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0", + challenge_len, challenge); + return 0; +} + +static int +chapms2_verify_response(int id, char *name, + unsigned char *secret, int secret_len, + unsigned char *challenge, unsigned char *response, + char *message, int message_space) +{ + MS_Chap2Response *rmd = (MS_Chap2Response *) response; + MS_Chap2Response md; + char saresponse[MS_AUTH_RESPONSE_LENGTH+1]; + int challenge_len, response_len; + + challenge_len = *challenge++; /* skip length, is 16 */ + response_len = *response++; + if (response_len != MS_CHAP2_RESPONSE_LEN) + goto bad; /* not even the right length */ + + /* Generate the expected response and our mutual auth. */ + ChapMS2(challenge, rmd->PeerChallenge, name, + secret, secret_len, &md, + saresponse, MS_CHAP2_AUTHENTICATOR); + + /* compare MDs and send the appropriate status */ + /* + * Per RFC 2759, success message must be formatted as + * "S= M=" + * where + * is the Authenticator Response (mutual auth) + * is a text message + * + * However, some versions of Windows (win98 tested) do not know + * about the M= part (required per RFC 2759) and flag + * it as an error (reported incorrectly as an encryption error + * to the user). Since the RFC requires it, and it can be + * useful information, we supply it if the peer is a conforming + * system. Luckily (?), win98 sets the Flags field to 0x04 + * (contrary to RFC requirements) so we can use that to + * distinguish between conforming and non-conforming systems. + * + * Special thanks to Alex Swiridov for + * help debugging this. + */ + if (memcmp(md.NTResp, rmd->NTResp, sizeof(md.NTResp)) == 0) { + if (rmd->Flags[0]) + slprintf(message, message_space, "S=%s", saresponse); + else + slprintf(message, message_space, "S=%s M=%s", + saresponse, "Access granted"); + return 1; + } + + bad: + /* + * Failure message must be formatted as + * "E=e R=r C=c V=v M=m" + * where + * e = error code (we use 691, ERROR_AUTHENTICATION_FAILURE) + * r = retry (we use 1, ok to retry) + * c = challenge to use for next response, we reuse previous + * v = Change Password version supported, we use 0 + * m = text message + * + * The M=m part is only for MS-CHAPv2. Neither win2k nor + * win98 (others untested) display the message to the user anyway. + * They also both ignore the E=e code. + * + * Note that it's safe to reuse the same challenge as we don't + * actually accept another response based on the error message + * (and no clients try to resend a response anyway). + * + * Basically, this whole bit is useless code, even the small + * implementation here is only because of overspecification. + */ + slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0 M=%s", + challenge_len, challenge, "Access denied"); + return 0; +} + +static void +chapms_make_response(unsigned char *response, int id, char *our_name, + unsigned char *challenge, char *secret, int secret_len, + unsigned char *private) +{ + challenge++; /* skip length, should be 8 */ + *response++ = MS_CHAP_RESPONSE_LEN; + ChapMS(challenge, secret, secret_len, (MS_ChapResponse *) response); +} + +static void +chapms2_make_response(unsigned char *response, int id, char *our_name, + unsigned char *challenge, char *secret, int secret_len, + unsigned char *private) +{ + challenge++; /* skip length, should be 16 */ + *response++ = MS_CHAP2_RESPONSE_LEN; + ChapMS2(challenge, mschap2_peer_challenge, our_name, + secret, secret_len, + (MS_Chap2Response *) response, private, + MS_CHAP2_AUTHENTICATEE); +} + +static int +chapms2_check_success(unsigned char *msg, int len, unsigned char *private) +{ + if ((len < MS_AUTH_RESPONSE_LENGTH + 2) || strncmp(msg, "S=", 2)) { + /* Packet does not start with "S=" */ + error("MS-CHAPv2 Success packet is badly formed."); + return 0; + } + msg += 2; + len -= 2; + if (len < MS_AUTH_RESPONSE_LENGTH + || memcmp(msg, private, MS_AUTH_RESPONSE_LENGTH)) { + /* Authenticator Response did not match expected. */ + error("MS-CHAPv2 mutual authentication failed."); + return 0; + } + /* Authenticator Response matches. */ + msg += MS_AUTH_RESPONSE_LENGTH; /* Eat it */ + len -= MS_AUTH_RESPONSE_LENGTH; + if ((len >= 3) && !strncmp(msg, " M=", 3)) { + msg += 3; /* Eat the delimiter */ + } else if (len) { + /* Packet has extra text which does not begin " M=" */ + error("MS-CHAPv2 Success packet is badly formed."); + return 0; + } + return 1; +} + +static void +chapms_handle_failure(unsigned char *inp, int len) +{ + int err; + char *p, *msg; + + /* We want a null-terminated string for strxxx(). */ + msg = malloc(len + 1); + if (!msg) { + notice("Out of memory in chapms_handle_failure"); + return; + } + BCOPY(inp, msg, len); + msg[len] = 0; + p = msg; + + /* + * Deal with MS-CHAP formatted failure messages; just print the + * M= part (if any). For MS-CHAP we're not really supposed + * to use M=, but it shouldn't hurt. See + * chapms[2]_verify_response. + */ + if (!strncmp(p, "E=", 2)) + err = strtol(p, NULL, 10); /* Remember the error code. */ + else + goto print_msg; /* Message is badly formatted. */ + + if (len && ((p = strstr(p, " M=")) != NULL)) { + /* M= field found. */ + p += 3; + } else { + /* No M=; use the error code. */ + switch (err) { + case MS_CHAP_ERROR_RESTRICTED_LOGON_HOURS: + p = "E=646 Restricted logon hours"; + break; + + case MS_CHAP_ERROR_ACCT_DISABLED: + p = "E=647 Account disabled"; + break; + + case MS_CHAP_ERROR_PASSWD_EXPIRED: + p = "E=648 Password expired"; + break; + + case MS_CHAP_ERROR_NO_DIALIN_PERMISSION: + p = "E=649 No dialin permission"; + break; + + case MS_CHAP_ERROR_AUTHENTICATION_FAILURE: + p = "E=691 Authentication failure"; + break; + + case MS_CHAP_ERROR_CHANGING_PASSWORD: + /* Should never see this, we don't support Change Password. */ + p = "E=709 Error changing password"; + break; + + default: + free(msg); + error("Unknown MS-CHAP authentication failure: %.*v", + len, inp); + return; + } + } +print_msg: + if (p != NULL) + error("MS-CHAP authentication failed: %v", p); + free(msg); +} + static void ChallengeResponse(u_char *challenge, u_char PasswordHash[MD4_SIGNATURE_SIZE], @@ -469,7 +766,7 @@ SetMasterKeys(char *secret, int secret_len, u_char NTResponse[24], int IsServer) void -ChapMS(chap_state *cstate, u_char *rchallenge, char *secret, int secret_len, +ChapMS(u_char *rchallenge, char *secret, int secret_len, MS_ChapResponse *response) { #if 0 @@ -488,8 +785,6 @@ ChapMS(chap_state *cstate, u_char *rchallenge, char *secret, int secret_len, response->UseNT[0] = 1; #endif - cstate->resp_length = MS_CHAP_RESPONSE_LEN; - #ifdef MPPE Set_Start_Key(rchallenge, secret, secret_len); mppe_keys_set = 1; @@ -508,9 +803,9 @@ ChapMS(chap_state *cstate, u_char *rchallenge, char *secret, int secret_len, * Authenticator Response. */ void -ChapMS2(chap_state *cstate, u_char *rchallenge, u_char *PeerChallenge, +ChapMS2(u_char *rchallenge, u_char *PeerChallenge, char *user, char *secret, int secret_len, MS_Chap2Response *response, - u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1], int authenticator) + u_char authResponse[], int authenticator) { /* ARGSUSED */ u_char *p = response->PeerChallenge; @@ -535,8 +830,6 @@ ChapMS2(chap_state *cstate, u_char *rchallenge, u_char *PeerChallenge, response->PeerChallenge, rchallenge, user, authResponse); - cstate->resp_length = MS_CHAP2_RESPONSE_LEN; - #ifdef MPPE SetMasterKeys(secret, secret_len, response->NTResp, authenticator); mppe_keys_set = 1; @@ -576,4 +869,30 @@ set_mppe_enc_types(int policy, int types) } #endif /* MPPE */ +static struct chap_digest_type chapms_digest = { + CHAP_MICROSOFT, /* code */ + chapms_generate_challenge, + chapms_verify_response, + chapms_make_response, + NULL, /* check_success */ + chapms_handle_failure, +}; + +static struct chap_digest_type chapms2_digest = { + CHAP_MICROSOFT_V2, /* code */ + chapms2_generate_challenge, + chapms2_verify_response, + chapms2_make_response, + chapms2_check_success, + chapms_handle_failure, +}; + +void +chapms_init(void) +{ + chap_register_digest(&chapms_digest); + chap_register_digest(&chapms2_digest); + add_options(chapms_option_list); +} + #endif /* CHAPMS */ diff --git a/pppd/chap_ms.h b/pppd/chap_ms.h index 251a4ba..4e2ac11 100644 --- a/pppd/chap_ms.h +++ b/pppd/chap_ms.h @@ -27,7 +27,7 @@ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * - * $Id: chap_ms.h,v 1.9 2002/12/24 03:43:35 fcusack Exp $ + * $Id: chap_ms.h,v 1.10 2003/06/11 23:56:26 paulus Exp $ */ #ifndef __CHAPMS_INCLUDE__ @@ -37,6 +37,8 @@ #define MS_CHAP_RESPONSE_LEN 49 /* Response length for MS-CHAP */ #define MS_CHAP2_RESPONSE_LEN 49 /* Response length for MS-CHAPv2 */ +#define MS_AUTH_RESPONSE_LENGTH 40 /* MS-CHAPv2 authenticator response, */ + /* as ASCII */ /* E=eeeeeeeeee error codes for MS-CHAP failure messages. */ #define MS_CHAP_ERROR_RESTRICTED_LOGON_HOURS 646 @@ -87,13 +89,14 @@ extern void set_mppe_enc_types(int, int); #define MS_CHAP2_AUTHENTICATEE 0 #define MS_CHAP2_AUTHENTICATOR 1 -#include "chap.h" /* chap_state, et al */ -void ChapMS __P((chap_state *, u_char *, char *, int, MS_ChapResponse *)); -void ChapMS2 __P((chap_state *, u_char *, u_char *, char *, char *, int, +void ChapMS __P((u_char *, char *, int, MS_ChapResponse *)); +void ChapMS2 __P((u_char *, u_char *, char *, char *, int, MS_Chap2Response *, u_char[MS_AUTH_RESPONSE_LENGTH+1], int)); #ifdef MPPE void mppe_set_keys __P((u_char *, u_char[MD4_SIGNATURE_SIZE])); #endif +void chapms_init(void); + #define __CHAPMS_INCLUDE__ #endif /* __CHAPMS_INCLUDE__ */ diff --git a/pppd/eap.c b/pppd/eap.c index 8c22838..6a50a59 100644 --- a/pppd/eap.c +++ b/pppd/eap.c @@ -43,7 +43,7 @@ * Based on draft-ietf-pppext-eap-srp-03.txt. */ -#define RCSID "$Id: eap.c,v 1.2 2002/11/14 21:50:12 fcusack Exp $" +#define RCSID "$Id: eap.c,v 1.3 2003/06/11 23:56:26 paulus Exp $" /* * TODO: @@ -63,8 +63,6 @@ #include "pppd.h" #include "pathnames.h" #include "md5.h" -/* For MD5_SIGNATURE_SIZE and MIN/MAX_CHALLENGE_LENGTH; should fix. */ -#include "chap.h" #include "eap.h" #ifdef USE_SRP diff --git a/pppd/eap.h b/pppd/eap.h index cf5adac..199d184 100644 --- a/pppd/eap.h +++ b/pppd/eap.h @@ -17,7 +17,7 @@ * * Original version by James Carlson * - * $Id: eap.h,v 1.1 2002/11/02 19:48:12 carlsonj Exp $ + * $Id: eap.h,v 1.2 2003/06/11 23:56:26 paulus Exp $ */ #ifndef PPP_EAP_H @@ -74,6 +74,10 @@ extern "C" { #define SRP_PSEUDO_ID "pseudo_" #define SRP_PSEUDO_LEN 7 +#define MD5_SIGNATURE_SIZE 16 +#define MIN_CHALLENGE_LENGTH 16 +#define MAX_CHALLENGE_LENGTH 24 + enum eap_state_code { eapInitial = 0, /* No EAP authentication yet requested */ eapPending, /* Waiting for LCP (no timer) */ diff --git a/pppd/lcp.c b/pppd/lcp.c index cf2f46d..88f43db 100644 --- a/pppd/lcp.c +++ b/pppd/lcp.c @@ -40,7 +40,7 @@ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#define RCSID "$Id: lcp.c,v 1.68 2003/06/11 23:50:53 paulus Exp $" +#define RCSID "$Id: lcp.c,v 1.69 2003/06/11 23:56:26 paulus Exp $" /* * TODO: @@ -53,7 +53,7 @@ #include "pppd.h" #include "fsm.h" #include "lcp.h" -#include "chap.h" +#include "chap-new.h" #include "magic.h" static const char rcsid[] = RCSID; @@ -2038,7 +2038,7 @@ lcp_printpkt(p, plen, printer, arg) printer(arg, "chap"); if (p < optend) { switch (*p) { - case CHAP_DIGEST_MD5: + case CHAP_MD5: printer(arg, " MD5"); ++p; break; diff --git a/pppd/magic.c b/pppd/magic.c index 2e0426c..2fb23ff 100644 --- a/pppd/magic.c +++ b/pppd/magic.c @@ -40,9 +40,10 @@ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#define RCSID "$Id: magic.c,v 1.10 2002/12/04 23:03:32 paulus Exp $" +#define RCSID "$Id: magic.c,v 1.11 2003/06/11 23:56:26 paulus Exp $" #include +#include #include #include #include @@ -82,6 +83,18 @@ magic() return (u_int32_t) mrand48(); } +/* + * random_bytes - Fill a buffer with random bytes. + */ +void +random_bytes(unsigned char *buf, int len) +{ + int i; + + for (i = 0; i < len; ++i) + buf[i] = mrand48() >> 24; +} + #ifdef NO_DRAND48 /* * Substitute procedures for those systems which don't have diff --git a/pppd/magic.h b/pppd/magic.h index 38718fb..c81213b 100644 --- a/pppd/magic.h +++ b/pppd/magic.h @@ -39,8 +39,11 @@ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * - * $Id: magic.h,v 1.4 2002/12/04 23:03:32 paulus Exp $ + * $Id: magic.h,v 1.5 2003/06/11 23:56:26 paulus Exp $ */ void magic_init __P((void)); /* Initialize the magic number generator */ u_int32_t magic __P((void)); /* Returns the next magic number */ + +/* Fill buffer with random bytes */ +void random_bytes __P((unsigned char *buf, int len)); diff --git a/pppd/main.c b/pppd/main.c index 8511503..640782a 100644 --- a/pppd/main.c +++ b/pppd/main.c @@ -40,7 +40,7 @@ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#define RCSID "$Id: main.c,v 1.127 2003/05/12 07:31:36 fcusack Exp $" +#define RCSID "$Id: main.c,v 1.128 2003/06/11 23:56:26 paulus Exp $" #include #include @@ -74,7 +74,7 @@ #include "ipv6cp.h" #endif #include "upap.h" -#include "chap.h" +#include "chap-new.h" #include "eap.h" #include "ccp.h" #include "ecp.h" -- 2.39.2