contrib/wpa_supplicant/radius.c

   1 /*
   2  * hostapd / RADIUS message processing
   3  * Copyright (c) 2002-2008, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  16
  17 #include "common.h"
  18 #include "radius.h"
  19 #include "md5.h"
  20 #include "crypto.h"
  21
  22
  23 struct radius_msg *radius_msg_new(u8 code, u8 identifier)
  24 {
  25         struct radius_msg *msg;
  26
  27         msg = os_malloc(sizeof(*msg));
  28         if (msg == NULL)
  29                 return NULL;
  30
  31         if (radius_msg_initialize(msg, RADIUS_DEFAULT_MSG_SIZE)) {
  32                 os_free(msg);
  33                 return NULL;
  34         }
  35
  36         radius_msg_set_hdr(msg, code, identifier);
  37
  38         return msg;
  39 }
  40
  41
  42 int radius_msg_initialize(struct radius_msg *msg, size_t init_len)
  43 {
  44         if (msg == NULL || init_len < sizeof(struct radius_hdr))
  45                 return -1;
  46
  47         os_memset(msg, 0, sizeof(*msg));
  48         msg->buf = wpa_zalloc(init_len);
  49         if (msg->buf == NULL)
  50                 return -1;
  51
  52         msg->buf_size = init_len;
  53         msg->hdr = (struct radius_hdr *) msg->buf;
  54         msg->buf_used = sizeof(*msg->hdr);
  55
  56         msg->attrs =
  57                 os_malloc(RADIUS_DEFAULT_ATTR_COUNT * sizeof(*msg->attrs));
  58         if (msg->attrs == NULL) {
  59                 os_free(msg->buf);
  60                 msg->buf = NULL;
  61                 msg->hdr = NULL;
  62                 return -1;
  63         }
  64
  65         msg->attr_size = RADIUS_DEFAULT_ATTR_COUNT;
  66         msg->attr_used = 0;
  67
  68         return 0;
  69 }
  70
  71
  72 void radius_msg_set_hdr(struct radius_msg *msg, u8 code, u8 identifier)
  73 {
  74         msg->hdr->code = code;
  75         msg->hdr->identifier = identifier;
  76 }
  77
  78
  79 void radius_msg_free(struct radius_msg *msg)
  80 {
  81         if (msg->buf != NULL) {
  82                 os_free(msg->buf);
  83                 msg->buf = NULL;
  84                 msg->hdr = NULL;
  85         }
  86         msg->buf_size = msg->buf_used = 0;
  87
  88         if (msg->attrs != NULL) {
  89                 os_free(msg->attrs);
  90                 msg->attrs = NULL;
  91         }
  92         msg->attr_size = msg->attr_used = 0;
  93 }
  94
  95
  96 static const char *radius_code_string(u8 code)
  97 {
  98         switch (code) {
  99         case RADIUS_CODE_ACCESS_REQUEST: return "Access-Request";
 100         case RADIUS_CODE_ACCESS_ACCEPT: return "Access-Accept";
 101         case RADIUS_CODE_ACCESS_REJECT: return "Access-Reject";
 102         case RADIUS_CODE_ACCOUNTING_REQUEST: return "Accounting-Request";
 103         case RADIUS_CODE_ACCOUNTING_RESPONSE: return "Accounting-Response";
 104         case RADIUS_CODE_ACCESS_CHALLENGE: return "Access-Challenge";
 105         case RADIUS_CODE_STATUS_SERVER: return "Status-Server";
 106         case RADIUS_CODE_STATUS_CLIENT: return "Status-Client";
 107         case RADIUS_CODE_RESERVED: return "Reserved";
 108         default: return "?Unknown?";
 109         }
 110 }
 111
 112
 113 struct radius_attr_type {
 114         u8 type;
 115         char *name;
 116         enum {
 117                 RADIUS_ATTR_UNDIST, RADIUS_ATTR_TEXT, RADIUS_ATTR_IP,
 118                 RADIUS_ATTR_HEXDUMP, RADIUS_ATTR_INT32, RADIUS_ATTR_IPV6
 119         } data_type;
 120 };
 121
 122 static struct radius_attr_type radius_attrs[] =
 123 {
 124         { RADIUS_ATTR_USER_NAME, "User-Name", RADIUS_ATTR_TEXT },
 125         { RADIUS_ATTR_USER_PASSWORD, "User-Password", RADIUS_ATTR_UNDIST },
 126         { RADIUS_ATTR_NAS_IP_ADDRESS, "NAS-IP-Address", RADIUS_ATTR_IP },
 127         { RADIUS_ATTR_NAS_PORT, "NAS-Port", RADIUS_ATTR_INT32 },
 128         { RADIUS_ATTR_FRAMED_MTU, "Framed-MTU", RADIUS_ATTR_INT32 },
 129         { RADIUS_ATTR_STATE, "State", RADIUS_ATTR_UNDIST },
 130         { RADIUS_ATTR_CLASS, "Class", RADIUS_ATTR_UNDIST },
 131         { RADIUS_ATTR_VENDOR_SPECIFIC, "Vendor-Specific", RADIUS_ATTR_UNDIST },
 132         { RADIUS_ATTR_SESSION_TIMEOUT, "Session-Timeout", RADIUS_ATTR_INT32 },
 133         { RADIUS_ATTR_IDLE_TIMEOUT, "Idle-Timeout", RADIUS_ATTR_INT32 },
 134         { RADIUS_ATTR_TERMINATION_ACTION, "Termination-Action",
 135           RADIUS_ATTR_INT32 },
 136         { RADIUS_ATTR_CALLED_STATION_ID, "Called-Station-Id",
 137           RADIUS_ATTR_TEXT },
 138         { RADIUS_ATTR_CALLING_STATION_ID, "Calling-Station-Id",
 139           RADIUS_ATTR_TEXT },
 140         { RADIUS_ATTR_NAS_IDENTIFIER, "NAS-Identifier", RADIUS_ATTR_TEXT },
 141         { RADIUS_ATTR_PROXY_STATE, "Proxy-State", RADIUS_ATTR_UNDIST },
 142         { RADIUS_ATTR_ACCT_STATUS_TYPE, "Acct-Status-Type",
 143           RADIUS_ATTR_INT32 },
 144         { RADIUS_ATTR_ACCT_DELAY_TIME, "Acct-Delay-Time", RADIUS_ATTR_INT32 },
 145         { RADIUS_ATTR_ACCT_INPUT_OCTETS, "Acct-Input-Octets",
 146           RADIUS_ATTR_INT32 },
 147         { RADIUS_ATTR_ACCT_OUTPUT_OCTETS, "Acct-Output-Octets",
 148           RADIUS_ATTR_INT32 },
 149         { RADIUS_ATTR_ACCT_SESSION_ID, "Acct-Session-Id", RADIUS_ATTR_TEXT },
 150         { RADIUS_ATTR_ACCT_AUTHENTIC, "Acct-Authentic", RADIUS_ATTR_INT32 },
 151         { RADIUS_ATTR_ACCT_SESSION_TIME, "Acct-Session-Time",
 152           RADIUS_ATTR_INT32 },
 153         { RADIUS_ATTR_ACCT_INPUT_PACKETS, "Acct-Input-Packets",
 154           RADIUS_ATTR_INT32 },
 155         { RADIUS_ATTR_ACCT_OUTPUT_PACKETS, "Acct-Output-Packets",
 156           RADIUS_ATTR_INT32 },
 157         { RADIUS_ATTR_ACCT_TERMINATE_CAUSE, "Acct-Terminate-Cause",
 158           RADIUS_ATTR_INT32 },
 159         { RADIUS_ATTR_ACCT_MULTI_SESSION_ID, "Acct-Multi-Session-Id",
 160           RADIUS_ATTR_TEXT },
 161         { RADIUS_ATTR_ACCT_LINK_COUNT, "Acct-Link-Count", RADIUS_ATTR_INT32 },
 162         { RADIUS_ATTR_ACCT_INPUT_GIGAWORDS, "Acct-Input-Gigawords",
 163           RADIUS_ATTR_INT32 },
 164         { RADIUS_ATTR_ACCT_OUTPUT_GIGAWORDS, "Acct-Output-Gigawords",
 165           RADIUS_ATTR_INT32 },
 166         { RADIUS_ATTR_EVENT_TIMESTAMP, "Event-Timestamp",
 167           RADIUS_ATTR_INT32 },
 168         { RADIUS_ATTR_NAS_PORT_TYPE, "NAS-Port-Type", RADIUS_ATTR_INT32 },
 169         { RADIUS_ATTR_TUNNEL_TYPE, "Tunnel-Type", RADIUS_ATTR_HEXDUMP },
 170         { RADIUS_ATTR_TUNNEL_MEDIUM_TYPE, "Tunnel-Medium-Type",
 171           RADIUS_ATTR_HEXDUMP },
 172         { RADIUS_ATTR_CONNECT_INFO, "Connect-Info", RADIUS_ATTR_TEXT },
 173         { RADIUS_ATTR_EAP_MESSAGE, "EAP-Message", RADIUS_ATTR_UNDIST },
 174         { RADIUS_ATTR_MESSAGE_AUTHENTICATOR, "Message-Authenticator",
 175           RADIUS_ATTR_UNDIST },
 176         { RADIUS_ATTR_TUNNEL_PRIVATE_GROUP_ID, "Tunnel-Private-Group-Id",
 177           RADIUS_ATTR_HEXDUMP },
 178         { RADIUS_ATTR_ACCT_INTERIM_INTERVAL, "Acct-Interim-Interval",
 179           RADIUS_ATTR_INT32 },
 180         { RADIUS_ATTR_NAS_IPV6_ADDRESS, "NAS-IPv6-Address", RADIUS_ATTR_IPV6 },
 181 };
 182 #define RADIUS_ATTRS (sizeof(radius_attrs) / sizeof(radius_attrs[0]))
 183
 184
 185 static struct radius_attr_type *radius_get_attr_type(u8 type)
 186 {
 187         size_t i;
 188
 189         for (i = 0; i < RADIUS_ATTRS; i++) {
 190                 if (type == radius_attrs[i].type)
 191                         return &radius_attrs[i];
 192         }
 193
 194         return NULL;
 195 }
 196
 197
 198 static void print_char(char c)
 199 {
 200         if (c >= 32 && c < 127)
 201                 printf("%c", c);
 202         else
 203                 printf("<%02x>", c);
 204 }
 205
 206
 207 static void radius_msg_dump_attr(struct radius_attr_hdr *hdr)
 208 {
 209         struct radius_attr_type *attr;
 210         int i, len;
 211         unsigned char *pos;
 212
 213         attr = radius_get_attr_type(hdr->type);
 214
 215         printf("   Attribute %d (%s) length=%d\n",
 216                hdr->type, attr ? attr->name : "?Unknown?", hdr->length);
 217
 218         if (attr == NULL)
 219                 return;
 220
 221         len = hdr->length - sizeof(struct radius_attr_hdr);
 222         pos = (unsigned char *) (hdr + 1);
 223
 224         switch (attr->data_type) {
 225         case RADIUS_ATTR_TEXT:
 226                 printf("      Value: '");
 227                 for (i = 0; i < len; i++)
 228                         print_char(pos[i]);
 229                 printf("'\n");
 230                 break;
 231
 232         case RADIUS_ATTR_IP:
 233                 if (len == 4) {
 234                         struct in_addr addr;
 235                         os_memcpy(&addr, pos, 4);
 236                         printf("      Value: %s\n", inet_ntoa(addr));
 237                 } else
 238                         printf("      Invalid IP address length %d\n", len);
 239                 break;
 240
 241 #ifdef CONFIG_IPV6
 242         case RADIUS_ATTR_IPV6:
 243                 if (len == 16) {
 244                         char buf[128];
 245                         const char *atxt;
 246                         struct in6_addr *addr = (struct in6_addr *) pos;
 247                         atxt = inet_ntop(AF_INET6, addr, buf, sizeof(buf));
 248                         printf("      Value: %s\n", atxt ? atxt : "?");
 249                 } else
 250                         printf("      Invalid IPv6 address length %d\n", len);
 251                 break;
 252 #endif /* CONFIG_IPV6 */
 253
 254         case RADIUS_ATTR_HEXDUMP:
 255         case RADIUS_ATTR_UNDIST:
 256                 printf("      Value:");
 257                 for (i = 0; i < len; i++)
 258                         printf(" %02x", pos[i]);
 259                 printf("\n");
 260                 break;
 261
 262         case RADIUS_ATTR_INT32:
 263                 if (len == 4)
 264                         printf("      Value: %u\n", WPA_GET_BE32(pos));
 265                 else
 266                         printf("      Invalid INT32 length %d\n", len);
 267                 break;
 268
 269         default:
 270                 break;
 271         }
 272 }
 273
 274
 275 void radius_msg_dump(struct radius_msg *msg)
 276 {
 277         size_t i;
 278
 279         printf("RADIUS message: code=%d (%s) identifier=%d length=%d\n",
 280                msg->hdr->code, radius_code_string(msg->hdr->code),
 281                msg->hdr->identifier, ntohs(msg->hdr->length));
 282
 283         for (i = 0; i < msg->attr_used; i++) {
 284                 radius_msg_dump_attr(msg->attrs[i]);
 285         }
 286 }
 287
 288
 289 int radius_msg_finish(struct radius_msg *msg, u8 *secret, size_t secret_len)
 290 {
 291         if (secret) {
 292                 u8 auth[MD5_MAC_LEN];
 293                 struct radius_attr_hdr *attr;
 294
 295                 os_memset(auth, 0, MD5_MAC_LEN);
 296                 attr = radius_msg_add_attr(msg,
 297                                            RADIUS_ATTR_MESSAGE_AUTHENTICATOR,
 298                                            auth, MD5_MAC_LEN);
 299                 if (attr == NULL) {
 300                         printf("WARNING: Could not add "
 301                                "Message-Authenticator\n");
 302                         return -1;
 303                 }
 304                 msg->hdr->length = htons(msg->buf_used);
 305                 hmac_md5(secret, secret_len, msg->buf, msg->buf_used,
 306                          (u8 *) (attr + 1));
 307         } else
 308                 msg->hdr->length = htons(msg->buf_used);
 309
 310         if (msg->buf_used > 0xffff) {
 311                 printf("WARNING: too long RADIUS message (%lu)\n",
 312                        (unsigned long) msg->buf_used);
 313                 return -1;
 314         }
 315         return 0;
 316 }
 317
 318
 319 int radius_msg_finish_srv(struct radius_msg *msg, const u8 *secret,
 320                           size_t secret_len, const u8 *req_authenticator)
 321 {
 322         u8 auth[MD5_MAC_LEN];
 323         struct radius_attr_hdr *attr;
 324         const u8 *addr[4];
 325         size_t len[4];
 326
 327         os_memset(auth, 0, MD5_MAC_LEN);
 328         attr = radius_msg_add_attr(msg, RADIUS_ATTR_MESSAGE_AUTHENTICATOR,
 329                                    auth, MD5_MAC_LEN);
 330         if (attr == NULL) {
 331                 printf("WARNING: Could not add Message-Authenticator\n");
 332                 return -1;
 333         }
 334         msg->hdr->length = htons(msg->buf_used);
 335         os_memcpy(msg->hdr->authenticator, req_authenticator,
 336                   sizeof(msg->hdr->authenticator));
 337         hmac_md5(secret, secret_len, msg->buf, msg->buf_used,
 338                  (u8 *) (attr + 1));
 339
 340         /* ResponseAuth = MD5(Code+ID+Length+RequestAuth+Attributes+Secret) */
 341         addr[0] = (u8 *) msg->hdr;
 342         len[0] = 1 + 1 + 2;
 343         addr[1] = req_authenticator;
 344         len[1] = MD5_MAC_LEN;
 345         addr[2] = (u8 *) (msg->hdr + 1);
 346         len[2] = msg->buf_used - sizeof(*msg->hdr);
 347         addr[3] = secret;
 348         len[3] = secret_len;
 349         md5_vector(4, addr, len, msg->hdr->authenticator);
 350
 351         if (msg->buf_used > 0xffff) {
 352                 printf("WARNING: too long RADIUS message (%lu)\n",
 353                        (unsigned long) msg->buf_used);
 354                 return -1;
 355         }
 356         return 0;
 357 }
 358
 359
 360 void radius_msg_finish_acct(struct radius_msg *msg, u8 *secret,
 361                             size_t secret_len)
 362 {
 363         const u8 *addr[2];
 364         size_t len[2];
 365
 366         msg->hdr->length = htons(msg->buf_used);
 367         os_memset(msg->hdr->authenticator, 0, MD5_MAC_LEN);
 368         addr[0] = msg->buf;
 369         len[0] = msg->buf_used;
 370         addr[1] = secret;
 371         len[1] = secret_len;
 372         md5_vector(2, addr, len, msg->hdr->authenticator);
 373
 374         if (msg->buf_used > 0xffff) {
 375                 printf("WARNING: too long RADIUS messages (%lu)\n",
 376                        (unsigned long) msg->buf_used);
 377         }
 378 }
 379
 380
 381 static int radius_msg_add_attr_to_array(struct radius_msg *msg,
 382                                         struct radius_attr_hdr *attr)
 383 {
 384         if (msg->attr_used >= msg->attr_size) {
 385                 struct radius_attr_hdr **nattrs;
 386                 int nlen = msg->attr_size * 2;
 387
 388                 nattrs = os_realloc(msg->attrs, nlen * sizeof(*msg->attrs));
 389                 if (nattrs == NULL)
 390                         return -1;
 391
 392                 msg->attrs = nattrs;
 393                 msg->attr_size = nlen;
 394         }
 395
 396         msg->attrs[msg->attr_used++] = attr;
 397
 398         return 0;
 399 }
 400
 401
 402 struct radius_attr_hdr *radius_msg_add_attr(struct radius_msg *msg, u8 type,
 403                                             const u8 *data, size_t data_len)
 404 {
 405         size_t buf_needed;
 406         struct radius_attr_hdr *attr;
 407
 408         if (data_len > RADIUS_MAX_ATTR_LEN) {
 409                 printf("radius_msg_add_attr: too long attribute (%lu bytes)\n",
 410                        (unsigned long) data_len);
 411                 return NULL;
 412         }
 413
 414         buf_needed = msg->buf_used + sizeof(*attr) + data_len;
 415
 416         if (msg->buf_size < buf_needed) {
 417                 /* allocate more space for message buffer */
 418                 unsigned char *nbuf;
 419                 size_t i, nlen = msg->buf_size;
 420                 int diff;
 421
 422                 while (nlen < buf_needed)
 423                         nlen *= 2;
 424                 nbuf = os_realloc(msg->buf, nlen);
 425                 if (nbuf == NULL)
 426                         return NULL;
 427                 diff = nbuf - msg->buf;
 428                 msg->buf = nbuf;
 429                 msg->hdr = (struct radius_hdr *) msg->buf;
 430                 /* adjust attr pointers to match with the new buffer */
 431                 for (i = 0; i < msg->attr_used; i++)
 432                         msg->attrs[i] = (struct radius_attr_hdr *)
 433                                 (((u8 *) msg->attrs[i]) + diff);
 434                 os_memset(msg->buf + msg->buf_size, 0, nlen - msg->buf_size);
 435                 msg->buf_size = nlen;
 436         }
 437
 438         attr = (struct radius_attr_hdr *) (msg->buf + msg->buf_used);
 439         attr->type = type;
 440         attr->length = sizeof(*attr) + data_len;
 441         if (data_len > 0)
 442                 os_memcpy(attr + 1, data, data_len);
 443
 444         msg->buf_used += sizeof(*attr) + data_len;
 445
 446         if (radius_msg_add_attr_to_array(msg, attr))
 447                 return NULL;
 448
 449         return attr;
 450 }
 451
 452
 453 struct radius_msg *radius_msg_parse(const u8 *data, size_t len)
 454 {
 455         struct radius_msg *msg;
 456         struct radius_hdr *hdr;
 457         struct radius_attr_hdr *attr;
 458         size_t msg_len;
 459         unsigned char *pos, *end;
 460
 461         if (data == NULL || len < sizeof(*hdr))
 462                 return NULL;
 463
 464         hdr = (struct radius_hdr *) data;
 465
 466         msg_len = ntohs(hdr->length);
 467         if (msg_len < sizeof(*hdr) || msg_len > len) {
 468                 printf("Invalid RADIUS message length\n");
 469                 return NULL;
 470         }
 471
 472         if (msg_len < len) {
 473                 printf("Ignored %lu extra bytes after RADIUS message\n",
 474                        (unsigned long) len - msg_len);
 475         }
 476
 477         msg = os_malloc(sizeof(*msg));
 478         if (msg == NULL)
 479                 return NULL;
 480
 481         if (radius_msg_initialize(msg, msg_len)) {
 482                 os_free(msg);
 483                 return NULL;
 484         }
 485
 486         os_memcpy(msg->buf, data, msg_len);
 487         msg->buf_size = msg->buf_used = msg_len;
 488
 489         /* parse attributes */
 490         pos = (unsigned char *) (msg->hdr + 1);
 491         end = msg->buf + msg->buf_used;
 492         while (pos < end) {
 493                 if ((size_t) (end - pos) < sizeof(*attr))
 494                         goto fail;
 495
 496                 attr = (struct radius_attr_hdr *) pos;
 497
 498                 if (pos + attr->length > end || attr->length < sizeof(*attr))
 499                         goto fail;
 500
 501                 /* TODO: check that attr->length is suitable for attr->type */
 502
 503                 if (radius_msg_add_attr_to_array(msg, attr))
 504                         goto fail;
 505
 506                 pos += attr->length;
 507         }
 508
 509         return msg;
 510
 511  fail:
 512         radius_msg_free(msg);
 513         os_free(msg);
 514         return NULL;
 515 }
 516
 517
 518 int radius_msg_add_eap(struct radius_msg *msg, const u8 *data, size_t data_len)
 519 {
 520         const u8 *pos = data;
 521         size_t left = data_len;
 522
 523         while (left > 0) {
 524                 int len;
 525                 if (left > RADIUS_MAX_ATTR_LEN)
 526                         len = RADIUS_MAX_ATTR_LEN;
 527                 else
 528                         len = left;
 529
 530                 if (!radius_msg_add_attr(msg, RADIUS_ATTR_EAP_MESSAGE,
 531                                          pos, len))
 532                         return 0;
 533
 534                 pos += len;
 535                 left -= len;
 536         }
 537
 538         return 1;
 539 }
 540
 541
 542 u8 *radius_msg_get_eap(struct radius_msg *msg, size_t *eap_len)
 543 {
 544         u8 *eap, *pos;
 545         size_t len, i;
 546
 547         if (msg == NULL)
 548                 return NULL;
 549
 550         len = 0;
 551         for (i = 0; i < msg->attr_used; i++) {
 552                 if (msg->attrs[i]->type == RADIUS_ATTR_EAP_MESSAGE)
 553                         len += msg->attrs[i]->length -
 554                                 sizeof(struct radius_attr_hdr);
 555         }
 556
 557         if (len == 0)
 558                 return NULL;
 559
 560         eap = os_malloc(len);
 561         if (eap == NULL)
 562                 return NULL;
 563
 564         pos = eap;
 565         for (i = 0; i < msg->attr_used; i++) {
 566                 if (msg->attrs[i]->type == RADIUS_ATTR_EAP_MESSAGE) {
 567                         struct radius_attr_hdr *attr = msg->attrs[i];
 568                         int flen = attr->length - sizeof(*attr);
 569                         os_memcpy(pos, attr + 1, flen);
 570                         pos += flen;
 571                 }
 572         }
 573
 574         if (eap_len)
 575                 *eap_len = len;
 576
 577         return eap;
 578 }
 579
 580
 581 int radius_msg_verify_msg_auth(struct radius_msg *msg, const u8 *secret,
 582                                size_t secret_len, const u8 *req_auth)
 583 {
 584         u8 auth[MD5_MAC_LEN], orig[MD5_MAC_LEN];
 585         u8 orig_authenticator[16];
 586         struct radius_attr_hdr *attr = NULL;
 587         size_t i;
 588
 589         for (i = 0; i < msg->attr_used; i++) {
 590                 if (msg->attrs[i]->type == RADIUS_ATTR_MESSAGE_AUTHENTICATOR) {
 591                         if (attr != NULL) {
 592                                 printf("Multiple Message-Authenticator "
 593                                        "attributes in RADIUS message\n");
 594                                 return 1;
 595                         }
 596                         attr = msg->attrs[i];
 597                 }
 598         }
 599
 600         if (attr == NULL) {
 601                 printf("No Message-Authenticator attribute found\n");
 602                 return 1;
 603         }
 604
 605         os_memcpy(orig, attr + 1, MD5_MAC_LEN);
 606         os_memset(attr + 1, 0, MD5_MAC_LEN);
 607         if (req_auth) {
 608                 os_memcpy(orig_authenticator, msg->hdr->authenticator,
 609                           sizeof(orig_authenticator));
 610                 os_memcpy(msg->hdr->authenticator, req_auth,
 611                           sizeof(msg->hdr->authenticator));
 612         }
 613         hmac_md5(secret, secret_len, msg->buf, msg->buf_used, auth);
 614         os_memcpy(attr + 1, orig, MD5_MAC_LEN);
 615         if (req_auth) {
 616                 os_memcpy(msg->hdr->authenticator, orig_authenticator,
 617                           sizeof(orig_authenticator));
 618         }
 619
 620         if (os_memcmp(orig, auth, MD5_MAC_LEN) != 0) {
 621                 printf("Invalid Message-Authenticator!\n");
 622                 return 1;
 623         }
 624
 625         return 0;
 626 }
 627
 628
 629 int radius_msg_verify(struct radius_msg *msg, const u8 *secret,
 630                       size_t secret_len, struct radius_msg *sent_msg, int auth)
 631 {
 632         const u8 *addr[4];
 633         size_t len[4];
 634         u8 hash[MD5_MAC_LEN];
 635
 636         if (sent_msg == NULL) {
 637                 printf("No matching Access-Request message found\n");
 638                 return 1;
 639         }
 640
 641         if (auth &&
 642             radius_msg_verify_msg_auth(msg, secret, secret_len,
 643                                        sent_msg->hdr->authenticator)) {
 644                 return 1;
 645         }
 646
 647         /* ResponseAuth = MD5(Code+ID+Length+RequestAuth+Attributes+Secret) */
 648         addr[0] = (u8 *) msg->hdr;
 649         len[0] = 1 + 1 + 2;
 650         addr[1] = sent_msg->hdr->authenticator;
 651         len[1] = MD5_MAC_LEN;
 652         addr[2] = (u8 *) (msg->hdr + 1);
 653         len[2] = msg->buf_used - sizeof(*msg->hdr);
 654         addr[3] = secret;
 655         len[3] = secret_len;
 656         md5_vector(4, addr, len, hash);
 657         if (os_memcmp(hash, msg->hdr->authenticator, MD5_MAC_LEN) != 0) {
 658                 printf("Response Authenticator invalid!\n");
 659                 return 1;
 660         }
 661
 662         return 0;
 663 }
 664
 665
 666 int radius_msg_copy_attr(struct radius_msg *dst, struct radius_msg *src,
 667                          u8 type)
 668 {
 669         struct radius_attr_hdr *attr;
 670         size_t i;
 671         int count = 0;
 672
 673         for (i = 0; i < src->attr_used; i++) {
 674                 attr = src->attrs[i];
 675                 if (attr->type == type) {
 676                         if (!radius_msg_add_attr(dst, type, (u8 *) (attr + 1),
 677                                                  attr->length - sizeof(*attr)))
 678                                 return -1;
 679                         count++;
 680                 }
 681         }
 682
 683         return count;
 684 }
 685
 686
 687 /* Create Request Authenticator. The value should be unique over the lifetime
 688  * of the shared secret between authenticator and authentication server.
 689  * Use one-way MD5 hash calculated from current timestamp and some data given
 690  * by the caller. */
 691 void radius_msg_make_authenticator(struct radius_msg *msg,
 692                                    const u8 *data, size_t len)
 693 {
 694         struct os_time tv;
 695         long int l;
 696         const u8 *addr[3];
 697         size_t elen[3];
 698
 699         os_get_time(&tv);
 700         l = os_random();
 701         addr[0] = (u8 *) &tv;
 702         elen[0] = sizeof(tv);
 703         addr[1] = data;
 704         elen[1] = len;
 705         addr[2] = (u8 *) &l;
 706         elen[2] = sizeof(l);
 707         md5_vector(3, addr, elen, msg->hdr->authenticator);
 708 }
 709
 710
 711 /* Get Vendor-specific RADIUS Attribute from a parsed RADIUS message.
 712  * Returns the Attribute payload and sets alen to indicate the length of the
 713  * payload if a vendor attribute with subtype is found, otherwise returns NULL.
 714  * The returned payload is allocated with os_malloc() and caller must free it
 715  * by calling os_free().
 716  */
 717 static u8 *radius_msg_get_vendor_attr(struct radius_msg *msg, u32 vendor,
 718                                       u8 subtype, size_t *alen)
 719 {
 720         u8 *data, *pos;
 721         size_t i, len;
 722
 723         if (msg == NULL)
 724                 return NULL;
 725
 726         for (i = 0; i < msg->attr_used; i++) {
 727                 struct radius_attr_hdr *attr = msg->attrs[i];
 728                 size_t left;
 729                 u32 vendor_id;
 730                 struct radius_attr_vendor *vhdr;
 731
 732                 if (attr->type != RADIUS_ATTR_VENDOR_SPECIFIC)
 733                         continue;
 734
 735                 left = attr->length - sizeof(*attr);
 736                 if (left < 4)
 737                         continue;
 738
 739                 pos = (u8 *) (attr + 1);
 740
 741                 os_memcpy(&vendor_id, pos, 4);
 742                 pos += 4;
 743                 left -= 4;
 744
 745                 if (ntohl(vendor_id) != vendor)
 746                         continue;
 747
 748                 while (left >= sizeof(*vhdr)) {
 749                         vhdr = (struct radius_attr_vendor *) pos;
 750                         if (vhdr->vendor_length > left ||
 751                             vhdr->vendor_length < sizeof(*vhdr)) {
 752                                 left = 0;
 753                                 break;
 754                         }
 755                         if (vhdr->vendor_type != subtype) {
 756                                 pos += vhdr->vendor_length;
 757                                 left -= vhdr->vendor_length;
 758                                 continue;
 759                         }
 760
 761                         len = vhdr->vendor_length - sizeof(*vhdr);
 762                         data = os_malloc(len);
 763                         if (data == NULL)
 764                                 return NULL;
 765                         os_memcpy(data, pos + sizeof(*vhdr), len);
 766                         if (alen)
 767                                 *alen = len;
 768                         return data;
 769                 }
 770         }
 771
 772         return NULL;
 773 }
 774
 775
 776 static u8 * decrypt_ms_key(const u8 *key, size_t len,
 777                            const u8 *req_authenticator,
 778                            const u8 *secret, size_t secret_len, size_t *reslen)
 779 {
 780         u8 *plain, *ppos, *res;
 781         const u8 *pos;
 782         size_t left, plen;
 783         u8 hash[MD5_MAC_LEN];
 784         int i, first = 1;
 785         const u8 *addr[3];
 786         size_t elen[3];
 787
 788         /* key: 16-bit salt followed by encrypted key info */
 789
 790         if (len < 2 + 16)
 791                 return NULL;
 792
 793         pos = key + 2;
 794         left = len - 2;
 795         if (left % 16) {
 796                 printf("Invalid ms key len %lu\n", (unsigned long) left);
 797                 return NULL;
 798         }
 799
 800         plen = left;
 801         ppos = plain = os_malloc(plen);
 802         if (plain == NULL)
 803                 return NULL;
 804
 805         while (left > 0) {
 806                 /* b(1) = MD5(Secret + Request-Authenticator + Salt)
 807                  * b(i) = MD5(Secret + c(i - 1)) for i > 1 */
 808
 809                 addr[0] = secret;
 810                 elen[0] = secret_len;
 811                 if (first) {
 812                         addr[1] = req_authenticator;
 813                         elen[1] = MD5_MAC_LEN;
 814                         addr[2] = key;
 815                         elen[2] = 2; /* Salt */
 816                 } else {
 817                         addr[1] = pos - MD5_MAC_LEN;
 818                         elen[1] = MD5_MAC_LEN;
 819                 }
 820                 md5_vector(first ? 3 : 2, addr, elen, hash);
 821                 first = 0;
 822
 823                 for (i = 0; i < MD5_MAC_LEN; i++)
 824                         *ppos++ = *pos++ ^ hash[i];
 825                 left -= MD5_MAC_LEN;
 826         }
 827
 828         if (plain[0] > plen - 1) {
 829                 printf("Failed to decrypt MPPE key\n");
 830                 os_free(plain);
 831                 return NULL;
 832         }
 833
 834         res = os_malloc(plain[0]);
 835         if (res == NULL) {
 836                 os_free(plain);
 837                 return NULL;
 838         }
 839         os_memcpy(res, plain + 1, plain[0]);
 840         if (reslen)
 841                 *reslen = plain[0];
 842         os_free(plain);
 843         return res;
 844 }
 845
 846
 847 static void encrypt_ms_key(const u8 *key, size_t key_len, u16 salt,
 848                            const u8 *req_authenticator,
 849                            const u8 *secret, size_t secret_len,
 850                            u8 *ebuf, size_t *elen)
 851 {
 852         int i, len, first = 1;
 853         u8 hash[MD5_MAC_LEN], saltbuf[2], *pos;
 854         const u8 *addr[3];
 855         size_t _len[3];
 856
 857         saltbuf[0] = salt >> 8;
 858         saltbuf[1] = salt;
 859
 860         len = 1 + key_len;
 861         if (len & 0x0f) {
 862                 len = (len & 0xf0) + 16;
 863         }
 864         os_memset(ebuf, 0, len);
 865         ebuf[0] = key_len;
 866         os_memcpy(ebuf + 1, key, key_len);
 867
 868         *elen = len;
 869
 870         pos = ebuf;
 871         while (len > 0) {
 872                 /* b(1) = MD5(Secret + Request-Authenticator + Salt)
 873                  * b(i) = MD5(Secret + c(i - 1)) for i > 1 */
 874                 addr[0] = secret;
 875                 _len[0] = secret_len;
 876                 if (first) {
 877                         addr[1] = req_authenticator;
 878                         _len[1] = MD5_MAC_LEN;
 879                         addr[2] = saltbuf;
 880                         _len[2] = sizeof(saltbuf);
 881                 } else {
 882                         addr[1] = pos - MD5_MAC_LEN;
 883                         _len[1] = MD5_MAC_LEN;
 884                 }
 885                 md5_vector(first ? 3 : 2, addr, _len, hash);
 886                 first = 0;
 887
 888                 for (i = 0; i < MD5_MAC_LEN; i++)
 889                         *pos++ ^= hash[i];
 890
 891                 len -= MD5_MAC_LEN;
 892         }
 893 }
 894
 895
 896 struct radius_ms_mppe_keys *
 897 radius_msg_get_ms_keys(struct radius_msg *msg, struct radius_msg *sent_msg,
 898                        u8 *secret, size_t secret_len)
 899 {
 900         u8 *key;
 901         size_t keylen;
 902         struct radius_ms_mppe_keys *keys;
 903
 904         if (msg == NULL || sent_msg == NULL)
 905                 return NULL;
 906
 907         keys = wpa_zalloc(sizeof(*keys));
 908         if (keys == NULL)
 909                 return NULL;
 910
 911         key = radius_msg_get_vendor_attr(msg, RADIUS_VENDOR_ID_MICROSOFT,
 912                                          RADIUS_VENDOR_ATTR_MS_MPPE_SEND_KEY,
 913                                          &keylen);
 914         if (key) {
 915                 keys->send = decrypt_ms_key(key, keylen,
 916                                             sent_msg->hdr->authenticator,
 917                                             secret, secret_len,
 918                                             &keys->send_len);
 919                 os_free(key);
 920         }
 921
 922         key = radius_msg_get_vendor_attr(msg, RADIUS_VENDOR_ID_MICROSOFT,
 923                                          RADIUS_VENDOR_ATTR_MS_MPPE_RECV_KEY,
 924                                          &keylen);
 925         if (key) {
 926                 keys->recv = decrypt_ms_key(key, keylen,
 927                                             sent_msg->hdr->authenticator,
 928                                             secret, secret_len,
 929                                             &keys->recv_len);
 930                 os_free(key);
 931         }
 932
 933         return keys;
 934 }
 935
 936
 937 struct radius_ms_mppe_keys *
 938 radius_msg_get_cisco_keys(struct radius_msg *msg, struct radius_msg *sent_msg,
 939                           u8 *secret, size_t secret_len)
 940 {
 941         u8 *key;
 942         size_t keylen;
 943         struct radius_ms_mppe_keys *keys;
 944
 945         if (msg == NULL || sent_msg == NULL)
 946                 return NULL;
 947
 948         keys = wpa_zalloc(sizeof(*keys));
 949         if (keys == NULL)
 950                 return NULL;
 951
 952         key = radius_msg_get_vendor_attr(msg, RADIUS_VENDOR_ID_CISCO,
 953                                          RADIUS_CISCO_AV_PAIR, &keylen);
 954         if (key && keylen == 51 &&
 955             os_memcmp(key, "leap:session-key=", 17) == 0) {
 956                 keys->recv = decrypt_ms_key(key + 17, keylen - 17,
 957                                             sent_msg->hdr->authenticator,
 958                                             secret, secret_len,
 959                                             &keys->recv_len);
 960         }
 961         os_free(key);
 962
 963         return keys;
 964 }
 965
 966
 967 int radius_msg_add_mppe_keys(struct radius_msg *msg,
 968                              const u8 *req_authenticator,
 969                              const u8 *secret, size_t secret_len,
 970                              const u8 *send_key, size_t send_key_len,
 971                              const u8 *recv_key, size_t recv_key_len)
 972 {
 973         struct radius_attr_hdr *attr;
 974         u32 vendor_id = htonl(RADIUS_VENDOR_ID_MICROSOFT);
 975         u8 *buf;
 976         struct radius_attr_vendor *vhdr;
 977         u8 *pos;
 978         size_t elen;
 979         int hlen;
 980         u16 salt;
 981
 982         hlen = sizeof(vendor_id) + sizeof(*vhdr) + 2;
 983
 984         /* MS-MPPE-Send-Key */
 985         buf = os_malloc(hlen + send_key_len + 16);
 986         if (buf == NULL) {
 987                 return 0;
 988         }
 989         pos = buf;
 990         os_memcpy(pos, &vendor_id, sizeof(vendor_id));
 991         pos += sizeof(vendor_id);
 992         vhdr = (struct radius_attr_vendor *) pos;
 993         vhdr->vendor_type = RADIUS_VENDOR_ATTR_MS_MPPE_SEND_KEY;
 994         pos = (u8 *) (vhdr + 1);
 995         salt = os_random() | 0x8000;
 996         *pos++ = salt >> 8;
 997         *pos++ = salt;
 998         encrypt_ms_key(send_key, send_key_len, salt, req_authenticator, secret,
 999                        secret_len, pos, &elen);
1000         vhdr->vendor_length = hlen + elen - sizeof(vendor_id);
1001
1002         attr = radius_msg_add_attr(msg, RADIUS_ATTR_VENDOR_SPECIFIC,
1003                                    buf, hlen + elen);
1004         os_free(buf);
1005         if (attr == NULL) {
1006                 return 0;
1007         }
1008
1009         /* MS-MPPE-Recv-Key */
1010         buf = os_malloc(hlen + send_key_len + 16);
1011         if (buf == NULL) {
1012                 return 0;
1013         }
1014         pos = buf;
1015         os_memcpy(pos, &vendor_id, sizeof(vendor_id));
1016         pos += sizeof(vendor_id);
1017         vhdr = (struct radius_attr_vendor *) pos;
1018         vhdr->vendor_type = RADIUS_VENDOR_ATTR_MS_MPPE_RECV_KEY;
1019         pos = (u8 *) (vhdr + 1);
1020         salt ^= 1;
1021         *pos++ = salt >> 8;
1022         *pos++ = salt;
1023         encrypt_ms_key(recv_key, recv_key_len, salt, req_authenticator, secret,
1024                        secret_len, pos, &elen);
1025         vhdr->vendor_length = hlen + elen - sizeof(vendor_id);
1026
1027         attr = radius_msg_add_attr(msg, RADIUS_ATTR_VENDOR_SPECIFIC,
1028                                    buf, hlen + elen);
1029         os_free(buf);
1030         if (attr == NULL) {
1031                 return 0;
1032         }
1033
1034         return 1;
1035 }
1036
1037
1038 /* Add User-Password attribute to a RADIUS message and encrypt it as specified
1039  * in RFC 2865, Chap. 5.2 */
1040 struct radius_attr_hdr *
1041 radius_msg_add_attr_user_password(struct radius_msg *msg,
1042                                   u8 *data, size_t data_len,
1043                                   u8 *secret, size_t secret_len)
1044 {
1045         u8 buf[128];
1046         int padlen, i;
1047         size_t buf_len, pos;
1048         const u8 *addr[2];
1049         size_t len[2];
1050         u8 hash[16];
1051
1052         if (data_len > 128)
1053                 return NULL;
1054
1055         os_memcpy(buf, data, data_len);
1056         buf_len = data_len;
1057
1058         padlen = data_len % 16;
1059         if (padlen) {
1060                 padlen = 16 - padlen;
1061                 os_memset(buf + data_len, 0, padlen);
1062                 buf_len += padlen;
1063         }
1064
1065         addr[0] = secret;
1066         len[0] = secret_len;
1067         addr[1] = msg->hdr->authenticator;
1068         len[1] = 16;
1069         md5_vector(2, addr, len, hash);
1070
1071         for (i = 0; i < 16; i++)
1072                 buf[i] ^= hash[i];
1073         pos = 16;
1074
1075         while (pos < buf_len) {
1076                 addr[0] = secret;
1077                 len[0] = secret_len;
1078                 addr[1] = &buf[pos - 16];
1079                 len[1] = 16;
1080                 md5_vector(2, addr, len, hash);
1081
1082                 for (i = 0; i < 16; i++)
1083                         buf[pos + i] ^= hash[i];
1084
1085                 pos += 16;
1086         }
1087
1088         return radius_msg_add_attr(msg, RADIUS_ATTR_USER_PASSWORD,
1089                                    buf, buf_len);
1090 }
1091
1092
1093 int radius_msg_get_attr(struct radius_msg *msg, u8 type, u8 *buf, size_t len)
1094 {
1095         struct radius_attr_hdr *attr = NULL;
1096         size_t i, dlen;
1097
1098         for (i = 0; i < msg->attr_used; i++) {
1099                 if (msg->attrs[i]->type == type) {
1100                         attr = msg->attrs[i];
1101                         break;
1102                 }
1103         }
1104
1105         if (!attr)
1106                 return -1;
1107
1108         dlen = attr->length - sizeof(*attr);
1109         if (buf)
1110                 os_memcpy(buf, (attr + 1), dlen > len ? len : dlen);
1111         return dlen;
1112 }
1113
1114
1115 int radius_msg_get_attr_ptr(struct radius_msg *msg, u8 type, u8 **buf,
1116                             size_t *len, const u8 *start)
1117 {
1118         size_t i;
1119         struct radius_attr_hdr *attr = NULL;
1120
1121         for (i = 0; i < msg->attr_used; i++) {
1122                 if (msg->attrs[i]->type == type &&
1123                     (start == NULL || (u8 *) msg->attrs[i] > start)) {
1124                         attr = msg->attrs[i];
1125                         break;
1126                 }
1127         }
1128
1129         if (!attr)
1130                 return -1;
1131
1132         *buf = (u8 *) (attr + 1);
1133         *len = attr->length - sizeof(*attr);
1134         return 0;
1135 }
1136
1137
1138 int radius_msg_count_attr(struct radius_msg *msg, u8 type, int min_len)
1139 {
1140         size_t i;
1141         int count;
1142
1143         for (count = 0, i = 0; i < msg->attr_used; i++) {
1144                 if (msg->attrs[i]->type == type &&
1145                     msg->attrs[i]->length >=
1146                     sizeof(struct radius_attr_hdr) + min_len)
1147                         count++;
1148         }
1149
1150         return count;
1151 }
1152
1153
1154 struct radius_tunnel_attrs {
1155         int tag_used;
1156         int type; /* Tunnel-Type */
1157         int medium_type; /* Tunnel-Medium-Type */
1158         int vlanid;
1159 };
1160
1161
1162 /**
1163  * radius_msg_get_vlanid - Parse RADIUS attributes for VLAN tunnel information
1164  * @msg: RADIUS message
1165  * Returns: VLAN ID for the first tunnel configuration of -1 if none is found
1166  */
1167 int radius_msg_get_vlanid(struct radius_msg *msg)
1168 {
1169         struct radius_tunnel_attrs tunnel[RADIUS_TUNNEL_TAGS], *tun;
1170         size_t i;
1171         struct radius_attr_hdr *attr = NULL;
1172         const u8 *data;
1173         char buf[10];
1174         size_t dlen;
1175
1176         os_memset(&tunnel, 0, sizeof(tunnel));
1177
1178         for (i = 0; i < msg->attr_used; i++) {
1179                 attr = msg->attrs[i];
1180                 data = (const u8 *) (attr + 1);
1181                 dlen = attr->length - sizeof(*attr);
1182                 if (attr->length < 3)
1183                         continue;
1184                 if (data[0] >= RADIUS_TUNNEL_TAGS)
1185                         tun = &tunnel[0];
1186                 else
1187                         tun = &tunnel[data[0]];
1188
1189                 switch (attr->type) {
1190                 case RADIUS_ATTR_TUNNEL_TYPE:
1191                         if (attr->length != 6)
1192                                 break;
1193                         tun->tag_used++;
1194                         tun->type = (data[1] << 16) | (data[2] << 8) | data[3];
1195                         break;
1196                 case RADIUS_ATTR_TUNNEL_MEDIUM_TYPE:
1197                         if (attr->length != 6)
1198                                 break;
1199                         tun->tag_used++;
1200                         tun->medium_type =
1201                                 (data[1] << 16) | (data[2] << 8) | data[3];
1202                         break;
1203                 case RADIUS_ATTR_TUNNEL_PRIVATE_GROUP_ID:
1204                         if (data[0] < RADIUS_TUNNEL_TAGS) {
1205                                 data++;
1206                                 dlen--;
1207                         }
1208                         if (dlen >= sizeof(buf))
1209                                 break;
1210                         os_memcpy(buf, data, dlen);
1211                         buf[dlen] = '\0';
1212                         tun->tag_used++;
1213                         tun->vlanid = atoi(buf);
1214                         break;
1215                 }
1216         }
1217
1218         for (i = 0; i < RADIUS_TUNNEL_TAGS; i++) {
1219                 tun = &tunnel[i];
1220                 if (tun->tag_used &&
1221                     tun->type == RADIUS_TUNNEL_TYPE_VLAN &&
1222                     tun->medium_type == RADIUS_TUNNEL_MEDIUM_TYPE_802 &&
1223                     tun->vlanid > 0)
1224                         return tun->vlanid;
1225         }
1226
1227         return -1;
1228 }