diff --git a/src/sled/strings/base64.cc b/src/sled/strings/base64.cc index 6a32e9e..1724671 100644 --- a/src/sled/strings/base64.cc +++ b/src/sled/strings/base64.cc @@ -5,9 +5,14 @@ #include #include #include +extern "C" { +#include "sled/strings/base64_decode.inc" +#include "sled/strings/base64_encode.inc" +} namespace sled { -const char kBase64Chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +static constexpr int kBufferSize = 4096; +const char kBase64Chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; std::array kInvBase64Chars; // static int kInvBase64Chars[(1 << sizeof(char))]; static OnceFlag once_flag; @@ -39,6 +44,30 @@ std::string Base64::Encode(const uint8_t *ptr, size_t len) { + if (len == 0) { return std::string(); } + std::string result((len + 2) / 3 * 4, '0'); + size_t write_idx = 0; + + base64_encodestate state; + base64_init_encodestate(&state); + + // char code[kBufferSize]; + int plainlength = 0; + int codelength = 0; + char *code = const_cast(result.data()) + write_idx; + do { + plainlength = std::min(kBufferSize, static_cast(len)); + codelength = base64_encode_block(reinterpret_cast(ptr), plainlength, code, &state); + code += codelength; + len -= plainlength; + ptr += plainlength; + } while (len > 0 && plainlength > 0); + + codelength = base64_encode_blockend(code, &state); + + return result; + + /* // std::stringstream ss; auto encoded_length = EncodedLength(len); std::string result(encoded_length, 0); @@ -58,11 +87,10 @@ Base64::Encode(const uint8_t *ptr, size_t len) --len; } - /** - * value_bits - * 2 -> 4 -> (8 - value_bits - 2) - * 4 -> 2 -> (8 - value_bits - 2) - **/ + // value_bits + // 2 -> 4 -> (8 - value_bits - 2) + // 4 -> 2 -> (8 - value_bits - 2) + // if (value_bits > 0) { result[write_idx++] = kBase64Chars[(value << (6 - value_bits)) & 0x3F]; // ss << kBase64Chars[((value << 8) >> (value_bits + 2)) & 0x3F]; @@ -72,11 +100,33 @@ Base64::Encode(const uint8_t *ptr, size_t len) // return ss.str(); return result; + */ } StatusOr Base64::Decode(const uint8_t *ptr, size_t len) { + if (len == 0) { return std::string(); } + + base64_decodestate state; + base64_init_decodestate(&state); + + std::stringstream ss; + char plaintext[kBufferSize]; + int codelength = 0; + int plainlength = 0; + do { + codelength = std::min(kBufferSize, static_cast(len)); + plainlength = base64_decode_block(reinterpret_cast(ptr), codelength, plaintext, &state); + ss.write(plaintext, plainlength); + + ptr += codelength; + len -= codelength; + } while (len > 0 && codelength > 0); + + return ss.str(); + /* + CallOnce(once_flag, [&] { std::fill(kInvBase64Chars.begin(), kInvBase64Chars.end(), -1); for (int i = 0; kBase64Chars[i]; i++) { kInvBase64Chars[kBase64Chars[i]] = i; } @@ -112,6 +162,7 @@ Base64::Decode(const uint8_t *ptr, size_t len) while (write_idx < data.size()) data.pop_back(); return make_status_or(data); + */ } }// namespace sled diff --git a/src/sled/strings/base64_bench.cc b/src/sled/strings/base64_bench.cc index 2cb8066..27654c6 100644 --- a/src/sled/strings/base64_bench.cc +++ b/src/sled/strings/base64_bench.cc @@ -39,5 +39,5 @@ Base64Decode(picobench::state &state) } } -PICOBENCH(Base64Encode); PICOBENCH(Base64Decode); +PICOBENCH(Base64Encode); diff --git a/src/sled/strings/base64_decode.inc b/src/sled/strings/base64_decode.inc new file mode 100644 index 0000000..b323b83 --- /dev/null +++ b/src/sled/strings/base64_decode.inc @@ -0,0 +1,85 @@ +typedef enum { step_a, step_b, step_c, step_d } base64_decodestep; + +typedef struct { + base64_decodestep step; + char plainchar; +} base64_decodestate; + +int +base64_decode_value(char value_in) +{ + static const char decoding[] + = {62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1, -1, 0, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51}; + static const char decoding_size = sizeof(decoding); + value_in -= 43; + if (value_in < 0 || value_in > decoding_size) return -1; + return decoding[(int) value_in]; +} + +void +base64_init_decodestate(base64_decodestate *state_in) +{ + state_in->step = step_a; + state_in->plainchar = 0; +} + +int +base64_decode_block(const char *code_in, const int length_in, char *plaintext_out, base64_decodestate *state_in) +{ + const char *codechar = code_in; + char *plainchar = plaintext_out; + char fragment; + + *plainchar = state_in->plainchar; + + switch (state_in->step) { + while (1) { + case step_a: + do { + if (codechar == code_in + length_in) { + state_in->step = step_a; + state_in->plainchar = *plainchar; + return plainchar - plaintext_out; + } + fragment = (char) base64_decode_value(*codechar++); + } while (fragment < 0); + *plainchar = (fragment & 0x03f) << 2; + case step_b: + do { + if (codechar == code_in + length_in) { + state_in->step = step_b; + state_in->plainchar = *plainchar; + return plainchar - plaintext_out; + } + fragment = (char) base64_decode_value(*codechar++); + } while (fragment < 0); + *plainchar++ |= (fragment & 0x030) >> 4; + *plainchar = (fragment & 0x00f) << 4; + case step_c: + do { + if (codechar == code_in + length_in) { + state_in->step = step_c; + state_in->plainchar = *plainchar; + return plainchar - plaintext_out; + } + fragment = (char) base64_decode_value(*codechar++); + } while (fragment < 0); + *plainchar++ |= (fragment & 0x03c) >> 2; + *plainchar = (fragment & 0x003) << 6; + case step_d: + do { + if (codechar == code_in + length_in) { + state_in->step = step_d; + state_in->plainchar = *plainchar; + return plainchar - plaintext_out; + } + fragment = (char) base64_decode_value(*codechar++); + } while (fragment < 0); + *plainchar++ |= (fragment & 0x03f); + } + } + /* control should not reach here */ + return plainchar - plaintext_out; +} diff --git a/src/sled/strings/base64_encode.inc b/src/sled/strings/base64_encode.inc new file mode 100644 index 0000000..5af5639 --- /dev/null +++ b/src/sled/strings/base64_encode.inc @@ -0,0 +1,120 @@ +/* +cencoder.c - c source to a base64 encoding algorithm implementation + +This is part of the libb64 project, and has been placed in the public domain. +For details, see http://sourceforge.net/projects/libb64 +*/ + +typedef enum +{ + step_A, step_B, step_C +} base64_encodestep; + +typedef struct +{ + base64_encodestep step; + char result; + int stepcount; +} base64_encodestate; + +const int CHARS_PER_LINE = 72; + +void base64_init_encodestate(base64_encodestate* state_in) +{ + state_in->step = step_A; + state_in->result = 0; + state_in->stepcount = 0; +} + +char base64_encode_value(char value_in) +{ + static const char* encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + if (value_in > 63) return '='; + return encoding[(int)value_in]; +} + +int base64_encode_block(const char* plaintext_in, int length_in, char* code_out, base64_encodestate* state_in) +{ + const char* plainchar = plaintext_in; + const char* const plaintextend = plaintext_in + length_in; + char* codechar = code_out; + char result; + char fragment; + + result = state_in->result; + + switch (state_in->step) + { + while (1) + { + case step_A: + if (plainchar == plaintextend) + { + state_in->result = result; + state_in->step = step_A; + return codechar - code_out; + } + fragment = *plainchar++; + result = (fragment & 0x0fc) >> 2; + *codechar++ = base64_encode_value(result); + result = (fragment & 0x003) << 4; + case step_B: + if (plainchar == plaintextend) + { + state_in->result = result; + state_in->step = step_B; + return codechar - code_out; + } + fragment = *plainchar++; + result |= (fragment & 0x0f0) >> 4; + *codechar++ = base64_encode_value(result); + result = (fragment & 0x00f) << 2; + case step_C: + if (plainchar == plaintextend) + { + state_in->result = result; + state_in->step = step_C; + return codechar - code_out; + } + fragment = *plainchar++; + result |= (fragment & 0x0c0) >> 6; + *codechar++ = base64_encode_value(result); + result = (fragment & 0x03f) >> 0; + *codechar++ = base64_encode_value(result); + + ++(state_in->stepcount); + if (state_in->stepcount == CHARS_PER_LINE/4) + { + // *codechar++ = '\n'; + state_in->stepcount = 0; + } + } + } + /* control should not reach here */ + return codechar - code_out; +} + +int base64_encode_blockend(char* code_out, base64_encodestate* state_in) +{ + char* codechar = code_out; + + switch (state_in->step) + { + case step_B: + *codechar++ = base64_encode_value(state_in->result); + *codechar++ = '='; + *codechar++ = '='; + break; + case step_C: + *codechar++ = base64_encode_value(state_in->result); + *codechar++ = '='; + break; + case step_A: + break; + } + // *codechar++ = '\n'; + + return codechar - code_out; +} + + diff --git a/src/sled/strings/base64_test.cc b/src/sled/strings/base64_test.cc index 2c13d52..e43ad1c 100644 --- a/src/sled/strings/base64_test.cc +++ b/src/sled/strings/base64_test.cc @@ -31,6 +31,7 @@ TEST_SUITE("Base64") CHECK_EQ("aGVsbG8gd29ybGQK", sled::Base64::Encode("hello world\n")); CHECK_EQ("U2VuZCByZWluZm9yY2VtZW50cwo=", sled::Base64::Encode("Send reinforcements\n")); CHECK_EQ("", sled::Base64::Encode("")); + CHECK_EQ(sled::Base64::Encode(""), ""); CHECK_EQ("IA==", sled::Base64::Encode(" ")); CHECK_EQ("AA==", sled::Base64::Encode(std::string("\0", 1))); CHECK_EQ("AAA=", sled::Base64::Encode(std::string("\0\0", 2)));