xref: /openssl/crypto/asn1/bio_asn1.c (revision 0f48050b)
1 /*
2  * Copyright 2006-2021 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (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     bwrite_conv,
83     asn1_bio_write,
84     bread_conv,
85     asn1_bio_read,
86     asn1_bio_puts,
87     asn1_bio_gets,
88     asn1_bio_ctrl,
89     asn1_bio_new,
90     asn1_bio_free,
91     asn1_bio_callback_ctrl,
92 };
93 
BIO_f_asn1(void)94 const BIO_METHOD *BIO_f_asn1(void)
95 {
96     return &methods_asn1;
97 }
98 
asn1_bio_new(BIO * b)99 static int asn1_bio_new(BIO *b)
100 {
101     BIO_ASN1_BUF_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
102 
103     if (ctx == NULL)
104         return 0;
105     if (!asn1_bio_init(ctx, DEFAULT_ASN1_BUF_SIZE)) {
106         OPENSSL_free(ctx);
107         return 0;
108     }
109     BIO_set_data(b, ctx);
110     BIO_set_init(b, 1);
111 
112     return 1;
113 }
114 
asn1_bio_init(BIO_ASN1_BUF_CTX * ctx,int size)115 static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size)
116 {
117     if (size <= 0) {
118         ERR_raise(ERR_LIB_ASN1, ERR_R_PASSED_INVALID_ARGUMENT);
119         return 0;
120     }
121     if ((ctx->buf = OPENSSL_malloc(size)) == NULL)
122         return 0;
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     if (ctx->prefix_free != NULL)
142         ctx->prefix_free(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg);
143     if (ctx->suffix_free != NULL)
144         ctx->suffix_free(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg);
145 
146     OPENSSL_free(ctx->buf);
147     OPENSSL_free(ctx);
148     BIO_set_data(b, NULL);
149     BIO_set_init(b, 0);
150 
151     return 1;
152 }
153 
asn1_bio_write(BIO * b,const char * in,int inl)154 static int asn1_bio_write(BIO *b, const char *in, int inl)
155 {
156     BIO_ASN1_BUF_CTX *ctx;
157     int wrmax, wrlen, ret;
158     unsigned char *p;
159     BIO *next;
160 
161     ctx = BIO_get_data(b);
162     next = BIO_next(b);
163     if (in == NULL || inl < 0 || ctx == NULL || next == NULL)
164         return 0;
165 
166     wrlen = 0;
167     ret = -1;
168 
169     for (;;) {
170         switch (ctx->state) {
171             /* Setup prefix data, call it */
172         case ASN1_STATE_START:
173             if (!asn1_bio_setup_ex(b, ctx, ctx->prefix,
174                                    ASN1_STATE_PRE_COPY, ASN1_STATE_HEADER))
175                 return -1;
176             break;
177 
178             /* Copy any pre data first */
179         case ASN1_STATE_PRE_COPY:
180 
181             ret = asn1_bio_flush_ex(b, ctx, ctx->prefix_free,
182                                     ASN1_STATE_HEADER);
183 
184             if (ret <= 0)
185                 goto done;
186 
187             break;
188 
189         case ASN1_STATE_HEADER:
190             ctx->buflen = ASN1_object_size(0, inl, ctx->asn1_tag) - inl;
191             if (!ossl_assert(ctx->buflen <= ctx->bufsize))
192                 return -1;
193             p = ctx->buf;
194             ASN1_put_object(&p, 0, inl, ctx->asn1_tag, ctx->asn1_class);
195             ctx->copylen = inl;
196             ctx->state = ASN1_STATE_HEADER_COPY;
197 
198             break;
199 
200         case ASN1_STATE_HEADER_COPY:
201             ret = BIO_write(next, ctx->buf + ctx->bufpos, ctx->buflen);
202             if (ret <= 0)
203                 goto done;
204 
205             ctx->buflen -= ret;
206             if (ctx->buflen)
207                 ctx->bufpos += ret;
208             else {
209                 ctx->bufpos = 0;
210                 ctx->state = ASN1_STATE_DATA_COPY;
211             }
212 
213             break;
214 
215         case ASN1_STATE_DATA_COPY:
216 
217             if (inl > ctx->copylen)
218                 wrmax = ctx->copylen;
219             else
220                 wrmax = inl;
221             ret = BIO_write(next, in, wrmax);
222             if (ret <= 0)
223                 goto done;
224             wrlen += ret;
225             ctx->copylen -= ret;
226             in += ret;
227             inl -= ret;
228 
229             if (ctx->copylen == 0)
230                 ctx->state = ASN1_STATE_HEADER;
231 
232             if (inl == 0)
233                 goto done;
234 
235             break;
236 
237         case ASN1_STATE_POST_COPY:
238         case ASN1_STATE_DONE:
239             BIO_clear_retry_flags(b);
240             return 0;
241 
242         }
243 
244     }
245 
246  done:
247     BIO_clear_retry_flags(b);
248     BIO_copy_next_retry(b);
249 
250     return (wrlen > 0) ? wrlen : ret;
251 
252 }
253 
asn1_bio_flush_ex(BIO * b,BIO_ASN1_BUF_CTX * ctx,asn1_ps_func * cleanup,asn1_bio_state_t next)254 static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
255                              asn1_ps_func *cleanup, asn1_bio_state_t next)
256 {
257     int ret;
258 
259     if (ctx->ex_len <= 0)
260         return 1;
261     for (;;) {
262         ret = BIO_write(BIO_next(b), ctx->ex_buf + ctx->ex_pos, ctx->ex_len);
263         if (ret <= 0)
264             break;
265         ctx->ex_len -= ret;
266         if (ctx->ex_len > 0)
267             ctx->ex_pos += ret;
268         else {
269             if (cleanup)
270                 cleanup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg);
271             ctx->state = next;
272             ctx->ex_pos = 0;
273             break;
274         }
275     }
276     return ret;
277 }
278 
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)279 static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
280                              asn1_ps_func *setup,
281                              asn1_bio_state_t ex_state,
282                              asn1_bio_state_t other_state)
283 {
284     if (setup && !setup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg)) {
285         BIO_clear_retry_flags(b);
286         return 0;
287     }
288     if (ctx->ex_len > 0)
289         ctx->state = ex_state;
290     else
291         ctx->state = other_state;
292     return 1;
293 }
294 
asn1_bio_read(BIO * b,char * in,int inl)295 static int asn1_bio_read(BIO *b, char *in, int inl)
296 {
297     BIO *next = BIO_next(b);
298     if (next == NULL)
299         return 0;
300     return BIO_read(next, in, inl);
301 }
302 
asn1_bio_puts(BIO * b,const char * str)303 static int asn1_bio_puts(BIO *b, const char *str)
304 {
305     return asn1_bio_write(b, str, strlen(str));
306 }
307 
asn1_bio_gets(BIO * b,char * str,int size)308 static int asn1_bio_gets(BIO *b, char *str, int size)
309 {
310     BIO *next = BIO_next(b);
311     if (next == NULL)
312         return 0;
313     return BIO_gets(next, str, size);
314 }
315 
asn1_bio_callback_ctrl(BIO * b,int cmd,BIO_info_cb * fp)316 static long asn1_bio_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
317 {
318     BIO *next = BIO_next(b);
319     if (next == NULL)
320         return 0;
321     return BIO_callback_ctrl(next, cmd, fp);
322 }
323 
asn1_bio_ctrl(BIO * b,int cmd,long arg1,void * arg2)324 static long asn1_bio_ctrl(BIO *b, int cmd, long arg1, void *arg2)
325 {
326     BIO_ASN1_BUF_CTX *ctx;
327     BIO_ASN1_EX_FUNCS *ex_func;
328     long ret = 1;
329     BIO *next;
330 
331     ctx = BIO_get_data(b);
332     if (ctx == NULL)
333         return 0;
334     next = BIO_next(b);
335     switch (cmd) {
336 
337     case BIO_C_SET_PREFIX:
338         ex_func = arg2;
339         ctx->prefix = ex_func->ex_func;
340         ctx->prefix_free = ex_func->ex_free_func;
341         break;
342 
343     case BIO_C_GET_PREFIX:
344         ex_func = arg2;
345         ex_func->ex_func = ctx->prefix;
346         ex_func->ex_free_func = ctx->prefix_free;
347         break;
348 
349     case BIO_C_SET_SUFFIX:
350         ex_func = arg2;
351         ctx->suffix = ex_func->ex_func;
352         ctx->suffix_free = ex_func->ex_free_func;
353         break;
354 
355     case BIO_C_GET_SUFFIX:
356         ex_func = arg2;
357         ex_func->ex_func = ctx->suffix;
358         ex_func->ex_free_func = ctx->suffix_free;
359         break;
360 
361     case BIO_C_SET_EX_ARG:
362         ctx->ex_arg = arg2;
363         break;
364 
365     case BIO_C_GET_EX_ARG:
366         *(void **)arg2 = ctx->ex_arg;
367         break;
368 
369     case BIO_CTRL_FLUSH:
370         if (next == NULL)
371             return 0;
372 
373         /* Call post function if possible */
374         if (ctx->state == ASN1_STATE_HEADER) {
375             if (!asn1_bio_setup_ex(b, ctx, ctx->suffix,
376                                    ASN1_STATE_POST_COPY, ASN1_STATE_DONE))
377                 return 0;
378         }
379 
380         if (ctx->state == ASN1_STATE_POST_COPY) {
381             ret = asn1_bio_flush_ex(b, ctx, ctx->suffix_free,
382                                     ASN1_STATE_DONE);
383             if (ret <= 0)
384                 return ret;
385         }
386 
387         if (ctx->state == ASN1_STATE_DONE)
388             return BIO_ctrl(next, cmd, arg1, arg2);
389         else {
390             BIO_clear_retry_flags(b);
391             return 0;
392         }
393 
394     default:
395         if (next == NULL)
396             return 0;
397         return BIO_ctrl(next, cmd, arg1, arg2);
398 
399     }
400 
401     return ret;
402 }
403 
asn1_bio_set_ex(BIO * b,int cmd,asn1_ps_func * ex_func,asn1_ps_func * ex_free_func)404 static int asn1_bio_set_ex(BIO *b, int cmd,
405                            asn1_ps_func *ex_func, asn1_ps_func *ex_free_func)
406 {
407     BIO_ASN1_EX_FUNCS extmp;
408     extmp.ex_func = ex_func;
409     extmp.ex_free_func = ex_free_func;
410     return BIO_ctrl(b, cmd, 0, &extmp);
411 }
412 
asn1_bio_get_ex(BIO * b,int cmd,asn1_ps_func ** ex_func,asn1_ps_func ** ex_free_func)413 static int asn1_bio_get_ex(BIO *b, int cmd,
414                            asn1_ps_func **ex_func,
415                            asn1_ps_func **ex_free_func)
416 {
417     BIO_ASN1_EX_FUNCS extmp;
418     int ret;
419     ret = BIO_ctrl(b, cmd, 0, &extmp);
420     if (ret > 0) {
421         *ex_func = extmp.ex_func;
422         *ex_free_func = extmp.ex_free_func;
423     }
424     return ret;
425 }
426 
BIO_asn1_set_prefix(BIO * b,asn1_ps_func * prefix,asn1_ps_func * prefix_free)427 int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
428                         asn1_ps_func *prefix_free)
429 {
430     return asn1_bio_set_ex(b, BIO_C_SET_PREFIX, prefix, prefix_free);
431 }
432 
BIO_asn1_get_prefix(BIO * b,asn1_ps_func ** pprefix,asn1_ps_func ** pprefix_free)433 int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
434                         asn1_ps_func **pprefix_free)
435 {
436     return asn1_bio_get_ex(b, BIO_C_GET_PREFIX, pprefix, pprefix_free);
437 }
438 
BIO_asn1_set_suffix(BIO * b,asn1_ps_func * suffix,asn1_ps_func * suffix_free)439 int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
440                         asn1_ps_func *suffix_free)
441 {
442     return asn1_bio_set_ex(b, BIO_C_SET_SUFFIX, suffix, suffix_free);
443 }
444 
BIO_asn1_get_suffix(BIO * b,asn1_ps_func ** psuffix,asn1_ps_func ** psuffix_free)445 int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
446                         asn1_ps_func **psuffix_free)
447 {
448     return asn1_bio_get_ex(b, BIO_C_GET_SUFFIX, psuffix, psuffix_free);
449 }
450