1 // Copyright 2020 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 #include "pw_base64/base64.h"
16
17 #include <cstdint>
18
19 #include "pw_assert/check.h"
20
21 namespace pw::base64 {
22 namespace {
23
24 // Encoding functions
25 constexpr size_t kEncodedGroupSize = 4;
26 constexpr char kChar62 = '+'; // URL safe encoding uses - instead
27 constexpr char kChar63 = '/'; // URL safe encoding uses _ instead
28 constexpr char kPadding = '=';
29
30 // Table that encodes a 6-bit pattern as a Base64 character
31 constexpr char kEncodeTable[64] = {
32 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
33 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
34 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
35 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
36 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', kChar62, kChar63};
37
BitGroup0Char(uint8_t byte0)38 constexpr char BitGroup0Char(uint8_t byte0) {
39 return kEncodeTable[(byte0 & 0b11111100) >> 2];
40 }
BitGroup1Char(uint8_t byte0,uint8_t byte1=0)41 constexpr char BitGroup1Char(uint8_t byte0, uint8_t byte1 = 0) {
42 return kEncodeTable[((byte0 & 0b00000011) << 4) |
43 ((byte1 & 0b11110000) >> 4)];
44 }
BitGroup2Char(uint8_t byte1,uint8_t byte2=0)45 constexpr char BitGroup2Char(uint8_t byte1, uint8_t byte2 = 0) {
46 return kEncodeTable[((byte1 & 0b00001111) << 2) |
47 ((byte2 & 0b11000000) >> 6)];
48 }
BitGroup3Char(uint8_t byte2)49 constexpr char BitGroup3Char(uint8_t byte2) {
50 return kEncodeTable[byte2 & 0b00111111];
51 }
52
53 // Decoding functions
54 constexpr char kMinValidChar = '+';
55 constexpr char kMaxValidChar = 'z';
56 constexpr uint8_t kX = 0xff; // Value used for invalid characters
57
58 // Table that decodes a Base64 character to its 6-bit value. Supports the
59 // standard (+/) and URL-safe (-_) alphabets. Starts from the lowest-value valid
60 // character, which is +.
61 constexpr uint8_t kDecodeTable[] = {
62 62, kX, 62, kX, 63, 52, 53, 54, 55, 56, // 0 - 09
63 57, 58, 59, 60, 61, kX, kX, kX, 0, kX, // 10 - 19
64 kX, kX, 0, 1, 2, 3, 4, 5, 6, 7, // 20 - 29
65 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, // 30 - 39
66 18, 19, 20, 21, 22, 23, 24, 25, kX, kX, // 40 - 49
67 kX, kX, 63, kX, 26, 27, 28, 29, 30, 31, // 50 - 59
68 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, // 60 - 69
69 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // 70 - 79
70 };
71
CharToBits(char ch)72 constexpr uint8_t CharToBits(char ch) {
73 return kDecodeTable[ch - kMinValidChar];
74 }
75
Byte0(uint8_t bits0,uint8_t bits1)76 constexpr uint8_t Byte0(uint8_t bits0, uint8_t bits1) {
77 return static_cast<uint8_t>(bits0 << 2) | ((bits1 & 0b110000) >> 4);
78 }
Byte1(uint8_t bits1,uint8_t bits2)79 constexpr uint8_t Byte1(uint8_t bits1, uint8_t bits2) {
80 return static_cast<uint8_t>((bits1 & 0b001111) << 4) |
81 ((bits2 & 0b111100) >> 2);
82 }
Byte2(uint8_t bits2,uint8_t bits3)83 constexpr uint8_t Byte2(uint8_t bits2, uint8_t bits3) {
84 return static_cast<uint8_t>((bits2 & 0b000011) << 6) | bits3;
85 }
86
87 } // namespace
88
pw_Base64Encode(const void * binary_data,const size_t binary_size_bytes,char * output)89 extern "C" void pw_Base64Encode(const void* binary_data,
90 const size_t binary_size_bytes,
91 char* output) {
92 const uint8_t* bytes = static_cast<const uint8_t*>(binary_data);
93
94 // Encode groups of 3 source bytes into 4 output characters.
95 size_t remaining = binary_size_bytes;
96 for (; remaining >= 3u; remaining -= 3u, bytes += 3) {
97 *output++ = BitGroup0Char(bytes[0]);
98 *output++ = BitGroup1Char(bytes[0], bytes[1]);
99 *output++ = BitGroup2Char(bytes[1], bytes[2]);
100 *output++ = BitGroup3Char(bytes[2]);
101 }
102
103 // If the source data length isn't a multiple of 3, pad the end with either 1
104 // or 2 '=' characters, to stay Python-compatible.
105 if (remaining > 0u) {
106 *output++ = BitGroup0Char(bytes[0]);
107 if (remaining == 1u) {
108 *output++ = BitGroup1Char(bytes[0]);
109 *output++ = kPadding;
110 } else {
111 *output++ = BitGroup1Char(bytes[0], bytes[1]);
112 *output++ = BitGroup2Char(bytes[1]);
113 }
114 *output++ = kPadding;
115 }
116 }
117
pw_Base64Decode(const char * base64,size_t base64_size_bytes,void * output)118 extern "C" size_t pw_Base64Decode(const char* base64,
119 size_t base64_size_bytes,
120 void* output) {
121 // If too small, can't be valid input, due to likely missing padding
122 if (base64_size_bytes < 4) {
123 return 0;
124 }
125
126 uint8_t* binary = static_cast<uint8_t*>(output);
127 for (size_t ch = 0; ch < base64_size_bytes; ch += kEncodedGroupSize) {
128 const uint8_t char0 = CharToBits(base64[ch + 0]);
129 const uint8_t char1 = CharToBits(base64[ch + 1]);
130 const uint8_t char2 = CharToBits(base64[ch + 2]);
131 const uint8_t char3 = CharToBits(base64[ch + 3]);
132
133 *binary++ = Byte0(char0, char1);
134 *binary++ = Byte1(char1, char2);
135 *binary++ = Byte2(char2, char3);
136 }
137
138 size_t pad = 0;
139 if (base64[base64_size_bytes - 2] == kPadding) {
140 pad = 2;
141 } else if (base64[base64_size_bytes - 1] == kPadding) {
142 pad = 1;
143 }
144
145 return static_cast<size_t>(binary - static_cast<uint8_t*>(output)) - pad;
146 }
147
pw_Base64IsValidChar(char base64_char)148 extern "C" bool pw_Base64IsValidChar(char base64_char) {
149 return !(base64_char < kMinValidChar || base64_char > kMaxValidChar ||
150 CharToBits(base64_char) == kX /* invalid char */);
151 }
152
pw_Base64IsValid(const char * base64_data,size_t base64_size)153 extern "C" bool pw_Base64IsValid(const char* base64_data, size_t base64_size) {
154 if (base64_size % kEncodedGroupSize != 0) {
155 return false;
156 }
157
158 for (size_t i = 0; i < base64_size; ++i) {
159 if (!pw_Base64IsValidChar(base64_data[i])) {
160 return false;
161 }
162 }
163 return true;
164 }
165
Encode(span<const std::byte> binary,span<char> output_buffer)166 size_t Encode(span<const std::byte> binary, span<char> output_buffer) {
167 const size_t required_size = EncodedSize(binary.size_bytes());
168 if (output_buffer.size_bytes() < required_size) {
169 return 0;
170 }
171 pw_Base64Encode(binary.data(), binary.size_bytes(), output_buffer.data());
172 return required_size;
173 }
174
Decode(std::string_view base64,span<std::byte> output_buffer)175 size_t Decode(std::string_view base64, span<std::byte> output_buffer) {
176 if (output_buffer.size_bytes() < MaxDecodedSize(base64.size()) ||
177 !IsValid(base64)) {
178 return 0;
179 }
180 return Decode(base64, output_buffer.data());
181 }
182
Encode(span<const std::byte> binary,InlineString<> & output)183 void Encode(span<const std::byte> binary, InlineString<>& output) {
184 const size_t initial_size = output.size();
185 const size_t final_size = initial_size + EncodedSize(binary.size());
186
187 PW_CHECK(final_size <= output.capacity());
188
189 output.resize_and_overwrite([&](char* data, size_t) {
190 Encode(binary, data + initial_size);
191 return final_size;
192 });
193 }
194
195 } // namespace pw::base64
196