usr.sbin/ppp/auth.c

   1 /*-
   2  * Copyright (c) 1996 - 2001 Brian Somers <brian@Awfulhak.org>
   3  *          based on work by Toshiharu OHNO <tony-o@iij.ad.jp>
   4  *                           Internet Initiative Japan, Inc (IIJ)
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/usr.sbin/ppp/auth.c,v 1.50.2.2 2002/09/01 02:12:22 brian Exp $
  29  * $DragonFly: src/usr.sbin/ppp/auth.c,v 1.2 2003/06/17 04:30:00 dillon Exp $
  30  */
  31
  32 #include <sys/param.h>
  33 #include <netinet/in.h>
  34 #include <netinet/in_systm.h>
  35 #include <netinet/ip.h>
  36 #include <sys/socket.h>
  37 #include <sys/un.h>
  38
  39 #include <pwd.h>
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <termios.h>
  43 #include <unistd.h>
  44
  45 #include "layer.h"
  46 #include "mbuf.h"
  47 #include "defs.h"
  48 #include "log.h"
  49 #include "timer.h"
  50 #include "fsm.h"
  51 #include "iplist.h"
  52 #include "throughput.h"
  53 #include "slcompress.h"
  54 #include "lqr.h"
  55 #include "hdlc.h"
  56 #include "ncpaddr.h"
  57 #include "ipcp.h"
  58 #include "auth.h"
  59 #include "systems.h"
  60 #include "lcp.h"
  61 #include "ccp.h"
  62 #include "link.h"
  63 #include "descriptor.h"
  64 #include "chat.h"
  65 #include "proto.h"
  66 #include "filter.h"
  67 #include "mp.h"
  68 #ifndef NORADIUS
  69 #include "radius.h"
  70 #endif
  71 #include "cbcp.h"
  72 #include "chap.h"
  73 #include "async.h"
  74 #include "physical.h"
  75 #include "datalink.h"
  76 #include "ipv6cp.h"
  77 #include "ncp.h"
  78 #include "bundle.h"
  79
  80 const char *
  81 Auth2Nam(u_short auth, u_char type)
  82 {
  83   static char chap[10];
  84
  85   switch (auth) {
  86   case PROTO_PAP:
  87     return "PAP";
  88   case PROTO_CHAP:
  89     snprintf(chap, sizeof chap, "CHAP 0x%02x", type);
  90     return chap;
  91   case 0:
  92     return "none";
  93   }
  94   return "unknown";
  95 }
  96
  97 static int
  98 auth_CheckPasswd(const char *name, const char *data, const char *key)
  99 {
 100   if (!strcmp(data, "*")) {
 101     /* Then look up the real password database */
 102     struct passwd *pw;
 103     int result;
 104
 105     result = (pw = getpwnam(name)) &&
 106              !strcmp(crypt(key, pw->pw_passwd), pw->pw_passwd);
 107     endpwent();
 108     return result;
 109   }
 110
 111   return !strcmp(data, key);
 112 }
 113
 114 int
 115 auth_SetPhoneList(const char *name, char *phone, int phonelen)
 116 {
 117   FILE *fp;
 118   int n, lineno;
 119   char *vector[6], buff[LINE_LEN];
 120   const char *slash;
 121
 122   fp = OpenSecret(SECRETFILE);
 123   if (fp != NULL) {
 124 again:
 125     lineno = 0;
 126     while (fgets(buff, sizeof buff, fp)) {
 127       lineno++;
 128       if (buff[0] == '#')
 129         continue;
 130       buff[strlen(buff) - 1] = '\0';
 131       memset(vector, '\0', sizeof vector);
 132       if ((n = MakeArgs(buff, vector, VECSIZE(vector), PARSE_REDUCE)) < 0)
 133         log_Printf(LogWARN, "%s: %d: Invalid line\n", SECRETFILE, lineno);
 134       if (n < 5)
 135         continue;
 136       if (strcmp(vector[0], name) == 0) {
 137         CloseSecret(fp);
 138         if (*vector[4] == '\0')
 139           return 0;
 140         strncpy(phone, vector[4], phonelen - 1);
 141         phone[phonelen - 1] = '\0';
 142         return 1;               /* Valid */
 143       }
 144     }
 145
 146     if ((slash = strrchr(name, '\\')) != NULL && slash[1]) {
 147       /* Look for the name without the leading domain */
 148       name = slash + 1;
 149       rewind(fp);
 150       goto again;
 151     }
 152
 153     CloseSecret(fp);
 154   }
 155   *phone = '\0';
 156   return 0;
 157 }
 158
 159 int
 160 auth_Select(struct bundle *bundle, const char *name)
 161 {
 162   FILE *fp;
 163   int n, lineno;
 164   char *vector[5], buff[LINE_LEN];
 165   const char *slash;
 166
 167   if (*name == '\0') {
 168     ipcp_Setup(&bundle->ncp.ipcp, INADDR_NONE);
 169     return 1;
 170   }
 171
 172 #ifndef NORADIUS
 173   if (bundle->radius.valid && bundle->radius.ip.s_addr != INADDR_NONE &&
 174         bundle->radius.ip.s_addr != RADIUS_INADDR_POOL) {
 175     /* We've got a radius IP - it overrides everything */
 176     if (!ipcp_UseHisIPaddr(bundle, bundle->radius.ip))
 177       return 0;
 178     ipcp_Setup(&bundle->ncp.ipcp, bundle->radius.mask.s_addr);
 179     /* Continue with ppp.secret in case we've got a new label */
 180   }
 181 #endif
 182
 183   fp = OpenSecret(SECRETFILE);
 184   if (fp != NULL) {
 185 again:
 186     lineno = 0;
 187     while (fgets(buff, sizeof buff, fp)) {
 188       lineno++;
 189       if (buff[0] == '#')
 190         continue;
 191       buff[strlen(buff) - 1] = '\0';
 192       memset(vector, '\0', sizeof vector);
 193       if ((n = MakeArgs(buff, vector, VECSIZE(vector), PARSE_REDUCE)) < 0)
 194         log_Printf(LogWARN, "%s: %d: Invalid line\n", SECRETFILE, lineno);
 195       if (n < 2)
 196         continue;
 197       if (strcmp(vector[0], name) == 0) {
 198         CloseSecret(fp);
 199 #ifndef NORADIUS
 200         if (!bundle->radius.valid || bundle->radius.ip.s_addr == INADDR_NONE) {
 201 #endif
 202           if (n > 2 && *vector[2] && strcmp(vector[2], "*") &&
 203               !ipcp_UseHisaddr(bundle, vector[2], 1))
 204             return 0;
 205           ipcp_Setup(&bundle->ncp.ipcp, INADDR_NONE);
 206 #ifndef NORADIUS
 207         }
 208 #endif
 209         if (n > 3 && *vector[3] && strcmp(vector[3], "*"))
 210           bundle_SetLabel(bundle, vector[3]);
 211         return 1;               /* Valid */
 212       }
 213     }
 214
 215     if ((slash = strrchr(name, '\\')) != NULL && slash[1]) {
 216       /* Look for the name without the leading domain */
 217       name = slash + 1;
 218       rewind(fp);
 219       goto again;
 220     }
 221
 222     CloseSecret(fp);
 223   }
 224
 225 #ifndef NOPASSWDAUTH
 226   /* Let 'em in anyway - they must have been in the passwd file */
 227   ipcp_Setup(&bundle->ncp.ipcp, INADDR_NONE);
 228   return 1;
 229 #else
 230 #ifndef NORADIUS
 231   if (bundle->radius.valid)
 232     return 1;
 233 #endif
 234
 235   /* Disappeared from ppp.secret ??? */
 236   return 0;
 237 #endif
 238 }
 239
 240 int
 241 auth_Validate(struct bundle *bundle, const char *name, const char *key)
 242 {
 243   /* Used by PAP routines */
 244
 245   FILE *fp;
 246   int n, lineno;
 247   char *vector[5], buff[LINE_LEN];
 248   const char *slash;
 249
 250   fp = OpenSecret(SECRETFILE);
 251 again:
 252   lineno = 0;
 253   if (fp != NULL) {
 254     while (fgets(buff, sizeof buff, fp)) {
 255       lineno++;
 256       if (buff[0] == '#')
 257         continue;
 258       buff[strlen(buff) - 1] = 0;
 259       memset(vector, '\0', sizeof vector);
 260       if ((n = MakeArgs(buff, vector, VECSIZE(vector), PARSE_REDUCE)) < 0)
 261         log_Printf(LogWARN, "%s: %d: Invalid line\n", SECRETFILE, lineno);
 262       if (n < 2)
 263         continue;
 264       if (strcmp(vector[0], name) == 0) {
 265         CloseSecret(fp);
 266         return auth_CheckPasswd(name, vector[1], key);
 267       }
 268     }
 269   }
 270
 271   if ((slash = strrchr(name, '\\')) != NULL && slash[1]) {
 272     /* Look for the name without the leading domain */
 273     name = slash + 1;
 274     if (fp != NULL) {
 275       rewind(fp);
 276       goto again;
 277     }
 278   }
 279
 280   if (fp != NULL)
 281     CloseSecret(fp);
 282
 283 #ifndef NOPASSWDAUTH
 284   if (Enabled(bundle, OPT_PASSWDAUTH))
 285     return auth_CheckPasswd(name, "*", key);
 286 #endif
 287
 288   return 0;                     /* Invalid */
 289 }
 290
 291 char *
 292 auth_GetSecret(const char *name, size_t len)
 293 {
 294   /* Used by CHAP routines */
 295
 296   FILE *fp;
 297   int n, lineno;
 298   char *vector[5];
 299   const char *slash;
 300   static char buff[LINE_LEN];   /* vector[] will point here when returned */
 301
 302   fp = OpenSecret(SECRETFILE);
 303   if (fp == NULL)
 304     return (NULL);
 305
 306 again:
 307   lineno = 0;
 308   while (fgets(buff, sizeof buff, fp)) {
 309     lineno++;
 310     if (buff[0] == '#')
 311       continue;
 312     n = strlen(buff) - 1;
 313     if (buff[n] == '\n')
 314       buff[n] = '\0';   /* Trim the '\n' */
 315     memset(vector, '\0', sizeof vector);
 316     if ((n = MakeArgs(buff, vector, VECSIZE(vector), PARSE_REDUCE)) < 0)
 317       log_Printf(LogWARN, "%s: %d: Invalid line\n", SECRETFILE, lineno);
 318     if (n < 2)
 319       continue;
 320     if (strlen(vector[0]) == len && strncmp(vector[0], name, len) == 0) {
 321       CloseSecret(fp);
 322       return vector[1];
 323     }
 324   }
 325
 326   if ((slash = strrchr(name, '\\')) != NULL && slash[1]) {
 327     /* Go back and look for the name without the leading domain */
 328     len -= slash - name + 1;
 329     name = slash + 1;
 330     rewind(fp);
 331     goto again;
 332   }
 333
 334   CloseSecret(fp);
 335   return (NULL);                /* Invalid */
 336 }
 337
 338 static void
 339 AuthTimeout(void *vauthp)
 340 {
 341   struct authinfo *authp = (struct authinfo *)vauthp;
 342
 343   timer_Stop(&authp->authtimer);
 344   if (--authp->retry > 0) {
 345     authp->id++;
 346     (*authp->fn.req)(authp);
 347     timer_Start(&authp->authtimer);
 348   } else {
 349     log_Printf(LogPHASE, "Auth: No response from server\n");
 350     datalink_AuthNotOk(authp->physical->dl);
 351   }
 352 }
 353
 354 void
 355 auth_Init(struct authinfo *authp, struct physical *p, auth_func req,
 356           auth_func success, auth_func failure)
 357 {
 358   memset(authp, '\0', sizeof(struct authinfo));
 359   authp->cfg.fsm.timeout = DEF_FSMRETRY;
 360   authp->cfg.fsm.maxreq = DEF_FSMAUTHTRIES;
 361   authp->cfg.fsm.maxtrm = 0;    /* not used */
 362   authp->fn.req = req;
 363   authp->fn.success = success;
 364   authp->fn.failure = failure;
 365   authp->physical = p;
 366 }
 367
 368 void
 369 auth_StartReq(struct authinfo *authp)
 370 {
 371   timer_Stop(&authp->authtimer);
 372   authp->authtimer.func = AuthTimeout;
 373   authp->authtimer.name = "auth";
 374   authp->authtimer.load = authp->cfg.fsm.timeout * SECTICKS;
 375   authp->authtimer.arg = (void *)authp;
 376   authp->retry = authp->cfg.fsm.maxreq;
 377   authp->id = 1;
 378   (*authp->fn.req)(authp);
 379   timer_Start(&authp->authtimer);
 380 }
 381
 382 void
 383 auth_StopTimer(struct authinfo *authp)
 384 {
 385   timer_Stop(&authp->authtimer);
 386 }
 387
 388 struct mbuf *
 389 auth_ReadHeader(struct authinfo *authp, struct mbuf *bp)
 390 {
 391   size_t len;
 392
 393   len = m_length(bp);
 394   if (len >= sizeof authp->in.hdr) {
 395     bp = mbuf_Read(bp, (u_char *)&authp->in.hdr, sizeof authp->in.hdr);
 396     if (len >= ntohs(authp->in.hdr.length))
 397       return bp;
 398     authp->in.hdr.length = htons(0);
 399     log_Printf(LogWARN, "auth_ReadHeader: Short packet (%u > %zu) !\n",
 400                ntohs(authp->in.hdr.length), len);
 401   } else {
 402     authp->in.hdr.length = htons(0);
 403     log_Printf(LogWARN, "auth_ReadHeader: Short packet header (%u > %zu) !\n",
 404                (int)(sizeof authp->in.hdr), len);
 405   }
 406
 407   m_freem(bp);
 408   return NULL;
 409 }
 410
 411 struct mbuf *
 412 auth_ReadName(struct authinfo *authp, struct mbuf *bp, size_t len)
 413 {
 414   if (len > sizeof authp->in.name - 1)
 415     log_Printf(LogWARN, "auth_ReadName: Name too long (%zu) !\n", len);
 416   else {
 417     size_t mlen = m_length(bp);
 418
 419     if (len > mlen)
 420       log_Printf(LogWARN, "auth_ReadName: Short packet (%zu > %zu) !\n",
 421                  len, mlen);
 422     else {
 423       bp = mbuf_Read(bp, (u_char *)authp->in.name, len);
 424       authp->in.name[len] = '\0';
 425       return bp;
 426     }
 427   }
 428
 429   *authp->in.name = '\0';
 430   m_freem(bp);
 431   return NULL;
 432 }