Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libcrypto/crypto/../../libssl/src/crypto/evp/encode.c	Lines:	156	184	84.8 %
Date:	2016-12-06	Branches:	88	106	83.0 %


/* $OpenBSD: encode.c,v 1.24 2016/05/04 15:05:13 tedu Exp $ */
/* 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 <limits.h>
#include <stdio.h>
#include <string.h>

#include <openssl/evp.h>

#define conv_bin2ascii(a)	(data_bin2ascii[(a)&0x3f])
#define conv_ascii2bin(a)	(data_ascii2bin[(a)&0x7f])

/* 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 const 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 const 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,
    const unsigned char *in, int inl)
{
	int i, j;
	size_t total = 0;

	*outl = 0;
	if (inl == 0)
		return;
	OPENSSL_assert(ctx->length <= (int)sizeof(ctx->enc_data));
	if (ctx->length - ctx->num > inl) {
		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 && total <= INT_MAX) {
		j = EVP_EncodeBlock(out, in, ctx->length);
		in += ctx->length;
		inl -= ctx->length;
		out += j;
		*(out++) = '\n';
		*out = '\0';
		total += j + 1;
	}
	if (total > INT_MAX) {
		/* Too much output data! */
		*outl = 0;
		return;
	}
	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, const 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,
    const unsigned char *in, int inl)
{
	int seof = -1, eof = 0, rv = -1, ret = 0, i, v, tmp, n, ln, 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)) {
			OPENSSL_assert(n < (int)sizeof(ctx->enc_data));
			d[n++] = tmp;
			ln++;
		} else if (v == B64_ERROR) {
			rv = -1;
			goto end;
		}

		/* There should not be base64 data after padding. */
		if (eof && tmp != '=' && tmp != '\r' && tmp != '\n' &&
		    v != B64_EOF) {
			rv = -1;
			goto end;
		}

		/* have we seen a '=' which is 'definitely' 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++;
		}

		/* There should be no more than two padding markers. */
		if (eof > 2) {
			rv = -1;
			goto end;
		}

		if (v == B64_CR) {
			ln = 0;
			if (exp_nl)
				continue;
		}

		/* 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;
			/* In case things were given us in really small
			   records (so two '=' were given in separate
			   updates), eof may contain the incorrect number
			   of ending bytes to skip, so let's redo the count */
			eof = 0;
			if (d[n-1] == '=')
				eof++;
			if (d[n-2] == '=')
				eof++;
			/* There will never be more than two '=' */
		}

		if ((v == B64_EOF && (n&3) == 0) || (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;
			if (n > 0) {
				v = EVP_DecodeBlock(out, d, n);
				n = 0;
				if (v < 0) {
					rv = 0;
					goto end;
				}
				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, const 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);
}


Generated by: GCOVR (Version 3.3)

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