base64.c
No One
Actions

Authored By

	dereckson
	May 14 2023, 12:39

Size

6 KB

Referenced Files

None

Subscribers

None

base64.c
View Options

	/* -------------------------------------------------------------
	Base64 - RFC 1341
	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	Description: Base64 helper functions
	Author: Jouni Malinen <j@w1.fi>
	License: BSD-2-Clause
	Source: This version has been extracted from FreeBSD
	source code - src/contrib/wpa/src/utils/base64.c
	Commit source: 0a6760a1de32bf5df91ef926eba25b3f74b4f84f
	------------------------------------------------------------- */

	#include <stdint.h>
	#include <stdlib.h>
	#include <string.h>

	#ifndef BIT
	#define BIT(x) (1U << (x))
	#endif

	/* -------------------------------------------------------------
	Helper functions to actually do the encode/decode work
	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

	static const char base64_table[65] =
	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

	#define BASE64_PAD BIT(0)
	#define BASE64_LF BIT(1)

	static char * base64_gen_encode(const unsigned char *src, size_t len,
	size_t out_len, const char table, int add_pad)
	{
	char out, pos;
	const unsigned char end, in;
	size_t olen;
	int line_len;

	if (len >= SIZE_MAX / 4)
	return NULL;
	olen = len * 4 / 3 + 4; /* 3-byte blocks to 4-byte */
	if (add_pad & BASE64_LF)
	olen += olen / 72; /* line feeds */
	olen++; /* nul termination */
	if (olen < len)
	return NULL; /* integer overflow */
	out = malloc(olen);
	if (out == NULL)
	return NULL;

	end = src + len;
	in = src;
	pos = out;
	line_len = 0;
	while (end - in >= 3) {
	*pos++ = table[(in[0] >> 2) & 0x3f];
	*pos++ = table[(((in[0] & 0x03) << 4) \| (in[1] >> 4)) & 0x3f];
	*pos++ = table[(((in[1] & 0x0f) << 2) \| (in[2] >> 6)) & 0x3f];
	*pos++ = table[in[2] & 0x3f];
	in += 3;
	line_len += 4;
	if ((add_pad & BASE64_LF) && line_len >= 72) {
	*pos++ = '\n';
	line_len = 0;
	}
	}

	if (end - in) {
	*pos++ = table[(in[0] >> 2) & 0x3f];
	if (end - in == 1) {
	*pos++ = table[((in[0] & 0x03) << 4) & 0x3f];
	if (add_pad & BASE64_PAD)
	*pos++ = '=';
	} else {
	*pos++ = table[(((in[0] & 0x03) << 4) \|
	(in[1] >> 4)) & 0x3f];
	*pos++ = table[((in[1] & 0x0f) << 2) & 0x3f];
	}
	if (add_pad & BASE64_PAD)
	*pos++ = '=';
	line_len += 4;
	}

	if ((add_pad & BASE64_LF) && line_len)
	*pos++ = '\n';

	*pos = '\0';
	if (out_len)
	*out_len = pos - out;
	return out;
	}

	static unsigned char * base64_gen_decode(const char *src, size_t len,
	size_t out_len, const char table)
	{
	unsigned char dtable[256], out, pos, block[4], tmp;
	size_t i, count, olen;
	int pad = 0;
	size_t extra_pad;

	memset(dtable, 0x80, 256);
	for (i = 0; i < sizeof(base64_table) - 1; i++)
	dtable[(unsigned char) table[i]] = (unsigned char) i;
	dtable['='] = 0;

	count = 0;
	for (i = 0; i < len; i++) {
	if (dtable[(unsigned char) src[i]] != 0x80)
	count++;
	}

	if (count == 0)
	return NULL;
	extra_pad = (4 - count % 4) % 4;

	olen = (count + extra_pad) / 4 * 3;
	pos = out = malloc(olen);
	if (out == NULL)
	return NULL;

	count = 0;
	for (i = 0; i < len + extra_pad; i++) {
	unsigned char val;

	if (i >= len)
	val = '=';
	else
	val = src[i];
	tmp = dtable[val];
	if (tmp == 0x80)
	continue;

	if (val == '=')
	pad++;
	block[count] = tmp;
	count++;
	if (count == 4) {
	*pos++ = (block[0] << 2) \| (block[1] >> 4);
	*pos++ = (block[1] << 4) \| (block[2] >> 2);
	*pos++ = (block[2] << 6) \| block[3];
	count = 0;
	if (pad) {
	if (pad == 1)
	pos--;
	else if (pad == 2)
	pos -= 2;
	else {
	/* Invalid padding */
	free(out);
	return NULL;
	}
	break;
	}
	}
	}

	*out_len = pos - out;
	return out;
	}

	/* -------------------------------------------------------------
	High-level functions to use as library
	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

	/**
	* base64_encode - Base64 encode
	* @src: Data to be encoded
	* @len: Length of the data to be encoded
	* @out_len: Pointer to output length variable, or %NULL if not used
	* Returns: Allocated buffer of out_len bytes of encoded data,
	* or %NULL on failure
	*
	* Caller is responsible for freeing the returned buffer. Returned buffer is
	* nul terminated to make it easier to use as a C string. The nul terminator is
	* not included in out_len.
	*/
	char * base64_encode(const void src, size_t len, size_t out_len)
	{
	return base64_gen_encode(src, len, out_len, base64_table,
	BASE64_PAD \| BASE64_LF);
	}

	/**
	* base64_decode - Base64 decode
	* @src: Data to be decoded
	* @len: Length of the data to be decoded
	* @out_len: Pointer to output length variable
	* Returns: Allocated buffer of out_len bytes of decoded data,
	* or %NULL on failure
	*
	* Caller is responsible for freeing the returned buffer.
	*/
	unsigned char * base64_decode(const char src, size_t len, size_t out_len)
	{
	return base64_gen_decode(src, len, out_len, base64_table);
	}

File Metadata

Mime Type: text/plain; charset=utf-8
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1393316
Default Alt Text: base64.c (6 KB)

base64.cNo OneActions

base64.cView Options

File Metadata

Event Timeline

base64.c
No One
Actions

base64.c
View Options