• C++ 使用base64进行编码和解码

    1、base64编码的作用：

            base64编码的东西，任何人都可以解码，所以称之为加密和解密是不合适的，其作用是：便于数据再网络上的传输。举个简单的例子，你使用SMTP协议 （Simple Mail Transfer Protocol 简单邮件传输协议）来发送邮件，因为这个协议是基于文本的协议，所以，如果邮件中包含一幅图片，我们知道图片的存储格式是二进制数据（binary data）而非文本格式，我们必须将二进制的数据编码成文本格式，这时候Base 64 Encoding就派上用场了。

    2、C++实现的base64编码类及其使用方法：

    1）、类：

    1. #include "stdafx.h"
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. using namespace std;
    8.  
    9. namespace {
    10.  
    11. static char encoding_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
    12.                 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
    13.                 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
    14.                 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
    15.                 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
    16.                 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
    17.                 'w', 'x', 'y', 'z', '0', '1', '2', '3',
    18.                 '4', '5', '6', '7', '8', '9', '+', '/' };
    19. static char *decoding_table = NULL;
    20. static int mod_table[] = { 0, 2, 1 };
    21.  
    22. void build_decoding_table()
    23. {
    24.     decoding_table = (char*)malloc(256);
    25.     for (int i = 0; i < 64; i++)
    26.         decoding_table[(unsigned char)encoding_table[i]] = i;
    27. }
    28. char* base64_encode(const unsigned char *data, size_t input_length, size_t *output_length)
    29. 	{
    30. 		*output_length = 4 * ((input_length + 2) / 3);
    31. 		char *encoded_data = (char*)malloc(*output_length + 1);
    32. 		if (encoded_data == NULL) return NULL;
    33.         memset(encoded_data, 0, *output_length + 1);
    34. 		for (int i = 0, j = 0; i < input_length;) {
    35. 			uint32_t octet_a = i < input_length ? (unsigned char)data[i++] : 0;
    36. 			uint32_t octet_b = i < input_length ? (unsigned char)data[i++] : 0;
    37. 			uint32_t octet_c = i < input_length ? (unsigned char)data[i++] : 0;
    38. 			uint32_t triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
    39. 			encoded_data[j++] = encoding_table[(triple >> 3 * 6) & 0x3F];
    40. 			encoded_data[j++] = encoding_table[(triple >> 2 * 6) & 0x3F];
    41. 			encoded_data[j++] = encoding_table[(triple >> 1 * 6) & 0x3F];
    42. 			encoded_data[j++] = encoding_table[(triple >> 0 * 6) & 0x3F];
    43. 		}
    44. 		for (int i = 0; i < mod_table[input_length % 3]; i++)
    45. 			encoded_data[*output_length - 1 - i] = '=';
    46. 		return encoded_data;
    47. 	}
    48. unsigned char* base64_decode(const char *data, size_t input_length, size_t *output_length)
    49. {
    50.     if (decoding_table == NULL) build_decoding_table();
    51.     if (input_length % 4 != 0) return NULL;
    52.     *output_length = input_length / 4 * 3;
    53.     if (data[input_length - 1] == '=') (*output_length)--;
    54.     if (data[input_length - 2] == '=') (*output_length)--;
    55.     unsigned char *decoded_data = (unsigned char*)malloc(*output_length);
    56.     if (decoded_data == NULL) return NULL;
    57.     memset(decoded_data, 0, *output_length);
    58.     for (int i = 0, j = 0; i < input_length;) {
    59.         uint32_t sextet_a = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
    60.         uint32_t sextet_b = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
    61.         uint32_t sextet_c = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
    62.         uint32_t sextet_d = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
    63.         uint32_t triple = (sextet_a << 3 * 6)
    64.             + (sextet_b << 2 * 6)
    65.             + (sextet_c << 1 * 6)
    66.             + (sextet_d << 0 * 6);
    67.         if (j < *output_length) decoded_data[j++] = (triple >> 2 * 8) & 0xFF;
    68.         if (j < *output_length) decoded_data[j++] = (triple >> 1 * 8) & 0xFF;
    69.         if (j < *output_length) decoded_data[j++] = (triple >> 0 * 8) & 0xFF;
    70.     }
    71.     return decoded_data;
    72. }
    73. void base64_cleanup()
    74. {
    75.     free(decoding_table);
    76. }
    77. } // namespace

    2）、使用注意：

    特别要注意的是：在编码前，我们应该将编码内容转换成通用的UTF8格式，解码出来的内容也要转换成自己的编码格式来显示，比如：unicode/ansi等格式。否则的话，对于中文内容，如果和其他语言进行中文内容的传输操作，比如java，它解码出来的内容会是乱码。

    3）、编码转换函数，由于我本地是ANSI编码格式，所以下面给出ANSI与UTF8编码格式的相互转换函数，如果你本地使用的是UNICODE编码格式，就要用到UNICODE与UTF8之间的相互转换：

    1. std::string ANSItoUTF8(const char * ansi)
    2. {
    3. 	int len = MultiByteToWideChar(CP_ACP, 0, ansi, -1, NULL, 0);
    4. 	wchar_t* wstr = new wchar_t[len+1];
    5. 	memset(wstr, 0, len+1);
    6. 	MultiByteToWideChar(CP_ACP, 0, ansi, -1, wstr, len);
    7. 	len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
    8. 	char* str = new char[len+1];
    9. 	memset(str, 0, len+1);
    10. 	WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL);
    11. 	if(wstr) delete[] wstr;
    12. 	std::string ret = str;
    13. 	if(str) delete[] str;
    14. 	return ret;
    15. }
    16.  
    17. std::string UTF8toANSI(const char* utf8)
    18. {
    19. 	int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
    20. 	wchar_t* wstr = new wchar_t[len+1];
    21. 	memset(wstr, 0, len+1);
    22. 	MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wstr, len);
    23. 	len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
    24. 	char* str = new char[len+1];
    25. 	memset(str, 0, len+1);
    26. 	WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
    27. 	if(wstr) delete[] wstr;
    28. 	std::string ret = str;
    29. 	if(str) delete[] str;
    30. 	return ret;
    31. }

    4）、实例：

    1. // base64Test.cpp : 定义控制台应用程序的入口点?
    2. //
    3.  
    4. #include "stdafx.h"
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. using namespace std;
    11.  
    12. namespace {
    13.  
    14. static char encoding_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
    15.                 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
    16.                 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
    17.                 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
    18.                 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
    19.                 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
    20.                 'w', 'x', 'y', 'z', '0', '1', '2', '3',
    21.                 '4', '5', '6', '7', '8', '9', '+', '/' };
    22. static char *decoding_table = NULL;
    23. static int mod_table[] = { 0, 2, 1 };
    24.  
    25. void build_decoding_table()
    26. {
    27.     decoding_table = (char*)malloc(256);
    28.     for (int i = 0; i < 64; i++)
    29.         decoding_table[(unsigned char)encoding_table[i]] = i;
    30. }
    31. char* base64_encode(const unsigned char *data, size_t input_length, size_t *output_length)
    32. {
    33.     *output_length = 4 * ((input_length + 2) / 3);
    34.     char *encoded_data = (char*)malloc(*output_length);
    35.     if (encoded_data == NULL) return NULL;
    36.     for (int i = 0, j = 0; i < input_length;) {
    37.         uint32_t octet_a = i < input_length ? (unsigned char)data[i++] : 0;
    38.         uint32_t octet_b = i < input_length ? (unsigned char)data[i++] : 0;
    39.         uint32_t octet_c = i < input_length ? (unsigned char)data[i++] : 0;
    40.         uint32_t triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
    41.         encoded_data[j++] = encoding_table[(triple >> 3 * 6) & 0x3F];
    42.         encoded_data[j++] = encoding_table[(triple >> 2 * 6) & 0x3F];
    43.         encoded_data[j++] = encoding_table[(triple >> 1 * 6) & 0x3F];
    44.         encoded_data[j++] = encoding_table[(triple >> 0 * 6) & 0x3F];
    45.     }
    46.     for (int i = 0; i < mod_table[input_length % 3]; i++)
    47.         encoded_data[*output_length - 1 - i] = '=';
    48.     return encoded_data;
    49. }
    50. unsigned char* base64_decode(const char *data, size_t input_length, size_t *output_length)
    51. {
    52.     if (decoding_table == NULL) build_decoding_table();
    53.     if (input_length % 4 != 0) return NULL;
    54.     *output_length = input_length / 4 * 3;
    55.     if (data[input_length - 1] == '=') (*output_length)--;
    56.     if (data[input_length - 2] == '=') (*output_length)--;
    57.     unsigned char *decoded_data = (unsigned char*)malloc(*output_length);
    58.     if (decoded_data == NULL) return NULL;
    59.     for (int i = 0, j = 0; i < input_length;) {
    60.         uint32_t sextet_a = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
    61.         uint32_t sextet_b = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
    62.         uint32_t sextet_c = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
    63.         uint32_t sextet_d = data[i] == '=' ? 0 & i++ : decoding_table[data[i++]];
    64.         uint32_t triple = (sextet_a << 3 * 6)
    65.             + (sextet_b << 2 * 6)
    66.             + (sextet_c << 1 * 6)
    67.             + (sextet_d << 0 * 6);
    68.         if (j < *output_length) decoded_data[j++] = (triple >> 2 * 8) & 0xFF;
    69.         if (j < *output_length) decoded_data[j++] = (triple >> 1 * 8) & 0xFF;
    70.         if (j < *output_length) decoded_data[j++] = (triple >> 0 * 8) & 0xFF;
    71.     }
    72.     return decoded_data;
    73. }
    74. void base64_cleanup()
    75. {
    76.     free(decoding_table);
    77. }
    78. } // namespace
    79.  
    80.  
    81. std::string ANSItoUTF8(const char * ansi)
    82. {
    83. 	int len = MultiByteToWideChar(CP_ACP, 0, ansi, -1, NULL, 0);
    84. 	wchar_t* wstr = new wchar_t[len+1];
    85. 	memset(wstr, 0, len+1);
    86. 	MultiByteToWideChar(CP_ACP, 0, ansi, -1, wstr, len);
    87. 	len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
    88. 	char* str = new char[len+1];
    89. 	memset(str, 0, len+1);
    90. 	WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL);
    91. 	if(wstr) delete[] wstr;
    92. 	std::string ret = str;
    93. 	if(str) delete[] str;
    94. 	return ret;
    95. }
    96.  
    97. std::string UTF8toANSI(const char* utf8)
    98. {
    99. 	int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
    100. 	wchar_t* wstr = new wchar_t[len+1];
    101. 	memset(wstr, 0, len+1);
    102. 	MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wstr, len);
    103. 	len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
    104. 	char* str = new char[len+1];
    105. 	memset(str, 0, len+1);
    106. 	WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
    107. 	if(wstr) delete[] wstr;
    108. 	std::string ret = str;
    109. 	if(str) delete[] str;
    110. 	return ret;
    111. }
    112.  
    113. int _tmain(int argc, _TCHAR* argv[])
    114. {
    115. 	std::string strSrc = "我热爱C++语言";
    116. 	string strUtf8 = ANSItoUTF8(strSrc.c_str());
    117. 	fprintf(stdout, "str: %s\n", strSrc.c_str());
    118.  
    119. 	size_t output_length_encode = 0;
    120.     char* strEncode = base64_encode((const unsigned char*)strUtf8.c_str(), strUtf8.length(), &output_length_encode);
    121.  
    122. 	//打印编码结果
    123.     std::string tmpEncode(strEncode, output_length_encode);
    124.     fprintf(stdout, "encode result: %s\n", tmpEncode.c_str());
    125.  
    126.     size_t output_length_decode = 0;
    127.     unsigned char* strDecode= base64_decode(strEncode, output_length_encode, &output_length_decode);
    128. 	std::string tmpDecode((char*)strDecode, output_length_decode);
    129.  
    130. 	//打印解密结果
    131. 	string strDecodeUtf8 = UTF8toANSI(tmpDecode.c_str());
    132.     fprintf(stdout, "str decode2: %s\n", strDecodeUtf8.c_str());
    133.  
    134.     free(strEncode);
    135.     free(strDecode);
    136.     base64_cleanup();
    137.  
    138.  
    139. 	system("pause");
    140.  
    141. 	return 0;
    142. }
    143.

    结果：

     与在线的base64编码对照结果：

  • 相关阅读:
    力扣OJ（601-800）
    工厂模式、抽象工厂、简单工厂
    GitLab 卸载步骤 - 完全卸载
    uniapp让输入框保持聚焦状态，不会失去焦点
    Antd按钮点击完返回未点样式
    基于PTP实现主机与相机系统时钟同步功能
    汽车行驶工况||汽车行驶工况构建|||工况导入AVL Cruise（附下载）
    七天强化学习DAY1-2｜(二)马尔科夫决策过程MDP｜学习笔记
    【网络】计算机网络基础概念入门
    Nodejs -- Express 中间件的分类
  • 原文地址：https://blog.csdn.net/u012372584/article/details/126101074