ssl/bio_ssl.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <errno.h>
  14 #include <openssl/crypto.h>
  15 #include "internal/bio.h"
  16 #include <openssl/err.h>
  17 #include "ssl_locl.h"
  18
  19 static int ssl_write(BIO *h, const char *buf, size_t size, size_t *written);
  20 static int ssl_read(BIO *b, char *buf, size_t size, size_t *readbytes);
  21 static int ssl_puts(BIO *h, const char *str);
  22 static long ssl_ctrl(BIO *h, int cmd, long arg1, void *arg2);
  23 static int ssl_new(BIO *h);
  24 static int ssl_free(BIO *data);
  25 static long ssl_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp);
  26 typedef struct bio_ssl_st {
  27     SSL *ssl;                   /* The ssl handle :-) */
  28     /* re-negotiate every time the total number of bytes is this size */
  29     int num_renegotiates;
  30     unsigned long renegotiate_count;
  31     size_t byte_count;
  32     unsigned long renegotiate_timeout;
  33     unsigned long last_time;
  34 } BIO_SSL;
  35
  36 static const BIO_METHOD methods_sslp = {
  37     BIO_TYPE_SSL, "ssl",
  38     ssl_write,
  39     NULL,
  40     ssl_read,
  41     NULL,
  42     ssl_puts,
  43     NULL,                       /* ssl_gets, */
  44     ssl_ctrl,
  45     ssl_new,
  46     ssl_free,
  47     ssl_callback_ctrl,
  48 };
  49
  50 const BIO_METHOD *BIO_f_ssl(void)
  51 {
  52     return (&methods_sslp);
  53 }
  54
  55 static int ssl_new(BIO *bi)
  56 {
  57     BIO_SSL *bs = OPENSSL_zalloc(sizeof(*bs));
  58
  59     if (bs == NULL) {
  60         BIOerr(BIO_F_SSL_NEW, ERR_R_MALLOC_FAILURE);
  61         return (0);
  62     }
  63     BIO_set_init(bi, 0);
  64     BIO_set_data(bi, bs);
  65     /* Clear all flags */
  66     BIO_clear_flags(bi, ~0);
  67
  68     return 1;
  69 }
  70
  71 static int ssl_free(BIO *a)
  72 {
  73     BIO_SSL *bs;
  74
  75     if (a == NULL)
  76         return (0);
  77     bs = BIO_get_data(a);
  78     if (bs->ssl != NULL)
  79         SSL_shutdown(bs->ssl);
  80     if (BIO_get_shutdown(a)) {
  81         if (BIO_get_init(a))
  82             SSL_free(bs->ssl);
  83         /* Clear all flags */
  84         BIO_clear_flags(a, ~0);
  85         BIO_set_init(a, 0);
  86     }
  87     OPENSSL_free(bs);
  88     return 1;
  89 }
  90
  91 static int ssl_read(BIO *b, char *buf, size_t size, size_t *readbytes)
  92 {
  93     int ret = 1;
  94     BIO_SSL *sb;
  95     SSL *ssl;
  96     int retry_reason = 0;
  97     int r = 0;
  98
  99     if (buf == NULL)
 100         return 0;
 101     sb = BIO_get_data(b);
 102     ssl = sb->ssl;
 103
 104     BIO_clear_retry_flags(b);
 105
 106     if (size > INT_MAX)
 107         size = INT_MAX;
 108
 109     ret = SSL_read(ssl, buf, size);
 110     if (ret > 0)
 111         *readbytes = ret;
 112
 113     switch (SSL_get_error(ssl, ret)) {
 114     case SSL_ERROR_NONE:
 115         if (*readbytes == 0)
 116             break;
 117         if (sb->renegotiate_count > 0) {
 118             sb->byte_count += *readbytes;
 119             if (sb->byte_count > sb->renegotiate_count) {
 120                 sb->byte_count = 0;
 121                 sb->num_renegotiates++;
 122                 SSL_renegotiate(ssl);
 123                 r = 1;
 124             }
 125         }
 126         if ((sb->renegotiate_timeout > 0) && (!r)) {
 127             unsigned long tm;
 128
 129             tm = (unsigned long)time(NULL);
 130             if (tm > sb->last_time + sb->renegotiate_timeout) {
 131                 sb->last_time = tm;
 132                 sb->num_renegotiates++;
 133                 SSL_renegotiate(ssl);
 134             }
 135         }
 136
 137         break;
 138     case SSL_ERROR_WANT_READ:
 139         BIO_set_retry_read(b);
 140         break;
 141     case SSL_ERROR_WANT_WRITE:
 142         BIO_set_retry_write(b);
 143         break;
 144     case SSL_ERROR_WANT_X509_LOOKUP:
 145         BIO_set_retry_special(b);
 146         retry_reason = BIO_RR_SSL_X509_LOOKUP;
 147         break;
 148     case SSL_ERROR_WANT_ACCEPT:
 149         BIO_set_retry_special(b);
 150         retry_reason = BIO_RR_ACCEPT;
 151         break;
 152     case SSL_ERROR_WANT_CONNECT:
 153         BIO_set_retry_special(b);
 154         retry_reason = BIO_RR_CONNECT;
 155         break;
 156     case SSL_ERROR_SYSCALL:
 157     case SSL_ERROR_SSL:
 158     case SSL_ERROR_ZERO_RETURN:
 159     default:
 160         break;
 161     }
 162
 163     BIO_set_retry_reason(b, retry_reason);
 164
 165     return ret;
 166 }
 167
 168 static int ssl_write(BIO *b, const char *buf, size_t size, size_t *written)
 169 {
 170     int ret, r = 0;
 171     int retry_reason = 0;
 172     SSL *ssl;
 173     BIO_SSL *bs;
 174
 175     if (buf == NULL)
 176         return 0;
 177     bs = BIO_get_data(b);
 178     ssl = bs->ssl;
 179
 180     BIO_clear_retry_flags(b);
 181
 182     ret = SSL_write_ex(ssl, buf, size, written);
 183
 184     switch (SSL_get_error(ssl, ret)) {
 185     case SSL_ERROR_NONE:
 186         if (*written == 0)
 187             break;
 188         if (bs->renegotiate_count > 0) {
 189             bs->byte_count += *written;
 190             if (bs->byte_count > bs->renegotiate_count) {
 191                 bs->byte_count = 0;
 192                 bs->num_renegotiates++;
 193                 SSL_renegotiate(ssl);
 194                 r = 1;
 195             }
 196         }
 197         if ((bs->renegotiate_timeout > 0) && (!r)) {
 198             unsigned long tm;
 199
 200             tm = (unsigned long)time(NULL);
 201             if (tm > bs->last_time + bs->renegotiate_timeout) {
 202                 bs->last_time = tm;
 203                 bs->num_renegotiates++;
 204                 SSL_renegotiate(ssl);
 205             }
 206         }
 207         break;
 208     case SSL_ERROR_WANT_WRITE:
 209         BIO_set_retry_write(b);
 210         break;
 211     case SSL_ERROR_WANT_READ:
 212         BIO_set_retry_read(b);
 213         break;
 214     case SSL_ERROR_WANT_X509_LOOKUP:
 215         BIO_set_retry_special(b);
 216         retry_reason = BIO_RR_SSL_X509_LOOKUP;
 217         break;
 218     case SSL_ERROR_WANT_CONNECT:
 219         BIO_set_retry_special(b);
 220         retry_reason = BIO_RR_CONNECT;
 221     case SSL_ERROR_SYSCALL:
 222     case SSL_ERROR_SSL:
 223     default:
 224         break;
 225     }
 226
 227     BIO_set_retry_reason(b, retry_reason);
 228
 229     return ret;
 230 }
 231
 232 static long ssl_ctrl(BIO *b, int cmd, long num, void *ptr)
 233 {
 234     SSL **sslp, *ssl;
 235     BIO_SSL *bs, *dbs;
 236     BIO *dbio, *bio;
 237     long ret = 1;
 238     BIO *next;
 239
 240     bs = BIO_get_data(b);
 241     next = BIO_next(b);
 242     ssl = bs->ssl;
 243     if ((ssl == NULL) && (cmd != BIO_C_SET_SSL))
 244         return (0);
 245     switch (cmd) {
 246     case BIO_CTRL_RESET:
 247         SSL_shutdown(ssl);
 248
 249         if (ssl->handshake_func == ssl->method->ssl_connect)
 250             SSL_set_connect_state(ssl);
 251         else if (ssl->handshake_func == ssl->method->ssl_accept)
 252             SSL_set_accept_state(ssl);
 253
 254         if (!SSL_clear(ssl)) {
 255             ret = 0;
 256             break;
 257         }
 258
 259         if (next != NULL)
 260             ret = BIO_ctrl(next, cmd, num, ptr);
 261         else if (ssl->rbio != NULL)
 262             ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
 263         else
 264             ret = 1;
 265         break;
 266     case BIO_CTRL_INFO:
 267         ret = 0;
 268         break;
 269     case BIO_C_SSL_MODE:
 270         if (num)                /* client mode */
 271             SSL_set_connect_state(ssl);
 272         else
 273             SSL_set_accept_state(ssl);
 274         break;
 275     case BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT:
 276         ret = bs->renegotiate_timeout;
 277         if (num < 60)
 278             num = 5;
 279         bs->renegotiate_timeout = (unsigned long)num;
 280         bs->last_time = (unsigned long)time(NULL);
 281         break;
 282     case BIO_C_SET_SSL_RENEGOTIATE_BYTES:
 283         ret = bs->renegotiate_count;
 284         if ((long)num >= 512)
 285             bs->renegotiate_count = (unsigned long)num;
 286         break;
 287     case BIO_C_GET_SSL_NUM_RENEGOTIATES:
 288         ret = bs->num_renegotiates;
 289         break;
 290     case BIO_C_SET_SSL:
 291         if (ssl != NULL) {
 292             ssl_free(b);
 293             if (!ssl_new(b))
 294                 return 0;
 295         }
 296         BIO_set_shutdown(b, num);
 297         ssl = (SSL *)ptr;
 298         bs->ssl = ssl;
 299         bio = SSL_get_rbio(ssl);
 300         if (bio != NULL) {
 301             if (next != NULL)
 302                 BIO_push(bio, next);
 303             BIO_set_next(b, bio);
 304             BIO_up_ref(bio);
 305         }
 306         BIO_set_init(b, 1);
 307         break;
 308     case BIO_C_GET_SSL:
 309         if (ptr != NULL) {
 310             sslp = (SSL **)ptr;
 311             *sslp = ssl;
 312         } else
 313             ret = 0;
 314         break;
 315     case BIO_CTRL_GET_CLOSE:
 316         ret = BIO_get_shutdown(b);
 317         break;
 318     case BIO_CTRL_SET_CLOSE:
 319         BIO_set_shutdown(b, (int)num);
 320         break;
 321     case BIO_CTRL_WPENDING:
 322         ret = BIO_ctrl(ssl->wbio, cmd, num, ptr);
 323         break;
 324     case BIO_CTRL_PENDING:
 325         ret = SSL_pending(ssl);
 326         if (ret == 0)
 327             ret = BIO_pending(ssl->rbio);
 328         break;
 329     case BIO_CTRL_FLUSH:
 330         BIO_clear_retry_flags(b);
 331         ret = BIO_ctrl(ssl->wbio, cmd, num, ptr);
 332         BIO_copy_next_retry(b);
 333         break;
 334     case BIO_CTRL_PUSH:
 335         if ((next != NULL) && (next != ssl->rbio)) {
 336             /*
 337              * We are going to pass ownership of next to the SSL object...but
 338              * we don't own a reference to pass yet - so up ref
 339              */
 340             BIO_up_ref(next);
 341             SSL_set_bio(ssl, next, next);
 342         }
 343         break;
 344     case BIO_CTRL_POP:
 345         /* Only detach if we are the BIO explicitly being popped */
 346         if (b == ptr) {
 347             /* This will clear the reference we obtained during push */
 348             SSL_set_bio(ssl, NULL, NULL);
 349         }
 350         break;
 351     case BIO_C_DO_STATE_MACHINE:
 352         BIO_clear_retry_flags(b);
 353
 354         BIO_set_retry_reason(b, 0);
 355         ret = (int)SSL_do_handshake(ssl);
 356
 357         switch (SSL_get_error(ssl, (int)ret)) {
 358         case SSL_ERROR_WANT_READ:
 359             BIO_set_flags(b, BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY);
 360             break;
 361         case SSL_ERROR_WANT_WRITE:
 362             BIO_set_flags(b, BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY);
 363             break;
 364         case SSL_ERROR_WANT_CONNECT:
 365             BIO_set_flags(b, BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY);
 366             BIO_set_retry_reason(b, BIO_get_retry_reason(next));
 367             break;
 368         case SSL_ERROR_WANT_X509_LOOKUP:
 369             BIO_set_retry_special(b);
 370             BIO_set_retry_reason(b, BIO_RR_SSL_X509_LOOKUP);
 371             break;
 372         default:
 373             break;
 374         }
 375         break;
 376     case BIO_CTRL_DUP:
 377         dbio = (BIO *)ptr;
 378         dbs = BIO_get_data(dbio);
 379         SSL_free(dbs->ssl);
 380         dbs->ssl = SSL_dup(ssl);
 381         dbs->num_renegotiates = bs->num_renegotiates;
 382         dbs->renegotiate_count = bs->renegotiate_count;
 383         dbs->byte_count = bs->byte_count;
 384         dbs->renegotiate_timeout = bs->renegotiate_timeout;
 385         dbs->last_time = bs->last_time;
 386         ret = (dbs->ssl != NULL);
 387         break;
 388     case BIO_C_GET_FD:
 389         ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
 390         break;
 391     case BIO_CTRL_SET_CALLBACK:
 392         {
 393 #if 0                           /* FIXME: Should this be used? -- Richard
 394                                  * Levitte */
 395             SSLerr(SSL_F_SSL_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 396             ret = -1;
 397 #else
 398             ret = 0;
 399 #endif
 400         }
 401         break;
 402     case BIO_CTRL_GET_CALLBACK:
 403         {
 404             void (**fptr) (const SSL *xssl, int type, int val);
 405
 406             fptr = (void (**)(const SSL *xssl, int type, int val))ptr;
 407             *fptr = SSL_get_info_callback(ssl);
 408         }
 409         break;
 410     default:
 411         ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
 412         break;
 413     }
 414     return (ret);
 415 }
 416
 417 static long ssl_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
 418 {
 419     SSL *ssl;
 420     BIO_SSL *bs;
 421     long ret = 1;
 422
 423     bs = BIO_get_data(b);
 424     ssl = bs->ssl;
 425     switch (cmd) {
 426     case BIO_CTRL_SET_CALLBACK:
 427         {
 428             /*
 429              * FIXME: setting this via a completely different prototype seems
 430              * like a crap idea
 431              */
 432             SSL_set_info_callback(ssl, (void (*)(const SSL *, int, int))fp);
 433         }
 434         break;
 435     default:
 436         ret = BIO_callback_ctrl(ssl->rbio, cmd, fp);
 437         break;
 438     }
 439     return (ret);
 440 }
 441
 442 static int ssl_puts(BIO *bp, const char *str)
 443 {
 444     int n, ret;
 445
 446     n = strlen(str);
 447     ret = BIO_write(bp, str, n);
 448     return (ret);
 449 }
 450
 451 BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx)
 452 {
 453 #ifndef OPENSSL_NO_SOCK
 454     BIO *ret = NULL, *buf = NULL, *ssl = NULL;
 455
 456     if ((buf = BIO_new(BIO_f_buffer())) == NULL)
 457         return (NULL);
 458     if ((ssl = BIO_new_ssl_connect(ctx)) == NULL)
 459         goto err;
 460     if ((ret = BIO_push(buf, ssl)) == NULL)
 461         goto err;
 462     return (ret);
 463  err:
 464     BIO_free(buf);
 465     BIO_free(ssl);
 466 #endif
 467     return (NULL);
 468 }
 469
 470 BIO *BIO_new_ssl_connect(SSL_CTX *ctx)
 471 {
 472 #ifndef OPENSSL_NO_SOCK
 473     BIO *ret = NULL, *con = NULL, *ssl = NULL;
 474
 475     if ((con = BIO_new(BIO_s_connect())) == NULL)
 476         return (NULL);
 477     if ((ssl = BIO_new_ssl(ctx, 1)) == NULL)
 478         goto err;
 479     if ((ret = BIO_push(ssl, con)) == NULL)
 480         goto err;
 481     return (ret);
 482  err:
 483     BIO_free(con);
 484 #endif
 485     return (NULL);
 486 }
 487
 488 BIO *BIO_new_ssl(SSL_CTX *ctx, int client)
 489 {
 490     BIO *ret;
 491     SSL *ssl;
 492
 493     if ((ret = BIO_new(BIO_f_ssl())) == NULL)
 494         return (NULL);
 495     if ((ssl = SSL_new(ctx)) == NULL) {
 496         BIO_free(ret);
 497         return (NULL);
 498     }
 499     if (client)
 500         SSL_set_connect_state(ssl);
 501     else
 502         SSL_set_accept_state(ssl);
 503
 504     BIO_set_ssl(ret, ssl, BIO_CLOSE);
 505     return (ret);
 506 }
 507
 508 int BIO_ssl_copy_session_id(BIO *t, BIO *f)
 509 {
 510     BIO_SSL *tdata, *fdata;
 511     t = BIO_find_type(t, BIO_TYPE_SSL);
 512     f = BIO_find_type(f, BIO_TYPE_SSL);
 513     if ((t == NULL) || (f == NULL))
 514         return 0;
 515     tdata = BIO_get_data(t);
 516     fdata = BIO_get_data(f);
 517     if ((tdata->ssl == NULL) || (fdata->ssl == NULL))
 518         return (0);
 519     if (!SSL_copy_session_id(tdata->ssl, (fdata->ssl)))
 520         return 0;
 521     return (1);
 522 }
 523
 524 void BIO_ssl_shutdown(BIO *b)
 525 {
 526     SSL *s;
 527
 528     b = BIO_find_type(b, BIO_TYPE_SSL);
 529     if (b == NULL)
 530         return;
 531
 532     s = BIO_get_data(b);
 533     SSL_shutdown(s);
 534 }