bio_b64.c revision 120631 
1/* crypto/evp/bio_b64.c */
2/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 * All rights reserved.
4 *
5 * This package is an SSL implementation written
6 * by Eric Young (eay@cryptsoft.com).
7 * The implementation was written so as to conform with Netscapes SSL.
8 *
9 * This library is free for commercial and non-commercial use as long as
10 * the following conditions are aheared to.  The following conditions
11 * apply to all code found in this distribution, be it the RC4, RSA,
12 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13 * included with this distribution is covered by the same copyright terms
14 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 *
16 * Copyright remains Eric Young's, and as such any Copyright notices in
17 * the code are not to be removed.
18 * If this package is used in a product, Eric Young should be given attribution
19 * as the author of the parts of the library used.
20 * This can be in the form of a textual message at program startup or
21 * in documentation (online or textual) provided with the package.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
25 * are met:
26 * 1. Redistributions of source code must retain the copyright
27 *    notice, this list of conditions and the following disclaimer.
28 * 2. Redistributions in binary form must reproduce the above copyright
29 *    notice, this list of conditions and the following disclaimer in the
30 *    documentation and/or other materials provided with the distribution.
31 * 3. All advertising materials mentioning features or use of this software
32 *    must display the following acknowledgement:
33 *    "This product includes cryptographic software written by
34 *     Eric Young (eay@cryptsoft.com)"
35 *    The word 'cryptographic' can be left out if the rouines from the library
36 *    being used are not cryptographic related :-).
37 * 4. If you include any Windows specific code (or a derivative thereof) from
38 *    the apps directory (application code) you must include an acknowledgement:
39 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 *
41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 * SUCH DAMAGE.
52 *
53 * The licence and distribution terms for any publically available version or
54 * derivative of this code cannot be changed.  i.e. this code cannot simply be
55 * copied and put under another distribution licence
56 * [including the GNU Public Licence.]
57 */
58
59#include <stdio.h>
60#include <errno.h>
61#include "cryptlib.h"
62#include <openssl/buffer.h>
63#include <openssl/evp.h>
64
65static int b64_write(BIO *h, const char *buf, int num);
66static int b64_read(BIO *h, char *buf, int size);
67/*static int b64_puts(BIO *h, const char *str); */
68/*static int b64_gets(BIO *h, char *str, int size); */
69static long b64_ctrl(BIO *h, int cmd, long arg1, void *arg2);
70static int b64_new(BIO *h);
71static int b64_free(BIO *data);
72static long b64_callback_ctrl(BIO *h,int cmd,bio_info_cb *fp);
73#define B64_BLOCK_SIZE	1024
74#define B64_BLOCK_SIZE2	768
75#define B64_NONE	0
76#define B64_ENCODE	1
77#define B64_DECODE	2
78
79typedef struct b64_struct
80	{
81	/*BIO *bio; moved to the BIO structure */
82	int buf_len;
83	int buf_off;
84	int tmp_len;		/* used to find the start when decoding */
85	int tmp_nl;		/* If true, scan until '\n' */
86	int encode;
87	int start;		/* have we started decoding yet? */
88	int cont;		/* <= 0 when finished */
89	EVP_ENCODE_CTX base64;
90	char buf[EVP_ENCODE_LENGTH(B64_BLOCK_SIZE)+10];
91	char tmp[B64_BLOCK_SIZE];
92	} BIO_B64_CTX;
93
94static BIO_METHOD methods_b64=
95	{
96	BIO_TYPE_BASE64,"base64 encoding",
97	b64_write,
98	b64_read,
99	NULL, /* b64_puts, */
100	NULL, /* b64_gets, */
101	b64_ctrl,
102	b64_new,
103	b64_free,
104	b64_callback_ctrl,
105	};
106
107BIO_METHOD *BIO_f_base64(void)
108	{
109	return(&methods_b64);
110	}
111
112static int b64_new(BIO *bi)
113	{
114	BIO_B64_CTX *ctx;
115
116	ctx=(BIO_B64_CTX *)OPENSSL_malloc(sizeof(BIO_B64_CTX));
117	if (ctx == NULL) return(0);
118
119	ctx->buf_len=0;
120	ctx->tmp_len=0;
121	ctx->tmp_nl=0;
122	ctx->buf_off=0;
123	ctx->cont=1;
124	ctx->start=1;
125	ctx->encode=0;
126
127	bi->init=1;
128	bi->ptr=(char *)ctx;
129	bi->flags=0;
130	return(1);
131	}
132
133static int b64_free(BIO *a)
134	{
135	if (a == NULL) return(0);
136	OPENSSL_free(a->ptr);
137	a->ptr=NULL;
138	a->init=0;
139	a->flags=0;
140	return(1);
141	}
142
143static int b64_read(BIO *b, char *out, int outl)
144	{
145	int ret=0,i,ii,j,k,x,n,num,ret_code=0;
146	BIO_B64_CTX *ctx;
147	unsigned char *p,*q;
148
149	if (out == NULL) return(0);
150	ctx=(BIO_B64_CTX *)b->ptr;
151
152	if ((ctx == NULL) || (b->next_bio == NULL)) return(0);
153
154	if (ctx->encode != B64_DECODE)
155		{
156		ctx->encode=B64_DECODE;
157		ctx->buf_len=0;
158		ctx->buf_off=0;
159		ctx->tmp_len=0;
160		EVP_DecodeInit(&(ctx->base64));
161		}
162
163	/* First check if there are bytes decoded/encoded */
164	if (ctx->buf_len > 0)
165		{
166		i=ctx->buf_len-ctx->buf_off;
167		if (i > outl) i=outl;
168		OPENSSL_assert(ctx->buf_off+i < sizeof ctx->buf);
169		memcpy(out,&(ctx->buf[ctx->buf_off]),i);
170		ret=i;
171		out+=i;
172		outl-=i;
173		ctx->buf_off+=i;
174		if (ctx->buf_len == ctx->buf_off)
175			{
176			ctx->buf_len=0;
177			ctx->buf_off=0;
178			}
179		}
180
181	/* At this point, we have room of outl bytes and an empty
182	 * buffer, so we should read in some more. */
183
184	ret_code=0;
185	while (outl > 0)
186		{
187
188		if (ctx->cont <= 0)
189			break;
190
191		i=BIO_read(b->next_bio,&(ctx->tmp[ctx->tmp_len]),
192			B64_BLOCK_SIZE-ctx->tmp_len);
193
194		if (i <= 0)
195			{
196			ret_code=i;
197
198			/* Should be continue next time we are called? */
199			if (!BIO_should_retry(b->next_bio))
200				{
201				ctx->cont=i;
202				/* If buffer empty break */
203				if(ctx->tmp_len == 0)
204					break;
205				/* Fall through and process what we have */
206				else
207					i = 0;
208				}
209			/* else we retry and add more data to buffer */
210			else
211				break;
212			}
213		i+=ctx->tmp_len;
214		ctx->tmp_len = i;
215
216		/* We need to scan, a line at a time until we
217		 * have a valid line if we are starting. */
218		if (ctx->start && (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL))
219			{
220			/* ctx->start=1; */
221			ctx->tmp_len=0;
222			}
223		else if (ctx->start)
224			{
225			q=p=(unsigned char *)ctx->tmp;
226			for (j=0; j<i; j++)
227				{
228				if (*(q++) != '\n') continue;
229
230				/* due to a previous very long line,
231				 * we need to keep on scanning for a '\n'
232				 * before we even start looking for
233				 * base64 encoded stuff. */
234				if (ctx->tmp_nl)
235					{
236					p=q;
237					ctx->tmp_nl=0;
238					continue;
239					}
240
241				k=EVP_DecodeUpdate(&(ctx->base64),
242					(unsigned char *)ctx->buf,
243					&num,p,q-p);
244				if ((k <= 0) && (num == 0) && (ctx->start))
245					EVP_DecodeInit(&ctx->base64);
246				else
247					{
248					if (p != (unsigned char *)
249						&(ctx->tmp[0]))
250						{
251						i-=(p- (unsigned char *)
252							&(ctx->tmp[0]));
253						for (x=0; x < i; x++)
254							ctx->tmp[x]=p[x];
255						}
256					EVP_DecodeInit(&ctx->base64);
257					ctx->start=0;
258					break;
259					}
260				p=q;
261				}
262
263			/* we fell off the end without starting */
264			if (j == i)
265				{
266				/* Is this is one long chunk?, if so, keep on
267				 * reading until a new line. */
268				if (p == (unsigned char *)&(ctx->tmp[0]))
269					{
270					/* Check buffer full */
271					if (i == B64_BLOCK_SIZE)
272						{
273						ctx->tmp_nl=1;
274						ctx->tmp_len=0;
275						}
276					}
277				else if (p != q) /* finished on a '\n' */
278					{
279					n=q-p;
280					for (ii=0; ii<n; ii++)
281						ctx->tmp[ii]=p[ii];
282					ctx->tmp_len=n;
283					}
284				/* else finished on a '\n' */
285				continue;
286				}
287			else
288				ctx->tmp_len=0;
289			}
290		/* If buffer isn't full and we can retry then
291		 * restart to read in more data.
292		 */
293		else if ((i < B64_BLOCK_SIZE) && (ctx->cont > 0))
294			continue;
295
296		if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)
297			{
298			int z,jj;
299
300			jj=(i>>2)<<2;
301			z=EVP_DecodeBlock((unsigned char *)ctx->buf,
302				(unsigned char *)ctx->tmp,jj);
303			if (jj > 2)
304				{
305				if (ctx->tmp[jj-1] == '=')
306					{
307					z--;
308					if (ctx->tmp[jj-2] == '=')
309						z--;
310					}
311				}
312			/* z is now number of output bytes and jj is the
313			 * number consumed */
314			if (jj != i)
315				{
316				memcpy((unsigned char *)ctx->tmp,
317					(unsigned char *)&(ctx->tmp[jj]),i-jj);
318				ctx->tmp_len=i-jj;
319				}
320			ctx->buf_len=0;
321			if (z > 0)
322				{
323				ctx->buf_len=z;
324				i=1;
325				}
326			else
327				i=z;
328			}
329		else
330			{
331			i=EVP_DecodeUpdate(&(ctx->base64),
332				(unsigned char *)ctx->buf,&ctx->buf_len,
333				(unsigned char *)ctx->tmp,i);
334			ctx->tmp_len = 0;
335			}
336		ctx->buf_off=0;
337		if (i < 0)
338			{
339			ret_code=0;
340			ctx->buf_len=0;
341			break;
342			}
343
344		if (ctx->buf_len <= outl)
345			i=ctx->buf_len;
346		else
347			i=outl;
348
349		memcpy(out,ctx->buf,i);
350		ret+=i;
351		ctx->buf_off=i;
352		if (ctx->buf_off == ctx->buf_len)
353			{
354			ctx->buf_len=0;
355			ctx->buf_off=0;
356			}
357		outl-=i;
358		out+=i;
359		}
360	BIO_clear_retry_flags(b);
361	BIO_copy_next_retry(b);
362	return((ret == 0)?ret_code:ret);
363	}
364
365static int b64_write(BIO *b, const char *in, int inl)
366	{
367	int ret=inl,n,i;
368	BIO_B64_CTX *ctx;
369
370	ctx=(BIO_B64_CTX *)b->ptr;
371	BIO_clear_retry_flags(b);
372
373	if (ctx->encode != B64_ENCODE)
374		{
375		ctx->encode=B64_ENCODE;
376		ctx->buf_len=0;
377		ctx->buf_off=0;
378		ctx->tmp_len=0;
379		EVP_EncodeInit(&(ctx->base64));
380		}
381
382	n=ctx->buf_len-ctx->buf_off;
383	while (n > 0)
384		{
385		i=BIO_write(b->next_bio,&(ctx->buf[ctx->buf_off]),n);
386		if (i <= 0)
387			{
388			BIO_copy_next_retry(b);
389			return(i);
390			}
391		ctx->buf_off+=i;
392		n-=i;
393		}
394	/* at this point all pending data has been written */
395	ctx->buf_off=0;
396	ctx->buf_len=0;
397
398	if ((in == NULL) || (inl <= 0)) return(0);
399
400	while (inl > 0)
401		{
402		n=(inl > B64_BLOCK_SIZE)?B64_BLOCK_SIZE:inl;
403
404		if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)
405			{
406			if (ctx->tmp_len > 0)
407				{
408				n=3-ctx->tmp_len;
409				/* There's a teoretical possibility for this */
410				if (n > inl)
411					n=inl;
412				memcpy(&(ctx->tmp[ctx->tmp_len]),in,n);
413				ctx->tmp_len+=n;
414				if (ctx->tmp_len < 3)
415					break;
416				ctx->buf_len=EVP_EncodeBlock(
417					(unsigned char *)ctx->buf,
418					(unsigned char *)ctx->tmp,
419					ctx->tmp_len);
420				/* Since we're now done using the temporary
421				   buffer, the length should be 0'd */
422				ctx->tmp_len=0;
423				}
424			else
425				{
426				if (n < 3)
427					{
428					memcpy(&(ctx->tmp[0]),in,n);
429					ctx->tmp_len=n;
430					break;
431					}
432				n-=n%3;
433				ctx->buf_len=EVP_EncodeBlock(
434					(unsigned char *)ctx->buf,
435					(unsigned char *)in,n);
436				}
437			}
438		else
439			{
440			EVP_EncodeUpdate(&(ctx->base64),
441				(unsigned char *)ctx->buf,&ctx->buf_len,
442				(unsigned char *)in,n);
443			}
444		inl-=n;
445		in+=n;
446
447		ctx->buf_off=0;
448		n=ctx->buf_len;
449		while (n > 0)
450			{
451			i=BIO_write(b->next_bio,&(ctx->buf[ctx->buf_off]),n);
452			if (i <= 0)
453				{
454				BIO_copy_next_retry(b);
455				return((ret == 0)?i:ret);
456				}
457			n-=i;
458			ctx->buf_off+=i;
459			}
460		ctx->buf_len=0;
461		ctx->buf_off=0;
462		}
463	return(ret);
464	}
465
466static long b64_ctrl(BIO *b, int cmd, long num, void *ptr)
467	{
468	BIO_B64_CTX *ctx;
469	long ret=1;
470	int i;
471
472	ctx=(BIO_B64_CTX *)b->ptr;
473
474	switch (cmd)
475		{
476	case BIO_CTRL_RESET:
477		ctx->cont=1;
478		ctx->start=1;
479		ctx->encode=B64_NONE;
480		ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
481		break;
482	case BIO_CTRL_EOF:	/* More to read */
483		if (ctx->cont <= 0)
484			ret=1;
485		else
486			ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
487		break;
488	case BIO_CTRL_WPENDING: /* More to write in buffer */
489		ret=ctx->buf_len-ctx->buf_off;
490		if ((ret == 0) && (ctx->encode != B64_NONE)
491			&& (ctx->base64.num != 0))
492			ret=1;
493		else if (ret <= 0)
494			ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
495		break;
496	case BIO_CTRL_PENDING: /* More to read in buffer */
497		ret=ctx->buf_len-ctx->buf_off;
498		if (ret <= 0)
499			ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
500		break;
501	case BIO_CTRL_FLUSH:
502		/* do a final write */
503again:
504		while (ctx->buf_len != ctx->buf_off)
505			{
506			i=b64_write(b,NULL,0);
507			if (i < 0)
508				return i;
509			}
510		if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)
511			{
512			if (ctx->tmp_len != 0)
513				{
514				ctx->buf_len=EVP_EncodeBlock(
515					(unsigned char *)ctx->buf,
516					(unsigned char *)ctx->tmp,
517					ctx->tmp_len);
518				ctx->buf_off=0;
519				ctx->tmp_len=0;
520				goto again;
521				}
522			}
523		else if (ctx->encode != B64_NONE && ctx->base64.num != 0)
524			{
525			ctx->buf_off=0;
526			EVP_EncodeFinal(&(ctx->base64),
527				(unsigned char *)ctx->buf,
528				&(ctx->buf_len));
529			/* push out the bytes */
530			goto again;
531			}
532		/* Finally flush the underlying BIO */
533		ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
534		break;
535
536	case BIO_C_DO_STATE_MACHINE:
537		BIO_clear_retry_flags(b);
538		ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
539		BIO_copy_next_retry(b);
540		break;
541
542	case BIO_CTRL_DUP:
543		break;
544	case BIO_CTRL_INFO:
545	case BIO_CTRL_GET:
546	case BIO_CTRL_SET:
547	default:
548		ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
549		break;
550		}
551	return(ret);
552	}
553
554static long b64_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
555	{
556	long ret=1;
557
558	if (b->next_bio == NULL) return(0);
559	switch (cmd)
560		{
561	default:
562		ret=BIO_callback_ctrl(b->next_bio,cmd,fp);
563		break;
564		}
565	return(ret);
566	}
567
568