Convert X509* functions to use const getters
[openssl.git] / 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 }