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