80206aa4f64a06d4ebe1b65d07055902af75d9c3
[openssl.git] / crypto / asn1 / bio_asn1.c
1 /*
2  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3  * project.
4  */
5 /* ====================================================================
6  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in
17  *    the documentation and/or other materials provided with the
18  *    distribution.
19  *
20  * 3. All advertising materials mentioning features or use of this
21  *    software must display the following acknowledgment:
22  *    "This product includes software developed by the OpenSSL Project
23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24  *
25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26  *    endorse or promote products derived from this software without
27  *    prior written permission. For written permission, please contact
28  *    licensing@OpenSSL.org.
29  *
30  * 5. Products derived from this software may not be called "OpenSSL"
31  *    nor may "OpenSSL" appear in their names without prior written
32  *    permission of the OpenSSL Project.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50  * OF THE POSSIBILITY OF SUCH DAMAGE.
51  * ====================================================================
52  *
53  * This product includes cryptographic software written by Eric Young
54  * (eay@cryptsoft.com).  This product includes software written by Tim
55  * Hudson (tjh@cryptsoft.com).
56  *
57  */
58
59 /*
60  * Experimental ASN1 BIO. When written through the data is converted to an
61  * ASN1 string type: default is OCTET STRING. Additional functions can be
62  * provided to add prefix and suffix data.
63  */
64
65 #include <string.h>
66 #include <openssl/bio.h>
67 #include <openssl/asn1.h>
68
69 /* Must be large enough for biggest tag+length */
70 #define DEFAULT_ASN1_BUF_SIZE 20
71
72 typedef enum {
73     ASN1_STATE_START,
74     ASN1_STATE_PRE_COPY,
75     ASN1_STATE_HEADER,
76     ASN1_STATE_HEADER_COPY,
77     ASN1_STATE_DATA_COPY,
78     ASN1_STATE_POST_COPY,
79     ASN1_STATE_DONE
80 } asn1_bio_state_t;
81
82 typedef struct BIO_ASN1_EX_FUNCS_st {
83     asn1_ps_func *ex_func;
84     asn1_ps_func *ex_free_func;
85 } BIO_ASN1_EX_FUNCS;
86
87 typedef struct BIO_ASN1_BUF_CTX_t {
88     /* Internal state */
89     asn1_bio_state_t state;
90     /* Internal buffer */
91     unsigned char *buf;
92     /* Size of buffer */
93     int bufsize;
94     /* Current position in buffer */
95     int bufpos;
96     /* Current buffer length */
97     int buflen;
98     /* Amount of data to copy */
99     int copylen;
100     /* Class and tag to use */
101     int asn1_class, asn1_tag;
102     asn1_ps_func *prefix, *prefix_free, *suffix, *suffix_free;
103     /* Extra buffer for prefix and suffix data */
104     unsigned char *ex_buf;
105     int ex_len;
106     int ex_pos;
107     void *ex_arg;
108 } BIO_ASN1_BUF_CTX;
109
110 static int asn1_bio_write(BIO *h, const char *buf, int num);
111 static int asn1_bio_read(BIO *h, char *buf, int size);
112 static int asn1_bio_puts(BIO *h, const char *str);
113 static int asn1_bio_gets(BIO *h, char *str, int size);
114 static long asn1_bio_ctrl(BIO *h, int cmd, long arg1, void *arg2);
115 static int asn1_bio_new(BIO *h);
116 static int asn1_bio_free(BIO *data);
117 static long asn1_bio_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp);
118
119 static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size);
120 static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
121                              asn1_ps_func *cleanup, asn1_bio_state_t next);
122 static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
123                              asn1_ps_func *setup,
124                              asn1_bio_state_t ex_state,
125                              asn1_bio_state_t other_state);
126
127 static const BIO_METHOD methods_asn1 = {
128     BIO_TYPE_ASN1,
129     "asn1",
130     asn1_bio_write,
131     asn1_bio_read,
132     asn1_bio_puts,
133     asn1_bio_gets,
134     asn1_bio_ctrl,
135     asn1_bio_new,
136     asn1_bio_free,
137     asn1_bio_callback_ctrl,
138 };
139
140 const BIO_METHOD *BIO_f_asn1(void)
141 {
142     return (&methods_asn1);
143 }
144
145 static int asn1_bio_new(BIO *b)
146 {
147     BIO_ASN1_BUF_CTX *ctx;
148     ctx = OPENSSL_malloc(sizeof(*ctx));
149     if (ctx == NULL)
150         return 0;
151     if (!asn1_bio_init(ctx, DEFAULT_ASN1_BUF_SIZE)) {
152         OPENSSL_free(ctx);
153         return 0;
154     }
155     b->init = 1;
156     b->ptr = (char *)ctx;
157     b->flags = 0;
158     return 1;
159 }
160
161 static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size)
162 {
163     ctx->buf = OPENSSL_malloc(size);
164     if (ctx->buf == NULL)
165         return 0;
166     ctx->bufsize = size;
167     ctx->bufpos = 0;
168     ctx->buflen = 0;
169     ctx->copylen = 0;
170     ctx->asn1_class = V_ASN1_UNIVERSAL;
171     ctx->asn1_tag = V_ASN1_OCTET_STRING;
172     ctx->ex_buf = 0;
173     ctx->ex_pos = 0;
174     ctx->ex_len = 0;
175     ctx->state = ASN1_STATE_START;
176     return 1;
177 }
178
179 static int asn1_bio_free(BIO *b)
180 {
181     BIO_ASN1_BUF_CTX *ctx = (BIO_ASN1_BUF_CTX *)b->ptr;
182
183     if (ctx == NULL)
184         return 0;
185     OPENSSL_free(ctx->buf);
186     OPENSSL_free(ctx);
187     b->init = 0;
188     b->ptr = NULL;
189     b->flags = 0;
190     return 1;
191 }
192
193 static int asn1_bio_write(BIO *b, const char *in, int inl)
194 {
195     BIO_ASN1_BUF_CTX *ctx;
196     int wrmax, wrlen, ret;
197     unsigned char *p;
198     if (!in || (inl < 0) || (b->next_bio == NULL))
199         return 0;
200     ctx = (BIO_ASN1_BUF_CTX *)b->ptr;
201     if (ctx == NULL)
202         return 0;
203
204     wrlen = 0;
205     ret = -1;
206
207     for (;;) {
208         switch (ctx->state) {
209
210             /* Setup prefix data, call it */
211         case ASN1_STATE_START:
212             if (!asn1_bio_setup_ex(b, ctx, ctx->prefix,
213                                    ASN1_STATE_PRE_COPY, ASN1_STATE_HEADER))
214                 return 0;
215             break;
216
217             /* Copy any pre data first */
218         case ASN1_STATE_PRE_COPY:
219
220             ret = asn1_bio_flush_ex(b, ctx, ctx->prefix_free,
221                                     ASN1_STATE_HEADER);
222
223             if (ret <= 0)
224                 goto done;
225
226             break;
227
228         case ASN1_STATE_HEADER:
229             ctx->buflen = ASN1_object_size(0, inl, ctx->asn1_tag) - inl;
230             OPENSSL_assert(ctx->buflen <= ctx->bufsize);
231             p = ctx->buf;
232             ASN1_put_object(&p, 0, inl, ctx->asn1_tag, ctx->asn1_class);
233             ctx->copylen = inl;
234             ctx->state = ASN1_STATE_HEADER_COPY;
235
236             break;
237
238         case ASN1_STATE_HEADER_COPY:
239             ret = BIO_write(b->next_bio, ctx->buf + ctx->bufpos, ctx->buflen);
240             if (ret <= 0)
241                 goto done;
242
243             ctx->buflen -= ret;
244             if (ctx->buflen)
245                 ctx->bufpos += ret;
246             else {
247                 ctx->bufpos = 0;
248                 ctx->state = ASN1_STATE_DATA_COPY;
249             }
250
251             break;
252
253         case ASN1_STATE_DATA_COPY:
254
255             if (inl > ctx->copylen)
256                 wrmax = ctx->copylen;
257             else
258                 wrmax = inl;
259             ret = BIO_write(b->next_bio, in, wrmax);
260             if (ret <= 0)
261                 break;
262             wrlen += ret;
263             ctx->copylen -= ret;
264             in += ret;
265             inl -= ret;
266
267             if (ctx->copylen == 0)
268                 ctx->state = ASN1_STATE_HEADER;
269
270             if (inl == 0)
271                 goto done;
272
273             break;
274
275         default:
276             BIO_clear_retry_flags(b);
277             return 0;
278
279         }
280
281     }
282
283  done:
284     BIO_clear_retry_flags(b);
285     BIO_copy_next_retry(b);
286
287     return (wrlen > 0) ? wrlen : ret;
288
289 }
290
291 static int asn1_bio_flush_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
292                              asn1_ps_func *cleanup, asn1_bio_state_t next)
293 {
294     int ret;
295     if (ctx->ex_len <= 0)
296         return 1;
297     for (;;) {
298         ret = BIO_write(b->next_bio, ctx->ex_buf + ctx->ex_pos, ctx->ex_len);
299         if (ret <= 0)
300             break;
301         ctx->ex_len -= ret;
302         if (ctx->ex_len > 0)
303             ctx->ex_pos += ret;
304         else {
305             if (cleanup)
306                 cleanup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg);
307             ctx->state = next;
308             ctx->ex_pos = 0;
309             break;
310         }
311     }
312     return ret;
313 }
314
315 static int asn1_bio_setup_ex(BIO *b, BIO_ASN1_BUF_CTX *ctx,
316                              asn1_ps_func *setup,
317                              asn1_bio_state_t ex_state,
318                              asn1_bio_state_t other_state)
319 {
320     if (setup && !setup(b, &ctx->ex_buf, &ctx->ex_len, &ctx->ex_arg)) {
321         BIO_clear_retry_flags(b);
322         return 0;
323     }
324     if (ctx->ex_len > 0)
325         ctx->state = ex_state;
326     else
327         ctx->state = other_state;
328     return 1;
329 }
330
331 static int asn1_bio_read(BIO *b, char *in, int inl)
332 {
333     if (!b->next_bio)
334         return 0;
335     return BIO_read(b->next_bio, in, inl);
336 }
337
338 static int asn1_bio_puts(BIO *b, const char *str)
339 {
340     return asn1_bio_write(b, str, strlen(str));
341 }
342
343 static int asn1_bio_gets(BIO *b, char *str, int size)
344 {
345     if (!b->next_bio)
346         return 0;
347     return BIO_gets(b->next_bio, str, size);
348 }
349
350 static long asn1_bio_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
351 {
352     if (b->next_bio == NULL)
353         return (0);
354     return BIO_callback_ctrl(b->next_bio, cmd, fp);
355 }
356
357 static long asn1_bio_ctrl(BIO *b, int cmd, long arg1, void *arg2)
358 {
359     BIO_ASN1_BUF_CTX *ctx;
360     BIO_ASN1_EX_FUNCS *ex_func;
361     long ret = 1;
362     ctx = (BIO_ASN1_BUF_CTX *)b->ptr;
363     if (ctx == NULL)
364         return 0;
365     switch (cmd) {
366
367     case BIO_C_SET_PREFIX:
368         ex_func = arg2;
369         ctx->prefix = ex_func->ex_func;
370         ctx->prefix_free = ex_func->ex_free_func;
371         break;
372
373     case BIO_C_GET_PREFIX:
374         ex_func = arg2;
375         ex_func->ex_func = ctx->prefix;
376         ex_func->ex_free_func = ctx->prefix_free;
377         break;
378
379     case BIO_C_SET_SUFFIX:
380         ex_func = arg2;
381         ctx->suffix = ex_func->ex_func;
382         ctx->suffix_free = ex_func->ex_free_func;
383         break;
384
385     case BIO_C_GET_SUFFIX:
386         ex_func = arg2;
387         ex_func->ex_func = ctx->suffix;
388         ex_func->ex_free_func = ctx->suffix_free;
389         break;
390
391     case BIO_C_SET_EX_ARG:
392         ctx->ex_arg = arg2;
393         break;
394
395     case BIO_C_GET_EX_ARG:
396         *(void **)arg2 = ctx->ex_arg;
397         break;
398
399     case BIO_CTRL_FLUSH:
400         if (!b->next_bio)
401             return 0;
402
403         /* Call post function if possible */
404         if (ctx->state == ASN1_STATE_HEADER) {
405             if (!asn1_bio_setup_ex(b, ctx, ctx->suffix,
406                                    ASN1_STATE_POST_COPY, ASN1_STATE_DONE))
407                 return 0;
408         }
409
410         if (ctx->state == ASN1_STATE_POST_COPY) {
411             ret = asn1_bio_flush_ex(b, ctx, ctx->suffix_free,
412                                     ASN1_STATE_DONE);
413             if (ret <= 0)
414                 return ret;
415         }
416
417         if (ctx->state == ASN1_STATE_DONE)
418             return BIO_ctrl(b->next_bio, cmd, arg1, arg2);
419         else {
420             BIO_clear_retry_flags(b);
421             return 0;
422         }
423
424     default:
425         if (!b->next_bio)
426             return 0;
427         return BIO_ctrl(b->next_bio, cmd, arg1, arg2);
428
429     }
430
431     return ret;
432 }
433
434 static int asn1_bio_set_ex(BIO *b, int cmd,
435                            asn1_ps_func *ex_func, asn1_ps_func *ex_free_func)
436 {
437     BIO_ASN1_EX_FUNCS extmp;
438     extmp.ex_func = ex_func;
439     extmp.ex_free_func = ex_free_func;
440     return BIO_ctrl(b, cmd, 0, &extmp);
441 }
442
443 static int asn1_bio_get_ex(BIO *b, int cmd,
444                            asn1_ps_func **ex_func,
445                            asn1_ps_func **ex_free_func)
446 {
447     BIO_ASN1_EX_FUNCS extmp;
448     int ret;
449     ret = BIO_ctrl(b, cmd, 0, &extmp);
450     if (ret > 0) {
451         *ex_func = extmp.ex_func;
452         *ex_free_func = extmp.ex_free_func;
453     }
454     return ret;
455 }
456
457 int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
458                         asn1_ps_func *prefix_free)
459 {
460     return asn1_bio_set_ex(b, BIO_C_SET_PREFIX, prefix, prefix_free);
461 }
462
463 int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
464                         asn1_ps_func **pprefix_free)
465 {
466     return asn1_bio_get_ex(b, BIO_C_GET_PREFIX, pprefix, pprefix_free);
467 }
468
469 int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
470                         asn1_ps_func *suffix_free)
471 {
472     return asn1_bio_set_ex(b, BIO_C_SET_SUFFIX, suffix, suffix_free);
473 }
474
475 int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
476                         asn1_ps_func **psuffix_free)
477 {
478     return asn1_bio_get_ex(b, BIO_C_GET_SUFFIX, psuffix, psuffix_free);
479 }