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