src/lib/radius.c

   1 /*
   2  * radius.c     Functions to send/receive radius packets.
   3  *
   4  * Version:     $Id$
   5  *
   6  *   This library is free software; you can redistribute it and/or
   7  *   modify it under the terms of the GNU Lesser General Public
   8  *   License as published by the Free Software Foundation; either
   9  *   version 2.1 of the License, or (at your option) any later version.
  10  *
  11  *   This library is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  *   Lesser General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU Lesser General Public
  17  *   License along with this library; if not, write to the Free Software
  18  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * Copyright 2000-2003,2006  The FreeRADIUS server project
  21  */
  22
  23 #include        <freeradius-devel/ident.h>
  24 RCSID("$Id$")
  25
  26 #include        <freeradius-devel/libradius.h>
  27 #include        <freeradius-devel/md5.h>
  28
  29 #include        <fcntl.h>
  30 #include        <ctype.h>
  31
  32 #ifdef WITH_UDPFROMTO
  33 #include        <freeradius-devel/udpfromto.h>
  34 #endif
  35
  36 #ifdef HAVE_MALLOC_H
  37 #include        <malloc.h>
  38 #endif
  39
  40 /*
  41  *  The RFC says 4096 octets max, and most packets are less than 256.
  42  */
  43 #define MAX_PACKET_LEN 4096
  44
  45 /*
  46  *      The maximum number of attributes which we allow in an incoming
  47  *      request.  If there are more attributes than this, the request
  48  *      is rejected.
  49  *
  50  *      This helps to minimize the potential for a DoS, when an
  51  *      attacker spoofs Access-Request packets, which don't have a
  52  *      Message-Authenticator attribute.  This means that the packet
  53  *      is unsigned, and the attacker can use resources on the server,
  54  *      even if the end request is rejected.
  55  */
  56 int fr_max_attributes = 0;
  57 FILE *fr_log_fp = NULL;
  58
  59 typedef struct radius_packet_t {
  60   uint8_t       code;
  61   uint8_t       id;
  62   uint8_t       length[2];
  63   uint8_t       vector[AUTH_VECTOR_LEN];
  64   uint8_t       data[1];
  65 } radius_packet_t;
  66
  67 static fr_randctx fr_rand_pool; /* across multiple calls */
  68 static int fr_rand_initialized = 0;
  69 static unsigned int salt_offset = 0;
  70
  71 const char *fr_packet_codes[FR_MAX_PACKET_CODE] = {
  72   "",
  73   "Access-Request",
  74   "Access-Accept",
  75   "Access-Reject",
  76   "Accounting-Request",
  77   "Accounting-Response",
  78   "Accounting-Status",
  79   "Password-Request",
  80   "Password-Accept",
  81   "Password-Reject",
  82   "Accounting-Message",
  83   "Access-Challenge",
  84   "Status-Server",
  85   "Status-Client",
  86   "14",
  87   "15",
  88   "16",
  89   "17",
  90   "18",
  91   "19",
  92   "20",
  93   "Resource-Free-Request",
  94   "Resource-Free-Response",
  95   "Resource-Query-Request",
  96   "Resource-Query-Response",
  97   "Alternate-Resource-Reclaim-Request",
  98   "NAS-Reboot-Request",
  99   "NAS-Reboot-Response",
 100   "28",
 101   "Next-Passcode",
 102   "New-Pin",
 103   "Terminate-Session",
 104   "Password-Expired",
 105   "Event-Request",
 106   "Event-Response",
 107   "35",
 108   "36",
 109   "37",
 110   "38",
 111   "39",
 112   "Disconnect-Request",
 113   "Disconnect-ACK",
 114   "Disconnect-NAK",
 115   "CoA-Request",
 116   "CoA-ACK",
 117   "CoA-NAK",
 118   "46",
 119   "47",
 120   "48",
 121   "49",
 122   "IP-Address-Allocate",
 123   "IP-Address-Release"
 124 };
 125
 126
 127 void fr_printf_log(const char *fmt, ...)
 128 {
 129         va_list ap;
 130
 131         va_start(ap, fmt);
 132         if ((fr_debug_flag == 0) || !fr_log_fp) {
 133                 va_end(ap);
 134                 return;
 135         }
 136
 137         vfprintf(fr_log_fp, fmt, ap);
 138         va_end(ap);
 139
 140         return;
 141 }
 142
 143 static void print_hex(RADIUS_PACKET *packet)
 144 {
 145         int i;
 146
 147         if (!packet->data) return;
 148
 149         printf("  Code:\t\t%u\n", packet->data[0]);
 150         printf("  Id:\t\t%u\n", packet->data[1]);
 151         printf("  Length:\t%u\n", ((packet->data[2] << 8) |
 152                                    (packet->data[3])));
 153         printf("  Vector:\t");
 154         for (i = 4; i < 20; i++) {
 155                 printf("%02x", packet->data[i]);
 156         }
 157         printf("\n");
 158
 159         if (packet->data_len > 20) {
 160                 int total;
 161                 const uint8_t *ptr;
 162                 printf("  Data:");
 163
 164                 total = packet->data_len - 20;
 165                 ptr = packet->data + 20;
 166
 167                 while (total > 0) {
 168                         int attrlen;
 169
 170                         printf("\t\t");
 171                         if (total < 2) { /* too short */
 172                                 printf("%02x\n", *ptr);
 173                                 break;
 174                         }
 175
 176                         if (ptr[1] > total) { /* too long */
 177                                 for (i = 0; i < total; i++) {
 178                                         printf("%02x ", ptr[i]);
 179                                 }
 180                                 break;
 181                         }
 182
 183                         printf("%02x  %02x  ", ptr[0], ptr[1]);
 184                         attrlen = ptr[1] - 2;
 185                         ptr += 2;
 186                         total -= 2;
 187
 188                         for (i = 0; i < attrlen; i++) {
 189                                 if ((i > 0) && ((i & 0x0f) == 0x00))
 190                                         printf("\t\t\t");
 191                                 printf("%02x ", ptr[i]);
 192                                 if ((i & 0x0f) == 0x0f) printf("\n");
 193                         }
 194
 195                         if ((attrlen & 0x0f) != 0x00) printf("\n");
 196
 197                         ptr += attrlen;
 198                         total -= attrlen;
 199                 }
 200         }
 201         fflush(stdout);
 202 }
 203
 204
 205 /*
 206  *      Wrapper for sendto which handles sendfromto, IPv6, and all
 207  *      possible combinations.
 208  */
 209 static int rad_sendto(int sockfd, void *data, size_t data_len, int flags,
 210                       fr_ipaddr_t *src_ipaddr, int src_port,
 211                       fr_ipaddr_t *dst_ipaddr, int dst_port)
 212 {
 213         struct sockaddr_storage dst;
 214         socklen_t               sizeof_dst;
 215
 216 #ifdef WITH_UDPFROMTO
 217         struct sockaddr_storage src;
 218         socklen_t               sizeof_src;
 219
 220         fr_ipaddr2sockaddr(src_ipaddr, src_port, &src, &sizeof_src);
 221 #else
 222         src_port = src_port;    /* -Wunused */
 223 #endif
 224
 225         if (!fr_ipaddr2sockaddr(dst_ipaddr, dst_port, &dst, &sizeof_dst)) {
 226                 return -1;
 227         }
 228
 229 #ifdef WITH_UDPFROMTO
 230         /*
 231          *      Only IPv4 is supported for udpfromto.
 232          *
 233          *      And if they don't specify a source IP address, don't
 234          *      use udpfromto.
 235          */
 236         if ((dst_ipaddr->af == AF_INET) ||
 237             (src_ipaddr->af != AF_UNSPEC)) {
 238                 return sendfromto(sockfd, data, data_len, flags,
 239                                   (struct sockaddr *)&src, sizeof_src,
 240                                   (struct sockaddr *)&dst, sizeof_dst);
 241         }
 242 #else
 243         src_ipaddr = src_ipaddr; /* -Wunused */
 244 #endif
 245
 246         /*
 247          *      No udpfromto, OR an IPv6 socket, fail gracefully.
 248          */
 249         return sendto(sockfd, data, data_len, flags,
 250                       (struct sockaddr *) &dst, sizeof_dst);
 251 }
 252
 253
 254 void rad_recv_discard(int sockfd)
 255 {
 256         uint8_t                 header[4];
 257         struct sockaddr_storage src;
 258         socklen_t               sizeof_src = sizeof(src);
 259
 260         recvfrom(sockfd, header, sizeof(header), 0,
 261                  (struct sockaddr *)&src, &sizeof_src);
 262 }
 263
 264
 265 ssize_t rad_recv_header(int sockfd, fr_ipaddr_t *src_ipaddr, int *src_port,
 266                         int *code)
 267 {
 268         ssize_t                 data_len, packet_len;
 269         uint8_t                 header[4];
 270         struct sockaddr_storage src;
 271         socklen_t               sizeof_src = sizeof(src);
 272
 273         data_len = recvfrom(sockfd, header, sizeof(header), MSG_PEEK,
 274                             (struct sockaddr *)&src, &sizeof_src);
 275         if (data_len < 0) {
 276                 if ((errno == EAGAIN) || (errno == EINTR)) return 0;
 277                 return -1;
 278         }
 279
 280         /*
 281          *      Too little data is available, discard the packet.
 282          */
 283         if (data_len < 4) {
 284                 recvfrom(sockfd, header, sizeof(header), 0,
 285                          (struct sockaddr *)&src, &sizeof_src);
 286                 return 1;
 287
 288         } else {                /* we got 4 bytes of data. */
 289                 /*
 290                  *      See how long the packet says it is.
 291                  */
 292                 packet_len = (header[2] * 256) + header[3];
 293
 294                 /*
 295                  *      The length in the packet says it's less than
 296                  *      a RADIUS header length: discard it.
 297                  */
 298                 if (packet_len < AUTH_HDR_LEN) {
 299                         recvfrom(sockfd, header, sizeof(header), 0,
 300                                  (struct sockaddr *)&src, &sizeof_src);
 301                         return 1;
 302
 303                         /*
 304                          *      Enforce RFC requirements, for sanity.
 305                          *      Anything after 4k will be discarded.
 306                          */
 307                 } else if (packet_len > MAX_PACKET_LEN) {
 308                         recvfrom(sockfd, header, sizeof(header), 0,
 309                                  (struct sockaddr *)&src, &sizeof_src);
 310                         return 1;
 311                 }
 312         }
 313
 314         /*
 315          *      Convert AF.  If unknown, discard packet.
 316          */
 317         if (!fr_sockaddr2ipaddr(&src, sizeof_src, src_ipaddr, src_port)) {
 318                 recvfrom(sockfd, header, sizeof(header), 0,
 319                          (struct sockaddr *)&src, &sizeof_src);
 320                 return 1;
 321         }
 322
 323         *code = header[0];
 324
 325         /*
 326          *      The packet says it's this long, but the actual UDP
 327          *      size could still be smaller.
 328          */
 329         return packet_len;
 330 }
 331
 332
 333 /*
 334  *      wrapper for recvfrom, which handles recvfromto, IPv6, and all
 335  *      possible combinations.
 336  */
 337 static ssize_t rad_recvfrom(int sockfd, uint8_t **pbuf, int flags,
 338                             fr_ipaddr_t *src_ipaddr, uint16_t *src_port,
 339                             fr_ipaddr_t *dst_ipaddr, uint16_t *dst_port)
 340 {
 341         struct sockaddr_storage src;
 342         struct sockaddr_storage dst;
 343         socklen_t               sizeof_src = sizeof(src);
 344         socklen_t               sizeof_dst = sizeof(dst);
 345         ssize_t                 data_len;
 346         uint8_t                 header[4];
 347         void                    *buf;
 348         size_t                  len;
 349         int                     port;
 350
 351         memset(&src, 0, sizeof_src);
 352         memset(&dst, 0, sizeof_dst);
 353
 354         /*
 355          *      Get address family, etc. first, so we know if we
 356          *      need to do udpfromto.
 357          *
 358          *      FIXME: udpfromto also does this, but it's not
 359          *      a critical problem.
 360          */
 361         if (getsockname(sockfd, (struct sockaddr *)&dst,
 362                         &sizeof_dst) < 0) return -1;
 363
 364         /*
 365          *      Read the length of the packet, from the packet.
 366          *      This lets us allocate the buffer to use for
 367          *      reading the rest of the packet.
 368          */
 369         data_len = recvfrom(sockfd, header, sizeof(header), MSG_PEEK,
 370                             (struct sockaddr *)&src, &sizeof_src);
 371         if (data_len < 0) {
 372                 if ((errno == EAGAIN) || (errno == EINTR)) return 0;
 373                 return -1;
 374         }
 375
 376         /*
 377          *      Too little data is available, discard the packet.
 378          */
 379         if (data_len < 4) {
 380                 recvfrom(sockfd, header, sizeof(header), flags,
 381                          (struct sockaddr *)&src, &sizeof_src);
 382                 return 0;
 383
 384         } else {                /* we got 4 bytes of data. */
 385                 /*
 386                  *      See how long the packet says it is.
 387                  */
 388                 len = (header[2] * 256) + header[3];
 389
 390                 /*
 391                  *      The length in the packet says it's less than
 392                  *      a RADIUS header length: discard it.
 393                  */
 394                 if (len < AUTH_HDR_LEN) {
 395                         recvfrom(sockfd, header, sizeof(header), flags,
 396                                  (struct sockaddr *)&src, &sizeof_src);
 397                         return 0;
 398
 399                         /*
 400                          *      Enforce RFC requirements, for sanity.
 401                          *      Anything after 4k will be discarded.
 402                          */
 403                 } else if (len > MAX_PACKET_LEN) {
 404                         recvfrom(sockfd, header, sizeof(header), flags,
 405                                  (struct sockaddr *)&src, &sizeof_src);
 406                         return len;
 407                 }
 408         }
 409
 410         buf = malloc(len);
 411         if (!buf) return -1;
 412
 413         /*
 414          *      Receive the packet.  The OS will discard any data in the
 415          *      packet after "len" bytes.
 416          */
 417 #ifdef WITH_UDPFROMTO
 418         if (dst.ss_family == AF_INET) {
 419                 data_len = recvfromto(sockfd, buf, len, flags,
 420                                       (struct sockaddr *)&src, &sizeof_src,
 421                                       (struct sockaddr *)&dst, &sizeof_dst);
 422         } else
 423 #endif
 424                 /*
 425                  *      No udpfromto, OR an IPv6 socket.  Fail gracefully.
 426                  */
 427                 data_len = recvfrom(sockfd, buf, len, flags,
 428                                     (struct sockaddr *)&src, &sizeof_src);
 429         if (data_len < 0) {
 430                 free(buf);
 431                 return data_len;
 432         }
 433
 434         if (!fr_sockaddr2ipaddr(&src, sizeof_src, src_ipaddr, &port)) {
 435                 free(buf);
 436                 return -1;      /* Unknown address family, Die Die Die! */
 437         }
 438         *src_port = port;
 439
 440         fr_sockaddr2ipaddr(&dst, sizeof_dst, dst_ipaddr, &port);
 441         *dst_port = port;
 442
 443         /*
 444          *      Different address families should never happen.
 445          */
 446         if (src.ss_family != dst.ss_family) {
 447                 free(buf);
 448                 return -1;
 449         }
 450
 451         /*
 452          *      Tell the caller about the data
 453          */
 454         *pbuf = buf;
 455
 456         return data_len;
 457 }
 458
 459
 460 #define AUTH_PASS_LEN (AUTH_VECTOR_LEN)
 461 /*************************************************************************
 462  *
 463  *      Function: make_secret
 464  *
 465  *      Purpose: Build an encrypted secret value to return in a reply
 466  *               packet.  The secret is hidden by xoring with a MD5 digest
 467  *               created from the shared secret and the authentication
 468  *               vector.  We put them into MD5 in the reverse order from
 469  *               that used when encrypting passwords to RADIUS.
 470  *
 471  *************************************************************************/
 472 static void make_secret(uint8_t *digest, const uint8_t *vector,
 473                         const char *secret, const uint8_t *value)
 474 {
 475         FR_MD5_CTX context;
 476         int             i;
 477
 478         fr_MD5Init(&context);
 479         fr_MD5Update(&context, vector, AUTH_VECTOR_LEN);
 480         fr_MD5Update(&context, (const uint8_t *) secret, strlen(secret));
 481         fr_MD5Final(digest, &context);
 482
 483         for ( i = 0; i < AUTH_VECTOR_LEN; i++ ) {
 484                 digest[i] ^= value[i];
 485         }
 486 }
 487
 488 #define MAX_PASS_LEN (128)
 489 static void make_passwd(uint8_t *output, size_t *outlen,
 490                         const uint8_t *input, size_t inlen,
 491                         const char *secret, const uint8_t *vector)
 492 {
 493         FR_MD5_CTX context, old;
 494         uint8_t digest[AUTH_VECTOR_LEN];
 495         uint8_t passwd[MAX_PASS_LEN];
 496         int     i, n;
 497         int     len;
 498
 499         /*
 500          *      If the length is zero, round it up.
 501          */
 502         len = inlen;
 503
 504         if (len > MAX_PASS_LEN) len = MAX_PASS_LEN;
 505
 506         memcpy(passwd, input, len);
 507         memset(passwd + len, 0, sizeof(passwd) - len);
 508
 509         if (len == 0) {
 510                 len = AUTH_PASS_LEN;
 511         }
 512
 513         else if ((len & 0x0f) != 0) {
 514                 len += 0x0f;
 515                 len &= ~0x0f;
 516         }
 517         *outlen = len;
 518
 519         fr_MD5Init(&context);
 520         fr_MD5Update(&context, (const uint8_t *) secret, strlen(secret));
 521         old = context;
 522
 523         /*
 524          *      Do first pass.
 525          */
 526         fr_MD5Update(&context, vector, AUTH_PASS_LEN);
 527
 528         for (n = 0; n < len; n += AUTH_PASS_LEN) {
 529                 if (n > 0) {
 530                         context = old;
 531                         fr_MD5Update(&context,
 532                                        passwd + n - AUTH_PASS_LEN,
 533                                        AUTH_PASS_LEN);
 534                 }
 535
 536                 fr_MD5Final(digest, &context);
 537                 for (i = 0; i < AUTH_PASS_LEN; i++) {
 538                         passwd[i + n] ^= digest[i];
 539                 }
 540         }
 541
 542         memcpy(output, passwd, len);
 543 }
 544
 545 static void make_tunnel_passwd(uint8_t *output, size_t *outlen,
 546                                const uint8_t *input, size_t inlen, size_t room,
 547                                const char *secret, const uint8_t *vector)
 548 {
 549         FR_MD5_CTX context, old;
 550         uint8_t digest[AUTH_VECTOR_LEN];
 551         uint8_t passwd[MAX_STRING_LEN + AUTH_VECTOR_LEN];
 552         int     i, n;
 553         int     len;
 554
 555         /*
 556          *      Be paranoid.
 557          */
 558         if (room > 253) room = 253;
 559
 560         /*
 561          *      Account for 2 bytes of the salt, and round the room
 562          *      available down to the nearest multiple of 16.  Then,
 563          *      subtract one from that to account for the length byte,
 564          *      and the resulting number is the upper bound on the data
 565          *      to copy.
 566          *
 567          *      We could short-cut this calculation just be forcing
 568          *      inlen to be no more than 239.  It would work for all
 569          *      VSA's, as we don't pack multiple VSA's into one
 570          *      attribute.
 571          *
 572          *      However, this calculation is more general, if a little
 573          *      complex.  And it will work in the future for all possible
 574          *      kinds of weird attribute packing.
 575          */
 576         room -= 2;
 577         room -= (room & 0x0f);
 578         room--;
 579
 580         if (inlen > room) inlen = room;
 581
 582         /*
 583          *      Length of the encrypted data is password length plus
 584          *      one byte for the length of the password.
 585          */
 586         len = inlen + 1;
 587         if ((len & 0x0f) != 0) {
 588                 len += 0x0f;
 589                 len &= ~0x0f;
 590         }
 591         *outlen = len + 2;      /* account for the salt */
 592
 593         /*
 594          *      Copy the password over.
 595          */
 596         memcpy(passwd + 3, input, inlen);
 597         memset(passwd + 3 + inlen, 0, sizeof(passwd) - 3 - inlen);
 598
 599         /*
 600          *      Generate salt.  The RFC's say:
 601          *
 602          *      The high bit of salt[0] must be set, each salt in a
 603          *      packet should be unique, and they should be random
 604          *
 605          *      So, we set the high bit, add in a counter, and then
 606          *      add in some CSPRNG data.  should be OK..
 607          */
 608         passwd[0] = (0x80 | ( ((salt_offset++) & 0x0f) << 3) |
 609                      (fr_rand() & 0x07));
 610         passwd[1] = fr_rand();
 611         passwd[2] = inlen;      /* length of the password string */
 612
 613         fr_MD5Init(&context);
 614         fr_MD5Update(&context, (const uint8_t *) secret, strlen(secret));
 615         old = context;
 616
 617         fr_MD5Update(&context, vector, AUTH_VECTOR_LEN);
 618         fr_MD5Update(&context, &passwd[0], 2);
 619
 620         for (n = 0; n < len; n += AUTH_PASS_LEN) {
 621                 if (n > 0) {
 622                         context = old;
 623                         fr_MD5Update(&context,
 624                                        passwd + 2 + n - AUTH_PASS_LEN,
 625                                        AUTH_PASS_LEN);
 626                 }
 627
 628                 fr_MD5Final(digest, &context);
 629                 for (i = 0; i < AUTH_PASS_LEN; i++) {
 630                         passwd[i + 2 + n] ^= digest[i];
 631                 }
 632         }
 633         memcpy(output, passwd, len + 2);
 634 }
 635
 636 /*
 637  *      Returns the end of the data.
 638  */
 639 static int vp2data(const RADIUS_PACKET *packet, const RADIUS_PACKET *original,
 640                    const char *secret, const VALUE_PAIR *vp, uint8_t *start,
 641                    size_t room)
 642 {
 643         uint32_t lvalue;
 644         size_t len;
 645         const uint8_t *data;
 646         uint8_t *ptr = start;
 647         uint8_t array[4];
 648
 649         /*
 650          *      Set up the default sources for the data.
 651          */
 652         data = vp->vp_octets;
 653         len = vp->length;
 654
 655         switch(vp->type) {
 656         case PW_TYPE_STRING:
 657         case PW_TYPE_OCTETS:
 658         case PW_TYPE_IFID:
 659         case PW_TYPE_IPV6ADDR:
 660         case PW_TYPE_IPV6PREFIX:
 661         case PW_TYPE_ABINARY:
 662                 /* nothing more to do */
 663                 break;
 664
 665         case PW_TYPE_BYTE:
 666                 len = 1;        /* just in case */
 667                 array[0] = vp->vp_integer & 0xff;
 668                 data = array;
 669                 break;
 670
 671         case PW_TYPE_SHORT:
 672                 len = 2;        /* just in case */
 673                 array[0] = (vp->vp_integer >> 8) & 0xff;
 674                 array[1] = vp->vp_integer & 0xff;
 675                 data = array;
 676                 break;
 677
 678         case PW_TYPE_INTEGER:
 679                 len = 4;        /* just in case */
 680                 lvalue = htonl(vp->vp_integer);
 681                 memcpy(array, &lvalue, sizeof(lvalue));
 682                 data = array;
 683                 break;
 684
 685         case PW_TYPE_IPADDR:
 686                 data = (const uint8_t *) &vp->vp_ipaddr;
 687                 len = 4;        /* just in case */
 688                 break;
 689
 690                 /*
 691                  *  There are no tagged date attributes.
 692                  */
 693         case PW_TYPE_DATE:
 694                 lvalue = htonl(vp->vp_date);
 695                 data = (const uint8_t *) &lvalue;
 696                 len = 4;        /* just in case */
 697                 break;
 698
 699         case PW_TYPE_SIGNED:
 700         {
 701                 int32_t slvalue;
 702
 703                 len = 4;        /* just in case */
 704                 slvalue = htonl(vp->vp_signed);
 705                 memcpy(array, &slvalue, sizeof(slvalue));
 706                 break;
 707         }
 708
 709         case PW_TYPE_TLV:
 710                 data = vp->vp_tlv;
 711                 if (!data) {
 712                         fr_strerror_printf("ERROR: Cannot encode NULL TLV");
 713                         return -1;
 714                 }
 715                 if (vp->length > room) return 0; /* can't chop TLVs to fit */
 716                 break;
 717
 718         default:                /* unknown type: ignore it */
 719                 fr_strerror_printf("ERROR: Unknown attribute type %d", vp->type);
 720                 return -1;
 721         }
 722
 723         /*
 724          *      Bound the data to the calling size
 725          */
 726         if (len > room) len = room;
 727
 728         /*
 729          *      Encrypt the various password styles
 730          *
 731          *      Attributes with encrypted values MUST be less than
 732          *      128 bytes long.
 733          */
 734         switch (vp->flags.encrypt) {
 735         case FLAG_ENCRYPT_USER_PASSWORD:
 736                 make_passwd(ptr, &len, data, len,
 737                             secret, packet->vector);
 738                 break;
 739
 740         case FLAG_ENCRYPT_TUNNEL_PASSWORD:
 741                 /*
 742                  *      Check if there's enough room.  If there isn't,
 743                  *      we discard the attribute.
 744                  *
 745                  *      This is ONLY a problem if we have multiple VSA's
 746                  *      in one Vendor-Specific, though.
 747                  */
 748                 if (room < 19) return 0;
 749
 750                 switch (packet->code) {
 751                 case PW_AUTHENTICATION_ACK:
 752                 case PW_AUTHENTICATION_REJECT:
 753                 case PW_ACCESS_CHALLENGE:
 754                 default:
 755                         if (!original) {
 756                                 fr_strerror_printf("ERROR: No request packet, cannot encrypt %s attribute in the vp.", vp->name);
 757                                 return -1;
 758                         }
 759                         ptr[0] = vp->flags.tag;
 760                         make_tunnel_passwd(ptr + 1, &len, data, len, room - 1,
 761                                            secret, original->vector);
 762                         break;
 763                 case PW_ACCOUNTING_REQUEST:
 764                 case PW_DISCONNECT_REQUEST:
 765                 case PW_COA_REQUEST:
 766                         ptr[0] = vp->flags.tag;
 767                         make_tunnel_passwd(ptr + 1, &len, data, len - 1, room,
 768                                            secret, packet->vector);
 769                         break;
 770                 }
 771                 break;
 772
 773                 /*
 774                  *      The code above ensures that this attribute
 775                  *      always fits.
 776                  */
 777         case FLAG_ENCRYPT_ASCEND_SECRET:
 778                 make_secret(ptr, packet->vector, secret, data);
 779                 len = AUTH_VECTOR_LEN;
 780                 break;
 781
 782
 783         default:
 784                 if (vp->flags.has_tag && TAG_VALID(vp->flags.tag)) {
 785                         if (vp->type == PW_TYPE_STRING) {
 786                                 if (len > (room - 1)) len = room - 1;
 787                                 ptr[0] = vp->flags.tag;
 788                                 ptr++;
 789                         } else if (vp->type == PW_TYPE_INTEGER) {
 790                                 array[0] = vp->flags.tag;
 791                         } /* else it can't be any other type */
 792                 }
 793                 memcpy(ptr, data, len);
 794                 break;
 795         } /* switch over encryption flags */
 796
 797         return len + (ptr - start);;
 798 }
 799
 800
 801 static int rad_vp2rfc(const RADIUS_PACKET *packet,
 802                       const RADIUS_PACKET *original,
 803                       const char *secret, const VALUE_PAIR *vp,
 804                       unsigned int attribute, uint8_t *ptr, size_t room)
 805 {
 806         int len;
 807
 808         if (room < 2) return 0;
 809
 810         ptr[0] = attribute & 0xff; /* NOT vp->attribute */
 811         ptr[1] = 2;
 812
 813         len = vp2data(packet, original, secret, vp, ptr + 2, room - 2);
 814         if (len < 0) return len;
 815
 816         ptr[1] += len;
 817
 818         return ptr[1];
 819 }
 820
 821 static int tlv2data(const RADIUS_PACKET *packet,
 822                     const RADIUS_PACKET *original,
 823                     const char *secret, const VALUE_PAIR *vp, int attribute,
 824                     uint8_t *ptr, size_t room)
 825 {
 826         int len;
 827
 828         if (room < 2) return 0;
 829         room -= 2;
 830
 831         ptr[0] = attribute & 0xff;
 832         ptr[1] = 2;
 833
 834         /*
 835          *      No more nested TLVs: pack the data.
 836          */
 837         if ((attribute & ~0xff) == 0) {
 838                 len = vp2data(packet, original, secret, vp, ptr + 2, room);
 839         } else {
 840                 len = tlv2data(packet, original, secret, vp, attribute >> 8,
 841                                ptr + 2, room);
 842         }
 843         if (len <= 0) return len;
 844
 845         ptr[1] += len;
 846
 847         return ptr[1];
 848 }
 849
 850 static int wimax2data(const RADIUS_PACKET *packet,
 851                       const RADIUS_PACKET *original,
 852                       const char *secret, const VALUE_PAIR *vp,
 853                       uint8_t *start, size_t room, uint8_t *ptr)
 854 {
 855         int len;
 856
 857         /*
 858          *      Offsets to Vendor-Specific length, and to length of
 859          *      WiMAX attribute.
 860          */
 861 #define VS_OFF (1)
 862 #define WM_OFF (7)
 863
 864         if (room < 1) return 0;
 865         room--;
 866
 867         /*
 868          *      Account for continuation bytes.  The caller has
 869          *      already accounting for the continuation byte in the
 870          *      Vendor-Specific "length" field.
 871          */
 872         start[WM_OFF]++;
 873         *(ptr++) = 0;
 874
 875         /*
 876          *      Chop everything to fit in one attribute.
 877          */
 878         if (room > (255 - 9)) room = (255 - 9);
 879
 880         /*
 881          *      The attribute contains TLVs that we have NOT decoded
 882          *      properly, OR it contains TLV that the user has encoded
 883          *      manually.  If it has no data, OR it's too long,
 884          *      discard it.  We're not going to walk through its
 885          *      contents trying to figure out how to chop it across
 886          *      multiple continuations.
 887          */
 888         if (vp->flags.has_tlv && (!vp->vp_tlv || (vp->length > room))) {
 889                 return 0;
 890         }
 891
 892         /*
 893          *      The attribute is a top-level integer, ipaddr, etc.
 894          *      Encode it.
 895          */
 896         if (!vp->flags.is_tlv) {
 897                 len = vp2data(packet, original, secret, vp, ptr, room);
 898         } else {
 899                 len = tlv2data(packet, original, secret, vp, vp->attribute >> 8,
 900                                ptr, room);
 901         }
 902
 903         if (len <= 0) return len;
 904
 905         start[VS_OFF] += len;
 906         start[WM_OFF] += len;
 907
 908         return start[VS_OFF];
 909 }
 910
 911
 912 /*
 913  *      Parse a data structure into a RADIUS attribute.
 914  */
 915 int rad_vp2attr(const RADIUS_PACKET *packet, const RADIUS_PACKET *original,
 916                 const char *secret, const VALUE_PAIR *vp, uint8_t *start,
 917                 size_t room)
 918 {
 919         int len;
 920         uint32_t lvalue;
 921         uint8_t *ptr;
 922         DICT_VENDOR *dv;
 923
 924         /*
 925          *      RFC format attributes take the fast path.
 926          */
 927         if (vp->vendor == 0) {
 928                 len = rad_vp2rfc(packet, original, secret, vp,
 929                                  vp->attribute, start, room);
 930                 if (len < 0) return -1;
 931
 932                 /*
 933                  *      RFC 2865 section 5 says that zero-length
 934                  *      attributes MUST NOT be sent.
 935                  *
 936                  *      ... and the WiMAX forum ignores
 937                  *      this... because of one vendor.  Don't they
 938                  *      have anything better to do with their time?
 939                  */
 940                 if ((len == 0) &&
 941                     (vp->attribute != PW_CHARGEABLE_USER_IDENTITY)) return 0;
 942
 943                 return len;
 944
 945         }
 946
 947         /*
 948          *      Not enough room for:
 949          *              attr, len, vendor-id, vsa, vsalen
 950          */
 951         if (room < 8) return 0;
 952
 953         /*
 954          *      Build the Vendor-Specific header
 955          */
 956         ptr = start;
 957         *ptr++ = PW_VENDOR_SPECIFIC;
 958         *ptr++ = 6;
 959         room -= 6;
 960         lvalue = htonl(vp->vendor);
 961         memcpy(ptr, &lvalue, 4);
 962         ptr += 4;
 963
 964         /*
 965          *      Unknown vendors, and type=1,length=1,no-continuation
 966          *      are RFC format attributes.
 967          */
 968         dv = dict_vendorbyvalue(vp->vendor);
 969         if (!dv ||
 970             ((dv->type == 1) && (dv->length = 1) && !dv->flags)) {
 971                 len = rad_vp2rfc(packet, original, secret, vp,
 972                                  vp->attribute, ptr, room);
 973                 if (len <= 0) return len;
 974
 975                 start[1] += len;
 976                 return start[1];
 977         }
 978
 979         if (room < (dv->type + dv->length + dv->flags)) return 0;
 980         room -= (dv->type + dv->length + dv->flags);
 981         start[1] += (dv->type + dv->length + dv->flags);
 982
 983         switch (dv->type) {
 984                 case 1:
 985                         ptr[0] = (vp->attribute & 0xFF);
 986                         break;
 987
 988                 case 2:
 989                         ptr[0] = ((vp->attribute >> 8) & 0xFF);
 990                         ptr[1] = (vp->attribute & 0xFF);
 991                         break;
 992
 993                 case 4:
 994                         ptr[0] = 0;
 995                         ptr[1] = ((vp->attribute >> 16) & 0xFF);
 996                         ptr[2] = ((vp->attribute >> 8) & 0xFF);
 997                         ptr[3] = (vp->attribute & 0xFF);
 998                         break;
 999
1000                 default:
1001                         return 0; /* silently discard it */
1002         }
1003         ptr += dv->type;
1004
1005         switch (dv->length) {
1006         case 0:
1007                 break;
1008         case 1:
1009                 ptr[0] = dv->type + 1;
1010                 break;
1011         case 2:
1012                 ptr[0] = 0;
1013                 ptr[1] = dv->type + 2;
1014                 break;
1015
1016         default:
1017                 return 0; /* silently discard it */
1018         }
1019         ptr += dv->length;
1020
1021         /*
1022          *      WiMAX attributes take their own path through the
1023          *      system.
1024          */
1025         if (dv->flags) return wimax2data(packet, original, secret, vp,
1026                                          start, room, ptr);
1027
1028         len = vp2data(packet, original, secret, vp, ptr, room);
1029         if (len <= 0) return len;
1030
1031         if (dv->length != 0) ptr[-1] += len;
1032
1033         start[1] += len;
1034
1035         return start[1];
1036 }
1037
1038 /*
1039  *  Swap 123a -> 0321
1040  */
1041 #define REORDER(x) ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | ((x & 0xff000000 >> 24))
1042
1043
1044 /*
1045  *      Encode a WiMAX sub-TLV.  It must NOT be called for WiMAX
1046  *      attributes that are of type integer, string, etc.
1047  */
1048 static int rad_encode_wimax(const RADIUS_PACKET *packet,
1049                             const RADIUS_PACKET *original,
1050                             const char *secret, VALUE_PAIR *reply,
1051                             uint8_t *start, size_t room)
1052 {
1053         int len, redo;
1054         uint32_t lvalue;
1055         uint8_t *ptr = start, *vsa = start;
1056         uint32_t maxattr;
1057         VALUE_PAIR *vp = reply;
1058
1059         /*
1060          *      Swap the order of the WiMAX hacks, to make later
1061          *      comparisons easier.
1062          */
1063         maxattr = REORDER(vp->attribute);
1064
1065         /*
1066          *      Build the Vendor-Specific header
1067          */
1068         ptr = start;
1069         redo = 0;
1070
1071 redo_vsa:
1072         vsa = ptr;
1073
1074         if (room < 9) return 0;
1075         *ptr++ = PW_VENDOR_SPECIFIC;
1076         *ptr++ = 9;
1077         room -= 9;
1078         lvalue = htonl(vp->vendor);
1079         memcpy(ptr, &lvalue, 4);
1080         ptr += 4;
1081         *(ptr++) = vp->attribute & 0xff;
1082         *(ptr++) = 3;
1083         *(ptr++) = 0;           /* continuation */
1084         room -= 9;
1085
1086 redo_tlv:
1087         len = tlv2data(packet, original, secret, vp, vp->attribute >> 8,
1088                        ptr, room);
1089         if (len < 0) return len;
1090
1091         /*
1092          *      Not enough room.  Do a continuation.
1093          */
1094         if ((len == 0) || ((vsa[VS_OFF] + len) > 255)) {
1095                 if (redo) return (start - vsa);
1096
1097                 vsa[8] = 0x80;
1098                 redo = 1;
1099                 goto redo_vsa;
1100         }
1101         redo = 0;
1102
1103         ptr += len;
1104         vsa[VS_OFF] += len;
1105         vsa[WM_OFF] += len;
1106
1107         vp->flags.encoded = 1;
1108         vp = vp->next;
1109
1110         /*
1111          *      Look at the NEXT tlv.  Ensure that we encode
1112          *      attributes into a common VSA *only* if they are for
1113          *      the same WiMAX VSA, AND if the TLVs are in numerically
1114          *      increasing order.
1115          */
1116         if (vp && vp->flags.is_tlv && (reply->vendor == vp->vendor) &&
1117             ((reply->attribute & 0xff) == (vp->attribute & 0xff))) {
1118                 uint32_t attr;
1119
1120                 attr = REORDER(vp->attribute);
1121                 if (attr >= maxattr) {
1122                         maxattr = attr;
1123                         goto redo_tlv;
1124                 }
1125         }
1126
1127         return ptr - start;
1128 }
1129
1130
1131 /*
1132  *      Encode a packet.
1133  */
1134 int rad_encode(RADIUS_PACKET *packet, const RADIUS_PACKET *original,
1135                const char *secret)
1136 {
1137         radius_packet_t *hdr;
1138         uint8_t         *ptr;
1139         uint16_t        total_length;
1140         int             len;
1141         VALUE_PAIR      *reply;
1142         const char      *what;
1143         char            ip_buffer[128];
1144
1145         /*
1146          *      A 4K packet, aligned on 64-bits.
1147          */
1148         uint64_t        data[MAX_PACKET_LEN / sizeof(uint64_t)];
1149
1150         if ((packet->code > 0) && (packet->code < FR_MAX_PACKET_CODE)) {
1151                 what = fr_packet_codes[packet->code];
1152         } else {
1153                 what = "Reply";
1154         }
1155
1156         DEBUG("Sending %s of id %d to %s port %d\n",
1157               what, packet->id,
1158               inet_ntop(packet->dst_ipaddr.af,
1159                         &packet->dst_ipaddr.ipaddr,
1160                         ip_buffer, sizeof(ip_buffer)),
1161               packet->dst_port);
1162
1163         /*
1164          *      Double-check some things based on packet code.
1165          */
1166         switch (packet->code) {
1167         case PW_AUTHENTICATION_ACK:
1168         case PW_AUTHENTICATION_REJECT:
1169         case PW_ACCESS_CHALLENGE:
1170                 if (!original) {
1171                         fr_strerror_printf("ERROR: Cannot sign response packet without a request packet.");
1172                         return -1;
1173                 }
1174                 break;
1175
1176                 /*
1177                  *      These packet vectors start off as all zero.
1178                  */
1179         case PW_ACCOUNTING_REQUEST:
1180         case PW_DISCONNECT_REQUEST:
1181         case PW_COA_REQUEST:
1182                 memset(packet->vector, 0, sizeof(packet->vector));
1183                 break;
1184
1185         default:
1186                 break;
1187         }
1188
1189         /*
1190          *      Use memory on the stack, until we know how
1191          *      large the packet will be.
1192          */
1193         hdr = (radius_packet_t *) data;
1194
1195         /*
1196          *      Build standard header
1197          */
1198         hdr->code = packet->code;
1199         hdr->id = packet->id;
1200
1201         memcpy(hdr->vector, packet->vector, sizeof(hdr->vector));
1202
1203         total_length = AUTH_HDR_LEN;
1204
1205         /*
1206          *      Load up the configuration values for the user
1207          */
1208         ptr = hdr->data;
1209         packet->offset = 0;
1210
1211         /*
1212          *      FIXME: Loop twice over the reply list.  The first time,
1213          *      calculate the total length of data.  The second time,
1214          *      allocate the memory, and fill in the VP's.
1215          *
1216          *      Hmm... this may be slower than just doing a small
1217          *      memcpy.
1218          */
1219
1220         /*
1221          *      Loop over the reply attributes for the packet.
1222          */
1223         for (reply = packet->vps; reply; reply = reply->next) {
1224                 /*
1225                  *      Ignore non-wire attributes
1226                  */
1227                 if ((reply->vendor == 0) &&
1228                     ((reply->attribute & 0xFFFF) > 0xff)) {
1229 #ifndef NDEBUG
1230                         /*
1231                          *      Permit the admin to send BADLY formatted
1232                          *      attributes with a debug build.
1233                          */
1234                         if (reply->attribute == PW_RAW_ATTRIBUTE) {
1235                                 memcpy(ptr, reply->vp_octets, reply->length);
1236                                 len = reply->length;
1237                                 goto next;
1238                         }
1239 #endif
1240                         continue;
1241                 }
1242
1243                 /*
1244                  *      Set the Message-Authenticator to the correct
1245                  *      length and initial value.
1246                  */
1247                 if (reply->attribute == PW_MESSAGE_AUTHENTICATOR) {
1248                         reply->length = AUTH_VECTOR_LEN;
1249                         memset(reply->vp_strvalue, 0, AUTH_VECTOR_LEN);
1250
1251                         /*
1252                          *      Cache the offset to the
1253                          *      Message-Authenticator
1254                          */
1255                         packet->offset = total_length;
1256                 }
1257
1258                 /*
1259                  *      Print out ONLY the attributes which
1260                  *      we're sending over the wire, and print
1261                  *      them out BEFORE they're encrypted.
1262                  */
1263                 debug_pair(reply);
1264
1265                 /*
1266                  *      Skip attributes that are encoded.
1267                  */
1268                 if (reply->flags.encoded) continue;
1269
1270                 if (reply->flags.is_tlv) {
1271                         len = rad_encode_wimax(packet, original, secret,
1272                                                reply, ptr,
1273                                                ((uint8_t *) data) + sizeof(data) - ptr);
1274                 } else {
1275
1276                         len = rad_vp2attr(packet, original, secret, reply, ptr,
1277                                           ((uint8_t *) data) + sizeof(data) - ptr);
1278                 }
1279
1280                 if (len < 0) return -1;
1281
1282         next:
1283                 ptr += len;
1284                 total_length += len;
1285         } /* done looping over all attributes */
1286
1287         /*
1288          *      Fill in the rest of the fields, and copy the data over
1289          *      from the local stack to the newly allocated memory.
1290          *
1291          *      Yes, all this 'memcpy' is slow, but it means
1292          *      that we only allocate the minimum amount of
1293          *      memory for a request.
1294          */
1295         packet->data_len = total_length;
1296         packet->data = (uint8_t *) malloc(packet->data_len);
1297         if (!packet->data) {
1298                 fr_strerror_printf("Out of memory");
1299                 return -1;
1300         }
1301
1302         memcpy(packet->data, hdr, packet->data_len);
1303         hdr = (radius_packet_t *) packet->data;
1304
1305         total_length = htons(total_length);
1306         memcpy(hdr->length, &total_length, sizeof(total_length));
1307
1308         return 0;
1309 }
1310
1311
1312 /*
1313  *      Sign a previously encoded packet.
1314  */
1315 int rad_sign(RADIUS_PACKET *packet, const RADIUS_PACKET *original,
1316              const char *secret)
1317 {
1318         radius_packet_t *hdr = (radius_packet_t *)packet->data;
1319
1320         /*
1321          *      It wasn't assigned an Id, this is bad!
1322          */
1323         if (packet->id < 0) {
1324                 fr_strerror_printf("ERROR: RADIUS packets must be assigned an Id.");
1325                 return -1;
1326         }
1327
1328         if (!packet->data || (packet->data_len < AUTH_HDR_LEN) ||
1329             (packet->offset < 0)) {
1330                 fr_strerror_printf("ERROR: You must call rad_encode() before rad_sign()");
1331                 return -1;
1332         }
1333
1334         /*
1335          *      If there's a Message-Authenticator, update it
1336          *      now, BEFORE updating the authentication vector.
1337          */
1338         if (packet->offset > 0) {
1339                 uint8_t calc_auth_vector[AUTH_VECTOR_LEN];
1340
1341                 switch (packet->code) {
1342                 case PW_ACCOUNTING_REQUEST:
1343                 case PW_ACCOUNTING_RESPONSE:
1344                 case PW_DISCONNECT_REQUEST:
1345                 case PW_DISCONNECT_ACK:
1346                 case PW_DISCONNECT_NAK:
1347                 case PW_COA_REQUEST:
1348                 case PW_COA_ACK:
1349                 case PW_COA_NAK:
1350                         memset(hdr->vector, 0, AUTH_VECTOR_LEN);
1351                         break;
1352
1353                 case PW_AUTHENTICATION_ACK:
1354                 case PW_AUTHENTICATION_REJECT:
1355                 case PW_ACCESS_CHALLENGE:
1356                         if (!original) {
1357                                 fr_strerror_printf("ERROR: Cannot sign response packet without a request packet.");
1358                                 return -1;
1359                         }
1360                         memcpy(hdr->vector, original->vector,
1361                                AUTH_VECTOR_LEN);
1362                         break;
1363
1364                 default:        /* others have vector already set to zero */
1365                         break;
1366
1367                 }
1368
1369                 /*
1370                  *      Set the authentication vector to zero,
1371                  *      calculate the signature, and put it
1372                  *      into the Message-Authenticator
1373                  *      attribute.
1374                  */
1375                 fr_hmac_md5(packet->data, packet->data_len,
1376                             (const uint8_t *) secret, strlen(secret),
1377                             calc_auth_vector);
1378                 memcpy(packet->data + packet->offset + 2,
1379                        calc_auth_vector, AUTH_VECTOR_LEN);
1380
1381                 /*
1382                  *      Copy the original request vector back
1383                  *      to the raw packet.
1384                  */
1385                 memcpy(hdr->vector, packet->vector, AUTH_VECTOR_LEN);
1386         }
1387
1388         /*
1389          *      Switch over the packet code, deciding how to
1390          *      sign the packet.
1391          */
1392         switch (packet->code) {
1393                 /*
1394                  *      Request packets are not signed, bur
1395                  *      have a random authentication vector.
1396                  */
1397         case PW_AUTHENTICATION_REQUEST:
1398         case PW_STATUS_SERVER:
1399                 break;
1400
1401                 /*
1402                  *      Reply packets are signed with the
1403                  *      authentication vector of the request.
1404                  */
1405         default:
1406                 {
1407                         uint8_t digest[16];
1408
1409                         FR_MD5_CTX      context;
1410                         fr_MD5Init(&context);
1411                         fr_MD5Update(&context, packet->data, packet->data_len);
1412                         fr_MD5Update(&context, (const uint8_t *) secret,
1413                                      strlen(secret));
1414                         fr_MD5Final(digest, &context);
1415
1416                         memcpy(hdr->vector, digest, AUTH_VECTOR_LEN);
1417                         memcpy(packet->vector, digest, AUTH_VECTOR_LEN);
1418                         break;
1419                 }
1420         }/* switch over packet codes */
1421
1422         return 0;
1423 }
1424
1425 /*
1426  *      Reply to the request.  Also attach
1427  *      reply attribute value pairs and any user message provided.
1428  */
1429 int rad_send(RADIUS_PACKET *packet, const RADIUS_PACKET *original,
1430              const char *secret)
1431 {
1432         VALUE_PAIR              *reply;
1433         const char              *what;
1434         char                    ip_buffer[128];
1435
1436         /*
1437          *      Maybe it's a fake packet.  Don't send it.
1438          */
1439         if (!packet || (packet->sockfd < 0)) {
1440                 return 0;
1441         }
1442
1443         if ((packet->code > 0) && (packet->code < FR_MAX_PACKET_CODE)) {
1444                 what = fr_packet_codes[packet->code];
1445         } else {
1446                 what = "Reply";
1447         }
1448
1449         /*
1450          *  First time through, allocate room for the packet
1451          */
1452         if (!packet->data) {
1453                 /*
1454                  *      Encode the packet.
1455                  */
1456                 if (rad_encode(packet, original, secret) < 0) {
1457                         return -1;
1458                 }
1459
1460                 /*
1461                  *      Re-sign it, including updating the
1462                  *      Message-Authenticator.
1463                  */
1464                 if (rad_sign(packet, original, secret) < 0) {
1465                         return -1;
1466                 }
1467
1468                 /*
1469                  *      If packet->data points to data, then we print out
1470                  *      the VP list again only for debugging.
1471                  */
1472         } else if (fr_debug_flag) {
1473                 DEBUG("Sending %s of id %d to %s port %d\n", what, packet->id,
1474                       inet_ntop(packet->dst_ipaddr.af,
1475                                 &packet->dst_ipaddr.ipaddr,
1476                                 ip_buffer, sizeof(ip_buffer)),
1477                       packet->dst_port);
1478
1479                 for (reply = packet->vps; reply; reply = reply->next) {
1480                         if ((reply->vendor == 0) &&
1481                             ((reply->attribute & 0xFFFF) > 0xff)) continue;
1482                         debug_pair(reply);
1483                 }
1484         }
1485
1486         /*
1487          *      And send it on it's way.
1488          */
1489         return rad_sendto(packet->sockfd, packet->data, packet->data_len, 0,
1490                           &packet->src_ipaddr, packet->src_port,
1491                           &packet->dst_ipaddr, packet->dst_port);
1492 }
1493
1494 /*
1495  *      Do a comparison of two authentication digests by comparing
1496  *      the FULL digest.  Otehrwise, the server can be subject to
1497  *      timing attacks that allow attackers find a valid message
1498  *      authenticator.
1499  *
1500  *      http://www.cs.rice.edu/~dwallach/pub/crosby-timing2009.pdf
1501  */
1502 static int digest_cmp(const uint8_t *a, const uint8_t *b, size_t length)
1503 {
1504         int result = 0;
1505         size_t i;
1506
1507         for (i = 0; i < length; i++) {
1508                 result |= a[i] ^ b[i];
1509         }
1510
1511         return result;          /* 0 is OK, !0 is !OK, just like memcmp */
1512 }
1513
1514
1515 /*
1516  *      Validates the requesting client NAS.  Calculates the
1517  *      signature based on the clients private key.
1518  */
1519 static int calc_acctdigest(RADIUS_PACKET *packet, const char *secret)
1520 {
1521         uint8_t         digest[AUTH_VECTOR_LEN];
1522         FR_MD5_CTX              context;
1523
1524         /*
1525          *      Zero out the auth_vector in the received packet.
1526          *      Then append the shared secret to the received packet,
1527          *      and calculate the MD5 sum. This must be the same
1528          *      as the original MD5 sum (packet->vector).
1529          */
1530         memset(packet->data + 4, 0, AUTH_VECTOR_LEN);
1531
1532         /*
1533          *  MD5(packet + secret);
1534          */
1535         fr_MD5Init(&context);
1536         fr_MD5Update(&context, packet->data, packet->data_len);
1537         fr_MD5Update(&context, (const uint8_t *) secret, strlen(secret));
1538         fr_MD5Final(digest, &context);
1539
1540         /*
1541          *      Return 0 if OK, 2 if not OK.
1542          */
1543         if (digest_cmp(digest, packet->vector, AUTH_VECTOR_LEN) != 0) return 2;
1544         return 0;
1545 }
1546
1547
1548 /*
1549  *      Validates the requesting client NAS.  Calculates the
1550  *      signature based on the clients private key.
1551  */
1552 static int calc_replydigest(RADIUS_PACKET *packet, RADIUS_PACKET *original,
1553                             const char *secret)
1554 {
1555         uint8_t         calc_digest[AUTH_VECTOR_LEN];
1556         FR_MD5_CTX              context;
1557
1558         /*
1559          *      Very bad!
1560          */
1561         if (original == NULL) {
1562                 return 3;
1563         }
1564
1565         /*
1566          *  Copy the original vector in place.
1567          */
1568         memcpy(packet->data + 4, original->vector, AUTH_VECTOR_LEN);
1569
1570         /*
1571          *  MD5(packet + secret);
1572          */
1573         fr_MD5Init(&context);
1574         fr_MD5Update(&context, packet->data, packet->data_len);
1575         fr_MD5Update(&context, (const uint8_t *) secret, strlen(secret));
1576         fr_MD5Final(calc_digest, &context);
1577
1578         /*
1579          *  Copy the packet's vector back to the packet.
1580          */
1581         memcpy(packet->data + 4, packet->vector, AUTH_VECTOR_LEN);
1582
1583         /*
1584          *      Return 0 if OK, 2 if not OK.
1585          */
1586         if (digest_cmp(packet->vector, calc_digest, AUTH_VECTOR_LEN) != 0) return 2;
1587         return 0;
1588 }
1589
1590
1591 /*
1592  *      See if the data pointed to by PTR is a valid RADIUS packet.
1593  *
1594  *      packet is not 'const * const' because we may update data_len,
1595  *      if there's more data in the UDP packet than in the RADIUS packet.
1596  */
1597 int rad_packet_ok(RADIUS_PACKET *packet, int flags)
1598 {
1599         uint8_t                 *attr;
1600         int                     totallen;
1601         int                     count;
1602         radius_packet_t         *hdr;
1603         char                    host_ipaddr[128];
1604         int                     require_ma = 0;
1605         int                     seen_ma = 0;
1606         int                     num_attributes;
1607
1608         /*
1609          *      Check for packets smaller than the packet header.
1610          *
1611          *      RFC 2865, Section 3., subsection 'length' says:
1612          *
1613          *      "The minimum length is 20 ..."
1614          */
1615         if (packet->data_len < AUTH_HDR_LEN) {
1616                 fr_strerror_printf("WARNING: Malformed RADIUS packet from host %s: too short (received %d < minimum %d)",
1617                            inet_ntop(packet->src_ipaddr.af,
1618                                      &packet->src_ipaddr.ipaddr,
1619                                      host_ipaddr, sizeof(host_ipaddr)),
1620                                    (int) packet->data_len, AUTH_HDR_LEN);
1621                 return 0;
1622         }
1623
1624         /*
1625          *      RFC 2865, Section 3., subsection 'length' says:
1626          *
1627          *      " ... and maximum length is 4096."
1628          */
1629         if (packet->data_len > MAX_PACKET_LEN) {
1630                 fr_strerror_printf("WARNING: Malformed RADIUS packet from host %s: too long (received %d > maximum %d)",
1631                            inet_ntop(packet->src_ipaddr.af,
1632                                      &packet->src_ipaddr.ipaddr,
1633                                      host_ipaddr, sizeof(host_ipaddr)),
1634                                    (int) packet->data_len, MAX_PACKET_LEN);
1635                 return 0;
1636         }
1637
1638         /*
1639          *      Check for packets with mismatched size.
1640          *      i.e. We've received 128 bytes, and the packet header
1641          *      says it's 256 bytes long.
1642          */
1643         totallen = (packet->data[2] << 8) | packet->data[3];
1644         hdr = (radius_packet_t *)packet->data;
1645
1646         /*
1647          *      Code of 0 is not understood.
1648          *      Code of 16 or greate is not understood.
1649          */
1650         if ((hdr->code == 0) ||
1651             (hdr->code >= FR_MAX_PACKET_CODE)) {
1652                 fr_strerror_printf("WARNING: Bad RADIUS packet from host %s: unknown packet code%d ",
1653                            inet_ntop(packet->src_ipaddr.af,
1654                                      &packet->src_ipaddr.ipaddr,
1655                                      host_ipaddr, sizeof(host_ipaddr)),
1656                            hdr->code);
1657                 return 0;
1658         }
1659
1660         /*
1661          *      Message-Authenticator is required in Status-Server
1662          *      packets, otherwise they can be trivially forged.
1663          */
1664         if (hdr->code == PW_STATUS_SERVER) require_ma = 1;
1665
1666         /*
1667          *      It's also required if the caller asks for it.
1668          */
1669         if (flags) require_ma = 1;
1670
1671         /*
1672          *      Repeat the length checks.  This time, instead of
1673          *      looking at the data we received, look at the value
1674          *      of the 'length' field inside of the packet.
1675          *
1676          *      Check for packets smaller than the packet header.
1677          *
1678          *      RFC 2865, Section 3., subsection 'length' says:
1679          *
1680          *      "The minimum length is 20 ..."
1681          */
1682         if (totallen < AUTH_HDR_LEN) {
1683                 fr_strerror_printf("WARNING: Malformed RADIUS packet from host %s: too short (length %d < minimum %d)",
1684                            inet_ntop(packet->src_ipaddr.af,
1685                                      &packet->src_ipaddr.ipaddr,
1686                                      host_ipaddr, sizeof(host_ipaddr)),
1687                            totallen, AUTH_HDR_LEN);
1688                 return 0;
1689         }
1690
1691         /*
1692          *      And again, for the value of the 'length' field.
1693          *
1694          *      RFC 2865, Section 3., subsection 'length' says:
1695          *
1696          *      " ... and maximum length is 4096."
1697          */
1698         if (totallen > MAX_PACKET_LEN) {
1699                 fr_strerror_printf("WARNING: Malformed RADIUS packet from host %s: too long (length %d > maximum %d)",
1700                            inet_ntop(packet->src_ipaddr.af,
1701                                      &packet->src_ipaddr.ipaddr,
1702                                      host_ipaddr, sizeof(host_ipaddr)),
1703                            totallen, MAX_PACKET_LEN);
1704                 return 0;
1705         }
1706
1707         /*
1708          *      RFC 2865, Section 3., subsection 'length' says:
1709          *
1710          *      "If the packet is shorter than the Length field
1711          *      indicates, it MUST be silently discarded."
1712          *
1713          *      i.e. No response to the NAS.
1714          */
1715         if (packet->data_len < totallen) {
1716                 fr_strerror_printf("WARNING: Malformed RADIUS packet from host %s: received %d octets, packet length says %d",
1717                            inet_ntop(packet->src_ipaddr.af,
1718                                      &packet->src_ipaddr.ipaddr,
1719                                      host_ipaddr, sizeof(host_ipaddr)),
1720                                    (int) packet->data_len, totallen);
1721                 return 0;
1722         }
1723
1724         /*
1725          *      RFC 2865, Section 3., subsection 'length' says:
1726          *
1727          *      "Octets outside the range of the Length field MUST be
1728          *      treated as padding and ignored on reception."
1729          */
1730         if (packet->data_len > totallen) {
1731                 /*
1732                  *      We're shortening the packet below, but just
1733                  *      to be paranoid, zero out the extra data.
1734                  */
1735                 memset(packet->data + totallen, 0, packet->data_len - totallen);
1736                 packet->data_len = totallen;
1737         }
1738
1739         /*
1740          *      Walk through the packet's attributes, ensuring that
1741          *      they add up EXACTLY to the size of the packet.
1742          *
1743          *      If they don't, then the attributes either under-fill
1744          *      or over-fill the packet.  Any parsing of the packet
1745          *      is impossible, and will result in unknown side effects.
1746          *
1747          *      This would ONLY happen with buggy RADIUS implementations,
1748          *      or with an intentional attack.  Either way, we do NOT want
1749          *      to be vulnerable to this problem.
1750          */
1751         attr = hdr->data;
1752         count = totallen - AUTH_HDR_LEN;
1753         num_attributes = 0;
1754
1755         while (count > 0) {
1756                 /*
1757                  *      Attribute number zero is NOT defined.
1758                  */
1759                 if (attr[0] == 0) {
1760                         fr_strerror_printf("WARNING: Malformed RADIUS packet from host %s: Invalid attribute 0",
1761                                    inet_ntop(packet->src_ipaddr.af,
1762                                              &packet->src_ipaddr.ipaddr,
1763                                              host_ipaddr, sizeof(host_ipaddr)));
1764                         return 0;
1765                 }
1766
1767                 /*
1768                  *      Attributes are at LEAST as long as the ID & length
1769                  *      fields.  Anything shorter is an invalid attribute.
1770                  */
1771                 if (attr[1] < 2) {
1772                         fr_strerror_printf("WARNING: Malformed RADIUS packet from host %s: attribute %d too short",
1773                                    inet_ntop(packet->src_ipaddr.af,
1774                                              &packet->src_ipaddr.ipaddr,
1775                                              host_ipaddr, sizeof(host_ipaddr)),
1776                                    attr[0]);
1777                         return 0;
1778                 }
1779
1780                 /*
1781                  *      Sanity check the attributes for length.
1782                  */
1783                 switch (attr[0]) {
1784                 default:        /* don't do anything by default */
1785                         break;
1786
1787                         /*
1788                          *      If there's an EAP-Message, we require
1789                          *      a Message-Authenticator.
1790                          */
1791                 case PW_EAP_MESSAGE:
1792                         require_ma = 1;
1793                         break;
1794
1795                 case PW_MESSAGE_AUTHENTICATOR:
1796                         if (attr[1] != 2 + AUTH_VECTOR_LEN) {
1797                                 fr_strerror_printf("WARNING: Malformed RADIUS packet from host %s: Message-Authenticator has invalid length %d",
1798                                            inet_ntop(packet->src_ipaddr.af,
1799                                                      &packet->src_ipaddr.ipaddr,
1800                                                      host_ipaddr, sizeof(host_ipaddr)),
1801                                            attr[1] - 2);
1802                                 return 0;
1803                         }
1804                         seen_ma = 1;
1805                         break;
1806                 }
1807
1808                 /*
1809                  *      FIXME: Look up the base 255 attributes in the
1810                  *      dictionary, and switch over their type.  For
1811                  *      integer/date/ip, the attribute length SHOULD
1812                  *      be 6.
1813                  */
1814                 count -= attr[1];       /* grab the attribute length */
1815                 attr += attr[1];
1816                 num_attributes++;       /* seen one more attribute */
1817         }
1818
1819         /*
1820          *      If the attributes add up to a packet, it's allowed.
1821          *
1822          *      If not, we complain, and throw the packet away.
1823          */
1824         if (count != 0) {
1825                 fr_strerror_printf("WARNING: Malformed RADIUS packet from host %s: packet attributes do NOT exactly fill the packet",
1826                            inet_ntop(packet->src_ipaddr.af,
1827                                      &packet->src_ipaddr.ipaddr,
1828                                      host_ipaddr, sizeof(host_ipaddr)));
1829                 return 0;
1830         }
1831
1832         /*
1833          *      If we're configured to look for a maximum number of
1834          *      attributes, and we've seen more than that maximum,
1835          *      then throw the packet away, as a possible DoS.
1836          */
1837         if ((fr_max_attributes > 0) &&
1838             (num_attributes > fr_max_attributes)) {
1839                 fr_strerror_printf("WARNING: Possible DoS attack from host %s: Too many attributes in request (received %d, max %d are allowed).",
1840                            inet_ntop(packet->src_ipaddr.af,
1841                                      &packet->src_ipaddr.ipaddr,
1842                                      host_ipaddr, sizeof(host_ipaddr)),
1843                            num_attributes, fr_max_attributes);
1844                 return 0;
1845         }
1846
1847         /*
1848          *      http://www.freeradius.org/rfc/rfc2869.html#EAP-Message
1849          *
1850          *      A packet with an EAP-Message attribute MUST also have
1851          *      a Message-Authenticator attribute.
1852          *
1853          *      A Message-Authenticator all by itself is OK, though.
1854          *
1855          *      Similarly, Status-Server packets MUST contain
1856          *      Message-Authenticator attributes.
1857          */
1858         if (require_ma && ! seen_ma) {
1859                 fr_strerror_printf("WARNING: Insecure packet from host %s:  Packet does not contain required Message-Authenticator attribute",
1860                            inet_ntop(packet->src_ipaddr.af,
1861                                      &packet->src_ipaddr.ipaddr,
1862                                      host_ipaddr, sizeof(host_ipaddr)));
1863                 return 0;
1864         }
1865
1866         /*
1867          *      Fill RADIUS header fields
1868          */
1869         packet->code = hdr->code;
1870         packet->id = hdr->id;
1871         memcpy(packet->vector, hdr->vector, AUTH_VECTOR_LEN);
1872
1873         return 1;
1874 }
1875
1876
1877 /*
1878  *      Receive UDP client requests, and fill in
1879  *      the basics of a RADIUS_PACKET structure.
1880  */
1881 RADIUS_PACKET *rad_recv(int fd, int flags)
1882 {
1883         int sock_flags = 0;
1884         RADIUS_PACKET           *packet;
1885
1886         /*
1887          *      Allocate the new request data structure
1888          */
1889         if ((packet = malloc(sizeof(*packet))) == NULL) {
1890                 fr_strerror_printf("out of memory");
1891                 return NULL;
1892         }
1893         memset(packet, 0, sizeof(*packet));
1894
1895         if (flags & 0x02) {
1896                 sock_flags = MSG_PEEK;
1897                 flags &= ~0x02;
1898         }
1899
1900         packet->data_len = rad_recvfrom(fd, &packet->data, sock_flags,
1901                                         &packet->src_ipaddr, &packet->src_port,
1902                                         &packet->dst_ipaddr, &packet->dst_port);
1903
1904         /*
1905          *      Check for socket errors.
1906          */
1907         if (packet->data_len < 0) {
1908                 fr_strerror_printf("Error receiving packet: %s", strerror(errno));
1909                 /* packet->data is NULL */
1910                 free(packet);
1911                 return NULL;
1912         }
1913
1914         /*
1915          *      If the packet is too big, then rad_recvfrom did NOT
1916          *      allocate memory.  Instead, it just discarded the
1917          *      packet.
1918          */
1919         if (packet->data_len > MAX_PACKET_LEN) {
1920                 fr_strerror_printf("Discarding packet: Larger than RFC limitation of 4096 bytes.");
1921                 /* packet->data is NULL */
1922                 free(packet);
1923                 return NULL;
1924         }
1925
1926         /*
1927          *      Read no data.  Continue.
1928          *      This check is AFTER the MAX_PACKET_LEN check above, because
1929          *      if the packet is larger than MAX_PACKET_LEN, we also have
1930          *      packet->data == NULL
1931          */
1932         if ((packet->data_len == 0) || !packet->data) {
1933                 fr_strerror_printf("Empty packet: Socket is not ready.");
1934                 free(packet);
1935                 return NULL;
1936         }
1937
1938         /*
1939          *      See if it's a well-formed RADIUS packet.
1940          */
1941         if (!rad_packet_ok(packet, flags)) {
1942                 rad_free(&packet);
1943                 return NULL;
1944         }
1945
1946         /*
1947          *      Remember which socket we read the packet from.
1948          */
1949         packet->sockfd = fd;
1950
1951         /*
1952          *      FIXME: Do even more filtering by only permitting
1953          *      certain IP's.  The problem is that we don't know
1954          *      how to do this properly for all possible clients...
1955          */
1956
1957         /*
1958          *      Explicitely set the VP list to empty.
1959          */
1960         packet->vps = NULL;
1961
1962         if (fr_debug_flag) {
1963                 char host_ipaddr[128];
1964
1965                 if ((packet->code > 0) && (packet->code < FR_MAX_PACKET_CODE)) {
1966                         DEBUG("rad_recv: %s packet from host %s port %d",
1967                               fr_packet_codes[packet->code],
1968                               inet_ntop(packet->src_ipaddr.af,
1969                                         &packet->src_ipaddr.ipaddr,
1970                                         host_ipaddr, sizeof(host_ipaddr)),
1971                               packet->src_port);
1972                 } else {
1973                         DEBUG("rad_recv: Packet from host %s port %d code=%d",
1974                               inet_ntop(packet->src_ipaddr.af,
1975                                         &packet->src_ipaddr.ipaddr,
1976                                         host_ipaddr, sizeof(host_ipaddr)),
1977                               packet->src_port,
1978                               packet->code);
1979                 }
1980                 DEBUG(", id=%d, length=%d\n",
1981                       packet->id, (int) packet->data_len);
1982         }
1983
1984         return packet;
1985 }
1986
1987
1988 /*
1989  *      Verify the signature of a packet.
1990  */
1991 int rad_verify(RADIUS_PACKET *packet, RADIUS_PACKET *original,
1992                const char *secret)
1993 {
1994         uint8_t                 *ptr;
1995         int                     length;
1996         int                     attrlen;
1997
1998         if (!packet || !packet->data) return -1;
1999
2000         /*
2001          *      Before we allocate memory for the attributes, do more
2002          *      sanity checking.
2003          */
2004         ptr = packet->data + AUTH_HDR_LEN;
2005         length = packet->data_len - AUTH_HDR_LEN;
2006         while (length > 0) {
2007                 uint8_t msg_auth_vector[AUTH_VECTOR_LEN];
2008                 uint8_t calc_auth_vector[AUTH_VECTOR_LEN];
2009
2010                 attrlen = ptr[1];
2011
2012                 switch (ptr[0]) {
2013                 default:        /* don't do anything. */
2014                         break;
2015
2016                         /*
2017                          *      Note that more than one Message-Authenticator
2018                          *      attribute is invalid.
2019                          */
2020                 case PW_MESSAGE_AUTHENTICATOR:
2021                         memcpy(msg_auth_vector, &ptr[2], sizeof(msg_auth_vector));
2022                         memset(&ptr[2], 0, AUTH_VECTOR_LEN);
2023
2024                         switch (packet->code) {
2025                         default:
2026                                 break;
2027
2028                         case PW_ACCOUNTING_REQUEST:
2029                         case PW_ACCOUNTING_RESPONSE:
2030                         case PW_DISCONNECT_REQUEST:
2031                         case PW_DISCONNECT_ACK:
2032                         case PW_DISCONNECT_NAK:
2033                         case PW_COA_REQUEST:
2034                         case PW_COA_ACK:
2035                         case PW_COA_NAK:
2036                                 memset(packet->data + 4, 0, AUTH_VECTOR_LEN);
2037                                 break;
2038
2039                         case PW_AUTHENTICATION_ACK:
2040                         case PW_AUTHENTICATION_REJECT:
2041                         case PW_ACCESS_CHALLENGE:
2042                                 if (!original) {
2043                                         fr_strerror_printf("ERROR: Cannot validate Message-Authenticator in response packet without a request packet.");
2044                                         return -1;
2045                                 }
2046                                 memcpy(packet->data + 4, original->vector, AUTH_VECTOR_LEN);
2047                                 break;
2048                         }
2049
2050                         fr_hmac_md5(packet->data, packet->data_len,
2051                                     (const uint8_t *) secret, strlen(secret),
2052                                     calc_auth_vector);
2053                         if (digest_cmp(calc_auth_vector, msg_auth_vector,
2054                                    sizeof(calc_auth_vector)) != 0) {
2055                                 char buffer[32];
2056                                 fr_strerror_printf("Received packet from %s with invalid Message-Authenticator!  (Shared secret is incorrect.)",
2057                                            inet_ntop(packet->src_ipaddr.af,
2058                                                      &packet->src_ipaddr.ipaddr,
2059                                                      buffer, sizeof(buffer)));
2060                                 /* Silently drop packet, according to RFC 3579 */
2061                                 return -1;
2062                         } /* else the message authenticator was good */
2063
2064                         /*
2065                          *      Reinitialize Authenticators.
2066                          */
2067                         memcpy(&ptr[2], msg_auth_vector, AUTH_VECTOR_LEN);
2068                         memcpy(packet->data + 4, packet->vector, AUTH_VECTOR_LEN);
2069                         break;
2070                 } /* switch over the attributes */
2071
2072                 ptr += attrlen;
2073                 length -= attrlen;
2074         } /* loop over the packet, sanity checking the attributes */
2075
2076         /*
2077          *      It looks like a RADIUS packet, but we can't validate
2078          *      the signature.
2079          */
2080         if ((packet->code == 0) || (packet->code >= FR_MAX_PACKET_CODE)) {
2081                 char buffer[32];
2082                 fr_strerror_printf("Received Unknown packet code %d "
2083                            "from client %s port %d: Cannot validate signature.",
2084                            packet->code,
2085                            inet_ntop(packet->src_ipaddr.af,
2086                                      &packet->src_ipaddr.ipaddr,
2087                                      buffer, sizeof(buffer)),
2088                            packet->src_port);
2089                 return -1;
2090         }
2091
2092         /*
2093          *      Calculate and/or verify digest.
2094          */
2095         switch(packet->code) {
2096                 int rcode;
2097                 char buffer[32];
2098
2099                 case PW_AUTHENTICATION_REQUEST:
2100                 case PW_STATUS_SERVER:
2101                         /*
2102                          *      The authentication vector is random
2103                          *      nonsense, invented by the client.
2104                          */
2105                         break;
2106
2107                 case PW_COA_REQUEST:
2108                 case PW_DISCONNECT_REQUEST:
2109                 case PW_ACCOUNTING_REQUEST:
2110                         if (calc_acctdigest(packet, secret) > 1) {
2111                                 fr_strerror_printf("Received %s packet "
2112                                            "from %s with invalid signature!  (Shared secret is incorrect.)",
2113                                            fr_packet_codes[packet->code],
2114                                            inet_ntop(packet->src_ipaddr.af,
2115                                                      &packet->src_ipaddr.ipaddr,
2116                                                      buffer, sizeof(buffer)));
2117                                 return -1;
2118                         }
2119                         break;
2120
2121                         /* Verify the reply digest */
2122                 case PW_AUTHENTICATION_ACK:
2123                 case PW_AUTHENTICATION_REJECT:
2124                 case PW_ACCESS_CHALLENGE:
2125                 case PW_ACCOUNTING_RESPONSE:
2126                 case PW_DISCONNECT_ACK:
2127                 case PW_DISCONNECT_NAK:
2128                 case PW_COA_ACK:
2129                 case PW_COA_NAK:
2130                         rcode = calc_replydigest(packet, original, secret);
2131                         if (rcode > 1) {
2132                                 fr_strerror_printf("Received %s packet "
2133                                            "from client %s port %d with invalid signature (err=%d)!  (Shared secret is incorrect.)",
2134                                            fr_packet_codes[packet->code],
2135                                            inet_ntop(packet->src_ipaddr.af,
2136                                                      &packet->src_ipaddr.ipaddr,
2137                                                      buffer, sizeof(buffer)),
2138                                            packet->src_port,
2139                                            rcode);
2140                                 return -1;
2141                         }
2142                         break;
2143
2144                 default:
2145                         fr_strerror_printf("Received Unknown packet code %d "
2146                                    "from client %s port %d: Cannot validate signature",
2147                                    packet->code,
2148                                    inet_ntop(packet->src_ipaddr.af,
2149                                              &packet->src_ipaddr.ipaddr,
2150                                                      buffer, sizeof(buffer)),
2151                                    packet->src_port);
2152                         return -1;
2153         }
2154
2155         return 0;
2156 }
2157
2158
2159 static VALUE_PAIR *data2vp(const RADIUS_PACKET *packet,
2160                            const RADIUS_PACKET *original,
2161                            const char *secret, size_t length,
2162                            const uint8_t *data, VALUE_PAIR *vp)
2163 {
2164         int offset = 0;
2165
2166         /*
2167          *      If length is greater than 253, something is SERIOUSLY
2168          *      wrong.
2169          */
2170         if (length > 253) length = 253; /* paranoia (pair-anoia?) */
2171
2172         vp->length = length;
2173         vp->operator = T_OP_EQ;
2174         vp->next = NULL;
2175
2176         /*
2177          *      Handle tags.
2178          */
2179         if (vp->flags.has_tag) {
2180                 if (TAG_VALID(data[0]) ||
2181                     (vp->flags.encrypt == FLAG_ENCRYPT_TUNNEL_PASSWORD)) {
2182                         /*
2183                          *      Tunnel passwords REQUIRE a tag, even
2184                          *      if don't have a valid tag.
2185                          */
2186                         vp->flags.tag = data[0];
2187
2188                         if ((vp->type == PW_TYPE_STRING) ||
2189                             (vp->type == PW_TYPE_OCTETS)) offset = 1;
2190                 }
2191         }
2192
2193         /*
2194          *      Copy the data to be decrypted
2195          */
2196         memcpy(&vp->vp_octets[0], data + offset, length - offset);
2197         vp->length -= offset;
2198
2199         /*
2200          *      Decrypt the attribute.
2201          */
2202         switch (vp->flags.encrypt) {
2203                 /*
2204                  *  User-Password
2205                  */
2206         case FLAG_ENCRYPT_USER_PASSWORD:
2207                 if (original) {
2208                         rad_pwdecode((char *)vp->vp_strvalue,
2209                                      vp->length, secret,
2210                                      original->vector);
2211                 } else {
2212                         rad_pwdecode((char *)vp->vp_strvalue,
2213                                      vp->length, secret,
2214                                      packet->vector);
2215                 }
2216                 if (vp->attribute == PW_USER_PASSWORD) {
2217                         vp->length = strlen(vp->vp_strvalue);
2218                 }
2219                 break;
2220
2221                 /*
2222                  *      Tunnel-Password's may go ONLY
2223                  *      in response packets.
2224                  */
2225         case FLAG_ENCRYPT_TUNNEL_PASSWORD:
2226                 if (!original) goto raw;
2227
2228                 if (rad_tunnel_pwdecode(vp->vp_octets, &vp->length,
2229                                         secret, original->vector) < 0) {
2230                         goto raw;
2231                 }
2232                 break;
2233
2234                 /*
2235                  *  Ascend-Send-Secret
2236                  *  Ascend-Receive-Secret
2237                  */
2238         case FLAG_ENCRYPT_ASCEND_SECRET:
2239                 if (!original) {
2240                         goto raw;
2241                 } else {
2242                         uint8_t my_digest[AUTH_VECTOR_LEN];
2243                         make_secret(my_digest,
2244                                     original->vector,
2245                                     secret, data);
2246                         memcpy(vp->vp_strvalue, my_digest,
2247                                AUTH_VECTOR_LEN );
2248                         vp->vp_strvalue[AUTH_VECTOR_LEN] = '\0';
2249                         vp->length = strlen(vp->vp_strvalue);
2250                 }
2251                 break;
2252
2253         default:
2254                 break;
2255         } /* switch over encryption flags */
2256
2257
2258         switch (vp->type) {
2259         case PW_TYPE_STRING:
2260         case PW_TYPE_OCTETS:
2261         case PW_TYPE_ABINARY:
2262                 /* nothing more to do */
2263                 break;
2264
2265         case PW_TYPE_BYTE:
2266                 if (vp->length != 1) goto raw;
2267
2268                 vp->vp_integer = vp->vp_octets[0];
2269                 break;
2270
2271
2272         case PW_TYPE_SHORT:
2273                 if (vp->length != 2) goto raw;
2274
2275                 vp->vp_integer = (vp->vp_octets[0] << 8) | vp->vp_octets[1];
2276                 break;
2277
2278         case PW_TYPE_INTEGER:
2279                 if (vp->length != 4) goto raw;
2280
2281                 memcpy(&vp->vp_integer, vp->vp_octets, 4);
2282                 vp->vp_integer = ntohl(vp->vp_integer);
2283
2284                 if (vp->flags.has_tag) vp->vp_integer &= 0x00ffffff;
2285
2286                 /*
2287                  *      Try to get named VALUEs
2288                  */
2289                 {
2290                         DICT_VALUE *dval;
2291                         dval = dict_valbyattr(vp->attribute, vp->vendor,
2292                                               vp->vp_integer);
2293                         if (dval) {
2294                                 strlcpy(vp->vp_strvalue,
2295                                         dval->name,
2296                                         sizeof(vp->vp_strvalue));
2297                         }
2298                 }
2299                 break;
2300
2301         case PW_TYPE_DATE:
2302                 if (vp->length != 4) goto raw;
2303
2304                 memcpy(&vp->vp_date, vp->vp_octets, 4);
2305                 vp->vp_date = ntohl(vp->vp_date);
2306                 break;
2307
2308
2309         case PW_TYPE_IPADDR:
2310                 if (vp->length != 4) goto raw;
2311
2312                 memcpy(&vp->vp_ipaddr, vp->vp_octets, 4);
2313                 break;
2314
2315                 /*
2316                  *      IPv6 interface ID is 8 octets long.
2317                  */
2318         case PW_TYPE_IFID:
2319                 if (vp->length != 8) goto raw;
2320                 /* vp->vp_ifid == vp->vp_octets */
2321                 break;
2322
2323                 /*
2324                  *      IPv6 addresses are 16 octets long
2325                  */
2326         case PW_TYPE_IPV6ADDR:
2327                 if (vp->length != 16) goto raw;
2328                 /* vp->vp_ipv6addr == vp->vp_octets */
2329                 break;
2330
2331                 /*
2332                  *      IPv6 prefixes are 2 to 18 octets long.
2333                  *
2334                  *      RFC 3162: The first octet is unused.
2335                  *      The second is the length of the prefix
2336                  *      the rest are the prefix data.
2337                  *
2338                  *      The prefix length can have value 0 to 128.
2339                  */
2340         case PW_TYPE_IPV6PREFIX:
2341                 if (vp->length < 2 || vp->length > 18) goto raw;
2342                 if (vp->vp_octets[1] > 128) goto raw;
2343
2344                 /*
2345                  *      FIXME: double-check that
2346                  *      (vp->vp_octets[1] >> 3) matches vp->length + 2
2347                  */
2348                 if (vp->length < 18) {
2349                         memset(vp->vp_octets + vp->length, 0,
2350                                18 - vp->length);
2351                 }
2352                 break;
2353
2354         case PW_TYPE_SIGNED:
2355                 if (vp->length != 4) goto raw;
2356
2357                 /*
2358                  *      Overload vp_integer for ntohl, which takes
2359                  *      uint32_t, not int32_t
2360                  */
2361                 memcpy(&vp->vp_integer, vp->vp_octets, 4);
2362                 vp->vp_integer = ntohl(vp->vp_integer);
2363                 memcpy(&vp->vp_signed, &vp->vp_integer, 4);
2364                 break;
2365
2366         case PW_TYPE_TLV:
2367                 vp->length = length;
2368                 vp->vp_tlv = malloc(length);
2369                 if (!vp->vp_tlv) {
2370                         pairfree(&vp);
2371                         fr_strerror_printf("No memory");
2372                         return NULL;
2373                 }
2374                 memcpy(vp->vp_tlv, data, length);
2375                 break;
2376
2377         case PW_TYPE_COMBO_IP:
2378                 if (vp->length == 4) {
2379                         vp->type = PW_TYPE_IPADDR;
2380                         memcpy(&vp->vp_ipaddr, vp->vp_octets, 4);
2381                         break;
2382
2383                 } else if (vp->length == 16) {
2384                         vp->type = PW_TYPE_IPV6ADDR;
2385                         /* vp->vp_ipv6addr == vp->vp_octets */
2386                         break;
2387
2388                 }
2389                 /* FALL-THROUGH */
2390
2391         default:
2392         raw:
2393                 vp->type = PW_TYPE_OCTETS;
2394                 vp->length = length;
2395                 memcpy(vp->vp_octets, data, length);
2396
2397
2398                 /*
2399                  *      Ensure there's no encryption or tag stuff,
2400                  *      we just pass the attribute as-is.
2401                  */
2402                 memset(&vp->flags, 0, sizeof(vp->flags));
2403         }
2404
2405         return vp;
2406 }
2407
2408 static void rad_sortvp(VALUE_PAIR **head)
2409 {
2410         int swapped;
2411         VALUE_PAIR *vp, **tail;
2412
2413         /*
2414          *      Walk over the VP's, sorting them in order.  Did I
2415          *      mention that I hate WiMAX continuations?
2416          *
2417          *      And bubble sort!  WTF is up with that?
2418          */
2419         do {
2420                 swapped = 0;
2421                 tail = head;
2422                 while (*tail) {
2423                         vp = *tail;
2424                         if (!vp->next) break;
2425
2426                         if (vp->attribute > vp->next->attribute) {
2427                                 *tail = vp->next;
2428                                 vp->next = (*tail)->next;
2429                                 (*tail)->next = vp;
2430                                 swapped = 1;
2431                         }
2432                         tail = &(vp->next);
2433                 }
2434         } while (swapped);
2435 }
2436
2437
2438 /*
2439  *      Walk the packet, looking for continuations of this attribute.
2440  *
2441  *      This is (worst-case) O(N^2) in the number of RADIUS
2442  *      attributes.  That happens only when perverse clients create
2443  *      continued attributes, AND separate the fragmented portions
2444  *      with a lot of other attributes.
2445  *
2446  *      Sane clients should put the fragments next to each other, in
2447  *      which case this is O(N), in the number of fragments.
2448  */
2449 static uint8_t *rad_coalesce(unsigned int attribute, int vendor,
2450                              size_t length, uint8_t *data,
2451                              size_t packet_length, size_t *ptlv_length)
2452
2453 {
2454         uint32_t lvalue;
2455         size_t tlv_length = length;
2456         uint8_t *ptr, *tlv, *tlv_data;
2457
2458         for (ptr = data + length;
2459              ptr != (data + packet_length);
2460              ptr += ptr[1]) {
2461                 /* FIXME: Check that there are 6 bytes of data here... */
2462                 if ((ptr[0] != PW_VENDOR_SPECIFIC) ||
2463                     (ptr[1] < (2 + 4 + 3)) || /* WiMAX VSA with continuation */
2464                     (ptr[2] != 0) || (ptr[3] != 0) ||  /* our requirement */
2465                     (ptr[4] != ((vendor >> 8) & 0xff)) ||
2466                     (ptr[5] != (vendor & 0xff))) {
2467                         continue;
2468                 }
2469
2470                 memcpy(&lvalue, ptr + 2, 4); /* Vendor Id */
2471                 lvalue = ntohl(lvalue);
2472                 lvalue <<= 16;
2473                 lvalue |= ptr[2 + 4]; /* add in VSA number */
2474                 if (lvalue != attribute) continue;
2475
2476                 /*
2477                  *      If the vendor-length is too small, it's badly
2478                  *      formed, so we stop.
2479                  */
2480                 if ((ptr[2 + 4 + 1]) < 3) break;
2481
2482                 tlv_length += ptr[2 + 4 + 1] - 3;
2483                 if ((ptr[2 + 4 + 1 + 1] & 0x80) == 0) break;
2484         }
2485
2486         tlv = tlv_data = malloc(tlv_length);
2487         if (!tlv_data) return NULL;
2488
2489         memcpy(tlv, data, length);
2490         tlv += length;
2491
2492         /*
2493          *      Now we walk the list again, copying the data over to
2494          *      our newly created memory.
2495          */
2496         for (ptr = data + length;
2497              ptr != (data + packet_length);
2498              ptr += ptr[1]) {
2499                 int this_length;
2500
2501                 if ((ptr[0] != PW_VENDOR_SPECIFIC) ||
2502                     (ptr[1] < (2 + 4 + 3)) || /* WiMAX VSA with continuation */
2503                     (ptr[2] != 0) || (ptr[3] != 0)) { /* our requirement */
2504                         continue;
2505                 }
2506
2507                 memcpy(&lvalue, ptr + 2, 4);
2508                 lvalue = ntohl(lvalue);
2509                 lvalue <<= 16;
2510                 lvalue |= ptr[2 + 4];
2511                 if (lvalue != attribute) continue;
2512
2513                 /*
2514                  *      If the vendor-length is too small, it's badly
2515                  *      formed, so we stop.
2516                  */
2517                 if ((ptr[2 + 4 + 1]) < 3) break;
2518
2519                 this_length = ptr[2 + 4 + 1] - 3;
2520                 memcpy(tlv, ptr + 2 + 4 + 3, this_length);
2521                 tlv += this_length;
2522
2523                 ptr[2 + 4] = 0; /* What a hack! */
2524                 if ((ptr[2 + 4 + 1 + 1] & 0x80) == 0) break;
2525         }
2526
2527         *ptlv_length = tlv_length;
2528         return tlv_data;
2529 }
2530
2531 /*
2532  *      Walk over Evil WIMAX Hell, creating attributes.
2533  *
2534  *      Won't someone think of the children?  What if they read this code?
2535  */
2536 static VALUE_PAIR *recurse_evil(const RADIUS_PACKET *packet,
2537                                 const RADIUS_PACKET *original,
2538                                 const char *secret,
2539                                 int attribute, int vendor,
2540                                 uint8_t *ptr, size_t len, int shift)
2541 {
2542         VALUE_PAIR *head = NULL;
2543         VALUE_PAIR **tail = &head;
2544         VALUE_PAIR *vp;
2545         uint8_t *y;             /* why do I need to do this? */
2546
2547         if (shift > 24) return NULL;
2548
2549         /*
2550          *      Sanity check the attribute.
2551          */
2552         for (y = ptr; y < (ptr + len); y += y[1]) {
2553                 if ((y[0] == 0) || ((y + 2) > (ptr + len)) ||
2554                     (y[1] < 2) || ((y + y[1]) > (ptr + len))) {
2555                         return NULL;
2556                 }
2557         }
2558
2559         for (y = ptr; y < (ptr + len); y += y[1]) {
2560                 DICT_ATTR *da;
2561
2562                 da = dict_attrbyvalue(attribute | (ptr[0] << shift), vendor);
2563                 if (da && (da->type == PW_TYPE_TLV)) {
2564                         vp = recurse_evil(packet, original, secret,
2565                                           attribute | (ptr[0] << shift),
2566                                           vendor, ptr + 2, ptr[1] - 2,
2567                                           shift + 8);
2568                         if (!vp) goto error;
2569                 } else {
2570                         vp = paircreate(attribute | (ptr[0] << shift), vendor,
2571                                         PW_TYPE_OCTETS);
2572                         if (!vp) {
2573                         error:
2574                                 pairfree(&head);
2575                                 return NULL;
2576                         }
2577
2578                         if (!data2vp(packet, original, secret,
2579                                      y[1] - 2, y + 2, vp)) {
2580                                 goto error;
2581                         }
2582                 }
2583
2584                 *tail = vp;
2585                 while (*tail) tail = &((*tail)->next);
2586         }
2587
2588         return head;
2589 }
2590
2591 /*
2592  *      Start at the *data* portion of a continued attribute.  search
2593  *      through the rest of the attributes to find a matching one, and
2594  *      add it's contents to our contents.
2595  */
2596 static VALUE_PAIR *rad_continuation2vp(const RADIUS_PACKET *packet,
2597                                        const RADIUS_PACKET *original,
2598                                        const char *secret, int attribute,
2599                                        int vendor,
2600                                        int length, /* CANNOT be zero */
2601                                        uint8_t *data, size_t packet_length,
2602                                        int flag, DICT_ATTR *da)
2603 {
2604         size_t tlv_length, left;
2605         uint8_t *ptr;
2606         uint8_t *tlv_data;
2607         VALUE_PAIR *vp, *head, **tail;
2608         DICT_ATTR *tlv_da;
2609
2610         /*
2611          *      Ensure we have data that hasn't been split across
2612          *      multiple attributes.
2613          */
2614         if (flag) {
2615                 tlv_data = rad_coalesce(attribute, vendor, length,
2616                                         data, packet_length, &tlv_length);
2617                 if (!tlv_data) return NULL;
2618         } else {
2619                 tlv_data = data;
2620                 tlv_length = length;
2621         }
2622
2623         /*
2624          *      Non-TLV types cannot be continued across multiple
2625          *      attributes.  This is true even of keys that are
2626          *      encrypted with the tunnel-password method.  The spec
2627          *      says that they can be continued... but also that the
2628          *      keys are 160 bits, which means that they CANNOT be
2629          *      continued.  <sigh>
2630          *
2631          *      Note that we don't check "flag" here.  The calling
2632          *      code ensures that
2633          */
2634         if (!da || (da->type != PW_TYPE_TLV)) {
2635         not_well_formed:
2636                 if (tlv_data == data) { /* true if we had 'goto' */
2637                         tlv_data = malloc(tlv_length);
2638                         if (!tlv_data) return NULL;
2639                         memcpy(tlv_data, data, tlv_length);
2640                 }
2641
2642                 vp = paircreate(attribute, vendor, PW_TYPE_OCTETS);
2643                 if (!vp) return NULL;
2644
2645                 vp->type = PW_TYPE_TLV;
2646                 vp->flags.encrypt = FLAG_ENCRYPT_NONE;
2647                 vp->flags.has_tag = 0;
2648                 vp->flags.is_tlv = 0;
2649                 vp->vp_tlv = tlv_data;
2650                 vp->length = tlv_length;
2651                 return vp;
2652         } /* else it WAS a TLV, go decode the sub-tlv's */
2653
2654         /*
2655          *      Now (sigh) we walk over the TLV, seeing if it is
2656          *      well-formed.
2657          */
2658         left = tlv_length;
2659         for (ptr = tlv_data;
2660              ptr != (tlv_data + tlv_length);
2661              ptr += ptr[1]) {
2662                 if ((left < 2) ||
2663                     (ptr[1] < 2) ||
2664                     (ptr[1] > left)) {
2665                         goto not_well_formed;
2666                 }
2667
2668                 left -= ptr[1];
2669         }
2670
2671         /*
2672          *      Now we walk over the TLV *again*, creating sub-tlv's.
2673          */
2674         head = NULL;
2675         tail = &head;
2676
2677         for (ptr = tlv_data;
2678              ptr != (tlv_data + tlv_length);
2679              ptr += ptr[1]) {
2680
2681                 tlv_da = dict_attrbyvalue(attribute | (ptr[0] << 8), vendor);
2682                 if (tlv_da && (tlv_da->type == PW_TYPE_TLV)) {
2683                         vp = recurse_evil(packet, original, secret,
2684                                           attribute | (ptr[0] << 8),
2685                                           vendor, ptr + 2, ptr[1] - 2, 16);
2686
2687                         if (!vp) {
2688                                 pairfree(&head);
2689                                 goto not_well_formed;
2690                         }
2691                 } else {
2692                         vp = paircreate(attribute | (ptr[0] << 8), vendor,
2693                                         PW_TYPE_OCTETS);
2694                         if (!vp) {
2695                                 pairfree(&head);
2696                                 goto not_well_formed;
2697                         }
2698
2699                         if (!data2vp(packet, original, secret,
2700                                      ptr[1] - 2, ptr + 2, vp)) {
2701                                 pairfree(&head);
2702                                 goto not_well_formed;
2703                         }
2704                 }
2705
2706                 *tail = vp;
2707
2708                 while (*tail) tail = &((*tail)->next);
2709         }
2710
2711         /*
2712          *      TLV's MAY be continued, but sometimes they're not.
2713          */
2714         if (tlv_data != data) free(tlv_data);
2715
2716         if (head->next) rad_sortvp(&head);
2717
2718         return head;
2719 }
2720
2721
2722 /*
2723  *      Parse a RADIUS attribute into a data structure.
2724  */
2725 VALUE_PAIR *rad_attr2vp(const RADIUS_PACKET *packet,
2726                         const RADIUS_PACKET *original,
2727                         const char *secret, int attribute, int vendor,
2728                         int length, const uint8_t *data)
2729 {
2730         VALUE_PAIR *vp;
2731
2732         vp = paircreate(attribute, vendor, PW_TYPE_OCTETS);
2733         if (!vp) return NULL;
2734
2735         return data2vp(packet, original, secret, length, data, vp);
2736 }
2737
2738
2739 /*
2740  *      Calculate/check digest, and decode radius attributes.
2741  *      Returns:
2742  *      -1 on decoding error
2743  *      0 on success
2744  */
2745 int rad_decode(RADIUS_PACKET *packet, RADIUS_PACKET *original,
2746                const char *secret)
2747 {
2748         uint32_t                lvalue;
2749         uint32_t                vendorcode;
2750         VALUE_PAIR              **tail;
2751         VALUE_PAIR              *pair;
2752         uint8_t                 *ptr, *vsa_ptr;
2753         int                     packet_length;
2754         int                     attribute;
2755         int                     attrlen;
2756         int                     vendorlen;
2757         radius_packet_t         *hdr;
2758         int                     vsa_tlen, vsa_llen, vsa_offset;
2759         DICT_VENDOR             *dv = NULL;
2760         int                     num_attributes = 0;
2761
2762         /*
2763          *      Extract attribute-value pairs
2764          */
2765         hdr = (radius_packet_t *)packet->data;
2766         ptr = hdr->data;
2767         packet_length = packet->data_len - AUTH_HDR_LEN;
2768
2769         /*
2770          *      There may be VP's already in the packet.  Don't
2771          *      destroy them.
2772          */
2773         for (tail = &packet->vps; *tail != NULL; tail = &((*tail)->next)) {
2774                 /* nothing */
2775         }
2776
2777         vendorcode = 0;
2778         vendorlen  = 0;
2779         vsa_tlen = vsa_llen = 1;
2780         vsa_offset = 0;
2781
2782         /*
2783          *      We have to read at least two bytes.
2784          *
2785          *      rad_recv() above ensures that this is OK.
2786          */
2787         while (packet_length > 0) {
2788                 attribute = -1;
2789                 attrlen = -1;
2790
2791                 /*
2792                  *      Normal attribute, handle it like normal.
2793                  */
2794                 if (vendorcode == 0) {
2795                         /*
2796                          *      No room to read attr/length,
2797                          *      or bad attribute, or attribute is
2798                          *      too short, or attribute is too long,
2799                          *      stop processing the packet.
2800                          */
2801                         if ((packet_length < 2) ||
2802                             (ptr[0] == 0) ||  (ptr[1] < 2) ||
2803                             (ptr[1] > packet_length)) break;
2804
2805                         attribute = *ptr++;
2806                         attrlen   = *ptr++;
2807
2808                         attrlen -= 2;
2809                         packet_length  -= 2;
2810
2811                         if (attribute != PW_VENDOR_SPECIFIC) goto create_pair;
2812
2813                         /*
2814                          *      No vendor code, or ONLY vendor code.
2815                          */
2816                         if (attrlen <= 4) goto create_pair;
2817
2818                         vendorlen = 0;
2819                 }
2820
2821                 /*
2822                  *      Handle Vendor-Specific
2823                  */
2824                 if (vendorlen == 0) {
2825                         uint8_t *subptr;
2826                         int sublen;
2827                         int myvendor;
2828
2829                         /*
2830                          *      attrlen was checked above.
2831                          */
2832                         memcpy(&lvalue, ptr, 4);
2833                         myvendor = ntohl(lvalue);
2834
2835                         /*
2836                          *      Zero isn't allowed.
2837                          */
2838                         if (myvendor == 0) goto create_pair;
2839
2840                         /*
2841                          *      This is an implementation issue.
2842                          *      We currently pack vendor into the upper
2843                          *      16 bits of a 32-bit attribute number,
2844                          *      so we can't handle vendor numbers larger
2845                          *      than 16 bits.
2846                          */
2847                         if (myvendor > 65535) goto create_pair;
2848
2849                         vsa_tlen = vsa_llen = 1;
2850                         vsa_offset = 0;
2851                         dv = dict_vendorbyvalue(myvendor);
2852                         if (dv) {
2853                                 vsa_tlen = dv->type;
2854                                 vsa_llen = dv->length;
2855                                 if (dv->flags) vsa_offset = 1;
2856                         }
2857
2858                         /*
2859                          *      Sweep through the list of VSA's,
2860                          *      seeing if they exactly fill the
2861                          *      outer Vendor-Specific attribute.
2862                          *
2863                          *      If not, create a raw Vendor-Specific.
2864                          */
2865                         subptr = ptr + 4;
2866                         sublen = attrlen - 4;
2867
2868                         /*
2869                          *      See if we can parse it.
2870                          */
2871                         do {
2872                                 int myattr = 0;
2873
2874                                 /*
2875                                  *      Not enough room for one more
2876                                  *      attribute.  Die!
2877                                  */
2878                                 if (sublen < (vsa_tlen + vsa_llen + vsa_offset)) goto create_pair;
2879
2880                                 /*
2881                                  *      Ensure that the attribute number
2882                                  *      is OK.
2883                                  */
2884                                 switch (vsa_tlen) {
2885                                 case 1:
2886                                         myattr = subptr[0];
2887                                         break;
2888
2889                                 case 2:
2890                                         myattr = (subptr[0] << 8) | subptr[1];
2891                                         break;
2892
2893                                 case 4:
2894                                         if ((subptr[0] != 0) ||
2895                                             (subptr[1] != 0)) goto create_pair;
2896
2897                                         myattr = (subptr[2] << 8) | subptr[3];
2898                                         break;
2899
2900                                         /*
2901                                          *      Our dictionary is broken.
2902                                          */
2903                                 default:
2904                                         goto create_pair;
2905                                 }
2906
2907                                 switch (vsa_llen) {
2908                                 case 0:
2909                                         attribute = myattr;
2910                                         ptr += 4 + vsa_tlen;
2911                                         attrlen -= (4 + vsa_tlen);
2912                                         packet_length -= 4 + vsa_tlen;
2913                                         goto create_pair;
2914
2915                                 case 1:
2916                                         if (subptr[vsa_tlen] < (vsa_tlen + vsa_llen + vsa_offset))
2917                                                 goto create_pair;
2918
2919                                         if (subptr[vsa_tlen] > sublen)
2920                                                 goto create_pair;
2921
2922                                         /*
2923                                          *      WiMAX: 0bCrrrrrrr
2924                                          *      Reserved bits MUST be
2925                                          *      zero.
2926                                          */
2927                                         if (vsa_offset &&
2928                                             ((subptr[vsa_tlen + vsa_llen] & 0x7f) != 0))
2929                                                 goto create_pair;
2930
2931                                         sublen -= subptr[vsa_tlen];
2932                                         subptr += subptr[vsa_tlen];
2933                                         break;
2934
2935                                 case 2:
2936                                         if (subptr[vsa_tlen] != 0) goto create_pair;
2937                                         if (subptr[vsa_tlen + 1] < (vsa_tlen + vsa_llen))
2938                                                 goto create_pair;
2939                                         if (subptr[vsa_tlen + 1] > sublen)
2940                                                 goto create_pair;
2941                                         sublen -= subptr[vsa_tlen + 1];
2942                                         subptr += subptr[vsa_tlen + 1];
2943                                         break;
2944
2945                                         /*
2946                                          *      Our dictionaries are
2947                                          *      broken.
2948                                          */
2949                                 default:
2950                                         goto create_pair;
2951                                 }
2952                         } while (sublen > 0);
2953
2954                         vendorcode = myvendor;
2955                         vendorlen = attrlen - 4;
2956                         packet_length -= 4;
2957
2958                         ptr += 4;
2959                 }
2960
2961                 /*
2962                  *      attrlen is the length of this attribute.
2963                  *      total_len is the length of the encompassing
2964                  *      attribute.
2965                  */
2966                 switch (vsa_tlen) {
2967                 case 1:
2968                         attribute = ptr[0];
2969                         break;
2970
2971                 case 2:
2972                         attribute = (ptr[0] << 8) | ptr[1];
2973                         break;
2974
2975                 default:        /* can't hit this. */
2976                         return -1;
2977                 }
2978                 vsa_ptr = ptr;
2979                 ptr += vsa_tlen;
2980
2981                 switch (vsa_llen) {
2982                 case 1:
2983                         attrlen = ptr[0] - (vsa_tlen + vsa_llen + vsa_offset);
2984                         break;
2985
2986                 case 2:
2987                         attrlen = ptr[1] - (vsa_tlen + vsa_llen);
2988                         break;
2989
2990                 default:        /* can't hit this. */
2991                         return -1;
2992                 }
2993
2994                 ptr += vsa_llen + vsa_offset;
2995                 vendorlen -= vsa_tlen + vsa_llen + vsa_offset + attrlen;
2996                 packet_length -= (vsa_tlen + vsa_llen + vsa_offset);
2997
2998                 /*
2999                  *      Ignore VSAs that have no data.
3000                  */
3001                 if (attrlen == 0) goto next;
3002
3003                 /*
3004                  *      WiMAX attributes of type 0 are ignored.  They
3005                  *      are a secret flag to us that the attribute has
3006                  *      already been dealt with.
3007                  */
3008                 if ((vendorcode == VENDORPEC_WIMAX) && (attribute == 0)) {
3009                         goto next;
3010                 }
3011
3012                 if (vsa_offset) {
3013                         DICT_ATTR *da;
3014
3015                         da = dict_attrbyvalue(attribute, vendorcode);
3016
3017                         /*
3018                          *      If it's NOT continued, AND we know
3019                          *      about it, AND it's not a TLV, we can
3020                          *      create a normal pair.
3021                          */
3022                         if (((vsa_ptr[2] & 0x80) == 0) &&
3023                             da && (da->type != PW_TYPE_TLV)) goto create_pair;
3024
3025                         /*
3026                          *      Else it IS continued, or it's a TLV.
3027                          *      Go do a lot of work to find the stuff.
3028                          */
3029                         pair = rad_continuation2vp(packet, original, secret,
3030                                                    attribute, vendorcode,
3031                                                    attrlen, ptr,
3032                                                    packet_length,
3033                                                    ((vsa_ptr[2] & 0x80) != 0),
3034                                                    da);
3035                         goto created_pair;
3036                 }
3037
3038                 /*
3039                  *      Create the attribute, setting the default type
3040                  *      to 'octets'.  If the type in the dictionary
3041                  *      is different, then the dictionary type will
3042                  *      over-ride this one.
3043                  *
3044                  *      If the attribute has no data, then discard it.
3045                  *
3046                  *      Unless it's CUI.  Damn you, CUI!
3047                  */
3048         create_pair:
3049                 if (!attrlen &&
3050                     (attribute != PW_CHARGEABLE_USER_IDENTITY)) goto next;
3051
3052                 pair = rad_attr2vp(packet, original, secret,
3053                                    attribute, vendorcode, attrlen, ptr);
3054                 if (!pair) {
3055                         pairfree(&packet->vps);
3056                         fr_strerror_printf("out of memory");
3057                         return -1;
3058                 }
3059
3060         created_pair:
3061                 *tail = pair;
3062                 while (pair) {
3063                         num_attributes++;
3064                         debug_pair(pair);
3065                         tail = &pair->next;
3066                         pair = pair->next;
3067                 }
3068
3069                 /*
3070                  *      VSA's may not have been counted properly in
3071                  *      rad_packet_ok() above, as it is hard to count
3072                  *      then without using the dictionary.  We
3073                  *      therefore enforce the limits here, too.
3074                  */
3075                 if ((fr_max_attributes > 0) &&
3076                     (num_attributes > fr_max_attributes)) {
3077                         char host_ipaddr[128];
3078
3079                         pairfree(&packet->vps);
3080                         fr_strerror_printf("WARNING: Possible DoS attack from host %s: Too many attributes in request (received %d, max %d are allowed).",
3081                                    inet_ntop(packet->src_ipaddr.af,
3082                                              &packet->src_ipaddr.ipaddr,
3083                                              host_ipaddr, sizeof(host_ipaddr)),
3084                                    num_attributes, fr_max_attributes);
3085                         return -1;
3086                 }
3087
3088         next:
3089                 if (vendorlen == 0) vendorcode = 0;
3090                 ptr += attrlen;
3091                 packet_length -= attrlen;
3092         }
3093
3094         /*
3095          *      Merge information from the outside world into our
3096          *      random pool.
3097          */
3098         fr_rand_seed(packet->data, AUTH_HDR_LEN);
3099
3100         return 0;
3101 }
3102
3103
3104 /*
3105  *      Encode password.
3106  *
3107  *      We assume that the passwd buffer passed is big enough.
3108  *      RFC2138 says the password is max 128 chars, so the size
3109  *      of the passwd buffer must be at least 129 characters.
3110  *      Preferably it's just MAX_STRING_LEN.
3111  *
3112  *      int *pwlen is updated to the new length of the encrypted
3113  *      password - a multiple of 16 bytes.
3114  */
3115 int rad_pwencode(char *passwd, size_t *pwlen, const char *secret,
3116                  const uint8_t *vector)
3117 {
3118         FR_MD5_CTX context, old;
3119         uint8_t digest[AUTH_VECTOR_LEN];
3120         int     i, n, secretlen;
3121         int     len;
3122
3123         /*
3124          *      RFC maximum is 128 bytes.
3125          *
3126          *      If length is zero, pad it out with zeros.
3127          *
3128          *      If the length isn't aligned to 16 bytes,
3129          *      zero out the extra data.
3130          */
3131         len = *pwlen;
3132
3133         if (len > 128) len = 128;
3134
3135         if (len == 0) {
3136                 memset(passwd, 0, AUTH_PASS_LEN);
3137                 len = AUTH_PASS_LEN;
3138         } else if ((len % AUTH_PASS_LEN) != 0) {
3139                 memset(&passwd[len], 0, AUTH_PASS_LEN - (len % AUTH_PASS_LEN));
3140                 len += AUTH_PASS_LEN - (len % AUTH_PASS_LEN);
3141         }
3142         *pwlen = len;
3143
3144         /*
3145          *      Use the secret to setup the decryption digest
3146          */
3147         secretlen = strlen(secret);
3148
3149         fr_MD5Init(&context);
3150         fr_MD5Update(&context, (const uint8_t *) secret, secretlen);
3151         old = context;          /* save intermediate work */
3152
3153         /*
3154          *      Encrypt it in place.  Don't bother checking
3155          *      len, as we've ensured above that it's OK.
3156          */
3157         for (n = 0; n < len; n += AUTH_PASS_LEN) {
3158                 if (n == 0) {
3159                         fr_MD5Update(&context, vector, AUTH_PASS_LEN);
3160                         fr_MD5Final(digest, &context);
3161                 } else {
3162                         context = old;
3163                         fr_MD5Update(&context,
3164                                      (uint8_t *) passwd + n - AUTH_PASS_LEN,
3165                                      AUTH_PASS_LEN);
3166                         fr_MD5Final(digest, &context);
3167                 }
3168
3169                 for (i = 0; i < AUTH_PASS_LEN; i++) {
3170                         passwd[i + n] ^= digest[i];
3171                 }
3172         }
3173
3174         return 0;
3175 }
3176
3177 /*
3178  *      Decode password.
3179  */
3180 int rad_pwdecode(char *passwd, size_t pwlen, const char *secret,
3181                  const uint8_t *vector)
3182 {
3183         FR_MD5_CTX context, old;
3184         uint8_t digest[AUTH_VECTOR_LEN];
3185         int     i;
3186         size_t  n, secretlen;
3187
3188         /*
3189          *      The RFC's say that the maximum is 128.
3190          *      The buffer we're putting it into above is 254, so
3191          *      we don't need to do any length checking.
3192          */
3193         if (pwlen > 128) pwlen = 128;
3194
3195         /*
3196          *      Catch idiots.
3197          */
3198         if (pwlen == 0) goto done;
3199
3200         /*
3201          *      Use the secret to setup the decryption digest
3202          */
3203         secretlen = strlen(secret);
3204
3205         fr_MD5Init(&context);
3206         fr_MD5Update(&context, (const uint8_t *) secret, secretlen);
3207         old = context;          /* save intermediate work */
3208
3209         /*
3210          *      The inverse of the code above.
3211          */
3212         for (n = 0; n < pwlen; n += AUTH_PASS_LEN) {
3213                 if (n == 0) {
3214                         fr_MD5Update(&context, vector, AUTH_VECTOR_LEN);
3215                         fr_MD5Final(digest, &context);
3216
3217                         context = old;
3218                         if (pwlen > AUTH_PASS_LEN) {
3219                                 fr_MD5Update(&context, (uint8_t *) passwd,
3220                                              AUTH_PASS_LEN);
3221                         }
3222                 } else {
3223                         fr_MD5Final(digest, &context);
3224
3225                         context = old;
3226                         if (pwlen > (n + AUTH_PASS_LEN)) {
3227                                 fr_MD5Update(&context, (uint8_t *) passwd + n,
3228                                              AUTH_PASS_LEN);
3229                         }
3230                 }
3231
3232                 for (i = 0; i < AUTH_PASS_LEN; i++) {
3233                         passwd[i + n] ^= digest[i];
3234                 }
3235         }
3236
3237  done:
3238         passwd[pwlen] = '\0';
3239         return strlen(passwd);
3240 }
3241
3242
3243 /*
3244  *      Encode Tunnel-Password attributes when sending them out on the wire.
3245  *
3246  *      int *pwlen is updated to the new length of the encrypted
3247  *      password - a multiple of 16 bytes.
3248  *
3249  *      This is per RFC-2868 which adds a two char SALT to the initial intermediate
3250  *      value MD5 hash.
3251  */
3252 int rad_tunnel_pwencode(char *passwd, size_t *pwlen, const char *secret,
3253                         const uint8_t *vector)
3254 {
3255         uint8_t buffer[AUTH_VECTOR_LEN + MAX_STRING_LEN + 3];
3256         unsigned char   digest[AUTH_VECTOR_LEN];
3257         char*   salt;
3258         int     i, n, secretlen;
3259         unsigned len, n2;
3260
3261         len = *pwlen;
3262
3263         if (len > 127) len = 127;
3264
3265         /*
3266          * Shift the password 3 positions right to place a salt and original
3267          * length, tag will be added automatically on packet send
3268          */
3269         for (n=len ; n>=0 ; n--) passwd[n+3] = passwd[n];
3270         salt = passwd;
3271         passwd += 2;
3272         /*
3273          * save original password length as first password character;
3274          */
3275         *passwd = len;
3276         len += 1;
3277
3278
3279         /*
3280          *      Generate salt.  The RFC's say:
3281          *
3282          *      The high bit of salt[0] must be set, each salt in a
3283          *      packet should be unique, and they should be random
3284          *
3285          *      So, we set the high bit, add in a counter, and then
3286          *      add in some CSPRNG data.  should be OK..
3287          */
3288         salt[0] = (0x80 | ( ((salt_offset++) & 0x0f) << 3) |
3289                    (fr_rand() & 0x07));
3290         salt[1] = fr_rand();
3291
3292         /*
3293          *      Padd password to multiple of AUTH_PASS_LEN bytes.
3294          */
3295         n = len % AUTH_PASS_LEN;
3296         if (n) {
3297                 n = AUTH_PASS_LEN - n;
3298                 for (; n > 0; n--, len++)
3299                         passwd[len] = 0;
3300         }
3301         /* set new password length */
3302         *pwlen = len + 2;
3303
3304         /*
3305          *      Use the secret to setup the decryption digest
3306          */
3307         secretlen = strlen(secret);
3308         memcpy(buffer, secret, secretlen);
3309
3310         for (n2 = 0; n2 < len; n2+=AUTH_PASS_LEN) {
3311                 if (!n2) {
3312                         memcpy(buffer + secretlen, vector, AUTH_VECTOR_LEN);
3313                         memcpy(buffer + secretlen + AUTH_VECTOR_LEN, salt, 2);
3314                         fr_md5_calc(digest, buffer, secretlen + AUTH_VECTOR_LEN + 2);
3315                 } else {
3316                         memcpy(buffer + secretlen, passwd + n2 - AUTH_PASS_LEN, AUTH_PASS_LEN);
3317                         fr_md5_calc(digest, buffer, secretlen + AUTH_PASS_LEN);
3318                 }
3319
3320                 for (i = 0; i < AUTH_PASS_LEN; i++) {
3321                         passwd[i + n2] ^= digest[i];
3322                 }
3323         }
3324         passwd[n2] = 0;
3325         return 0;
3326 }
3327
3328 /*
3329  *      Decode Tunnel-Password encrypted attributes.
3330  *
3331  *      Defined in RFC-2868, this uses a two char SALT along with the
3332  *      initial intermediate value, to differentiate it from the
3333  *      above.
3334  */
3335 int rad_tunnel_pwdecode(uint8_t *passwd, size_t *pwlen, const char *secret,
3336                         const uint8_t *vector)
3337 {
3338         FR_MD5_CTX  context, old;
3339         uint8_t         digest[AUTH_VECTOR_LEN];
3340         int             secretlen;
3341         unsigned        i, n, len, reallen;
3342
3343         len = *pwlen;
3344
3345         /*
3346          *      We need at least a salt.
3347          */
3348         if (len < 2) {
3349                 fr_strerror_printf("tunnel password is too short");
3350                 return -1;
3351         }
3352
3353         /*
3354          *      There's a salt, but no password.  Or, there's a salt
3355          *      and a 'data_len' octet.  It's wrong, but at least we
3356          *      can figure out what it means: the password is empty.
3357          *
3358          *      Note that this means we ignore the 'data_len' field,
3359          *      if the attribute length tells us that there's no
3360          *      more data.  So the 'data_len' field may be wrong,
3361          *      but that's ok...
3362          */
3363         if (len <= 3) {
3364                 passwd[0] = 0;
3365                 *pwlen = 0;
3366                 return 0;
3367         }
3368
3369         len -= 2;               /* discount the salt */
3370
3371         /*
3372          *      Use the secret to setup the decryption digest
3373          */
3374         secretlen = strlen(secret);
3375
3376         fr_MD5Init(&context);
3377         fr_MD5Update(&context, (const uint8_t *) secret, secretlen);
3378         old = context;          /* save intermediate work */
3379
3380         /*
3381          *      Set up the initial key:
3382          *
3383          *       b(1) = MD5(secret + vector + salt)
3384          */
3385         fr_MD5Update(&context, vector, AUTH_VECTOR_LEN);
3386         fr_MD5Update(&context, passwd, 2);
3387
3388         reallen = 0;
3389         for (n = 0; n < len; n += AUTH_PASS_LEN) {
3390                 int base = 0;
3391
3392                 if (n == 0) {
3393                         fr_MD5Final(digest, &context);
3394
3395                         context = old;
3396
3397                         /*
3398                          *      A quick check: decrypt the first octet
3399                          *      of the password, which is the
3400                          *      'data_len' field.  Ensure it's sane.
3401                          */
3402                         reallen = passwd[2] ^ digest[0];
3403                         if (reallen >= len) {
3404                                 fr_strerror_printf("tunnel password is too long for the attribute");
3405                                 return -1;
3406                         }
3407
3408                         fr_MD5Update(&context, passwd + 2, AUTH_PASS_LEN);
3409
3410                         base = 1;
3411                 } else {
3412                         fr_MD5Final(digest, &context);
3413
3414                         context = old;
3415                         fr_MD5Update(&context, passwd + n + 2, AUTH_PASS_LEN);
3416                 }
3417
3418                 for (i = base; i < AUTH_PASS_LEN; i++) {
3419                         passwd[n + i - 1] = passwd[n + i + 2] ^ digest[i];
3420                 }
3421         }
3422
3423         /*
3424          *      See make_tunnel_password, above.
3425          */
3426         if (reallen > 239) reallen = 239;
3427
3428         *pwlen = reallen;
3429         passwd[reallen] = 0;
3430
3431         return reallen;
3432 }
3433
3434 /*
3435  *      Encode a CHAP password
3436  *
3437  *      FIXME: might not work with Ascend because
3438  *      we use vp->length, and Ascend gear likes
3439  *      to send an extra '\0' in the string!
3440  */
3441 int rad_chap_encode(RADIUS_PACKET *packet, uint8_t *output, int id,
3442                     VALUE_PAIR *password)
3443 {
3444         int             i;
3445         uint8_t         *ptr;
3446         uint8_t         string[MAX_STRING_LEN * 2 + 1];
3447         VALUE_PAIR      *challenge;
3448
3449         /*
3450          *      Sanity check the input parameters
3451          */
3452         if ((packet == NULL) || (password == NULL)) {
3453                 return -1;
3454         }
3455
3456         /*
3457          *      Note that the password VP can be EITHER
3458          *      a User-Password attribute (from a check-item list),
3459          *      or a CHAP-Password attribute (the client asking
3460          *      the library to encode it).
3461          */
3462
3463         i = 0;
3464         ptr = string;
3465         *ptr++ = id;
3466
3467         i++;
3468         memcpy(ptr, password->vp_strvalue, password->length);
3469         ptr += password->length;
3470         i += password->length;
3471
3472         /*
3473          *      Use Chap-Challenge pair if present,
3474          *      Request-Authenticator otherwise.
3475          */
3476         challenge = pairfind(packet->vps, PW_CHAP_CHALLENGE, 0);
3477         if (challenge) {
3478                 memcpy(ptr, challenge->vp_strvalue, challenge->length);
3479                 i += challenge->length;
3480         } else {
3481                 memcpy(ptr, packet->vector, AUTH_VECTOR_LEN);
3482                 i += AUTH_VECTOR_LEN;
3483         }
3484
3485         *output = id;
3486         fr_md5_calc((uint8_t *)output + 1, (uint8_t *)string, i);
3487
3488         return 0;
3489 }
3490
3491
3492 /*
3493  *      Seed the random number generator.
3494  *
3495  *      May be called any number of times.
3496  */
3497 void fr_rand_seed(const void *data, size_t size)
3498 {
3499         uint32_t hash;
3500
3501         /*
3502          *      Ensure that the pool is initialized.
3503          */
3504         if (!fr_rand_initialized) {
3505                 int fd;
3506
3507                 memset(&fr_rand_pool, 0, sizeof(fr_rand_pool));
3508
3509                 fd = open("/dev/urandom", O_RDONLY);
3510                 if (fd >= 0) {
3511                         size_t total;
3512                         ssize_t this;
3513
3514                         total = this = 0;
3515                         while (total < sizeof(fr_rand_pool.randrsl)) {
3516                                 this = read(fd, fr_rand_pool.randrsl,
3517                                             sizeof(fr_rand_pool.randrsl) - total);
3518                                 if ((this < 0) && (errno != EINTR)) break;
3519                                 if (this > 0) total += this;
3520                         }
3521                         close(fd);
3522                 } else {
3523                         fr_rand_pool.randrsl[0] = fd;
3524                         fr_rand_pool.randrsl[1] = time(NULL);
3525                         fr_rand_pool.randrsl[2] = errno;
3526                 }
3527
3528                 fr_randinit(&fr_rand_pool, 1);
3529                 fr_rand_pool.randcnt = 0;
3530                 fr_rand_initialized = 1;
3531         }
3532
3533         if (!data) return;
3534
3535         /*
3536          *      Hash the user data
3537          */
3538         hash = fr_rand();
3539         if (!hash) hash = fr_rand();
3540         hash = fr_hash_update(data, size, hash);
3541
3542         fr_rand_pool.randmem[fr_rand_pool.randcnt] ^= hash;
3543 }
3544
3545
3546 /*
3547  *      Return a 32-bit random number.
3548  */
3549 uint32_t fr_rand(void)
3550 {
3551         uint32_t num;
3552
3553         /*
3554          *      Ensure that the pool is initialized.
3555          */
3556         if (!fr_rand_initialized) {
3557                 fr_rand_seed(NULL, 0);
3558         }
3559
3560         num = fr_rand_pool.randrsl[fr_rand_pool.randcnt++];
3561         if (fr_rand_pool.randcnt >= 256) {
3562                 fr_rand_pool.randcnt = 0;
3563                 fr_isaac(&fr_rand_pool);
3564         }
3565
3566         return num;
3567 }
3568
3569
3570 /*
3571  *      Allocate a new RADIUS_PACKET
3572  */
3573 RADIUS_PACKET *rad_alloc(int newvector)
3574 {
3575         RADIUS_PACKET   *rp;
3576
3577         if ((rp = malloc(sizeof(RADIUS_PACKET))) == NULL) {
3578                 fr_strerror_printf("out of memory");
3579                 return NULL;
3580         }
3581         memset(rp, 0, sizeof(*rp));
3582         rp->id = -1;
3583         rp->offset = -1;
3584
3585         if (newvector) {
3586                 int i;
3587                 uint32_t hash, base;
3588
3589                 /*
3590                  *      Don't expose the actual contents of the random
3591                  *      pool.
3592                  */
3593                 base = fr_rand();
3594                 for (i = 0; i < AUTH_VECTOR_LEN; i += sizeof(uint32_t)) {
3595                         hash = fr_rand() ^ base;
3596                         memcpy(rp->vector + i, &hash, sizeof(hash));
3597                 }
3598         }
3599         fr_rand();              /* stir the pool again */
3600
3601         return rp;
3602 }
3603
3604 RADIUS_PACKET *rad_alloc_reply(RADIUS_PACKET *packet)
3605 {
3606         RADIUS_PACKET *reply;
3607
3608         if (!packet) return NULL;
3609
3610         reply = rad_alloc(0);
3611         if (!reply) return NULL;
3612
3613         /*
3614          *      Initialize the fields from the request.
3615          */
3616         reply->sockfd = packet->sockfd;
3617         reply->dst_ipaddr = packet->src_ipaddr;
3618         reply->src_ipaddr = packet->dst_ipaddr;
3619         reply->dst_port = packet->src_port;
3620         reply->src_port = packet->dst_port;
3621         reply->id = packet->id;
3622         reply->code = 0; /* UNKNOWN code */
3623         memcpy(reply->vector, packet->vector,
3624                sizeof(reply->vector));
3625         reply->vps = NULL;
3626         reply->data = NULL;
3627         reply->data_len = 0;
3628
3629         return reply;
3630 }
3631
3632
3633 /*
3634  *      Free a RADIUS_PACKET
3635  */
3636 void rad_free(RADIUS_PACKET **radius_packet_ptr)
3637 {
3638         RADIUS_PACKET *radius_packet;
3639
3640         if (!radius_packet_ptr || !*radius_packet_ptr) return;
3641         radius_packet = *radius_packet_ptr;
3642
3643         free(radius_packet->data);
3644
3645         pairfree(&radius_packet->vps);
3646
3647         free(radius_packet);
3648
3649         *radius_packet_ptr = NULL;
3650 }