Line data    Source code

       1              : // base64 encodig and decoding.
       2              : //
       3              : // Based on the implementations by
       4              : // Jouni Malinen <j@w1.fi> and contributors from wpa_supplicant and hostapd in
       5              : // http://web.mit.edu/freebsd/head/contrib/wpa/ and
       6              : // http://web.mit.edu/freebsd/head/contrib/wpa/src/utils/base64.c and
       7              : // http://web.mit.edu/freebsd/head/contrib/wpa/src/utils/base64.h
       8              : //
       9              : // Published under a 3-clause BSD license
      10              : //
      11              : 
      12              : #include <string>
      13              : #include <cstring>
      14              : #include <stdexcept>
      15              : 
      16              : #include "crpropa/base64.h"
      17              : 
      18              : namespace crpropa
      19              : {
      20              : 
      21              : //Alphabet used
      22              : static const unsigned char encode_alphabet[65] =
      23              : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
      24              : static int decode_alphabet[256] = {-1};
      25              : 
      26              : /// Encodes data
      27           99 : std::string Base64::encode(const unsigned char *src, size_t len)
      28              : {
      29           99 :                 size_t olen = 4*((len + 2) / 3); /* 3-byte blocks to 4-byte */
      30              : 
      31           99 :                 if (olen < len)
      32            0 :                         throw std::runtime_error("Integer overflow in Base64::encoding, data to large!");
      33              : 
      34              :                 std::string outStr;
      35              :                 outStr.resize(olen);
      36              : 
      37              :                 unsigned char *out = (unsigned char*) outStr.c_str();
      38              :                 unsigned char *pos = out;
      39              :                 const unsigned char *end, *in;
      40              : 
      41           99 :                 end = src + len;
      42              :                 in = src;
      43         6666 :                 while (end - in >= 3) {
      44         6567 :                                 *pos++ = encode_alphabet[in[0] >> 2];
      45         6567 :                                 *pos++ = encode_alphabet[((in[0] & 0x03) << 4) | (in[1] >> 4)];
      46         6567 :                                 *pos++ = encode_alphabet[((in[1] & 0x0f) << 2) | (in[2] >> 6)];
      47         6567 :                                 *pos++ = encode_alphabet[in[2] & 0x3f];
      48         6567 :                                 in += 3;
      49              :                 }
      50              : 
      51           99 :                 if (end - in) {
      52           66 :                                 *pos++ = encode_alphabet[in[0] >> 2];
      53           66 :                                 if (end - in == 1) {
      54           33 :                                                 *pos++ = encode_alphabet[(in[0] & 0x03) << 4];
      55           33 :                                                 *pos++ = '=';
      56              :                                 }
      57              :                                 else {
      58           33 :                                                 *pos++ = encode_alphabet[((in[0] & 0x03) << 4) |
      59           33 :                                                                 (in[1] >> 4)];
      60           33 :                                                 *pos++ = encode_alphabet[(in[1] & 0x0f) << 2];
      61              :                                 }
      62           66 :                                 *pos++ = '=';
      63              :                 }
      64              : 
      65           99 :                 return outStr;
      66              : }
      67              : 
      68              : 
      69          100 : std::string Base64::decode(const std::string &data)
      70              : {
      71              : const unsigned char *src = (unsigned char*) data.c_str();
      72              : size_t len = data.size();
      73              : 
      74          100 : if (decode_alphabet[0] == -1)
      75              : { // build decode alphabet
      76              :         std::memset(decode_alphabet, 0x80, 256);
      77           65 :         for (size_t i = 0; i < sizeof(encode_alphabet) - 1; i++)
      78           64 :                 decode_alphabet[encode_alphabet[i]] = (unsigned char) i;
      79            1 :         decode_alphabet['='] = 0;
      80              : }
      81              : 
      82              : size_t olen = 0;
      83        26656 : for (size_t i = 0; i < len; i++) {
      84        26556 :         if (decode_alphabet[src[i]] != 0x80)
      85        26556 :                 olen++;
      86              : }
      87              : 
      88          100 : if (olen == 0 || olen % 4)
      89            0 :                         throw std::runtime_error("Base64 decode, invalid input size");
      90              : 
      91          100 : olen = olen / 4 * 3;
      92              : std::string str;
      93              : str.resize(olen);
      94              : 
      95              : unsigned char *out = (unsigned char*) str.c_str();
      96              : unsigned char *pos = out;
      97              : 
      98              : size_t count = 0;
      99              : int pad = 0;
     100              : unsigned char block[4];
     101        26589 : for (size_t i = 0; i < len; i++) {
     102        26556 :         unsigned char tmp = decode_alphabet[src[i]];
     103        26556 :         if (tmp == 0x80)
     104            0 :                 continue;
     105              : 
     106        26556 :         if (src[i] == '=')
     107          101 :                 pad++;
     108        26556 :         block[count] = tmp;
     109        26556 :         count++;
     110        26556 :         if (count == 4) {
     111         6639 :                 *pos++ = (block[0] << 2) | (block[1] >> 4);
     112         6639 :                 *pos++ = (block[1] << 4) | (block[2] >> 2);
     113         6639 :                 *pos++ = (block[2] << 6) | block[3];
     114              :                 count = 0;
     115         6639 :                 if (pad) {
     116           67 :                         if (pad == 1)
     117              :                                 pos--;
     118           34 :                         else if (pad == 2)
     119              :                                 pos -= 2;
     120              :                         else {
     121            0 :                                 throw std::runtime_error("Base64 decode, invalid padding");
     122              :                         }
     123              :                         break;
     124              :                 }
     125              :         }
     126              : }
     127          100 : return str;
     128              : }
     129              : };