radsecproxy.c

   1 /*
   2  * Copyright (C) 2006 Stig Venaas <venaas@uninett.no>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  */
   8
   9 /* BUGS:
  10  * peers can not yet be specified with literal IPv6 addresses due to port syntax
  11  */
  12
  13 /* TODO:
  14  * Among other things:
  15  * timer based client retrans or maybe no retrans and just a timer...
  16  * make our server ignore client retrans?
  17  * tls keep alives
  18  * routing based on id....
  19  * need to also encrypt Tunnel-Password and Message-Authenticator attrs
  20  * tls certificate validation
  21 */
  22
  23 /* For UDP there is one server instance consisting of udpserverrd and udpserverth
  24  *              rd is responsible for init and launching wr
  25  * For TLS there is a server instance that launches tlsserverrd for each TLS peer
  26  *          each tlsserverrd launches tlsserverwr
  27  * For each UDP/TLS peer there is clientrd and clientwr, clientwr is responsible
  28  *          for init and launching rd
  29  *
  30  * serverrd will receive a request, processes it and puts it in the requestq of
  31  *          the appropriate clientwr
  32  * clientwr monitors its requestq and sends requests
  33  * clientrd looks for responses, processes them and puts them in the replyq of
  34  *          the peer the request came from
  35  * serverwr monitors its reply and sends replies
  36  *
  37  * In addition to the main thread, we have:
  38  * If UDP peers are configured, there will be 2 + 2 * #peers UDP threads
  39  * If TLS peers are configured, there will initially be 2 * #peers TLS threads
  40  * For each TLS peer connecting to us there will be 2 more TLS threads
  41  *       This is only for connected peers
  42  * Example: With 3 UDP peer and 30 TLS peers, there will be a max of
  43  *          1 + (2 + 2 * 3) + (2 * 30) + (2 * 30) = 129 threads
  44 */
  45
  46 #include <netdb.h>
  47 #include <unistd.h>
  48 #include <sys/time.h>
  49 #include <pthread.h>
  50 #include <openssl/ssl.h>
  51 #include <openssl/rand.h>
  52 #include <openssl/err.h>
  53 #include <openssl/md5.h>
  54 #include "radsecproxy.h"
  55
  56 static struct peer peers[MAX_PEERS];
  57 static int peer_count = 0;
  58
  59 static struct replyq udp_server_replyq;
  60 static int udp_server_sock = -1;
  61 static char *udp_server_port = DEFAULT_UDP_PORT;
  62 static pthread_mutex_t *ssl_locks;
  63 static long *ssl_lock_count;
  64 static SSL_CTX *ssl_ctx_cl;
  65 extern int optind;
  66 extern char *optarg;
  67
  68 /* callbacks for making OpenSSL thread safe */
  69 unsigned long ssl_thread_id() {
  70         return (unsigned long)pthread_self();
  71 };
  72
  73 void ssl_locking_callback(int mode, int type, const char *file, int line) {
  74     if (mode & CRYPTO_LOCK) {
  75         pthread_mutex_lock(&ssl_locks[type]);
  76         ssl_lock_count[type]++;
  77     } else
  78         pthread_mutex_unlock(&ssl_locks[type]);
  79 }
  80
  81 void ssl_locks_setup() {
  82     int i;
  83
  84     ssl_locks = malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
  85     ssl_lock_count = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
  86     for (i = 0; i < CRYPTO_num_locks(); i++) {
  87         ssl_lock_count[i] = 0;
  88         pthread_mutex_init(&ssl_locks[i], NULL);
  89     }
  90
  91     CRYPTO_set_id_callback(ssl_thread_id);
  92     CRYPTO_set_locking_callback(ssl_locking_callback);
  93 }
  94
  95 int resolvepeer(struct peer *peer) {
  96     struct addrinfo hints;
  97
  98     pthread_mutex_lock(&peer->lock);
  99     if (peer->addrinfo) {
 100         /* assume we should re-resolve */
 101         freeaddrinfo(peer->addrinfo);
 102         peer->addrinfo = NULL;
 103     }
 104
 105     memset(&hints, 0, sizeof(hints));
 106     hints.ai_socktype = (peer->type == 'T' ? SOCK_STREAM : SOCK_DGRAM);
 107     hints.ai_family = AF_UNSPEC;
 108     if (getaddrinfo(peer->host, peer->port, &hints, &peer->addrinfo)) {
 109         err("resolvepeer: can't resolve %s port %s", peer->host, peer->port);
 110         peer->addrinfo = NULL; /* probably don't need this */
 111         pthread_mutex_unlock(&peer->lock);
 112         return 0;
 113     }
 114     pthread_mutex_unlock(&peer->lock);
 115     return 1;
 116 }
 117
 118 int connecttopeer(struct peer *peer) {
 119     int s;
 120     struct addrinfo *res;
 121
 122     if (!peer->addrinfo) {
 123         resolvepeer(peer);
 124         if (!peer->addrinfo) {
 125             printf("connecttopeer: can't resolve %s into address to connect to\n", peer->host);
 126             return -1;
 127         }
 128     }
 129
 130     for (res = peer->addrinfo; res; res = res->ai_next) {
 131         s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
 132         if (s < 0) {
 133             err("connecttopeer: socket failed");
 134             continue;
 135         }
 136         if (connect(s, res->ai_addr, res->ai_addrlen) == 0)
 137             break;
 138         err("connecttopeer: connect failed");
 139         close(s);
 140         s = -1;
 141     }
 142     return s;
 143 }
 144
 145 /* returns the peer with matching address, or NULL */
 146 /* if peer argument is not NULL, we only check that one peer */
 147 struct peer *find_peer(char type, struct sockaddr *addr, struct peer *peer) {
 148     struct sockaddr_in6 *sa6;
 149     struct in_addr *a4 = NULL;
 150     struct peer *p;
 151     int i;
 152     struct addrinfo *res;
 153
 154     if (addr->sa_family == AF_INET6) {
 155         sa6 = (struct sockaddr_in6 *)addr;
 156         if (IN6_IS_ADDR_V4MAPPED(&sa6->sin6_addr))
 157             a4 = (struct in_addr *)&sa6->sin6_addr.s6_addr[12];
 158     } else
 159         a4 = &((struct sockaddr_in *)addr)->sin_addr;
 160
 161     p = (peer ? peer : peers);
 162     for (i = 0; i < peer_count; i++) {
 163         if (p->type == type)
 164             for (res = p->addrinfo; res; res = res->ai_next)
 165                 if ((a4 && res->ai_family == AF_INET &&
 166                      !memcmp(a4, &((struct sockaddr_in *)res->ai_addr)->sin_addr, 4)) ||
 167                     (res->ai_family == AF_INET6 &&
 168                      !memcmp(&sa6->sin6_addr, &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr, 16)))
 169                     return p;
 170         if (peer)
 171             break;
 172         p++;
 173     }
 174     return NULL;
 175 }
 176
 177 /* if *peer == NULL we return who we received from, else require it to be from peer */
 178 /* return from in sa if not NULL */
 179 unsigned char *radudpget(int s, struct peer **peer, struct sockaddr_storage *sa) {
 180     int cnt, len;
 181     struct peer *f;
 182     unsigned char buf[65536], *rad;
 183     struct sockaddr_storage from;
 184     socklen_t fromlen = sizeof(from);
 185
 186     for (;;) {
 187         cnt = recvfrom(s, buf, sizeof(buf), 0, (struct sockaddr *)&from, &fromlen);
 188         if (cnt == -1) {
 189             err("radudpget: recv failed");
 190             continue;
 191         }
 192         printf("radudpget: got %d bytes from %s\n", cnt, addr2string((struct sockaddr *)&from, fromlen));
 193
 194         if (cnt < 20) {
 195             printf("radudpget: packet too small\n");
 196             continue;
 197         }
 198
 199         len = RADLEN(buf);
 200
 201         if (cnt < len) {
 202             printf("radudpget: packet smaller than length field in radius header\n");
 203             continue;
 204         }
 205         if (cnt > len)
 206             printf("radudpget: packet was padded with %d bytes\n", cnt - len);
 207
 208         f = find_peer('U', (struct sockaddr *)&from, *peer);
 209         if (!f) {
 210             printf("radudpget: got packet from wrong or unknown UDP peer, ignoring\n");
 211             continue;
 212         }
 213
 214         rad = malloc(len);
 215         if (rad)
 216             break;
 217         err("radudpget: malloc failed");
 218     }
 219     memcpy(rad, buf, len);
 220     *peer = f; /* only need this if *peer == NULL, but if not NULL *peer == f here */
 221     if (sa)
 222         *sa = from;
 223     return rad;
 224 }
 225
 226 void tlsconnect(struct peer *peer, struct timeval *when, char *text) {
 227     struct timeval now;
 228     time_t elapsed;
 229     unsigned long error;
 230
 231     pthread_mutex_lock(&peer->lock);
 232     if (when && memcmp(&peer->lastconnecttry, when, sizeof(struct timeval))) {
 233         /* already reconnected, nothing to do */
 234         printf("tlsconnect: seems already reconnected\n");
 235         pthread_mutex_unlock(&peer->lock);
 236         return;
 237     }
 238
 239     printf("tlsconnect %s\n", text);
 240
 241     for (;;) {
 242         printf("tlsconnect: trying to open TLS connection to %s port %s\n", peer->host, peer->port);
 243         gettimeofday(&now, NULL);
 244         elapsed = now.tv_sec - peer->lastconnecttry.tv_sec;
 245         memcpy(&peer->lastconnecttry, &now, sizeof(struct timeval));
 246         if (peer->connectionok) {
 247             peer->connectionok = 0;
 248             sleep(10);
 249         } else if (elapsed < 5)
 250             sleep(10);
 251         else if (elapsed < 600)
 252             sleep(elapsed * 2);
 253         else if (elapsed < 10000) /* no sleep at startup */
 254                 sleep(900);
 255         if (peer->sockcl >= 0)
 256             close(peer->sockcl);
 257         if ((peer->sockcl = connecttopeer(peer)) < 0)
 258             continue;
 259         SSL_free(peer->sslcl);
 260         peer->sslcl = SSL_new(ssl_ctx_cl);
 261         SSL_set_fd(peer->sslcl, peer->sockcl);
 262         if (SSL_connect(peer->sslcl) > 0)
 263             break;
 264         while ((error = ERR_get_error()))
 265             err("tlsconnect: TLS: %s", ERR_error_string(error, NULL));
 266     }
 267     printf("tlsconnect: TLS connection to %s port %s up\n", peer->host, peer->port);
 268     pthread_mutex_unlock(&peer->lock);
 269 }
 270
 271 unsigned char *radtlsget(SSL *ssl) {
 272     int cnt, total, len;
 273     unsigned char buf[4], *rad;
 274
 275     for (;;) {
 276         for (total = 0; total < 4; total += cnt) {
 277             cnt = SSL_read(ssl, buf + total, 4 - total);
 278             if (cnt <= 0) {
 279                 printf("radtlsget: connection lost\n");
 280                 return NULL;
 281             }
 282         }
 283
 284         len = RADLEN(buf);
 285         rad = malloc(len);
 286         if (!rad) {
 287             err("radtlsget: malloc failed");
 288             continue;
 289         }
 290         memcpy(rad, buf, 4);
 291
 292         for (; total < len; total += cnt) {
 293             cnt = SSL_read(ssl, rad + total, len - total);
 294             if (cnt <= 0) {
 295                 printf("radtlsget: connection lost\n");
 296                 free(rad);
 297                 return NULL;
 298             }
 299         }
 300
 301         if (total >= 20)
 302             break;
 303
 304         free(rad);
 305         printf("radtlsget: packet smaller than minimum radius size\n");
 306     }
 307
 308     printf("radtlsget: got %d bytes\n", total);
 309     return rad;
 310 }
 311
 312 int clientradput(struct peer *peer, unsigned char *rad) {
 313     int cnt;
 314     size_t len;
 315     unsigned long error;
 316     struct timeval lastconnecttry;
 317
 318     len = RADLEN(rad);
 319     if (peer->type == 'U') {
 320         if (send(peer->sockcl, rad, len, 0) >= 0) {
 321             printf("clienradput: sent UDP of length %d to %s port %s\n", len, peer->host, peer->port);
 322             return 1;
 323         }
 324         err("clientradput: send failed");
 325         return 0;
 326     }
 327
 328     lastconnecttry = peer->lastconnecttry;
 329     while ((cnt = SSL_write(peer->sslcl, rad, len)) <= 0) {
 330         while ((error = ERR_get_error()))
 331             err("clientwr: TLS: %s", ERR_error_string(error, NULL));
 332         tlsconnect(peer, &lastconnecttry, "clientradput");
 333         lastconnecttry = peer->lastconnecttry;
 334     }
 335
 336     peer->connectionok = 1;
 337     printf("clientradput: Sent %d bytes, Radius packet of length %d to TLS peer %s\n",
 338            cnt, len, peer->host);
 339     return 1;
 340 }
 341
 342 int radsign(unsigned char *rad, unsigned char *sec) {
 343     static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 344     static unsigned char first = 1;
 345     static EVP_MD_CTX mdctx;
 346     unsigned int md_len;
 347     int result;
 348
 349     pthread_mutex_lock(&lock);
 350     if (first) {
 351         EVP_MD_CTX_init(&mdctx);
 352         first = 0;
 353     }
 354
 355     result = (EVP_DigestInit_ex(&mdctx, EVP_md5(), NULL) &&
 356         EVP_DigestUpdate(&mdctx, rad, RADLEN(rad)) &&
 357         EVP_DigestUpdate(&mdctx, sec, strlen(sec)) &&
 358         EVP_DigestFinal_ex(&mdctx, rad + 4, &md_len) &&
 359         md_len == 16);
 360     pthread_mutex_unlock(&lock);
 361     return result;
 362 }
 363
 364 int validauth(unsigned char *rad, unsigned char *reqauth, unsigned char *sec) {
 365     static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 366     static unsigned char first = 1;
 367     static EVP_MD_CTX mdctx;
 368     unsigned char hash[EVP_MAX_MD_SIZE];
 369     unsigned int len;
 370     int result;
 371
 372     pthread_mutex_lock(&lock);
 373     if (first) {
 374         EVP_MD_CTX_init(&mdctx);
 375         first = 0;
 376     }
 377
 378     len = RADLEN(rad);
 379
 380     result = (EVP_DigestInit_ex(&mdctx, EVP_md5(), NULL) &&
 381               EVP_DigestUpdate(&mdctx, rad, 4) &&
 382               EVP_DigestUpdate(&mdctx, reqauth, 16) &&
 383               (len <= 20 || EVP_DigestUpdate(&mdctx, rad + 20, len - 20)) &&
 384               EVP_DigestUpdate(&mdctx, sec, strlen(sec)) &&
 385               EVP_DigestFinal_ex(&mdctx, hash, &len) &&
 386               len == 16 &&
 387               !memcmp(hash, rad + 4, 16));
 388     pthread_mutex_unlock(&lock);
 389     return result;
 390 }
 391
 392 void sendrq(struct peer *to, struct peer *from, struct request *rq) {
 393     int i;
 394
 395     pthread_mutex_lock(&to->newrq_mutex);
 396     for (i = 0; i < MAX_REQUESTS; i++)
 397         if (!to->requests[i].buf)
 398             break;
 399     if (i == MAX_REQUESTS) {
 400         printf("No room in queue, dropping request\n");
 401         pthread_mutex_unlock(&to->newrq_mutex);
 402         return;
 403     }
 404
 405     rq->buf[1] = (char)i;
 406     to->requests[i] = *rq;
 407
 408     if (!to->newrq) {
 409         to->newrq = 1;
 410         printf("signalling client writer\n");
 411         pthread_cond_signal(&to->newrq_cond);
 412     }
 413     pthread_mutex_unlock(&to->newrq_mutex);
 414 }
 415
 416 void sendreply(struct peer *to, struct peer *from, char *buf, struct sockaddr_storage *tosa) {
 417     struct replyq *replyq = to->replyq;
 418
 419     pthread_mutex_lock(&replyq->count_mutex);
 420     if (replyq->count == replyq->size) {
 421         printf("No room in queue, dropping request\n");
 422         pthread_mutex_unlock(&replyq->count_mutex);
 423         return;
 424     }
 425
 426     replyq->replies[replyq->count].buf = buf;
 427     if (tosa)
 428         replyq->replies[replyq->count].tosa = *tosa;
 429     replyq->count++;
 430
 431     if (replyq->count == 1) {
 432         printf("signalling client writer\n");
 433         pthread_cond_signal(&replyq->count_cond);
 434     }
 435     pthread_mutex_unlock(&replyq->count_mutex);
 436 }
 437
 438 int pwdcrypt(uint8_t *plain, uint8_t *enc, uint8_t enclen, uint8_t *shared, uint8_t sharedlen,
 439                 uint8_t *auth) {
 440     static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 441     static unsigned char first = 1;
 442     static EVP_MD_CTX mdctx;
 443     unsigned char hash[EVP_MAX_MD_SIZE], *input;
 444     unsigned int md_len;
 445     uint8_t i, offset = 0;
 446
 447     pthread_mutex_lock(&lock);
 448     if (first) {
 449         EVP_MD_CTX_init(&mdctx);
 450         first = 0;
 451     }
 452
 453     input = auth;
 454     for (;;) {
 455         if (!EVP_DigestInit_ex(&mdctx, EVP_md5(), NULL) ||
 456             !EVP_DigestUpdate(&mdctx, shared, sharedlen) ||
 457             !EVP_DigestUpdate(&mdctx, input, 16) ||
 458             !EVP_DigestFinal_ex(&mdctx, hash, &md_len) ||
 459             md_len != 16) {
 460             pthread_mutex_unlock(&lock);
 461             return 0;
 462         }
 463         for (i = 0; i < 16; i++)
 464             plain[offset + i] = hash[i] ^ enc[offset + i];
 465         offset += 16;
 466         if (offset == enclen)
 467             break;
 468         input = enc + offset - 16;
 469     }
 470     pthread_mutex_unlock(&lock);
 471     return 1;
 472 }
 473
 474 struct peer *id2peer(char *id, uint8_t len) {
 475     int i;
 476     char **realm;
 477
 478     for (i = 0; i < peer_count; i++) {
 479         for (realm = peers[i].realms; *realm; realm++) {
 480             /* assume test@domain */
 481             printf("realmlength %d, usernamelength %d\n", strlen(*realm), len);
 482             if (strlen(*realm) == len - 5) {
 483                 printf("lengths match\n");
 484                 if (!memcmp(id + 5, *realm, len - 5)) {
 485                     printf("found matching realm: %s, host %s\n", *realm, peers[i].host);
 486                 return peers + i;
 487                 }
 488             }
 489         }
 490     }
 491     return NULL;
 492 }
 493
 494 struct peer *radsrv(struct request *rq, char *buf, struct peer *from) {
 495     uint8_t code, id, *auth, *attr, *usernameattr = NULL, *userpwdattr = NULL, pwd[128], pwdlen;
 496     int i;
 497     uint16_t len;
 498     int left;
 499     struct peer *to;
 500     unsigned char newauth[16];
 501
 502     code = *(uint8_t *)buf;
 503     id = *(uint8_t *)(buf + 1);
 504     len = RADLEN(buf);
 505     auth = (uint8_t *)(buf + 4);
 506
 507     printf("radsrv: code %d, id %d, length %d\n", code, id, len);
 508
 509     if (code != RAD_Access_Request) {
 510         printf("radsrv: server currently accepts only access-requests, ignoring\n");
 511         return NULL;
 512     }
 513
 514     left = len - 20;
 515     attr = buf + 20;
 516
 517     while (left > 1) {
 518         left -= attr[RAD_Attr_Length];
 519         if (left < 0) {
 520             printf("radsrv: attribute length exceeds packet length, ignoring packet\n");
 521             return NULL;
 522         }
 523         switch (attr[RAD_Attr_Type]) {
 524         case RAD_Attr_User_Name:
 525             usernameattr = attr;
 526             break;
 527         case RAD_Attr_User_Password:
 528             userpwdattr = attr;
 529             break;
 530         }
 531         attr += attr[RAD_Attr_Length];
 532     }
 533     if (left)
 534         printf("radsrv: malformed packet? remaining byte after last attribute\n");
 535
 536     if (usernameattr) {
 537         printf("radsrv: Username: ");
 538         for (i = 0; i < usernameattr[RAD_Attr_Length] - 2; i++)
 539             printf("%c", usernameattr[RAD_Attr_Value + i]);
 540         printf("\n");
 541     }
 542
 543     /* find out where to send the packet, for now we send to first connected
 544        TLS peer if UDP, and first UDP peer if TLS */
 545
 546     to = id2peer(&usernameattr[RAD_Attr_Value], usernameattr[RAD_Attr_Length] - 2);
 547     if (!to) {
 548         printf("radsrv: ignoring request, don't know where to send it\n");
 549         return NULL;
 550     }
 551
 552 #if 0
 553     i = peer_count;
 554
 555     switch (from->type) {
 556     case 'U':
 557         for (i = 0; i < peer_count; i++)
 558             if (peers[i].type == 'T' && peers[i].sockcl >= 0)
 559                 break;
 560         break;
 561     case 'T':
 562         for (i = 0; i < peer_count; i++)
 563             if (peers[i].type == 'U')
 564                 break;
 565         break;
 566     }
 567     if (i == peer_count) {
 568         printf("radsrv: ignoring request, don't know where to send it\n");
 569         return NULL;
 570     }
 571
 572     to = &peers[i];
 573
 574 #endif
 575
 576     if (!RAND_bytes(newauth, 16)) {
 577         printf("radsrv: failed to generate random auth\n");
 578         return NULL;
 579     }
 580
 581     if (userpwdattr) {
 582         printf("radsrv: found userpwdattr of length %d\n", userpwdattr[RAD_Attr_Length]);
 583         pwdlen = userpwdattr[RAD_Attr_Length] - 2;
 584         if (pwdlen < 16 || pwdlen > 128 || pwdlen % 16) {
 585             printf("radsrv: invalid user password length\n");
 586             return NULL;
 587         }
 588
 589         if (!pwdcrypt(pwd, &userpwdattr[RAD_Attr_Value], pwdlen, from->secret, strlen(from->secret), auth)) {
 590             printf("radsrv: cannot decrypt password\n");
 591             return NULL;
 592         }
 593         printf("radsrv: password: ");
 594         for (i = 0; i < pwdlen; i++)
 595             printf("%02x ", pwd[i]);
 596         printf("\n");
 597         if (!pwdcrypt(&userpwdattr[RAD_Attr_Value], pwd, pwdlen, to->secret, strlen(to->secret), newauth)) {
 598             printf("radsrv: cannot encrypt password\n");
 599             return NULL;
 600         }
 601     }
 602
 603     rq->buf = buf;
 604     rq->from = from;
 605     rq->origid = id;
 606     memcpy(rq->origauth, auth, 16);
 607     memcpy(rq->buf + 4, newauth, 16);
 608     return to;
 609 }
 610
 611 void *clientrd(void *arg) {
 612     struct peer *from, *peer = (struct peer *)arg;
 613     int i;
 614     unsigned char *buf;
 615     struct sockaddr_storage fromsa;
 616     struct timeval lastconnecttry;
 617
 618     for (;;) {
 619         lastconnecttry = peer->lastconnecttry;
 620         buf = (peer->type == 'U' ? radudpget(peer->sockcl, &peer, NULL) : radtlsget(peer->sslcl));
 621         if (!buf && peer->type == 'T') {
 622             tlsconnect(peer, &lastconnecttry, "clientrd");
 623             continue;
 624         }
 625
 626         peer->connectionok = 1;
 627
 628         i = buf[1]; /* i is the id */
 629
 630         pthread_mutex_lock(&peer->newrq_mutex);
 631         if (!peer->requests[i].buf || !peer->requests[i].tries) {
 632             pthread_mutex_unlock(&peer->newrq_mutex);
 633             printf("clientrd: no matching request sent with this id, ignoring\n");
 634             continue;
 635         }
 636
 637         if (peer->requests[i].received) {
 638             pthread_mutex_unlock(&peer->newrq_mutex);
 639             printf("clientrd: already received, ignoring\n");
 640             continue;
 641         }
 642
 643         if (!validauth(buf, peer->requests[i].buf + 4, peer->secret)) {
 644             pthread_mutex_unlock(&peer->newrq_mutex);
 645             printf("clientrd: invalid auth, ignoring\n");
 646             continue;
 647         }
 648
 649         /* once we set received = 1, requests[i] may be reused */
 650         buf[1] = (char)peer->requests[i].origid;
 651         memcpy(buf + 4, peer->requests[i].origauth, 16);
 652         from = peer->requests[i].from;
 653         if (from->type == 'U')
 654             fromsa = peer->requests[i].fromsa;
 655         peer->requests[i].received = 1;
 656         pthread_mutex_unlock(&peer->newrq_mutex);
 657
 658         if (!radsign(buf, from->secret)) {
 659             printf("clientrd: failed to sign message\n");
 660             continue;
 661         }
 662
 663         printf("clientrd: giving packet back to where it came from\n");
 664         sendreply(from, peer, buf, from->type == 'U' ? &fromsa : NULL);
 665     }
 666 }
 667
 668 void *clientwr(void *arg) {
 669     struct peer *peer = (struct peer *)arg;
 670     pthread_t clientrdth;
 671     int i;
 672
 673     if (peer->type == 'U') {
 674         if ((peer->sockcl = connecttopeer(peer)) < 0) {
 675             printf("clientwr: connecttopeer failed\n");
 676             exit(1);
 677         }
 678     } else
 679         tlsconnect(peer, NULL, "new client");
 680
 681     if (pthread_create(&clientrdth, NULL, clientrd, (void *)peer))
 682         errx("clientwr: pthread_create failed");
 683
 684     for (;;) {
 685         pthread_mutex_lock(&peer->newrq_mutex);
 686         while (!peer->newrq) {
 687             printf("clientwr: waiting for signal\n");
 688             pthread_cond_wait(&peer->newrq_cond, &peer->newrq_mutex);
 689             printf("clientwr: got signal\n");
 690         }
 691         peer->newrq = 0;
 692         pthread_mutex_unlock(&peer->newrq_mutex);
 693
 694         for (i = 0; i < MAX_REQUESTS; i++) {
 695             pthread_mutex_lock(&peer->newrq_mutex);
 696             while (!peer->requests[i].buf && i < MAX_REQUESTS)
 697                 i++;
 698             if (i == MAX_REQUESTS) {
 699                 pthread_mutex_unlock(&peer->newrq_mutex);
 700                 break;
 701             }
 702
 703             /* already received or too many tries */
 704             if (peer->requests[i].received || peer->requests[i].tries > 2) {
 705                 free(peer->requests[i].buf);
 706                 /* setting this to NULL means that it can be reused */
 707                 peer->requests[i].buf = NULL;
 708                 pthread_mutex_unlock(&peer->newrq_mutex);
 709                 continue;
 710             }
 711             pthread_mutex_unlock(&peer->newrq_mutex);
 712
 713             peer->requests[i].tries++;
 714             clientradput(peer, peer->requests[i].buf);
 715         }
 716     }
 717     /* should do more work to maintain TLS connections, keepalives etc */
 718 }
 719
 720 void *udpserverwr(void *arg) {
 721     struct replyq *replyq = &udp_server_replyq;
 722     struct reply *reply = replyq->replies;
 723
 724     pthread_mutex_lock(&replyq->count_mutex);
 725     for (;;) {
 726         while (!replyq->count) {
 727             printf("udp server writer, waiting for signal\n");
 728             pthread_cond_wait(&replyq->count_cond, &replyq->count_mutex);
 729             printf("udp server writer, got signal\n");
 730         }
 731         pthread_mutex_unlock(&replyq->count_mutex);
 732
 733         if (sendto(udp_server_sock, reply->buf, RADLEN(reply->buf), 0,
 734                    (struct sockaddr *)&reply->tosa, SOCKADDR_SIZE(reply->tosa)) < 0)
 735             err("sendudp: send failed");
 736         free(reply->buf);
 737
 738         pthread_mutex_lock(&replyq->count_mutex);
 739         replyq->count--;
 740         memmove(replyq->replies, replyq->replies + 1,
 741                 replyq->count * sizeof(struct reply));
 742     }
 743 }
 744
 745 void *udpserverrd(void *arg) {
 746     struct request rq;
 747     unsigned char *buf;
 748     struct peer *to, *fr;
 749     pthread_t udpserverwrth;
 750
 751     if ((udp_server_sock = bindport(SOCK_DGRAM, udp_server_port)) < 0) {
 752         printf("udpserverrd: socket/bind failed\n");
 753         exit(1);
 754     }
 755     printf("udpserverrd: listening on UDP port %s\n", udp_server_port);
 756
 757     if (pthread_create(&udpserverwrth, NULL, udpserverwr, NULL))
 758         errx("pthread_create failed");
 759
 760     for (;;) {
 761         fr = NULL;
 762         memset(&rq, 0, sizeof(struct request));
 763         buf = radudpget(udp_server_sock, &fr, &rq.fromsa);
 764         to = radsrv(&rq, buf, fr);
 765         if (!to) {
 766             printf("udpserverrd: ignoring request, no place to send it\n");
 767             continue;
 768         }
 769         sendrq(to, fr, &rq);
 770     }
 771 }
 772
 773 void *tlsserverwr(void *arg) {
 774     int cnt;
 775     unsigned long error;
 776     struct peer *peer = (struct peer *)arg;
 777     struct replyq *replyq;
 778
 779     pthread_mutex_lock(&peer->replycount_mutex);
 780     for (;;) {
 781         replyq = peer->replyq;
 782         while (!replyq->count) {
 783             printf("tls server writer, waiting for signal\n");
 784             pthread_cond_wait(&replyq->count_cond, &replyq->count_mutex);
 785             printf("tls server writer, got signal\n");
 786         }
 787         pthread_mutex_unlock(&replyq->count_mutex);
 788         cnt = SSL_write(peer->sslsrv, replyq->replies->buf, RADLEN(replyq->replies->buf));
 789         if (cnt > 0)
 790             printf("tlsserverwr: Sent %d bytes, Radius packet of length %d\n",
 791                    cnt, RADLEN(replyq->replies->buf));
 792         else
 793             while ((error = ERR_get_error()))
 794                 err("tlsserverwr: SSL: %s", ERR_error_string(error, NULL));
 795         free(replyq->replies->buf);
 796
 797         pthread_mutex_lock(&replyq->count_mutex);
 798         replyq->count--;
 799         memmove(replyq->replies, replyq->replies + 1, replyq->count * sizeof(struct reply));
 800     }
 801 }
 802
 803 void *tlsserverrd(void *arg) {
 804     struct request rq;
 805     char unsigned *buf;
 806     unsigned long error;
 807     struct peer *to;
 808     int s;
 809     struct peer *peer = (struct peer *)arg;
 810     pthread_t tlsserverwrth;
 811
 812     printf("tlsserverrd starting\n");
 813     if (SSL_accept(peer->sslsrv) <= 0) {
 814         while ((error = ERR_get_error()))
 815             err("tlsserverrd: SSL: %s", ERR_error_string(error, NULL));
 816         errx("accept failed, child exiting");
 817     }
 818
 819     if (pthread_create(&tlsserverwrth, NULL, tlsserverwr, (void *)peer))
 820         errx("pthread_create failed");
 821
 822     for (;;) {
 823         buf = radtlsget(peer->sslsrv);
 824         if (!buf) {
 825             printf("tlsserverrd: connection lost\n");
 826             s = SSL_get_fd(peer->sslsrv);
 827             SSL_free(peer->sslsrv);
 828             peer->sslsrv = NULL;
 829             if (s >= 0)
 830                 close(s);
 831             pthread_exit(NULL);
 832         }
 833         printf("tlsserverrd: got Radius message from %s\n", peer->host);
 834         memset(&rq, 0, sizeof(struct request));
 835         to = radsrv(&rq, buf, peer);
 836         if (!to) {
 837             printf("ignoring request, no place to send it\n");
 838             continue;
 839         }
 840         sendrq(to, peer, &rq);
 841     }
 842 }
 843
 844 int tlslistener(SSL_CTX *ssl_ctx) {
 845     pthread_t tlsserverth;
 846     int s, snew;
 847     struct sockaddr_storage from;
 848     size_t fromlen = sizeof(from);
 849     struct peer *peer;
 850
 851     if ((s = bindport(SOCK_STREAM, DEFAULT_TLS_PORT)) < 0) {
 852         printf("tlslistener: socket/bind failed\n");
 853         exit(1);
 854     }
 855
 856     listen(s, 0);
 857     printf("listening for incoming TLS on port %s\n", DEFAULT_TLS_PORT);
 858
 859     for (;;) {
 860         snew = accept(s, (struct sockaddr *)&from, &fromlen);
 861         if (snew < 0)
 862             errx("accept failed");
 863         printf("incoming TLS connection from %s\n", addr2string((struct sockaddr *)&from, fromlen));
 864
 865         peer = find_peer('T', (struct sockaddr *)&from, NULL);
 866         if (!peer) {
 867             printf("ignoring request, not a known TLS peer\n");
 868             close(snew);
 869             continue;
 870         }
 871
 872         if (peer->sslsrv) {
 873             printf("Ignoring incoming connection, already have one from this peer\n");
 874             close(snew);
 875             continue;
 876         }
 877         peer->sslsrv = SSL_new(ssl_ctx);
 878         SSL_set_fd(peer->sslsrv, snew);
 879         if (pthread_create(&tlsserverth, NULL, tlsserverrd, (void *)peer))
 880             errx("pthread_create failed");
 881     }
 882     return 0;
 883 }
 884
 885 char *parsehostport(char *s, struct peer *peer) {
 886     char *p, *field;
 887     int ipv6 = 0;
 888
 889     p = s;
 890     // allow literal addresses and port, e.g. [2001:db8::1]:1812
 891     if (*p == '[') {
 892         p++;
 893         field = p;
 894         for (; *p && *p != ']' && *p != ' ' && *p != '\t' && *p != '\n'; p++);
 895         if (*p != ']') {
 896             printf("no ] matching initial [\n");
 897             exit(1);
 898         }
 899         ipv6 = 1;
 900     } else {
 901         field = p;
 902         for (; *p && *p != ':' && *p != ' ' && *p != '\t' && *p != '\n'; p++);
 903     }
 904     if (field == p) {
 905         printf("missing host/address\n");
 906         exit(1);
 907     }
 908     peer->host = malloc(p - field + 1);
 909     if (!peer->host)
 910         errx("malloc failed");
 911     memcpy(peer->host, field, p - field);
 912     peer->host[p - field] = '\0';
 913     if (ipv6) {
 914         p++;
 915         if (*p && *p != ':' && *p != ' ' && *p != '\t' && *p != '\n') {
 916             printf("unexpected character after ]\n");
 917             exit(1);
 918         }
 919     }
 920     if (*p == ':') {
 921             /* port number or service name is specified */;
 922             field = p++;
 923             for (; *p && *p != ' ' && *p != '\t' && *p != '\n'; p++);
 924             if (field == p) {
 925                 printf("syntax error, : but no following port\n");
 926                 exit(1);
 927             }
 928             peer->port = malloc(p - field + 1);
 929             if (!peer->port)
 930                 errx("malloc failed");
 931             memcpy(peer->port, field, p - field);
 932             peer->port[p - field] = '\0';
 933     } else
 934         peer->port = NULL;
 935     return p;
 936 }
 937
 938 // * is default, else longest match ... ";" used for separator
 939 char *parserealmlist(char *s, struct peer *peer) {
 940     char *p;
 941     int i, n, l;
 942
 943     for (p = s, n = 1; *p && *p != ' ' && *p != '\t' && *p != '\n'; p++)
 944         if (*p == ';')
 945             n++;
 946     l = p - s;
 947     if (!l) {
 948         peer->realms = NULL;
 949         return p;
 950     }
 951     peer->realmdata = malloc(l + 1);
 952     if (!peer->realmdata)
 953         errx("malloc failed");
 954     memcpy(peer->realmdata, s, l);
 955     peer->realmdata[l] = '\0';
 956     peer->realms = malloc((1+n) * sizeof(char *));
 957     if (!peer->realms)
 958         errx("malloc failed");
 959     peer->realms[0] = peer->realmdata;
 960     for (n = 1, i = 0; i < l; i++)
 961         if (peer->realmdata[i] == ';') {
 962             peer->realmdata[i] = '\0';
 963             peer->realms[n++] = peer->realmdata + i + 1;
 964         }
 965     peer->realms[n] = NULL;
 966     return p;
 967 }
 968
 969 void getconfig(const char *filename) {
 970     FILE *f;
 971     char line[1024];
 972     char *p, *field, **r;
 973     struct peer *peer;
 974
 975     peer_count = 0;
 976
 977     udp_server_replyq.replies = malloc(4 * MAX_REQUESTS * sizeof(struct reply));
 978     if (!udp_server_replyq.replies)
 979         errx("malloc failed");
 980     udp_server_replyq.size = 4 * MAX_REQUESTS;
 981     udp_server_replyq.count = 0;
 982     pthread_mutex_init(&udp_server_replyq.count_mutex, NULL);
 983     pthread_cond_init(&udp_server_replyq.count_cond, NULL);
 984
 985     f = fopen(filename, "r");
 986     if (!f)
 987         errx("getconfig failed to open %s for reading", filename);
 988
 989     while (fgets(line, 1024, f) && peer_count < MAX_PEERS) {
 990         peer = &peers[peer_count];
 991         memset(peer, 0, sizeof(struct peer));
 992
 993         for (p = line; *p == ' ' || *p == '\t'; p++);
 994         if (*p == '#' || *p == '\n')
 995             continue;
 996         if (*p != 'U' && *p != 'T') {
 997             printf("server type must be U or T, got %c\n", *p);
 998             exit(1);
 999         }
1000         peer->type = *p;
1001         for (p++; *p == ' ' || *p == '\t'; p++);
1002         p = parsehostport(p, peer);
1003         if (!peer->port)
1004             peer->port = (peer->type == 'U' ? DEFAULT_UDP_PORT : DEFAULT_TLS_PORT);
1005         for (; *p == ' ' || *p == '\t'; p++);
1006         p = parserealmlist(p, peer);
1007         if (!peer->realms) {
1008             printf("realm list must be specified\n");
1009             exit(1);
1010         }
1011         for (; *p == ' ' || *p == '\t'; p++);
1012         field = p;
1013         for (; *p && *p != ' ' && *p != '\t' && *p != '\n'; p++);
1014         if (field == p) {
1015             /* no secret set and end of line, line is complete if TLS */
1016             if (peer->type == 'U') {
1017                 printf("secret must be specified for UDP\n");
1018                 exit(1);
1019             }
1020             peer->secret = DEFAULT_TLS_SECRET;
1021         } else {
1022             peer->secret = malloc(p - field + 1);
1023             if (!peer->secret)
1024                 errx("malloc failed");
1025             memcpy(peer->secret, field, p - field);
1026             peer->secret[p - field] = '\0';
1027             /* check that rest of line only white space */
1028             for (; *p == ' ' || *p == '\t'; p++);
1029             if (*p && *p != '\n') {
1030                 printf("max 4 fields per line, found a 5th\n");
1031                 exit(1);
1032             }
1033         }
1034         peer->sockcl = -1;
1035         pthread_mutex_init(&peer->lock, NULL);
1036         if (!resolvepeer(peer)) {
1037             printf("failed to resolve host %s port %s, exiting\n", peer->host, peer->port);
1038             exit(1);
1039         }
1040         peer->requests = malloc(MAX_REQUESTS * sizeof(struct request));
1041         if (!peer->requests)
1042             errx("malloc failed");
1043         memset(peer->requests, 0, MAX_REQUESTS * sizeof(struct request));
1044         peer->newrq = 0;
1045         pthread_mutex_init(&peer->newrq_mutex, NULL);
1046         pthread_cond_init(&peer->newrq_cond, NULL);
1047
1048         if (peer->type == 'U')
1049             peer->replyq = &udp_server_replyq;
1050         else {
1051             peer->replyq = malloc(sizeof(struct replyq));
1052             if (!peer->replyq)
1053                 errx("malloc failed");
1054             peer->replyq->replies = malloc(MAX_REQUESTS * sizeof(struct reply));
1055             if (!peer->replyq->replies)
1056                 errx("malloc failed");
1057             peer->replyq->size = MAX_REQUESTS;
1058             peer->replyq->count = 0;
1059             pthread_mutex_init(&peer->replyq->count_mutex, NULL);
1060             pthread_cond_init(&peer->replyq->count_cond, NULL);
1061         }
1062         printf("got type %c, host %s, port %s, secret %s\n", peers[peer_count].type,
1063                peers[peer_count].host, peers[peer_count].port, peers[peer_count].secret);
1064         printf("    with realms:");
1065         for (r = peer->realms; *r; r++)
1066             printf(" %s", *r);
1067         printf("\n");
1068         peer_count++;
1069     }
1070     fclose(f);
1071 }
1072
1073 void parseargs(int argc, char **argv) {
1074     int c;
1075
1076     while ((c = getopt(argc, argv, "p:")) != -1) {
1077         switch (c) {
1078         case 'p':
1079             udp_server_port = optarg;
1080             break;
1081         default:
1082             goto usage;
1083         }
1084     }
1085
1086     return;
1087
1088  usage:
1089     printf("radsecproxy [ -p UDP-port ]\n");
1090     exit(1);
1091 }
1092
1093 int main(int argc, char **argv) {
1094     SSL_CTX *ssl_ctx_srv;
1095     unsigned long error;
1096     pthread_t udpserverth;
1097     pthread_attr_t joinable;
1098     int i;
1099
1100     parseargs(argc, argv);
1101     getconfig("radsecproxy.conf");
1102
1103     ssl_locks_setup();
1104
1105     pthread_attr_init(&joinable);
1106     pthread_attr_setdetachstate(&joinable, PTHREAD_CREATE_JOINABLE);
1107
1108     /* listen on UDP if at least one UDP peer */
1109
1110     for (i = 0; i < peer_count; i++)
1111         if (peers[i].type == 'U') {
1112             if (pthread_create(&udpserverth, &joinable, udpserverrd, NULL))
1113                 errx("pthread_create failed");
1114             break;
1115         }
1116
1117     for (i = 0; i < peer_count; i++)
1118         if (peers[i].type == 'T')
1119             break;
1120
1121     if (i == peer_count) {
1122         printf("No TLS peers defined, just doing UDP proxying\n");
1123         /* just hang around doing nothing, anything to do here? */
1124         pthread_join(udpserverth, NULL);
1125         return 0;
1126     }
1127
1128     /* SSL setup */
1129     SSL_load_error_strings();
1130     SSL_library_init();
1131
1132     while (!RAND_status()) {
1133         time_t t = time(NULL);
1134         pid_t pid = getpid();
1135         RAND_seed((unsigned char *)&t, sizeof(time_t));
1136         RAND_seed((unsigned char *)&pid, sizeof(pid));
1137     }
1138
1139     /* initialise client part and start clients */
1140     ssl_ctx_cl = SSL_CTX_new(TLSv1_client_method());
1141     if (!ssl_ctx_cl)
1142         errx("no ssl ctx");
1143
1144     for (i = 0; i < peer_count; i++) {
1145         if (pthread_create(&peers[i].clientth, NULL, clientwr, (void *)&peers[i]))
1146             errx("pthread_create failed");
1147     }
1148
1149     /* setting up server/daemon part */
1150     ssl_ctx_srv = SSL_CTX_new(TLSv1_server_method());
1151     if (!ssl_ctx_srv)
1152         errx("no ssl ctx");
1153     if (!SSL_CTX_use_certificate_file(ssl_ctx_srv, "/tmp/server.pem", SSL_FILETYPE_PEM)) {
1154         while ((error = ERR_get_error()))
1155             err("SSL: %s", ERR_error_string(error, NULL));
1156         errx("Failed to load certificate");
1157     }
1158     if (!SSL_CTX_use_PrivateKey_file(ssl_ctx_srv, "/tmp/server.key", SSL_FILETYPE_PEM)) {
1159         while ((error = ERR_get_error()))
1160             err("SSL: %s", ERR_error_string(error, NULL));
1161         errx("Failed to load private key");
1162     }
1163     return tlslistener(ssl_ctx_srv);
1164 }