Base64 编解码

Base64编码简介

　　Base64用来将binary的字节序列数据编码成ASCII字符序列构成的文本。其使用的字符包括大小写字母各26个，加上10个数字，和加号“+”，斜杠“/”，一共64个字符。另外还使用等号“=”用来作为后缀。
　　Base64编码要求把3个8位字节(3*8=24)转化为4个6位的字节(4*6=24)，之后在6位的前面补两个0，形成8位一个字节的形式。如果剩下的字符不足3个字节，则用0填充，最后的输出字符时使用'='作为结尾，因此编码后输出的文本末尾可能会出现1或2个'='。
　　为了保证所输出的编码字符都是可读的，Base64制定了一个编码表，以便进行统一转换。编码表的大小为2^6=64。

Base64编码表
码值    字符    码值    字符    码值    字符    码值    字符
    A        Q        g        w
    B        R        h        x
    C        S        i        y
    D        T        j        z
    E        U        k
    F        V        l
    G        W        m
    H        X        n
    I        Y        o
    J        Z        p
    K        a        q
    L        b        r
    M        c        s
    N        d        t
    O        e        u        +
    P        f        v        /

C++实现

#ifndef __BASE64_UTILS__
#define __BASE64_UTILS__
 
#include <string>
 
using std::string;
 
class Base64Utils
{
public:
    Base64Utils(void);
    ~Base64Utils(void);
 
    /**
        将一个字节数组中的数据转为一个 base64 格式的数组
    */
    static string Encode(const unsigned char* pEncodeData, int nLength);
 
    /**
        nLength 为 0 时返回需要 pOutBuffer 需要分配的大小; 否则解码数据, 并存入 pOutBuffer 指向的内存中.
        返回值: 失败时返回0. 否则返回反解码后的字符的个数
    */
    static int Decode(const string& strBase64, unsigned char* pOutBuffer, int nLength);
 
    /** 解析为一个字符串(由调用者确定解出的字符中不包含'\0'才能能调用此函数,否则返回的结果可能不是期望的值) */
    static string DecodeToString(const string& strBase64);
 
    /** 检查一个字符是否是 base64 编码的字符 */
    static bool CheckBase64(unsigned char bas64Char);
 
protected:
    template <class T> static T min(T left, T right);
};
 
#endif __BASE64_UTILS__

#include "Base64Utils.h"
 
// Base64 编码所用的字符, 其顺序由 base64 协议规定
static const string BASE64_ENCODE_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
// 将 ascii 码表中, 对应的 Base64 字符的改成 Base64 字符表中的索引值, 以便解码时进行转行转换
static const unsigned char BASE64_DECODE_TABLE[] =
{
    , , , , , , , , , , , , , , , , , , , , , , , ,
    , , , , , , , , , , , , , , , , , , ,
    , // '+'
    , , ,
    , // '/'
    , , , , , , , , , , // '0'-'9'
    , , , , , , ,
    , , , , , , , , , , , , , , , , , , , , , , , , , , // 'A'-'Z'
    , , , , , ,
    , , , , , , , , , , , , , , , , , , , , , , , , , , // 'a'-'z'
};
 
static const unsigned char BASE64_END_CHARACTER = '=';
 
Base64Utils::Base64Utils(void)
{
}
 
Base64Utils::~Base64Utils(void)
{
}
 
template <class T> T Base64Utils::min(T left, T right)
{
    return (left < right) ? left : right;
}
 
bool Base64Utils::CheckBase64(unsigned char bas64Char)
{
    return (BASE64_ENCODE_TABLE.find(bas64Char) != -) ? true : false;
}
 
string Base64Utils::Encode(const unsigned char* pEncodeData, int nLength)
{
    string strBase64;
 
    int i = ;
    for (; i +  < nLength; i += )
    {
        strBase64.push_back(BASE64_ENCODE_TABLE.at((pEncodeData[i] >> ) & 0x3f));
        strBase64.push_back(BASE64_ENCODE_TABLE.at(((pEncodeData[i] & 0x03) << ) | ((pEncodeData[i + ] >> ) & 0x0f)));
        strBase64.push_back(BASE64_ENCODE_TABLE.at(((pEncodeData[i + ] & 0x0f) << ) | ((pEncodeData[i + ] >> ) & 0x03)));
        strBase64.push_back(BASE64_ENCODE_TABLE.at(pEncodeData[i + ] & 0x3f));
    }
 
    if (i < nLength)
    {
        strBase64.push_back(BASE64_ENCODE_TABLE.at((pEncodeData[i] >> ) & 0x3f));
        if (i +  < nLength)
        {
            strBase64.push_back(BASE64_ENCODE_TABLE.at(((pEncodeData[i] & 0x03) << ) | ((pEncodeData[i + ] >> ) & 0x0f)));
            strBase64.push_back(BASE64_ENCODE_TABLE.at(((pEncodeData[i + ] & 0x0f) << )));
        }
        else
        {
            strBase64.push_back(BASE64_ENCODE_TABLE.at(((pEncodeData[i] & 0x03) << )));
            strBase64.push_back(BASE64_END_CHARACTER);
        }
        strBase64.push_back(BASE64_END_CHARACTER);
    }
 
    return strBase64;
}
 
int Base64Utils::Decode(const string& strBase64, unsigned char* pOutBuffer, int nLength)
{
    nLength = abs(nLength);
    int nBase64 = strBase64.length();
    /** 不符合 base64 字符串长度要求的字符串, 不是 base64 编码格式的字符串, 返回 0 */
    if ((nBase64 == ) || ((nBase64 % ) != ))
    {
        return ;
    }
 
    int nNeedSize = nBase64 *  / ;
    if (strBase64.at(nBase64 - ) == BASE64_END_CHARACTER)
        nNeedSize--;
    if (strBase64.at(nBase64 - ) == BASE64_END_CHARACTER)
        nNeedSize--;
 
    if ( == nLength)
    {
        return nNeedSize;
    }
 
    nNeedSize = min(nNeedSize, nLength);
 
    const int nSizeOfDecode = sizeof(BASE64_DECODE_TABLE);
    int index = ;
    int k = ;
    unsigned char byteValue;
    unsigned char base64Char;
    unsigned char base64Arr[] = {};
    for (int i = ; i < nBase64; i++)
    {
        base64Char = strBase64.at(i);
        if (base64Char == BASE64_END_CHARACTER) // 遇到结速符
        {
            break;
        }
 
        /**
            如果 base64字符为编码表中只有一个字符, 其解码后值一定为 0
            否则, 到解码表中查找对应的值, 如果找到, 并且值不为 0, 才是符合的 base64 编码的字符.
            如果不是 base64 编码表中的字符, 则解码失败, 设置返回值为 0
        */
        if (base64Char == BASE64_ENCODE_TABLE.at())
        {
            byteValue = ;
        }
        else
        {
            if (base64Char < nSizeOfDecode)
            {
                byteValue = BASE64_DECODE_TABLE[base64Char];
            }
            if (byteValue == )
            {
                nNeedSize = ;
                break;
            }
        }
 
        base64Arr[k++] = byteValue;
 
        if (k == )
        {
            if (index >= nNeedSize)
                break;
            pOutBuffer[index++] = ((base64Arr[] & 0x3f) << ) | ((base64Arr[] & 0x30) >> );
            if (index >= nNeedSize)
                break;
            pOutBuffer[index++] = ((base64Arr[] & 0x0f) << ) | ((base64Arr[] & 0x3c) >> );
            if (index >= nNeedSize)
                break;
            pOutBuffer[index++] = ((base64Arr[] & 0x03) << ) | ((base64Arr[] & 0x3f));
            k = ;
        }
    }
 
    if ((k != ) && (index < nNeedSize))
    {
        for (; k < ; k++)
        {
            base64Arr[k] = ;
        }
        if (index < nNeedSize)
            pOutBuffer[index++] = ((base64Arr[] & 0x3f) << ) | ((base64Arr[] & 0x30) >> );
        if (index < nNeedSize)
            pOutBuffer[index++] = ((base64Arr[] & 0x0f) << ) | ((base64Arr[] & 0x3c) >> );
        if (index < nNeedSize)
            pOutBuffer[index++] = ((base64Arr[] & 0x03) << ) | ((base64Arr[] & 0x3f));
    }
 
    return nNeedSize;
}
 
string Base64Utils::DecodeToString(const string& strBase64)
{
    string strResult;
    int nSize = Decode(strBase64, NULL, );
    if (nSize == )
    {
        return strResult;
    }
    unsigned char* pOutBuffer = new unsigned char[nSize + ];
    if (!pOutBuffer)
    {
        return strResult;
    }
    pOutBuffer[nSize] = ;
    nSize = Decode(strBase64, pOutBuffer, nSize);
    if (nSize != )
    {
        strResult = reinterpret_cast<char*>(pOutBuffer);
    }
    delete[] pOutBuffer;
    pOutBuffer = NULL;
    return strResult;
}

测试代码

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include "Base64Utils.h"
 
#define PRINT_BYTE(str, len) {printf("[%03d]", len); for(int t = 0; t < len; t++) printf("%c", str[t]); printf("\n");}
 
int _tmain(int argc, _TCHAR* argv[])
{
    unsigned char pBuffer[] = "~!@#$%^&\0*(\t)_+{}:\"?></.,;'[]\\";
 
    int nCount = sizeof(pBuffer);
    printf("count=%d\n", nCount);
    for (int i = ; i <= nCount; i++)
    {
        string str(&pBuffer[], &pBuffer[i]);
        printf("----------  input %d ------------\n", i);
        printf("%s\n", str.c_str());
        string strBase64My = Base64Utils::Encode(pBuffer, i);
        printf("%s\n", strBase64My.c_str());
 
        int nOutSize = Base64Utils::Decode(strBase64My, NULL, );
        printf("need buffer : %d\n", nOutSize);
 
        //printf("decode:%s\n", Base64Utils::DecodeToString(strBase64My).c_str());
 
        //if (strBase64My.length() > 2)
        //{
        //    strBase64My.replace(strBase64My.begin() + 2, strBase64My.begin() + 3, 1, ',');
        //    printf("%s\n", strBase64My.c_str());
        //}
 
        int j = nOutSize;
        for (; j > ; j--)
        {
            unsigned char* pOutBuffer = new unsigned char[j + ];
            memset(pOutBuffer, , j + );
            //pOutBuffer[j] = 0;
            j = Base64Utils::Decode(strBase64My, pOutBuffer, j);
            // printf("[%03d]%s\n", j, pOutBuffer);
            PRINT_BYTE(pOutBuffer, j);
            delete[] pOutBuffer;
            pOutBuffer = NULL;
        }
    }
    system("pause");
    return ;
}