Кодировка Base 64 Потеря данных

Я не уверен, смогу ли я легко придумать более медленный метод преобразования Base-64.

Код требует 4 заголовка (в Mac OS X 10.7.5 с G ++ 4.7.1) и опцию компилятора -std=c++11 сделать #include <cstdint> приемлемый:

#include <string>
#include <iostream>
#include <sstream>
#include <cstdint>

Это также требует функции ToString() это не было определено; Я создал:

std::string ToString(int value)
{
std::stringstream ss;
ss << value;
return ss.str();
}

Код в вашем main() — это то, что использует ToString() Функция — это немного странно: зачем вам собирать строку из кусочков, а не просто использовать "IMG.677*604"?

Также стоит распечатать промежуточный результат:

int main()
{
std::string Data = EncodeBase64("IMG." + ::ToString(677) + "*" + ::ToString(604));
std::cout << Data << std::endl;
std::cout << DecodeBase64(Data) << std::endl;        //Prints IMG.677*601
}

Это дает:

SU1HLjY3Nyo2MDE===
IMG.677*601

Выходная строка (SU1HLjY3Nyo2MDE===) длиной 18 байт; это должно быть неправильно, так как действительная строка в кодировке Base-64 должна быть кратна длине 4 байта (так как три 8-битных байта кодируются в четыре байта, каждый из которых содержит 6 битов исходных данных). Это сразу говорит нам, что есть проблемы. Вы должны получить только ноль, одну или две площадки (=) персонажи; никогда три Это также подтверждает, что есть проблемы.

Удаление двух символов пэда оставляет допустимую строку Base-64. Когда я использую мои собственные функции кодирования и декодирования Base-64 для декодирования вашего (усеченного) вывода, он дает мне:

Base64:
0x0000: SU1HLjY3Nyo2MDE=
Binary:
0x0000: 49 4D 47 2E 36 37 37 2A 36 30 31 00               IMG.677*601.

Таким образом, кажется, что вы закодировали нулевое окончание строки. Когда я кодирую IMG.677*604, вывод, который я получаю:

Binary:
0x0000: 49 4D 47 2E 36 37 37 2A 36 30 34                  IMG.677*604
Base64: SU1HLjY3Nyo2MDQ=

Вы говорите, что хотите ускорить свой код. Помимо исправления так, чтобы он правильно кодировал (я не очень изучал декодирование), вы захотите избежать всех манипуляций со строками, которые вы делаете. Это должно быть небольшое упражнение по манипуляции, а не упражнение по манипуляции со струнами.

У меня есть 3 маленьких подпрограммы кодирования в моем коде для кодирования триплетов, дублетов и синглетов:

/* Encode 3 bytes of data into 4 */
static void encode_triplet(const char *triplet, char *quad)
{
quad[0] = base_64_map[(triplet[0] >> 2) & 0x3F];
quad[1] = base_64_map[((triplet[0] & 0x03) << 4) | ((triplet[1] >> 4) & 0x0F)];
quad[2] = base_64_map[((triplet[1] & 0x0F) << 2) | ((triplet[2] >> 6) & 0x03)];
quad[3] = base_64_map[triplet[2] & 0x3F];
}

/* Encode 2 bytes of data into 4 */
static void encode_doublet(const char *doublet, char *quad, char pad)
{
quad[0] = base_64_map[(doublet[0] >> 2) & 0x3F];
quad[1] = base_64_map[((doublet[0] & 0x03) << 4) | ((doublet[1] >> 4) & 0x0F)];
quad[2] = base_64_map[((doublet[1] & 0x0F) << 2)];
quad[3] = pad;
}

/* Encode 1 byte of data into 4 */
static void encode_singlet(const char *singlet, char *quad, char pad)
{
quad[0] = base_64_map[(singlet[0] >> 2) & 0x3F];
quad[1] = base_64_map[((singlet[0] & 0x03) << 4)];
quad[2] = pad;
quad[3] = pad;
}

Это написано как код C, а не как нативные идиомы C ++, но показанный код должен компилироваться с C ++ (в отличие от инициализаторов C99 в других местах исходного кода). base_64_map[] массив соответствует вашему Base64Chars строка. pad символ передается обычно '=', но может быть '\0' поскольку у системы, с которой я работаю, есть эксцентричные идеи о том, что нет необходимости в заполнении (предшествует моему участию в коде, и для загрузки используется нестандартный алфавит), а код обрабатывает как нестандартные, так и RFC 3548 стандарт.

Водительский код:

/* Encode input data as Base-64 string.  Output length returned, or negative error */
static int base64_encode_internal(const char *data, size_t datalen, char *buffer, size_t buflen, char pad)
{
size_t outlen = BASE64_ENCLENGTH(datalen);
const char *bin_data = (const void *)data;
char *b64_data = (void *)buffer;

if (outlen > buflen)
return(B64_ERR_OUTPUT_BUFFER_TOO_SMALL);
while (datalen >= 3)
{
encode_triplet(bin_data, b64_data);
bin_data += 3;
b64_data += 4;
datalen -= 3;
}
b64_data[0] = '\0';

if (datalen == 2)
encode_doublet(bin_data, b64_data, pad);
else if (datalen == 1)
encode_singlet(bin_data, b64_data, pad);
b64_data[4] = '\0';
return((b64_data - buffer) + strlen(b64_data));
}

/* Encode input data as Base-64 string.  Output length returned, or negative error */
int base64_encode(const char *data, size_t datalen, char *buffer, size_t buflen)
{
return(base64_encode_internal(data, datalen, buffer, buflen, base64_pad));
}

base64_pad константа является '='; также есть base64_encode_nopad() функция, которая поставляет '\0' вместо. Ошибки несколько произвольны, но имеют отношение к коду.

Главное, на что следует обратить внимание, это то, что вы должны выполнять битовую манипуляцию и создавать строку, которая является точным кратным 4 байтам для данного ввода.

std::string EncodeBase64(std::string Data)
{
std::string Binary = std::string();
std::string Result = std::string();

for (std::size_t I = 0; I < Data.size(); ++I)
{
Binary += DecToBinStr(Data[I], 8);
}

if (Binary.size() % 6)
{
Binary.resize(Binary.size() + 6 - Binary.size() % 6, '0');
}

for (std::size_t I = 0; I < Binary.size(); I += 6)
{
Result += Base64Chars[BinToDecStr(Copy(Binary, I, 6))];
if (I == 0) ++I;
}

if (Result.size() % 4)
{
Result.resize(Result.size() + 4 - Result.size() % 4, '=');
}

return Result;
}