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, sdb_ssl_options_t *src)
 141 {
 142         sdb_ssl_options_t def = SDB_SSL_DEFAULT_OPTIONS;
 143
 144         if (! src)
 145                 src = &def;
 146
 147         if (! src->ca_file)
 148                 src->ca_file = def.ca_file;
 149         if (! src->key_file)
 150                 src->key_file = def.key_file;
 151         if (! src->cert_file)
 152                 src->cert_file = def.cert_file;
 153
 154         dst->ca_file = strdup(src->ca_file);
 155         dst->key_file = strdup(src->key_file);
 156         dst->cert_file = strdup(src->cert_file);
 157         if ((! dst->ca_file) || (! dst->key_file) || (! dst->cert_file))
 158                 return -1;
 159         if (src->crl_file) {
 160                 dst->crl_file = strdup(src->crl_file);
 161                 if (! dst->crl_file)
 162                         return -1;
 163         }
 164         return 0;
 165 } /* copy_options */
 166
 167 /*
 168  * public API
 169  */
 170
 171 sdb_ssl_client_t *
 172 sdb_ssl_client_create(sdb_ssl_options_t *opts)
 173 {
 174         sdb_ssl_client_t *client;
 175
 176         client = calloc(1, sizeof(*client));
 177         if (! client)
 178                 return NULL;
 179
 180         if (copy_options(&client->opts, opts)) {
 181                 sdb_ssl_client_destroy(client);
 182                 return NULL;
 183         }
 184
 185         client->ctx = SSL_CTX_new(SSLv23_client_method());
 186         if (! client->ctx) {
 187                 ssl_log(SDB_LOG_ERR, "ssl: Failed to create SSL context");
 188                 sdb_ssl_client_destroy(client);
 189                 return NULL;
 190         }
 191
 192         if (! SSL_CTX_load_verify_locations(client->ctx,
 193                                 client->opts.ca_file, NULL)) {
 194                 ssl_log(SDB_LOG_ERR, "ssl: Failed to load CA file");
 195                 sdb_ssl_client_destroy(client);
 196                 return NULL;
 197         }
 198         if (! SSL_CTX_use_certificate_file(client->ctx,
 199                                 client->opts.cert_file, SSL_FILETYPE_PEM)) {
 200                 ssl_log(SDB_LOG_ERR, "ssl: Failed to load cert file '%s'",
 201                                 client->opts.cert_file);
 202                 sdb_ssl_client_destroy(client);
 203                 return NULL;
 204         }
 205         if (! SSL_CTX_use_PrivateKey_file(client->ctx,
 206                                 client->opts.key_file, SSL_FILETYPE_PEM)) {
 207                 ssl_log(SDB_LOG_ERR, "ssl: Failed to load key file '%s'",
 208                                 client->opts.key_file);
 209                 sdb_ssl_client_destroy(client);
 210                 return NULL;
 211         }
 212         if (! SSL_CTX_check_private_key(client->ctx)) {
 213                 ssl_log(SDB_LOG_ERR, "ssl: Failed to verify key (%s)",
 214                                 client->opts.key_file);
 215                 sdb_ssl_client_destroy(client);
 216                 return NULL;
 217         }
 218
 219         SSL_CTX_set_mode(client->ctx, SSL_MODE_AUTO_RETRY);
 220         SSL_CTX_set_verify(client->ctx, SSL_VERIFY_PEER, NULL);
 221         SSL_CTX_set_verify_depth(client->ctx, 1);
 222         return client;
 223 } /* sdb_ssl_client_create */
 224
 225 void
 226 sdb_ssl_client_destroy(sdb_ssl_client_t *client)
 227 {
 228         if (! client)
 229                 return;
 230
 231         if (client->ctx)
 232                 SSL_CTX_free(client->ctx);
 233         sdb_ssl_free_options(&client->opts);
 234         free(client);
 235 } /* sdb_ssl_client_destroy */
 236
 237 sdb_ssl_session_t *
 238 sdb_ssl_client_connect(sdb_ssl_client_t *client, int fd)
 239 {
 240         sdb_ssl_session_t *session;
 241         int status;
 242         BIO *bio;
 243
 244         if ((! client) || (fd < 0))
 245                 return NULL;
 246
 247         session = calloc(1, sizeof(*session));
 248         if (! session)
 249                 return NULL;
 250
 251         bio = BIO_new_socket(fd, BIO_NOCLOSE);
 252         if (! bio) {
 253                 ssl_log(SDB_LOG_ERR, "ssl: Failed to create SSL socket");
 254                 sdb_ssl_session_destroy(session);
 255                 return NULL;
 256         }
 257         session->ssl = SSL_new(client->ctx);
 258         if (! session->ssl) {
 259                 ssl_log(SDB_LOG_ERR, "ssl: Failed to create SSL object");
 260                 sdb_ssl_session_destroy(session);
 261                 return NULL;
 262         }
 263         SSL_set_bio(session->ssl, bio, bio);
 264
 265         if ((status = SSL_connect(session->ssl)) <= 0) {
 266                 ssl_log_err(SDB_LOG_ERR, session->ssl, status,
 267                                 "ssl: Failed to initialize SSL session");
 268                 sdb_ssl_session_destroy(session);
 269                 return NULL;
 270         }
 271         if (SSL_get_verify_result(session->ssl) != X509_V_OK) {
 272                 sdb_log(SDB_LOG_ERR, "Failed to verify SSL connection");
 273                 sdb_ssl_session_destroy(session);
 274                 return NULL;
 275         }
 276         return session;
 277 } /* sdb_ssl_client_connect */
 278
 279 sdb_ssl_server_t *
 280 sdb_ssl_server_create(sdb_ssl_options_t *opts)
 281 {
 282         sdb_ssl_server_t *server;
 283
 284         server = calloc(1, sizeof(*server));
 285         if (! server)
 286                 return NULL;
 287
 288         if (copy_options(&server->opts, opts)) {
 289                 sdb_ssl_server_destroy(server);
 290                 return NULL;
 291         }
 292
 293         server->ctx = SSL_CTX_new(SSLv23_server_method());
 294         if (! server->ctx) {
 295                 ssl_log(SDB_LOG_ERR, "ssl: Failed to create SSL context");
 296                 sdb_ssl_server_destroy(server);
 297                 return NULL;
 298         }
 299
 300         /* Recommendation documented at
 301          * https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/ */
 302         if (! SSL_CTX_set_cipher_list(server->ctx,
 303                                 "ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:"
 304                                 "DH+AES:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+3DES:"
 305                                 "!aNULL:!MD5:!DSS")) {
 306                 sdb_log(SDB_LOG_ERR, "ssl: Invalid cipher list");
 307                 sdb_ssl_server_destroy(server);
 308                 return NULL;
 309         }
 310
 311         if (! SSL_CTX_load_verify_locations(server->ctx,
 312                                 server->opts.ca_file, NULL)) {
 313                 ssl_log(SDB_LOG_ERR, "Failed to load CA file %s",
 314                                 server->opts.ca_file);
 315                 return NULL;
 316         }
 317         SSL_CTX_set_client_CA_list(server->ctx,
 318                         SSL_load_client_CA_file(server->opts.ca_file));
 319
 320         if (! SSL_CTX_use_certificate_file(server->ctx,
 321                                 server->opts.cert_file, SSL_FILETYPE_PEM)) {
 322                 ssl_log(SDB_LOG_ERR, "Failed to load SSL cert file %s",
 323                                 server->opts.cert_file);
 324                 return NULL;
 325         }
 326         if (! SSL_CTX_use_PrivateKey_file(server->ctx,
 327                                 server->opts.key_file, SSL_FILETYPE_PEM)) {
 328                 ssl_log(SDB_LOG_ERR, "Failed to load SSL key file %s",
 329                                 server->opts.key_file);
 330                 return NULL;
 331         }
 332         if (! SSL_CTX_check_private_key(server->ctx)) {
 333                 ssl_log(SDB_LOG_ERR, "Failed to verify SSL private key");
 334                 return NULL;
 335         }
 336
 337         SSL_CTX_set_mode(server->ctx, SSL_MODE_AUTO_RETRY);
 338         SSL_CTX_set_verify(server->ctx,
 339                         SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL);
 340         SSL_CTX_set_verify_depth(server->ctx, 1);
 341
 342         /* TODO: handle server->opts.crl_file */
 343         return server;
 344 } /* sdb_ssl_server_create */
 345
 346 void
 347 sdb_ssl_server_destroy(sdb_ssl_server_t *server)
 348 {
 349         if (! server)
 350                 return;
 351
 352         if (server->ctx)
 353                 SSL_CTX_free(server->ctx);
 354         sdb_ssl_free_options(&server->opts);
 355         free(server);
 356 } /* sdb_ssl_server_destroy */
 357
 358 sdb_ssl_session_t *
 359 sdb_ssl_server_accept(sdb_ssl_server_t *server, int fd)
 360 {
 361         sdb_ssl_session_t *session;
 362         int status;
 363         BIO *bio;
 364
 365         if ((! server) || (fd < 0))
 366                 return NULL;
 367
 368         session = calloc(1, sizeof(*session));
 369         if (! session)
 370                 return NULL;
 371
 372         bio = BIO_new_socket(fd, BIO_NOCLOSE);
 373         if (! bio) {
 374                 ssl_log(SDB_LOG_ERR, "ssl: Failed to create SSL socket");
 375                 sdb_ssl_session_destroy(session);
 376                 return NULL;
 377         }
 378         session->ssl = SSL_new(server->ctx);
 379         if (! session->ssl) {
 380                 ssl_log(SDB_LOG_ERR, "ssl: Failed to create SSL object");
 381                 sdb_ssl_session_destroy(session);
 382                 return NULL;
 383         }
 384         SSL_set_bio(session->ssl, bio, bio);
 385
 386         while (42) {
 387                 if ((status = SSL_accept(session->ssl)) <= 0) {
 388                         if (SSL_get_error(session->ssl, status) == SSL_ERROR_WANT_READ)
 389                                 continue;
 390
 391                         ssl_log_err(SDB_LOG_ERR, session->ssl, status,
 392                                         "ssl: Failed to initialize SSL session");
 393                         sdb_ssl_session_destroy(session);
 394                         return NULL;
 395                 }
 396                 break;
 397         }
 398         if (SSL_get_verify_result(session->ssl) != X509_V_OK) {
 399                 sdb_log(SDB_LOG_ERR, "Failed to verify SSL connection");
 400                 sdb_ssl_session_destroy(session);
 401                 return NULL;
 402         }
 403         return session;
 404 } /* sdb_ssl_server_accept */
 405
 406 void
 407 sdb_ssl_session_destroy(sdb_ssl_session_t *session)
 408 {
 409         if (! session)
 410                 return;
 411
 412         if (session->ssl) {
 413                 SSL_shutdown(session->ssl);
 414                 SSL_clear(session->ssl);
 415                 SSL_free(session->ssl);
 416         }
 417         free(session);
 418 } /* sdb_ssl_session_destroy */
 419
 420 char *
 421 sdb_ssl_session_peer(sdb_ssl_session_t *session)
 422 {
 423         X509 *x509;
 424         X509_NAME *name;
 425
 426         char *peer = NULL;
 427         char p[1024];
 428
 429         if (! session)
 430                 return NULL;
 431
 432         x509 = SSL_get_peer_certificate(session->ssl);
 433         if (! x509)
 434                 return NULL;
 435         name = X509_get_subject_name(x509);
 436         if (! name) {
 437                 X509_free(x509);
 438                 return NULL;
 439         }
 440
 441         if (X509_NAME_get_text_by_NID(name, NID_commonName, p, sizeof(p)) > 0)
 442                 peer = strdup(p);
 443
 444         X509_free(x509);
 445         return peer;
 446 } /* sdb_ssl_session_peer */
 447
 448 ssize_t
 449 sdb_ssl_session_write(sdb_ssl_session_t *session, const void *buf, size_t n)
 450 {
 451         int status;
 452
 453         if (! session)
 454                 return -1;
 455
 456         status = SSL_write(session->ssl, buf, (int)n);
 457         if (status) {
 458                 if ((status < 0) && (errno != EAGAIN))
 459                         ssl_log_err(SDB_LOG_ERR, session->ssl, status, "ssl: Write error");
 460                 return (ssize_t)status;
 461         }
 462
 463         status = SSL_get_error(session->ssl, status);
 464         if (status == SSL_ERROR_ZERO_RETURN)
 465                 return 0;
 466
 467         if ((status == SSL_ERROR_WANT_READ) || (status == SSL_ERROR_WANT_WRITE)) {
 468                 errno = EWOULDBLOCK;
 469                 return -1;
 470         }
 471         errno = ECONNRESET;
 472         return -1;
 473 } /* sdb_ssl_session_write */
 474
 475 ssize_t
 476 sdb_ssl_session_read(sdb_ssl_session_t *session, void *buf, size_t n)
 477 {
 478         int status;
 479
 480         if (! session)
 481                 return -1;
 482
 483         status = SSL_read(session->ssl, buf, (int)n);
 484         if (status) {
 485                 if ((status < 0) && (errno != EAGAIN))
 486                         ssl_log_err(SDB_LOG_ERR, session->ssl, status, "ssl: Read error");
 487                 return (ssize_t)status;
 488         }
 489
 490         status = SSL_get_error(session->ssl, status);
 491         if (status == SSL_ERROR_ZERO_RETURN)
 492                 return 0;
 493
 494         if ((status == SSL_ERROR_WANT_READ) || (status == SSL_ERROR_WANT_WRITE)) {
 495                 errno = EWOULDBLOCK;
 496                 return -1;
 497         }
 498         errno = ECONNRESET;
 499         return -1;
 500 } /* sdb_ssl_session_read */
 501
 502 void
 503 sdb_ssl_free_options(sdb_ssl_options_t *opts)
 504 {
 505         if (! opts)
 506                 return;
 507
 508         if (opts->ca_file)
 509                 free(opts->ca_file);
 510         if (opts->key_file)
 511                 free(opts->key_file);
 512         if (opts->cert_file)
 513                 free(opts->cert_file);
 514         if (opts->crl_file)
 515                 free(opts->crl_file);
 516
 517         opts->ca_file = opts->key_file = opts->cert_file = opts->crl_file = NULL;
 518 } /* sdb_ssl_free_options */
 519
 520 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 521