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