[exim.git] / src / src / base64.c

/*************************************************
*     Exim - an Internet mail transport agent    *
*************************************************/

/* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2004, 2015 */
/* License: GPL */

/* Copyright (c) University of Cambridge 1995 - 2018 */
/* Copyright (c) The Exim Maintainers 2020 */
/* See the file NOTICE for conditions of use and distribution. */


#include "exim.h"
#ifdef WITH_CONTENT_SCAN	/* file-IO specific decode function */
# include "mime.h"

/* BASE64 decoder matrix */
static unsigned char mime_b64[256]={
/*   0 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
/*  16 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
/*  32 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,   62,  128,  128,  128,   63,
/*  48 */   52,   53,   54,   55,   56,   57,   58,   59,   60,   61,  128,  128,  128,  255,  128,  128,
/*  64 */  128,    0,    1,    2,    3,    4,    5,    6,    7,    8,    9,   10,   11,   12,   13,   14,
/*  80 */   15,   16,   17,   18,   19,   20,   21,   22,   23,   24,   25,  128,  128,  128,  128,  128,
/*  96 */  128,   26,   27,   28,   29,   30,   31,   32,   33,   34,   35,   36,   37,   38,   39,   40,
/* 112 */   41,   42,   43,   44,   45,   46,   47,   48,   49,   50,   51,  128,  128,  128,  128,  128,
/* 128 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
/* 144 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
/* 160 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
/* 176 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
/* 192 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
/* 208 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
/* 224 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,
/* 240 */  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128,  128
};

/* decode base64 MIME part */
ssize_t
mime_decode_base64(FILE * in, FILE * out, uschar * boundary)
{
uschar ibuf[MIME_MAX_LINE_LENGTH], obuf[MIME_MAX_LINE_LENGTH];
uschar *opos;
ssize_t len, size = 0;
int bytestate = 0;

opos = obuf;

while (Ufgets(ibuf, MIME_MAX_LINE_LENGTH, in) != NULL)
  {
  if (boundary != NULL
     && Ustrncmp(ibuf, "--", 2) == 0
     && Ustrncmp((ibuf+2), boundary, Ustrlen(boundary)) == 0
     )
    break;

  for (uschar * ipos = ibuf ; *ipos != '\r' && *ipos != '\n' && *ipos; ++ipos)
    if (*ipos == '=')			/* skip padding */
      ++bytestate;

    else if (mime_b64[*ipos] == 128)	/* skip bad characters */
      mime_set_anomaly(MIME_ANOMALY_BROKEN_BASE64);

    /* simple state-machine */
    else switch((bytestate++) & 3)
      {
      case 0:
	*opos = mime_b64[*ipos] << 2; break;
      case 1:
	*opos++ |= mime_b64[*ipos] >> 4;
	*opos = mime_b64[*ipos] << 4; break;
      case 2:
	*opos++ |= mime_b64[*ipos] >> 2;
	*opos = mime_b64[*ipos] << 6; break;
      case 3:
	*opos++ |= mime_b64[*ipos]; break;
      }

  /* something to write? */
  len = opos - obuf;
  if (len > 0)
    {
    if (fwrite(obuf, 1, len, out) != len) return -1; /* error */
    size += len;
    /* copy incomplete last byte to start of obuf, where we continue */
    if ((bytestate & 3) != 0)
      *obuf = *opos;
    opos = obuf;
    }
  } /* while */

/* write out last byte if it was incomplete */
if (bytestate & 3)
  {
  if (fwrite(obuf, 1, 1, out) != 1) return -1;
  ++size;
  }

return size;
}

#endif	/*WITH_CONTENT_SCAN*/

/*************************************************
 *************************************************
 *************************************************
 *************************************************
 *************************************************
 *************************************************
 *************************************************
 *************************************************
 *************************************************
 *************************************************
 *************************************************
 *************************************************
 *************************************************
 *************************************************
 *************************************************
 *************************************************/


/*************************************************
*          Decode byte-string in base 64         *
*************************************************/

/* This function decodes a string in base 64 format as defined in RFC 2045
(MIME) and required by the SMTP AUTH extension (RFC 2554). The decoding
algorithm is written out in a straightforward way. Turning it into some kind of
compact loop is messy and would probably run more slowly.

Arguments:
  code        points to the coded string, zero-terminated
  ptr         where to put the pointer to the result, which is in
              allocated store, and zero-terminated

Returns:      the number of bytes in the result,
              or -1 if the input was malformed

Whitespace in the input is ignored.
A zero is added on to the end to make it easy in cases where the result is to
be interpreted as text. This is not included in the count. */

static uschar dec64table[] = {
  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, /*  0-15 */
  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, /* 16-31 */
  255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63, /* 32-47 */
   52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,255,255,255, /* 48-63 */
  255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, /* 64-79 */
   15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255, /* 80-95 */
  255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 96-111 */
   41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255  /* 112-127*/
};

int
b64decode(const uschar *code, uschar **ptr)
{

int x, y;
uschar *result;

{
  int l = Ustrlen(code);
  *ptr = result = store_get(1 + l/4 * 3 + l%4, is_tainted(code));
}

/* Each cycle of the loop handles a quantum of 4 input bytes. For the last
quantum this may decode to 1, 2, or 3 output bytes. */

while ((x = *code++) != 0)
  {
  if (isspace(x)) continue;
  /* debug_printf("b64d: '%c'\n", x); */

  if (x > 127 || (x = dec64table[x]) == 255) return -1;

  while (isspace(y = *code++)) ;
  /* debug_printf("b64d: '%c'\n", y); */
  if (y > 127 || (y = dec64table[y]) == 255)
    return -1;

  *result++ = (x << 2) | (y >> 4);
  /* debug_printf("b64d:      -> %02x\n", result[-1]); */

  while (isspace(x = *code++)) ;
  /* debug_printf("b64d: '%c'\n", x); */
  if (x == '=')		/* endmarker, but there should be another */
    {
    while (isspace(x = *code++)) ;
    /* debug_printf("b64d: '%c'\n", x); */
    if (x != '=') return -1;
    while (isspace(y = *code++)) ;
    if (y != 0) return -1;
    /* debug_printf("b64d: DONE\n"); */
    break;
    }
  else
    {
    if (x > 127 || (x = dec64table[x]) == 255) return -1;
    *result++ = (y << 4) | (x >> 2);
    /* debug_printf("b64d:      -> %02x\n", result[-1]); */

    while (isspace(y = *code++)) ;
    /* debug_printf("b64d: '%c'\n", y); */
    if (y == '=')
      {
      while (isspace(y = *code++)) ;
      if (y != 0) return -1;
      /* debug_printf("b64d: DONE\n"); */
      break;
      }
    else
      {
      if (y > 127 || (y = dec64table[y]) == 255) return -1;
      *result++ = (x << 6) | y;
      /* debug_printf("b64d:      -> %02x\n", result[-1]); */
      }
    }
  }

*result = 0;
return result - *ptr;
}


/*************************************************
*          Encode byte-string in base 64         *
*************************************************/

/* This function encodes a string of bytes, containing any values whatsoever,
in base 64 as defined in RFC 2045 (MIME) and required by the SMTP AUTH
extension (RFC 2554). The encoding algorithm is written out in a
straightforward way. Turning it into some kind of compact loop is messy and
would probably run more slowly.

Arguments:
  clear       points to the clear text bytes
  len         the number of bytes to encode

Returns:      a pointer to the zero-terminated base 64 string, which
              is in working store
*/

static uschar *enc64table =
  US"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

uschar *
b64encode_taint(const uschar * clear, int len, BOOL tainted)
{
uschar *code = store_get(4*((len+2)/3) + 1, tainted);
uschar *p = code;

while (len-- >0)
  {
  int x, y;

  x = *clear++;
  *p++ = enc64table[(x >> 2) & 63];

  if (len-- <= 0)
    {
    *p++ = enc64table[(x << 4) & 63];
    *p++ = '=';
    *p++ = '=';
    break;
    }

  y = *clear++;
  *p++ = enc64table[((x << 4) | ((y >> 4) & 15)) & 63];

  if (len-- <= 0)
    {
    *p++ = enc64table[(y << 2) & 63];
    *p++ = '=';
    break;
    }

  x = *clear++;
  *p++ = enc64table[((y << 2) | ((x >> 6) & 3)) & 63];

  *p++ = enc64table[x & 63];
  }

*p = 0;

return code;
}

uschar *
b64encode(const uschar * clear, int len)
{
return b64encode_taint(clear, len, is_tainted(clear));
}


/* End of base64.c */
/* vi: sw ai sw=2
*/
Commit	Line	Data
	1	/*************************************************
	2	* Exim - an Internet mail transport agent *
	3	*************************************************/
	4
	5	/* Copyright (c) Tom Kistner <tom@duncanthrax.net> 2004, 2015 */
	6	/* License: GPL */
	7
	8	/* Copyright (c) University of Cambridge 1995 - 2018 */
	9	/* Copyright (c) The Exim Maintainers 2020 */
	10	/* See the file NOTICE for conditions of use and distribution. */
	11
	12
	13	#include "exim.h"
	14	#ifdef WITH_CONTENT_SCAN /* file-IO specific decode function */
	15	# include "mime.h"
	16
	17	/* BASE64 decoder matrix */
	18	static unsigned char mime_b64[256]={
	19	/* 0 */ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
	20	/* 16 */ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
	21	/* 32 */ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 62, 128, 128, 128, 63,
	22	/* 48 */ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 255, 128, 128,
	23	/* 64 */ 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
	24	/* 80 */ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 128, 128, 128, 128, 128,
	25	/* 96 */ 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
	26	/* 112 */ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128,
	27	/* 128 */ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
	28	/* 144 */ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
	29	/* 160 */ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
	30	/* 176 */ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
	31	/* 192 */ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
	32	/* 208 */ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
	33	/* 224 */ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
	34	/* 240 */ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128
	35	};
	36
	37	/* decode base64 MIME part */
	38	ssize_t
	39	mime_decode_base64(FILE * in, FILE * out, uschar * boundary)
	40	{
	41	uschar ibuf[MIME_MAX_LINE_LENGTH], obuf[MIME_MAX_LINE_LENGTH];
	42	uschar *opos;
	43	ssize_t len, size = 0;
	44	int bytestate = 0;
	45
	46	opos = obuf;
	47
	48	while (Ufgets(ibuf, MIME_MAX_LINE_LENGTH, in) != NULL)
	49	{
	50	if (boundary != NULL
	51	&& Ustrncmp(ibuf, "--", 2) == 0
	52	&& Ustrncmp((ibuf+2), boundary, Ustrlen(boundary)) == 0
	53	)
	54	break;
	55
	56	for (uschar * ipos = ibuf ; ipos != '\r' && ipos != '\n' && *ipos; ++ipos)
	57	if (ipos == '=') / skip padding */
	58	++bytestate;
	59
	60	else if (mime_b64[ipos] == 128) / skip bad characters */
	61	mime_set_anomaly(MIME_ANOMALY_BROKEN_BASE64);
	62
	63	/* simple state-machine */
	64	else switch((bytestate++) & 3)
	65	{
	66	case 0:
	67	opos = mime_b64[ipos] << 2; break;
	68	case 1:
	69	opos++ \|= mime_b64[ipos] >> 4;
	70	opos = mime_b64[ipos] << 4; break;
	71	case 2:
	72	opos++ \|= mime_b64[ipos] >> 2;
	73	opos = mime_b64[ipos] << 6; break;
	74	case 3:
	75	opos++ \|= mime_b64[ipos]; break;
	76	}
	77
	78	/* something to write? */
	79	len = opos - obuf;
	80	if (len > 0)
	81	{
	82	if (fwrite(obuf, 1, len, out) != len) return -1; /* error */
	83	size += len;
	84	/* copy incomplete last byte to start of obuf, where we continue */
	85	if ((bytestate & 3) != 0)
	86	obuf = opos;
	87	opos = obuf;
	88	}
	89	} /* while */
	90
	91	/* write out last byte if it was incomplete */
	92	if (bytestate & 3)
	93	{
	94	if (fwrite(obuf, 1, 1, out) != 1) return -1;
	95	++size;
	96	}
	97
	98	return size;
	99	}
	100
	101	#endif /WITH_CONTENT_SCAN/
	102
	103	/*************************************************
	104	*************************************************
	105	*************************************************
	106	*************************************************
	107	*************************************************
	108	*************************************************
	109	*************************************************
	110	*************************************************
	111	*************************************************
	112	*************************************************
	113	*************************************************
	114	*************************************************
	115	*************************************************
	116	*************************************************
	117	*************************************************
	118	*************************************************/
	119
	120
	121	/*************************************************
	122	* Decode byte-string in base 64 *
	123	*************************************************/
	124
	125	/* This function decodes a string in base 64 format as defined in RFC 2045
	126	(MIME) and required by the SMTP AUTH extension (RFC 2554). The decoding
	127	algorithm is written out in a straightforward way. Turning it into some kind of
	128	compact loop is messy and would probably run more slowly.
	129
	130	Arguments:
	131	code points to the coded string, zero-terminated
	132	ptr where to put the pointer to the result, which is in
	133	allocated store, and zero-terminated
	134
	135	Returns: the number of bytes in the result,
	136	or -1 if the input was malformed
	137
	138	Whitespace in the input is ignored.
	139	A zero is added on to the end to make it easy in cases where the result is to
	140	be interpreted as text. This is not included in the count. */
	141
	142	static uschar dec64table[] = {
	143	255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, /* 0-15 */
	144	255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, /* 16-31 */
	145	255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63, /* 32-47 */
	146	52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,255,255,255, /* 48-63 */
	147	255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 64-79 */
	148	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255, /* 80-95 */
	149	255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 96-111 */
	150	41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255 /* 112-127*/
	151	};
	152
	153	int
	154	b64decode(const uschar code, uschar *ptr)
	155	{
	156
	157	int x, y;
	158	uschar *result;
	159
	160	{
	161	int l = Ustrlen(code);
	162	ptr = result = store_get(1 + l/4 3 + l%4, is_tainted(code));
	163	}
	164
	165	/* Each cycle of the loop handles a quantum of 4 input bytes. For the last
	166	quantum this may decode to 1, 2, or 3 output bytes. */
	167
	168	while ((x = *code++) != 0)
	169	{
	170	if (isspace(x)) continue;
	171	/* debug_printf("b64d: '%c'\n", x); */
	172
	173	if (x > 127 \|\| (x = dec64table[x]) == 255) return -1;
	174
	175	while (isspace(y = *code++)) ;
	176	/* debug_printf("b64d: '%c'\n", y); */
	177	if (y > 127 \|\| (y = dec64table[y]) == 255)
	178	return -1;
	179
	180	*result++ = (x << 2) \| (y >> 4);
	181	/* debug_printf("b64d: -> %02x\n", result[-1]); */
	182
	183	while (isspace(x = *code++)) ;
	184	/* debug_printf("b64d: '%c'\n", x); */
	185	if (x == '=') /* endmarker, but there should be another */
	186	{
	187	while (isspace(x = *code++)) ;
	188	/* debug_printf("b64d: '%c'\n", x); */
	189	if (x != '=') return -1;
	190	while (isspace(y = *code++)) ;
	191	if (y != 0) return -1;
	192	/* debug_printf("b64d: DONE\n"); */
	193	break;
	194	}
	195	else
	196	{
	197	if (x > 127 \|\| (x = dec64table[x]) == 255) return -1;
	198	*result++ = (y << 4) \| (x >> 2);
	199	/* debug_printf("b64d: -> %02x\n", result[-1]); */
	200
	201	while (isspace(y = *code++)) ;
	202	/* debug_printf("b64d: '%c'\n", y); */
	203	if (y == '=')
	204	{
	205	while (isspace(y = *code++)) ;
	206	if (y != 0) return -1;
	207	/* debug_printf("b64d: DONE\n"); */
	208	break;
	209	}
	210	else
	211	{
	212	if (y > 127 \|\| (y = dec64table[y]) == 255) return -1;
	213	*result++ = (x << 6) \| y;
	214	/* debug_printf("b64d: -> %02x\n", result[-1]); */
	215	}
	216	}
	217	}
	218
	219	*result = 0;
	220	return result - *ptr;
	221	}
	222
	223
	224	/*************************************************
	225	* Encode byte-string in base 64 *
	226	*************************************************/
	227
	228	/* This function encodes a string of bytes, containing any values whatsoever,
	229	in base 64 as defined in RFC 2045 (MIME) and required by the SMTP AUTH
	230	extension (RFC 2554). The encoding algorithm is written out in a
	231	straightforward way. Turning it into some kind of compact loop is messy and
	232	would probably run more slowly.
	233
	234	Arguments:
	235	clear points to the clear text bytes
	236	len the number of bytes to encode
	237
	238	Returns: a pointer to the zero-terminated base 64 string, which
	239	is in working store
	240	*/
	241
	242	static uschar *enc64table =
	243	US"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	244
	245	uschar *
	246	b64encode_taint(const uschar * clear, int len, BOOL tainted)
	247	{
	248	uschar code = store_get(4((len+2)/3) + 1, tainted);
	249	uschar *p = code;
	250
	251	while (len-- >0)
	252	{
	253	int x, y;
	254
	255	x = *clear++;
	256	*p++ = enc64table[(x >> 2) & 63];
	257
	258	if (len-- <= 0)
	259	{
	260	*p++ = enc64table[(x << 4) & 63];
	261	*p++ = '=';
	262	*p++ = '=';
	263	break;
	264	}
	265
	266	y = *clear++;
	267	*p++ = enc64table[((x << 4) \| ((y >> 4) & 15)) & 63];
	268
	269	if (len-- <= 0)
	270	{
	271	*p++ = enc64table[(y << 2) & 63];
	272	*p++ = '=';
	273	break;
	274	}
	275
	276	x = *clear++;
	277	*p++ = enc64table[((y << 2) \| ((x >> 6) & 3)) & 63];
	278
	279	*p++ = enc64table[x & 63];
	280	}
	281
	282	*p = 0;
	283
	284	return code;
	285	}
	286
	287	uschar *
	288	b64encode(const uschar * clear, int len)
	289	{
	290	return b64encode_taint(clear, len, is_tainted(clear));
	291	}
	292
	293
	294	/* End of base64.c */
	295	/* vi: sw ai sw=2
	296	*/