Algorithm series 8 "Base64", algorithm 8 "base64"

Algorithm series 8 "Base64", algorithm 8 "base64"

Base64 is one of the most common encoding methods used to transmit 8-bit code on the network. Base64 encoding can be used to transmit long identification information in the HTTP environment. In other applications, binary data is often encoded in a URL (including hidden form fields) format. At this time, Base64 encoding is not readable, that is, the encoded data is not directly seen by the human eye. Financial data is also provided in base64 encoding format.

Base64 is a representation of binary data based on 64 printable characters. Because the power of 6 in 2 is equal to 64, every 6 bits are a unit and correspond to a printable character. The three bytes have 24 BITs, which correspond to four Base64 units. That is, the three bytes are represented by four printable characters. It can be used as the transmission code of the email. The printable characters in Base64 include letters A-Z, a-z, and numbers 0-9, which have A total of 62 characters. The two printable characters are different in different systems. Some other encoding methods such as uuencode, and later binhex versions use different 64 character sets to represent six binary numbers, but they are not called base64.

Base64 index table

C ++ implementation code

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;}

Text/Xin Xinyuan ChongReprinted please indicate the source http://blog.csdn.net/yxstars/article/details/39031279

After the AES + BASE64 algorithm is encrypted, the ciphertext is JfdQlodleoekfeoiefwoHokY =. The last two values can be decrypted, and three values can be decrypted.

= Is the length of the string .. no actual meaning .. if there are only a few = numbers, you need to look at the length of the letter above... the first letter Length plus the equal number is an integral multiple of 3... the last two, two, and three equal signs are incorrect .. because the encrypted length must be an integer multiple of 3.

Base64 Algorithm

The latest. net Framework should already include this algorithm. You can simply use the relevant functions without writing them yourself. You can check the principle on the Internet. The advantage of BASE64 encoding is that it can encode any file such as Chinese characters. The encoded file only contains 26 letters and standard symbols on the keyboard, the advantage is that the encoded file is universal and can be processed by any crashing platform. For example, some foreign systems do not take into account the processing of Chinese and Japanese characters, therefore, an email may be lost or messed up by a network processing device that does not support the text through the internet. This problem will not occur after B64 encoding, therefore, this encoding method is widely used in emails.