Encoding and decoding base64 with C++

• Download source_code.zip-45.5KB
• Download binary_files.zip-124KB

Introduction

The Base 64 encoding is designed to represent arbitrary sequences of octets in a form that requires case sensitivity but need not be humanly readable.

A 65-character subset of US-ASCII is used, enabling 6 bits to be represented per printable character.(The extra 65th character, "=",is used to signify a special processing function.)

Here we have the Base64 characters map:

64-character subset : ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ 
Extra character     : =

How does it work?

Base64 encoding takes three bytes (each byte consisting of eight bits) and represents them as four printable characters in the ASCII standard.

These transformations are making in two steps:

1. Convert three bytes to four numbers of six bits. Each character in the ASCII code is formed from seven bits. Base64 only uses 6 bits (2^6 = 64 characters) to ensure encoded data is printable and humanly readable. None of the special characters available in ASCII are used.
2. These numbers are converted to ASCII characters using the Base64 encoding map.

This two-step process is applied to the whole sequence of bytes that are encoded.

If the size of the original buffer is not multiple of three we should add one or two octets. For proper encoding the buffer length should be multiple of 3.

These bytes (one or two) will be equal with ‘0’. In this way we have created a 3-byte group. These artificial values ‘0’ cannot be encoded using the encoded table . They are represented by a 65th character. This character is ‘=’ and it can only appear at the end of encoded data.

The source code

Class definition

class CBase64 { public: CBase64(void); ~CBase64(void); std::string base64_encode(BYTE* ptrBuffer, UINT buffLen); std::string base64_decode(std::string const & encoded_string); private: static const std::string base64_map; static inline bool is_base64Char(BYTE ch) { return (isalnum(ch) || (ch == '+') || (ch == '/')); } };

Base64 map initialization

const std::string CBase64::base64_map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

The encode function

std::string CBase64::base64_encode(BYTE* ptrBuffer, UINT buffLen) { std::string retStr; BYTE ptrBuff3[3]; BYTE ptrBuff4[4]; int padCount = buffLen % 3; for(UINT i = 0 ; i < buffLen - padCount ; i +=3) { ptrBuff3[0] = *(ptrBuffer++); ptrBuff3[1] = *(ptrBuffer++); ptrBuff3[2] = *(ptrBuffer++); ptrBuff4[0] = (ptrBuff3[0] & 0xfc) >> 2; ptrBuff4[1] = ((ptrBuff3[0] & 0x03) << 4) + ((ptrBuff3[1] & 0xf0) >> 4); ptrBuff4[2] = ((ptrBuff3[1] & 0x0f) << 2) + ((ptrBuff3[2] & 0xc0) >> 6); ptrBuff4[3] = ptrBuff3[2] & 0x3f; for(int j = 0; j <4 ; j++) retStr += base64_map[ptrBuff4[j]]; } if (padCount) { for(int j = 0; j < 3; j++) j<padCount? ptrBuff3[j]=*(ptrBuffer++):ptrBuff3[j] = '\0'; ptrBuff4[0] = (ptrBuff3[0] & 0xfc) >> 2; ptrBuff4[1] = ((ptrBuff3[0] & 0x03) << 4) + ((ptrBuff3[1] & 0xf0) >> 4); ptrBuff4[2] = ((ptrBuff3[1] & 0x0f) << 2) + ((ptrBuff3[2] & 0xc0) >> 6); ptrBuff4[3] = ptrBuff3[2] & 0x3f; for (j = 0; (j < padCount + 1); j++) retStr += base64_map[ptrBuff4[j]]; while((padCount++ < 3)) retStr += '='; } return retStr; }

The decode function

std::string CBase64::base64_decode(std::string const & encoded_str) { size_t strLen = encoded_str.size(); int i = 0; int j = 0; int index = 0; BYTE ptrBuffer4[4]; BYTE ptrBuffer3[3]; std::string retStr; while (strLen-- && ( encoded_str[index] != '=') && is_base64Char(encoded_str[index])) { ptrBuffer4[i++] = encoded_str[index++]; if (i == 4) { for (i = 0; i <4; i++) ptrBuffer4[i] =(BYTE) base64_map.find(ptrBuffer4[i]); ptrBuffer3[0] = (ptrBuffer4[0] << 2) + ((ptrBuffer4[1] & 0x30) >> 4); ptrBuffer3[1] = ((ptrBuffer4[1] & 0xf) << 4) + ((ptrBuffer4[2] & 0x3c) >> 2); ptrBuffer3[2] = ((ptrBuffer4[2] & 0x3) << 6) + ptrBuffer4[3]; for (i = 0; (i < 3); i++) retStr += ptrBuffer3[i]; i = 0; } } if (i) { for (j = i; j <4; j++) ptrBuffer4[j] = 0; for (j = 0; j <4; j++) ptrBuffer4[j] = (BYTE) base64_map.find(ptrBuffer4[j]); ptrBuffer3[0] = (ptrBuffer4[0] << 2) + ((ptrBuffer4[1] & 0x30) >> 4); ptrBuffer3[1] = ((ptrBuffer4[1] & 0xf) << 4) + ((ptrBuffer4[2] & 0x3c) >> 2); ptrBuffer3[2] = ((ptrBuffer4[2] & 0x3) << 6) + ptrBuffer4[3]; for (j = 0; (j < i - 1); j++) retStr += ptrBuffer3[j]; } return retStr; }

Using this class

CString inputStr; CBase64 base64Engine; //encode std::string outputStr = base64Engine.base64_encode(reinterpret_cast<BYTE*>((LPSTR)(LPCSTR)inputStr) , inputStr.GetLength()); //decode std::string outputStr = base64Engine.base64_decode((LPSTR)(LPCSTR)inputStr);

Conclusion

For more information about Base64, I suggest consulting the various RFCs. Base 64 is described in RFC 1521, http://www.ietf.org/rfc/rfc1521.txt?number=1521.

License

This article, along with any associated source code and files, is licensed under The Intelliproject Open License (IPOL)

About the author