1 AES算法介绍
美国国家标准技术研究所在2001年发布了高级加密标准（AES）。AES是一个对称加密算法，旨在取代DES成为广泛使用的标准，该标准以Rijndael算法为核心。
Rijndael算法是一种对称分组密码体制，采用代替或置换网络，每轮由三层组成：线性混合层确保多轮之上的高度扩散；非线性层由S盒并置起到混淆的作用；密钥加密层将子密钥异或到中间状态。
AES标准规定Rijndael算法的分组长度为128位，而密钥长度可以为128、192或256位，相应的迭代轮数为10轮、12轮或14轮。Rijndael 汇聚了安全性能、效率、可实现性和灵活性等优点。Rijndael 对内存的需求低，使它很适合用于资源受限制的环境中，Rijndael 的操作简单，并可抵御强大和实时的攻击
AES加密算法流程如下：
图1. AES算法流程
2 加密、解密涉及的操作介绍
2.1 字节代替
用一个S盒完成分组的字节到字节的代替；是一个基于S盒的非线性置换，它用于将每一个字节通过一个简单的查表操作映射为另一个字节。映射方法是把输入字节的高4位作为S盒的行值，低4位作为列值，然后取出S盒中对应行和列交叉位的元素作为输出
图2.字节代换
2.2 行移位
AES 的行移位也是一个简单的左循环移位操作。当密钥长度为128比特时，状态矩阵的第0行左移0字节，第1行左移1字节，第2行左移2字节，第3行左移3字节
图3. 行移位
2.3 列混合
列混合变换是通过矩阵相乘来实现的，经行移位后的状态矩阵与固定的矩阵相乘，得到混淆后的状态矩阵。
图4. 列混合
2.4 轮密钥加
当前分组和扩展密钥的一部分进行按位异或，将输入或中间态S的每一列与一个密钥字ki进行按位异或，即将128位轮密钥 Ki 同状态矩阵中的数据进行逐位异或操作。
3 密钥编排
1) 用一个 4 字节字元素的一维数组 W[Nb*(Nr+1)]表示扩展密钥。
2) 数组中最开始的 Nk 个字为种子密钥。
3) 其它的字由它前面的字经过递归处理后得到。
新列以如下的递归方式产生：
1) 如果i不是4的倍数，那么第i列由如下等式确定：
W[i]=W[i-4]⨁W[i-1]
2) 如果i是4的倍数，那么第i列由如下等式确定：
W[i]=W[i-4]⨁T(W[i-1])
函数T由3部分组成：字循环、字节代换和轮常量异或
a) 字循环：将1个字中的4个字节循环左移1个字节。即将输入字[b0, b1, b2, b3]变换成[b1,b2,b3,b0]。
b) 字节代换：对字循环的结果使用S盒进行字节代换。
c) 轮常量异或：将前两步的结果同轮常量Rcon[j]进行异或，其中j表示轮数。
4 代码
4.1 密钥扩展
keyExtend.h
#ifndef KEYEXTEND_H
#define KEYEXTEND_H
#include<bitset>
using namespace std;
typedef bitset<8> byte;
typedef bitset<32> word;
extern byte S[256];
extern byte inv_S[256];
extern word rcon[10];
extern byte encry_s[4*4];
extern byte decry_s[4*4];
//定义种子密钥长度以及扩展轮数
const int Nr = 10;//轮数
const int Nk = 4; //种子密钥有四个字
//密钥扩展 相关函数
// 1 四个字节转换成一个字
word Word(byte b0,byte b1,byte b2,byte b3);
// 2 字移位
word CycWord(word rw);
// 3 S盒替换
word SubWord(word sw);
// 4 密钥扩展
void KeyExpansion(byte key[4*Nk],word w[4*(Nr+1)]);
// 加密使用的列混合数组
#endifkeyExtend.cpp
#include"keyExtend.h"
#include<iostream>
#include<string>
using namespace std;
// S盒
byte S[256] = {
0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
};
//逆S盒
byte inv_S[256] = {
0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
};
// AES-128轮常量
word rcon[10] = {
0x01000000UL, 0x02000000UL, 0x04000000UL, 0x08000000UL, 0x10000000UL,
0x20000000UL, 0x40000000UL, 0x80000000UL, 0x1B000000UL, 0x36000000UL
};
// 加密使用的列混合数组
byte encry_s[16]={
0x02,0x03,0x01,0x01,
0x01,0x02,0x03,0x01,
0x01,0x01,0x02,0x03,
0x03,0x01,0x01,0x02
} ;
// 解密使用的列混合数组
byte decry_s[4*4]={
0x0e,0x0b,0x0d,0x09,
0x09,0x0e,0x0b,0x0d,
0x0d,0x09,0x0e,0x0b,
0x0b,0x0d,0x09,0x0e
};
//准备事件：将四个字节转化为一个字，方便进行计算
word Word(byte b0,byte b1,byte b2,byte b3){
word wordres=0x00000000;
word temp;
temp=b0.to_ulong();//b0
temp<<=24;
wordres|=temp;
temp=b1.to_ulong();//b1
temp<<=16;
wordres|=temp;
temp=b2.to_ulong();//b2
temp<<=8;
wordres|=temp;
temp=b3.to_ulong();//b0
wordres|=temp;
return wordres;
}
//第一步：字循环
//将1个字中的4个字节循环左移1个字节。即将输入字[b0, b1, b2, b3]变换成[b1,b2,b3,b0]。
word CycWord(word rw){
word high = rw<<8;
word low = rw>>24;
return high^low;
}
//第二步：字节代换
//对字循环的结果使用S盒进行字节代换。
word SubWord(word sw){
word temp;
for(int i=0;i<32;i+=8){
//先确定密钥字所在的位置
int row=sw[i+7]*8+sw[i+6]*4+sw[i+5]*2+sw[i+4]*1;
int col=sw[i+3]*8+sw[i+2]*4+sw[i+1]*2+sw[i]*1;
//进行S盒代换
byte tempvar=S[row*16+col];
for(int j=0;j<8;j++){
temp[i+j]=tempvar[j];
}
}
return temp;
}
//第三步：轮常量异或
//将前两步的结果同轮常量Rcon[j]进行异或，其中j表示轮数。
/*密钥扩展函数
1) 如果i不是4的倍数，那么第i列由如下等式确定：
W[i]=W[i-4]^W[i-1]
2) 如果i是4的倍数，那么第i列由如下等式确定：
W[i]=W[i-4]^T(W[i-1])
*/
void KeyExpansion(byte key[4*Nk],word w[4*(Nr+1)]){
word temp;
int i=0;
//获取种子密钥（前四个字）
while(i<Nk){
w[i]=Word(key[4*i],key[4*i+1],key[4*i+2],key[4*i+3]);
i++;
}
i=Nk;
//开始进行密钥扩展
while(i<4*(Nr+1)){
temp=w[i-1];
if(i%Nk==0){
w[i]=w[i-Nk]^SubWord(CycWord(temp))^rcon[i/Nk-1];
// cout<<"w["<<dec<<i<<"]对应的论常量为："<<hex<<rcon[i/Nk-1]<<endl;
// if(i==8){
// cout<<"w[8]的字移位，S盒变换以及论常量异或结果分别为："<<endl;
// cout<<CycWord(temp)<<endl;
// cout<<SubWord(CycWord(temp))<<endl;
// word c=SubWord(CycWord(temp))^ rcon[i/Nk-1];
// cout<<c<<endl;
// }
}else{
w[i]=w[i-Nk]^temp;
}
i++;
}
}
4.2 加密
encryption.h
#ifndef ENCRYPTION_H
#define ENCRYPTION_H
#include "keyExtend.h"
using namespace std;
/*
预处理工作
1 设计有限域上的乘法函数
*/
// 设计有限域上的乘法函数
byte GFMul(byte a,byte b);
// 1 轮密钥加
void RKey_Add(byte sta_matr[4*4],word w[4]);
// 2 字节代换
void SubBytes(byte sta_matr[4*4]);
// 3 行移位--按行进行字节移位
void ShiftRow(byte sta_matr[4*4]);
// 4 列混合
void MixColumns(byte sta_matr[4*4],byte s[4*4]);
// 5 加密函数
void encrypt(byte in[4*4],word w[4*(Nr+1)]);
#endifencryption.cpp
#include<iostream>
#include<string>
#include"encryption.h"
using namespace std;
//有限域上的乘法 GF(2^8) 表示含有2的N次方个元素的有限域 代码已测没问题
// 注意可以手写一下二进制乘法就知道原理了
byte GFMul(byte a, byte b) {
byte p = 0;
for (int i= 0;i< 8;i++) {
//先判断b的低阶位
if (b[0] == 1)
p ^= a;
//拿到a的高阶位
int temp=a[7];
a <<= 1;
//左移导致溢出了 所以用假如没有丢失数据的左移后a mod m(x) 等价于丢失数据后a ^ 0x1b
if (temp==1)
a ^= 0x1b;
b >>= 1;
}
return p;
}
// 1 轮密钥加 将状态矩阵的一列的四个字节和轮密钥的对应字节进行异或
void RKey_Add(byte sta_matr[4*4],word w[4]){
for(int i=0;i<4;i++){
//每一轮完成一列 四个字节的异或
word k0 = w[i]>>24;
word k1 = (w[i]<<8)>>24;
word k2 = (w[i]<<16)>>24;
word k3 = (w[i]<<24)>>24;
sta_matr[i] = sta_matr[i]^byte(k0.to_ulong());
sta_matr[i+4] = sta_matr[i+4]^byte(k1.to_ulong());
sta_matr[i+8] = sta_matr[i+8]^byte(k2.to_ulong());
sta_matr[i+12] = sta_matr[i+12]^byte(k3.to_ulong());
}
}
// 2 字节代换 经测试没有问题
void SubBytes(byte sta_matr[4*4]){
// 将16个字节依次进行代换
for(int i=0;i<16;i++){
//bitset地址存放是低位在前,高位在后,与常规相反,计算需要谨慎
int row = sta_matr[i][7]*8+sta_matr[i][6]*4+sta_matr[i][5]*2+sta_matr[i][4]*1;
int col = sta_matr[i][3]*8+sta_matr[i][2]*4+sta_matr[i][1]*2+sta_matr[i][0]*1;
sta_matr[i] = S[row*16+col];
}
}
// 3 行移位--按行进行字节移位 代码已测没问题
void ShiftRow(byte sta_matr[4*4]){
//第二行循环左移一个字节
//第三行循环左移二个字节
//第三行循环左移三个字节
for(int i=0;i<4;i++){
byte temp[i];
//存数 防止被覆盖
for(int j=0;j<i;j++){
temp[j]=sta_matr[i*4+j];
}
// 将不会发生下标溢出的进行赋值
for(int j=0;j<4-i;j++){
sta_matr[i*4+j]=sta_matr[i*4+j+i];
}
// 将暂存的数放回状态数组 行中
for(int m=4-i;m<4;m++){
sta_matr[i*4+m]=temp[m+i-4];
}
}
}
// 4 列混合 经测试没问题
void MixColumns(byte sta_matr[4*4],byte s[4*4]){
byte matr[4];
for(int i=0;i<4;i++){
for(int j=0;j<4;j++)
matr[j] = sta_matr[i+j*4];
sta_matr[i] = GFMul(s[0], matr[0]) ^ GFMul(s[1], matr[1]) ^ GFMul(s[2], matr[2]) ^ GFMul(s[3], matr[3]);
sta_matr[i+4] = GFMul(s[4], matr[0]) ^ GFMul(s[5], matr[1]) ^ GFMul(s[6], matr[2]) ^ GFMul(s[7], matr[3]);
sta_matr[i+8] = GFMul(s[8], matr[0]) ^ GFMul(s[9], matr[1]) ^ GFMul(s[10], matr[2]) ^ GFMul(s[11], matr[3]);
sta_matr[i+12] = GFMul(s[12], matr[0]) ^ GFMul(s[13], matr[1]) ^ GFMul(s[14], matr[2]) ^ GFMul(s[15], matr[3]);
}
}
// 5 加密函数
void encrypt(byte sta_matr[4*4],word w[4*(Nr+1)]){
word key[4];
for(int i=0; i<4; i++)
key[i] = w[i];
//先进行一次轮密钥加
RKey_Add(sta_matr,key);
// cout<<"第0轮加密的结果是："<<endl;
// for(int i=0;i<16;i++){
// cout<<hex<<sta_matr[i].to_ulong()<<" ";
// if((i+1)%4==0)cout<<endl;}
//九轮操作 S盒 行移位 列混合 轮密钥加
for(int r=1; r<Nr; r++)
{
SubBytes(sta_matr);
ShiftRow(sta_matr);
MixColumns(sta_matr,encry_s);
for(int i=0; i<4; i++)
key[i] = w[4*r+i];
RKey_Add(sta_matr, key);
// cout<<endl;
// cout<<"第"<<r<<"轮加密的结果是："<<endl;
// for(int i=0;i<16;i++){
// cout<<hex<<sta_matr[i].to_ulong()<<" ";
// if((i+1)%4==0)cout<<endl;
// }
}
//第十轮 S盒 行移位 轮密钥加
SubBytes(sta_matr);
ShiftRow(sta_matr);
for(int i=0; i<4; ++i)
key[i] = w[4*Nr+i];
RKey_Add(sta_matr, key);
cout<<endl;
// cout<<"第10轮加密的结果是："<<endl;
// for(int i=0;i<16;i++){
// cout<<hex<<sta_matr[i].to_ulong()<<" ";
// if((i+1)%4==0)cout<<endl;
// }
}
4.3 解密
decrypt.h
#ifndef DECRYPT_H
#define DECRYPT_H
#include"encryption.h"
using namespace std;
// 1 逆行变换
void InvShiftRow(byte sta_matr[4*4]);
// 2 逆S盒变换
void InvSubBytes(byte sta_matr[4*4]);
// 3 逆列变换
void InvMixColumns(byte sta_matr[4*4]);
// 4 解密函数
void decrypt(byte in[4*4],word w[4*(Nr+1)]);
#endifdecrypt.cpp
#include<iostream>
#include<string>
#include"decrypt.h"
using namespace std;
// 1 逆行变换 循环右移 已测试没有问题
void InvShiftRow(byte sta_matr[4*4]){
for(int i=0;i<4;i++){
byte temp[i];
//存数 防止被覆盖
for(int j=0;j<i;j++){
temp[j]=sta_matr[i*4+3-j];
}
// 将不会发生下标溢出的进行赋值
for(int j=0;j<4-i;j++){
sta_matr[i*4+3-j]=sta_matr[i*4+3-j-i];
}
// 将暂存的数放回状态数组 行中
for(int m=0;m<i;m++){
sta_matr[i*4+m]=temp[i-m-1];
}
}
}
// 2 逆S盒变换 没变化没问题
void InvSubBytes(byte sta_matr[4*4]){
// 将16个字节依次进行代换
for(int i=0;i<16;i++){
//bitset地址存放是低位在前,高位在后,与常规相反,计算需要谨慎
int row = sta_matr[i][7]*8+sta_matr[i][6]*4+sta_matr[i][5]*2+sta_matr[i][4];
int col = sta_matr[i][3]*8+sta_matr[i][2]*4+sta_matr[i][1]*2+sta_matr[i][0];
sta_matr[i] = inv_S[row*16+col];
}
}
// 3 逆列变换 没变化没问题
void InvMixColumns(byte sta_matr[4*4],byte s[4*4]){
byte matr[4];
for(int i=0;i<4;i++){
for(int j=0;j<4;j++)
matr[j] = sta_matr[i+j*4];
sta_matr[i] = GFMul(s[0], matr[0]) ^ GFMul(s[1], matr[1]) ^ GFMul(s[2], matr[2]) ^ GFMul(s[3], matr[3]);
sta_matr[i+4] = GFMul(s[4], matr[0]) ^ GFMul(s[5], matr[1]) ^ GFMul(s[6], matr[2]) ^ GFMul(s[7], matr[3]);
sta_matr[i+8] = GFMul(s[8], matr[0]) ^ GFMul(s[9], matr[1]) ^ GFMul(s[10], matr[2]) ^ GFMul(s[11], matr[3]);
sta_matr[i+12] = GFMul(s[12], matr[0]) ^ GFMul(s[13], matr[1]) ^ GFMul(s[14], matr[2]) ^ GFMul(s[15], matr[3]);
}
}
// 4 解密函数
void decrypt(byte sta_matr[4*4],word w[4*(Nr+1)]){
word key[4];
for(int i=0; i<4; i++)
key[i] = w[4*Nr+i];
//先进行一次轮密钥加
RKey_Add(sta_matr,key);
//九轮操作 逆行移位 逆S盒 轮密钥加 逆列混合
for(int r=Nr-1; r>0; r--)
{
InvShiftRow(sta_matr);
InvSubBytes(sta_matr);
for(int i=0; i<4; i++)
key[i] = w[4*r+i];
RKey_Add(sta_matr, key);
InvMixColumns(sta_matr,decry_s);
}
//第十轮 逆行移位 逆S盒 轮密钥加
InvShiftRow(sta_matr);
InvSubBytes(sta_matr);
for(int i=0; i<4; i++)
key[i] = w[i];
RKey_Add(sta_matr, key);
}
4.4 main函数
#include"encryption.h"
#include"decrypt.h"
#include<iostream>
#include<bitset>
int main(){
//种子密钥
byte key[16] = {0x2b, 0x7e, 0x15, 0x16,
0x28, 0xae, 0xd2, 0xa6,
0xab, 0xf7, 0x15, 0x88,
0x09, 0xcf, 0x4f, 0x3c};
// byte key[16] = {0x00, 0x01, 0x02, 0x03,
// 0x04, 0x05, 0x06, 0x07,
// 0x08, 0x09, 0x01, 0x02,
// 0x03, 0x04, 0x05, 0x06};
// byte key[16] = {0x00, 0x01, 0x02, 0x03,
// 0x04, 0x05, 0x06, 0x07,
// 0x08, 0x09, 0x0a, 0x0b,
// 0x0c, 0x0d, 0x0e, 0x0f};
//输入的明文
byte sta_matr[16]={0x32,0x88,0x31,0xe0,
0x43,0x5a,0x31,0x37,
0xf6,0x30,0x98,0x07,
0xa8,0x8d,0xa2,0x34};
// byte sta_matr[16]={0x61,0x62,0x63,0x64,
// 0x65,0x66,0x67,0x68,
// 0x69,0x6A,0x6B,0x6C,
// 0x6D,0x6E,0x6F,0x70
// };
// byte sta_matr[16] = {0x00, 0x11, 0x22, 0x33,
// 0x44, 0x55, 0x66, 0x77,
// 0x88, 0x99, 0xaa, 0xbb,
// 0xcc, 0xdd, 0xee, 0xff};
//进行密钥扩展
word w[4*(Nr+1)];
KeyExpansion(key,w);
//输出密钥
cout<<"密钥是:"<<endl;
for(int i=0;i<16;i++){
cout<<hex<<key[i].to_ulong()<<" ";
if((i+1)%4==0)cout<<endl;
}
cout<<endl;
//输出明文
cout<<"明文是:"<<endl;
for(int i=0;i<16;i++){
cout<<hex<<sta_matr[i].to_ulong()<<" ";
if((i+1)%4==0)cout<<endl;
}
//输出密文
cout<<endl;
encrypt(sta_matr,w);
cout<<"密文是:"<<endl;
for(int i=0;i<16;i++){
cout<<hex<<sta_matr[i].to_ulong()<<" ";
if((i+1)%4==0)cout<<endl;
}
//再次进行解密
cout<<endl;
cout<<"密文解密是:"<<endl;
decrypt(sta_matr,w);
for(int i=0;i<16;i++){
cout<<hex<<sta_matr[i].to_ulong()<<" ";
if((i+1)%4==0)cout<<endl;
}
return 0;
/*
以下是函数正确性验证部分
1 密钥扩展验证
for(int i=0;i<4*(Nr+1);i++){
cout<<"w["<<dec<<i<<"]="<<hex<<w[i].to_ulong()<<endl;
}
2 验证有限域乘法
byte temp=GFMul(0x57,0x83);
for(int i=0;i<8;i++){
cout<<temp[i]<<" ";}
cout<<endl;
cout<<"0x57*0x83:"<<hex<<temp.to_ulong();
3 测试字节代换有无问题
SubBytes(sta_matr);
cout<<"字节代换后是:"<<endl;
for(int i=0;i<16;i++){
cout<<hex<<sta_matr[i].to_ulong()<<" ";
if((i+1)%4==0)cout<<endl;
}
4 测试列混合函数是否正确
byte s[16] = {0xc9,0xe5,0xfd,0x2b,
0x7a,0xf2,0x78,0x6e,
0x63,0x9c,0x26,0x67,
0xb0,0xa7,0x82,0xe5};
MixColumns(s,encry_s);
for(int i=0;i<16;i++){
cout<<hex<<s[i].to_ulong()<<" ";
if((i+1)%4==0)cout<<endl;
}
*/
/*
以下维验证bitset类型数据的存储以及计算方式
1 小端模式：即常规思维的0011 0011在计算机存储变成1100 1100
2 定义的两个byte(bitset<8>)数据进行异或也是按照两个小端形式的数据进行异或，存储的依旧是小端格式
3 如果按位输出 小端格式 按字节输出 大端格式
4 比如使用a则正常顺序(大端) 仅当按位的时候才是小端
5 a^b 按字节输出是正常大端顺序
byte temp0=0x57;
cout<<temp<<endl;
cout<<(temp>>1)<<endl;
cout<<temp[5];
byte temp2=0x83;
cout<<(temp^temp2);
cout<<"temp1:";
for(int i=0;i<8;i++){
cout<<temp[i]<<" ";
}
cout<<endl;
cout<<"temp2:";
for(int i=0;i<8;i++){
cout<<temp2[i]<<" ";
}
cout<<endl;
cout<<"temp1^temp2:";
byte temp3=temp^temp2;
for(int i=0;i<8;i++){
cout<<temp3[i]<<" ";
}
cout<<dec<<temp3.to_ulong();
*/
} 4.5 结果测试
4060
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
