// 写了一个AES的C++实现,仅支持128位密钥, 写得匆忙,不够规范,仅供参考。
// AES.h
#ifndef AES_H_
#define AES_H_
#include <bitset>
#include <utility>
using namespace std;
class AES
{
public:
typedef unsigned char byte;
static const int KEY_SIZE = 16; // 密钥长度为128位
static const int N_ROUND = 11;
byte plainText[16]; // 明文
byte state[16]; // 当前分组。
byte cipherKey[16]; // 密钥
byte roundKey[N_ROUND][16]; //轮密钥
byte cipherText[16]; //密文
byte SBox[16][16]; // S盒
byte InvSBox[16][16]; // 逆S盒
void EncryptionProcess();
void DecryptionProcess();
void Round(const int& round);
void InvRound(const int& round);
void FinalRound();
void InvFinalRound();
void KeyExpansion();
void AddRoundKey(const int& round);
void SubBytes();
void InvSubBytes();
void ShiftRows();
void InvShiftRows();
void MixColumns();
void InvMixColumns();
void BuildSBox();
void BuildInvSBox();
void InitialState(const byte* text);
void InitialCipherText();
void InitialplainText();
byte GFMultplyByte(const byte& left, const byte& right);
const byte* GFMultplyBytesMatrix(const byte* left, const byte* right);
public:
AES();
const byte* Cipher(const byte* text, const byte* key, const int& keySize);
const byte* InvCipher(const byte* text, const byte* key, const int& keySize);
};
void AES::EncryptionProcess()
{ // 加密过程
InitialState(plainText);
KeyExpansion(); // 密钥扩展
AddRoundKey(0); // 轮密钥加
for(int i = 1; i < N_ROUND-1; ++i)
{
Round(i);
}
FinalRound();
InitialCipherText();
}
void AES::DecryptionProcess()
{ // 解密过程
InitialState(cipherText);
KeyExpansion();
InvFinalRound();
for(int i = N_ROUND-2; i > 0 ; --i)
{
InvRound(i);
}
AddRoundKey(0);
InitialplainText();
}
void AES::Round(const int& round)
{ // 正常轮
SubBytes();
ShiftRows();
MixColumns();
AddRoundKey(round);
}
void AES::InvRound(const int& round)
{ // 正常轮的逆
AddRoundKey(round);
InvMixColumns();
InvShiftRows();
InvSubBytes();
}
void AES::FinalRound()
{ // 最后轮
SubBytes();
ShiftRows();
AddRoundKey(N_ROUND - 1);
}
void AES::InvFinalRound()
{ // 最后轮的逆
AddRoundKey(N_ROUND - 1);
InvShiftRows();
InvSubBytes();
}
void AES::KeyExpansion()
{ // 密钥扩展
const byte rcon[N_ROUND][4] = {
{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 < 16; ++i)
{
roundKey[0][i] = cipherKey[i];
}
for(int i = 0; i < 4; ++i)
{ // roundKey[0][16]为cipherKey的转置矩阵
for(int j = 0; j < 4; ++j)
{
roundKey[0][4*i + j] = cipherKey[4*j + i];
}
}
for(int roundIndex = 1; roundIndex < N_ROUND; ++roundIndex)
{
byte rotWord[4] = {0x00};
rotWord[0] = roundKey[roundIndex - 1][3];
rotWord[1] = roundKey[roundIndex - 1][7];
rotWord[2] = roundKey[roundIndex - 1][11];
rotWord[3] = roundKey[roundIndex - 1][15];
std::swap<byte>(rotWord[0], rotWord[1]);
std::swap<byte>(rotWord[1], rotWord[2]);
std::swap<byte>(rotWord[2], rotWord[3]);
for(int i = 0; i < 4; ++i)
{
rotWord[i] = SBox[ rotWord[i] >> 4][ rotWord[i] & 0x0f ];
roundKey[roundIndex][4*i] = roundKey[roundIndex - 1][4*i] ^ rotWord[i] ^ rcon[roundIndex][i];
}
for(int j = 1; j < 4; ++j)
{
for(int i = 0; i < 4; ++i)
{
roundKey[roundIndex][4*i + j] = roundKey[roundIndex - 1][4*i + j] ^ roundKey[roundIndex][4*i + j - 1];
}
}
}
}
void AES::AddRoundKey(const int& round)
{ // 轮密钥加
for(int i = 0; i < 16; ++i)
{ // 利用当前分组state和第round组扩展密钥进行按位异或
state[i] ^= roundKey[round][i];
}
}
void AES::SubBytes()
{ // 字节代换
for(int i = 0; i < 16; ++i)
{
state[i] = SBox[ state[i] >> 4][ state[i] & 0x0f ];
}
}
void AES::InvSubBytes()
{ // 逆字节代换
for(int i = 0; i < 16; ++i)
{
state[i] = InvSBox[ state[i] >> 4][ state[i] & 0x0f ];
}
}
void AES::ShiftRows()
{ // 行变换
//state第一行保持不变
// Do nothing.
//state第二行循环左移一个字节
std::swap<byte>(state[4], state[5]);
std::swap<byte>(state[5], state[6]);
std::swap<byte>(state[6], state[7]);
//state第三行循环左移两个字节
std::swap<byte>(state[8], state[10]);
std::swap<byte>(state[9], state[11]);
//state第三行循环左移三个字节
std::swap<byte>(state[14], state[15]);
std::swap<byte>(state[13], state[14]);
std::swap<byte>(state[12], state[13]);
}
void AES::InvShiftRows()
{ // 行变换反演
//state第一行保持不变
// Do nothing.
//state第二行循环右移一个字节
std::swap<byte>(state[6], state[7]);
std::swap<byte>(state[5], state[6]);
std::swap<byte>(state[4], state[5]);
//state第三行循环右移两个字节
std::swap<byte>(state[9], state[11]);
std::swap<byte>(state[8], state[10]);
//state第三行循环右移三个字节
std::swap<byte>(state[12], state[13]);
std::swap<byte>(state[13], state[14]);
std::swap<byte>(state[14], state[15]);
}
void AES::MixColumns()
{ // 列混淆
byte matrix[4][4] = {
{0x02, 0x03, 0x01, 0x01},
{0x01, 0x02, 0x03, 0x01},
{0x01, 0x01, 0x02, 0x03},
{0x03, 0x01, 0x01, 0x02}};
const byte* temp = GFMultplyBytesMatrix((byte*)matrix, state);
for(int i = 0; i < 16; ++i)
{
state[i] = temp[i];
}
delete[] temp;
}
void AES::InvMixColumns()
{ // 列混淆反演
byte matrix[4][4] = {
{0x0e, 0x0b, 0x0d, 0x09},
{0x09, 0x0e, 0x0b, 0x0d},
{0x0d, 0x09, 0x0e, 0x0b},
{0x0b, 0x0d, 0x09, 0x0e} };
const byte* temp = GFMultplyBytesMatrix((byte*)matrix, state);
for(int i = 0; i < 16; ++i)
{
state[i] = temp[i];
}
delete[] temp;
}
void AES::BuildSBox()
{ // 构建S盒
byte box[16][16] =
{
/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
/*0*/ {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
- 1
- 2
- 3
- 4
- 5
- 6
前往页