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.