1 /*
2  * Copyright 2006-2018 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 /*
11  * Experimental ASN1 BIO. When written through the data is converted to an
12  * ASN1 string type: default is OCTET STRING. Additional functions can be
13  * provided to add prefix and suffix data.
14  */
15 
16 #include <string.h>
17 #include "internal/bio.h"
18 #include <openssl/asn1.h>
19 #include "internal/cryptlib.h"
20 
21 /* Must be large enough for biggest tag+length */
22 #define DEFAULT_ASN1_BUF_SIZE 20
23 
24 typedef enum {
25     ASN1_STATE_START,
26     ASN1_STATE_PRE_COPY,
27     ASN1_STATE_HEADER,
28     ASN1_STATE_HEADER_COPY,
29     ASN1_STATE_DATA_COPY,
30     ASN1_STATE_POST_COPY,
31     ASN1_STATE_DONE
32 } asn1_bio_state_t;
33 
34 typedef struct BIO_ASN1_EX_FUNCS_st {
35     asn1_ps_func *ex_func;
36     asn1_ps_func *ex_free_func;
37 } BIO_ASN1_EX_FUNCS;
38 
39 typedef struct BIO_ASN1_BUF_CTX_t {
40     /* Internal state */
41     asn1_bio_state_t state;
42     /* Internal buffer */
43     unsigned char *buf;
44     /* Size of buffer */
45     int bufsize;
46     /* Current position in buffer */
47     int bufpos;
48     /* Current buffer length */
49     int buflen;
50     /* Amount of data to copy */
51     int copylen;
52     /* Class and tag to use */
53     int asn1_class, asn1_tag;
54     asn1_ps_func *prefix, *prefix_free, *suffix, *suffix_free;
55     /* Extra buffer for prefix and suffix data */
56     unsigned char *ex_buf;
57     int ex_len;
58     int ex_pos;
59     void *ex_arg;
60 } BIO_ASN1_BUF_CTX;
61 
62 static int asn1_bio_write(BIO *h, const char *buf, int num);
63 static int asn1_bio_read(BIO *h, char *buf, int size);
64 static int asn1_bio_puts(BIO *h, const char *str);
65 static int asn1_bio_gets(BIO *h, char *str, int size);
66 static long asn1_bio_ctrl(BIO *h, int cmd, long arg1, void *arg2);
67 static int asn1_bio_new(BIO *h);
68 static int asn1_bio_free(BIO *data);
69 static long asn1_bio_callback_ctrl(BIO *h, int cmd, BIO_info_cb *fp);
70 
71 static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size);
72 static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
73                              asn1_ps_func *cleanup, asn1_bio_state_t next);
74 static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
75                              asn1_ps_func *setup,
76                              asn1_bio_state_t ex_state,
77                              asn1_bio_state_t other_state);
78 
79 static const BIO_METHOD methods_asn1 = {
80     BIO_TYPE_ASN1,
81     "asn1",
82     /* TODO: Convert to new style write function */
83     bwrite_conv,
84     asn1_bio_write,
85     /* TODO: Convert to new style read function */
86     bread_conv,
87     asn1_bio_read,
88     asn1_bio_puts,
89     asn1_bio_gets,
90     asn1_bio_ctrl,
91     asn1_bio_new,
92     asn1_bio_free,
93     asn1_bio_callback_ctrl,
94 };
95 
BIO_f_asn1(void)96 const BIO_METHOD *BIO_f_asn1(void)
97 {
98     return &methods_asn1;
99 }
100 
asn1_bio_new(BIO * b)101 static int asn1_bio_new(BIO *b)
102 {
103     BIO_ASN1_BUF_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
104 
105     if (ctx == NULL)
106         return 0;
107     if (!asn1_bio_init(ctx, DEFAULT_ASN1_BUF_SIZE)) {
108         OPENSSL_free(ctx);
109         return 0;
110     }
111     BIO_set_data(b, ctx);
112     BIO_set_init(b, 1);
113 
114     return 1;
115 }
116 
asn1_bio_init(BIO_ASN1_BUF_CTX * ctx,int size)117 static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size)
118 {
119     if ((ctx->buf = OPENSSL_malloc(size)) == NULL) {
120         ASN1err(ASN1_F_ASN1_BIO_INIT, ERR_R_MALLOC_FAILURE);
121         return 0;
122     }
123     ctx->bufsize = size;
124     ctx->asn1_class = V_ASN1_UNIVERSAL;
125     ctx->asn1_tag = V_ASN1_OCTET_STRING;
126     ctx->state = ASN1_STATE_START;
127     return 1;
128 }
129 
asn1_bio_free(BIO * b)130 static int asn1_bio_free(BIO *b)
131 {
132     BIO_ASN1_BUF_CTX *ctx;
133 
134     if (b == NULL)
135         return 0;
136 
137     ctx = BIO_get_data(b);
138     if (ctx == NULL)
139         return 0;
140 
141     OPENSSL_free(ctx->buf);
142     OPENSSL_free(ctx);
143     BIO_set_data(b, NULL);
144     BIO_set_init(b, 0);
145 
146     return 1;
147 }
148 
asn1_bio_write(BIO * b,const char * in,int inl)149 static int asn1_bio_write(BIO *b, const char *in, int inl)
150 {
151     BIO_ASN1_BUF_CTX *ctx;
152     int wrmax, wrlen, ret;
153     unsigned char *p;
154     BIO *next;
155 
156     ctx = BIO_get_data(b);
157     next = BIO_next(b);
158     if (in == NULL || inl < 0 || ctx == NULL || next == NULL)
159         return 0;
160 
161     wrlen = 0;
162     ret = -1;
163 
164     for (;;) {
165         switch (ctx->state) {
166             /* Setup prefix data, call it */
167         case ASN1_STATE_START:
168             if (!asn1_bio_setup_ex(b, ctx, ctx->prefix,
169                                    ASN1_STATE_PRE_COPY, ASN1_STATE_HEADER))
170                 return 0;
171             break;
172 
173             /* Copy any pre data first */
174         case ASN1_STATE_PRE_COPY:
175 
176             ret = asn1_bio_flush_ex(b, ctx, ctx->prefix_free,
177                                     ASN1_STATE_HEADER);
178 
179             if (ret <= 0)
180                 goto done;
181 
182             break;
183 
184         case ASN1_STATE_HEADER:
185             ctx->buflen = ASN1_object_size(0, inl, ctx->asn1_tag) - inl;
186             if (!ossl_assert(ctx->buflen <= ctx->bufsize))
187                 return 0;
188             p = ctx->buf;
189             ASN1_put_object(&p, 0, inl, ctx->asn1_tag, ctx->asn1_class);
190             ctx->copylen = inl;
191             ctx->state = ASN1_STATE_HEADER_COPY;
192 
193             break;
194 
195         case ASN1_STATE_HEADER_COPY:
196             ret = BIO_write(next, ctx->buf + ctx->bufpos, ctx->buflen);
197             if (ret <= 0)
198                 goto done;
199 
200             ctx->buflen -= ret;
201             if (ctx->buflen)
202                 ctx->bufpos += ret;
203             else {
204                 ctx->bufpos = 0;
205                 ctx->state = ASN1_STATE_DATA_COPY;
206             }
207 
208             break;
209 
210         case ASN1_STATE_DATA_COPY:
211 
212             if (inl > ctx->copylen)
213                 wrmax = ctx->copylen;
214             else
215                 wrmax = inl;
216             ret = BIO_write(next, in, wrmax);
217             if (ret <= 0)
218                 goto done;
219             wrlen += ret;
220             ctx->copylen -= ret;
221             in += ret;
222             inl -= ret;
223 
224             if (ctx->copylen == 0)
225                 ctx->state = ASN1_STATE_HEADER;
226 
227             if (inl == 0)
228                 goto done;
229 
230             break;
231 
232         case ASN1_STATE_POST_COPY:
233         case ASN1_STATE_DONE:
234             BIO_clear_retry_flags(b);
235             return 0;
236 
237         }
238 
239     }
240 
241  done:
242     BIO_clear_retry_flags(b);
243     BIO_copy_next_retry(b);
244 
245     return (wrlen > 0) ? wrlen : ret;
246 
247 }
248 
asn1_bio_flush_ex(BIO * b,BIO_ASN1_BUF_CTX * ctx,asn1_ps_func * cleanup,asn1_bio_state_t next)249 static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
250                              asn1_ps_func *cleanup, asn1_bio_state_t next)
251 {
252     int ret;
253 
254     if (ctx->ex_len <= 0)
255         return 1;
256     for (;;) {
257         ret = BIO_write(BIO_next(b), ctx->ex_buf + ctx->ex_pos, ctx->ex_len);
258         if (ret <= 0)
259             break;
260         ctx->ex_len -= ret;
261         if (ctx->ex_len > 0)
262             ctx->ex_pos += ret;
263         else {
264             if (cleanup)
265                 cleanup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg);
266             ctx->state = next;
267             ctx->ex_pos = 0;
268             break;
269         }
270     }
271     return ret;
272 }
273 
asn1_bio_setup_ex(BIO * b,BIO_ASN1_BUF_CTX * ctx,asn1_ps_func * setup,asn1_bio_state_t ex_state,asn1_bio_state_t other_state)274 static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
275                              asn1_ps_func *setup,
276                              asn1_bio_state_t ex_state,
277                              asn1_bio_state_t other_state)
278 {
279     if (setup && !setup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg)) {
280         BIO_clear_retry_flags(b);
281         return 0;
282     }
283     if (ctx->ex_len > 0)
284         ctx->state = ex_state;
285     else
286         ctx->state = other_state;
287     return 1;
288 }
289 
asn1_bio_read(BIO * b,char * in,int inl)290 static int asn1_bio_read(BIO *b, char *in, int inl)
291 {
292     BIO *next = BIO_next(b);
293     if (next == NULL)
294         return 0;
295     return BIO_read(next, in, inl);
296 }
297 
asn1_bio_puts(BIO * b,const char * str)298 static int asn1_bio_puts(BIO *b, const char *str)
299 {
300     return asn1_bio_write(b, str, strlen(str));
301 }
302 
asn1_bio_gets(BIO * b,char * str,int size)303 static int asn1_bio_gets(BIO *b, char *str, int size)
304 {
305     BIO *next = BIO_next(b);
306     if (next == NULL)
307         return 0;
308     return BIO_gets(next, str, size);
309 }
310 
asn1_bio_callback_ctrl(BIO * b,int cmd,BIO_info_cb * fp)311 static long asn1_bio_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
312 {
313     BIO *next = BIO_next(b);
314     if (next == NULL)
315         return 0;
316     return BIO_callback_ctrl(next, cmd, fp);
317 }
318 
asn1_bio_ctrl(BIO * b,int cmd,long arg1,void * arg2)319 static long asn1_bio_ctrl(BIO *b, int cmd, long arg1, void *arg2)
320 {
321     BIO_ASN1_BUF_CTX *ctx;
322     BIO_ASN1_EX_FUNCS *ex_func;
323     long ret = 1;
324     BIO *next;
325 
326     ctx = BIO_get_data(b);
327     if (ctx == NULL)
328         return 0;
329     next = BIO_next(b);
330     switch (cmd) {
331 
332     case BIO_C_SET_PREFIX:
333         ex_func = arg2;
334         ctx->prefix = ex_func->ex_func;
335         ctx->prefix_free = ex_func->ex_free_func;
336         break;
337 
338     case BIO_C_GET_PREFIX:
339         ex_func = arg2;
340         ex_func->ex_func = ctx->prefix;
341         ex_func->ex_free_func = ctx->prefix_free;
342         break;
343 
344     case BIO_C_SET_SUFFIX:
345         ex_func = arg2;
346         ctx->suffix = ex_func->ex_func;
347         ctx->suffix_free = ex_func->ex_free_func;
348         break;
349 
350     case BIO_C_GET_SUFFIX:
351         ex_func = arg2;
352         ex_func->ex_func = ctx->suffix;
353         ex_func->ex_free_func = ctx->suffix_free;
354         break;
355 
356     case BIO_C_SET_EX_ARG:
357         ctx->ex_arg = arg2;
358         break;
359 
360     case BIO_C_GET_EX_ARG:
361         *(void **)arg2 = ctx->ex_arg;
362         break;
363 
364     case BIO_CTRL_FLUSH:
365         if (next == NULL)
366             return 0;
367 
368         /* Call post function if possible */
369         if (ctx->state == ASN1_STATE_HEADER) {
370             if (!asn1_bio_setup_ex(b, ctx, ctx->suffix,
371                                    ASN1_STATE_POST_COPY, ASN1_STATE_DONE))
372                 return 0;
373         }
374 
375         if (ctx->state == ASN1_STATE_POST_COPY) {
376             ret = asn1_bio_flush_ex(b, ctx, ctx->suffix_free,
377                                     ASN1_STATE_DONE);
378             if (ret <= 0)
379                 return ret;
380         }
381 
382         if (ctx->state == ASN1_STATE_DONE)
383             return BIO_ctrl(next, cmd, arg1, arg2);
384         else {
385             BIO_clear_retry_flags(b);
386             return 0;
387         }
388 
389     default:
390         if (next == NULL)
391             return 0;
392         return BIO_ctrl(next, cmd, arg1, arg2);
393 
394     }
395 
396     return ret;
397 }
398 
asn1_bio_set_ex(BIO * b,int cmd,asn1_ps_func * ex_func,asn1_ps_func * ex_free_func)399 static int asn1_bio_set_ex(BIO *b, int cmd,
400                            asn1_ps_func *ex_func, asn1_ps_func *ex_free_func)
401 {
402     BIO_ASN1_EX_FUNCS extmp;
403     extmp.ex_func = ex_func;
404     extmp.ex_free_func = ex_free_func;
405     return BIO_ctrl(b, cmd, 0, &extmp);
406 }
407 
asn1_bio_get_ex(BIO * b,int cmd,asn1_ps_func ** ex_func,asn1_ps_func ** ex_free_func)408 static int asn1_bio_get_ex(BIO *b, int cmd,
409                            asn1_ps_func **ex_func,
410                            asn1_ps_func **ex_free_func)
411 {
412     BIO_ASN1_EX_FUNCS extmp;
413     int ret;
414     ret = BIO_ctrl(b, cmd, 0, &extmp);
415     if (ret > 0) {
416         *ex_func = extmp.ex_func;
417         *ex_free_func = extmp.ex_free_func;
418     }
419     return ret;
420 }
421 
BIO_asn1_set_prefix(BIO * b,asn1_ps_func * prefix,asn1_ps_func * prefix_free)422 int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
423                         asn1_ps_func *prefix_free)
424 {
425     return asn1_bio_set_ex(b, BIO_C_SET_PREFIX, prefix, prefix_free);
426 }
427 
BIO_asn1_get_prefix(BIO * b,asn1_ps_func ** pprefix,asn1_ps_func ** pprefix_free)428 int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
429                         asn1_ps_func **pprefix_free)
430 {
431     return asn1_bio_get_ex(b, BIO_C_GET_PREFIX, pprefix, pprefix_free);
432 }
433 
BIO_asn1_set_suffix(BIO * b,asn1_ps_func * suffix,asn1_ps_func * suffix_free)434 int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
435                         asn1_ps_func *suffix_free)
436 {
437     return asn1_bio_set_ex(b, BIO_C_SET_SUFFIX, suffix, suffix_free);
438 }
439 
BIO_asn1_get_suffix(BIO * b,asn1_ps_func ** psuffix,asn1_ps_func ** psuffix_free)440 int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
441                         asn1_ps_func **psuffix_free)
442 {
443     return asn1_bio_get_ex(b, BIO_C_GET_SUFFIX, psuffix, psuffix_free);
444 }
445