C++ AES加密实现

最新推荐文章于 2024-05-12 16:55:54 发布
最新推荐文章于 2024-05-12 16:55:54 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： Windows C++工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40565735/article/details/108225286
版权

网上找到的，分享一下：
Base64.h：

#ifndef BASE_64_H
#define BASE_64_H

//#include "stdafx.h"
#include <string>

std::string base64_encode(unsigned char const* , unsigned int len);
std::string base64_decode(std::string const& s);

#endif

Base64.cpp：

//#include "stdafx.h"
#include "Base64.h"
#include <iostream>
#include <ctype.h>
static const std::string base64_chars =
	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	"abcdefghijklmnopqrstuvwxyz"
	"0123456789+/";

static inline bool is_base64(unsigned char c) {
   
	return (isalnum(c) || (c == '+') || (c == '/'));
}

std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
   
	std::string ret;
	int i = 0;
    //int j = 0;
	unsigned char char_array_3[3];
	unsigned char char_array_4[4];

	while (in_len--) {
   
		char_array_3[i++] = *(bytes_to_encode++);
		if (i == 3) {
   
			char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
			char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
			char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
			char_array_4[3] = char_array_3[2] & 0x3f;

			for(i = 0; (i <4) ; i++)
				ret += base64_chars[char_array_4[i]];
			i = 0;
		}
	}

	if (i)
	{
   
        for(int j = i; j < 3; j++)
			char_array_3[j] = '\0';

		char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
		char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
		char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
		char_array_4[3] = char_array_3[2] & 0x3f;

        for (int j = 0; (j < i + 1); j++)
			ret += base64_chars[char_array_4[j]];

		while((i++ < 3))
			ret += '=';
	}
	return ret;
}

std::string base64_decode(std::string const& encoded_string) {
   
	int in_len = encoded_string.size();
	int i = 0;
    //int j = 0;
	int in_ = 0;
	unsigned char char_array_4[4], char_array_3[3];
	std::string ret;

	while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
   
		char_array_4[i++] = encoded_string[in_]; in_++;
		if (i ==4) {
   
			for (i = 0; i <4; i++)
				char_array_4[i] = base64_chars.find(char_array_4[i]);

			char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
			char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
			char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

			for (i = 0; (i < 3); i++)
				ret += char_array_3[i];
			i = 0;
		}
	}

	if (i) {
   
        for (int j = i; j <4; j++)
			char_array_4[j] = 0;

        for (int j = 0; j <4; j++)
			char_array_4[j] = base64_chars.find(char_array_4[j]);

		char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
		char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
		char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

        for (int j = 0; (j < i - 1); j++) ret += char_array_3[j];
	}
	return ret;
}

AES.h：

//AES.h
#ifndef _AES_H
#define _AES_H
#include <exception>
#include <cstring>
#include <string>
#define BLOCK_SIZE 16
using namespace std;

class AES
{
   
public:
	enum
	{
   
		ECB = 0, CBC = 1, CFB = 2
	};

private:
	enum
	{
   
		DEFAULT_BLOCK_SIZE = 16
	};
	enum
	{
   
		MAX_BLOCK_SIZE = 32, MAX_ROUNDS = 14, MAX_KC = 8, MAX_BC = 8
	};
public:
	AES();
	virtual ~AES();
private:
	//Key Initialization Flag
	bool m_bKeyInit;
	//Encryption (m_Ke) round key
	int m_Ke[MAX_ROUNDS + 1][MAX_BC];
	//Decryption (m_Kd) round key
	int m_Kd[MAX_ROUNDS + 1][MAX_BC];
	//Key Length
	int m_keylength;
	//Block Size
	int m_blockSize;
	//Number of Rounds
	int m_iROUNDS;
	//Chain Block
	char m_chain0[MAX_BLOCK_SIZE];
	char m_chain[MAX_BLOCK_SIZE];
	//Auxiliary private use buffers
	int tk[MAX_KC];
	int a[MAX_BC];
	int t[MAX_BC];
private:
	void Xor(char* buff, char const* chain);
	void DefEncryptBlock(char const* in, char* result);
	void DefDecryptBlock(char const* in, char* result);
	void EncryptBlock(char const* in, char* result);
	void DecryptBlock(char const* in, char* result);
public:
	void MakeKey(char const* key, char const* chain, int keylength =
		DEFAULT_BLOCK_SIZE, int blockSize = DEFAULT_BLOCK_SIZE);
	void Encrypt(char const* in, char* result, size_t n, int iMode = ECB);
	void Decrypt(char const* in, char* result, size_t n, int iMode = ECB);
};

#endif // __RIJNDAEL_H__

AES.cpp：

//#include "stdafx.h"
#include <cstring>
#include <exception>
#include "AES.h"
#include <iostream>
using namespace std;
const int sm_alog[256] =
{
    1, 3, 5, 15, 17, 51, 85, 255, 26, 46, 114, 150, 161, 248, 19, 53, 95, 225, 56,
72, 216, 115, 149, 164, 247, 2, 6, 10, 30, 34, 102, 170, 229, 52, 92,
228, 55, 89, 235, 38, 106, 190, 217, 112, 144, 171, 230, 49, 83, 245, 4,
12, 20, 60, 68, 204, 79, 209, 104, 184, 211, 110, 178, 205, 76, 212,
103, 169, 224, 59, 77, 215, 98, 166, 241, 8, 24, 40, 120, 136, 131, 158,
185, 208, 107, 189, 220, 127, 129, 152, 179, 206, 73, 219, 118, 154,
181, 196, 87, 249, 16, 48, 80, 240, 11, 29, 39, 105, 187, 214, 97, 163,
254, 25, 43, 125, 135, 146, 173, 236, 47, 113, 147, 174, 233, 32, 96,
160, 251, 22, 58, 78, 210, 109, 183, 194, 93, 231, 50, 86, 250, 21, 63,
65, 195, 94, 226, 61, 71, 201, 64, 192, 91, 237, 44, 116, 156, 191, 218,
117, 159, 186, 213, 100, 172, 239, 42, 126, 130, 157, 188, 223, 122,
142, 137, 128, 155, 182, 193, 88, 232, 35, 101, 175, 234, 37, 111, 177,
200, 67, 197, 84, 252, 31, 33, 99, 165, 244, 7, 9, 27, 45, 119, 153,
176, 203, 70, 202, 69, 207, 74, 222, 121, 139, 134, 145, 168, 227, 62,
66, 198, 81, 243, 14, 18, 54, 90, 238, 41, 123, 141, 140, 143, 138, 133,
148, 167, 242, 13, 23, 57, 75, 221, 124, 132, 151, 162, 253, 28, 36,
108, 180, 199, 82, 246, 1 };

const int sm_log[256] =
{
    0, 0, 25, 1, 50, 2, 26, 198, 75, 199, 27, 104, 51, 238, 223, 3, 100, 4, 224,
14, 52, 141, 129, 239, 76, 113, 8, 200, 248, 105, 28, 193, 125, 194, 29,
181, 249, 185, 39, 106, 77, 228, 166, 114, 154, 201, 9, 120, 101, 47,
138, 5, 33, 15, 225, 36, 18, 240, 130, 69, 53, 147, 218, 142, 150, 143,
219, 189, 54, 208, 206, 148, 19, 92, 210, 241, 64, 70, 131, 56, 102,
221, 253, 48, 191, 6, 139, 98, 179, 37, 226, 152, 34, 136, 145, 16, 126,
110, 72, 195, 163, 182, 30, 66, 58, 107, 40, 84, 250, 133, 61, 186, 43,
121, 10, 21, 155, 159, 94, 202, 78, 212, 172, 229, 243, 115, 167, 87,
175, 88, 168, 80, 244, 234, 214, 116, 79, 174, 233, 213, 231, 230, 173,
232, 44, 215, 117, 122, 235, 22, 11, 245, 89, 203, 95, 176, 156, 169,
81, 160, 127, 12, 246, 111, 23, 196, 73, 236, 216, 67, 31, 45, 164, 118,
123, 183, 204, 187, 62, 90, 251, 96, 177, 134, 59, 82, 161, 108, 170,
85, 41, 157, 151, 178, 135, 144, 97, 190, 220, 252, 188, 149, 207, 205,
55, 63, 91, 209, 83, 57, 132, 60, 65, 162, 109, 71, 20, 42, 158, 93, 86,
242, 211, 171, 68, 17, 146, 217, 35, 32, 46, 137, 180, 124, 184, 38,
119, 153, 227, 165, 103, 74, 237, 222, 197, 49, 254, 24, 13, 99, 140,
128, 192, 247, 112, 7 };

const signed char sm_S[256] =
{
    99, 124, 119, 123, -14, 107, 111, -59, 48, 1, 103, 43, -2, -41, -85, 118, -54,
-126, -55, 125, -6, 89, 71, -16, -83, -44, -94, -81, -100, -92, 114,
-64, -73, -3, -109, 38, 54, 63, -9, -52, 52, -91, -27, -15, 113, -40,
49, 21, 4, -57, 35, -61, 24, -106, 5, -102, 7, 18, -128, -30, -21, 39,
-78, 117, 9, -125, 44, 26, 27, 110, 90, -96, 82, 59, -42, -77, 41, -29,
47, -124, 83, -47, 0, -19, 32, -4, -79, 91, 106, -53, -66, 57, 74, 76,
88, -49, -48, -17, -86, -5, 67, 77, 51, -123, 69, -7, 2, 127, 80, 60,
-97, -88, 81, -93, 64, -113, -110, -99, 56, -11, -68, -74, -38, 33, 16,
-1, -13, -46, -51, 12, 19, -20, 95, -105, 68, 23, -60, -89, 126, 61,
100, 93, 25, 115, 96, -127, 79, -36, 34, 42, -112, -120, 70, -18, -72,
20, -34, 94, 11, -37, -32, 50, 58, 10, 73, 6, 36, 92, -62, -45, -84, 98,
-111, -107, -28, 121, -25, -56, 55, 109, -115, -43, 78, -87, 108, 86,
-12, -22, 101, 122, -82, 8, -70, 120, 37, 46, 28, -90, -76, -58, -24,
-35, 116, 31, 75, -67, -117, -118, 112, 62, -75, 102, 72, 3, -10, 14,
97, 53, 87, -71, -122, -63, 29, -98, -31, -8, -104, 17, 105, -39, -114,
-108, -101, 30, -121, -23, -50, 85, 40, -33, -116, -95, -119, 13, -65,
-26, 66, 104, 65, -103, 45, 15, -80, 84, -69, 22 };

const signed char sm_Si[256] =
{
    82, 9, 106, -43, 48, 54, -91, 56, -65, 64, -93, -98, -127, -13, -41, -5, 124,
-29, 57, -126, -101, 47, -1, -121, 52, -114, 67, 68, -60, -34, -23, -53,
84, 123, -108, 50, -90, -62, 35, 61, -18, 76, -107, 11, 66, -6, -61, 78,
8, 46, -95, 102, 40, -39, 36, -78, 118, 91, -94, 73, 109, -117, -47, 37,
114, -8, -10, 100, -122, 104, -104, 22, -44, -92, 92, -52, 93, 101, -74,
-110, 108, 112, 72, 80, -3, -19, -71, -38, 94, 21, 70, 87, -89, -115,
-99, -124, -112, -40, -85, 0, -116, -68, -45, 10, -9, -28, 88, 5, -72,
-77, 69, 6, -48, 44, 30, -113, -54, 63, 15, 2, -63, -81, -67, 3, 1, 19,
-118, 107, 58, -111, 17, 65, 79, 103, -36, -22, -105, -14, -49, -50,
-16, -76, -26, 115, -106, -84, 116, 34, -25, -83, 53, -123, -30, -7, 55,
-24, 28, 117, -33, 110, 71, -15, 26, 113, 29, 41, -59, -119, 111, -73,
98, 14, -86, 24, -66, 27, -4, 86, 62, 75, -58, -46, 121, 32, -102, -37,
-64, -2, 120, -51, 90, -12, 31, -35, -88, 51, -120, 7, -57, 49, -79,
最低0.47元/天 解锁文章
一缕阳光宣泄、整个世界
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AES加密算法的C++实现过程
06-14
AES加密算法的C++实现过程 希望能对大家提供给帮助
C++ AES加密算法的实现（附代码）
敲不好代码的小透明的博客
03-31 2万+
AES原理讲解、代码实现
AES对称加密算法原理、C++代码示例
最新发布
Bobowen的博客
05-12 752
高级加密标准（AES，全称：Advanced Encryption Standard）是一种对称加密算法，由美国国家标准与技术研究院（NIST）于2001年发布。它取代了数据加密标准（DES），成为许多政府、企业和机构广泛使用的标准加密方法。AES (Advanced Encryption Standard) 是一种对称加密算法，由 NIST 于 2001 年发布，取代了 DES。它通过多轮数学操作将明文转换为密文，密钥长度为 128、192 或 256 位。主要步骤包括字节代替、行移位、列混合和轮密钥加。
AES加密算法的C++实现
dbbaq24022的专栏
12-13 4021
摘要：作为新一代的加密标准，AES 旨在取代 DES（请看《DES加密算法的C++实现》），以适应当今分布式开放网络对数据加密安全性的要求。本文在分析了 AES 加密原理的基础上着重说明了算法实现的具体步骤，并用 C++ 实现了对文件的加密和解密。 一、AES 介绍 AES（高级加密标准，Advanced Encryption Standard），在密码学中又称 ...
aes加密c++实现
热门推荐
witto_sdy的专栏
10-25 2万+
工作中用到aes加密，项目中没有可用的接口（类），遂google. 整理了原理及代码，代码转自：https://blog.csdn.net/csdn49532/article/details/50686222?utm_source=blogxgwz0 什么是AES算法 AES是典型的对称加密算法，不同于信息摘要算法（md5,sha等）。 AES的工作步骤： 而摘要算法是不可逆的，它主...
AES加密算法原理(C++实现)
m0_47533197的博客
04-04 7504
AES加密算法(c++)实现
C/C++版AES加密实现
weixin_37885641的博客
07-11 1220
一、参考文档 1.https://www.jianshu.com/p/3840b344b27c?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation 2.https://songlee24.github.io/2014/12/13/aes-encrypt/...
c++实现AES加密算法
林庆丰的博客
10-01 938
c++实现AES加密算法 #include "stdafx.h" #include <Windows.h> void ShowError(char *pszText) { char szErr[MAX_PATH] = { 0 }; ::wsprintf(szErr, "%s Error[0x%x]\n", pszText, ::GetLastError()); #ifdef _DEBUG ::MessageBox(NULL, szErr, "ERROR", MB_OK | MB_ICO
c++ AES加密.zip
11-24
C++实现AES加密通常涉及到几个关键概念和步骤，这些在"VS2013下调试的c++ AES加密"资源中应该都有涵盖。 1. **AES算法原理**： AES是一种分组密码，它将明文数据分割成128位的块，并使用相同的密钥对每个块进行...
C++实现AES256加密
03-09
密钥被分为两部分，前半部分用于初始化AES加密器，后半部分用于初始化CBC模式。 然而，如果你打算从零开始实现AES256，这将涉及到对AES算法的深入理解，并且需要仔细处理内存管理和位操作。这样的实现既复杂又容易...
C++实现AES加密/解密
09-28
AES是一个对称加密算法，旨在取代DES成为广泛使用的标准。 创建工程后直接添加cpp、h文件，主要调用类方法 AesEncryptor(unsigned char* key); ~AesEncryptor(void); void SetKey(unsigned char* key); void ...
AES加密解密 c++ 实现全代码
11-14
高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。 该压缩包中包括aes加密算法的c++实现代码。
aes.rar_c++ aes加密解密
09-19
在C++中实现AES加密解密是一项常见的任务，尤其是在网络安全、数据保护和隐私领域。这个压缩包`aes.rar`包含了C++语言实现AES加密解密的源代码，确保已经通过了编译，可以直接用于项目中。 AES的核心是基于替换和...
AES加密——AES加密原理与C++实现AES加密
知来者逆的博客
03-09 5000
AES-256 密钥长度为 256 位，提供了极高的安全性。由于其密钥长度更长，因此具有更大的密钥空间，从而增加了破解的难度，即使是通过蛮力攻击也是很不好破解。
AES加解密之C++实现
lixiang987654321的专栏
10-11 1万+
一、AES介绍 AES，高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图： 下面简单介绍下各个部分的作用与意义： 明文P 没有经过加密的数据。 密钥K 用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生，但不可以直接在网络上传输，否则会导致密钥泄漏，通常是通过非对称加密算法加密密钥，然后再通过网络传输给
分组密码算法AES的C/C++编程实现
m0_63002183的博客
07-10 4800
实验过程中，意识到要实现完整地AES流程是相对十分复杂的，要提前对密钥进行密钥扩展，将明文转化成十六进制变为矩阵，加密过程中，先用初始密钥进行异或，再做九轮字节代换、行移位、列混合；AES加密过程先是明文经过初始化变换，其次再经过九轮循环运算，每一次循环运算都要依次进行字节代换、行移位、列混合和轮密钥加，九轮循环运算结束后，再进行一次最终轮运算，这一轮与前面的九轮的区别除了不进行列混合，其余的不变，也即是最后一轮依次进行字节代换、行移位和轮密钥加，经过这一步骤得到的即为密文。行移位，一个比较简单的置换；
AES加密解密算法设计（C++）
毕业作品网站
10-20 3663
void keyschedule(int key[4][4],int allkey[4][44],int nk,int nr) //128密钥扩展。void addroundkey6(int col[4][4],int allkey[4][52],int nr) //192比特轮密钥加。void addroundkey(int col[4][4],int allkey[4][44],int nr) //128论密钥加。void shiftrows(int col[4][4]) //行移位。
python3调用c++动态库（一）生成c++动态库
丁爸的博客
11-27 557
本文介绍c++生成dll动态库，在win10系统，使用vs2017生成。 一、创建工程 说明： AES.cpp和AES.h是实现AES加解密的文件 CAesDll.cpp和CAesDll.h是调用AES.h里面函数，封装成类CAes256 CApi.cpp和CApi.h是导出dll动态库的外部调用接口 二、封装AES加解密类 CAes256类，封装AES加解密功能： #ifndef ENCRYPT_DECRYPT_H #define ENCRYPT_DECRYPT_H #include <s
c++ 实现 AES 加密 BASE64
heshaoyou888的博客
04-27 1235
工作中用到aes加密，项目中没有可用的接口（类），遂google. 附各类加解密网站：http://tool.chacuo.net/cryptaes 什么是AES算法 AES是典型的对称加密算法，不同于信息摘要算法（md5,sha等）。 AES的工作步骤： 而摘要算法是不可逆的，它主要功能是对信息的一致性和完整性的校验。对称加密算法是可逆的，主要作用是保护隐私不被泄漏。 AES算法全称Advanced Encryption Standard，是DES算法的替代者。 要想学习AES，首先要清
aes加密C++实现
08-29
要在C语言中实现AES加密，可以按照以下步骤： 1. 首先，编写一个`AddRoundKey`函数，用于将密钥与状态矩阵进行异或操作。这个函数接收三个参数：一个指向状态矩阵的指针、一个指向扩展密钥的指针和当前轮数。在该...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值