src/utils/ssl.c

   1 /*
   2  * SysDB - src/utils/ssl.c
   3  * Copyright (C) 2015 Sebastian 'tokkee' Harl <sh@tokkee.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  17  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #if HAVE_CONFIG_H
  29 #       include "config.h"
  30 #endif
  31
  32 #include "utils/ssl.h"
  33 #include "utils/error.h"
  34
  35 #include <errno.h>
  36
  37 #include <stdlib.h>
  38 #include <string.h>
  39
  40 #include <openssl/ssl.h>
  41 #include <openssl/bio.h>
  42 #include <openssl/x509.h>
  43 #include <openssl/err.h>
  44
  45 /*
  46  * data types
  47  */
  48
  49 struct sdb_ssl_client {
  50         SSL_CTX *ctx;
  51         sdb_ssl_options_t opts;
  52 };
  53
  54 struct sdb_ssl_server {
  55         SSL_CTX *ctx;
  56         sdb_ssl_options_t opts;
  57 };
  58
  59 struct sdb_ssl_session {
  60         SSL *ssl;
  61 };
  62
  63 /*
  64  * private helper functions
  65  */
  66
  67 /* log all pending SSL errors */
  68 static void
  69 ssl_log(int prio, const char *prefix, ...)
  70 {
  71         char msg[1024];
  72         va_list ap;
  73
  74         va_start(ap, prefix);
  75         vsnprintf(msg, sizeof(msg), prefix, ap);
  76         msg[sizeof(msg) - 1] = '\0';
  77         va_end(ap);
  78
  79         while (42) {
  80                 unsigned long e = ERR_get_error();
  81                 if (! e)
  82                         break;
  83                 sdb_log(prio, "%s: %s", msg, ERR_reason_error_string(e));
  84         }
  85 } /* ssl_log */
  86
  87 static void
  88 ssl_log_err(int prio, SSL *ssl, int status, const char *prefix, ...)
  89 {
  90         int err = SSL_get_error(ssl, status);
  91         char msg[1024];
  92         va_list ap;
  93
  94         va_start(ap, prefix);
  95         vsnprintf(msg, sizeof(msg), prefix, ap);
  96         msg[sizeof(msg) - 1] = '\0';
  97         va_end(ap);
  98
  99         errno = 0;
 100         switch (err) {
 101                 case SSL_ERROR_NONE:
 102                         sdb_log(prio, "%s: success", msg);
 103                         break;
 104                 case SSL_ERROR_ZERO_RETURN:
 105                         errno = ECONNRESET;
 106                         break;
 107                 case SSL_ERROR_WANT_READ:
 108                 case SSL_ERROR_WANT_WRITE:
 109                         errno = EWOULDBLOCK;
 110                         break;
 111                 case SSL_ERROR_WANT_CONNECT:
 112                 case SSL_ERROR_WANT_ACCEPT:
 113                         sdb_log(prio, "%s: connection not set up", msg);
 114                         break;
 115                 case SSL_ERROR_WANT_X509_LOOKUP:
 116                         sdb_log(prio, "%s: application error", msg);
 117                         break;
 118                 case SSL_ERROR_SYSCALL:
 119                         if (ERR_peek_error())
 120                                 return ssl_log(prio, msg);
 121                         if (! status)
 122                                 sdb_log(prio, "%s: unexpected end-of-file", msg);
 123                         else if (! errno)
 124                                 errno = EIO;
 125                 case SSL_ERROR_SSL:
 126                         return ssl_log(prio, msg);
 127                 default:
 128                         sdb_log(prio, "%s: unkown SSL error %d", msg, err);
 129                         break;
 130         }
 131
 132         if (errno) {
 133                 char errbuf[1024];
 134                 sdb_log(prio, "%s: %s", msg,
 135                                 sdb_strerror(errno, errbuf, sizeof(errbuf)));
 136         }
 137 } /* ssl_log_err */
 138
 139 static int
 140 copy_options(sdb_ssl_options_t *dst, const sdb_ssl_options_t *src)
 141 {
 142         sdb_ssl_options_t tmp;
 143         sdb_ssl_options_t def = SDB_SSL_DEFAULT_OPTIONS;
 144
 145         if (src)
 146                 tmp = *src;
 147         else
 148                 tmp = def;
 149
 150         if (! tmp.ca_file)
 151                 tmp.ca_file = def.ca_file;
 152         if (! tmp.key_file)
 153                 tmp.key_file = def.key_file;
 154         if (! tmp.cert_file)
 155                 tmp.cert_file = def.cert_file;
 156
 157         dst->ca_file = strdup(tmp.ca_file);
 158         dst->key_file = strdup(tmp.key_file);
 159         dst->cert_file = strdup(tmp.cert_file);
 160         if ((! dst->ca_file) || (! dst->key_file) || (! dst->cert_file))
 161                 return -1;
 162         if (tmp.crl_file) {
 163                 dst->crl_file = strdup(tmp.crl_file);
 164                 if (! dst->crl_file)
 165                         return -1;
 166         }
 167         return 0;
 168 } /* copy_options */
 169
 170 /*
 171  * public API
 172  */
 173
 174 sdb_ssl_client_t *
 175 sdb_ssl_client_create(const sdb_ssl_options_t *opts)
 176 {
 177         sdb_ssl_client_t *client;
 178
 179         client = calloc(1, sizeof(*client));
 180         if (! client)
 181                 return NULL;
 182
 183         if (copy_options(&client->opts, opts)) {
 184                 sdb_ssl_client_destroy(client);
 185                 return NULL;
 186         }
 187
 188         client->ctx = SSL_CTX_new(SSLv23_client_method());
 189         if (! client->ctx) {
 190                 ssl_log(SDB_LOG_ERR, "ssl: Failed to create SSL context");
 191                 sdb_ssl_client_destroy(client);
 192                 return NULL;
 193         }
 194
 195         if (! SSL_CTX_load_verify_locations(client->ctx,
 196                                 client->opts.ca_file, NULL)) {
 197                 ssl_log(SDB_LOG_ERR, "ssl: Failed to load CA file '%s'",
 198                                 client->opts.ca_file);
 199                 sdb_ssl_client_destroy(client);
 200                 return NULL;
 201         }
 202         if (! SSL_CTX_use_certificate_file(client->ctx,
 203                                 client->opts.cert_file, SSL_FILETYPE_PEM)) {
 204                 ssl_log(SDB_LOG_ERR, "ssl: Failed to load cert file '%s'",
 205                                 client->opts.cert_file);
 206                 sdb_ssl_client_destroy(client);
 207                 return NULL;
 208         }
 209         if (! SSL_CTX_use_PrivateKey_file(client->ctx,
 210                                 client->opts.key_file, SSL_FILETYPE_PEM)) {
 211                 ssl_log(SDB_LOG_ERR, "ssl: Failed to load key file '%s'",
 212                                 client->opts.key_file);
 213                 sdb_ssl_client_destroy(client);
 214                 return NULL;
 215         }
 216         if (! SSL_CTX_check_private_key(client->ctx)) {
 217                 ssl_log(SDB_LOG_ERR, "ssl: Failed to verify key (%s)",
 218                                 client->opts.key_file);
 219                 sdb_ssl_client_destroy(client);
 220                 return NULL;
 221         }
 222
 223         SSL_CTX_set_mode(client->ctx, SSL_MODE_AUTO_RETRY);
 224         SSL_CTX_set_verify(client->ctx, SSL_VERIFY_PEER, NULL);
 225         SSL_CTX_set_verify_depth(client->ctx, 1);
 226         return client;
 227 } /* sdb_ssl_client_create */
 228
 229 void
 230 sdb_ssl_client_destroy(sdb_ssl_client_t *client)
 231 {
 232         if (! client)
 233                 return;
 234
 235         if (client->ctx)
 236                 SSL_CTX_free(client->ctx);
 237         sdb_ssl_free_options(&client->opts);
 238         free(client);
 239 } /* sdb_ssl_client_destroy */
 240
 241 sdb_ssl_session_t *
 242 sdb_ssl_client_connect(sdb_ssl_client_t *client, int fd)
 243 {
 244         sdb_ssl_session_t *session;
 245         int status;
 246         BIO *bio;
 247
 248         if ((! client) || (fd < 0))
 249                 return NULL;
 250
 251         session = calloc(1, sizeof(*session));
 252         if (! session)
 253                 return NULL;
 254
 255         bio = BIO_new_socket(fd, BIO_NOCLOSE);
 256         if (! bio) {
 257                 ssl_log(SDB_LOG_ERR, "ssl: Failed to create SSL socket");
 258                 sdb_ssl_session_destroy(session);
 259                 return NULL;
 260         }
 261         session->ssl = SSL_new(client->ctx);
 262         if (! session->ssl) {
 263                 ssl_log(SDB_LOG_ERR, "ssl: Failed to create SSL object");
 264                 sdb_ssl_session_destroy(session);
 265                 return NULL;
 266         }
 267         SSL_set_bio(session->ssl, bio, bio);
 268
 269         if ((status = SSL_connect(session->ssl)) <= 0) {
 270                 ssl_log_err(SDB_LOG_ERR, session->ssl, status,
 271                                 "ssl: Failed to initialize SSL session");
 272                 sdb_ssl_session_destroy(session);
 273                 return NULL;
 274         }
 275         if (SSL_get_verify_result(session->ssl) != X509_V_OK) {
 276                 sdb_log(SDB_LOG_ERR, "Failed to verify SSL connection");
 277                 sdb_ssl_session_destroy(session);
 278                 return NULL;
 279         }
 280         return session;
 281 } /* sdb_ssl_client_connect */
 282
 283 sdb_ssl_server_t *
 284 sdb_ssl_server_create(const sdb_ssl_options_t *opts)
 285 {
 286         sdb_ssl_server_t *server;
 287
 288         server = calloc(1, sizeof(*server));
 289         if (! server)
 290                 return NULL;
 291
 292         if (copy_options(&server->opts, opts)) {
 293                 sdb_ssl_server_destroy(server);
 294                 return NULL;
 295         }
 296
 297         server->ctx = SSL_CTX_new(SSLv23_server_method());
 298         if (! server->ctx) {
 299                 ssl_log(SDB_LOG_ERR, "ssl: Failed to create SSL context");
 300                 sdb_ssl_server_destroy(server);
 301                 return NULL;
 302         }
 303
 304         /* Recommendation documented at
 305          * https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/ */
 306         if (! SSL_CTX_set_cipher_list(server->ctx,
 307                                 "ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:"
 308                                 "DH+AES:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+3DES:"
 309                                 "!aNULL:!MD5:!DSS")) {
 310                 sdb_log(SDB_LOG_ERR, "ssl: Invalid cipher list");
 311                 sdb_ssl_server_destroy(server);
 312                 return NULL;
 313         }
 314
 315         if (! SSL_CTX_load_verify_locations(server->ctx,
 316                                 server->opts.ca_file, NULL)) {
 317                 ssl_log(SDB_LOG_ERR, "Failed to load CA file %s",
 318                                 server->opts.ca_file);
 319                 return NULL;
 320         }
 321         SSL_CTX_set_client_CA_list(server->ctx,
 322                         SSL_load_client_CA_file(server->opts.ca_file));
 323
 324         if (! SSL_CTX_use_certificate_file(server->ctx,
 325                                 server->opts.cert_file, SSL_FILETYPE_PEM)) {
 326                 ssl_log(SDB_LOG_ERR, "Failed to load SSL cert file %s",
 327                                 server->opts.cert_file);
 328                 return NULL;
 329         }
 330         if (! SSL_CTX_use_PrivateKey_file(server->ctx,
 331                                 server->opts.key_file, SSL_FILETYPE_PEM)) {
 332                 ssl_log(SDB_LOG_ERR, "Failed to load SSL key file %s",
 333                                 server->opts.key_file);
 334                 return NULL;
 335         }
 336         if (! SSL_CTX_check_private_key(server->ctx)) {
 337                 ssl_log(SDB_LOG_ERR, "Failed to verify SSL private key");
 338                 return NULL;
 339         }
 340
 341         SSL_CTX_set_mode(server->ctx, SSL_MODE_AUTO_RETRY);
 342         SSL_CTX_set_verify(server->ctx,
 343                         SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL);
 344         SSL_CTX_set_verify_depth(server->ctx, 1);
 345
 346         /* TODO: handle server->opts.crl_file */
 347         return server;
 348 } /* sdb_ssl_server_create */
 349
 350 void
 351 sdb_ssl_server_destroy(sdb_ssl_server_t *server)
 352 {
 353         if (! server)
 354                 return;
 355
 356         if (server->ctx)
 357                 SSL_CTX_free(server->ctx);
 358         sdb_ssl_free_options(&server->opts);
 359         free(server);
 360 } /* sdb_ssl_server_destroy */
 361
 362 sdb_ssl_session_t *
 363 sdb_ssl_server_accept(sdb_ssl_server_t *server, int fd)
 364 {
 365         sdb_ssl_session_t *session;
 366         int status;
 367         BIO *bio;
 368
 369         if ((! server) || (fd < 0))
 370                 return NULL;
 371
 372         session = calloc(1, sizeof(*session));
 373         if (! session)
 374                 return NULL;
 375
 376         bio = BIO_new_socket(fd, BIO_NOCLOSE);
 377         if (! bio) {
 378                 ssl_log(SDB_LOG_ERR, "ssl: Failed to create SSL socket");
 379                 sdb_ssl_session_destroy(session);
 380                 return NULL;
 381         }
 382         session->ssl = SSL_new(server->ctx);
 383         if (! session->ssl) {
 384                 ssl_log(SDB_LOG_ERR, "ssl: Failed to create SSL object");
 385                 sdb_ssl_session_destroy(session);
 386                 return NULL;
 387         }
 388         SSL_set_bio(session->ssl, bio, bio);
 389
 390         while (42) {
 391                 if ((status = SSL_accept(session->ssl)) <= 0) {
 392                         if (SSL_get_error(session->ssl, status) == SSL_ERROR_WANT_READ)
 393                                 continue;
 394
 395                         ssl_log_err(SDB_LOG_ERR, session->ssl, status,
 396                                         "ssl: Failed to initialize SSL session");
 397                         sdb_ssl_session_destroy(session);
 398                         return NULL;
 399                 }
 400                 break;
 401         }
 402         if (SSL_get_verify_result(session->ssl) != X509_V_OK) {
 403                 sdb_log(SDB_LOG_ERR, "Failed to verify SSL connection");
 404                 sdb_ssl_session_destroy(session);
 405                 return NULL;
 406         }
 407         return session;
 408 } /* sdb_ssl_server_accept */
 409
 410 void
 411 sdb_ssl_session_destroy(sdb_ssl_session_t *session)
 412 {
 413         if (! session)
 414                 return;
 415
 416         if (session->ssl) {
 417                 SSL_shutdown(session->ssl);
 418                 SSL_clear(session->ssl);
 419                 SSL_free(session->ssl);
 420         }
 421         free(session);
 422 } /* sdb_ssl_session_destroy */
 423
 424 char *
 425 sdb_ssl_session_peer(sdb_ssl_session_t *session)
 426 {
 427         X509 *x509;
 428         X509_NAME *name;
 429
 430         char *peer = NULL;
 431         char p[1024];
 432
 433         if (! session)
 434                 return NULL;
 435
 436         x509 = SSL_get_peer_certificate(session->ssl);
 437         if (! x509)
 438                 return NULL;
 439         name = X509_get_subject_name(x509);
 440         if (! name) {
 441                 X509_free(x509);
 442                 return NULL;
 443         }
 444
 445         if (X509_NAME_get_text_by_NID(name, NID_commonName, p, sizeof(p)) > 0)
 446                 peer = strdup(p);
 447
 448         X509_free(x509);
 449         return peer;
 450 } /* sdb_ssl_session_peer */
 451
 452 ssize_t
 453 sdb_ssl_session_write(sdb_ssl_session_t *session, const void *buf, size_t n)
 454 {
 455         int status;
 456
 457         if (! session)
 458                 return -1;
 459
 460         status = SSL_write(session->ssl, buf, (int)n);
 461         if (status) {
 462                 if ((status < 0) && (errno != EAGAIN))
 463                         ssl_log_err(SDB_LOG_ERR, session->ssl, status, "ssl: Write error");
 464                 return (ssize_t)status;
 465         }
 466
 467         status = SSL_get_error(session->ssl, status);
 468         if (status == SSL_ERROR_ZERO_RETURN)
 469                 return 0;
 470
 471         if ((status == SSL_ERROR_WANT_READ) || (status == SSL_ERROR_WANT_WRITE)) {
 472                 errno = EWOULDBLOCK;
 473                 return -1;
 474         }
 475         errno = ECONNRESET;
 476         return -1;
 477 } /* sdb_ssl_session_write */
 478
 479 ssize_t
 480 sdb_ssl_session_read(sdb_ssl_session_t *session, void *buf, size_t n)
 481 {
 482         int status;
 483
 484         if (! session)
 485                 return -1;
 486
 487         status = SSL_read(session->ssl, buf, (int)n);
 488         if (status) {
 489                 if ((status < 0) && (errno != EAGAIN))
 490                         ssl_log_err(SDB_LOG_ERR, session->ssl, status, "ssl: Read error");
 491                 return (ssize_t)status;
 492         }
 493
 494         status = SSL_get_error(session->ssl, status);
 495         if (status == SSL_ERROR_ZERO_RETURN)
 496                 return 0;
 497
 498         if ((status == SSL_ERROR_WANT_READ) || (status == SSL_ERROR_WANT_WRITE)) {
 499                 errno = EWOULDBLOCK;
 500                 return -1;
 501         }
 502         errno = ECONNRESET;
 503         return -1;
 504 } /* sdb_ssl_session_read */
 505
 506 void
 507 sdb_ssl_free_options(sdb_ssl_options_t *opts)
 508 {
 509         if (! opts)
 510                 return;
 511
 512         if (opts->ca_file)
 513                 free(opts->ca_file);
 514         if (opts->key_file)
 515                 free(opts->key_file);
 516         if (opts->cert_file)
 517                 free(opts->cert_file);
 518         if (opts->crl_file)
 519                 free(opts->crl_file);
 520
 521         opts->ca_file = opts->key_file = opts->cert_file = opts->crl_file = NULL;
 522 } /* sdb_ssl_free_options */
 523
 524 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 525