crypto/asn1/a_d2i_fp.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 <limits.h>
  12 #include "internal/cryptlib.h"
  13 #include "internal/numbers.h"
  14 #include <openssl/buffer.h>
  15 #include <openssl/asn1.h>
  16
  17 static int asn1_d2i_read_bio(BIO *in, BUF_MEM **pb);
  18
  19 #ifndef NO_OLD_ASN1
  20 # ifndef OPENSSL_NO_STDIO
  21
  22 void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x)
  23 {
  24     BIO *b;
  25     void *ret;
  26
  27     if ((b = BIO_new(BIO_s_file())) == NULL) {
  28         ASN1err(ASN1_F_ASN1_D2I_FP, ERR_R_BUF_LIB);
  29         return (NULL);
  30     }
  31     BIO_set_fp(b, in, BIO_NOCLOSE);
  32     ret = ASN1_d2i_bio(xnew, d2i, b, x);
  33     BIO_free(b);
  34     return (ret);
  35 }
  36 # endif
  37
  38 void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x)
  39 {
  40     BUF_MEM *b = NULL;
  41     const unsigned char *p;
  42     void *ret = NULL;
  43     int len;
  44
  45     len = asn1_d2i_read_bio(in, &b);
  46     if (len < 0)
  47         goto err;
  48
  49     p = (unsigned char *)b->data;
  50     ret = d2i(x, &p, len);
  51  err:
  52     BUF_MEM_free(b);
  53     return (ret);
  54 }
  55
  56 #endif
  57
  58 void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x)
  59 {
  60     BUF_MEM *b = NULL;
  61     const unsigned char *p;
  62     void *ret = NULL;
  63     int len;
  64
  65     len = asn1_d2i_read_bio(in, &b);
  66     if (len < 0)
  67         goto err;
  68
  69     p = (const unsigned char *)b->data;
  70     ret = ASN1_item_d2i(x, &p, len, it);
  71  err:
  72     BUF_MEM_free(b);
  73     return (ret);
  74 }
  75
  76 #ifndef OPENSSL_NO_STDIO
  77 void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x)
  78 {
  79     BIO *b;
  80     char *ret;
  81
  82     if ((b = BIO_new(BIO_s_file())) == NULL) {
  83         ASN1err(ASN1_F_ASN1_ITEM_D2I_FP, ERR_R_BUF_LIB);
  84         return (NULL);
  85     }
  86     BIO_set_fp(b, in, BIO_NOCLOSE);
  87     ret = ASN1_item_d2i_bio(it, b, x);
  88     BIO_free(b);
  89     return (ret);
  90 }
  91 #endif
  92
  93 #define HEADER_SIZE   8
  94 #define ASN1_CHUNK_INITIAL_SIZE (16 * 1024)
  95 static int asn1_d2i_read_bio(BIO *in, BUF_MEM **pb)
  96 {
  97     BUF_MEM *b;
  98     unsigned char *p;
  99     int i;
 100     size_t want = HEADER_SIZE;
 101     uint32_t eos = 0;
 102     size_t off = 0;
 103     size_t len = 0;
 104
 105     const unsigned char *q;
 106     long slen;
 107     int inf, tag, xclass;
 108
 109     b = BUF_MEM_new();
 110     if (b == NULL) {
 111         ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE);
 112         return -1;
 113     }
 114
 115     ERR_clear_error();
 116     for (;;) {
 117         if (want >= (len - off)) {
 118             want -= (len - off);
 119
 120             if (len + want < len || !BUF_MEM_grow_clean(b, len + want)) {
 121                 ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE);
 122                 goto err;
 123             }
 124             i = BIO_read(in, &(b->data[len]), want);
 125             if ((i < 0) && ((len - off) == 0)) {
 126                 ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_NOT_ENOUGH_DATA);
 127                 goto err;
 128             }
 129             if (i > 0) {
 130                 if (len + i < len) {
 131                     ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
 132                     goto err;
 133                 }
 134                 len += i;
 135             }
 136         }
 137         /* else data already loaded */
 138
 139         p = (unsigned char *)&(b->data[off]);
 140         q = p;
 141         inf = ASN1_get_object(&q, &slen, &tag, &xclass, len - off);
 142         if (inf & 0x80) {
 143             unsigned long e;
 144
 145             e = ERR_GET_REASON(ERR_peek_error());
 146             if (e != ASN1_R_TOO_LONG)
 147                 goto err;
 148             else
 149                 ERR_clear_error(); /* clear error */
 150         }
 151         i = q - p;            /* header length */
 152         off += i;               /* end of data */
 153
 154         if (inf & 1) {
 155             /* no data body so go round again */
 156             if (eos == UINT32_MAX) {
 157                 ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_HEADER_TOO_LONG);
 158                 goto err;
 159             }
 160             eos++;
 161             want = HEADER_SIZE;
 162         } else if (eos && (slen == 0) && (tag == V_ASN1_EOC)) {
 163             /* eos value, so go back and read another header */
 164             eos--;
 165             if (eos == 0)
 166                 break;
 167             else
 168                 want = HEADER_SIZE;
 169         } else {
 170             /* suck in slen bytes of data */
 171             want = slen;
 172             if (want > (len - off)) {
 173                 size_t chunk_max = ASN1_CHUNK_INITIAL_SIZE;
 174
 175                 want -= (len - off);
 176                 if (want > INT_MAX /* BIO_read takes an int length */  ||
 177                     len + want < len) {
 178                     ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
 179                     goto err;
 180                 }
 181                 while (want > 0) {
 182                     /*
 183                      * Read content in chunks of increasing size
 184                      * so we can return an error for EOF without
 185                      * having to allocate the entire content length
 186                      * in one go.
 187                      */
 188                     size_t chunk = want > chunk_max ? chunk_max : want;
 189
 190                     if (!BUF_MEM_grow_clean(b, len + chunk)) {
 191                         ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE);
 192                         goto err;
 193                     }
 194                     want -= chunk;
 195                     while (chunk > 0) {
 196                         i = BIO_read(in, &(b->data[len]), chunk);
 197                         if (i <= 0) {
 198                             ASN1err(ASN1_F_ASN1_D2I_READ_BIO,
 199                                     ASN1_R_NOT_ENOUGH_DATA);
 200                             goto err;
 201                         }
 202                     /*
 203                      * This can't overflow because |len+want| didn't
 204                      * overflow.
 205                      */
 206                         len += i;
 207                         chunk -= i;
 208                     }
 209                     if (chunk_max < INT_MAX/2)
 210                         chunk_max *= 2;
 211                 }
 212             }
 213             if (off + slen < off) {
 214                 ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
 215                 goto err;
 216             }
 217             off += slen;
 218             if (eos == 0) {
 219                 break;
 220             } else
 221                 want = HEADER_SIZE;
 222         }
 223     }
 224
 225     if (off > INT_MAX) {
 226         ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
 227         goto err;
 228     }
 229
 230     *pb = b;
 231     return off;
 232  err:
 233     BUF_MEM_free(b);
 234     return -1;
 235 }