Home | History | Annotate | Download | only in bio
      1 /* Copyright (C) 1995-1998 Eric Young (eay (at) cryptsoft.com)
      2  * All rights reserved.
      3  *
      4  * This package is an SSL implementation written
      5  * by Eric Young (eay (at) cryptsoft.com).
      6  * The implementation was written so as to conform with Netscapes SSL.
      7  *
      8  * This library is free for commercial and non-commercial use as long as
      9  * the following conditions are aheared to.  The following conditions
     10  * apply to all code found in this distribution, be it the RC4, RSA,
     11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
     12  * included with this distribution is covered by the same copyright terms
     13  * except that the holder is Tim Hudson (tjh (at) cryptsoft.com).
     14  *
     15  * Copyright remains Eric Young's, and as such any Copyright notices in
     16  * the code are not to be removed.
     17  * If this package is used in a product, Eric Young should be given attribution
     18  * as the author of the parts of the library used.
     19  * This can be in the form of a textual message at program startup or
     20  * in documentation (online or textual) provided with the package.
     21  *
     22  * Redistribution and use in source and binary forms, with or without
     23  * modification, are permitted provided that the following conditions
     24  * are met:
     25  * 1. Redistributions of source code must retain the copyright
     26  *    notice, this list of conditions and the following disclaimer.
     27  * 2. Redistributions in binary form must reproduce the above copyright
     28  *    notice, this list of conditions and the following disclaimer in the
     29  *    documentation and/or other materials provided with the distribution.
     30  * 3. All advertising materials mentioning features or use of this software
     31  *    must display the following acknowledgement:
     32  *    "This product includes cryptographic software written by
     33  *     Eric Young (eay (at) cryptsoft.com)"
     34  *    The word 'cryptographic' can be left out if the rouines from the library
     35  *    being used are not cryptographic related :-).
     36  * 4. If you include any Windows specific code (or a derivative thereof) from
     37  *    the apps directory (application code) you must include an acknowledgement:
     38  *    "This product includes software written by Tim Hudson (tjh (at) cryptsoft.com)"
     39  *
     40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
     41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     50  * SUCH DAMAGE.
     51  *
     52  * The licence and distribution terms for any publically available version or
     53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
     54  * copied and put under another distribution licence
     55  * [including the GNU Public Licence.] */
     56 
     57 #include <openssl/bio.h>
     58 
     59 #include <assert.h>
     60 #include <errno.h>
     61 #include <limits.h>
     62 #include <string.h>
     63 
     64 #include <openssl/err.h>
     65 #include <openssl/mem.h>
     66 #include <openssl/thread.h>
     67 
     68 #include "../internal.h"
     69 
     70 
     71 /* BIO_set initialises a BIO structure to have the given type and sets the
     72  * reference count to one. It returns one on success or zero on error. */
     73 static int bio_set(BIO *bio, const BIO_METHOD *method) {
     74   /* This function can be called with a stack allocated |BIO| so we have to
     75    * assume that the contents of |BIO| are arbitary. This also means that it'll
     76    * leak memory if you call |BIO_set| twice on the same BIO. */
     77   memset(bio, 0, sizeof(BIO));
     78 
     79   bio->method = method;
     80   bio->shutdown = 1;
     81   bio->references = 1;
     82 
     83   if (method->create != NULL && !method->create(bio)) {
     84     return 0;
     85   }
     86 
     87   return 1;
     88 }
     89 
     90 BIO *BIO_new(const BIO_METHOD *method) {
     91   BIO *ret = OPENSSL_malloc(sizeof(BIO));
     92   if (ret == NULL) {
     93     OPENSSL_PUT_ERROR(BIO, ERR_R_MALLOC_FAILURE);
     94     return NULL;
     95   }
     96 
     97   if (!bio_set(ret, method)) {
     98     OPENSSL_free(ret);
     99     ret = NULL;
    100   }
    101 
    102   return ret;
    103 }
    104 
    105 int BIO_free(BIO *bio) {
    106   BIO *next_bio;
    107 
    108   for (; bio != NULL; bio = next_bio) {
    109     if (!CRYPTO_refcount_dec_and_test_zero(&bio->references)) {
    110       return 0;
    111     }
    112 
    113     if (bio->callback != NULL) {
    114       int i = (int)bio->callback(bio, BIO_CB_FREE, NULL, 0, 0, 1);
    115       if (i <= 0) {
    116         return i;
    117       }
    118     }
    119 
    120     next_bio = BIO_pop(bio);
    121 
    122     if (bio->method != NULL && bio->method->destroy != NULL) {
    123       bio->method->destroy(bio);
    124     }
    125 
    126     OPENSSL_free(bio);
    127   }
    128   return 1;
    129 }
    130 
    131 BIO *BIO_up_ref(BIO *bio) {
    132   CRYPTO_refcount_inc(&bio->references);
    133   return bio;
    134 }
    135 
    136 void BIO_vfree(BIO *bio) {
    137   BIO_free(bio);
    138 }
    139 
    140 void BIO_free_all(BIO *bio) {
    141   BIO_free(bio);
    142 }
    143 
    144 static int bio_io(BIO *bio, void *buf, int len, size_t method_offset,
    145                   int callback_flags, size_t *num) {
    146   int i;
    147   typedef int (*io_func_t)(BIO *, char *, int);
    148   io_func_t io_func = NULL;
    149 
    150   if (bio != NULL && bio->method != NULL) {
    151     io_func =
    152         *((const io_func_t *)(((const uint8_t *)bio->method) + method_offset));
    153   }
    154 
    155   if (io_func == NULL) {
    156     OPENSSL_PUT_ERROR(BIO, BIO_R_UNSUPPORTED_METHOD);
    157     return -2;
    158   }
    159 
    160   if (bio->callback != NULL) {
    161     i = (int) bio->callback(bio, callback_flags, buf, len, 0L, 1L);
    162     if (i <= 0) {
    163       return i;
    164     }
    165   }
    166 
    167   if (!bio->init) {
    168     OPENSSL_PUT_ERROR(BIO, BIO_R_UNINITIALIZED);
    169     return -2;
    170   }
    171 
    172   i = 0;
    173   if (buf != NULL && len > 0) {
    174     i = io_func(bio, buf, len);
    175   }
    176 
    177   if (i > 0) {
    178     *num += i;
    179   }
    180 
    181   if (bio->callback != NULL) {
    182     i = (int)(bio->callback(bio, callback_flags | BIO_CB_RETURN, buf, len, 0L,
    183                             (long)i));
    184   }
    185 
    186   return i;
    187 }
    188 
    189 int BIO_read(BIO *bio, void *buf, int len) {
    190   return bio_io(bio, buf, len, offsetof(BIO_METHOD, bread), BIO_CB_READ,
    191                 &bio->num_read);
    192 }
    193 
    194 int BIO_gets(BIO *bio, char *buf, int len) {
    195   return bio_io(bio, buf, len, offsetof(BIO_METHOD, bgets), BIO_CB_GETS,
    196                 &bio->num_read);
    197 }
    198 
    199 int BIO_write(BIO *bio, const void *in, int inl) {
    200   return bio_io(bio, (char *)in, inl, offsetof(BIO_METHOD, bwrite),
    201                 BIO_CB_WRITE, &bio->num_write);
    202 }
    203 
    204 int BIO_puts(BIO *bio, const char *in) {
    205   return BIO_write(bio, in, strlen(in));
    206 }
    207 
    208 int BIO_flush(BIO *bio) {
    209   return BIO_ctrl(bio, BIO_CTRL_FLUSH, 0, NULL);
    210 }
    211 
    212 long BIO_ctrl(BIO *bio, int cmd, long larg, void *parg) {
    213   long ret;
    214 
    215   if (bio == NULL) {
    216     return 0;
    217   }
    218 
    219   if (bio->method == NULL || bio->method->ctrl == NULL) {
    220     OPENSSL_PUT_ERROR(BIO, BIO_R_UNSUPPORTED_METHOD);
    221     return -2;
    222   }
    223 
    224   if (bio->callback != NULL) {
    225     ret = bio->callback(bio, BIO_CB_CTRL, parg, cmd, larg, 1);
    226     if (ret <= 0) {
    227       return ret;
    228     }
    229   }
    230 
    231   ret = bio->method->ctrl(bio, cmd, larg, parg);
    232 
    233   if (bio->callback != NULL) {
    234     ret = bio->callback(bio, BIO_CB_CTRL | BIO_CB_RETURN, parg, cmd, larg, ret);
    235   }
    236 
    237   return ret;
    238 }
    239 
    240 char *BIO_ptr_ctrl(BIO *b, int cmd, long larg) {
    241   char *p = NULL;
    242 
    243   if (BIO_ctrl(b, cmd, larg, (void *)&p) <= 0) {
    244     return NULL;
    245   }
    246 
    247   return p;
    248 }
    249 
    250 long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg) {
    251   int i = iarg;
    252 
    253   return BIO_ctrl(b, cmd, larg, (void *)&i);
    254 }
    255 
    256 int BIO_reset(BIO *bio) {
    257   return BIO_ctrl(bio, BIO_CTRL_RESET, 0, NULL);
    258 }
    259 
    260 void BIO_set_flags(BIO *bio, int flags) {
    261   bio->flags |= flags;
    262 }
    263 
    264 int BIO_test_flags(const BIO *bio, int flags) {
    265   return bio->flags & flags;
    266 }
    267 
    268 int BIO_should_read(const BIO *bio) {
    269   return BIO_test_flags(bio, BIO_FLAGS_READ);
    270 }
    271 
    272 int BIO_should_write(const BIO *bio) {
    273   return BIO_test_flags(bio, BIO_FLAGS_WRITE);
    274 }
    275 
    276 int BIO_should_retry(const BIO *bio) {
    277   return BIO_test_flags(bio, BIO_FLAGS_SHOULD_RETRY);
    278 }
    279 
    280 int BIO_should_io_special(const BIO *bio) {
    281   return BIO_test_flags(bio, BIO_FLAGS_IO_SPECIAL);
    282 }
    283 
    284 int BIO_get_retry_reason(const BIO *bio) { return bio->retry_reason; }
    285 
    286 void BIO_clear_flags(BIO *bio, int flags) {
    287   bio->flags &= ~flags;
    288 }
    289 
    290 void BIO_set_retry_read(BIO *bio) {
    291   bio->flags |= BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY;
    292 }
    293 
    294 void BIO_set_retry_write(BIO *bio) {
    295   bio->flags |= BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY;
    296 }
    297 
    298 static const int kRetryFlags = BIO_FLAGS_RWS | BIO_FLAGS_SHOULD_RETRY;
    299 
    300 int BIO_get_retry_flags(BIO *bio) {
    301   return bio->flags & kRetryFlags;
    302 }
    303 
    304 void BIO_clear_retry_flags(BIO *bio) {
    305   bio->flags &= ~kRetryFlags;
    306   bio->retry_reason = 0;
    307 }
    308 
    309 int BIO_method_type(const BIO *bio) { return bio->method->type; }
    310 
    311 void BIO_copy_next_retry(BIO *bio) {
    312   BIO_clear_retry_flags(bio);
    313   BIO_set_flags(bio, BIO_get_retry_flags(bio->next_bio));
    314   bio->retry_reason = bio->next_bio->retry_reason;
    315 }
    316 
    317 long BIO_callback_ctrl(BIO *bio, int cmd, bio_info_cb fp) {
    318   long ret;
    319   bio_info_cb cb;
    320 
    321   if (bio == NULL) {
    322     return 0;
    323   }
    324 
    325   if (bio->method == NULL || bio->method->callback_ctrl == NULL) {
    326     OPENSSL_PUT_ERROR(BIO, BIO_R_UNSUPPORTED_METHOD);
    327     return 0;
    328   }
    329 
    330   cb = bio->callback;
    331 
    332   if (cb != NULL) {
    333     ret = cb(bio, BIO_CB_CTRL, (void *)&fp, cmd, 0, 1L);
    334     if (ret <= 0) {
    335       return ret;
    336     }
    337   }
    338 
    339   ret = bio->method->callback_ctrl(bio, cmd, fp);
    340 
    341   if (cb != NULL) {
    342     ret = cb(bio, BIO_CB_CTRL | BIO_CB_RETURN, (void *)&fp, cmd, 0, ret);
    343   }
    344 
    345   return ret;
    346 }
    347 
    348 size_t BIO_pending(const BIO *bio) {
    349   return BIO_ctrl((BIO *) bio, BIO_CTRL_PENDING, 0, NULL);
    350 }
    351 
    352 size_t BIO_ctrl_pending(const BIO *bio) {
    353   return BIO_pending(bio);
    354 }
    355 
    356 size_t BIO_wpending(const BIO *bio) {
    357   return BIO_ctrl((BIO *) bio, BIO_CTRL_WPENDING, 0, NULL);
    358 }
    359 
    360 int BIO_set_close(BIO *bio, int close_flag) {
    361   return BIO_ctrl(bio, BIO_CTRL_SET_CLOSE, close_flag, NULL);
    362 }
    363 
    364 void BIO_set_callback(BIO *bio, bio_info_cb callback_func) {
    365   bio->callback = callback_func;
    366 }
    367 
    368 void BIO_set_callback_arg(BIO *bio, char *arg) {
    369   bio->cb_arg = arg;
    370 }
    371 
    372 char *BIO_get_callback_arg(const BIO *bio) {
    373   return bio->cb_arg;
    374 }
    375 
    376 OPENSSL_EXPORT size_t BIO_number_read(const BIO *bio) {
    377   return bio->num_read;
    378 }
    379 
    380 OPENSSL_EXPORT size_t BIO_number_written(const BIO *bio) {
    381   return bio->num_write;
    382 }
    383 
    384 BIO *BIO_push(BIO *bio, BIO *appended_bio) {
    385   BIO *last_bio;
    386 
    387   if (bio == NULL) {
    388     return bio;
    389   }
    390 
    391   last_bio = bio;
    392   while (last_bio->next_bio != NULL) {
    393     last_bio = last_bio->next_bio;
    394   }
    395 
    396   last_bio->next_bio = appended_bio;
    397   return bio;
    398 }
    399 
    400 BIO *BIO_pop(BIO *bio) {
    401   BIO *ret;
    402 
    403   if (bio == NULL) {
    404     return NULL;
    405   }
    406   ret = bio->next_bio;
    407   bio->next_bio = NULL;
    408   return ret;
    409 }
    410 
    411 BIO *BIO_next(BIO *bio) {
    412   if (!bio) {
    413     return NULL;
    414   }
    415   return bio->next_bio;
    416 }
    417 
    418 BIO *BIO_find_type(BIO *bio, int type) {
    419   int method_type, mask;
    420 
    421   if (!bio) {
    422     return NULL;
    423   }
    424   mask = type & 0xff;
    425 
    426   do {
    427     if (bio->method != NULL) {
    428       method_type = bio->method->type;
    429 
    430       if (!mask) {
    431         if (method_type & type) {
    432           return bio;
    433         }
    434       } else if (method_type == type) {
    435         return bio;
    436       }
    437     }
    438     bio = bio->next_bio;
    439   } while (bio != NULL);
    440 
    441   return NULL;
    442 }
    443 
    444 int BIO_indent(BIO *bio, unsigned indent, unsigned max_indent) {
    445   if (indent > max_indent) {
    446     indent = max_indent;
    447   }
    448 
    449   while (indent--) {
    450     if (BIO_puts(bio, " ") != 1) {
    451       return 0;
    452     }
    453   }
    454   return 1;
    455 }
    456 
    457 static int print_bio(const char *str, size_t len, void *bio) {
    458   return BIO_write((BIO *)bio, str, len);
    459 }
    460 
    461 void BIO_print_errors(BIO *bio) {
    462   ERR_print_errors_cb(print_bio, bio);
    463 }
    464 
    465 void ERR_print_errors(BIO *bio) {
    466   BIO_print_errors(bio);
    467 }
    468 
    469 /* bio_read_all reads everything from |bio| and prepends |prefix| to it. On
    470  * success, |*out| is set to an allocated buffer (which should be freed with
    471  * |OPENSSL_free|), |*out_len| is set to its length and one is returned. The
    472  * buffer will contain |prefix| followed by the contents of |bio|. On failure,
    473  * zero is returned.
    474  *
    475  * The function will fail if the size of the output would equal or exceed
    476  * |max_len|. */
    477 static int bio_read_all(BIO *bio, uint8_t **out, size_t *out_len,
    478                         const uint8_t *prefix, size_t prefix_len,
    479                         size_t max_len) {
    480   static const size_t kChunkSize = 4096;
    481 
    482   size_t len = prefix_len + kChunkSize;
    483   if (len > max_len) {
    484     len = max_len;
    485   }
    486   if (len < prefix_len) {
    487     return 0;
    488   }
    489   *out = OPENSSL_malloc(len);
    490   if (*out == NULL) {
    491     return 0;
    492   }
    493   memcpy(*out, prefix, prefix_len);
    494   size_t done = prefix_len;
    495 
    496   for (;;) {
    497     if (done == len) {
    498       OPENSSL_free(*out);
    499       return 0;
    500     }
    501     const size_t todo = len - done;
    502     assert(todo < INT_MAX);
    503     const int n = BIO_read(bio, *out + done, todo);
    504     if (n == 0) {
    505       *out_len = done;
    506       return 1;
    507     } else if (n == -1) {
    508       OPENSSL_free(*out);
    509       return 0;
    510     }
    511 
    512     done += n;
    513     if (len < max_len && len - done < kChunkSize / 2) {
    514       len += kChunkSize;
    515       if (len < kChunkSize || len > max_len) {
    516         len = max_len;
    517       }
    518       uint8_t *new_buf = OPENSSL_realloc(*out, len);
    519       if (new_buf == NULL) {
    520         OPENSSL_free(*out);
    521         return 0;
    522       }
    523       *out = new_buf;
    524     }
    525   }
    526 }
    527 
    528 int BIO_read_asn1(BIO *bio, uint8_t **out, size_t *out_len, size_t max_len) {
    529   uint8_t header[6];
    530 
    531   static const size_t kInitialHeaderLen = 2;
    532   if (BIO_read(bio, header, kInitialHeaderLen) != (int) kInitialHeaderLen) {
    533     return 0;
    534   }
    535 
    536   const uint8_t tag = header[0];
    537   const uint8_t length_byte = header[1];
    538 
    539   if ((tag & 0x1f) == 0x1f) {
    540     /* Long form tags are not supported. */
    541     return 0;
    542   }
    543 
    544   size_t len, header_len;
    545   if ((length_byte & 0x80) == 0) {
    546     /* Short form length. */
    547     len = length_byte;
    548     header_len = kInitialHeaderLen;
    549   } else {
    550     const size_t num_bytes = length_byte & 0x7f;
    551 
    552     if ((tag & 0x20 /* constructed */) != 0 && num_bytes == 0) {
    553       /* indefinite length. */
    554       return bio_read_all(bio, out, out_len, header, kInitialHeaderLen,
    555                           max_len);
    556     }
    557 
    558     if (num_bytes == 0 || num_bytes > 4) {
    559       return 0;
    560     }
    561 
    562     if (BIO_read(bio, header + kInitialHeaderLen, num_bytes) !=
    563         (int)num_bytes) {
    564       return 0;
    565     }
    566     header_len = kInitialHeaderLen + num_bytes;
    567 
    568     uint32_t len32 = 0;
    569     unsigned i;
    570     for (i = 0; i < num_bytes; i++) {
    571       len32 <<= 8;
    572       len32 |= header[kInitialHeaderLen + i];
    573     }
    574 
    575     if (len32 < 128) {
    576       /* Length should have used short-form encoding. */
    577       return 0;
    578     }
    579 
    580     if ((len32 >> ((num_bytes-1)*8)) == 0) {
    581       /* Length should have been at least one byte shorter. */
    582       return 0;
    583     }
    584 
    585     len = len32;
    586   }
    587 
    588   if (len + header_len < len ||
    589       len + header_len > max_len ||
    590       len > INT_MAX) {
    591     return 0;
    592   }
    593   len += header_len;
    594   *out_len = len;
    595 
    596   *out = OPENSSL_malloc(len);
    597   if (*out == NULL) {
    598     return 0;
    599   }
    600   memcpy(*out, header, header_len);
    601   if (BIO_read(bio, (*out) + header_len, len - header_len) !=
    602       (int) (len - header_len)) {
    603     OPENSSL_free(*out);
    604     return 0;
    605   }
    606 
    607   return 1;
    608 }
    609