"Fossies" - the Fresh Open Source Software Archive

Member "openssl-1.0.2q/crypto/asn1/a_d2i_fp.c" (20 Nov 2018, 9435 Bytes) of package /linux/misc/openssl-1.0.2q.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "a_d2i_fp.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 1.1.0g_vs_1.1.1-pre2.

    1 /* crypto/asn1/a_d2i_fp.c */
    2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
    3  * All rights reserved.
    4  *
    5  * This package is an SSL implementation written
    6  * by Eric Young (eay@cryptsoft.com).
    7  * The implementation was written so as to conform with Netscapes SSL.
    8  *
    9  * This library is free for commercial and non-commercial use as long as
   10  * the following conditions are aheared to.  The following conditions
   11  * apply to all code found in this distribution, be it the RC4, RSA,
   12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
   13  * included with this distribution is covered by the same copyright terms
   14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
   15  *
   16  * Copyright remains Eric Young's, and as such any Copyright notices in
   17  * the code are not to be removed.
   18  * If this package is used in a product, Eric Young should be given attribution
   19  * as the author of the parts of the library used.
   20  * This can be in the form of a textual message at program startup or
   21  * in documentation (online or textual) provided with the package.
   22  *
   23  * Redistribution and use in source and binary forms, with or without
   24  * modification, are permitted provided that the following conditions
   25  * are met:
   26  * 1. Redistributions of source code must retain the copyright
   27  *    notice, this list of conditions and the following disclaimer.
   28  * 2. Redistributions in binary form must reproduce the above copyright
   29  *    notice, this list of conditions and the following disclaimer in the
   30  *    documentation and/or other materials provided with the distribution.
   31  * 3. All advertising materials mentioning features or use of this software
   32  *    must display the following acknowledgement:
   33  *    "This product includes cryptographic software written by
   34  *     Eric Young (eay@cryptsoft.com)"
   35  *    The word 'cryptographic' can be left out if the rouines from the library
   36  *    being used are not cryptographic related :-).
   37  * 4. If you include any Windows specific code (or a derivative thereof) from
   38  *    the apps directory (application code) you must include an acknowledgement:
   39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
   40  *
   41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
   42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   51  * SUCH DAMAGE.
   52  *
   53  * The licence and distribution terms for any publically available version or
   54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
   55  * copied and put under another distribution licence
   56  * [including the GNU Public Licence.]
   57  */
   58 
   59 #include <stdio.h>
   60 #include <limits.h>
   61 #include "cryptlib.h"
   62 #include <openssl/buffer.h>
   63 #include <openssl/asn1_mac.h>
   64 
   65 static int asn1_d2i_read_bio(BIO *in, BUF_MEM **pb);
   66 
   67 #ifndef NO_OLD_ASN1
   68 # ifndef OPENSSL_NO_FP_API
   69 
   70 void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x)
   71 {
   72     BIO *b;
   73     void *ret;
   74 
   75     if ((b = BIO_new(BIO_s_file())) == NULL) {
   76         ASN1err(ASN1_F_ASN1_D2I_FP, ERR_R_BUF_LIB);
   77         return (NULL);
   78     }
   79     BIO_set_fp(b, in, BIO_NOCLOSE);
   80     ret = ASN1_d2i_bio(xnew, d2i, b, x);
   81     BIO_free(b);
   82     return (ret);
   83 }
   84 # endif
   85 
   86 void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x)
   87 {
   88     BUF_MEM *b = NULL;
   89     const unsigned char *p;
   90     void *ret = NULL;
   91     int len;
   92 
   93     len = asn1_d2i_read_bio(in, &b);
   94     if (len < 0)
   95         goto err;
   96 
   97     p = (unsigned char *)b->data;
   98     ret = d2i(x, &p, len);
   99  err:
  100     if (b != NULL)
  101         BUF_MEM_free(b);
  102     return (ret);
  103 }
  104 
  105 #endif
  106 
  107 void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x)
  108 {
  109     BUF_MEM *b = NULL;
  110     const unsigned char *p;
  111     void *ret = NULL;
  112     int len;
  113 
  114     len = asn1_d2i_read_bio(in, &b);
  115     if (len < 0)
  116         goto err;
  117 
  118     p = (const unsigned char *)b->data;
  119     ret = ASN1_item_d2i(x, &p, len, it);
  120  err:
  121     if (b != NULL)
  122         BUF_MEM_free(b);
  123     return (ret);
  124 }
  125 
  126 #ifndef OPENSSL_NO_FP_API
  127 void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x)
  128 {
  129     BIO *b;
  130     char *ret;
  131 
  132     if ((b = BIO_new(BIO_s_file())) == NULL) {
  133         ASN1err(ASN1_F_ASN1_ITEM_D2I_FP, ERR_R_BUF_LIB);
  134         return (NULL);
  135     }
  136     BIO_set_fp(b, in, BIO_NOCLOSE);
  137     ret = ASN1_item_d2i_bio(it, b, x);
  138     BIO_free(b);
  139     return (ret);
  140 }
  141 #endif
  142 
  143 #define HEADER_SIZE   8
  144 #define ASN1_CHUNK_INITIAL_SIZE (16 * 1024)
  145 static int asn1_d2i_read_bio(BIO *in, BUF_MEM **pb)
  146 {
  147     BUF_MEM *b;
  148     unsigned char *p;
  149     int i;
  150     ASN1_const_CTX c;
  151     size_t want = HEADER_SIZE;
  152     int eos = 0;
  153     size_t off = 0;
  154     size_t len = 0;
  155 
  156     b = BUF_MEM_new();
  157     if (b == NULL) {
  158         ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE);
  159         return -1;
  160     }
  161 
  162     ERR_clear_error();
  163     for (;;) {
  164         if (want >= (len - off)) {
  165             want -= (len - off);
  166 
  167             if (len + want < len || !BUF_MEM_grow_clean(b, len + want)) {
  168                 ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE);
  169                 goto err;
  170             }
  171             i = BIO_read(in, &(b->data[len]), want);
  172             if ((i < 0) && ((len - off) == 0)) {
  173                 ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_NOT_ENOUGH_DATA);
  174                 goto err;
  175             }
  176             if (i > 0) {
  177                 if (len + i < len) {
  178                     ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
  179                     goto err;
  180                 }
  181                 len += i;
  182             }
  183         }
  184         /* else data already loaded */
  185 
  186         p = (unsigned char *)&(b->data[off]);
  187         c.p = p;
  188         c.inf = ASN1_get_object(&(c.p), &(c.slen), &(c.tag), &(c.xclass),
  189                                 len - off);
  190         if (c.inf & 0x80) {
  191             unsigned long e;
  192 
  193             e = ERR_GET_REASON(ERR_peek_error());
  194             if (e != ASN1_R_TOO_LONG)
  195                 goto err;
  196             else
  197                 ERR_clear_error(); /* clear error */
  198         }
  199         i = c.p - p;            /* header length */
  200         off += i;               /* end of data */
  201 
  202         if (c.inf & 1) {
  203             /* no data body so go round again */
  204             eos++;
  205             if (eos < 0) {
  206                 ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_HEADER_TOO_LONG);
  207                 goto err;
  208             }
  209             want = HEADER_SIZE;
  210         } else if (eos && (c.slen == 0) && (c.tag == V_ASN1_EOC)) {
  211             /* eos value, so go back and read another header */
  212             eos--;
  213             if (eos <= 0)
  214                 break;
  215             else
  216                 want = HEADER_SIZE;
  217         } else {
  218             /* suck in c.slen bytes of data */
  219             want = c.slen;
  220             if (want > (len - off)) {
  221                 size_t chunk_max = ASN1_CHUNK_INITIAL_SIZE;
  222 
  223                 want -= (len - off);
  224                 if (want > INT_MAX /* BIO_read takes an int length */  ||
  225                     len + want < len) {
  226                     ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
  227                     goto err;
  228                 }
  229                 while (want > 0) {
  230                     /*
  231                      * Read content in chunks of increasing size
  232                      * so we can return an error for EOF without
  233                      * having to allocate the entire content length
  234                      * in one go.
  235                      */
  236                     size_t chunk = want > chunk_max ? chunk_max : want;
  237 
  238                     if (!BUF_MEM_grow_clean(b, len + chunk)) {
  239                         ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ERR_R_MALLOC_FAILURE);
  240                         goto err;
  241                     }
  242                     want -= chunk;
  243                     while (chunk > 0) {
  244                         i = BIO_read(in, &(b->data[len]), chunk);
  245                         if (i <= 0) {
  246                             ASN1err(ASN1_F_ASN1_D2I_READ_BIO,
  247                                     ASN1_R_NOT_ENOUGH_DATA);
  248                             goto err;
  249                         }
  250                     /*
  251                      * This can't overflow because |len+want| didn't
  252                      * overflow.
  253                      */
  254                         len += i;
  255                         chunk -= i;
  256                     }
  257                     if (chunk_max < INT_MAX/2)
  258                         chunk_max *= 2;
  259                 }
  260             }
  261             if (off + c.slen < off) {
  262                 ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
  263                 goto err;
  264             }
  265             off += c.slen;
  266             if (eos <= 0) {
  267                 break;
  268             } else
  269                 want = HEADER_SIZE;
  270         }
  271     }
  272 
  273     if (off > INT_MAX) {
  274         ASN1err(ASN1_F_ASN1_D2I_READ_BIO, ASN1_R_TOO_LONG);
  275         goto err;
  276     }
  277 
  278     *pb = b;
  279     return off;
  280  err:
  281     if (b != NULL)
  282         BUF_MEM_free(b);
  283     return -1;
  284 }