Permalink
Fetching contributors…
Cannot retrieve contributors at this time
176 lines (143 sloc) 4.98 KB
// util/base64.cpp
/* Copyright 2009 10gen Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
* 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, the copyright holders give permission to link the
* code of portions of this program with the OpenSSL library under certain
* conditions as described in each individual source file and distribute
* linked combinations including the program with the OpenSSL library. You
* must comply with the GNU Affero General Public License in all respects
* for all of the code used other than as permitted herein. If you modify
* file(s) with this exception, you may extend this exception to your
* version of the file(s), but you are not obligated to do so. If you do not
* wish to do so, delete this exception statement from your version. If you
* delete this exception statement from all source files in the program,
* then also delete it in the license file.
*/
#include "mongo/platform/basic.h"
#include "mongo/util/base64.h"
#include "mongo/util/assert_util.h"
#include <array>
namespace mongo {
using std::begin;
using std::end;
using std::string;
using std::stringstream;
namespace {
constexpr unsigned char kInvalid = -1;
const class Alphabet {
public:
Alphabet() {
decode.fill(kInvalid);
for (size_t i = 0; i < encode.size(); ++i) {
decode[encode[i]] = i;
}
}
unsigned char e(std::uint8_t x) const {
return encode[x & 0x3f];
}
std::uint8_t d(unsigned char x) const {
auto const c = decode[x];
uassert(40537, "Invalid base64 character", c != kInvalid);
return c;
}
bool valid(unsigned char x) const {
return decode[x] != kInvalid;
}
private:
StringData encode{
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/"};
std::array<unsigned char, 256> decode;
} alphabet;
} // namespace
void base64::encode(stringstream& ss, const char* data, int size) {
for (int i = 0; i < size; i += 3) {
int left = size - i;
const unsigned char* start = (const unsigned char*)data + i;
// byte 0
ss << alphabet.e(start[0] >> 2);
// byte 1
unsigned char temp = (start[0] << 4);
if (left == 1) {
ss << alphabet.e(temp);
break;
}
temp |= ((start[1] >> 4) & 0xF);
ss << alphabet.e(temp);
// byte 2
temp = (start[1] & 0xF) << 2;
if (left == 2) {
ss << alphabet.e(temp);
break;
}
temp |= ((start[2] >> 6) & 0x3);
ss << alphabet.e(temp);
// byte 3
ss << alphabet.e(start[2] & 0x3f);
}
int mod = size % 3;
if (mod == 1) {
ss << "==";
} else if (mod == 2) {
ss << "=";
}
}
string base64::encode(const char* data, int size) {
stringstream ss;
encode(ss, data, size);
return ss.str();
}
string base64::encode(const string& s) {
return encode(s.c_str(), s.size());
}
void base64::decode(stringstream& ss, const string& s) {
uassert(10270, "invalid base64", s.size() % 4 == 0);
auto const data = reinterpret_cast<const unsigned char*>(s.c_str());
auto const size = s.size();
bool done = false;
for (size_t i = 0; i < size; i += 4) {
uassert(
40538, "Invalid Base64 stream. Additional data following terminating sequence.", !done);
auto const start = data + i;
done = (start[2] == '=') || (start[3] == '=');
ss << (char)(((alphabet.d(start[0]) << 2) & 0xFC) | ((alphabet.d(start[1]) >> 4) & 0x3));
if (start[2] != '=') {
ss << (char)(((alphabet.d(start[1]) << 4) & 0xF0) |
((alphabet.d(start[2]) >> 2) & 0xF));
if (!done) {
ss << (char)(((alphabet.d(start[2]) << 6) & 0xC0) |
((alphabet.d(start[3]) & 0x3F)));
}
}
}
}
string base64::decode(const string& s) {
stringstream ss;
decode(ss, s);
return ss.str();
}
bool base64::validate(const StringData s) {
if (s.size() % 4) {
return false;
}
if (s.empty()) {
return true;
}
auto const unwindTerminator = [](auto it) { return (*(it - 1) == '=') ? (it - 1) : it; };
auto const e = unwindTerminator(unwindTerminator(end(s)));
return e == std::find_if(begin(s), e, [](const char ch) { return !alphabet.valid(ch); });
}
} // namespace mongo