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.20 2002/12/24 03:43:35 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, rc_avpair_copy(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     if (*remote_number) {
 434         rc_avpair_add(&send, PW_CALLING_STATION_ID, remote_number, 0,
 435                        VENDOR_NONE);
 436     }
 437
 438     /* Add user specified vp's */
 439     if (rstate.avp)
 440         rc_avpair_insert(&send, NULL, rc_avpair_copy(rstate.avp));
 441
 442     /*
 443      * make authentication with RADIUS server
 444      */
 445
 446     if (rstate.authserver) {
 447         result = rc_auth_using_server(rstate.authserver,
 448                                       rstate.client_port, send,
 449                                       &received, radius_msg, req_info);
 450     } else {
 451         result = rc_auth(rstate.client_port, send, &received, radius_msg,
 452                          req_info);
 453     }
 454
 455     if (result == OK_RC) {
 456         if (!rstate.done_chap_once) {
 457             if (radius_setparams(cstate, received, radius_msg, req_info) < 0) {
 458                 error("%s", radius_msg);
 459                 result = ERROR_RC;
 460             } else {
 461                 rstate.done_chap_once = 1;
 462             }
 463         }
 464     }
 465
 466     rc_avpair_free(received);
 467     rc_avpair_free (send);
 468     return (result == OK_RC) ? CHAP_SUCCESS : CHAP_FAILURE;
 469 }
 470
 471 /**********************************************************************
 472 * %FUNCTION: make_username_realm
 473 * %ARGUMENTS:
 474 *  user -- the user given to pppd
 475 * %RETURNS:
 476 *  Nothing
 477 * %DESCRIPTION:
 478 *  Copies user into rstate.user.  If it lacks a realm (no "@domain" part),
 479 * then the default realm from the radiusclient config file is added.
 480 ***********************************************************************/
 481 static void
 482 make_username_realm(char *user)
 483 {
 484     char *default_realm;
 485
 486     if ( user != NULL ) {
 487         strlcpy(rstate.user, user, sizeof(rstate.user));
 488     }  else {
 489         rstate.user[0] = 0;
 490     }
 491
 492     default_realm = rc_conf_str("default_realm");
 493
 494     if (!strchr(rstate.user, '@') &&
 495         default_realm &&
 496         (*default_realm != '\0')) {
 497         strlcat(rstate.user, "@", sizeof(rstate.user));
 498         strlcat(rstate.user, default_realm, sizeof(rstate.user));
 499     }
 500 }
 501
 502 /**********************************************************************
 503 * %FUNCTION: radius_setparams
 504 * %ARGUMENTS:
 505 *  cstate -- pppd's chap_state structure
 506 *  vp -- received value-pairs
 507 *  msg -- buffer in which to place error message.  Holds up to BUF_LEN chars
 508 * %RETURNS:
 509 *  >= 0 on success; -1 on failure
 510 * %DESCRIPTION:
 511 *  Parses attributes sent by RADIUS server and sets them in pppd.
 512 ***********************************************************************/
 513 static int
 514 radius_setparams(chap_state *cstate, VALUE_PAIR *vp, char *msg,
 515                  REQUEST_INFO *req_info)
 516 {
 517     u_int32_t remote;
 518     int ms_chap2_success = 0;
 519 #ifdef MPPE
 520     int mppe_enc_keys = 0;      /* whether or not these were received */
 521     int mppe_enc_policy = 0;
 522     int mppe_enc_types = 0;
 523 #endif
 524
 525     /* Send RADIUS attributes to anyone else who might be interested */
 526     if (radius_attributes_hook) {
 527         (*radius_attributes_hook)(vp);
 528     }
 529
 530     /*
 531      * service type (if not framed then quit),
 532      * new IP address (RADIUS can define static IP for some users),
 533      */
 534
 535     while (vp) {
 536         if (vp->vendorcode == VENDOR_NONE) {
 537             switch (vp->attribute) {
 538             case PW_SERVICE_TYPE:
 539                 /* check for service type       */
 540                 /* if not FRAMED then exit      */
 541                 if (vp->lvalue != PW_FRAMED) {
 542                     slprintf(msg, BUF_LEN, "RADIUS: wrong service type %ld for %s",
 543                              vp->lvalue, rstate.user);
 544                     return -1;
 545                 }
 546                 break;
 547
 548             case PW_FRAMED_PROTOCOL:
 549                 /* check for framed protocol type       */
 550                 /* if not PPP then also exit            */
 551                 if (vp->lvalue != PW_PPP) {
 552                     slprintf(msg, BUF_LEN, "RADIUS: wrong framed protocol %ld for %s",
 553                              vp->lvalue, rstate.user);
 554                     return -1;
 555                 }
 556                 break;
 557
 558             case PW_SESSION_TIMEOUT:
 559                 /* Session timeout */
 560                 maxconnect = vp->lvalue;
 561                 break;
 562 #ifdef MAXOCTETS
 563             case PW_SESSION_OCTETS_LIMIT:
 564                 /* Session traffic limit */
 565                 maxoctets = vp->lvalue;
 566                 break;
 567             case PW_OCTETS_DIRECTION:
 568                 /* Session traffic limit direction check */
 569                 maxoctets_dir = ( vp->lvalue > 4 ) ? 0 : vp->lvalue ;
 570                 break;
 571 #endif
 572             case PW_ACCT_INTERIM_INTERVAL:
 573                 /* Send accounting updates every few seconds */
 574                 rstate.acct_interim_interval = vp->lvalue;
 575                 /* RFC says it MUST NOT be less than 60 seconds */
 576                 /* We use "0" to signify not sending updates */
 577                 if (rstate.acct_interim_interval &&
 578                     rstate.acct_interim_interval < 60) {
 579                     rstate.acct_interim_interval = 60;
 580                 }
 581                 break;
 582             case PW_FRAMED_IP_ADDRESS:
 583                 /* seting up remote IP addresses */
 584                 remote = vp->lvalue;
 585                 if (remote == 0xffffffff) {
 586                     /* 0xffffffff means user should be allowed to select one */
 587                     rstate.any_ip_addr_ok = 1;
 588                 } else if (remote != 0xfffffffe) {
 589                     /* 0xfffffffe means NAS should select an ip address */
 590                     remote = htonl(vp->lvalue);
 591                     if (bad_ip_adrs (remote)) {
 592                         slprintf(msg, BUF_LEN, "RADIUS: bad remote IP address %I for %s",
 593                                  remote, rstate.user);
 594                         return -1;
 595                     }
 596                     rstate.choose_ip = 1;
 597                     rstate.ip_addr = remote;
 598                 }
 599                 break;
 600             case PW_CLASS:
 601                 /* Save Class attribute to pass it in accounting request */
 602                 if (vp->lvalue <= MAXCLASSLEN) {
 603                     rstate.class_len=vp->lvalue;
 604                     memcpy(rstate.class, vp->strvalue, rstate.class_len);
 605                 } /* else too big for our buffer - ignore it */
 606                 break;
 607             }
 608
 609
 610 #ifdef CHAPMS
 611         } else if (vp->vendorcode == VENDOR_MICROSOFT) {
 612             switch (vp->attribute) {
 613             case PW_MS_CHAP2_SUCCESS:
 614                 if ((vp->lvalue != 43) || strncmp(vp->strvalue + 1, "S=", 2)) {
 615                     slprintf(msg,BUF_LEN,"RADIUS: bad MS-CHAP2-Success packet");
 616                     return -1;
 617                 }
 618                 memcpy(cstate->saresponse, vp->strvalue + 3,
 619                        MS_AUTH_RESPONSE_LENGTH);
 620                 cstate->saresponse[MS_AUTH_RESPONSE_LENGTH] = '\0';
 621                 ms_chap2_success = 1;
 622                 break;
 623
 624 #ifdef MPPE
 625             case PW_MS_CHAP_MPPE_KEYS:
 626                 if (radius_setmppekeys(vp, req_info, cstate) < 0) {
 627                     slprintf(msg, BUF_LEN,
 628                              "RADIUS: bad MS-CHAP-MPPE-Keys attribute");
 629                     return -1;
 630                 }
 631                 mppe_enc_keys = 1;
 632                 break;
 633
 634             case PW_MS_MPPE_SEND_KEY:
 635             case PW_MS_MPPE_RECV_KEY:
 636                 if (radius_setmppekeys2(vp, req_info) < 0) {
 637                     slprintf(msg, BUF_LEN,
 638                              "RADIUS: bad MS-MPPE-%s-Key attribute",
 639                              (vp->attribute == PW_MS_MPPE_SEND_KEY)?
 640                              "Send": "Recv");
 641                     return -1;
 642                 }
 643                 mppe_enc_keys = 1;
 644                 break;
 645
 646             case PW_MS_MPPE_ENCRYPTION_POLICY:
 647                 mppe_enc_policy = vp->lvalue;   /* save for later */
 648                 break;
 649
 650             case PW_MS_MPPE_ENCRYPTION_TYPES:
 651                 mppe_enc_types = vp->lvalue;    /* save for later */
 652                 break;
 653
 654 #endif /* MPPE */
 655 #if 0
 656             case PW_MS_PRIMARY_DNS_SERVER:
 657             case PW_MS_SECONDARY_DNS_SERVER:
 658             case PW_MS_PRIMARY_NBNS_SERVER:
 659             case PW_MS_SECONDARY_NBNS_SERVER:
 660                 break;
 661 #endif
 662             }
 663 #endif /* CHAPMS */
 664         }
 665         vp = vp->next;
 666     }
 667
 668     /* Require a valid MS-CHAP2-SUCCESS for MS-CHAPv2 auth */
 669     if (cstate && (cstate->chal_type == CHAP_MICROSOFT_V2) && !ms_chap2_success)
 670         return -1;
 671
 672 #ifdef MPPE
 673     /*
 674      * Require both policy and key attributes to indicate a valid key.
 675      * Note that if the policy value was '0' we don't set the key!
 676      */
 677     if (mppe_enc_policy && mppe_enc_keys) {
 678         mppe_keys_set = 1;
 679         /* Set/modify allowed encryption types. */
 680         if (mppe_enc_types)
 681             set_mppe_enc_types(mppe_enc_policy, mppe_enc_types);
 682     }
 683 #endif
 684
 685     return 0;
 686 }
 687
 688 #ifdef MPPE
 689 /**********************************************************************
 690 * %FUNCTION: radius_setmppekeys
 691 * %ARGUMENTS:
 692 *  vp -- value pair holding MS-CHAP-MPPE-KEYS attribute
 693 *  req_info -- radius request information used for encryption
 694 *  cstate -- chap_state structure for challenge info
 695 * %RETURNS:
 696 *  >= 0 on success; -1 on failure
 697 * %DESCRIPTION:
 698 *  Decrypt the "key" provided by the RADIUS server for MPPE encryption.
 699 *  See RFC 2548.
 700 ***********************************************************************/
 701 static int
 702 radius_setmppekeys(VALUE_PAIR *vp, REQUEST_INFO *req_info, chap_state *cstate)
 703 {
 704     int i;
 705     MD5_CTX Context;
 706     u_char  plain[32];
 707     u_char  buf[16];
 708
 709     if (vp->lvalue != 32) {
 710         error("RADIUS: Incorrect attribute length (%d) for MS-CHAP-MPPE-Keys",
 711               vp->lvalue);
 712         return -1;
 713     }
 714
 715     memcpy(plain, vp->strvalue, sizeof(plain));
 716
 717     MD5Init(&Context);
 718     MD5Update(&Context, req_info->secret, strlen(req_info->secret));
 719     MD5Update(&Context, req_info->request_vector, AUTH_VECTOR_LEN);
 720     MD5Final(buf, &Context);
 721
 722     for (i = 0; i < 16; i++)
 723         plain[i] ^= buf[i];
 724
 725     MD5Init(&Context);
 726     MD5Update(&Context, req_info->secret, strlen(req_info->secret));
 727     MD5Update(&Context, vp->strvalue, 16);
 728     MD5Final(buf, &Context);
 729
 730     for(i = 0; i < 16; i++)
 731         plain[i + 16] ^= buf[i];
 732
 733     /*
 734      * Annoying.  The "key" returned is just the NTPasswordHashHash, which
 735      * the NAS (us) doesn't need; we only need the start key.  So we have
 736      * to generate the start key, sigh.  NB: We do not support the LM-Key.
 737      */
 738     mppe_set_keys(cstate->challenge, &plain[8]);
 739
 740     return 0;
 741 }
 742
 743 /**********************************************************************
 744 * %FUNCTION: radius_setmppekeys2
 745 * %ARGUMENTS:
 746 *  vp -- value pair holding MS-MPPE-SEND-KEY or MS-MPPE-RECV-KEY attribute
 747 *  req_info -- radius request information used for encryption
 748 * %RETURNS:
 749 *  >= 0 on success; -1 on failure
 750 * %DESCRIPTION:
 751 *  Decrypt the key provided by the RADIUS server for MPPE encryption.
 752 *  See RFC 2548.
 753 ***********************************************************************/
 754 static int
 755 radius_setmppekeys2(VALUE_PAIR *vp, REQUEST_INFO *req_info)
 756 {
 757     int i;
 758     MD5_CTX Context;
 759     u_char  *salt = vp->strvalue;
 760     u_char  *crypt = vp->strvalue + 2;
 761     u_char  plain[32];
 762     u_char  buf[MD5_SIGNATURE_SIZE];
 763     char    *type = "Send";
 764
 765     if (vp->attribute == PW_MS_MPPE_RECV_KEY)
 766         type = "Recv";
 767
 768     if (vp->lvalue != 34) {
 769         error("RADIUS: Incorrect attribute length (%d) for MS-MPPE-%s-Key",
 770               vp->lvalue, type);
 771         return -1;
 772     }
 773
 774     if ((salt[0] & 0x80) == 0) {
 775         error("RADIUS: Illegal salt value for MS-MPPE-%s-Key attribute", type);
 776         return -1;
 777     }
 778
 779     memcpy(plain, crypt, 32);
 780
 781     MD5Init(&Context);
 782     MD5Update(&Context, req_info->secret, strlen(req_info->secret));
 783     MD5Update(&Context, req_info->request_vector, AUTH_VECTOR_LEN);
 784     MD5Update(&Context, salt, 2);
 785     MD5Final(buf, &Context);
 786
 787     for (i = 0; i < 16; i++)
 788         plain[i] ^= buf[i];
 789
 790     if (plain[0] != sizeof(mppe_send_key) /* 16 */) {
 791         error("RADIUS: Incorrect key length (%d) for MS-MPPE-%s-Key attribute",
 792               (int) plain[0], type);
 793         return -1;
 794     }
 795
 796     MD5Init(&Context);
 797     MD5Update(&Context, req_info->secret, strlen(req_info->secret));
 798     MD5Update(&Context, crypt, 16);
 799     MD5Final(buf, &Context);
 800
 801     plain[16] ^= buf[0]; /* only need the first byte */
 802
 803     if (vp->attribute == PW_MS_MPPE_SEND_KEY)
 804         memcpy(mppe_send_key, plain + 1, 16);
 805     else
 806         memcpy(mppe_recv_key, plain + 1, 16);
 807
 808     return 0;
 809 }
 810 #endif /* MPPE */
 811
 812 /**********************************************************************
 813 * %FUNCTION: radius_acct_start
 814 * %ARGUMENTS:
 815 *  None
 816 * %RETURNS:
 817 *  Nothing
 818 * %DESCRIPTION:
 819 *  Sends a "start" accounting message to the RADIUS server.
 820 ***********************************************************************/
 821 static void
 822 radius_acct_start(void)
 823 {
 824     UINT4 av_type;
 825     int result;
 826     VALUE_PAIR *send = NULL;
 827     ipcp_options *ho = &ipcp_hisoptions[0];
 828     u_int32_t hisaddr;
 829
 830     if (!rstate.initialized) {
 831         return;
 832     }
 833
 834     rstate.start_time = time(NULL);
 835
 836     strncpy(rstate.session_id, rc_mksid(), sizeof(rstate.session_id));
 837
 838     rc_avpair_add(&send, PW_ACCT_SESSION_ID,
 839                    rstate.session_id, 0, VENDOR_NONE);
 840     rc_avpair_add(&send, PW_USER_NAME,
 841                    rstate.user, 0, VENDOR_NONE);
 842
 843     if (rstate.class_len > 0)
 844         rc_avpair_add(&send, PW_CLASS,
 845                       rstate.class, rstate.class_len, VENDOR_NONE);
 846
 847     av_type = PW_STATUS_START;
 848     rc_avpair_add(&send, PW_ACCT_STATUS_TYPE, &av_type, 0, VENDOR_NONE);
 849
 850     av_type = PW_FRAMED;
 851     rc_avpair_add(&send, PW_SERVICE_TYPE, &av_type, 0, VENDOR_NONE);
 852
 853     av_type = PW_PPP;
 854     rc_avpair_add(&send, PW_FRAMED_PROTOCOL, &av_type, 0, VENDOR_NONE);
 855
 856     if (*remote_number) {
 857         rc_avpair_add(&send, PW_CALLING_STATION_ID,
 858                        remote_number, 0, VENDOR_NONE);
 859     }
 860
 861     av_type = PW_RADIUS;
 862     rc_avpair_add(&send, PW_ACCT_AUTHENTIC, &av_type, 0, VENDOR_NONE);
 863
 864
 865     av_type = PW_ASYNC;
 866     rc_avpair_add(&send, PW_NAS_PORT_TYPE, &av_type, 0, VENDOR_NONE);
 867
 868     hisaddr = ho->hisaddr;
 869     av_type = htonl(hisaddr);
 870     rc_avpair_add(&send, PW_FRAMED_IP_ADDRESS , &av_type , 0, VENDOR_NONE);
 871
 872     /* Add user specified vp's */
 873     if (rstate.avp)
 874         rc_avpair_insert(&send, NULL, rc_avpair_copy(rstate.avp));
 875
 876     if (rstate.acctserver) {
 877         result = rc_acct_using_server(rstate.acctserver,
 878                                       rstate.client_port, send);
 879     } else {
 880         result = rc_acct(rstate.client_port, send);
 881     }
 882
 883     rc_avpair_free(send);
 884
 885     if (result != OK_RC) {
 886         /* RADIUS server could be down so make this a warning */
 887         syslog(LOG_WARNING,
 888                 "Accounting START failed for %s", rstate.user);
 889     } else {
 890         rstate.accounting_started = 1;
 891         /* Kick off periodic accounting reports */
 892         if (rstate.acct_interim_interval) {
 893             TIMEOUT(radius_acct_interim, NULL, rstate.acct_interim_interval);
 894         }
 895     }
 896 }
 897
 898 /**********************************************************************
 899 * %FUNCTION: radius_acct_stop
 900 * %ARGUMENTS:
 901 *  None
 902 * %RETURNS:
 903 *  Nothing
 904 * %DESCRIPTION:
 905 *  Sends a "stop" accounting message to the RADIUS server.
 906 ***********************************************************************/
 907 static void
 908 radius_acct_stop(void)
 909 {
 910     UINT4 av_type;
 911     VALUE_PAIR *send = NULL;
 912     ipcp_options *ho = &ipcp_hisoptions[0];
 913     u_int32_t hisaddr;
 914     int result;
 915
 916     if (!rstate.initialized) {
 917         return;
 918     }
 919
 920     if (!rstate.accounting_started) {
 921         return;
 922     }
 923
 924     rstate.accounting_started = 0;
 925     rc_avpair_add(&send, PW_ACCT_SESSION_ID, rstate.session_id,
 926                    0, VENDOR_NONE);
 927
 928     rc_avpair_add(&send, PW_USER_NAME, rstate.user, 0, VENDOR_NONE);
 929
 930     av_type = PW_STATUS_STOP;
 931     rc_avpair_add(&send, PW_ACCT_STATUS_TYPE, &av_type, 0, VENDOR_NONE);
 932
 933     av_type = PW_FRAMED;
 934     rc_avpair_add(&send, PW_SERVICE_TYPE, &av_type, 0, VENDOR_NONE);
 935
 936     av_type = PW_PPP;
 937     rc_avpair_add(&send, PW_FRAMED_PROTOCOL, &av_type, 0, VENDOR_NONE);
 938
 939     av_type = PW_RADIUS;
 940     rc_avpair_add(&send, PW_ACCT_AUTHENTIC, &av_type, 0, VENDOR_NONE);
 941
 942
 943     if (link_stats_valid) {
 944         av_type = link_connect_time;
 945         rc_avpair_add(&send, PW_ACCT_SESSION_TIME, &av_type, 0, VENDOR_NONE);
 946
 947         av_type = link_stats.bytes_out;
 948         rc_avpair_add(&send, PW_ACCT_OUTPUT_OCTETS, &av_type, 0, VENDOR_NONE);
 949
 950         av_type = link_stats.bytes_in;
 951         rc_avpair_add(&send, PW_ACCT_INPUT_OCTETS, &av_type, 0, VENDOR_NONE);
 952
 953         av_type = link_stats.pkts_out;
 954         rc_avpair_add(&send, PW_ACCT_OUTPUT_PACKETS, &av_type, 0, VENDOR_NONE);
 955
 956         av_type = link_stats.pkts_in;
 957         rc_avpair_add(&send, PW_ACCT_INPUT_PACKETS, &av_type, 0, VENDOR_NONE);
 958     }
 959
 960     if (*remote_number) {
 961         rc_avpair_add(&send, PW_CALLING_STATION_ID,
 962                        remote_number, 0, VENDOR_NONE);
 963     }
 964
 965     av_type = PW_ASYNC;
 966     rc_avpair_add(&send, PW_NAS_PORT_TYPE, &av_type, 0, VENDOR_NONE);
 967
 968     hisaddr = ho->hisaddr;
 969     av_type = htonl(hisaddr);
 970     rc_avpair_add(&send, PW_FRAMED_IP_ADDRESS , &av_type , 0, VENDOR_NONE);
 971
 972     /* Add user specified vp's */
 973     if (rstate.avp)
 974         rc_avpair_insert(&send, NULL, rc_avpair_copy(rstate.avp));
 975
 976     if (rstate.acctserver) {
 977         result = rc_acct_using_server(rstate.acctserver,
 978                                       rstate.client_port, send);
 979     } else {
 980         result = rc_acct(rstate.client_port, send);
 981     }
 982
 983     if (result != OK_RC) {
 984         /* RADIUS server could be down so make this a warning */
 985         syslog(LOG_WARNING,
 986                 "Accounting STOP failed for %s", rstate.user);
 987     }
 988     rc_avpair_free(send);
 989 }
 990
 991 /**********************************************************************
 992 * %FUNCTION: radius_acct_interim
 993 * %ARGUMENTS:
 994 *  None
 995 * %RETURNS:
 996 *  Nothing
 997 * %DESCRIPTION:
 998 *  Sends an interim accounting message to the RADIUS server
 999 ***********************************************************************/
1000 static void
1001 radius_acct_interim(void *ignored)
1002 {
1003     UINT4 av_type;
1004     VALUE_PAIR *send = NULL;
1005     ipcp_options *ho = &ipcp_hisoptions[0];
1006     u_int32_t hisaddr;
1007     int result;
1008
1009     if (!rstate.initialized) {
1010         return;
1011     }
1012
1013     if (!rstate.accounting_started) {
1014         return;
1015     }
1016
1017     rc_avpair_add(&send, PW_ACCT_SESSION_ID, rstate.session_id,
1018                    0, VENDOR_NONE);
1019
1020     rc_avpair_add(&send, PW_USER_NAME, rstate.user, 0, VENDOR_NONE);
1021
1022     av_type = PW_STATUS_ALIVE;
1023     rc_avpair_add(&send, PW_ACCT_STATUS_TYPE, &av_type, 0, VENDOR_NONE);
1024
1025     av_type = PW_FRAMED;
1026     rc_avpair_add(&send, PW_SERVICE_TYPE, &av_type, 0, VENDOR_NONE);
1027
1028     av_type = PW_PPP;
1029     rc_avpair_add(&send, PW_FRAMED_PROTOCOL, &av_type, 0, VENDOR_NONE);
1030
1031     av_type = PW_RADIUS;
1032     rc_avpair_add(&send, PW_ACCT_AUTHENTIC, &av_type, 0, VENDOR_NONE);
1033
1034     /* Update link stats */
1035     update_link_stats(0);
1036
1037     if (link_stats_valid) {
1038         link_stats_valid = 0; /* Force later code to update */
1039
1040         av_type = link_connect_time;
1041         rc_avpair_add(&send, PW_ACCT_SESSION_TIME, &av_type, 0, VENDOR_NONE);
1042
1043         av_type = link_stats.bytes_out;
1044         rc_avpair_add(&send, PW_ACCT_OUTPUT_OCTETS, &av_type, 0, VENDOR_NONE);
1045
1046         av_type = link_stats.bytes_in;
1047         rc_avpair_add(&send, PW_ACCT_INPUT_OCTETS, &av_type, 0, VENDOR_NONE);
1048
1049         av_type = link_stats.pkts_out;
1050         rc_avpair_add(&send, PW_ACCT_OUTPUT_PACKETS, &av_type, 0, VENDOR_NONE);
1051
1052         av_type = link_stats.pkts_in;
1053         rc_avpair_add(&send, PW_ACCT_INPUT_PACKETS, &av_type, 0, VENDOR_NONE);
1054     }
1055
1056     if (*remote_number) {
1057         rc_avpair_add(&send, PW_CALLING_STATION_ID,
1058                        remote_number, 0, VENDOR_NONE);
1059     }
1060
1061     av_type = PW_ASYNC;
1062     rc_avpair_add(&send, PW_NAS_PORT_TYPE, &av_type, 0, VENDOR_NONE);
1063
1064     hisaddr = ho->hisaddr;
1065     av_type = htonl(hisaddr);
1066     rc_avpair_add(&send, PW_FRAMED_IP_ADDRESS , &av_type , 0, VENDOR_NONE);
1067
1068     /* Add user specified vp's */
1069     if (rstate.avp)
1070         rc_avpair_insert(&send, NULL, rc_avpair_copy(rstate.avp));
1071
1072     if (rstate.acctserver) {
1073         result = rc_acct_using_server(rstate.acctserver,
1074                                       rstate.client_port, send);
1075     } else {
1076         result = rc_acct(rstate.client_port, send);
1077     }
1078
1079     if (result != OK_RC) {
1080         /* RADIUS server could be down so make this a warning */
1081         syslog(LOG_WARNING,
1082                 "Interim accounting failed for %s", rstate.user);
1083     }
1084     rc_avpair_free(send);
1085
1086     /* Schedule another one */
1087     TIMEOUT(radius_acct_interim, NULL, rstate.acct_interim_interval);
1088 }
1089
1090 /**********************************************************************
1091 * %FUNCTION: radius_ip_up
1092 * %ARGUMENTS:
1093 *  opaque -- ignored
1094 *  arg -- ignored
1095 * %RETURNS:
1096 *  Nothing
1097 * %DESCRIPTION:
1098 *  Called when IPCP is up.  We'll do a start-accounting record.
1099 ***********************************************************************/
1100 static void
1101 radius_ip_up(void *opaque, int arg)
1102 {
1103     radius_acct_start();
1104 }
1105
1106 /**********************************************************************
1107 * %FUNCTION: radius_ip_down
1108 * %ARGUMENTS:
1109 *  opaque -- ignored
1110 *  arg -- ignored
1111 * %RETURNS:
1112 *  Nothing
1113 * %DESCRIPTION:
1114 *  Called when IPCP is down.  We'll do a stop-accounting record.
1115 ***********************************************************************/
1116 static void
1117 radius_ip_down(void *opaque, int arg)
1118 {
1119     radius_acct_stop();
1120 }
1121
1122 /**********************************************************************
1123 * %FUNCTION: radius_init
1124 * %ARGUMENTS:
1125 *  msg -- buffer of size BUF_LEN for error message
1126 * %RETURNS:
1127 *  negative on failure; non-negative on success
1128 * %DESCRIPTION:
1129 *  Initializes radiusclient library
1130 ***********************************************************************/
1131 static int
1132 radius_init(char *msg)
1133 {
1134     if (rstate.initialized) {
1135         return 0;
1136     }
1137
1138     if (config_file && *config_file) {
1139         strlcpy(rstate.config_file, config_file, MAXPATHLEN-1);
1140     }
1141
1142     rstate.initialized = 1;
1143
1144     if (rc_read_config(rstate.config_file) != 0) {
1145         slprintf(msg, BUF_LEN, "RADIUS: Can't read config file %s",
1146                  rstate.config_file);
1147         return -1;
1148     }
1149
1150     if (rc_read_dictionary(rc_conf_str("dictionary")) != 0) {
1151         slprintf(msg, BUF_LEN, "RADIUS: Can't read dictionary file %s",
1152                  rc_conf_str("dictionary"));
1153         return -1;
1154     }
1155
1156     if (rc_read_mapfile(rc_conf_str("mapfile")) != 0)   {
1157         slprintf(msg, BUF_LEN, "RADIUS: Can't read map file %s",
1158                  rc_conf_str("mapfile"));
1159         return -1;
1160     }
1161
1162     /* Add av pairs saved during option parsing */
1163     while (avpopt) {
1164         struct avpopt *n = avpopt->next;
1165
1166         rc_avpair_parse(avpopt->vpstr, &rstate.avp);
1167         free(avpopt->vpstr);
1168         free(avpopt);
1169         avpopt = n;
1170     }
1171     return 0;
1172 }
1173
1174 /**********************************************************************
1175 * %FUNCTION: get_client_port
1176 * %ARGUMENTS:
1177 *  ifname -- PPP interface name (e.g. "ppp7")
1178 * %RETURNS:
1179 *  The NAS port number (e.g. 7)
1180 * %DESCRIPTION:
1181 *  Extracts the port number from the interface name
1182 ***********************************************************************/
1183 static int
1184 get_client_port(char *ifname)
1185 {
1186     int port;
1187     if (sscanf(ifname, "ppp%d", &port) == 1) {
1188         return port;
1189     }
1190     return rc_map2id(ifname);
1191 }
1192
1193 /**********************************************************************
1194 * %FUNCTION: radius_allowed_address
1195 * %ARGUMENTS:
1196 *  addr -- IP address
1197 * %RETURNS:
1198 *  1 if we're allowed to use that IP address; 0 if not; -1 if we do
1199 *  not know.
1200 ***********************************************************************/
1201 static int
1202 radius_allowed_address(u_int32_t addr)
1203 {
1204     ipcp_options *wo = &ipcp_wantoptions[0];
1205
1206     if (!rstate.choose_ip) {
1207         /* If RADIUS server said any address is OK, then fine... */
1208         if (rstate.any_ip_addr_ok) {
1209             return 1;
1210         }
1211
1212         /* Sigh... if an address was supplied for remote host in pppd
1213            options, it has to match that.  */
1214         if (wo->hisaddr != 0 && wo->hisaddr == addr) {
1215             return 1;
1216         }
1217
1218         return 0;
1219     }
1220     if (addr == rstate.ip_addr) return 1;
1221     return 0;
1222 }
1223
1224 /* Useful for other plugins */
1225 char *radius_logged_in_user(void)
1226 {
1227     return rstate.user;
1228 }