pppd/plugins/radius/radius.c

   1 /***********************************************************************
   2 *
   3 * radius.c
   4 *
   5 * RADIUS plugin for pppd.  Performs PAP, CHAP, MS-CHAP, MS-CHAPv2
   6 * authentication using RADIUS.
   7 *
   8 * Copyright (C) 2002 Roaring Penguin Software Inc.
   9 *
  10 * Based on a patch for ipppd, which is:
  11 *    Copyright (C) 1996, Matjaz Godec <gody@elgo.si>
  12 *    Copyright (C) 1996, Lars Fenneberg <in5y050@public.uni-hamburg.de>
  13 *    Copyright (C) 1997, Miguel A.L. Paraz <map@iphil.net>
  14 *
  15 * Uses radiusclient library, which is:
  16 *    Copyright (C) 1995,1996,1997,1998 Lars Fenneberg <lf@elemental.net>
  17 *    Copyright (C) 2002 Roaring Penguin Software Inc.
  18 *
  19 * MPPE support is by Ralf Hofmann, <ralf.hofmann@elvido.net>, with
  20 * modification from Frank Cusack, <frank@google.com>.
  21 *
  22 * This plugin may be distributed according to the terms of the GNU
  23 * General Public License, version 2 or (at your option) any later version.
  24 *
  25 ***********************************************************************/
  26 static char const RCSID[] =
  27 "$Id: radius.c,v 1.16 2002/10/01 08:36:49 fcusack Exp $";
  28
  29 #include "pppd.h"
  30 #include "chap.h"
  31 #ifdef CHAPMS
  32 #include "chap_ms.h"
  33 #ifdef MPPE
  34 #include "md5.h"
  35 #endif
  36 #endif
  37 #include "radiusclient.h"
  38 #include "fsm.h"
  39 #include "ipcp.h"
  40 #include <syslog.h>
  41 #include <sys/types.h>
  42 #include <sys/time.h>
  43 #include <string.h>
  44
  45 #define BUF_LEN 1024
  46
  47 static char *config_file = NULL;
  48 static int add_avp(char **);
  49 static struct avpopt {
  50     char *vpstr;
  51     struct avpopt *next;
  52 } *avpopt = NULL;
  53
  54 static option_t Options[] = {
  55     { "radius-config-file", o_string, &config_file },
  56     { "avpair", o_special, add_avp },
  57     { NULL }
  58 };
  59
  60 static int radius_secret_check(void);
  61 static int radius_pap_auth(char *user,
  62                            char *passwd,
  63                            char **msgp,
  64                            struct wordlist **paddrs,
  65                            struct wordlist **popts);
  66 static int radius_chap_auth(char *user,
  67                             u_char *remmd,
  68                             int remmd_len,
  69                             chap_state *cstate);
  70
  71 static void radius_ip_up(void *opaque, int arg);
  72 static void radius_ip_down(void *opaque, int arg);
  73 static void make_username_realm(char *user);
  74 static int radius_setparams(chap_state *cstate, VALUE_PAIR *vp, char *msg,
  75                             REQUEST_INFO *req_info);
  76 static void radius_choose_ip(u_int32_t *addrp);
  77 static int radius_init(char *msg);
  78 static int get_client_port(char *ifname);
  79 static int radius_allowed_address(u_int32_t addr);
  80 static void radius_acct_interim(void *);
  81 #ifdef MPPE
  82 static int radius_setmppekeys(VALUE_PAIR *vp, REQUEST_INFO *req_info,
  83                               chap_state *);
  84 static int radius_setmppekeys2(VALUE_PAIR *vp, REQUEST_INFO *req_info);
  85 #endif
  86
  87 #ifndef MAXSESSIONID
  88 #define MAXSESSIONID 32
  89 #endif
  90
  91 #ifndef MAXCLASSLEN
  92 #define MAXCLASSLEN 500
  93 #endif
  94
  95 struct radius_state {
  96     int accounting_started;
  97     int initialized;
  98     int client_port;
  99     int choose_ip;
 100     int any_ip_addr_ok;
 101     int done_chap_once;
 102     u_int32_t ip_addr;
 103     char user[MAXNAMELEN];
 104     char config_file[MAXPATHLEN];
 105     char session_id[MAXSESSIONID + 1];
 106     time_t start_time;
 107     int acct_interim_interval;
 108     SERVER *authserver;         /* Authentication server to use */
 109     SERVER *acctserver;         /* Accounting server to use */
 110     int class_len;
 111     char class[MAXCLASSLEN];
 112     VALUE_PAIR *avp;    /* Additional (user supplied) vp's to send to server */
 113 };
 114
 115 void (*radius_attributes_hook)(VALUE_PAIR *) = NULL;
 116
 117 /* The pre_auth_hook MAY set authserver and acctserver if it wants.
 118    In that case, they override the values in the radiusclient.conf file */
 119 void (*radius_pre_auth_hook)(char const *user,
 120                              SERVER **authserver,
 121                              SERVER **acctserver) = NULL;
 122
 123 static struct radius_state rstate;
 124
 125 char pppd_version[] = VERSION;
 126
 127 /**********************************************************************
 128 * %FUNCTION: plugin_init
 129 * %ARGUMENTS:
 130 *  None
 131 * %RETURNS:
 132 *  Nothing
 133 * %DESCRIPTION:
 134 *  Initializes RADIUS plugin.
 135 ***********************************************************************/
 136 void
 137 plugin_init(void)
 138 {
 139     pap_check_hook = radius_secret_check;
 140     pap_auth_hook = radius_pap_auth;
 141
 142     chap_check_hook = radius_secret_check;
 143     chap_auth_hook = radius_chap_auth;
 144
 145     ip_choose_hook = radius_choose_ip;
 146     allowed_address_hook = radius_allowed_address;
 147
 148     add_notifier(&ip_up_notifier, radius_ip_up, NULL);
 149     add_notifier(&ip_down_notifier, radius_ip_down, NULL);
 150
 151     memset(&rstate, 0, sizeof(rstate));
 152
 153     strlcpy(rstate.config_file, "/etc/radiusclient/radiusclient.conf",
 154             sizeof(rstate.config_file));
 155
 156     add_options(Options);
 157
 158     info("RADIUS plugin initialized.");
 159 }
 160
 161 /**********************************************************************
 162 * %FUNCTION: add_avp
 163 * %ARGUMENTS:
 164 *  argv -- the <attribute=value> pair to add
 165 * %RETURNS:
 166 *  1
 167 * %DESCRIPTION:
 168 *  Adds an av pair to be passed on to the RADIUS server on each request.
 169 ***********************************************************************/
 170 static int
 171 add_avp(char **argv)
 172 {
 173     struct avpopt *p = malloc(sizeof(struct avpopt));
 174
 175     /* Append to a list of vp's for later parsing */
 176     p->vpstr = strdup(*argv);
 177     p->next = avpopt;
 178     avpopt = p;
 179
 180     return 1;
 181 }
 182
 183 /**********************************************************************
 184 * %FUNCTION: radius_secret_check
 185 * %ARGUMENTS:
 186 *  None
 187 * %RETURNS:
 188 *  1 -- we are ALWAYS willing to supply a secret. :-)
 189 * %DESCRIPTION:
 190 * Tells pppd that we will try to authenticate the peer, and not to
 191 * worry about looking in /etc/ppp/*-secrets
 192 ***********************************************************************/
 193 static int
 194 radius_secret_check(void)
 195 {
 196     return 1;
 197 }
 198
 199 /**********************************************************************
 200 * %FUNCTION: radius_choose_ip
 201 * %ARGUMENTS:
 202 *  addrp -- where to store the IP address
 203 * %RETURNS:
 204 *  Nothing
 205 * %DESCRIPTION:
 206 *  If RADIUS server has specified an IP address, it is stored in *addrp.
 207 ***********************************************************************/
 208 static void
 209 radius_choose_ip(u_int32_t *addrp)
 210 {
 211     if (rstate.choose_ip) {
 212         *addrp = rstate.ip_addr;
 213     }
 214 }
 215
 216 /**********************************************************************
 217 * %FUNCTION: radius_pap_auth
 218 * %ARGUMENTS:
 219 *  user -- user-name of peer
 220 *  passwd -- password supplied by peer
 221 *  msgp -- Message which will be sent in PAP response
 222 *  paddrs -- set to a list of possible peer IP addresses
 223 *  popts -- set to a list of additional pppd options
 224 * %RETURNS:
 225 *  1 if we can authenticate, -1 if we cannot.
 226 * %DESCRIPTION:
 227 * Performs PAP authentication using RADIUS
 228 ***********************************************************************/
 229 static int
 230 radius_pap_auth(char *user,
 231                 char *passwd,
 232                 char **msgp,
 233                 struct wordlist **paddrs,
 234                 struct wordlist **popts)
 235 {
 236     VALUE_PAIR *send, *received;
 237     UINT4 av_type;
 238     int result;
 239     static char radius_msg[BUF_LEN];
 240
 241     radius_msg[0] = 0;
 242     *msgp = radius_msg;
 243
 244     if (radius_init(radius_msg) < 0) {
 245         return 0;
 246     }
 247
 248     /* Put user with potentially realm added in rstate.user */
 249     make_username_realm(user);
 250
 251     if (radius_pre_auth_hook) {
 252         radius_pre_auth_hook(rstate.user,
 253                              &rstate.authserver,
 254                              &rstate.acctserver);
 255     }
 256
 257     send = NULL;
 258     received = NULL;
 259
 260     /* Hack... the "port" is the ppp interface number.  Should really be
 261        the tty */
 262     rstate.client_port = get_client_port(ifname);
 263
 264     av_type = PW_FRAMED;
 265     rc_avpair_add(&send, PW_SERVICE_TYPE, &av_type, 0, VENDOR_NONE);
 266
 267     av_type = PW_PPP;
 268     rc_avpair_add(&send, PW_FRAMED_PROTOCOL, &av_type, 0, VENDOR_NONE);
 269
 270     rc_avpair_add(&send, PW_USER_NAME, rstate.user , 0, VENDOR_NONE);
 271     rc_avpair_add(&send, PW_USER_PASSWORD, passwd, 0, VENDOR_NONE);
 272     if (*remote_number) {
 273         rc_avpair_add(&send, PW_CALLING_STATION_ID, remote_number, 0,
 274                        VENDOR_NONE);
 275     }
 276
 277     /* Add user specified vp's */
 278     if (rstate.avp)
 279         rc_avpair_insert(&send, NULL, rstate.avp);
 280
 281     if (rstate.authserver) {
 282         result = rc_auth_using_server(rstate.authserver,
 283                                       rstate.client_port, send,
 284                                       &received, radius_msg, NULL);
 285     } else {
 286         result = rc_auth(rstate.client_port, send, &received, radius_msg, NULL);
 287     }
 288
 289     if (result == OK_RC) {
 290         if (radius_setparams(NULL, received, radius_msg, NULL) < 0) {
 291             result = ERROR_RC;
 292         }
 293     }
 294
 295     /* free value pairs */
 296     rc_avpair_free(received);
 297     rc_avpair_free(send);
 298
 299     return (result == OK_RC) ? 1 : 0;
 300 }
 301
 302 /**********************************************************************
 303 * %FUNCTION: radius_chap_auth
 304 * %ARGUMENTS:
 305 *  user -- user-name of peer
 306 *  remmd -- hash received from peer
 307 *  remmd_len -- length of remmd
 308 *  cstate -- pppd's chap_state structure
 309 * %RETURNS:
 310 *  CHAP_SUCCESS if we can authenticate, CHAP_FAILURE if we cannot.
 311 * %DESCRIPTION:
 312 * Performs CHAP, MS-CHAP and MS-CHAPv2 authentication using RADIUS.
 313 ***********************************************************************/
 314 static int
 315 radius_chap_auth(char *user,
 316                  u_char *remmd,
 317                  int remmd_len,
 318                  chap_state *cstate)
 319 {
 320     VALUE_PAIR *send, *received;
 321     UINT4 av_type;
 322     static char radius_msg[BUF_LEN];
 323     int result;
 324     u_char cpassword[MAX_RESPONSE_LENGTH + 1];
 325 #ifdef MPPE
 326     /* Need the RADIUS secret and Request Authenticator to decode MPPE */
 327     REQUEST_INFO request_info, *req_info = &request_info;
 328 #else
 329     REQUEST_INFO *req_info = NULL;
 330 #endif
 331
 332     radius_msg[0] = 0;
 333
 334     if (radius_init(radius_msg) < 0) {
 335         error("%s", radius_msg);
 336         return CHAP_FAILURE;
 337     }
 338
 339     /* return error for types we can't handle */
 340     if ((cstate->chal_type != CHAP_DIGEST_MD5)
 341 #ifdef CHAPMS
 342         && (cstate->chal_type != CHAP_MICROSOFT)
 343         && (cstate->chal_type != CHAP_MICROSOFT_V2)
 344 #endif
 345         ) {
 346         error("RADIUS: Challenge type %u unsupported", cstate->chal_type);
 347         return CHAP_FAILURE;
 348     }
 349
 350     /* Put user with potentially realm added in rstate.user */
 351     if (!rstate.done_chap_once) {
 352         make_username_realm(user);
 353         rstate.client_port = get_client_port (ifname);
 354         if (radius_pre_auth_hook) {
 355             radius_pre_auth_hook(rstate.user,
 356                                  &rstate.authserver,
 357                                  &rstate.acctserver);
 358         }
 359     }
 360
 361     send = received = NULL;
 362
 363     av_type = PW_FRAMED;
 364     rc_avpair_add (&send, PW_SERVICE_TYPE, &av_type, 0, VENDOR_NONE);
 365
 366     av_type = PW_PPP;
 367     rc_avpair_add (&send, PW_FRAMED_PROTOCOL, &av_type, 0, VENDOR_NONE);
 368
 369     rc_avpair_add (&send, PW_USER_NAME, rstate.user , 0, VENDOR_NONE);
 370
 371     /*
 372      * add the challenge and response fields
 373      */
 374     switch (cstate->chal_type) {
 375     case CHAP_DIGEST_MD5:
 376         /* CHAP-Challenge and CHAP-Password */
 377         cpassword[0] = cstate->chal_id;
 378         memcpy(&cpassword[1], remmd, MD5_SIGNATURE_SIZE);
 379
 380         rc_avpair_add(&send, PW_CHAP_CHALLENGE,
 381                       cstate->challenge, cstate->chal_len, VENDOR_NONE);
 382         rc_avpair_add(&send, PW_CHAP_PASSWORD,
 383                       cpassword, MD5_SIGNATURE_SIZE + 1, VENDOR_NONE);
 384         break;
 385
 386 #ifdef CHAPMS
 387     case CHAP_MICROSOFT:
 388     {
 389         /* MS-CHAP-Challenge and MS-CHAP-Response */
 390         MS_ChapResponse *rmd = (MS_ChapResponse *) remmd;
 391         u_char *p = cpassword;
 392
 393         *p++ = cstate->chal_id;
 394         /* The idiots use a different field order in RADIUS than PPP */
 395         memcpy(p, rmd->UseNT, sizeof(rmd->UseNT));
 396         p += sizeof(rmd->UseNT);
 397         memcpy(p, rmd->LANManResp, sizeof(rmd->LANManResp));
 398         p += sizeof(rmd->LANManResp);
 399         memcpy(p, rmd->NTResp, sizeof(rmd->NTResp));
 400
 401         rc_avpair_add(&send, PW_MS_CHAP_CHALLENGE,
 402                       cstate->challenge, cstate->chal_len, VENDOR_MICROSOFT);
 403         rc_avpair_add(&send, PW_MS_CHAP_RESPONSE,
 404                       cpassword, MS_CHAP_RESPONSE_LEN + 1, VENDOR_MICROSOFT);
 405         break;
 406     }
 407
 408     case CHAP_MICROSOFT_V2:
 409     {
 410         /* MS-CHAP-Challenge and MS-CHAP2-Response */
 411         MS_Chap2Response *rmd = (MS_Chap2Response *) remmd;
 412         u_char *p = cpassword;
 413
 414         *p++ = cstate->chal_id;
 415         /* The idiots use a different field order in RADIUS than PPP */
 416         memcpy(p, rmd->Flags, sizeof(rmd->Flags));
 417         p += sizeof(rmd->Flags);
 418         memcpy(p, rmd->PeerChallenge, sizeof(rmd->PeerChallenge));
 419         p += sizeof(rmd->PeerChallenge);
 420         memcpy(p, rmd->Reserved, sizeof(rmd->Reserved));
 421         p += sizeof(rmd->Reserved);
 422         memcpy(p, rmd->NTResp, sizeof(rmd->NTResp));
 423
 424         rc_avpair_add(&send, PW_MS_CHAP_CHALLENGE,
 425                       cstate->challenge, cstate->chal_len, VENDOR_MICROSOFT);
 426         rc_avpair_add(&send, PW_MS_CHAP2_RESPONSE,
 427                       cpassword, MS_CHAP2_RESPONSE_LEN + 1, VENDOR_MICROSOFT);
 428         break;
 429     }
 430 #endif
 431
 432     }
 433
 434     /* Add user specified vp's */
 435     if (rstate.avp)
 436         rc_avpair_insert(&send, NULL, rstate.avp);
 437
 438     /*
 439      * make authentication with RADIUS server
 440      */
 441
 442     if (rstate.authserver) {
 443         result = rc_auth_using_server(rstate.authserver,
 444                                       rstate.client_port, send,
 445                                       &received, radius_msg, req_info);
 446     } else {
 447         result = rc_auth(rstate.client_port, send, &received, radius_msg,
 448                          req_info);
 449     }
 450
 451     if (result == OK_RC) {
 452         if (!rstate.done_chap_once) {
 453             if (radius_setparams(cstate, received, radius_msg, req_info) < 0) {
 454                 error("%s", radius_msg);
 455                 result = ERROR_RC;
 456             } else {
 457                 rstate.done_chap_once = 1;
 458             }
 459         }
 460     }
 461
 462     rc_avpair_free(received);
 463     rc_avpair_free (send);
 464     return (result == OK_RC) ? CHAP_SUCCESS : CHAP_FAILURE;
 465 }
 466
 467 /**********************************************************************
 468 * %FUNCTION: make_username_realm
 469 * %ARGUMENTS:
 470 *  user -- the user given to pppd
 471 * %RETURNS:
 472 *  Nothing
 473 * %DESCRIPTION:
 474 *  Copies user into rstate.user.  If it lacks a realm (no "@domain" part),
 475 * then the default realm from the radiusclient config file is added.
 476 ***********************************************************************/
 477 static void
 478 make_username_realm(char *user)
 479 {
 480     char *default_realm;
 481
 482     if ( user != NULL ) {
 483         strlcpy(rstate.user, user, sizeof(rstate.user));
 484     }  else {
 485         rstate.user[0] = 0;
 486     }
 487
 488     default_realm = rc_conf_str("default_realm");
 489
 490     if (!strchr(rstate.user, '@') &&
 491         default_realm &&
 492         (*default_realm != '\0')) {
 493         strlcat(rstate.user, "@", sizeof(rstate.user));
 494         strlcat(rstate.user, default_realm, sizeof(rstate.user));
 495     }
 496 }
 497
 498 /**********************************************************************
 499 * %FUNCTION: radius_setparams
 500 * %ARGUMENTS:
 501 *  cstate -- pppd's chap_state structure
 502 *  vp -- received value-pairs
 503 *  msg -- buffer in which to place error message.  Holds up to BUF_LEN chars
 504 * %RETURNS:
 505 *  >= 0 on success; -1 on failure
 506 * %DESCRIPTION:
 507 *  Parses attributes sent by RADIUS server and sets them in pppd.
 508 ***********************************************************************/
 509 static int
 510 radius_setparams(chap_state *cstate, VALUE_PAIR *vp, char *msg,
 511                  REQUEST_INFO *req_info)
 512 {
 513     u_int32_t remote;
 514     int ms_chap2_success = 0;
 515
 516     /* Send RADIUS attributes to anyone else who might be interested */
 517     if (radius_attributes_hook) {
 518         (*radius_attributes_hook)(vp);
 519     }
 520
 521     /*
 522      * service type (if not framed then quit),
 523      * new IP address (RADIUS can define static IP for some users),
 524      */
 525
 526     while (vp) {
 527         if (vp->vendorcode == VENDOR_NONE) {
 528             switch (vp->attribute) {
 529             case PW_SERVICE_TYPE:
 530                 /* check for service type       */
 531                 /* if not FRAMED then exit      */
 532                 if (vp->lvalue != PW_FRAMED) {
 533                     slprintf(msg, BUF_LEN, "RADIUS: wrong service type %ld for %s",
 534                              vp->lvalue, rstate.user);
 535                     return -1;
 536                 }
 537                 break;
 538
 539             case PW_FRAMED_PROTOCOL:
 540                 /* check for framed protocol type       */
 541                 /* if not PPP then also exit            */
 542                 if (vp->lvalue != PW_PPP) {
 543                     slprintf(msg, BUF_LEN, "RADIUS: wrong framed protocol %ld for %s",
 544                              vp->lvalue, rstate.user);
 545                     return -1;
 546                 }
 547                 break;
 548
 549             case PW_SESSION_TIMEOUT:
 550                 /* Session timeout */
 551                 maxconnect = vp->lvalue;
 552                 break;
 553 #ifdef MAXOCTETS
 554             case PW_SESSION_OCTETS_LIMIT:
 555                 /* Session traffic limit */
 556                 maxoctets = vp->lvalue;
 557                 break;
 558             case PW_OCTETS_DIRECTION:
 559                 /* Session traffic limit direction check */
 560                 maxoctets_dir = ( vp->lvalue > 4 ) ? 0 : vp->lvalue ;
 561                 break;
 562 #endif
 563             case PW_ACCT_INTERIM_INTERVAL:
 564                 /* Send accounting updates every few seconds */
 565                 rstate.acct_interim_interval = vp->lvalue;
 566                 /* RFC says it MUST NOT be less than 60 seconds */
 567                 /* We use "0" to signify not sending updates */
 568                 if (rstate.acct_interim_interval &&
 569                     rstate.acct_interim_interval < 60) {
 570                     rstate.acct_interim_interval = 60;
 571                 }
 572                 break;
 573             case PW_FRAMED_IP_ADDRESS:
 574                 /* seting up remote IP addresses */
 575                 remote = vp->lvalue;
 576                 if (remote == 0xffffffff) {
 577                     /* 0xffffffff means user should be allowed to select one */
 578                     rstate.any_ip_addr_ok = 1;
 579                 } else if (remote != 0xfffffffe) {
 580                     /* 0xfffffffe means NAS should select an ip address */
 581                     remote = htonl(vp->lvalue);
 582                     if (bad_ip_adrs (remote)) {
 583                         slprintf(msg, BUF_LEN, "RADIUS: bad remote IP address %I for %s",
 584                                  remote, rstate.user);
 585                         return -1;
 586                     }
 587                     rstate.choose_ip = 1;
 588                     rstate.ip_addr = remote;
 589                 }
 590                 break;
 591             case PW_CLASS:
 592                 /* Save Class attribute to pass it in accounting request */
 593                 if (vp->lvalue <= MAXCLASSLEN) {
 594                     rstate.class_len=vp->lvalue;
 595                     memcpy(rstate.class, vp->strvalue, rstate.class_len);
 596                 } /* else too big for our buffer - ignore it */
 597                 break;
 598             }
 599
 600
 601 #ifdef CHAPMS
 602         } else if (vp->vendorcode == VENDOR_MICROSOFT) {
 603             switch (vp->attribute) {
 604             case PW_MS_CHAP2_SUCCESS:
 605                 if ((vp->lvalue != 43) || strncmp(vp->strvalue + 1, "S=", 2)) {
 606                     slprintf(msg,BUF_LEN,"RADIUS: bad MS-CHAP2-Success packet");
 607                     return -1;
 608                 }
 609                 memcpy(cstate->saresponse, vp->strvalue + 3,
 610                        MS_AUTH_RESPONSE_LENGTH);
 611                 cstate->saresponse[MS_AUTH_RESPONSE_LENGTH] = '\0';
 612                 ms_chap2_success = 1;
 613                 break;
 614
 615 #ifdef MPPE
 616             case PW_MS_CHAP_MPPE_KEYS:
 617                 if (radius_setmppekeys(vp, req_info, cstate) < 0) {
 618                     slprintf(msg, BUF_LEN,
 619                              "RADIUS: bad MS-CHAP-MPPE-Keys attribute");
 620                     return -1;
 621                 }
 622                 break;
 623
 624             case PW_MS_MPPE_SEND_KEY:
 625             case PW_MS_MPPE_RECV_KEY:
 626                 if (radius_setmppekeys2(vp, req_info) < 0) {
 627                     slprintf(msg, BUF_LEN,
 628                              "RADIUS: bad MS-MPPE-%s-Key attribute",
 629                              (vp->attribute == PW_MS_MPPE_SEND_KEY)?
 630                              "Send": "Recv");
 631                     return -1;
 632                 }
 633                 break;
 634 #endif /* MPPE */
 635 #if 0
 636             case PW_MS_MPPE_ENCRYPTION_POLICY:
 637             case PW_MS_MPPE_ENCRYPTION_TYPES:
 638             case PW_MS_PRIMARY_DNS_SERVER:
 639             case PW_MS_SECONDARY_DNS_SERVER:
 640             case PW_MS_PRIMARY_NBNS_SERVER:
 641             case PW_MS_SECONDARY_NBNS_SERVER:
 642                 break;
 643 #endif
 644             }
 645 #endif /* CHAPMS */
 646         }
 647         vp = vp->next;
 648     }
 649
 650     /* Require a valid MS-CHAP2-SUCCESS for MS-CHAPv2 auth */
 651     if (cstate && (cstate->chal_type == CHAP_MICROSOFT_V2) && !ms_chap2_success)
 652         return -1;
 653
 654     return 0;
 655 }
 656
 657 #ifdef MPPE
 658 /**********************************************************************
 659 * %FUNCTION: radius_setmppekeys
 660 * %ARGUMENTS:
 661 *  vp -- value pair holding MS-CHAP-MPPE-KEYS attribute
 662 *  req_info -- radius request information used for encryption
 663 *  cstate -- chap_state structure for challenge info
 664 * %RETURNS:
 665 *  >= 0 on success; -1 on failure
 666 * %DESCRIPTION:
 667 *  Decrypt the "key" provided by the RADIUS server for MPPE encryption.
 668 *  See RFC 2548.
 669 ***********************************************************************/
 670 static int
 671 radius_setmppekeys(VALUE_PAIR *vp, REQUEST_INFO *req_info, chap_state *cstate)
 672 {
 673     int i;
 674     MD5_CTX Context;
 675     u_char  plain[32];
 676     u_char  buf[16];
 677
 678     if (vp->lvalue != 32) {
 679         error("RADIUS: Incorrect attribute length (%d) for MS-CHAP-MPPE-Keys",
 680               vp->lvalue);
 681         return -1;
 682     }
 683
 684     memcpy(plain, vp->strvalue, sizeof(plain));
 685
 686     MD5Init(&Context);
 687     MD5Update(&Context, req_info->secret, strlen(req_info->secret));
 688     MD5Update(&Context, req_info->request_vector, AUTH_VECTOR_LEN);
 689     MD5Final(buf, &Context);
 690
 691     for (i = 0; i < 16; i++)
 692         plain[i] ^= buf[i];
 693
 694     MD5Init(&Context);
 695     MD5Update(&Context, req_info->secret, strlen(req_info->secret));
 696     MD5Update(&Context, vp->strvalue, 16);
 697     MD5Final(buf, &Context);
 698
 699     for(i = 0; i < 16; i++)
 700         plain[i + 16] ^= buf[i];
 701
 702     /*
 703      * Annoying.  The "key" returned is just the NTPasswordHashHash, which
 704      * the NAS (us) doesn't need; we only need the start key.  So we have
 705      * to generate the start key, sigh.  NB: We do not support the LM-Key.
 706      */
 707     mppe_set_keys(cstate->challenge, &plain[8]);
 708
 709     return 0;
 710 }
 711
 712 /**********************************************************************
 713 * %FUNCTION: radius_setmppekeys2
 714 * %ARGUMENTS:
 715 *  vp -- value pair holding MS-MPPE-SEND-KEY or MS-MPPE-RECV-KEY attribute
 716 *  req_info -- radius request information used for encryption
 717 * %RETURNS:
 718 *  >= 0 on success; -1 on failure
 719 * %DESCRIPTION:
 720 *  Decrypt the key provided by the RADIUS server for MPPE encryption.
 721 *  See RFC 2548.
 722 ***********************************************************************/
 723 static int
 724 radius_setmppekeys2(VALUE_PAIR *vp, REQUEST_INFO *req_info)
 725 {
 726     int i;
 727     MD5_CTX Context;
 728     u_char  *salt = vp->strvalue;
 729     u_char  *crypt = vp->strvalue + 2;
 730     u_char  plain[32];
 731     u_char  buf[MD5_SIGNATURE_SIZE];
 732     char    *type = "Send";
 733
 734     if (vp->attribute == PW_MS_MPPE_RECV_KEY)
 735         type = "Recv";
 736
 737     if (vp->lvalue != 34) {
 738         error("RADIUS: Incorrect attribute length (%d) for MS-MPPE-%s-Key",
 739               vp->lvalue, type);
 740         return -1;
 741     }
 742
 743     if ((salt[0] & 0x80) == 0) {
 744         error("RADIUS: Illegal salt value for MS-MPPE-%s-Key attribute", type);
 745         return -1;
 746     }
 747
 748     memcpy(plain, crypt, 32);
 749
 750     MD5Init(&Context);
 751     MD5Update(&Context, req_info->secret, strlen(req_info->secret));
 752     MD5Update(&Context, req_info->request_vector, AUTH_VECTOR_LEN);
 753     MD5Update(&Context, salt, 2);
 754     MD5Final(buf, &Context);
 755
 756     for (i = 0; i < 16; i++)
 757         plain[i] ^= buf[i];
 758
 759     if (plain[0] != sizeof(mppe_send_key) /* 16 */) {
 760         error("RADIUS: Incorrect key length (%d) for MS-MPPE-%s-Key attribute",
 761               (int) plain[0], type);
 762         return -1;
 763     }
 764
 765     MD5Init(&Context);
 766     MD5Update(&Context, req_info->secret, strlen(req_info->secret));
 767     MD5Update(&Context, crypt, 16);
 768     MD5Final(buf, &Context);
 769
 770     plain[16] ^= buf[0]; /* only need the first byte */
 771
 772     if (vp->attribute == PW_MS_MPPE_SEND_KEY)
 773         memcpy(mppe_send_key, plain + 1, 16);
 774     else
 775         memcpy(mppe_recv_key, plain + 1, 16);
 776
 777     return 0;
 778 }
 779 #endif /* MPPE */
 780
 781 /**********************************************************************
 782 * %FUNCTION: radius_acct_start
 783 * %ARGUMENTS:
 784 *  None
 785 * %RETURNS:
 786 *  Nothing
 787 * %DESCRIPTION:
 788 *  Sends a "start" accounting message to the RADIUS server.
 789 ***********************************************************************/
 790 static void
 791 radius_acct_start(void)
 792 {
 793     UINT4 av_type;
 794     int result;
 795     VALUE_PAIR *send = NULL;
 796     ipcp_options *ho = &ipcp_hisoptions[0];
 797     u_int32_t hisaddr;
 798
 799     if (!rstate.initialized) {
 800         return;
 801     }
 802
 803     rstate.start_time = time(NULL);
 804
 805     strncpy(rstate.session_id, rc_mksid(), sizeof(rstate.session_id));
 806
 807     rc_avpair_add(&send, PW_ACCT_SESSION_ID,
 808                    rstate.session_id, 0, VENDOR_NONE);
 809     rc_avpair_add(&send, PW_USER_NAME,
 810                    rstate.user, 0, VENDOR_NONE);
 811
 812     if (rstate.class_len > 0)
 813         rc_avpair_add(&send, PW_CLASS,
 814                       rstate.class, rstate.class_len, VENDOR_NONE);
 815
 816     av_type = PW_STATUS_START;
 817     rc_avpair_add(&send, PW_ACCT_STATUS_TYPE, &av_type, 0, VENDOR_NONE);
 818
 819     av_type = PW_FRAMED;
 820     rc_avpair_add(&send, PW_SERVICE_TYPE, &av_type, 0, VENDOR_NONE);
 821
 822     av_type = PW_PPP;
 823     rc_avpair_add(&send, PW_FRAMED_PROTOCOL, &av_type, 0, VENDOR_NONE);
 824
 825     if (*remote_number) {
 826         rc_avpair_add(&send, PW_CALLING_STATION_ID,
 827                        remote_number, 0, VENDOR_NONE);
 828     }
 829
 830     av_type = PW_RADIUS;
 831     rc_avpair_add(&send, PW_ACCT_AUTHENTIC, &av_type, 0, VENDOR_NONE);
 832
 833
 834     av_type = PW_ASYNC;
 835     rc_avpair_add(&send, PW_NAS_PORT_TYPE, &av_type, 0, VENDOR_NONE);
 836
 837     hisaddr = ho->hisaddr;
 838     av_type = htonl(hisaddr);
 839     rc_avpair_add(&send, PW_FRAMED_IP_ADDRESS , &av_type , 0, VENDOR_NONE);
 840
 841     /* Add user specified vp's */
 842     if (rstate.avp)
 843         rc_avpair_insert(&send, NULL, rstate.avp);
 844
 845     if (rstate.acctserver) {
 846         result = rc_acct_using_server(rstate.acctserver,
 847                                       rstate.client_port, send);
 848     } else {
 849         result = rc_acct(rstate.client_port, send);
 850     }
 851
 852     rc_avpair_free(send);
 853
 854     if (result != OK_RC) {
 855         /* RADIUS server could be down so make this a warning */
 856         syslog(LOG_WARNING,
 857                 "Accounting START failed for %s", rstate.user);
 858     } else {
 859         rstate.accounting_started = 1;
 860         /* Kick off periodic accounting reports */
 861         if (rstate.acct_interim_interval) {
 862             TIMEOUT(radius_acct_interim, NULL, rstate.acct_interim_interval);
 863         }
 864     }
 865 }
 866
 867 /**********************************************************************
 868 * %FUNCTION: radius_acct_stop
 869 * %ARGUMENTS:
 870 *  None
 871 * %RETURNS:
 872 *  Nothing
 873 * %DESCRIPTION:
 874 *  Sends a "stop" accounting message to the RADIUS server.
 875 ***********************************************************************/
 876 static void
 877 radius_acct_stop(void)
 878 {
 879     UINT4 av_type;
 880     VALUE_PAIR *send = NULL;
 881     ipcp_options *ho = &ipcp_hisoptions[0];
 882     u_int32_t hisaddr;
 883     int result;
 884
 885     if (!rstate.initialized) {
 886         return;
 887     }
 888
 889     if (!rstate.accounting_started) {
 890         return;
 891     }
 892
 893     rstate.accounting_started = 0;
 894     rc_avpair_add(&send, PW_ACCT_SESSION_ID, rstate.session_id,
 895                    0, VENDOR_NONE);
 896
 897     rc_avpair_add(&send, PW_USER_NAME, rstate.user, 0, VENDOR_NONE);
 898
 899     av_type = PW_STATUS_STOP;
 900     rc_avpair_add(&send, PW_ACCT_STATUS_TYPE, &av_type, 0, VENDOR_NONE);
 901
 902     av_type = PW_FRAMED;
 903     rc_avpair_add(&send, PW_SERVICE_TYPE, &av_type, 0, VENDOR_NONE);
 904
 905     av_type = PW_PPP;
 906     rc_avpair_add(&send, PW_FRAMED_PROTOCOL, &av_type, 0, VENDOR_NONE);
 907
 908     av_type = PW_RADIUS;
 909     rc_avpair_add(&send, PW_ACCT_AUTHENTIC, &av_type, 0, VENDOR_NONE);
 910
 911
 912     if (link_stats_valid) {
 913         av_type = link_connect_time;
 914         rc_avpair_add(&send, PW_ACCT_SESSION_TIME, &av_type, 0, VENDOR_NONE);
 915
 916         av_type = link_stats.bytes_out;
 917         rc_avpair_add(&send, PW_ACCT_OUTPUT_OCTETS, &av_type, 0, VENDOR_NONE);
 918
 919         av_type = link_stats.bytes_in;
 920         rc_avpair_add(&send, PW_ACCT_INPUT_OCTETS, &av_type, 0, VENDOR_NONE);
 921
 922         av_type = link_stats.pkts_out;
 923         rc_avpair_add(&send, PW_ACCT_OUTPUT_PACKETS, &av_type, 0, VENDOR_NONE);
 924
 925         av_type = link_stats.pkts_in;
 926         rc_avpair_add(&send, PW_ACCT_INPUT_PACKETS, &av_type, 0, VENDOR_NONE);
 927     }
 928
 929     if (*remote_number) {
 930         rc_avpair_add(&send, PW_CALLING_STATION_ID,
 931                        remote_number, 0, VENDOR_NONE);
 932     }
 933
 934     av_type = PW_ASYNC;
 935     rc_avpair_add(&send, PW_NAS_PORT_TYPE, &av_type, 0, VENDOR_NONE);
 936
 937     hisaddr = ho->hisaddr;
 938     av_type = htonl(hisaddr);
 939     rc_avpair_add(&send, PW_FRAMED_IP_ADDRESS , &av_type , 0, VENDOR_NONE);
 940
 941     /* Add user specified vp's */
 942     if (rstate.avp)
 943         rc_avpair_insert(&send, NULL, rstate.avp);
 944
 945     if (rstate.acctserver) {
 946         result = rc_acct_using_server(rstate.acctserver,
 947                                       rstate.client_port, send);
 948     } else {
 949         result = rc_acct(rstate.client_port, send);
 950     }
 951
 952     if (result != OK_RC) {
 953         /* RADIUS server could be down so make this a warning */
 954         syslog(LOG_WARNING,
 955                 "Accounting STOP failed for %s", rstate.user);
 956     }
 957     rc_avpair_free(send);
 958 }
 959
 960 /**********************************************************************
 961 * %FUNCTION: radius_acct_interim
 962 * %ARGUMENTS:
 963 *  None
 964 * %RETURNS:
 965 *  Nothing
 966 * %DESCRIPTION:
 967 *  Sends an interim accounting message to the RADIUS server
 968 ***********************************************************************/
 969 static void
 970 radius_acct_interim(void *ignored)
 971 {
 972     UINT4 av_type;
 973     VALUE_PAIR *send = NULL;
 974     ipcp_options *ho = &ipcp_hisoptions[0];
 975     u_int32_t hisaddr;
 976     int result;
 977
 978     if (!rstate.initialized) {
 979         return;
 980     }
 981
 982     if (!rstate.accounting_started) {
 983         return;
 984     }
 985
 986     rc_avpair_add(&send, PW_ACCT_SESSION_ID, rstate.session_id,
 987                    0, VENDOR_NONE);
 988
 989     rc_avpair_add(&send, PW_USER_NAME, rstate.user, 0, VENDOR_NONE);
 990
 991     av_type = PW_STATUS_ALIVE;
 992     rc_avpair_add(&send, PW_ACCT_STATUS_TYPE, &av_type, 0, VENDOR_NONE);
 993
 994     av_type = PW_FRAMED;
 995     rc_avpair_add(&send, PW_SERVICE_TYPE, &av_type, 0, VENDOR_NONE);
 996
 997     av_type = PW_PPP;
 998     rc_avpair_add(&send, PW_FRAMED_PROTOCOL, &av_type, 0, VENDOR_NONE);
 999
1000     av_type = PW_RADIUS;
1001     rc_avpair_add(&send, PW_ACCT_AUTHENTIC, &av_type, 0, VENDOR_NONE);
1002
1003     /* Update link stats */
1004     update_link_stats(0);
1005
1006     if (link_stats_valid) {
1007         link_stats_valid = 0; /* Force later code to update */
1008
1009         av_type = link_connect_time;
1010         rc_avpair_add(&send, PW_ACCT_SESSION_TIME, &av_type, 0, VENDOR_NONE);
1011
1012         av_type = link_stats.bytes_out;
1013         rc_avpair_add(&send, PW_ACCT_OUTPUT_OCTETS, &av_type, 0, VENDOR_NONE);
1014
1015         av_type = link_stats.bytes_in;
1016         rc_avpair_add(&send, PW_ACCT_INPUT_OCTETS, &av_type, 0, VENDOR_NONE);
1017
1018         av_type = link_stats.pkts_out;
1019         rc_avpair_add(&send, PW_ACCT_OUTPUT_PACKETS, &av_type, 0, VENDOR_NONE);
1020
1021         av_type = link_stats.pkts_in;
1022         rc_avpair_add(&send, PW_ACCT_INPUT_PACKETS, &av_type, 0, VENDOR_NONE);
1023     }
1024
1025     if (*remote_number) {
1026         rc_avpair_add(&send, PW_CALLING_STATION_ID,
1027                        remote_number, 0, VENDOR_NONE);
1028     }
1029
1030     av_type = PW_ASYNC;
1031     rc_avpair_add(&send, PW_NAS_PORT_TYPE, &av_type, 0, VENDOR_NONE);
1032
1033     hisaddr = ho->hisaddr;
1034     av_type = htonl(hisaddr);
1035     rc_avpair_add(&send, PW_FRAMED_IP_ADDRESS , &av_type , 0, VENDOR_NONE);
1036
1037     /* Add user specified vp's */
1038     if (rstate.avp)
1039         rc_avpair_insert(&send, NULL, rstate.avp);
1040
1041     if (rstate.acctserver) {
1042         result = rc_acct_using_server(rstate.acctserver,
1043                                       rstate.client_port, send);
1044     } else {
1045         result = rc_acct(rstate.client_port, send);
1046     }
1047
1048     if (result != OK_RC) {
1049         /* RADIUS server could be down so make this a warning */
1050         syslog(LOG_WARNING,
1051                 "Interim accounting failed for %s", rstate.user);
1052     }
1053     rc_avpair_free(send);
1054
1055     /* Schedule another one */
1056     TIMEOUT(radius_acct_interim, NULL, rstate.acct_interim_interval);
1057 }
1058
1059 /**********************************************************************
1060 * %FUNCTION: radius_ip_up
1061 * %ARGUMENTS:
1062 *  opaque -- ignored
1063 *  arg -- ignored
1064 * %RETURNS:
1065 *  Nothing
1066 * %DESCRIPTION:
1067 *  Called when IPCP is up.  We'll do a start-accounting record.
1068 ***********************************************************************/
1069 static void
1070 radius_ip_up(void *opaque, int arg)
1071 {
1072     radius_acct_start();
1073 }
1074
1075 /**********************************************************************
1076 * %FUNCTION: radius_ip_down
1077 * %ARGUMENTS:
1078 *  opaque -- ignored
1079 *  arg -- ignored
1080 * %RETURNS:
1081 *  Nothing
1082 * %DESCRIPTION:
1083 *  Called when IPCP is down.  We'll do a stop-accounting record.
1084 ***********************************************************************/
1085 static void
1086 radius_ip_down(void *opaque, int arg)
1087 {
1088     radius_acct_stop();
1089 }
1090
1091 /**********************************************************************
1092 * %FUNCTION: radius_init
1093 * %ARGUMENTS:
1094 *  msg -- buffer of size BUF_LEN for error message
1095 * %RETURNS:
1096 *  negative on failure; non-negative on success
1097 * %DESCRIPTION:
1098 *  Initializes radiusclient library
1099 ***********************************************************************/
1100 static int
1101 radius_init(char *msg)
1102 {
1103     if (rstate.initialized) {
1104         return 0;
1105     }
1106
1107     if (config_file && *config_file) {
1108         strlcpy(rstate.config_file, config_file, MAXPATHLEN-1);
1109     }
1110
1111     rstate.initialized = 1;
1112
1113     if (rc_read_config(rstate.config_file) != 0) {
1114         slprintf(msg, BUF_LEN, "RADIUS: Can't read config file %s",
1115                  rstate.config_file);
1116         return -1;
1117     }
1118
1119     if (rc_read_dictionary(rc_conf_str("dictionary")) != 0) {
1120         slprintf(msg, BUF_LEN, "RADIUS: Can't read dictionary file %s",
1121                  rc_conf_str("dictionary"));
1122         return -1;
1123     }
1124
1125     if (rc_read_mapfile(rc_conf_str("mapfile")) != 0)   {
1126         slprintf(msg, BUF_LEN, "RADIUS: Can't read map file %s",
1127                  rc_conf_str("mapfile"));
1128         return -1;
1129     }
1130
1131     /* Add av pairs saved during option parsing */
1132     while (avpopt) {
1133         struct avpopt *n = avpopt->next;
1134
1135         rc_avpair_parse(avpopt->vpstr, &rstate.avp);
1136         free(avpopt->vpstr);
1137         free(avpopt);
1138         avpopt = n;
1139     }
1140     return 0;
1141 }
1142
1143 /**********************************************************************
1144 * %FUNCTION: get_client_port
1145 * %ARGUMENTS:
1146 *  ifname -- PPP interface name (e.g. "ppp7")
1147 * %RETURNS:
1148 *  The NAS port number (e.g. 7)
1149 * %DESCRIPTION:
1150 *  Extracts the port number from the interface name
1151 ***********************************************************************/
1152 static int
1153 get_client_port(char *ifname)
1154 {
1155     int port;
1156     if (sscanf(ifname, "ppp%d", &port) == 1) {
1157         return port;
1158     }
1159     return rc_map2id(ifname);
1160 }
1161
1162 /**********************************************************************
1163 * %FUNCTION: radius_allowed_address
1164 * %ARGUMENTS:
1165 *  addr -- IP address
1166 * %RETURNS:
1167 *  1 if we're allowed to use that IP address; 0 if not; -1 if we do
1168 *  not know.
1169 ***********************************************************************/
1170 static int
1171 radius_allowed_address(u_int32_t addr)
1172 {
1173     ipcp_options *wo = &ipcp_wantoptions[0];
1174
1175     if (!rstate.choose_ip) {
1176         /* If RADIUS server said any address is OK, then fine... */
1177         if (rstate.any_ip_addr_ok) {
1178             return 1;
1179         }
1180
1181         /* Sigh... if an address was supplied for remote host in pppd
1182            options, it has to match that.  */
1183         if (wo->hisaddr != 0 && wo->hisaddr == addr) {
1184             return 1;
1185         }
1186
1187         return 0;
1188     }
1189     if (addr == rstate.ip_addr) return 1;
1190     return 0;
1191 }
1192
1193 /* Useful for other plugins */
1194 char *radius_logged_in_user(void)
1195 {
1196     return rstate.user;
1197 }