* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
-#define RCSID "$Id: auth.c,v 1.69 2001/03/12 22:50:01 paulus Exp $"
+#define RCSID "$Id: auth.c,v 1.83 2002/09/15 12:51:05 paulus Exp $"
#include <stdio.h>
#include <stddef.h>
#define PW_PPP PW_LOGIN
#endif
#endif
+#include <time.h>
#include "pppd.h"
#include "fsm.h"
#include "lcp.h"
+#include "ccp.h"
+#include "ecp.h"
#include "ipcp.h"
#include "upap.h"
#include "chap.h"
/* Records which authentication operations haven't completed yet. */
static int auth_pending[NUM_PPP];
+/* Records which authentication operations have been completed. */
+int auth_done[NUM_PPP];
+
/* Set if we have successfully called plogin() */
static int logged_in;
/* 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 whether it is OK if the peer
+ refuses to authenticate. */
+int (*null_auth_hook) __P((struct wordlist **paddrs,
+ struct wordlist **popts)) = NULL;
+
+int (*allowed_address_hook) __P((u_int32_t addr)) = NULL;
+
+/* A notifier for when the peer has authenticated itself,
+ and we are proceeding to the network phase. */
+struct notifier *auth_up_notifier = NULL;
+
+/* A notifier for when the link goes down. */
+struct notifier *link_down_notifier = NULL;
+
/*
* This is used to ensure that we don't start an auth-up/down
* script while one is already running.
bool cryptpap = 0; /* Passwords in pap-secrets are encrypted */
bool refuse_pap = 0; /* Don't wanna auth. ourselves with PAP */
bool refuse_chap = 0; /* Don't wanna auth. ourselves with CHAP */
+#ifdef CHAPMS
+bool refuse_mschap = 0; /* Don't wanna auth. ourselves with MS-CHAP */
+bool refuse_mschap_v2 = 0; /* Don't wanna auth. ourselves with MS-CHAPv2 */
+#else
+bool refuse_mschap = 1; /* Don't wanna auth. ourselves with MS-CHAP */
+bool refuse_mschap_v2 = 1; /* Don't wanna auth. ourselves with MS-CHAPv2 */
+#endif
bool usehostname = 0; /* Use hostname for our_name */
bool auth_required = 0; /* Always require authentication from peer */
bool allow_any_ip = 0; /* Allow peer to use any IP address */
static char *uafname; /* name of most recent +ua file */
-/* Bits in auth_pending[] */
-#define PAP_WITHPEER 1
-#define PAP_PEER 2
-#define CHAP_WITHPEER 4
-#define CHAP_PEER 8
-
extern char *crypt __P((const char *, const char *));
/* Prototypes for procedures local to this file. */
static void check_access __P((FILE *, char *));
static int wordlist_count __P((struct wordlist *));
+#ifdef MAXOCTETS
+static void check_maxoctets __P((void *));
+#endif
+
/*
* Authentication-related options.
*/
OPT_ALIAS | OPT_PRIOSUB | 1, &auth_required },
{ "require-chap", o_bool, &lcp_wantoptions[0].neg_chap,
"Require CHAP authentication from peer",
- OPT_PRIOSUB | 1, &auth_required },
+ OPT_PRIOSUB | OPT_A2COPY | OPT_A3OR | MDTYPE_MD5,
+ &auth_required, 0, 0, NULL, 0, 0, &lcp_wantoptions[0].chap_mdtype },
{ "+chap", o_bool, &lcp_wantoptions[0].neg_chap,
"Require CHAP authentication from peer",
- OPT_ALIAS | OPT_PRIOSUB | 1, &auth_required },
+ OPT_ALIAS | OPT_PRIOSUB | OPT_A2COPY | OPT_A3OR | MDTYPE_MD5,
+ &auth_required, 0, 0, NULL, 0, 0, &lcp_wantoptions[0].chap_mdtype },
+#ifdef CHAPMS
+ { "require-mschap", o_bool, &lcp_wantoptions[0].neg_chap,
+ "Require MS-CHAP authentication from peer",
+ OPT_PRIOSUB | OPT_A2COPY | OPT_A3OR | MDTYPE_MICROSOFT,
+ &auth_required, 0, 0, NULL, 0, 0, &lcp_wantoptions[0].chap_mdtype },
+ { "+mschap", o_bool, &lcp_wantoptions[0].neg_chap,
+ "Require MS-CHAP authentication from peer",
+ OPT_ALIAS | OPT_PRIOSUB | OPT_A2COPY | OPT_A3OR | MDTYPE_MICROSOFT,
+ &auth_required, 0, 0, NULL, 0, 0, &lcp_wantoptions[0].chap_mdtype },
+ { "require-mschap-v2", o_bool, &lcp_wantoptions[0].neg_chap,
+ "Require MS-CHAPv2 authentication from peer",
+ OPT_PRIOSUB | OPT_A2COPY | OPT_A3OR | MDTYPE_MICROSOFT_V2,
+ &auth_required, 0, 0, NULL, 0, 0, &lcp_wantoptions[0].chap_mdtype },
+ { "+mschap-v2", o_bool, &lcp_wantoptions[0].neg_chap,
+ "Require MS-CHAPv2 authentication from peer",
+ OPT_ALIAS | OPT_PRIOSUB | OPT_A2COPY | OPT_A3OR | MDTYPE_MICROSOFT_V2,
+ &auth_required, 0, 0, NULL, 0, 0, &lcp_wantoptions[0].chap_mdtype },
+#endif
{ "refuse-pap", o_bool, &refuse_pap,
"Don't agree to auth to peer with PAP", 1 },
{ "-pap", o_bool, &refuse_pap,
"Don't allow PAP authentication with peer", OPT_ALIAS | 1 },
-
{ "refuse-chap", o_bool, &refuse_chap,
- "Don't agree to auth to peer with CHAP", 1 },
+ "Don't agree to auth to peer with CHAP", OPT_A2CLRB | MDTYPE_MD5,
+ &lcp_allowoptions[0].chap_mdtype },
{ "-chap", o_bool, &refuse_chap,
- "Don't allow CHAP authentication with peer", OPT_ALIAS | 1 },
+ "Don't allow CHAP authentication with peer",
+ OPT_ALIAS | OPT_A2CLRB | MDTYPE_MD5,
+ &lcp_allowoptions[0].chap_mdtype },
+#ifdef CHAPMS
+ { "refuse-mschap", o_bool, &refuse_mschap,
+ "Don't agree to auth to peer with MS-CHAP",
+ OPT_A2CLRB | MDTYPE_MICROSOFT, &lcp_allowoptions[0].chap_mdtype },
+ { "-mschap", o_bool, &refuse_mschap,
+ "Don't allow MS-CHAP authentication with peer",
+ OPT_ALIAS | OPT_A2CLRB | MDTYPE_MICROSOFT,
+ &lcp_allowoptions[0].chap_mdtype },
+ { "refuse-mschap-v2", o_bool, &refuse_mschap_v2,
+ "Don't agree to auth to peer with MS-CHAPv2",
+ OPT_A2CLRB | MDTYPE_MICROSOFT_V2, &lcp_allowoptions[0].chap_mdtype },
+ { "-mschap-v2", o_bool, &refuse_mschap_v2,
+ "Don't allow MS-CHAPv2 authentication with peer",
+ OPT_ALIAS | OPT_A2CLRB | MDTYPE_MICROSOFT_V2,
+ &lcp_allowoptions[0].chap_mdtype },
+#endif
{ "name", o_string, our_name,
"Set local name for authentication",
int i;
struct protent *protp;
+ notify(link_down_notifier, 0);
auth_state = s_down;
if (auth_script_state == s_up && auth_script_pid == 0) {
update_link_stats(unit);
num_np_open = 0;
num_np_up = 0;
if (phase != PHASE_DEAD)
- new_phase(PHASE_TERMINATE);
+ new_phase(PHASE_ESTABLISH);
}
/*
&& protp->lowerup != NULL)
(*protp->lowerup)(unit);
- if (auth_required && !(go->neg_chap || go->neg_upap)) {
+ if (auth_required && !(go->neg_upap || go->neg_chap)) {
/*
* We wanted the peer to authenticate itself, and it refused:
* if we have some address(es) it can use without auth, fine,
* otherwise treat it as though it authenticated with PAP using
- * a username * of "" and a password of "". If that's not OK,
+ * a username of "" and a password of "". If that's not OK,
* boot it out.
*/
if (noauth_addrs != NULL) {
used_login = 0;
auth = 0;
if (go->neg_chap) {
- ChapAuthPeer(unit, our_name, go->chap_mdtype);
+ ChapAuthPeer(unit, our_name, CHAP_DIGEST(go->chap_mdtype));
auth |= CHAP_PEER;
} else if (go->neg_upap) {
upap_authpeer(unit);
auth |= PAP_PEER;
}
if (ho->neg_chap) {
- ChapAuthWithPeer(unit, user, ho->chap_mdtype);
+ ChapAuthWithPeer(unit, user, CHAP_DIGEST(ho->chap_mdtype));
auth |= CHAP_WITHPEER;
} else if (ho->neg_upap) {
if (passwd[0] == 0) {
auth |= PAP_WITHPEER;
}
auth_pending[unit] = auth;
+ auth_done[unit] = 0;
if (!auth)
network_phase(unit);
* If the peer had to authenticate, run the auth-up script now.
*/
if (go->neg_chap || go->neg_upap) {
+ notify(auth_up_notifier, 0);
auth_state = s_up;
if (auth_script_state == s_down && auth_script_pid == 0) {
auth_script_state = s_up;
free_wordlist(extra_options);
extra_options = 0;
}
- start_networks();
+ start_networks(unit);
}
void
-start_networks()
+start_networks(unit)
+ int unit;
{
int i;
struct protent *protp;
+ int ecp_required, mppe_required;
new_phase(PHASE_NETWORK);
if (!demand)
set_filters(&pass_filter, &active_filter);
#endif
+ /* Start CCP and ECP */
+ for (i = 0; (protp = protocols[i]) != NULL; ++i)
+ if ((protp->protocol == PPP_ECP || protp->protocol == PPP_CCP)
+ && protp->enabled_flag && protp->open != NULL)
+ (*protp->open)(0);
+
+ /*
+ * Bring up other network protocols iff encryption is not required.
+ */
+ ecp_required = ecp_gotoptions[unit].required;
+ mppe_required = ccp_gotoptions[unit].mppe;
+ if (!ecp_required && !mppe_required)
+ continue_networks(unit);
+}
+
+void
+continue_networks(unit)
+ int unit;
+{
+ int i;
+ struct protent *protp;
+
+ /*
+ * Start the "real" network protocols.
+ */
for (i = 0; (protp = protocols[i]) != NULL; ++i)
- if (protp->protocol < 0xC000 && protp->enabled_flag
- && protp->open != NULL) {
+ if (protp->protocol < 0xC000
+ && protp->protocol != PPP_CCP && protp->protocol != PPP_ECP
+ && protp->enabled_flag && protp->open != NULL) {
(*protp->open)(0);
- if (protp->protocol != PPP_CCP)
- ++num_np_open;
+ ++num_np_open;
}
if (num_np_open == 0)
* The peer has been successfully authenticated using `protocol'.
*/
void
-auth_peer_success(unit, protocol, name, namelen)
- int unit, protocol;
+auth_peer_success(unit, protocol, prot_flavor, name, namelen)
+ int unit, protocol, prot_flavor;
char *name;
int namelen;
{
switch (protocol) {
case PPP_CHAP:
bit = CHAP_PEER;
+ switch (prot_flavor) {
+ case CHAP_DIGEST_MD5:
+ bit |= CHAP_MD5_PEER;
+ break;
+#ifdef CHAPMS
+ case CHAP_MICROSOFT:
+ bit |= CHAP_MS_PEER;
+ break;
+ case CHAP_MICROSOFT_V2:
+ bit |= CHAP_MS2_PEER;
+ break;
+#endif
+ }
break;
case PPP_PAP:
bit = PAP_PEER;
peer_authname[namelen] = 0;
script_setenv("PEERNAME", peer_authname, 0);
+ /* Save the authentication method for later. */
+ auth_done[unit] |= bit;
+
/*
* If there is no more authentication still to be done,
* proceed to the network (or callback) phase.
* We have successfully authenticated ourselves with the peer using `protocol'.
*/
void
-auth_withpeer_success(unit, protocol)
- int unit, protocol;
+auth_withpeer_success(unit, protocol, prot_flavor)
+ int unit, protocol, prot_flavor;
{
int bit;
switch (protocol) {
case PPP_CHAP:
bit = CHAP_WITHPEER;
+ switch (prot_flavor) {
+ case CHAP_DIGEST_MD5:
+ bit |= CHAP_MD5_WITHPEER;
+ break;
+#ifdef CHAPMS
+ case CHAP_MICROSOFT:
+ bit |= CHAP_MS_WITHPEER;
+ break;
+ case CHAP_MICROSOFT_V2:
+ bit |= CHAP_MS2_WITHPEER;
+ break;
+#endif
+ }
break;
case PPP_PAP:
if (passwd_from_file)
bit = 0;
}
+ /* Save the authentication method for later. */
+ auth_done[unit] |= bit;
+
/*
* If there is no more authentication still being done,
* proceed to the network (or callback) phase.
if (maxconnect > 0)
TIMEOUT(connect_time_expired, 0, maxconnect);
+#ifdef MAXOCTETS
+ if (maxoctets > 0)
+ TIMEOUT(check_maxoctets, NULL, maxoctets_timeout);
+#endif
+
/*
* Detach now, if the updetach option was given.
*/
{
if (--num_np_up == 0) {
UNTIMEOUT(check_idle, NULL);
+ UNTIMEOUT(connect_time_expired, NULL);
+#ifdef MAXOCTETS
+ UNTIMEOUT(check_maxoctets, NULL);
+#endif
new_phase(PHASE_NETWORK);
}
}
}
}
+#ifdef MAXOCTETS
+static void
+check_maxoctets(arg)
+ void *arg;
+{
+ int diff;
+ unsigned int used;
+
+ update_link_stats(ifunit);
+ link_stats_valid=0;
+
+ switch(maxoctets_dir) {
+ case PPP_OCTETS_DIRECTION_IN:
+ used = link_stats.bytes_in;
+ break;
+ case PPP_OCTETS_DIRECTION_OUT:
+ used = link_stats.bytes_out;
+ break;
+ case PPP_OCTETS_DIRECTION_MAXOVERAL:
+ case PPP_OCTETS_DIRECTION_MAXSESSION:
+ used = (link_stats.bytes_in > link_stats.bytes_out) ? link_stats.bytes_in : link_stats.bytes_out;
+ break;
+ default:
+ used = link_stats.bytes_in+link_stats.bytes_out;
+ break;
+ }
+ diff = maxoctets - used;
+ if(diff < 0) {
+ notice("Traffic limit reached. Limit: %u Used: %u", maxoctets, used);
+ lcp_close(0, "Traffic limit");
+ need_holdoff = 0;
+ status = EXIT_TRAFFIC_LIMIT;
+ } else {
+ TIMEOUT(check_maxoctets, NULL, maxoctets_timeout);
+ }
+}
+#endif
+
/*
* check_idle - check whether the link has been idle for long
* enough that we can shut it down.
if (auth_required) {
allow_any_ip = 0;
if (!wo->neg_chap && !wo->neg_upap) {
- wo->neg_chap = 1;
+ wo->neg_chap = 1; wo->chap_mdtype = MDTYPE_ALL;
wo->neg_upap = 1;
}
} else {
- wo->neg_chap = 0;
+ wo->neg_chap = 0; wo->chap_mdtype = MDTYPE_NONE;
wo->neg_upap = 0;
}
*/
lacks_ip = 0;
can_auth = wo->neg_upap && (uselogin || have_pap_secret(&lacks_ip));
- if (!can_auth && wo->neg_chap) {
+ if (!can_auth && (wo->neg_chap)) {
can_auth = have_chap_secret((explicit_remote? remote_name: NULL),
our_name, 1, &lacks_ip);
}
lcp_options *ao = &lcp_allowoptions[0];
ao->neg_upap = !refuse_pap && (passwd[0] != 0 || get_pap_passwd(NULL));
- ao->neg_chap = !refuse_chap
+ ao->neg_chap = (!refuse_chap || !refuse_mschap || !refuse_mschap_v2)
&& (passwd[0] != 0
|| have_chap_secret(user, (explicit_remote? remote_name: NULL),
0, NULL));
BZERO(passwd, sizeof(passwd));
if (addrs != 0)
free_wordlist(addrs);
+ if (opts != 0) {
+ free_wordlist(opts);
+ }
return ret? UPAP_AUTHACK: UPAP_AUTHNAK;
}
}
if (pam_error == PAM_SUCCESS && !PAM_error) {
pam_error = pam_acct_mgmt (pamh, PAM_SILENT);
if (pam_error == PAM_SUCCESS)
- pam_open_session (pamh, PAM_SILENT);
+ pam_error = pam_open_session (pamh, PAM_SILENT);
}
*msg = (char *) pam_strerror (pamh, pam_error);
tty = devnam;
if (strncmp(tty, "/dev/", 5) == 0)
tty += 5;
- logwtmp(tty, user, remote_name); /* Add wtmp login entry */
+ logwtmp(tty, user, ifname); /* Add wtmp login entry */
#if defined(_PATH_LASTLOG) && !defined(USE_PAM)
if (pw != (struct passwd *)NULL) {
struct wordlist *addrs, *opts;
char secret[MAXWORDLEN];
+ /*
+ * Check if a plugin wants to handle this.
+ */
+ ret = -1;
+ if (null_auth_hook)
+ ret = (*null_auth_hook)(&addrs, &opts);
+
/*
* Open the file of pap secrets and scan for a suitable secret.
*/
- filename = _PATH_UPAPFILE;
- addrs = NULL;
- f = fopen(filename, "r");
- if (f == NULL)
- return 0;
- check_access(f, filename);
+ if (ret <= 0) {
+ filename = _PATH_UPAPFILE;
+ addrs = NULL;
+ f = fopen(filename, "r");
+ if (f == NULL)
+ return 0;
+ check_access(f, filename);
- i = scan_authfile(f, "", our_name, secret, &addrs, &opts, filename);
- ret = i >= 0 && secret[0] == 0;
- BZERO(secret, sizeof(secret));
+ i = scan_authfile(f, "", our_name, secret, &addrs, &opts, filename);
+ ret = i >= 0 && secret[0] == 0;
+ BZERO(secret, sizeof(secret));
+ fclose(f);
+ }
if (ret)
set_allowed_addrs(unit, addrs, opts);
if (addrs != 0)
free_wordlist(addrs);
- fclose(f);
return ret;
}
char *filename;
struct wordlist *addrs;
+ if (chap_check_hook) {
+ ret = (*chap_check_hook)();
+ if (ret >= 0) {
+ return ret;
+ }
+ }
+
filename = _PATH_CHAPFILE;
f = fopen(filename, "r");
if (f == NULL)
if (!am_server && passwd[0] != 0) {
strlcpy(secbuf, passwd, sizeof(secbuf));
+ } else if (!am_server && chap_passwd_hook) {
+ if ( (*chap_passwd_hook)(client, secbuf) < 0) {
+ error("Unable to obtain CHAP password for %s on %s from plugin",
+ client, server);
+ return 0;
+ }
} else {
filename = _PATH_CHAPFILE;
addrs = NULL;
if (bad_ip_adrs(addr))
return 0;
+ if (allowed_address_hook) {
+ ok = allowed_address_hook(addr);
+ if (ok >= 0) return ok;
+ }
+
if (addresses[unit] != NULL) {
ok = ip_addr_check(addr, addresses[unit]);
if (ok >= 0)
return ok;
}
+
if (auth_required)
return 0; /* no addresses authorized */
return allow_any_ip || privileged || !have_route_to(addr);