mg_base64_decode() and binary

[Juggler-5]

Hello. If I understand correctly, mg_base64_decode() does not process binaries, it only converts base-64 strings into "normal" strings, just like in docs?
Usage example:
char buf[128];
mg_base64_decode("Q2VzYW50YQ==", 12, buf, 128); // buf is now "Cesanta"
I pass binary data within JSON strings, and mg_base64_encode() fits well, but back convertion returns 0, if try something like
mg_base64_decode("AAAAAAAAAAAA", 12, buf, 128); // return 0
Hope I missed something, but if not, I think it could be a piece of use make base64 stuff do what it intended for.

[scaprile]

https://mongoose.ws/documentation/#mg_base64_decode

#include "mongoose.h"

int main(void) {
  uint8_t buf[128];
  int len = mg_base64_decode("AAAAAAAAAAAA", 12, buf, 128);
  MG_INFO(("len: %d", len));
  mg_hexdump(buf, len);
  return 0;
}

$ ./b
28d889aa 2 b.c:7:main                   len: 9
0000   00 00 00 00 00 00 00 00 00 00                     ..........      
$ 

mongoose/src/base64.c

Lines 16 to 17 in f618fe1

	if (c >= 'A' && c <= 'Z') {
	return c - 'A';

'A' --> 0

We use base64 decoding in our HTML processing and in our TLS stack, and it serves its purpose

mongoose/src/base64.c

Lines 69 to 93 in f618fe1

	size_t mg_base64_decode(const char *src, size_t n, char *dst, size_t dl) {
	const char *end = src == NULL ? NULL : src + n; // Cannot add to NULL
	size_t len = 0;
	if (dl < n / 4 * 3 + 1) goto fail;
	while (src != NULL && src + 3 < end) {
	int a = mg_base64_decode_single(src[0]),
	b = mg_base64_decode_single(src[1]),
	c = mg_base64_decode_single(src[2]),
	d = mg_base64_decode_single(src[3]);
	if (a == 64 || a < 0 || b == 64 || b < 0 || c < 0 || d < 0) {
	goto fail;
	}
	dst[len++] = (char) ((a << 2) | (b >> 4));
	if (src[2] != '=') {
	dst[len++] = (char) ((b << 4) | (c >> 2));
	if (src[3] != '=') dst[len++] = (char) ((c << 6) | d);
	}
	src += 4;
	}
	dst[len] = '\0';
	return len;
	fail:
	if (dl > 0) dst[0] = '\0';
	return 0;
	}

mongoose/src/base64.c

Lines 15 to 31 in f618fe1

	static int mg_base64_decode_single(int c) {
	if (c >= 'A' && c <= 'Z') {
	return c - 'A';
	} else if (c >= 'a' && c <= 'z') {
	return c + 26 - 'a';
	} else if (c >= '0' && c <= '9') {
	return c + 52 - '0';
	} else if (c == '+') {
	return 62;
	} else if (c == '/') {
	return 63;
	} else if (c == '=') {
	return 64;
	} else {
	return -1;
	}
	}

[Juggler-5]

My problem is here: if (dl < n / 4 * 3 + 1) goto fail; and dst[len] = '\0'; - you demand to provide larger buffer for eol. For example, I need encode 96 zeros, it results in 128 bytes of base64. Back convertion requires +1 byte to add to buffer. What makes it impossible to handle packed binary structures in an efficient way. Are you sure you treat binary as string all the time?

[Juggler-5]

Finally solved it by adding "mg_eol_guard" field in my binary structure to handle such an overflow. Anyway, hope you also find it reasonable to update mg_base64_decode() into a more safe version of it.