src/tls.c

   1 /*
   2     Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015,
   3     2016, 2017
   4     Ben Kibbey <bjk@luxsci.net>
   5
   6     This file is part of pwmd.
   7
   8     Pwmd is free software: you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation, either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     Pwmd is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with Pwmd.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <gnutls/x509.h>
  26 #include <errno.h>
  27 #include <sys/types.h>
  28 #include <sys/socket.h>
  29 #include <netdb.h>
  30
  31 #ifdef HAVE_STRINGS_H
  32 #include <strings.h>
  33 #endif
  34
  35 #include "pwmd-error.h"
  36 #include <gcrypt.h>
  37 #include "mem.h"
  38 #include "util-misc.h"
  39 #include "util-string.h"
  40 #include "common.h"
  41 #include "tls.h"
  42 #include "mutex.h"
  43 #include "rcfile.h"
  44
  45 #define WAIT_INTERVAL 50000
  46 #define TEST_TIMEOUT(timeout, ret, start, rc)                           \
  47   do {                                                                  \
  48     rc = 0;                                                             \
  49     if (ret == GNUTLS_E_AGAIN)                                          \
  50       {                                                                 \
  51         time_t now = time (NULL);                                       \
  52         if (timeout && now - start >= timeout)                          \
  53           {                                                             \
  54             rc = gpg_error (GPG_ERR_ETIMEDOUT);                         \
  55             ret = GNUTLS_E_TIMEDOUT;                                    \
  56             break;                                                      \
  57           }                                                             \
  58         struct timeval wtv = { 0, WAIT_INTERVAL };                      \
  59         select (0, NULL, NULL, NULL, &wtv);                             \
  60       }                                                                 \
  61     if (ret != GNUTLS_E_INTERRUPTED)                                    \
  62       break;                                                            \
  63   }                                                                     \
  64   while (0)
  65
  66 static gnutls_dh_params_t dh_params;
  67 static gnutls_certificate_credentials_t x509_cred;
  68
  69 static char *
  70 tls_fingerprint (gnutls_session_t ses)
  71 {
  72   gnutls_x509_crt_t crt;
  73   const gnutls_datum_t *cert_list;
  74   unsigned count;
  75   unsigned char buf[32];
  76   size_t len = sizeof (buf);
  77
  78   gnutls_x509_crt_init (&crt);
  79   if (!crt)
  80     {
  81       log_write ("%s(%i): %s(): %s", __FILE__, __LINE__, __FUNCTION__,
  82                  gnutls_strerror (GNUTLS_E_MEMORY_ERROR));
  83       return NULL;
  84     }
  85
  86   cert_list = gnutls_certificate_get_peers (ses, &count);
  87   if (count)
  88     {
  89       gnutls_x509_crt_import (crt, &cert_list[0], GNUTLS_X509_FMT_DER);
  90       gnutls_x509_crt_get_fingerprint (crt, GNUTLS_DIG_SHA256, buf, &len);
  91       gnutls_x509_crt_deinit (crt);
  92
  93       return len ? bin2hex (buf, len) : NULL;
  94     }
  95
  96   gnutls_x509_crt_deinit (crt);
  97   return NULL;
  98 }
  99
 100 static int
 101 verify_client_certificate (unsigned status)
 102 {
 103   if (!status)
 104     return 0;
 105
 106   if (status & GNUTLS_CERT_REVOKED)
 107     log_write (_("client certificate is revoked"));
 108
 109   if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)
 110     log_write (_("client certificate has no signer"));
 111
 112   if (status & GNUTLS_CERT_SIGNATURE_FAILURE)
 113     log_write (_("client certificate signature verification failed"));
 114
 115   if (status & GNUTLS_CERT_EXPIRED)
 116     log_write (_("client certificate expired"));
 117
 118   if (status & GNUTLS_CERT_SIGNER_NOT_CA)
 119     log_write (_("client certificate signer is not from CA"));
 120
 121   if (status & GNUTLS_CERT_INSECURE_ALGORITHM)
 122     log_write (_("client certificate has insecure algorithm"));
 123
 124   if (status & GNUTLS_CERT_INVALID)
 125     log_write (_("client certificate is invalid"));
 126
 127   return GNUTLS_E_CERTIFICATE_ERROR;
 128 }
 129
 130 struct tls_s *
 131 tls_init_client (int fd, int timeout, const char *prio)
 132 {
 133   int ret;
 134   unsigned status;
 135   const char *prio_error;
 136   gnutls_kx_algorithm_t kx;
 137   gpg_error_t rc = 0;
 138   struct tls_s *tls = xcalloc (1, sizeof (struct tls_s));
 139
 140   if (!tls)
 141     {
 142       log_write ("%s(%i): %s: %s", __FILE__, __LINE__, __FUNCTION__,
 143                  strerror (ENOMEM));
 144       return NULL;
 145     }
 146
 147   ret = gnutls_init (&tls->ses, GNUTLS_SERVER);
 148   if (ret != GNUTLS_E_SUCCESS)
 149     goto fail;
 150
 151   ret = gnutls_priority_set_direct (tls->ses, prio, &prio_error);
 152   if (ret != GNUTLS_E_SUCCESS)
 153     goto fail;
 154
 155   ret = gnutls_credentials_set (tls->ses, GNUTLS_CRD_CERTIFICATE, x509_cred);
 156   if (ret != GNUTLS_E_SUCCESS)
 157     goto fail;
 158
 159   gnutls_certificate_server_set_request (tls->ses, GNUTLS_CERT_REQUIRE);
 160   gnutls_transport_set_ptr (tls->ses, (gnutls_transport_ptr_t) fd);
 161   time_t start = time (NULL);
 162   do
 163     {
 164       ret = gnutls_handshake (tls->ses);
 165       TEST_TIMEOUT (timeout, ret, start, rc);
 166       if (rc)
 167         goto fail;
 168     }
 169   while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
 170
 171   if (ret != GNUTLS_E_SUCCESS)
 172     goto fail;
 173
 174   ret = gnutls_certificate_verify_peers2 (tls->ses, &status);
 175   if (ret)
 176     goto fail;
 177
 178   kx = gnutls_kx_get (tls->ses);
 179   tls->fp = tls_fingerprint (tls->ses);
 180   log_write ("PROTO=%s CIPHER=%s MAC=%s KX=%s(%d) FP=%s",
 181              gnutls_protocol_get_name (gnutls_protocol_get_version
 182                                        (tls->ses)),
 183              gnutls_cipher_get_name (gnutls_cipher_get (tls->ses)),
 184              gnutls_mac_get_name (gnutls_mac_get (tls->ses)),
 185              gnutls_kx_get_name (kx), gnutls_dh_get_prime_bits (tls->ses),
 186              tls->fp ? tls->fp : "N/A");
 187   ret = verify_client_certificate (status);
 188   if (ret)
 189     goto fail;
 190
 191   return tls;
 192
 193 fail:
 194   log_write ("%s", rc ? pwmd_strerror(rc) : gnutls_strerror (ret));
 195   gnutls_deinit (tls->ses);
 196   xfree (tls->fp);
 197   xfree (tls);
 198   return NULL;
 199 }
 200
 201 void
 202 tls_log (int level, const char *msg)
 203 {
 204   log_write ("TLS: %i: %s", level, msg);
 205 }
 206
 207 void
 208 tls_audit_log (gnutls_session_t s, const char *msg)
 209 {
 210   (void)s;
 211   log_write ("TLS: %s", msg);
 212 }
 213
 214 ssize_t
 215 tls_read_hook (assuan_context_t ctx, assuan_fd_t fd, void *data, size_t len)
 216 {
 217   struct client_s *client = assuan_get_pointer (ctx);
 218   struct tls_s *tls = client->thd->tls;
 219   time_t start = time (NULL);
 220   ssize_t ret;
 221
 222   do
 223     {
 224       gpg_error_t rc = 0;
 225       struct timeval tv = { 0, 0 };
 226       fd_set fds;
 227       int n;
 228
 229       FD_ZERO (&fds);
 230       FD_SET (fd, &fds);
 231       n = select (client->thd->fd+1, &fds, NULL, NULL, &tv);
 232       if (n == 0 && tls->nl)
 233         {
 234           char c[] = "#\n";
 235
 236           memcpy (data, c, sizeof(c));
 237           ret = strlen (c);
 238           break;
 239         }
 240
 241       ret = gnutls_record_recv (tls->ses, data, len);
 242       if (ret == GNUTLS_E_REHANDSHAKE)
 243         {
 244           tls->rehandshake = 0;
 245
 246           do
 247             {
 248               ret = gnutls_handshake (tls->ses);
 249               TEST_TIMEOUT (client->thd->timeout, ret, start, rc);
 250               if (rc)
 251                 break;
 252             }
 253           while (ret < 0 && gnutls_error_is_fatal (ret) == 0);
 254
 255           if (!ret)
 256             {
 257               gnutls_kx_algorithm_t kx;
 258               char c[] = "# \n";
 259
 260               if (tls->nl)
 261                 {
 262                   memcpy (data, c, sizeof (c));
 263                   ret = strlen (c);
 264                 }
 265               else
 266                 ret = GNUTLS_E_AGAIN;
 267
 268               kx = gnutls_kx_get (tls->ses);
 269               log_write ("PROTO=%s CIPHER=%s MAC=%s KX=%s(%d)",
 270                          gnutls_protocol_get_name (gnutls_protocol_get_version
 271                                                    (tls->ses)),
 272                          gnutls_cipher_get_name (gnutls_cipher_get (tls->ses)),
 273                          gnutls_mac_get_name (gnutls_mac_get (tls->ses)),
 274                          gnutls_kx_get_name (kx), gnutls_dh_get_prime_bits (tls->ses));
 275               if (!tls->nl)
 276                 continue;
 277             }
 278           break;
 279         }
 280
 281       TEST_TIMEOUT (client->thd->timeout, ret, start, rc);
 282       if (rc)
 283         break;
 284     }
 285   while (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN);
 286
 287   if (ret < 0)
 288     {
 289       log_write ("TLS: %s", gnutls_strerror (ret));
 290       ret = 0;
 291     }
 292   else if (ret > 0)
 293     tls->nl = ((char *)data)[ret-1] == '\n';
 294
 295   return ret;
 296 }
 297
 298 ssize_t
 299 tls_write_hook (assuan_context_t ctx, assuan_fd_t fd, const void *data,
 300                 size_t len)
 301 {
 302   struct client_s *client = assuan_get_pointer (ctx);
 303   ssize_t ret;
 304   time_t start = time (NULL);
 305
 306   if (client->disco)
 307     return -1;
 308
 309   (void)fd;
 310   do
 311     {
 312       gpg_error_t rc = 0;
 313
 314       ret = gnutls_record_send (client->thd->tls->ses, data, len);
 315       TEST_TIMEOUT (client->thd->timeout, ret, start, rc);
 316       if (rc)
 317         break;
 318     }
 319   while (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN);
 320
 321   if (ret < 0)
 322     log_write ("TLS: %s", gnutls_strerror (ret));
 323
 324   return ret;
 325 }
 326
 327 static gpg_error_t
 328 tls_init_params ()
 329 {
 330   int n;
 331   char *tmp, *tmp2;
 332   gpg_error_t rc = GPG_ERR_GENERAL;
 333   static pthread_mutex_t tls_mutex = PTHREAD_MUTEX_INITIALIZER;
 334
 335   if (x509_cred)
 336     return 0;
 337
 338   MUTEX_LOCK(&tls_mutex);
 339   pthread_cleanup_push (release_mutex_cb, &tls_mutex);
 340   tls_deinit_params ();
 341   n = gnutls_certificate_allocate_credentials (&x509_cred);
 342   if (n != GNUTLS_E_SUCCESS)
 343     {
 344       log_write ("%s", gnutls_strerror (n));
 345       x509_cred = NULL;
 346       goto fail;
 347     }
 348
 349   tmp = str_asprintf ("%s/ca-cert.pem", homedir);
 350   if (!tmp)
 351     {
 352       rc = GPG_ERR_ENOMEM;
 353       log_write ("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror (rc));
 354       goto fail;
 355     }
 356
 357   n = gnutls_certificate_set_x509_trust_file (x509_cred, tmp,
 358                                               GNUTLS_X509_FMT_PEM);
 359   if (n < 0)
 360     {
 361       log_write ("%s: %s", tmp, gnutls_strerror (n));
 362       xfree (tmp);
 363       goto fail;
 364     }
 365
 366   xfree (tmp);
 367   tmp = str_asprintf ("%s/server-cert.pem", homedir);
 368   if (!tmp)
 369     {
 370       rc = GPG_ERR_ENOMEM;
 371       log_write ("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror (rc));
 372       goto fail;
 373     }
 374
 375   tmp2 = str_asprintf ("%s/server-key.pem", homedir);
 376   if (!tmp2)
 377     {
 378       xfree (tmp);
 379       rc = GPG_ERR_ENOMEM;
 380       log_write ("%s(%i): %s", __FILE__, __LINE__, pwmd_strerror (rc));
 381       goto fail;
 382     }
 383
 384   n = gnutls_certificate_set_x509_key_file (x509_cred, tmp, tmp2,
 385                                             GNUTLS_X509_FMT_PEM);
 386   xfree (tmp);
 387   xfree (tmp2);
 388   if (n != GNUTLS_E_SUCCESS)
 389     {
 390       log_write ("%s", gnutls_strerror (n));
 391       goto fail;
 392     }
 393
 394   tmp = config_get_string ("global", "tls_dh_params_file");
 395   if (tmp)
 396     {
 397       tmp2 = expand_homedir (tmp);
 398       if (!tmp2)
 399         {
 400           log_write ("%s: %s", tmp, pwmd_strerror (GPG_ERR_ENOMEM));
 401           xfree (tmp);
 402           rc = GPG_ERR_ENOMEM;
 403           goto fail;
 404         }
 405
 406       xfree (tmp);
 407       tmp = tmp2;
 408       n = gnutls_dh_params_init (&dh_params);
 409       if (!n)
 410         {
 411           gnutls_datum_t data;
 412
 413           n = gnutls_load_file (tmp, &data);
 414           if (!n)
 415             {
 416               n = gnutls_dh_params_import_pkcs3 (dh_params, &data,
 417                                                  GNUTLS_X509_FMT_PEM);
 418               if (!n)
 419                 gnutls_certificate_set_dh_params (x509_cred, dh_params);
 420
 421               wipememory (data.data, 0, data.size);
 422               free (data.data);
 423             }
 424         }
 425
 426       if (n != GNUTLS_E_SUCCESS)
 427         {
 428           log_write ("%s: %s", tmp, gnutls_strerror (n));
 429           xfree (tmp);
 430           goto fail;
 431         }
 432       xfree (tmp);
 433     }
 434
 435   rc = 0;
 436
 437 fail:
 438   if (rc)
 439     tls_deinit_params ();
 440
 441   pthread_cleanup_pop (1);
 442   return rc;
 443 }
 444
 445 void
 446 tls_deinit_params ()
 447 {
 448   if (dh_params)
 449     {
 450       gnutls_dh_params_deinit (dh_params);
 451       dh_params = NULL;
 452     }
 453
 454   if (x509_cred)
 455     {
 456       gnutls_certificate_free_credentials (x509_cred);
 457       x509_cred = NULL;
 458     }
 459 }
 460
 461 static gpg_error_t
 462 do_tls_validate_access (struct client_s *client, const char *section)
 463 {
 464   char **access = config_get_list (section, "allowed");
 465   char **p;
 466   int allowed = 0;
 467
 468   if (!access || !*access)
 469     return GPG_ERR_EACCES;
 470
 471   for (p = access; p && *p; p++)
 472     {
 473       int not = 0;
 474       char *fp = *p;
 475
 476       if (*fp && *fp == '+' && *(fp + 1) == 0) // allow all connections
 477         {
 478           allowed = 1;
 479           continue;
 480         }
 481
 482       if (*fp == '!' || *fp == '-')
 483         {
 484           not = 1;
 485           fp++;
 486           if (!*fp)
 487             break;
 488         }
 489
 490       if (*fp++ != '#')
 491         continue;
 492
 493       if (!strcasecmp (client->thd->tls->fp, fp))
 494         allowed = not ? 0 : 1;
 495     }
 496
 497   strv_free (access);
 498   return allowed ? 0 : GPG_ERR_EACCES;
 499 }
 500
 501 gpg_error_t
 502 tls_validate_access (struct client_s *client, const char *filename)
 503 {
 504   gpg_error_t rc = do_tls_validate_access (client, "global");
 505
 506   if (!rc && filename)
 507     rc = do_tls_validate_access (client, filename);
 508
 509   return rc;
 510 }
 511
 512 void
 513 tls_rehandshake ()
 514 {
 515   unsigned t, i;
 516
 517   MUTEX_LOCK (&cn_mutex);
 518   t = slist_length (cn_thread_list);
 519   for (i = 0; i < t; i++)
 520     {
 521       struct client_thread_s *thd = slist_nth_data (cn_thread_list, i);
 522
 523       if (thd->remote && thd->tls)
 524         thd->tls->rehandshake = 1;
 525     }
 526   MUTEX_UNLOCK (&cn_mutex);
 527 }
 528
 529 static int
 530 start_stop_tls_with_protocol (int ipv6, int term)
 531 {
 532   struct addrinfo hints, *servinfo, *p;
 533   int port = config_get_integer ("global", "tcp_port");
 534   char buf[7];
 535   int n;
 536   int *fd = ipv6 ? &tls6_fd : &tls_fd;
 537
 538   if (term || config_get_boolean ("global", "enable_tcp") == 0)
 539     {
 540       if (tls6_fd != -1)
 541         {
 542           shutdown (tls6_fd, SHUT_RDWR);
 543           close (tls6_fd);
 544           tls6_fd = -1;
 545         }
 546
 547       if (tls_fd != -1)
 548         {
 549           shutdown (tls_fd, SHUT_RDWR);
 550           close (tls_fd);
 551           tls_fd = -1;
 552         }
 553
 554       return 0;
 555     }
 556
 557   memset (&hints, 0, sizeof (hints));
 558   hints.ai_family = ipv6 ? AF_INET6 : AF_INET;
 559   hints.ai_socktype = SOCK_STREAM;
 560   hints.ai_flags = AI_PASSIVE;
 561   snprintf (buf, sizeof (buf), "%i", port);
 562
 563   if ((n = getaddrinfo (NULL, buf, &hints, &servinfo)) == -1)
 564     {
 565       log_write ("getaddrinfo(): %s", gai_strerror (n));
 566       return 0;
 567     }
 568
 569   for (n = 0, p = servinfo; p != NULL; p = p->ai_next)
 570     {
 571       int r = 1;
 572
 573       if ((ipv6 && p->ai_family != AF_INET6)
 574           || (!ipv6 && p->ai_family != AF_INET))
 575         continue;
 576
 577       if ((*fd = socket (p->ai_family, p->ai_socktype, p->ai_protocol)) == -1)
 578         {
 579           log_write ("socket(): %s", strerror (errno));
 580           continue;
 581         }
 582
 583       if (setsockopt (*fd, SOL_SOCKET, SO_REUSEADDR, &r, sizeof (int)) == -1)
 584         {
 585           log_write ("setsockopt(): %s",
 586                      pwmd_strerror (gpg_error_from_errno (errno)));
 587           freeaddrinfo (servinfo);
 588           goto fail;
 589         }
 590
 591       if (bind (*fd, p->ai_addr, p->ai_addrlen) == -1)
 592         {
 593           close (*fd);
 594           log_write ("bind(): %s",
 595                      pwmd_strerror (gpg_error_from_errno (errno)));
 596           continue;
 597         }
 598
 599       n++;
 600       break;
 601     }
 602
 603   freeaddrinfo (servinfo);
 604
 605   if (!n)
 606     goto fail;
 607
 608 #if HAVE_DECL_SO_BINDTODEVICE != 0
 609   char *tmp = config_get_string ("global", "tcp_interface");
 610   if (tmp && setsockopt (*fd, SOL_SOCKET, SO_BINDTODEVICE, tmp,
 611                          strlen (tmp)) == -1)
 612     {
 613       log_write ("setsockopt(): %s",
 614                  pwmd_strerror (gpg_error_from_errno (errno)));
 615       xfree (tmp);
 616       goto fail;
 617     }
 618
 619   xfree (tmp);
 620 #endif
 621
 622   if (listen (*fd, 128) == -1)
 623     {
 624       log_write ("listen(): %s", strerror (errno));
 625       goto fail;
 626     }
 627
 628   return 1;
 629
 630 fail:
 631   start_stop_tls_with_protocol (0, 1);
 632   if (tls_fd != -1)
 633     close (tls_fd);
 634
 635   if (tls6_fd != -1)
 636     close (tls6_fd);
 637
 638   tls_fd = -1;
 639   tls6_fd = -1;
 640   return 0;
 641 }
 642
 643 int
 644 tls_start_stop (int term)
 645 {
 646   char *s = config_get_string ("global", "tcp_bind");
 647   int b;
 648
 649   if (!s)
 650     return 0;
 651
 652   if (!strcmp (s, "any"))
 653     {
 654       b = start_stop_tls_with_protocol (0, term);
 655       if (b)
 656         b = start_stop_tls_with_protocol (1, term);
 657     }
 658   else if (!strcmp (s, "ipv4"))
 659     b = start_stop_tls_with_protocol (0, term);
 660   else if (!strcmp (s, "ipv6"))
 661     b = start_stop_tls_with_protocol (1, term);
 662   else
 663     b = 0;
 664
 665   xfree (s);
 666   if (!term && b)
 667     {
 668       gpg_error_t rc = tls_init_params ();
 669       if (rc)
 670         {
 671           start_stop_tls_with_protocol (0, 1);
 672           return 0;
 673         }
 674     }
 675
 676   return b;
 677 }