算法系列8《Base64》
Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一，Base64编码可用于在HTTP环境下传递较长的标识信息。在其他应用程序中，也常常需要把二进制数据编码为适合放在URL（包括隐藏表单域）中的形式。此时，采用Base64编码具有不可读性，即所编码的数据不会被人用肉眼所直接看到。金融数据也常以base64编码格式提供。
Base64是一种基于64个可打印字符来表示二进制数据的表示方法。由于2的6次方等于64，所以每6个比特为一个单元，对应某个可打印字符。三个字节有24个比特，对应于4个Base64单元，即3个字节需要用4个可打印字符来表示。它可用来作为电子邮件的传输编码。在Base64中的可打印字符包括字母A-Z、a-z、数字0-9，这样共有62个字符，此外两个可打印符号在不同的系统中而不同。一些如uuencode的其他编码方法，和之后binhex的版本使用不同的64字符集来代表6个二进制数字，但是它们不叫Base64。
Base64索引表
C++实现代码
1. 《Base64.h》
// Base64.h
#pragma once
#include <windows.h>
class CBase64
{
// Internal bucket class.
class TempBucket
{
public:
BYTE nData[4];
BYTE nSize;
void Clear() { ::ZeroMemory(nData, 4); nSize = 0; };
};
PBYTE m_pDBuffer;
PBYTE m_pEBuffer;
DWORD m_nDBufLen;
DWORD m_nEBufLen;
DWORD m_nDDataLen;
DWORD m_nEDataLen;
public:
CBase64();
virtual ~CBase64();
public:
virtual PBYTE Encode(const PBYTE, DWORD);
virtual PBYTE Decode(const PBYTE, DWORD);
virtual CString Encode(LPCSTR sMessage);
virtual CString Decode(LPCSTR sMessage);
virtual LPCSTR DecodedMessage() const;
virtual LPCSTR EncodedMessage() const;
virtual void AlloCEncodeDlg(DWORD);
virtual void AllocDecode(DWORD);
virtual void SetEncodeBuffer(const PBYTE pBuffer, DWORD nBufLen);
virtual void SetDecodeBuffer(const PBYTE pBuffer, DWORD nBufLen);
protected:
virtual void _EncodeToBuffer(const TempBucket &Decode, PBYTE pBuffer);
virtual ULONG _DecodeToBuffer(const TempBucket &Decode, PBYTE pBuffer);
virtual void _EncodeRaw(TempBucket &, const TempBucket &);
virtual void _DecodeRaw(TempBucket &, const TempBucket &);
virtual BOOL _IsBadMimeChar(BYTE);
static char m_DecodeTable[256];
static BOOL m_Init;
void _Init();
};
2. 《CBase64.cpp》
// CBase64.cpp
// CBase64.cpp: implementation of the CBase64 class.
//////////////////////////////////////////////////////////////////////
#include "stdAfx.h"
#include "Base64.h"
#include "DataX.h"
using namespace DataX;
// Digits...
static char Base64Digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
BOOL CBase64::m_Init = FALSE;
char CBase64::m_DecodeTable[256];
#ifndef PAGESIZE
#define PAGESIZE 4096
#endif
#ifndef ROUNDTOPAGE
#define ROUNDTOPAGE(a) ((((a) / 4096) + 1) * 4096)
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CBase64::CBase64()
: m_pDBuffer(NULL),
m_pEBuffer(NULL),
m_nDBufLen(0),
m_nEBufLen(0)
{
}
CBase64::~CBase64()
{
if (m_pDBuffer != NULL)
{
delete [] m_pDBuffer;
}
if (m_pEBuffer != NULL)
{
delete [] m_pEBuffer;
}
}
LPCSTR CBase64::DecodedMessage() const
{
return (LPCSTR) m_pDBuffer;
}
LPCSTR CBase64::EncodedMessage() const
{
return (LPCSTR) m_pEBuffer;
}
void CBase64::AlloCEncodeDlg(DWORD nSize)
{
if (m_nEBufLen < nSize)
{
if (m_pEBuffer != NULL)
delete [] m_pEBuffer;
m_nEBufLen = ROUNDTOPAGE(nSize);
m_pEBuffer = new BYTE[m_nEBufLen];
}
::ZeroMemory(m_pEBuffer, m_nEBufLen);
m_nEDataLen = 0;
}
void CBase64::AllocDecode(DWORD nSize)
{
if (m_nDBufLen < nSize)
{
if (m_pDBuffer != NULL)
{
delete [] m_pDBuffer;
}
m_nDBufLen = ROUNDTOPAGE(nSize);
m_pDBuffer = new BYTE[m_nDBufLen];
}
::ZeroMemory(m_pDBuffer, m_nDBufLen);
m_nDDataLen = 0;
}
void CBase64::SetEncodeBuffer(const PBYTE pBuffer, DWORD nBufLen)
{
DWORD ii = 0;
AlloCEncodeDlg(nBufLen);
while(ii < nBufLen)
{
if (!_IsBadMimeChar(pBuffer[ii]))
{
m_pEBuffer[m_nEDataLen] = pBuffer[ii];
m_nEDataLen ++ ;
}
ii ++ ;
}
}
void CBase64::SetDecodeBuffer(const PBYTE pBuffer, DWORD nBufLen)
{
AllocDecode(nBufLen);
::CopyMemory(m_pDBuffer, pBuffer, nBufLen);
m_nDDataLen = nBufLen;
}
PBYTE CBase64::Encode(const PBYTE pBuffer, DWORD nBufLen)
{
SetDecodeBuffer(pBuffer, nBufLen);
AlloCEncodeDlg(nBufLen * 2);
TempBucket Raw;
DWORD nIndex = 0;
while((nIndex + 3) <= nBufLen)
{
Raw.Clear();
::CopyMemory(&Raw, m_pDBuffer + nIndex, 3);
Raw.nSize = 3;
_EncodeToBuffer(Raw, m_pEBuffer + m_nEDataLen);
nIndex += 3;
m_nEDataLen += 4;
}
if (nBufLen > nIndex)
{
Raw.Clear();
Raw.nSize = (BYTE) (nBufLen - nIndex);
::CopyMemory(&Raw, m_pDBuffer + nIndex, nBufLen - nIndex);
_EncodeToBuffer(Raw, m_pEBuffer + m_nEDataLen);
m_nEDataLen += 4;
}
return m_pEBuffer;
}
CString CBase64::Encode(LPCSTR szMessage)
{
CString strHex = _T("");
if (szMessage != NULL)
{
CBase64::Encode((const PBYTE)szMessage, lstrlenA(szMessage));
if (m_nEDataLen > 0)
{
AscToHex(m_pEBuffer, m_nEDataLen, strHex);
}
}
return strHex;
}
PBYTE CBase64::Decode(const PBYTE pBuffer, DWORD dwBufLen)
{
if (!CBase64::m_Init)
_Init();
SetEncodeBuffer(pBuffer, dwBufLen);
AllocDecode(dwBufLen);
TempBucket Raw;
DWORD nIndex = 0;
while((nIndex + 4) <= m_nEDataLen)
{
Raw.Clear();
Raw.nData[0] = CBase64::m_DecodeTable[m_pEBuffer[nIndex]];
Raw.nData[1] = CBase64::m_DecodeTable[m_pEBuffer[nIndex + 1]];
Raw.nData[2] = CBase64::m_DecodeTable[m_pEBuffer[nIndex + 2]];
Raw.nData[3] = CBase64::m_DecodeTable[m_pEBuffer[nIndex + 3]];
if (Raw.nData[2] == 255)
Raw.nData[2] = 0;
if (Raw.nData[3] == 255)
Raw.nData[3] = 0;
Raw.nSize = 4;
_DecodeToBuffer(Raw, m_pDBuffer + m_nDDataLen);
nIndex += 4;
m_nDDataLen += 3;
}
// If nIndex < m_nEDataLen, then we got a decode message without padding.
// We may want to throw some kind of warning here, but we are still required
// to handle the decoding as if it was properly padded.
if (nIndex < m_nEDataLen)
{
Raw.Clear();
for(DWORD ii = nIndex; ii < m_nEDataLen; ii ++ )
{
Raw.nData[ii - nIndex] = CBase64::m_DecodeTable[m_pEBuffer[ii]];
Raw.nSize ++ ;
if (Raw.nData[ii - nIndex] == 255)
Raw.nData[ii - nIndex] = 0;
}
_DecodeToBuffer(Raw, m_pDBuffer + m_nDDataLen);
m_nDDataLen += (m_nEDataLen - nIndex);
}
return m_pDBuffer;
}
CString CBase64::Decode(LPCSTR pszMessage)
{
if (!pszMessage)
{
return _T("");
}
CBase64::Decode((const PBYTE)pszMessage, lstrlenA(pszMessage));
CString strHex = _T("");
if (m_nDDataLen > 0)
{
AscToHex(m_pDBuffer, m_nDDataLen, strHex);
}
return strHex;
}
DWORD CBase64::_DecodeToBuffer(const TempBucket &Decode, PBYTE pBuffer)
{
TempBucket Data;
DWORD nCount = 0;
_DecodeRaw(Data, Decode);
for(int ii = 0; ii < 3; ii ++ )
{
pBuffer[ii] = Data.nData[ii];
if (pBuffer[ii] != 255)
nCount ++ ;
}
return nCount;
}
void CBase64::_EncodeToBuffer(const TempBucket &Decode, PBYTE pBuffer)
{
TempBucket Data;
_EncodeRaw(Data, Decode);
for(int ii = 0; ii < 4; ii ++ )
pBuffer[ii] = Base64Digits[Data.nData[ii]];
switch(Decode.nSize)
{
case 1:
pBuffer[2] = '=';
case 2:
pBuffer[3] = '=';
}
}
void CBase64::_DecodeRaw(TempBucket &Data, const TempBucket &Decode)
{
BYTE nTemp;
Data.nData[0] = Decode.nData[0];
Data.nData[0] <<= 2;
nTemp = Decode.nData[1];
nTemp >>= 4;
nTemp &= 0x03;
Data.nData[0] |= nTemp;
Data.nData[1] = Decode.nData[1];
Data.nData[1] <<= 4;
nTemp = Decode.nData[2];
nTemp >>= 2;
nTemp &= 0x0F;
Data.nData[1] |= nTemp;
Data.nData[2] = Decode.nData[2];
Data.nData[2] <<= 6;
nTemp = Decode.nData[3];
nTemp &= 0x3F;
Data.nData[2] |= nTemp;
}
void CBase64::_EncodeRaw(TempBucket &Data, const TempBucket &Decode)
{
BYTE nTemp;
Data.nData[0] = Decode.nData[0];
Data.nData[0] >>= 2;
Data.nData[1] = Decode.nData[0];
Data.nData[1] <<= 4;
nTemp = Decode.nData[1];
nTemp >>= 4;
Data.nData[1] |= nTemp;
Data.nData[1] &= 0x3F;
Data.nData[2] = Decode.nData[1];
Data.nData[2] <<= 2;
nTemp = Decode.nData[2];
nTemp >>= 6;
Data.nData[2] |= nTemp;
Data.nData[2] &= 0x3F;
Data.nData[3] = Decode.nData[2];
Data.nData[3] &= 0x3F;
}
BOOL CBase64::_IsBadMimeChar(BYTE nData)
{
switch(nData)
{
case '\r': case '\n': case '\t': case ' ' :
case '\b': case '\a': case '\f': case '\v':
return TRUE;
default:
return FALSE;
}
}
void CBase64::_Init()
{
// Initialize Decoding table.
int ii;
for(ii = 0; ii < 256; ii ++ )
CBase64::m_DecodeTable[ii] = -2;
for(ii = 0; ii < 64; ii ++ )
{
CBase64::m_DecodeTable[Base64Digits[ii]] = (CHAR)ii;
CBase64::m_DecodeTable[Base64Digits[ii]|0x80] = (CHAR)ii;
}
CBase64::m_DecodeTable['='] = -1;
CBase64::m_DecodeTable['='|0x80] = -1;
CBase64::m_Init = TRUE;
}
文/yanxin8原创，获取更多信息请访问http://yanxin8.com/277.html