You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
442 lines
13 KiB
442 lines
13 KiB
/* Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License, version 2.0,
|
|
as published by the Free Software Foundation.
|
|
|
|
This program is also distributed with certain software (including
|
|
but not limited to OpenSSL) that is licensed under separate terms,
|
|
as designated in a particular file or component or in included license
|
|
documentation. The authors of MySQL hereby grant you an additional
|
|
permission to link the program and your derivative works with the
|
|
separately licensed software that they have included with MySQL.
|
|
|
|
Without limiting anything contained in the foregoing, this file,
|
|
which is part of C Driver for MySQL (Connector/C), is also subject to the
|
|
Universal FOSS Exception, version 1.0, a copy of which can be found at
|
|
http://oss.oracle.com/licenses/universal-foss-exception.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License, version 2.0, for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
|
|
|
#include "base64.h"
|
|
|
|
#include <math.h>
|
|
#include <stddef.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
|
|
#include "my_config.h"
|
|
#include "my_dbug.h"
|
|
|
|
/**
|
|
@file mysys/base64.cc
|
|
*/
|
|
|
|
#ifndef MAIN
|
|
|
|
static char base64_table[] =
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
"abcdefghijklmnopqrstuvwxyz"
|
|
"0123456789+/";
|
|
|
|
/**
|
|
* Maximum length base64_needed_encoded_length()
|
|
* can handle without overflow.
|
|
*/
|
|
uint64 base64_encode_max_arg_length() {
|
|
#if (SIZEOF_VOIDP == 8)
|
|
/*
|
|
6827690988321067803 -> 9223372036854775805
|
|
6827690988321067804 -> -9223372036854775807
|
|
*/
|
|
return 0x5EC0D4C77B03531BLL;
|
|
#else
|
|
/*
|
|
1589695686 -> 2147483646
|
|
1589695687 -> -2147483645
|
|
*/
|
|
return 0x5EC0D4C6;
|
|
#endif
|
|
}
|
|
|
|
uint64 base64_needed_encoded_length(uint64 length_of_data) {
|
|
uint64 nb_base64_chars;
|
|
if (length_of_data == 0) return 1;
|
|
nb_base64_chars = (length_of_data + 2) / 3 * 4;
|
|
|
|
return nb_base64_chars + /* base64 char incl padding */
|
|
(nb_base64_chars - 1) / 76 + /* newlines */
|
|
1; /* NUL termination of string */
|
|
}
|
|
|
|
/**
|
|
* Maximum length base64_needed_decoded_length()
|
|
* can handle without overflow.
|
|
*/
|
|
uint64 base64_decode_max_arg_length() {
|
|
#if (SIZEOF_VOIDP == 8)
|
|
return 0x2AAAAAAAAAAAAAAALL;
|
|
#else
|
|
return 0x2AAAAAAA;
|
|
#endif
|
|
}
|
|
|
|
uint64 base64_needed_decoded_length(uint64 length_of_encoded_data) {
|
|
return static_cast<uint64>(
|
|
ceil(static_cast<double>(length_of_encoded_data * 3 / 4)));
|
|
}
|
|
|
|
/*
|
|
Encode a data as base64.
|
|
|
|
Note: We require that dst is pre-allocated to correct size.
|
|
See base64_needed_encoded_length().
|
|
*/
|
|
|
|
int base64_encode(const void *src, size_t src_len, char *dst) {
|
|
const unsigned char *s = (const unsigned char *)src;
|
|
size_t i = 0;
|
|
size_t len = 0;
|
|
|
|
for (; i < src_len; len += 4) {
|
|
unsigned c;
|
|
|
|
if (len == 76) {
|
|
len = 0;
|
|
*dst++ = '\n';
|
|
}
|
|
|
|
c = s[i++];
|
|
c <<= 8;
|
|
|
|
if (i < src_len) c += s[i];
|
|
c <<= 8;
|
|
i++;
|
|
|
|
if (i < src_len) c += s[i];
|
|
i++;
|
|
|
|
*dst++ = base64_table[(c >> 18) & 0x3f];
|
|
*dst++ = base64_table[(c >> 12) & 0x3f];
|
|
|
|
if (i > (src_len + 1))
|
|
*dst++ = '=';
|
|
else
|
|
*dst++ = base64_table[(c >> 6) & 0x3f];
|
|
|
|
if (i > src_len)
|
|
*dst++ = '=';
|
|
else
|
|
*dst++ = base64_table[(c >> 0) & 0x3f];
|
|
}
|
|
*dst = '\0';
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
Base64 decoder stream
|
|
*/
|
|
typedef struct my_base64_decoder_t {
|
|
const char *src; /* Pointer to the current input position */
|
|
const char *end; /* Pointer to the end of input buffer */
|
|
uint c; /* Collect bits into this number */
|
|
int error; /* Error code */
|
|
uchar state; /* Character number in the current group of 4 */
|
|
uchar mark; /* Number of padding marks in the current group */
|
|
} MY_BASE64_DECODER;
|
|
|
|
/*
|
|
Helper table for decoder.
|
|
-2 means "space character"
|
|
-1 means "bad character"
|
|
Non-negative values mean valid base64 encoding character.
|
|
*/
|
|
static int8 from_base64_table[] = {
|
|
/*00*/ -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -2, -2, -2, -2, -2, -1, -1,
|
|
/*10*/ -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
/*20*/ -2, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 62, -1, -1, -1, 63, /* !"#$%&'()*+,-./ */
|
|
/*30*/ 52, 53, 54, 55, 56, 57, 58, 59,
|
|
60, 61, -1, -1, -1, -1, -1, -1, /* 0123456789:;<=>? */
|
|
/*40*/ -1, 0, 1, 2, 3, 4, 5, 6,
|
|
7, 8, 9, 10, 11, 12, 13, 14, /* @ABCDEFGHIJKLMNO */
|
|
/*50*/ 15, 16, 17, 18, 19, 20, 21, 22,
|
|
23, 24, 25, -1, -1, -1, -1, -1, /* PQRSTUVWXYZ[\]^_ */
|
|
/*60*/ -1, 26, 27, 28, 29, 30, 31, 32,
|
|
33, 34, 35, 36, 37, 38, 39, 40, /* `abcdefghijklmno */
|
|
/*70*/ 41, 42, 43, 44, 45, 46, 47, 48,
|
|
49, 50, 51, -1, -1, -1, -1, -1, /* pqrstuvwxyz{|}~ */
|
|
/*80*/ -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
/*90*/ -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
/*A0*/ -2, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
/*B0*/ -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
/*C0*/ -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
/*D0*/ -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
/*E0*/ -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1,
|
|
/*F0*/ -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1};
|
|
|
|
/**
|
|
* Skip leading spaces in a base64 encoded stream
|
|
* and stop on the first non-space character.
|
|
* decoder->src will point to the first non-space character,
|
|
* or to the end of the input string.
|
|
* In case when end-of-input met on unexpected position,
|
|
* decoder->error is also set to 1.
|
|
*
|
|
* @param decoder Pointer to MY_BASE64_DECODER
|
|
*
|
|
* @return
|
|
* false on success (there are some more non-space input characters)
|
|
* true on error (end-of-input found)
|
|
*/
|
|
static inline bool my_base64_decoder_skip_spaces(MY_BASE64_DECODER *decoder) {
|
|
for (; decoder->src < decoder->end; decoder->src++) {
|
|
if (from_base64_table[(uchar)*decoder->src] != -2) return false;
|
|
}
|
|
if (decoder->state > 0)
|
|
decoder->error = 1; /* Unexpected end-of-input found */
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Convert the next character in a base64 encoded stream
|
|
* to a number in the range [0..63]
|
|
* and mix it with the previously collected value in decoder->c.
|
|
*
|
|
* @param decoder base64 decoding stream
|
|
*
|
|
* @return
|
|
* false on success
|
|
* true on error (invalid base64 character found)
|
|
*/
|
|
static inline bool my_base64_add(MY_BASE64_DECODER *decoder) {
|
|
int res;
|
|
decoder->c <<= 6;
|
|
if ((res = from_base64_table[(uchar)*decoder->src++]) < 0)
|
|
return (decoder->error = true);
|
|
decoder->c += (uint)res;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get the next character from a base64 encoded stream.
|
|
* Skip spaces, then scan the next base64 character or a pad character
|
|
* and collect bits into decoder->c.
|
|
*
|
|
* @param decoder Pointer to MY_BASE64_DECODER
|
|
* @return
|
|
* false on success (a valid base64 encoding character found)
|
|
* true on error (unexpected character or unexpected end-of-input found)
|
|
*/
|
|
static inline bool my_base64_decoder_getch(MY_BASE64_DECODER *decoder) {
|
|
if (my_base64_decoder_skip_spaces(decoder)) return true; /* End-of-input */
|
|
|
|
if (!my_base64_add(decoder)) /* Valid base64 character found */
|
|
{
|
|
if (decoder->mark) {
|
|
/* If we have scanned '=' already, then only '=' is valid */
|
|
DBUG_ASSERT(decoder->state == 3);
|
|
decoder->error = 1;
|
|
decoder->src--;
|
|
return true; /* expected '=', but encoding character found */
|
|
}
|
|
decoder->state++;
|
|
return false;
|
|
}
|
|
|
|
/* Process error */
|
|
switch (decoder->state) {
|
|
case 0:
|
|
case 1:
|
|
decoder->src--;
|
|
return true; /* base64 character expected */
|
|
|
|
case 2:
|
|
case 3:
|
|
if (decoder->src[-1] == '=') {
|
|
decoder->error = 0; /* Not an error - it's a pad character */
|
|
decoder->mark++;
|
|
} else {
|
|
decoder->src--;
|
|
return true; /* base64 character or '=' expected */
|
|
}
|
|
break;
|
|
|
|
default:
|
|
DBUG_ASSERT(0);
|
|
return true; /* Wrong state, should not happen */
|
|
}
|
|
|
|
decoder->state++;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Decode a base64 string
|
|
* The base64-encoded data in the range ['src','*end_ptr') will be
|
|
* decoded and stored starting at 'dst'. The decoding will stop
|
|
* after 'len' characters have been read from 'src', or when padding
|
|
* occurs in the base64-encoded data. In either case: if 'end_ptr' is
|
|
* non-null, '*end_ptr' will be set to point to the character after
|
|
* the last read character, even in the presence of error.
|
|
*
|
|
* Note: We require that 'dst' is pre-allocated to correct size.
|
|
*
|
|
* @param src_base Pointer to base64-encoded string
|
|
* @param len Length of string at 'src'
|
|
* @param dst Pointer to location where decoded data will be stored
|
|
* @param end_ptr Pointer to variable that will refer to the character
|
|
* after the end of the encoded data that were decoded.
|
|
* Can be NULL.
|
|
* @param flags flags e.g. allow multiple chunks
|
|
* @return Number of bytes written at 'dst', or -1 in case of failure
|
|
*/
|
|
int64 base64_decode(const char *src_base, size_t len, void *dst,
|
|
const char **end_ptr, int flags) {
|
|
char *d = (char *)dst;
|
|
MY_BASE64_DECODER decoder;
|
|
|
|
decoder.src = src_base;
|
|
decoder.end = src_base + len;
|
|
decoder.error = 0;
|
|
decoder.mark = 0;
|
|
|
|
for (;;) {
|
|
decoder.c = 0;
|
|
decoder.state = 0;
|
|
|
|
if (my_base64_decoder_getch(&decoder) ||
|
|
my_base64_decoder_getch(&decoder) ||
|
|
my_base64_decoder_getch(&decoder) || my_base64_decoder_getch(&decoder))
|
|
break;
|
|
|
|
*d++ = (decoder.c >> 16) & 0xff;
|
|
*d++ = (decoder.c >> 8) & 0xff;
|
|
*d++ = (decoder.c >> 0) & 0xff;
|
|
|
|
if (decoder.mark) {
|
|
d -= decoder.mark;
|
|
if (!(flags & MY_BASE64_DECODE_ALLOW_MULTIPLE_CHUNKS)) break;
|
|
decoder.mark = 0;
|
|
}
|
|
}
|
|
|
|
/* Return error if there are more non-space characters */
|
|
decoder.state = 0;
|
|
if (!my_base64_decoder_skip_spaces(&decoder)) decoder.error = 1;
|
|
|
|
if (end_ptr != NULL) *end_ptr = decoder.src;
|
|
|
|
return decoder.error ? -1 : (int)(d - (char *)dst);
|
|
}
|
|
|
|
#else /* MAIN */
|
|
|
|
#define require(b) \
|
|
{ \
|
|
if (!(b)) { \
|
|
printf("Require failed at %s:%d\n", __FILE__, __LINE__); \
|
|
abort(); \
|
|
} \
|
|
}
|
|
|
|
int main(void) {
|
|
int i;
|
|
size_t j;
|
|
size_t k, l;
|
|
size_t dst_len;
|
|
size_t needed_length;
|
|
char *src;
|
|
char *s;
|
|
char *str;
|
|
char *dst;
|
|
const char *end_ptr;
|
|
size_t src_len;
|
|
|
|
for (i = 0; i <= 500; i++) {
|
|
/* Create source data */
|
|
if (i == 500) {
|
|
#if (SIZEOF_VOIDP == 8)
|
|
printf("Test case for base64 max event length: 2119594243\n");
|
|
src_len = 2119594243;
|
|
#else
|
|
printf("Test case for base64 max event length: 536870912\n");
|
|
src_len = 536870912;
|
|
#endif
|
|
} else
|
|
src_len = rand() % 1000 + 1;
|
|
|
|
src = (char *)malloc(src_len);
|
|
s = src;
|
|
|
|
require(src);
|
|
for (j = 0; j < src_len; j++) {
|
|
char c = rand();
|
|
*s++ = c;
|
|
}
|
|
|
|
/* Encode */
|
|
needed_length = base64_needed_encoded_length(src_len);
|
|
str = (char *)malloc(needed_length);
|
|
require(str);
|
|
for (k = 0; k < needed_length; k++)
|
|
str[k] = 0xff; /* Fill memory to check correct NUL termination */
|
|
require(base64_encode(src, src_len, str) == 0);
|
|
require(needed_length == strlen(str) + 1);
|
|
|
|
/* Decode */
|
|
dst = (char *)malloc(base64_needed_decoded_length(strlen(str)));
|
|
require(dst);
|
|
dst_len = base64_decode(str, strlen(str), dst, &end_ptr, 0);
|
|
require(dst_len == src_len);
|
|
|
|
if (memcmp(src, dst, src_len) != 0) {
|
|
printf(" --------- src --------- --------- dst ---------\n");
|
|
for (k = 0; k < src_len; k += 8) {
|
|
printf("%.4x ", (uint)k);
|
|
for (l = 0; l < 8 && k + l < src_len; l++) {
|
|
unsigned char c = src[k + l];
|
|
printf("%.2x ", (unsigned)c);
|
|
}
|
|
|
|
printf(" ");
|
|
|
|
for (l = 0; l < 8 && k + l < dst_len; l++) {
|
|
unsigned char c = dst[k + l];
|
|
printf("%.2x ", (unsigned)c);
|
|
}
|
|
printf("\n");
|
|
}
|
|
printf("src length: %.8x, dst length: %.8x\n", (uint)src_len,
|
|
(uint)dst_len);
|
|
require(0);
|
|
}
|
|
free(src);
|
|
free(str);
|
|
free(dst);
|
|
}
|
|
printf("Test succeeded.\n");
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|