contrib/openbsm/bin/auditdistd/proto_tls.c

   1 /*-
   2  * Copyright (c) 2011 The FreeBSD Foundation
   3  * All rights reserved.
   4  *
   5  * This software was developed by Pawel Jakub Dawidek under sponsorship from
   6  * the FreeBSD Foundation.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <config/config.h>
  31
  32 #include <sys/param.h>  /* MAXHOSTNAMELEN */
  33 #include <sys/socket.h>
  34
  35 #include <arpa/inet.h>
  36
  37 #include <netinet/in.h>
  38 #include <netinet/tcp.h>
  39
  40 #include <errno.h>
  41 #include <fcntl.h>
  42 #include <netdb.h>
  43 #include <signal.h>
  44 #include <stdbool.h>
  45 #include <stdint.h>
  46 #include <stdio.h>
  47 #include <string.h>
  48 #include <unistd.h>
  49
  50 #include <openssl/err.h>
  51 #include <openssl/ssl.h>
  52
  53 #include <compat/compat.h>
  54 #ifndef HAVE_CLOSEFROM
  55 #include <compat/closefrom.h>
  56 #endif
  57 #ifndef HAVE_STRLCPY
  58 #include <compat/strlcpy.h>
  59 #endif
  60
  61 #include "pjdlog.h"
  62 #include "proto_impl.h"
  63 #include "sandbox.h"
  64 #include "subr.h"
  65
  66 #define TLS_CTX_MAGIC   0x715c7
  67 struct tls_ctx {
  68         int             tls_magic;
  69         struct proto_conn *tls_sock;
  70         struct proto_conn *tls_tcp;
  71         char            tls_laddr[256];
  72         char            tls_raddr[256];
  73         int             tls_side;
  74 #define TLS_SIDE_CLIENT         0
  75 #define TLS_SIDE_SERVER_LISTEN  1
  76 #define TLS_SIDE_SERVER_WORK    2
  77         bool            tls_wait_called;
  78 };
  79
  80 #define TLS_DEFAULT_TIMEOUT     30
  81
  82 static int tls_connect_wait(void *ctx, int timeout);
  83 static void tls_close(void *ctx);
  84
  85 static void
  86 block(int fd)
  87 {
  88         int flags;
  89
  90         flags = fcntl(fd, F_GETFL);
  91         if (flags == -1)
  92                 pjdlog_exit(EX_TEMPFAIL, "fcntl(F_GETFL) failed");
  93         flags &= ~O_NONBLOCK;
  94         if (fcntl(fd, F_SETFL, flags) == -1)
  95                 pjdlog_exit(EX_TEMPFAIL, "fcntl(F_SETFL) failed");
  96 }
  97
  98 static void
  99 nonblock(int fd)
 100 {
 101         int flags;
 102
 103         flags = fcntl(fd, F_GETFL);
 104         if (flags == -1)
 105                 pjdlog_exit(EX_TEMPFAIL, "fcntl(F_GETFL) failed");
 106         flags |= O_NONBLOCK;
 107         if (fcntl(fd, F_SETFL, flags) == -1)
 108                 pjdlog_exit(EX_TEMPFAIL, "fcntl(F_SETFL) failed");
 109 }
 110
 111 static int
 112 wait_for_fd(int fd, int timeout)
 113 {
 114         struct timeval tv;
 115         fd_set fdset;
 116         int error, ret;
 117
 118         error = 0;
 119
 120         for (;;) {
 121                 FD_ZERO(&fdset);
 122                 FD_SET(fd, &fdset);
 123
 124                 tv.tv_sec = timeout;
 125                 tv.tv_usec = 0;
 126
 127                 ret = select(fd + 1, NULL, &fdset, NULL,
 128                     timeout == -1 ? NULL : &tv);
 129                 if (ret == 0) {
 130                         error = ETIMEDOUT;
 131                         break;
 132                 } else if (ret == -1) {
 133                         if (errno == EINTR)
 134                                 continue;
 135                         error = errno;
 136                         break;
 137                 }
 138                 PJDLOG_ASSERT(ret > 0);
 139                 PJDLOG_ASSERT(FD_ISSET(fd, &fdset));
 140                 break;
 141         }
 142
 143         return (error);
 144 }
 145
 146 static void
 147 ssl_log_errors(void)
 148 {
 149         unsigned long error;
 150
 151         while ((error = ERR_get_error()) != 0)
 152                 pjdlog_error("SSL error: %s", ERR_error_string(error, NULL));
 153 }
 154
 155 static int
 156 ssl_check_error(SSL *ssl, int ret)
 157 {
 158         int error;
 159
 160         error = SSL_get_error(ssl, ret);
 161
 162         switch (error) {
 163         case SSL_ERROR_NONE:
 164                 return (0);
 165         case SSL_ERROR_WANT_READ:
 166                 pjdlog_debug(2, "SSL_ERROR_WANT_READ");
 167                 return (-1);
 168         case SSL_ERROR_WANT_WRITE:
 169                 pjdlog_debug(2, "SSL_ERROR_WANT_WRITE");
 170                 return (-1);
 171         case SSL_ERROR_ZERO_RETURN:
 172                 pjdlog_exitx(EX_OK, "Connection closed.");
 173         case SSL_ERROR_SYSCALL:
 174                 ssl_log_errors();
 175                 pjdlog_exitx(EX_TEMPFAIL, "SSL I/O error.");
 176         case SSL_ERROR_SSL:
 177                 ssl_log_errors();
 178                 pjdlog_exitx(EX_TEMPFAIL, "SSL protocol error.");
 179         default:
 180                 ssl_log_errors();
 181                 pjdlog_exitx(EX_TEMPFAIL, "Unknown SSL error (%d).", error);
 182         }
 183 }
 184
 185 static void
 186 tcp_recv_ssl_send(int recvfd, SSL *sendssl)
 187 {
 188         static unsigned char buf[65536];
 189         ssize_t tcpdone;
 190         int sendfd, ssldone;
 191
 192         sendfd = SSL_get_fd(sendssl);
 193         PJDLOG_ASSERT(sendfd >= 0);
 194         pjdlog_debug(2, "%s: start %d -> %d", __func__, recvfd, sendfd);
 195         for (;;) {
 196                 tcpdone = recv(recvfd, buf, sizeof(buf), 0);
 197                 pjdlog_debug(2, "%s: recv() returned %zd", __func__, tcpdone);
 198                 if (tcpdone == 0) {
 199                         pjdlog_debug(1, "Connection terminated.");
 200                         exit(0);
 201                 } else if (tcpdone == -1) {
 202                         if (errno == EINTR)
 203                                 continue;
 204                         else if (errno == EAGAIN)
 205                                 break;
 206                         pjdlog_exit(EX_TEMPFAIL, "recv() failed");
 207                 }
 208                 for (;;) {
 209                         ssldone = SSL_write(sendssl, buf, (int)tcpdone);
 210                         pjdlog_debug(2, "%s: send() returned %d", __func__,
 211                             ssldone);
 212                         if (ssl_check_error(sendssl, ssldone) == -1) {
 213                                 (void)wait_for_fd(sendfd, -1);
 214                                 continue;
 215                         }
 216                         PJDLOG_ASSERT(ssldone == tcpdone);
 217                         break;
 218                 }
 219         }
 220         pjdlog_debug(2, "%s: done %d -> %d", __func__, recvfd, sendfd);
 221 }
 222
 223 static void
 224 ssl_recv_tcp_send(SSL *recvssl, int sendfd)
 225 {
 226         static unsigned char buf[65536];
 227         unsigned char *ptr;
 228         ssize_t tcpdone;
 229         size_t todo;
 230         int recvfd, ssldone;
 231
 232         recvfd = SSL_get_fd(recvssl);
 233         PJDLOG_ASSERT(recvfd >= 0);
 234         pjdlog_debug(2, "%s: start %d -> %d", __func__, recvfd, sendfd);
 235         for (;;) {
 236                 ssldone = SSL_read(recvssl, buf, sizeof(buf));
 237                 pjdlog_debug(2, "%s: SSL_read() returned %d", __func__,
 238                     ssldone);
 239                 if (ssl_check_error(recvssl, ssldone) == -1)
 240                         break;
 241                 todo = (size_t)ssldone;
 242                 ptr = buf;
 243                 do {
 244                         tcpdone = send(sendfd, ptr, todo, MSG_NOSIGNAL);
 245                         pjdlog_debug(2, "%s: send() returned %zd", __func__,
 246                             tcpdone);
 247                         if (tcpdone == 0) {
 248                                 pjdlog_debug(1, "Connection terminated.");
 249                                 exit(0);
 250                         } else if (tcpdone == -1) {
 251                                 if (errno == EINTR || errno == ENOBUFS)
 252                                         continue;
 253                                 if (errno == EAGAIN) {
 254                                         (void)wait_for_fd(sendfd, -1);
 255                                         continue;
 256                                 }
 257                                 pjdlog_exit(EX_TEMPFAIL, "send() failed");
 258                         }
 259                         todo -= tcpdone;
 260                         ptr += tcpdone;
 261                 } while (todo > 0);
 262         }
 263         pjdlog_debug(2, "%s: done %d -> %d", __func__, recvfd, sendfd);
 264 }
 265
 266 static void
 267 tls_loop(int sockfd, SSL *tcpssl)
 268 {
 269         fd_set fds;
 270         int maxfd, tcpfd;
 271
 272         tcpfd = SSL_get_fd(tcpssl);
 273         PJDLOG_ASSERT(tcpfd >= 0);
 274
 275         for (;;) {
 276                 FD_ZERO(&fds);
 277                 FD_SET(sockfd, &fds);
 278                 FD_SET(tcpfd, &fds);
 279                 maxfd = MAX(sockfd, tcpfd);
 280
 281                 PJDLOG_ASSERT(maxfd + 1 <= (int)FD_SETSIZE);
 282                 if (select(maxfd + 1, &fds, NULL, NULL, NULL) == -1) {
 283                         if (errno == EINTR)
 284                                 continue;
 285                         pjdlog_exit(EX_TEMPFAIL, "select() failed");
 286                 }
 287                 if (FD_ISSET(sockfd, &fds))
 288                         tcp_recv_ssl_send(sockfd, tcpssl);
 289                 if (FD_ISSET(tcpfd, &fds))
 290                         ssl_recv_tcp_send(tcpssl, sockfd);
 291         }
 292 }
 293
 294 static void
 295 tls_certificate_verify(SSL *ssl, const char *fingerprint)
 296 {
 297         unsigned char md[EVP_MAX_MD_SIZE];
 298         char mdstr[sizeof("SHA256=") - 1 + EVP_MAX_MD_SIZE * 3];
 299         char *mdstrp;
 300         unsigned int i, mdsize;
 301         X509 *cert;
 302
 303         if (fingerprint[0] == '\0') {
 304                 pjdlog_debug(1, "No fingerprint verification requested.");
 305                 return;
 306         }
 307
 308         cert = SSL_get_peer_certificate(ssl);
 309         if (cert == NULL)
 310                 pjdlog_exitx(EX_TEMPFAIL, "No peer certificate received.");
 311
 312         if (X509_digest(cert, EVP_sha256(), md, &mdsize) != 1)
 313                 pjdlog_exitx(EX_TEMPFAIL, "X509_digest() failed.");
 314         PJDLOG_ASSERT(mdsize <= EVP_MAX_MD_SIZE);
 315
 316         X509_free(cert);
 317
 318         (void)strlcpy(mdstr, "SHA256=", sizeof(mdstr));
 319         mdstrp = mdstr + strlen(mdstr);
 320         for (i = 0; i < mdsize; i++) {
 321                 PJDLOG_VERIFY(mdstrp + 3 <= mdstr + sizeof(mdstr));
 322                 (void)sprintf(mdstrp, "%02hhX:", md[i]);
 323                 mdstrp += 3;
 324         }
 325         /* Clear last colon. */
 326         mdstrp[-1] = '\0';
 327         if (strcasecmp(mdstr, fingerprint) != 0) {
 328                 pjdlog_exitx(EX_NOPERM,
 329                     "Finger print doesn't match. Received \"%s\", expected \"%s\"",
 330                     mdstr, fingerprint);
 331         }
 332 }
 333
 334 static void
 335 tls_exec_client(const char *user, int startfd, const char *srcaddr,
 336     const char *dstaddr, const char *fingerprint, const char *defport,
 337     int timeout, int debuglevel)
 338 {
 339         struct proto_conn *tcp;
 340         char *saddr, *daddr;
 341         SSL_CTX *sslctx;
 342         SSL *ssl;
 343         long ret;
 344         int sockfd, tcpfd;
 345         uint8_t connected;
 346
 347         pjdlog_debug_set(debuglevel);
 348         pjdlog_prefix_set("[TLS sandbox] (client) ");
 349 #ifdef HAVE_SETPROCTITLE
 350         setproctitle("[TLS sandbox] (client) ");
 351 #endif
 352         proto_set("tcp:port", defport);
 353
 354         sockfd = startfd;
 355
 356         /* Change tls:// to tcp://. */
 357         if (srcaddr == NULL) {
 358                 saddr = NULL;
 359         } else {
 360                 saddr = strdup(srcaddr);
 361                 if (saddr == NULL)
 362                         pjdlog_exitx(EX_TEMPFAIL, "Unable to allocate memory.");
 363                 bcopy("tcp://", saddr, 6);
 364         }
 365         daddr = strdup(dstaddr);
 366         if (daddr == NULL)
 367                 pjdlog_exitx(EX_TEMPFAIL, "Unable to allocate memory.");
 368         bcopy("tcp://", daddr, 6);
 369
 370         /* Establish TCP connection. */
 371         if (proto_connect(saddr, daddr, timeout, &tcp) == -1)
 372                 exit(EX_TEMPFAIL);
 373
 374         SSL_load_error_strings();
 375         SSL_library_init();
 376
 377         /*
 378          * TODO: On FreeBSD we could move this below sandbox() once libc and
 379          *       libcrypto use sysctl kern.arandom to obtain random data
 380          *       instead of /dev/urandom and friends.
 381          */
 382         sslctx = SSL_CTX_new(TLSv1_client_method());
 383         if (sslctx == NULL)
 384                 pjdlog_exitx(EX_TEMPFAIL, "SSL_CTX_new() failed.");
 385
 386         if (sandbox(user, true, "proto_tls client: %s", dstaddr) != 0)
 387                 pjdlog_exitx(EX_CONFIG, "Unable to sandbox TLS client.");
 388         pjdlog_debug(1, "Privileges successfully dropped.");
 389
 390         SSL_CTX_set_options(sslctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
 391
 392         /* Load CA certs. */
 393         /* TODO */
 394         //SSL_CTX_load_verify_locations(sslctx, cacerts_file, NULL);
 395
 396         ssl = SSL_new(sslctx);
 397         if (ssl == NULL)
 398                 pjdlog_exitx(EX_TEMPFAIL, "SSL_new() failed.");
 399
 400         tcpfd = proto_descriptor(tcp);
 401
 402         block(tcpfd);
 403
 404         if (SSL_set_fd(ssl, tcpfd) != 1)
 405                 pjdlog_exitx(EX_TEMPFAIL, "SSL_set_fd() failed.");
 406
 407         ret = SSL_connect(ssl);
 408         ssl_check_error(ssl, (int)ret);
 409
 410         nonblock(sockfd);
 411         nonblock(tcpfd);
 412
 413         tls_certificate_verify(ssl, fingerprint);
 414
 415         /*
 416          * The following byte is send to make proto_connect_wait() to work.
 417          */
 418         connected = 1;
 419         for (;;) {
 420                 switch (send(sockfd, &connected, sizeof(connected), 0)) {
 421                 case -1:
 422                         if (errno == EINTR || errno == ENOBUFS)
 423                                 continue;
 424                         if (errno == EAGAIN) {
 425                                 (void)wait_for_fd(sockfd, -1);
 426                                 continue;
 427                         }
 428                         pjdlog_exit(EX_TEMPFAIL, "send() failed");
 429                 case 0:
 430                         pjdlog_debug(1, "Connection terminated.");
 431                         exit(0);
 432                 case 1:
 433                         break;
 434                 }
 435                 break;
 436         }
 437
 438         tls_loop(sockfd, ssl);
 439 }
 440
 441 static void
 442 tls_call_exec_client(struct proto_conn *sock, const char *srcaddr,
 443     const char *dstaddr, int timeout)
 444 {
 445         char *timeoutstr, *startfdstr, *debugstr;
 446         int startfd;
 447
 448         /* Declare that we are receiver. */
 449         proto_recv(sock, NULL, 0);
 450
 451         if (pjdlog_mode_get() == PJDLOG_MODE_STD)
 452                 startfd = 3;
 453         else /* if (pjdlog_mode_get() == PJDLOG_MODE_SYSLOG) */
 454                 startfd = 0;
 455
 456         if (proto_descriptor(sock) != startfd) {
 457                 /* Move socketpair descriptor to descriptor number startfd. */
 458                 if (dup2(proto_descriptor(sock), startfd) == -1)
 459                         pjdlog_exit(EX_OSERR, "dup2() failed");
 460                 proto_close(sock);
 461         } else {
 462                 /*
 463                  * The FD_CLOEXEC is cleared by dup2(2), so when we not
 464                  * call it, we have to clear it by hand in case it is set.
 465                  */
 466                 if (fcntl(startfd, F_SETFD, 0) == -1)
 467                         pjdlog_exit(EX_OSERR, "fcntl() failed");
 468         }
 469
 470         closefrom(startfd + 1);
 471
 472         if (asprintf(&startfdstr, "%d", startfd) == -1)
 473                 pjdlog_exit(EX_TEMPFAIL, "asprintf() failed");
 474         if (timeout == -1)
 475                 timeout = TLS_DEFAULT_TIMEOUT;
 476         if (asprintf(&timeoutstr, "%d", timeout) == -1)
 477                 pjdlog_exit(EX_TEMPFAIL, "asprintf() failed");
 478         if (asprintf(&debugstr, "%d", pjdlog_debug_get()) == -1)
 479                 pjdlog_exit(EX_TEMPFAIL, "asprintf() failed");
 480
 481         execl(proto_get("execpath"), proto_get("execpath"), "proto", "tls",
 482             proto_get("user"), "client", startfdstr,
 483             srcaddr == NULL ? "" : srcaddr, dstaddr,
 484             proto_get("tls:fingerprint"), proto_get("tcp:port"), timeoutstr,
 485             debugstr, NULL);
 486         pjdlog_exit(EX_SOFTWARE, "execl() failed");
 487 }
 488
 489 static int
 490 tls_connect(const char *srcaddr, const char *dstaddr, int timeout, void **ctxp)
 491 {
 492         struct tls_ctx *tlsctx;
 493         struct proto_conn *sock;
 494         pid_t pid;
 495         int error;
 496
 497         PJDLOG_ASSERT(srcaddr == NULL || srcaddr[0] != '\0');
 498         PJDLOG_ASSERT(dstaddr != NULL);
 499         PJDLOG_ASSERT(timeout >= -1);
 500         PJDLOG_ASSERT(ctxp != NULL);
 501
 502         if (strncmp(dstaddr, "tls://", 6) != 0)
 503                 return (-1);
 504         if (srcaddr != NULL && strncmp(srcaddr, "tls://", 6) != 0)
 505                 return (-1);
 506
 507         if (proto_connect(NULL, "socketpair://", -1, &sock) == -1)
 508                 return (errno);
 509
 510 #if 0
 511         /*
 512          * We use rfork() with the following flags to disable SIGCHLD
 513          * delivery upon the sandbox process exit.
 514          */
 515         pid = rfork(RFFDG | RFPROC | RFTSIGZMB | RFTSIGFLAGS(0));
 516 #else
 517         /*
 518          * We don't use rfork() to be able to log information about sandbox
 519          * process exiting.
 520          */
 521         pid = fork();
 522 #endif
 523         switch (pid) {
 524         case -1:
 525                 /* Failure. */
 526                 error = errno;
 527                 proto_close(sock);
 528                 return (error);
 529         case 0:
 530                 /* Child. */
 531                 pjdlog_prefix_set("[TLS sandbox] (client) ");
 532 #ifdef HAVE_SETPROCTITLE
 533                 setproctitle("[TLS sandbox] (client) ");
 534 #endif
 535                 tls_call_exec_client(sock, srcaddr, dstaddr, timeout);
 536                 /* NOTREACHED */
 537         default:
 538                 /* Parent. */
 539                 tlsctx = calloc(1, sizeof(*tlsctx));
 540                 if (tlsctx == NULL) {
 541                         error = errno;
 542                         proto_close(sock);
 543                         (void)kill(pid, SIGKILL);
 544                         return (error);
 545                 }
 546                 proto_send(sock, NULL, 0);
 547                 tlsctx->tls_sock = sock;
 548                 tlsctx->tls_tcp = NULL;
 549                 tlsctx->tls_side = TLS_SIDE_CLIENT;
 550                 tlsctx->tls_wait_called = false;
 551                 tlsctx->tls_magic = TLS_CTX_MAGIC;
 552                 if (timeout >= 0) {
 553                         error = tls_connect_wait(tlsctx, timeout);
 554                         if (error != 0) {
 555                                 (void)kill(pid, SIGKILL);
 556                                 tls_close(tlsctx);
 557                                 return (error);
 558                         }
 559                 }
 560                 *ctxp = tlsctx;
 561                 return (0);
 562         }
 563 }
 564
 565 static int
 566 tls_connect_wait(void *ctx, int timeout)
 567 {
 568         struct tls_ctx *tlsctx = ctx;
 569         int error, sockfd;
 570         uint8_t connected;
 571
 572         PJDLOG_ASSERT(tlsctx != NULL);
 573         PJDLOG_ASSERT(tlsctx->tls_magic == TLS_CTX_MAGIC);
 574         PJDLOG_ASSERT(tlsctx->tls_side == TLS_SIDE_CLIENT);
 575         PJDLOG_ASSERT(tlsctx->tls_sock != NULL);
 576         PJDLOG_ASSERT(!tlsctx->tls_wait_called);
 577         PJDLOG_ASSERT(timeout >= 0);
 578
 579         sockfd = proto_descriptor(tlsctx->tls_sock);
 580         error = wait_for_fd(sockfd, timeout);
 581         if (error != 0)
 582                 return (error);
 583
 584         for (;;) {
 585                 switch (recv(sockfd, &connected, sizeof(connected),
 586                     MSG_WAITALL)) {
 587                 case -1:
 588                         if (errno == EINTR || errno == ENOBUFS)
 589                                 continue;
 590                         error = errno;
 591                         break;
 592                 case 0:
 593                         pjdlog_debug(1, "Connection terminated.");
 594                         error = ENOTCONN;
 595                         break;
 596                 case 1:
 597                         tlsctx->tls_wait_called = true;
 598                         break;
 599                 }
 600                 break;
 601         }
 602
 603         return (error);
 604 }
 605
 606 static int
 607 tls_server(const char *lstaddr, void **ctxp)
 608 {
 609         struct proto_conn *tcp;
 610         struct tls_ctx *tlsctx;
 611         char *laddr;
 612         int error;
 613
 614         if (strncmp(lstaddr, "tls://", 6) != 0)
 615                 return (-1);
 616
 617         tlsctx = malloc(sizeof(*tlsctx));
 618         if (tlsctx == NULL) {
 619                 pjdlog_warning("Unable to allocate memory.");
 620                 return (ENOMEM);
 621         }
 622
 623         laddr = strdup(lstaddr);
 624         if (laddr == NULL) {
 625                 free(tlsctx);
 626                 pjdlog_warning("Unable to allocate memory.");
 627                 return (ENOMEM);
 628         }
 629         bcopy("tcp://", laddr, 6);
 630
 631         if (proto_server(laddr, &tcp) == -1) {
 632                 error = errno;
 633                 free(tlsctx);
 634                 free(laddr);
 635                 return (error);
 636         }
 637         free(laddr);
 638
 639         tlsctx->tls_sock = NULL;
 640         tlsctx->tls_tcp = tcp;
 641         tlsctx->tls_side = TLS_SIDE_SERVER_LISTEN;
 642         tlsctx->tls_wait_called = true;
 643         tlsctx->tls_magic = TLS_CTX_MAGIC;
 644         *ctxp = tlsctx;
 645
 646         return (0);
 647 }
 648
 649 static void
 650 tls_exec_server(const char *user, int startfd, const char *privkey,
 651     const char *cert, int debuglevel)
 652 {
 653         SSL_CTX *sslctx;
 654         SSL *ssl;
 655         int sockfd, tcpfd, ret;
 656
 657         pjdlog_debug_set(debuglevel);
 658         pjdlog_prefix_set("[TLS sandbox] (server) ");
 659 #ifdef HAVE_SETPROCTITLE
 660         setproctitle("[TLS sandbox] (server) ");
 661 #endif
 662
 663         sockfd = startfd;
 664         tcpfd = startfd + 1;
 665
 666         SSL_load_error_strings();
 667         SSL_library_init();
 668
 669         sslctx = SSL_CTX_new(TLSv1_server_method());
 670         if (sslctx == NULL)
 671                 pjdlog_exitx(EX_TEMPFAIL, "SSL_CTX_new() failed.");
 672
 673         SSL_CTX_set_options(sslctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
 674
 675         ssl = SSL_new(sslctx);
 676         if (ssl == NULL)
 677                 pjdlog_exitx(EX_TEMPFAIL, "SSL_new() failed.");
 678
 679         if (SSL_use_RSAPrivateKey_file(ssl, privkey, SSL_FILETYPE_PEM) != 1) {
 680                 ssl_log_errors();
 681                 pjdlog_exitx(EX_CONFIG,
 682                     "SSL_use_RSAPrivateKey_file(%s) failed.", privkey);
 683         }
 684
 685         if (SSL_use_certificate_file(ssl, cert, SSL_FILETYPE_PEM) != 1) {
 686                 ssl_log_errors();
 687                 pjdlog_exitx(EX_CONFIG, "SSL_use_certificate_file(%s) failed.",
 688                     cert);
 689         }
 690
 691         if (sandbox(user, true, "proto_tls server") != 0)
 692                 pjdlog_exitx(EX_CONFIG, "Unable to sandbox TLS server.");
 693         pjdlog_debug(1, "Privileges successfully dropped.");
 694
 695         nonblock(sockfd);
 696         nonblock(tcpfd);
 697
 698         if (SSL_set_fd(ssl, tcpfd) != 1)
 699                 pjdlog_exitx(EX_TEMPFAIL, "SSL_set_fd() failed.");
 700
 701         ret = SSL_accept(ssl);
 702         ssl_check_error(ssl, ret);
 703
 704         tls_loop(sockfd, ssl);
 705 }
 706
 707 static void
 708 tls_call_exec_server(struct proto_conn *sock, struct proto_conn *tcp)
 709 {
 710         int startfd, sockfd, tcpfd, safefd;
 711         char *startfdstr, *debugstr;
 712
 713         if (pjdlog_mode_get() == PJDLOG_MODE_STD)
 714                 startfd = 3;
 715         else /* if (pjdlog_mode_get() == PJDLOG_MODE_SYSLOG) */
 716                 startfd = 0;
 717
 718         /* Declare that we are receiver. */
 719         proto_send(sock, NULL, 0);
 720
 721         sockfd = proto_descriptor(sock);
 722         tcpfd = proto_descriptor(tcp);
 723
 724         safefd = MAX(sockfd, tcpfd);
 725         safefd = MAX(safefd, startfd);
 726         safefd++;
 727
 728         /* Move sockfd and tcpfd to safe numbers first. */
 729         if (dup2(sockfd, safefd) == -1)
 730                 pjdlog_exit(EX_OSERR, "dup2() failed");
 731         proto_close(sock);
 732         sockfd = safefd;
 733         if (dup2(tcpfd, safefd + 1) == -1)
 734                 pjdlog_exit(EX_OSERR, "dup2() failed");
 735         proto_close(tcp);
 736         tcpfd = safefd + 1;
 737
 738         /* Move socketpair descriptor to descriptor number startfd. */
 739         if (dup2(sockfd, startfd) == -1)
 740                 pjdlog_exit(EX_OSERR, "dup2() failed");
 741         (void)close(sockfd);
 742         /* Move tcp descriptor to descriptor number startfd + 1. */
 743         if (dup2(tcpfd, startfd + 1) == -1)
 744                 pjdlog_exit(EX_OSERR, "dup2() failed");
 745         (void)close(tcpfd);
 746
 747         closefrom(startfd + 2);
 748
 749         /*
 750          * Even if FD_CLOEXEC was set on descriptors before dup2(), it should
 751          * have been cleared on dup2(), but better be safe than sorry.
 752          */
 753         if (fcntl(startfd, F_SETFD, 0) == -1)
 754                 pjdlog_exit(EX_OSERR, "fcntl() failed");
 755         if (fcntl(startfd + 1, F_SETFD, 0) == -1)
 756                 pjdlog_exit(EX_OSERR, "fcntl() failed");
 757
 758         if (asprintf(&startfdstr, "%d", startfd) == -1)
 759                 pjdlog_exit(EX_TEMPFAIL, "asprintf() failed");
 760         if (asprintf(&debugstr, "%d", pjdlog_debug_get()) == -1)
 761                 pjdlog_exit(EX_TEMPFAIL, "asprintf() failed");
 762
 763         execl(proto_get("execpath"), proto_get("execpath"), "proto", "tls",
 764             proto_get("user"), "server", startfdstr, proto_get("tls:keyfile"),
 765             proto_get("tls:certfile"), debugstr, NULL);
 766         pjdlog_exit(EX_SOFTWARE, "execl() failed");
 767 }
 768
 769 static int
 770 tls_accept(void *ctx, void **newctxp)
 771 {
 772         struct tls_ctx *tlsctx = ctx;
 773         struct tls_ctx *newtlsctx;
 774         struct proto_conn *sock, *tcp;
 775         pid_t pid;
 776         int error;
 777
 778         PJDLOG_ASSERT(tlsctx != NULL);
 779         PJDLOG_ASSERT(tlsctx->tls_magic == TLS_CTX_MAGIC);
 780         PJDLOG_ASSERT(tlsctx->tls_side == TLS_SIDE_SERVER_LISTEN);
 781
 782         if (proto_connect(NULL, "socketpair://", -1, &sock) == -1)
 783                 return (errno);
 784
 785         /* Accept TCP connection. */
 786         if (proto_accept(tlsctx->tls_tcp, &tcp) == -1) {
 787                 error = errno;
 788                 proto_close(sock);
 789                 return (error);
 790         }
 791
 792         pid = fork();
 793         switch (pid) {
 794         case -1:
 795                 /* Failure. */
 796                 error = errno;
 797                 proto_close(sock);
 798                 return (error);
 799         case 0:
 800                 /* Child. */
 801                 pjdlog_prefix_set("[TLS sandbox] (server) ");
 802 #ifdef HAVE_SETPROCTITLE
 803                 setproctitle("[TLS sandbox] (server) ");
 804 #endif
 805                 /* Close listen socket. */
 806                 proto_close(tlsctx->tls_tcp);
 807                 tls_call_exec_server(sock, tcp);
 808                 /* NOTREACHED */
 809                 PJDLOG_ABORT("Unreachable.");
 810         default:
 811                 /* Parent. */
 812                 newtlsctx = calloc(1, sizeof(*tlsctx));
 813                 if (newtlsctx == NULL) {
 814                         error = errno;
 815                         proto_close(sock);
 816                         proto_close(tcp);
 817                         (void)kill(pid, SIGKILL);
 818                         return (error);
 819                 }
 820                 proto_local_address(tcp, newtlsctx->tls_laddr,
 821                     sizeof(newtlsctx->tls_laddr));
 822                 PJDLOG_ASSERT(strncmp(newtlsctx->tls_laddr, "tcp://", 6) == 0);
 823                 bcopy("tls://", newtlsctx->tls_laddr, 6);
 824                 *strrchr(newtlsctx->tls_laddr, ':') = '\0';
 825                 proto_remote_address(tcp, newtlsctx->tls_raddr,
 826                     sizeof(newtlsctx->tls_raddr));
 827                 PJDLOG_ASSERT(strncmp(newtlsctx->tls_raddr, "tcp://", 6) == 0);
 828                 bcopy("tls://", newtlsctx->tls_raddr, 6);
 829                 *strrchr(newtlsctx->tls_raddr, ':') = '\0';
 830                 proto_close(tcp);
 831                 proto_recv(sock, NULL, 0);
 832                 newtlsctx->tls_sock = sock;
 833                 newtlsctx->tls_tcp = NULL;
 834                 newtlsctx->tls_wait_called = true;
 835                 newtlsctx->tls_side = TLS_SIDE_SERVER_WORK;
 836                 newtlsctx->tls_magic = TLS_CTX_MAGIC;
 837                 *newctxp = newtlsctx;
 838                 return (0);
 839         }
 840 }
 841
 842 static int
 843 tls_wrap(int fd, bool client, void **ctxp)
 844 {
 845         struct tls_ctx *tlsctx;
 846         struct proto_conn *sock;
 847         int error;
 848
 849         tlsctx = calloc(1, sizeof(*tlsctx));
 850         if (tlsctx == NULL)
 851                 return (errno);
 852
 853         if (proto_wrap("socketpair", client, fd, &sock) == -1) {
 854                 error = errno;
 855                 free(tlsctx);
 856                 return (error);
 857         }
 858
 859         tlsctx->tls_sock = sock;
 860         tlsctx->tls_tcp = NULL;
 861         tlsctx->tls_wait_called = (client ? false : true);
 862         tlsctx->tls_side = (client ? TLS_SIDE_CLIENT : TLS_SIDE_SERVER_WORK);
 863         tlsctx->tls_magic = TLS_CTX_MAGIC;
 864         *ctxp = tlsctx;
 865
 866         return (0);
 867 }
 868
 869 static int
 870 tls_send(void *ctx, const unsigned char *data, size_t size, int fd)
 871 {
 872         struct tls_ctx *tlsctx = ctx;
 873
 874         PJDLOG_ASSERT(tlsctx != NULL);
 875         PJDLOG_ASSERT(tlsctx->tls_magic == TLS_CTX_MAGIC);
 876         PJDLOG_ASSERT(tlsctx->tls_side == TLS_SIDE_CLIENT ||
 877             tlsctx->tls_side == TLS_SIDE_SERVER_WORK);
 878         PJDLOG_ASSERT(tlsctx->tls_sock != NULL);
 879         PJDLOG_ASSERT(tlsctx->tls_wait_called);
 880         PJDLOG_ASSERT(fd == -1);
 881
 882         if (proto_send(tlsctx->tls_sock, data, size) == -1)
 883                 return (errno);
 884
 885         return (0);
 886 }
 887
 888 static int
 889 tls_recv(void *ctx, unsigned char *data, size_t size, int *fdp)
 890 {
 891         struct tls_ctx *tlsctx = ctx;
 892
 893         PJDLOG_ASSERT(tlsctx != NULL);
 894         PJDLOG_ASSERT(tlsctx->tls_magic == TLS_CTX_MAGIC);
 895         PJDLOG_ASSERT(tlsctx->tls_side == TLS_SIDE_CLIENT ||
 896             tlsctx->tls_side == TLS_SIDE_SERVER_WORK);
 897         PJDLOG_ASSERT(tlsctx->tls_sock != NULL);
 898         PJDLOG_ASSERT(tlsctx->tls_wait_called);
 899         PJDLOG_ASSERT(fdp == NULL);
 900
 901         if (proto_recv(tlsctx->tls_sock, data, size) == -1)
 902                 return (errno);
 903
 904         return (0);
 905 }
 906
 907 static int
 908 tls_descriptor(const void *ctx)
 909 {
 910         const struct tls_ctx *tlsctx = ctx;
 911
 912         PJDLOG_ASSERT(tlsctx != NULL);
 913         PJDLOG_ASSERT(tlsctx->tls_magic == TLS_CTX_MAGIC);
 914
 915         switch (tlsctx->tls_side) {
 916         case TLS_SIDE_CLIENT:
 917         case TLS_SIDE_SERVER_WORK:
 918                 PJDLOG_ASSERT(tlsctx->tls_sock != NULL);
 919
 920                 return (proto_descriptor(tlsctx->tls_sock));
 921         case TLS_SIDE_SERVER_LISTEN:
 922                 PJDLOG_ASSERT(tlsctx->tls_tcp != NULL);
 923
 924                 return (proto_descriptor(tlsctx->tls_tcp));
 925         default:
 926                 PJDLOG_ABORT("Invalid side (%d).", tlsctx->tls_side);
 927         }
 928 }
 929
 930 static bool
 931 tcp_address_match(const void *ctx, const char *addr)
 932 {
 933         const struct tls_ctx *tlsctx = ctx;
 934
 935         PJDLOG_ASSERT(tlsctx != NULL);
 936         PJDLOG_ASSERT(tlsctx->tls_magic == TLS_CTX_MAGIC);
 937
 938         return (strcmp(tlsctx->tls_raddr, addr) == 0);
 939 }
 940
 941 static void
 942 tls_local_address(const void *ctx, char *addr, size_t size)
 943 {
 944         const struct tls_ctx *tlsctx = ctx;
 945
 946         PJDLOG_ASSERT(tlsctx != NULL);
 947         PJDLOG_ASSERT(tlsctx->tls_magic == TLS_CTX_MAGIC);
 948         PJDLOG_ASSERT(tlsctx->tls_wait_called);
 949
 950         switch (tlsctx->tls_side) {
 951         case TLS_SIDE_CLIENT:
 952                 PJDLOG_ASSERT(tlsctx->tls_sock != NULL);
 953
 954                 PJDLOG_VERIFY(strlcpy(addr, "tls://N/A", size) < size);
 955                 break;
 956         case TLS_SIDE_SERVER_WORK:
 957                 PJDLOG_ASSERT(tlsctx->tls_sock != NULL);
 958
 959                 PJDLOG_VERIFY(strlcpy(addr, tlsctx->tls_laddr, size) < size);
 960                 break;
 961         case TLS_SIDE_SERVER_LISTEN:
 962                 PJDLOG_ASSERT(tlsctx->tls_tcp != NULL);
 963
 964                 proto_local_address(tlsctx->tls_tcp, addr, size);
 965                 PJDLOG_ASSERT(strncmp(addr, "tcp://", 6) == 0);
 966                 /* Replace tcp:// prefix with tls:// */
 967                 bcopy("tls://", addr, 6);
 968                 break;
 969         default:
 970                 PJDLOG_ABORT("Invalid side (%d).", tlsctx->tls_side);
 971         }
 972 }
 973
 974 static void
 975 tls_remote_address(const void *ctx, char *addr, size_t size)
 976 {
 977         const struct tls_ctx *tlsctx = ctx;
 978
 979         PJDLOG_ASSERT(tlsctx != NULL);
 980         PJDLOG_ASSERT(tlsctx->tls_magic == TLS_CTX_MAGIC);
 981         PJDLOG_ASSERT(tlsctx->tls_wait_called);
 982
 983         switch (tlsctx->tls_side) {
 984         case TLS_SIDE_CLIENT:
 985                 PJDLOG_ASSERT(tlsctx->tls_sock != NULL);
 986
 987                 PJDLOG_VERIFY(strlcpy(addr, "tls://N/A", size) < size);
 988                 break;
 989         case TLS_SIDE_SERVER_WORK:
 990                 PJDLOG_ASSERT(tlsctx->tls_sock != NULL);
 991
 992                 PJDLOG_VERIFY(strlcpy(addr, tlsctx->tls_raddr, size) < size);
 993                 break;
 994         case TLS_SIDE_SERVER_LISTEN:
 995                 PJDLOG_ASSERT(tlsctx->tls_tcp != NULL);
 996
 997                 proto_remote_address(tlsctx->tls_tcp, addr, size);
 998                 PJDLOG_ASSERT(strncmp(addr, "tcp://", 6) == 0);
 999                 /* Replace tcp:// prefix with tls:// */
1000                 bcopy("tls://", addr, 6);
1001                 break;
1002         default:
1003                 PJDLOG_ABORT("Invalid side (%d).", tlsctx->tls_side);
1004         }
1005 }
1006
1007 static void
1008 tls_close(void *ctx)
1009 {
1010         struct tls_ctx *tlsctx = ctx;
1011
1012         PJDLOG_ASSERT(tlsctx != NULL);
1013         PJDLOG_ASSERT(tlsctx->tls_magic == TLS_CTX_MAGIC);
1014
1015         if (tlsctx->tls_sock != NULL) {
1016                 proto_close(tlsctx->tls_sock);
1017                 tlsctx->tls_sock = NULL;
1018         }
1019         if (tlsctx->tls_tcp != NULL) {
1020                 proto_close(tlsctx->tls_tcp);
1021                 tlsctx->tls_tcp = NULL;
1022         }
1023         tlsctx->tls_side = 0;
1024         tlsctx->tls_magic = 0;
1025         free(tlsctx);
1026 }
1027
1028 static int
1029 tls_exec(int argc, char *argv[])
1030 {
1031
1032         PJDLOG_ASSERT(argc > 3);
1033         PJDLOG_ASSERT(strcmp(argv[0], "tls") == 0);
1034
1035         pjdlog_init(atoi(argv[3]) == 0 ? PJDLOG_MODE_SYSLOG : PJDLOG_MODE_STD);
1036
1037         if (strcmp(argv[2], "client") == 0) {
1038                 if (argc != 10)
1039                         return (EINVAL);
1040                 tls_exec_client(argv[1], atoi(argv[3]),
1041                     argv[4][0] == '\0' ? NULL : argv[4], argv[5], argv[6],
1042                     argv[7], atoi(argv[8]), atoi(argv[9]));
1043         } else if (strcmp(argv[2], "server") == 0) {
1044                 if (argc != 7)
1045                         return (EINVAL);
1046                 tls_exec_server(argv[1], atoi(argv[3]), argv[4], argv[5],
1047                     atoi(argv[6]));
1048         }
1049         return (EINVAL);
1050 }
1051
1052 static struct proto tls_proto = {
1053         .prt_name = "tls",
1054         .prt_connect = tls_connect,
1055         .prt_connect_wait = tls_connect_wait,
1056         .prt_server = tls_server,
1057         .prt_accept = tls_accept,
1058         .prt_wrap = tls_wrap,
1059         .prt_send = tls_send,
1060         .prt_recv = tls_recv,
1061         .prt_descriptor = tls_descriptor,
1062         .prt_address_match = tcp_address_match,
1063         .prt_local_address = tls_local_address,
1064         .prt_remote_address = tls_remote_address,
1065         .prt_close = tls_close,
1066         .prt_exec = tls_exec
1067 };
1068
1069 static __constructor void
1070 tls_ctor(void)
1071 {
1072
1073         proto_register(&tls_proto, false);
1074 }