[thirdparty/openssl.git] / crypto / evp / encode.c

/* crypto/evp/encode.c */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 * 
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 * 
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from 
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 * 
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * 
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */

#include <stdio.h>
#include "cryptlib.h"
#include <openssl/evp.h>

#ifndef CHARSET_EBCDIC
#define conv_bin2ascii(a)	(data_bin2ascii[(a)&0x3f])
#define conv_ascii2bin(a)	(data_ascii2bin[(a)&0x7f])
#else
/* We assume that PEM encoded files are EBCDIC files
 * (i.e., printable text files). Convert them here while decoding.
 * When encoding, output is EBCDIC (text) format again.
 * (No need for conversion in the conv_bin2ascii macro, as the
 * underlying textstring data_bin2ascii[] is already EBCDIC)
 */
#define conv_bin2ascii(a)	(data_bin2ascii[(a)&0x3f])
#define conv_ascii2bin(a)	(data_ascii2bin[os_toascii[a]&0x7f])
#endif

/* 64 char lines
 * pad input with 0
 * left over chars are set to =
 * 1 byte  => xx==
 * 2 bytes => xxx=
 * 3 bytes => xxxx
 */
#define BIN_PER_LINE    (64/4*3)
#define CHUNKS_PER_LINE (64/4)
#define CHAR_PER_LINE   (64+1)

static unsigned char data_bin2ascii[65]="ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz0123456789+/";

/* 0xF0 is a EOLN
 * 0xF1 is ignore but next needs to be 0xF0 (for \r\n processing).
 * 0xF2 is EOF
 * 0xE0 is ignore at start of line.
 * 0xFF is error
 */

#define B64_EOLN		0xF0
#define B64_CR			0xF1
#define B64_EOF			0xF2
#define B64_WS			0xE0
#define B64_ERROR       	0xFF
#define B64_NOT_BASE64(a)	(((a)|0x13) == 0xF3)

static unsigned char data_ascii2bin[128]={
	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	0xFF,0xE0,0xF0,0xFF,0xFF,0xF1,0xFF,0xFF,
	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	0xFF,0xFF,0xFF,0x3E,0xFF,0xF2,0xFF,0x3F,
	0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,
	0x3C,0x3D,0xFF,0xFF,0xFF,0x00,0xFF,0xFF,
	0xFF,0x00,0x01,0x02,0x03,0x04,0x05,0x06,
	0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,
	0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,
	0x17,0x18,0x19,0xFF,0xFF,0xFF,0xFF,0xFF,
	0xFF,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,
	0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,
	0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,
	0x31,0x32,0x33,0xFF,0xFF,0xFF,0xFF,0xFF,
	};

void EVP_EncodeInit(EVP_ENCODE_CTX *ctx)
	{
	ctx->length=48;
	ctx->num=0;
	ctx->line_num=0;
	}

void EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
	     unsigned char *in, int inl)
	{
	int i,j;
	unsigned int total=0;

	*outl=0;
	if (inl == 0) return;
	if ((ctx->num+inl) < ctx->length)
		{
		memcpy(&(ctx->enc_data[ctx->num]),in,inl);
		ctx->num+=inl;
		return;
		}
	if (ctx->num != 0)
		{
		i=ctx->length-ctx->num;
		memcpy(&(ctx->enc_data[ctx->num]),in,i);
		in+=i;
		inl-=i;
		j=EVP_EncodeBlock(out,ctx->enc_data,ctx->length);
		ctx->num=0;
		out+=j;
		*(out++)='\n';
		*out='\0';
		total=j+1;
		}
	while (inl >= ctx->length)
		{
		j=EVP_EncodeBlock(out,in,ctx->length);
		in+=ctx->length;
		inl-=ctx->length;
		out+=j;
		*(out++)='\n';
		*out='\0';
		total+=j+1;
		}
	if (inl != 0)
		memcpy(&(ctx->enc_data[0]),in,inl);
	ctx->num=inl;
	*outl=total;
	}

void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl)
	{
	unsigned int ret=0;

	if (ctx->num != 0)
		{
		ret=EVP_EncodeBlock(out,ctx->enc_data,ctx->num);
		out[ret++]='\n';
		out[ret]='\0';
		ctx->num=0;
		}
	*outl=ret;
	}

int EVP_EncodeBlock(unsigned char *t, unsigned char *f, int dlen)
	{
	int i,ret=0;
	unsigned long l;

	for (i=dlen; i > 0; i-=3)
		{
		if (i >= 3)
			{
			l=	(((unsigned long)f[0])<<16L)|
				(((unsigned long)f[1])<< 8L)|f[2];
			*(t++)=conv_bin2ascii(l>>18L);
			*(t++)=conv_bin2ascii(l>>12L);
			*(t++)=conv_bin2ascii(l>> 6L);
			*(t++)=conv_bin2ascii(l     );
			}
		else
			{
			l=((unsigned long)f[0])<<16L;
			if (i == 2) l|=((unsigned long)f[1]<<8L);

			*(t++)=conv_bin2ascii(l>>18L);
			*(t++)=conv_bin2ascii(l>>12L);
			*(t++)=(i == 1)?'=':conv_bin2ascii(l>> 6L);
			*(t++)='=';
			}
		ret+=4;
		f+=3;
		}

	*t='\0';
	return(ret);
	}

void EVP_DecodeInit(EVP_ENCODE_CTX *ctx)
	{
	ctx->length=30;
	ctx->num=0;
	ctx->line_num=0;
	ctx->expect_nl=0;
	}

/* -1 for error
 *  0 for last line
 *  1 for full line
 */
int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl,
	     unsigned char *in, int inl)
	{
	int seof= -1,eof=0,rv= -1,ret=0,i,v,tmp,n,ln,tmp2,exp_nl;
	unsigned char *d;

	n=ctx->num;
	d=ctx->enc_data;
	ln=ctx->line_num;
	exp_nl=ctx->expect_nl;

	/* last line of input. */
	if ((inl == 0) || ((n == 0) && (conv_ascii2bin(in[0]) == B64_EOF)))
		{ rv=0; goto end; }
		
	/* We parse the input data */
	for (i=0; i<inl; i++)
		{
		/* If the current line is > 80 characters, scream alot */
		if (ln >= 80) { rv= -1; goto end; }

		/* Get char and put it into the buffer */
		tmp= *(in++);
		v=conv_ascii2bin(tmp);
		/* only save the good data :-) */
		if (!B64_NOT_BASE64(v))
			{
			d[n++]=tmp;
			ln++;
			}
		else if (v == B64_ERROR)
			{
			rv= -1;
			goto end;
			}

		/* have we seen a '=' which is 'definitly' the last
		 * input line.  seof will point to the character that
		 * holds it. and eof will hold how many characters to
		 * chop off. */
		if (tmp == '=')
			{
			if (seof == -1) seof=n;
			eof++;
			}

		/* eoln */
		if (v == B64_EOLN)
			{
			ln=0;
			if (exp_nl)
				{
				exp_nl=0;
				continue;
				}
			}
		exp_nl=0;

		/* If we are at the end of input and it looks like a
		 * line, process it. */
		if (((i+1) == inl) && (((n&3) == 0) || eof))
			v=B64_EOF;

		if ((v == B64_EOF) || (n >= 64))
			{
			/* This is needed to work correctly on 64 byte input
			 * lines.  We process the line and then need to
			 * accept the '\n' */
			if ((v != B64_EOF) && (n >= 64)) exp_nl=1;
			tmp2=v;
			if (n > 0)
				{
				v=EVP_DecodeBlock(out,d,n);
				if (v < 0) { rv=0; goto end; }
				n=0;
				ret+=(v-eof);
				}
			else
				{
				eof=1;
				v=0;
				}

			/* This is the case where we have had a short
			 * but valid input line */
			if ((v < ctx->length) && eof)
				{
				rv=0;
				goto end;
				}
			else
				ctx->length=v;

			if (seof >= 0) { rv=0; goto end; }
			out+=v;
			}
		}
	rv=1;
end:
	*outl=ret;
	ctx->num=n;
	ctx->line_num=ln;
	ctx->expect_nl=exp_nl;
	return(rv);
	}

int EVP_DecodeBlock(unsigned char *t, unsigned char *f, int n)
	{
	int i,ret=0,a,b,c,d;
	unsigned long l;

	/* trim white space from the start of the line. */
	while ((conv_ascii2bin(*f) == B64_WS) && (n > 0))
		{
		f++;
		n--;
		}

	/* strip off stuff at the end of the line
	 * ascii2bin values B64_WS, B64_EOLN, B64_EOLN and B64_EOF */
	while ((n > 3) && (B64_NOT_BASE64(conv_ascii2bin(f[n-1]))))
		n--;

	if (n%4 != 0) return(-1);

	for (i=0; i<n; i+=4)
		{
		a=conv_ascii2bin(*(f++));
		b=conv_ascii2bin(*(f++));
		c=conv_ascii2bin(*(f++));
		d=conv_ascii2bin(*(f++));
		if (	(a & 0x80) || (b & 0x80) ||
			(c & 0x80) || (d & 0x80))
			return(-1);
		l=(	(((unsigned long)a)<<18L)|
			(((unsigned long)b)<<12L)|
			(((unsigned long)c)<< 6L)|
			(((unsigned long)d)     ));
		*(t++)=(unsigned char)(l>>16L)&0xff;
		*(t++)=(unsigned char)(l>> 8L)&0xff;
		*(t++)=(unsigned char)(l     )&0xff;
		ret+=3;
		}
	return(ret);
	}

int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl)
	{
	int i;

	*outl=0;
	if (ctx->num != 0)
		{
		i=EVP_DecodeBlock(out,ctx->enc_data,ctx->num);
		if (i < 0) return(-1);
		ctx->num=0;
		*outl=i;
		return(1);
		}
	else
		return(1);
	}

#ifdef undef
int EVP_DecodeValid(unsigned char *buf, int len)
	{
	int i,num=0,bad=0;

	if (len == 0) return(-1);
	while (conv_ascii2bin(*buf) == B64_WS)
		{
		buf++;
		len--;
		if (len == 0) return(-1);
		}

	for (i=len; i >= 4; i-=4)
		{
		if (	(conv_ascii2bin(buf[0]) >= 0x40) ||
			(conv_ascii2bin(buf[1]) >= 0x40) ||
			(conv_ascii2bin(buf[2]) >= 0x40) ||
			(conv_ascii2bin(buf[3]) >= 0x40))
			return(-1);
		buf+=4;
		num+=1+(buf[2] != '=')+(buf[3] != '=');
		}
	if ((i == 1) && (conv_ascii2bin(buf[0]) == B64_EOLN))
		return(num);
	if ((i == 2) && (conv_ascii2bin(buf[0]) == B64_EOLN) &&
		(conv_ascii2bin(buf[0]) == B64_EOLN))
		return(num);
	return(1);
	}
#endif
Commit	Line	Data
d02b48c6	1	/* crypto/evp/encode.c */
58964a49	2	/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
d02b48c6 RE	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 "cryptlib.h"
ec577822	61	#include <openssl/evp.h>
d02b48c6	62
a53955d8	63	#ifndef CHARSET_EBCDIC
d02b48c6 RE	64	#define conv_bin2ascii(a) (data_bin2ascii[(a)&0x3f])
d02b48c6 RE	65	#define conv_ascii2bin(a) (data_ascii2bin[(a)&0x7f])
a53955d8 UM	66	#else
	67	/* We assume that PEM encoded files are EBCDIC files
	68	* (i.e., printable text files). Convert them here while decoding.
	69	* When encoding, output is EBCDIC (text) format again.
	70	* (No need for conversion in the conv_bin2ascii macro, as the
	71	* underlying textstring data_bin2ascii[] is already EBCDIC)
	72	*/
	73	#define conv_bin2ascii(a) (data_bin2ascii[(a)&0x3f])
	74	#define conv_ascii2bin(a) (data_ascii2bin[os_toascii[a]&0x7f])
	75	#endif
d02b48c6 RE	76
	77	/* 64 char lines
	78	* pad input with 0
	79	* left over chars are set to =
	80	* 1 byte => xx==
	81	* 2 bytes => xxx=
	82	* 3 bytes => xxxx
	83	*/
	84	#define BIN_PER_LINE (64/4*3)
	85	#define CHUNKS_PER_LINE (64/4)
	86	#define CHAR_PER_LINE (64+1)
	87
	88	static unsigned char data_bin2ascii[65]="ABCDEFGHIJKLMNOPQRSTUVWXYZ\
	89	abcdefghijklmnopqrstuvwxyz0123456789+/";
	90
	91	/* 0xF0 is a EOLN
	92	* 0xF1 is ignore but next needs to be 0xF0 (for \r\n processing).
	93	* 0xF2 is EOF
	94	* 0xE0 is ignore at start of line.
	95	* 0xFF is error
	96	*/
	97
	98	#define B64_EOLN 0xF0
	99	#define B64_CR 0xF1
	100	#define B64_EOF 0xF2
	101	#define B64_WS 0xE0
	102	#define B64_ERROR 0xFF
	103	#define B64_NOT_BASE64(a) (((a)\|0x13) == 0xF3)
	104
	105	static unsigned char data_ascii2bin[128]={
	106	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	107	0xFF,0xE0,0xF0,0xFF,0xFF,0xF1,0xFF,0xFF,
	108	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	109	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	110	0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
	111	0xFF,0xFF,0xFF,0x3E,0xFF,0xF2,0xFF,0x3F,
	112	0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,
	113	0x3C,0x3D,0xFF,0xFF,0xFF,0x00,0xFF,0xFF,
	114	0xFF,0x00,0x01,0x02,0x03,0x04,0x05,0x06,
	115	0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,
	116	0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,
	117	0x17,0x18,0x19,0xFF,0xFF,0xFF,0xFF,0xFF,
	118	0xFF,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,
	119	0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,
	120	0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,
	121	0x31,0x32,0x33,0xFF,0xFF,0xFF,0xFF,0xFF,
	122	};
	123
6b691a5c	124	void EVP_EncodeInit(EVP_ENCODE_CTX *ctx)
d02b48c6 RE	125	{
	126	ctx->length=48;
	127	ctx->num=0;
	128	ctx->line_num=0;
	129	}
	130
6b691a5c UM	131	void EVP_EncodeUpdate(EVP_ENCODE_CTX ctx, unsigned char out, int *outl,
6b691a5c UM	132	unsigned char *in, int inl)
d02b48c6 RE	133	{
	134	int i,j;
	135	unsigned int total=0;
	136
	137	*outl=0;
	138	if (inl == 0) return;
	139	if ((ctx->num+inl) < ctx->length)
	140	{
	141	memcpy(&(ctx->enc_data[ctx->num]),in,inl);
	142	ctx->num+=inl;
	143	return;
	144	}
	145	if (ctx->num != 0)
	146	{
	147	i=ctx->length-ctx->num;
	148	memcpy(&(ctx->enc_data[ctx->num]),in,i);
	149	in+=i;
	150	inl-=i;
	151	j=EVP_EncodeBlock(out,ctx->enc_data,ctx->length);
	152	ctx->num=0;
	153	out+=j;
	154	*(out++)='\n';
	155	*out='\0';
	156	total=j+1;
	157	}
	158	while (inl >= ctx->length)
	159	{
	160	j=EVP_EncodeBlock(out,in,ctx->length);
	161	in+=ctx->length;
	162	inl-=ctx->length;
	163	out+=j;
	164	*(out++)='\n';
	165	*out='\0';
	166	total+=j+1;
	167	}
	168	if (inl != 0)
	169	memcpy(&(ctx->enc_data[0]),in,inl);
	170	ctx->num=inl;
	171	*outl=total;
	172	}
	173
6b691a5c	174	void EVP_EncodeFinal(EVP_ENCODE_CTX ctx, unsigned char out, int *outl)
d02b48c6 RE	175	{
	176	unsigned int ret=0;
	177
	178	if (ctx->num != 0)
	179	{
	180	ret=EVP_EncodeBlock(out,ctx->enc_data,ctx->num);
	181	out[ret++]='\n';
	182	out[ret]='\0';
	183	ctx->num=0;
	184	}
	185	*outl=ret;
	186	}
	187
6b691a5c	188	int EVP_EncodeBlock(unsigned char t, unsigned char f, int dlen)
d02b48c6 RE	189	{
	190	int i,ret=0;
	191	unsigned long l;
	192
	193	for (i=dlen; i > 0; i-=3)
	194	{
	195	if (i >= 3)
	196	{
	197	l= (((unsigned long)f[0])<<16L)\|
	198	(((unsigned long)f[1])<< 8L)\|f[2];
	199	*(t++)=conv_bin2ascii(l>>18L);
	200	*(t++)=conv_bin2ascii(l>>12L);
	201	*(t++)=conv_bin2ascii(l>> 6L);
	202	*(t++)=conv_bin2ascii(l );
	203	}
	204	else
	205	{
	206	l=((unsigned long)f[0])<<16L;
	207	if (i == 2) l\|=((unsigned long)f[1]<<8L);
	208
	209	*(t++)=conv_bin2ascii(l>>18L);
	210	*(t++)=conv_bin2ascii(l>>12L);
	211	*(t++)=(i == 1)?'=':conv_bin2ascii(l>> 6L);
	212	*(t++)='=';
	213	}
	214	ret+=4;
	215	f+=3;
	216	}
	217
	218	*t='\0';
	219	return(ret);
	220	}
	221
6b691a5c	222	void EVP_DecodeInit(EVP_ENCODE_CTX *ctx)
d02b48c6 RE	223	{
	224	ctx->length=30;
	225	ctx->num=0;
	226	ctx->line_num=0;
58964a49	227	ctx->expect_nl=0;
d02b48c6 RE	228	}
	229
	230	/* -1 for error
	231	* 0 for last line
	232	* 1 for full line
	233	*/
6b691a5c UM	234	int EVP_DecodeUpdate(EVP_ENCODE_CTX ctx, unsigned char out, int *outl,
6b691a5c UM	235	unsigned char *in, int inl)
d02b48c6	236	{
58964a49	237	int seof= -1,eof=0,rv= -1,ret=0,i,v,tmp,n,ln,tmp2,exp_nl;
d02b48c6 RE	238	unsigned char *d;
	239
	240	n=ctx->num;
	241	d=ctx->enc_data;
	242	ln=ctx->line_num;
58964a49	243	exp_nl=ctx->expect_nl;
d02b48c6 RE	244
	245	/* last line of input. */
	246	if ((inl == 0) \|\| ((n == 0) && (conv_ascii2bin(in[0]) == B64_EOF)))
	247	{ rv=0; goto end; }
	248
	249	/* We parse the input data */
	250	for (i=0; i<inl; i++)
	251	{
	252	/* If the current line is > 80 characters, scream alot */
	253	if (ln >= 80) { rv= -1; goto end; }
	254
	255	/* Get char and put it into the buffer */
	256	tmp= *(in++);
	257	v=conv_ascii2bin(tmp);
	258	/* only save the good data :-) */
	259	if (!B64_NOT_BASE64(v))
	260	{
	261	d[n++]=tmp;
	262	ln++;
	263	}
	264	else if (v == B64_ERROR)
	265	{
	266	rv= -1;
	267	goto end;
	268	}
	269
	270	/* have we seen a '=' which is 'definitly' the last
	271	* input line. seof will point to the character that
	272	* holds it. and eof will hold how many characters to
	273	* chop off. */
	274	if (tmp == '=')
	275	{
	276	if (seof == -1) seof=n;
	277	eof++;
	278	}
	279
	280	/* eoln */
58964a49 RE	281	if (v == B64_EOLN)
	282	{
	283	ln=0;
	284	if (exp_nl)
	285	{
	286	exp_nl=0;
	287	continue;
	288	}
	289	}
	290	exp_nl=0;
d02b48c6 RE	291
	292	/* If we are at the end of input and it looks like a
	293	* line, process it. */
	294	if (((i+1) == inl) && (((n&3) == 0) \|\| eof))
	295	v=B64_EOF;
	296
	297	if ((v == B64_EOF) \|\| (n >= 64))
	298	{
58964a49 RE	299	/* This is needed to work correctly on 64 byte input
	300	* lines. We process the line and then need to
	301	* accept the '\n' */
	302	if ((v != B64_EOF) && (n >= 64)) exp_nl=1;
d02b48c6 RE	303	tmp2=v;
	304	if (n > 0)
	305	{
	306	v=EVP_DecodeBlock(out,d,n);
	307	if (v < 0) { rv=0; goto end; }
	308	n=0;
	309	ret+=(v-eof);
	310	}
	311	else
	312	{
	313	eof=1;
	314	v=0;
	315	}
	316
	317	/* This is the case where we have had a short
	318	* but valid input line */
	319	if ((v < ctx->length) && eof)
	320	{
	321	rv=0;
	322	goto end;
	323	}
	324	else
	325	ctx->length=v;
	326
	327	if (seof >= 0) { rv=0; goto end; }
	328	out+=v;
	329	}
	330	}
	331	rv=1;
	332	end:
	333	*outl=ret;
	334	ctx->num=n;
	335	ctx->line_num=ln;
58964a49	336	ctx->expect_nl=exp_nl;
d02b48c6 RE	337	return(rv);
	338	}
	339
6b691a5c	340	int EVP_DecodeBlock(unsigned char t, unsigned char f, int n)
d02b48c6 RE	341	{
	342	int i,ret=0,a,b,c,d;
	343	unsigned long l;
	344
	345	/* trim white space from the start of the line. */
	346	while ((conv_ascii2bin(*f) == B64_WS) && (n > 0))
	347	{
	348	f++;
	349	n--;
	350	}
	351
	352	/* strip off stuff at the end of the line
	353	* ascii2bin values B64_WS, B64_EOLN, B64_EOLN and B64_EOF */
	354	while ((n > 3) && (B64_NOT_BASE64(conv_ascii2bin(f[n-1]))))
	355	n--;
	356
	357	if (n%4 != 0) return(-1);
	358
	359	for (i=0; i<n; i+=4)
	360	{
	361	a=conv_ascii2bin(*(f++));
	362	b=conv_ascii2bin(*(f++));
	363	c=conv_ascii2bin(*(f++));
	364	d=conv_ascii2bin(*(f++));
	365	if ( (a & 0x80) \|\| (b & 0x80) \|\|
	366	(c & 0x80) \|\| (d & 0x80))
	367	return(-1);
	368	l=( (((unsigned long)a)<<18L)\|
	369	(((unsigned long)b)<<12L)\|
	370	(((unsigned long)c)<< 6L)\|
	371	(((unsigned long)d) ));
	372	*(t++)=(unsigned char)(l>>16L)&0xff;
	373	*(t++)=(unsigned char)(l>> 8L)&0xff;
	374	*(t++)=(unsigned char)(l )&0xff;
	375	ret+=3;
	376	}
	377	return(ret);
	378	}
	379
6b691a5c	380	int EVP_DecodeFinal(EVP_ENCODE_CTX ctx, unsigned char out, int *outl)
d02b48c6 RE	381	{
	382	int i;
	383
	384	*outl=0;
	385	if (ctx->num != 0)
	386	{
	387	i=EVP_DecodeBlock(out,ctx->enc_data,ctx->num);
	388	if (i < 0) return(-1);
	389	ctx->num=0;
	390	*outl=i;
	391	return(1);
	392	}
	393	else
	394	return(1);
	395	}
	396
	397	#ifdef undef
6b691a5c	398	int EVP_DecodeValid(unsigned char *buf, int len)
d02b48c6 RE	399	{
	400	int i,num=0,bad=0;
	401
	402	if (len == 0) return(-1);
	403	while (conv_ascii2bin(*buf) == B64_WS)
	404	{
	405	buf++;
	406	len--;
	407	if (len == 0) return(-1);
	408	}
	409
	410	for (i=len; i >= 4; i-=4)
	411	{
	412	if ( (conv_ascii2bin(buf[0]) >= 0x40) \|\|
	413	(conv_ascii2bin(buf[1]) >= 0x40) \|\|
	414	(conv_ascii2bin(buf[2]) >= 0x40) \|\|
	415	(conv_ascii2bin(buf[3]) >= 0x40))
	416	return(-1);
	417	buf+=4;
	418	num+=1+(buf[2] != '=')+(buf[3] != '=');
	419	}
	420	if ((i == 1) && (conv_ascii2bin(buf[0]) == B64_EOLN))
	421	return(num);
	422	if ((i == 2) && (conv_ascii2bin(buf[0]) == B64_EOLN) &&
	423	(conv_ascii2bin(buf[0]) == B64_EOLN))
	424	return(num);
	425	return(1);
	426	}
	427	#endif