C++自己实现AES算法

最新推荐文章于 2024-09-12 08:29:36 发布
最新推荐文章于 2024-09-12 08:29:36 发布
阅读量4.7k 收藏 10
点赞数
分类专栏： C++ 安全 文章标签： MD5 安全 AES c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lcli2009/article/details/21408373
版权
C++ 同时被 2 个专栏收录
10 篇文章 0 订阅
订阅专栏
安全
3 篇文章 0 订阅
订阅专栏

在移动端需要安全算法时，直接使用开源库可能不合适(开源库都比较大，也可以自己抽取需要的代码)，本Demo是根据AES的原理来实现算法，采用ECB/PKCS5Padding，实现短小精悍！！

注意：本算法在生成加密key时，使用了md5算法，编译本demo需要依赖 C++自行实现MD5算法 里面的算法。

#ifndef _AES_20140317_H_
#define _AES_20140317_H_

#define Bits128				16
#define Bits192				24
#define Bits256				32
#define ENCRYPT_BLOCK_SIZE	16
#define SUCESS 0
#define TRUE 1

#include "md5.h"
#include <stdio.h>
#include <malloc.h>

typedef unsigned char _u8;
typedef int _int32;
typedef unsigned int _u32;

typedef struct
{
	_int32 Nb;
	_int32 Nk;
	_int32 Nr;
	_u8 State[4][4];
	_u8 key[32];
	_u8 w[16 * 15];
} ctx_aes;

enum AESKeyLength
{
	AES_KEY_LENGTH_16 = 16, AES_KEY_LENGTH_24 = 24, AES_KEY_LENGTH_32 = 32
};

namespace comm
{
namespace util
{
class AES
{
public:
	AES();
	~AES()
	{
		if (Sbox != NULL)
		{
			delete []Sbox;
			Sbox = NULL;
		}

		if (iSbox != NULL)
		{
			delete []iSbox;
			iSbox = NULL;
		}

		if (Rcon != NULL)
		{
			delete []Rcon;
			Rcon = NULL;
		}
	}
public:
	int decrypt4aes(const std::string &inData, const std::string &strKey,
			std::string &outData, std::string &errMsg);
	int encrypt4aes(const std::string &inData, const std::string &strKey,
			std::string &outData, std::string &errMsg);
private:
	void aes_init(ctx_aes* aes, int keySize, _u8* keyBytes);
	void aes_cipher(ctx_aes* aes, _u8* input, _u8* output);
	void aes_invcipher(ctx_aes* aes, _u8* input, _u8* output);
	void SetNbNkNr(ctx_aes* aes, _int32 keyS);
	void AddRoundKey(ctx_aes* aes, _int32 round);
	void SubBytes(ctx_aes* aes);
	void InvSubBytes(ctx_aes* aes);
	void ShiftRows(ctx_aes* aes);
	void InvShiftRows(ctx_aes* aes);
	void MixColumns(ctx_aes* aes);
	void InvMixColumns(ctx_aes* aes);
	_u8 gfmultby01(_u8 b);
	_u8 gfmultby02(_u8 b);
	_u8 gfmultby03(_u8 b);
	unsigned char gfmultby09(unsigned char b);
	unsigned char gfmultby0b(unsigned char b);
	unsigned char gfmultby0d(unsigned char b);
	unsigned char gfmultby0e(unsigned char b);
	void KeyExpansion(ctx_aes* aes);
	void SubWord(_u8 *word, _u8 *result);
	void RotWord(_u8 *word, _u8 *result);
	_int32 aes_encrypt_with_known_key(char* buffer, _u32* len, _u8 *key,std::string &outData);
	_int32 aes_decrypt_with_known_key(char* p_data_buff, _u32* p_data_buff_len,
			_u8 *key,std::string &outData);
private:
	_u8 *Sbox;
	_u8 *iSbox;
	_u8 *Rcon;
};
}
} //comm::util
#endif//_AES_20140317_H_


#include "aes.h"

using namespace comm::util;

AES::AES()
{
	Sbox = new _u8[256];

	_u8 Sbox_temp[256] =
	{ 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
			0xfe, 0xd7, 0xab, 0x76,
			/*1*/0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4,
			0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
			/*2*/0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5,
			0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
			/*3*/0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12,
			0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
			/*4*/0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b,
			0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
			/*5*/0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb,
			0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
			/*6*/0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9,
			0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
			/*7*/0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6,
			0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
			/*8*/0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7,
			0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
			/*9*/0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee,
			0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
			/*a*/0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3,
			0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
			/*b*/0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56,
			0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
			/*c*/0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd,
			0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
			/*d*/0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35,
			0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
			/*e*/0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e,
			0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
			/*f*/0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99,
			0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };

	for (int i = 0; i < 256; i++)
	{
		Sbox[i] = Sbox_temp[i];
	}

	iSbox = new _u8[256];

	_u8 iSbox_temp[256] =
	{ 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e,
			0x81, 0xf3, 0xd7, 0xfb,
			/*1*/0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e,
			0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
			/*2*/0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c,
			0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
			/*3*/0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b,
			0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
			/*4*/0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4,
			0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
			/*5*/0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15,
			0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
			/*6*/0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4,
			0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
			/*7*/0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf,
			0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
			/*8*/0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2,
			0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
			/*9*/0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9,
			0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
			/*a*/0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7,
			0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
			/*b*/0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb,
			0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
			/*c*/0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12,
			0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
			/*d*/0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5,
			0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
			/*e*/0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb,
			0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
			/*f*/0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69,
			0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };
	for (int i = 0; i < 256; i++)
	{
		iSbox[i] = iSbox_temp[i];
	}

	Rcon = new _u8[44];

	_u8 Rcon_temp[44] =
	{ 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
			0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
			0x00, 0x20, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x80, 0x00,
			0x00, 0x00, 0x1b, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00 };

	for (int i = 0; i < 44; i++)
	{
		Rcon[i] = Rcon_temp[i];
	}
}

void AES::aes_init(ctx_aes* aes, int keySize, _u8* keyBytes)
{
	SetNbNkNr(aes, keySize);
	memcpy(aes->key, keyBytes, keySize);
	KeyExpansion(aes);
}

void AES::aes_cipher(ctx_aes* aes, _u8* input, _u8* output) // encipher 16-bit input
{
	// state = input
	int i;
	int round;
	memset(&aes->State[0][0], 0, 16);
	for (i = 0; i < (4 * aes->Nb); i++)  //
	{
		aes->State[i % 4][i / 4] = input[i];
	}
	AddRoundKey(aes, 0);
	for (round = 1; round <= (aes->Nr - 1); round++)  // main round loop
	{
		SubBytes(aes);
		ShiftRows(aes);
		MixColumns(aes);
		AddRoundKey(aes, round);
	}  // main round loop

	SubBytes(aes);
	ShiftRows(aes);
	AddRoundKey(aes, aes->Nr);

	// output = state
	for (i = 0; i < (4 * aes->Nb); i++)
	{
		output[i] = aes->State[i % 4][i / 4];
	}

}  // Cipher()

void AES::aes_invcipher(ctx_aes* aes, _u8* input, _u8* output) // decipher 16-bit input
{
	// state = input
	int i;
	int round;
	memset(&aes->State[0][0], 0, 16);
	for (i = 0; i < (4 * aes->Nb); i++)
	{
		aes->State[i % 4][i / 4] = input[i];
	}

	AddRoundKey(aes, aes->Nr);

	for (round = aes->Nr - 1; round >= 1; round--)  // main round loop
	{
		InvShiftRows(aes);
		InvSubBytes(aes);
		AddRoundKey(aes, round);
		InvMixColumns(aes);
	}  // end main round loop for InvCipher

	InvShiftRows(aes);
	InvSubBytes(aes);
	AddRoundKey(aes, 0);

	// output = state
	for (i = 0; i < (4 * aes->Nb); i++)
	{
		output[i] = aes->State[i % 4][i / 4];
	}

}  // InvCipher()

void AES::SetNbNkNr(ctx_aes* aes, _int32 keyS)
{
	aes->Nb = 4;    // block size always = 4 words = 16 bytes = 128 bits for AES
	aes->Nk = 4;
	if (keyS == Bits128)
	{
		aes->Nk = 4;   // key size = 4 words = 16 bytes = 128 bits
		aes->Nr = 10;  // rounds for algorithm = 10
	}
	else if (keyS == Bits192)
	{
		aes->Nk = 6;   // 6 words = 24 bytes = 192 bits
		aes->Nr = 12;
	}
	else if (keyS == Bits256)
	{
		aes->Nk = 8;   // 8 words = 32 bytes = 256 bits
		aes->Nr = 14;
	}
}  // SetNbNkNr()

void AES::AddRoundKey(ctx_aes* aes, _int32 round)
{
	int r, c;
	for (r = 0; r < 4; r++)
	{
		for (c = 0; c < 4; c++)
		{  //w:    4*x+y
			aes->State[r][c] = (unsigned char) ((int) aes->State[r][c]
					^ (int) aes->w[4 * ((round * 4) + c) + r]);
		}
	}
}  // AddRoundKey()

void AES::SubBytes(ctx_aes* aes)
{
	int r, c;
	for (r = 0; r < 4; r++)
	{
		for (c = 0; c < 4; c++)
		{
			aes->State[r][c] = Sbox[16 * (aes->State[r][c] >> 4)
					+ (aes->State[r][c] & 0x0f)];
		}
	}
}  // SubBytes

void AES::InvSubBytes(ctx_aes* aes)
{
	int r, c;
	for (r = 0; r < 4; r++)
	{
		for (c = 0; c < 4; c++)
		{
			aes->State[r][c] = iSbox[16 * (aes->State[r][c] >> 4)
					+ (aes->State[r][c] & 0x0f)];
		}
	}
}  // InvSubBytes

void AES::ShiftRows(ctx_aes* aes)
{
	unsigned char temp[4 * 4];
	int r, c;
	for (r = 0; r < 4; r++)  // copy State into temp[]
	{
		for (c = 0; c < 4; c++)
		{
			temp[4 * r + c] = aes->State[r][c];
		}
	}
	//??
	for (r = 1; r < 4; r++)  // shift temp into State
	{
		for (c = 0; c < 4; c++)
		{
			aes->State[r][c] = temp[4 * r + (c + r) % aes->Nb];
		}
	}
}  // ShiftRows()

void AES::InvShiftRows(ctx_aes* aes)
{
	unsigned char temp[4 * 4];
	int r, c;
	for (r = 0; r < 4; r++)  // copy State into temp[]
	{
		for (c = 0; c < 4; c++)
		{
			temp[4 * r + c] = aes->State[r][c];
		}
	}
	for (r = 1; r < 4; r++)  // shift temp into State
	{
		for (c = 0; c < 4; c++)
		{
			aes->State[r][(c + r) % aes->Nb] = temp[4 * r + c];
		}
	}
}  // InvShiftRows()

void AES::MixColumns(ctx_aes* aes)
{
	unsigned char temp[4 * 4];
	int r, c;
	for (r = 0; r < 4; r++)  // copy State into temp[]
	{
		for (c = 0; c < 4; c++)
		{
			temp[4 * r + c] = aes->State[r][c];
		}
	}

	for (c = 0; c < 4; c++)
	{
		aes->State[0][c] = (unsigned char) ((int) gfmultby02(temp[0 + c])
				^ (int) gfmultby03(temp[4 * 1 + c])
				^ (int) gfmultby01(temp[4 * 2 + c])
				^ (int) gfmultby01(temp[4 * 3 + c]));
		aes->State[1][c] = (unsigned char) ((int) gfmultby01(temp[0 + c])
				^ (int) gfmultby02(temp[4 * 1 + c])
				^ (int) gfmultby03(temp[4 * 2 + c])
				^ (int) gfmultby01(temp[4 * 3 + c]));
		aes->State[2][c] = (unsigned char) ((int) gfmultby01(temp[0 + c])
				^ (int) gfmultby01(temp[4 * 1 + c])
				^ (int) gfmultby02(temp[4 * 2 + c])
				^ (int) gfmultby03(temp[4 * 3 + c]));
		aes->State[3][c] = (unsigned char) ((int) gfmultby03(temp[0 + c])
				^ (int) gfmultby01(temp[4 * 1 + c])
				^ (int) gfmultby01(temp[4 * 2 + c])
				^ (int) gfmultby02(temp[4 * 3 + c]));
	}
}  // MixColumns

void AES::InvMixColumns(ctx_aes* aes)
{
	unsigned char temp[4 * 4];
	int r, c;
	for (r = 0; r < 4; r++)  // copy State into temp[]
	{
		for (c = 0; c < 4; c++)
		{
			temp[4 * r + c] = aes->State[r][c];
		}
	}

	for (c = 0; c < 4; c++)
	{
		aes->State[0][c] = (unsigned char) ((int) gfmultby0e(temp[c])
				^ (int) gfmultby0b(temp[4 + c])
				^ (int) gfmultby0d(temp[4 * 2 + c])
				^ (int) gfmultby09(temp[4 * 3 + c]));
		aes->State[1][c] = (unsigned char) ((int) gfmultby09(temp[c])
				^ (int) gfmultby0e(temp[4 + c])
				^ (int) gfmultby0b(temp[4 * 2 + c])
				^ (int) gfmultby0d(temp[4 * 3 + c]));
		aes->State[2][c] = (unsigned char) ((int) gfmultby0d(temp[c])
				^ (int) gfmultby09(temp[4 + c])
				^ (int) gfmultby0e(temp[4 * 2 + c])
				^ (int) gfmultby0b(temp[4 * 3 + c]));
		aes->State[3][c] = (unsigned char) ((int) gfmultby0b(temp[c])
				^ (int) gfmultby0d(temp[4 + c])
				^ (int) gfmultby09(temp[4 * 2 + c])
				^ (int) gfmultby0e(temp[4 * 3 + c]));
	}
}  // InvMixColumns

_u8 AES::gfmultby01(_u8 b)
{
	return b;
}

_u8 AES::gfmultby02(_u8 b)
{
	if (b < 0x80)
		return (_u8) (_int32) (b << 1);
	else
		return (_u8) ((_int32) (b << 1) ^ (_int32) (0x1b));
}

_u8 AES::gfmultby03(_u8 b)
{
	return (_u8) ((_int32) gfmultby02(b) ^ (_int32) b);
}

unsigned char AES::gfmultby09(unsigned char b)
{
	return (unsigned char) ((int) gfmultby02(gfmultby02(gfmultby02(b)))
			^ (int) b);
}

unsigned char AES::gfmultby0b(unsigned char b)
{
	return (unsigned char) ((int) gfmultby02(gfmultby02(gfmultby02(b)))
			^ (int) gfmultby02(b) ^ (int) b);
}

unsigned char AES::gfmultby0d(unsigned char b)
{
	return (unsigned char) ((int) gfmultby02(gfmultby02(gfmultby02(b)))
			^ (int) gfmultby02(gfmultby02(b)) ^ (int) (b));
}

unsigned char AES::gfmultby0e(unsigned char b)
{
	return (unsigned char) ((int) gfmultby02(gfmultby02(gfmultby02(b)))
			^ (int) gfmultby02(gfmultby02(b)) ^ (int) gfmultby02(b));
}

void AES::KeyExpansion(ctx_aes* aes)
{
	int row;
	_u8 temp[4];
	_u8 result[4], result2[4];
	memset(aes->w, 0, 16 * 15);
	for (row = 0; row < aes->Nk; row++)  //Nk=4,6,8
	{
		aes->w[4 * row + 0] = aes->key[4 * row];
		aes->w[4 * row + 1] = aes->key[4 * row + 1];
		aes->w[4 * row + 2] = aes->key[4 * row + 2];
		aes->w[4 * row + 3] = aes->key[4 * row + 3];
	}
	for (row = aes->Nk; row < aes->Nb * (aes->Nr + 1); row++)
	{
		temp[0] = aes->w[4 * (row - 1) + 0];
		temp[1] = aes->w[4 * (row - 1) + 1];
		temp[2] = aes->w[4 * (row - 1) + 2];
		temp[3] = aes->w[4 * (row - 1) + 3];

		if (row % aes->Nk == 0)
		{
			RotWord(temp, result);
			SubWord(result, result2);
			memcpy(temp, result2, 4);  //

			temp[0] = (unsigned char) ((int) temp[0]
					^ (int) Rcon[4 * (row / aes->Nk) + 0]);
			temp[1] = (unsigned char) ((int) temp[1]
					^ (int) Rcon[4 * (row / aes->Nk) + 1]);
			temp[2] = (unsigned char) ((int) temp[2]
					^ (int) Rcon[4 * (row / aes->Nk) + 2]);
			temp[3] = (unsigned char) ((int) temp[3]
					^ (int) Rcon[4 * (row / aes->Nk) + 3]);
		}
		else if (aes->Nk > 6 && (row % aes->Nk == 4))
		{
			SubWord(temp, result);
			memcpy(temp, result, 4);
		}
		// w[row] = w[row-Nk] xor temp
		aes->w[4 * row + 0] = (unsigned char) ((int) aes->w[4 * (row - aes->Nk)
				+ 0] ^ (int) temp[0]);
		aes->w[4 * row + 1] = (unsigned char) ((int) aes->w[4 * (row - aes->Nk)
				+ 1] ^ (int) temp[1]);
		aes->w[4 * row + 2] = (unsigned char) ((int) aes->w[4 * (row - aes->Nk)
				+ 2] ^ (int) temp[2]);
		aes->w[4 * row + 3] = (unsigned char) ((int) aes->w[4 * (row - aes->Nk)
				+ 3] ^ (int) temp[3]);
	}  // for loop
}  // KeyExpansion()

void AES::SubWord(_u8 *word, _u8 *result)
{  //²»ÒªÕâÑù·µ»Ø£¡
	result[0] = Sbox[16 * (word[0] >> 4) + (word[0] & 0x0f)];
	result[1] = Sbox[16 * (word[1] >> 4) + (word[1] & 0x0f)];
	result[2] = Sbox[16 * (word[2] >> 4) + (word[2] & 0x0f)];
	result[3] = Sbox[16 * (word[3] >> 4) + (word[3] & 0x0f)];
}

void AES::RotWord(_u8 *word, _u8 *result)
{  //²»ÒªÕâÑù·µ»Ø
	result[0] = word[1];
	result[1] = word[2];
	result[2] = word[3];
	result[3] = word[0];
}

_int32 AES::aes_encrypt_with_known_key(char* buffer, _u32* len, _u8 *key,
		std::string &outData)
{
	_int32 ret;
	char *pOutBuff;
	_int32 nOutLen;
	_int32 nBeginOffset;
	ctx_aes aes;
	int nInOffset;
	int nOutOffset;
	unsigned char inBuff[ENCRYPT_BLOCK_SIZE], ouBuff[ENCRYPT_BLOCK_SIZE];
	if (buffer == NULL)
	{
		return -1;
	}
	pOutBuff = (char*) malloc(*len + 16);
	if (pOutBuff == NULL)
		return -1;
	nOutLen = 0;
	nBeginOffset = 0;
	aes_init(&aes, 16, key);
	nInOffset = nBeginOffset;
	nOutOffset = 0;
	memset(inBuff, 0, ENCRYPT_BLOCK_SIZE);
	memset(ouBuff, 0, ENCRYPT_BLOCK_SIZE);
	while (TRUE)
	{
		if (*len - nInOffset >= ENCRYPT_BLOCK_SIZE)
		{
			memcpy(inBuff, buffer + nInOffset, ENCRYPT_BLOCK_SIZE);
			aes_cipher(&aes, inBuff, ouBuff);
			memcpy(pOutBuff + nOutOffset, ouBuff, ENCRYPT_BLOCK_SIZE);
			nInOffset += ENCRYPT_BLOCK_SIZE;
			nOutOffset += ENCRYPT_BLOCK_SIZE;
		}
		else
		{
			int nDataLen = *len - nInOffset;
			int nFillData = ENCRYPT_BLOCK_SIZE - nDataLen;
			memset(inBuff, nFillData, ENCRYPT_BLOCK_SIZE);
			memset(ouBuff, 0, ENCRYPT_BLOCK_SIZE);
			if (nDataLen > 0)
			{
				memcpy(inBuff, buffer + nInOffset, nDataLen);
				aes_cipher(&aes, inBuff, ouBuff);
				memcpy(pOutBuff + nOutOffset, ouBuff, ENCRYPT_BLOCK_SIZE);
				nInOffset += nDataLen;
				nOutOffset += ENCRYPT_BLOCK_SIZE;
			}
			else
			{
				aes_cipher(&aes, inBuff, ouBuff);
				memcpy(pOutBuff + nOutOffset, ouBuff, ENCRYPT_BLOCK_SIZE);
				nOutOffset += ENCRYPT_BLOCK_SIZE;
			}
			break;
		}
	}
	nOutLen = nOutOffset;
	outData = std::string(pOutBuff, nOutLen);
	free(pOutBuff);
	if (nOutLen + nBeginOffset > *len + 16)
		return -1;
	*len = nOutLen + nBeginOffset;
	return 0;
}

_int32 AES::aes_decrypt_with_known_key(char* pDataBuff, _u32* nBuffLen,
		_u8 *p_aeskey, std::string &outData)
{
	_int32 ret;
	int nBeginOffset;
	char *pOutBuff;
	int nOutLen;
	ctx_aes aes;
	int nInOffset;
	int nOutOffset;
	unsigned char inBuff[ENCRYPT_BLOCK_SIZE], ouBuff[ENCRYPT_BLOCK_SIZE];
	char * out_ptr;
	if (pDataBuff == NULL)
	{
		return -1;
	}
	nBeginOffset = 0;
	if ((*nBuffLen - nBeginOffset) % ENCRYPT_BLOCK_SIZE != 0)
	{
		return -2;
	}
	pOutBuff = (char*) malloc(*nBuffLen + 16);
	if (pOutBuff == NULL)
		return -1;

	nOutLen = 0;

	aes_init(&aes, 16, p_aeskey);
	nInOffset = nBeginOffset;
	nOutOffset = 0;
	memset(inBuff, 0, ENCRYPT_BLOCK_SIZE);
	memset(ouBuff, 0, ENCRYPT_BLOCK_SIZE);
	while (*nBuffLen - nInOffset > 0)
	{
		memcpy(inBuff, pDataBuff + nInOffset, ENCRYPT_BLOCK_SIZE);
		aes_invcipher(&aes, inBuff, ouBuff);
		memcpy(pOutBuff + nOutOffset, ouBuff, ENCRYPT_BLOCK_SIZE);
		nInOffset += ENCRYPT_BLOCK_SIZE;
		nOutOffset += ENCRYPT_BLOCK_SIZE;
	}
	nOutLen = nOutOffset;

	out_ptr = pOutBuff + nOutLen - 1;
	if (*out_ptr <= 0 || *out_ptr > ENCRYPT_BLOCK_SIZE)
	{
		ret = -3;
	}
	else
	{
		if (nBeginOffset + nOutLen - *out_ptr < *nBuffLen)
		{
			*nBuffLen = nBeginOffset + nOutLen - *out_ptr;
			ret = 0;
		}
		else
		{
			ret = -4;
		}
	}
	outData = std::string(pOutBuff,*nBuffLen);
	free(pOutBuff);
	return ret;
}

int AES::encrypt4aes(const std::string &inData, const std::string &strKey,
		std::string &outData, std::string &errMsg)
{
	outData = "";
	errMsg = "";

	if (inData.empty() || strKey.empty())
	{
		errMsg = "indata or key is empty!!";
		return -1;
	}

	unsigned int iKeyLen = strKey.length();

	if (iKeyLen != AES_KEY_LENGTH_16 && iKeyLen != AES_KEY_LENGTH_24
			&& iKeyLen != AES_KEY_LENGTH_32)
	{
		errMsg = "aes key invalid!!";
		return -2;
	}

	char* aes_data = const_cast<char*>(inData.c_str());
	unsigned int aes_data_len = (unsigned int) (inData.length());
	unsigned char* md5_result_data =
			(unsigned char*) (const_cast<char*>(strKey.c_str()));

	outData = "";

	int iResult = aes_encrypt_with_known_key(aes_data, &aes_data_len,
			md5_result_data, outData);

	if(iResult)
	{
		errMsg = "aes_encrypt_with_known_key failed!!";
		iResult = -3;
	}

	return iResult;
}

int AES::decrypt4aes(const std::string &inData, const std::string &strKey,
		std::string &outData, std::string &errMsg)
{
	outData = "";
	errMsg = "";

	if (inData.empty() || strKey.empty())
	{
		errMsg = "indata or key is empty!!";
		return -1;
	}

	unsigned int iKeyLen = strKey.length();

	if (iKeyLen != AES_KEY_LENGTH_16 && iKeyLen != AES_KEY_LENGTH_24
			&& iKeyLen != AES_KEY_LENGTH_32)
	{
		errMsg = "aes key invalid!!";
		return -2;
	}

	int iResult = 0;

	char* aes_data = const_cast<char*>(inData.c_str());
	unsigned int aes_data_len = (unsigned int) (inData.length());
	unsigned char* md5_result_data =
			(unsigned char*) (const_cast<char*>(strKey.c_str()));

	outData = "";

	iResult = aes_decrypt_with_known_key(aes_data, &aes_data_len,
			md5_result_data, outData);

	if(iResult)
	{
		errMsg = "aes_encrypt_with_known_key failed!!";
		iResult = -3;
	}

	return iResult;
}

int main(int argc, char**argv)
{
	std::string md5_data = "123456789";
	std::string aes_data = "";

	comm::util::MD5 md5;
	std::string strResult = md5.md5(md5_data);

	comm::util::AES aes;
	std::string errMsg;
	std::string outData;
	aes.encrypt4aes(aes_data, strResult, outData, errMsg);

	std::string strInput;
	aes.decrypt4aes(outData, strResult, strInput, errMsg);

	for (int i = 0; i < strInput.length(); i++)
	{
		printf("%c", strInput[i] & 255);
	}

	printf("\n");

	return 0;
}



lcli
关注
专栏目录
AES加密算法的C++实现
dbbaq24022的专栏
12-13 4176
摘要：作为新一代的加密标准，AES 旨在取代 DES（请看《DES加密算法的C++实现》），以适应当今分布式开放网络对数据加密安全性的要求。本文在分析了 AES 加密原理的基础上着重说明了算法实现的具体步骤，并用 C++ 实现了对文件的加密和解密。 一、AES 介绍 AES（高级加密标准，Advanced Encryption Standard），在密码学中又称 ...
AES/ECB---C++算法实现
ailugong8410的博客
05-15 300
　　密码学课后作业实现AES/ECB算法的实现，所以这几天都有在查一些AES资料，在此整理下并附上C++代码(: 　　这里引用一下维基上关于AES的基本介绍： AES加密过程是在一个4×4的字节矩阵上运作，这个矩阵又称为“体（state）”，其初值就是一个明文区块（矩阵中一个元素大小就是明文区块中的一个Byte）。（Rijndael加密法因支持更大的区块，其矩阵行数可视情况增加）加...
强力加密工具：C++版AES 256 GCM——跨平台数据安全的守护者
最新发布
gitblog_00120的博客
09-12 345
强力加密工具：C++版AES 256 GCM——跨平台数据安全的守护者 AES_GCM_256_C 项目地址: https://gitcode.com/gh_mirrors/ae/AES_GCM_256_C ...
【php】php的AES的算法实现（增加解密算法，优化域算法）
行路中
10-31 1276
一直没时间写解密算法，最近要用到，就写了个。还有调用的类也整理了以下。     class.Aes.php <?php class Aes { /** * AES Cipher function: encrypt 'input' with Rijndael algorithm * * @param input message as byte-array (16
使用C++的方式实现AES算法
CHYabc123456hh的博客
11-23 716
aes_file.h #include <iostream> #include <fstream> #include <bitset> #include <string> using namespace std; typedef bitset<8> byte; typedef bitset<32> word; const int Nr = 10; // AES-128需要 10 轮加密 const int Nk = 4; /
AES加密算法C++实现
LearnLHC的博客
05-22 5037
（1）aes.h#ifndef aes_h__ #define aes_h__ class AES { public: AES(unsigned char* key); virtual ~AES(); unsigned char* Cipher(unsigned char* input); // 加密，传入的数组大小必须是16字节 unsigned char* InvCiphe...
c++语言实现AES加密算法代码.zip
11-10
SummerMVP的gravatar头像 SummerMVP2020-04-16 17:32:30原c++语言实现AES加密算法代码分享 项目描述 AES的实现 1. 只要求实现块长为 128 位、密钥长为 128 位的 AES，分别实现 ECB、CBC、CFB、OFB 这...C++，AES算法
基于C++实现简易AES加解密算法
07-12
二、AES算法原理 AES由一系列操作组成，包括字节替换（SubBytes）、行位移（ShiftRows）、列混淆（MixColumns）和密钥扩展（KeyExpansion）。这些步骤在加密和解密过程中交替进行，形成多个轮的处理。128位的输入...
利用C\C++实现AES算法的加、解密运算
04-15
（1）分组长度128比特，16字节。 （2）定义位操作LOAD32H(x, y) 将uint8_t y[4] 转换成 uint32_t x，STORE32H(x, y) 将uint32_t x 转换成 uint8_t y[4]，BYTE(x, n) 从uint32_t x中提取从低位开始的第n个字节，MIX...
AES加解密算法（C++实现）
03-05
支持 CFB, OFB, CBC, ECB 模式，支持256字节以下任意长度数据加解密，也可以放开成任意长度数据加解密。 其中：AES.cpp 中为算法的实现代码;Test.cpp为测试程序
C++实现的AES算法
01-18
在原有的AES算法上，做了修改，解决了源代码的一个BUG，在加密解密过程中，不会出现乱码现象。
C++实现AES算法
06-15
《Theory and Technology of Secure Protocol in Communication Network》作业2：实现AES算法。实验环境VS2010
AES（c++编的）
04-10
AES——国际主流加密算法，这里是一个完整的可运行代码
AES的C++实现(128位密钥)
05-25
AES的C++实现(128位密钥) 写了一个AES的C++实现，支持128位密钥，仅供参考。
AES 加密算法源代码20091025 （C++版）
10-27
AES类的三个公共函数 //设置AES类的模式为加密还是解密，并说明密钥长度和明文长度(解密时为密文) //key 密钥数据 //keySize 密钥长度 //inSize 明文长度(解密时为密文) //isdecrypt 是否为解密(解密时为TRUE) //成功返回1 失败返回-1 失败是由于参数设置不正确引起 int setMode(unsigned char* key, int keySize, int inSize, bool isdecrypt); //加密数据 //input 明文数据，长度为setMode时inSize指定 //ouput 加密后的数据，长度为setMode时inSize指定 void cipher (const unsigned char* input, unsigned char* output); //解密数据 //input 密文数据，长度为setMode时inSize指定 //output 明文数据，长度为setMode时inSize指定 void invCipher(const unsigned char* input, unsigned char* output); //例子 #include "aes.h" #include void main() { char* str = "0123456789abcdef"; //被加密的数据16字节 char* pwd = "1111111111111111"; //密码16字节 char out[17]; //输出缓存 out[16]='\0'; AES aes; /*加密时*/ aes.setMode(pwd, 16, 16, FALSE); aes.cipher(str, out); printf(out); //输出加密数据 printf("\n"); /*解密时*/ aes.setMode(pwd, 16, 16, TRUE); aes.invCipher(out, out); printf(out); } 本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/scofield_zhang/archive/2008/07/21/2687037.aspx
c++实现AES加密算法
林庆丰的博客
10-01 973
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
AES加密算法
zgjxhgh的专栏
03-29 1320
先搞定AES算法，基本变换包括SubBytes（字节替代）、ShiftRows（行移位）、MixColumns（列混淆）、AddRoundKey(轮密钥加） 其算法一般描述为 明文及密钥的组织排列方式   ByteSubstitution（字节替代） 非线性的字节替代，单独处理每个字节： 求该字节在有限域GF(28)上的乘法逆，"0"被映射为自身，即对于α∈GF(28)，求β∈
密码学——128位AES算法（C/C++实现）
Rayme629的博客
03-30 6370
使用C/C++实现128位AES算法
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值