密码学学习笔记（三）——AES的查表加速

最新推荐文章于 2024-06-06 08:11:59 发布
最新推荐文章于 2024-06-06 08:11:59 发布
阅读量4.6k 收藏 40
点赞数 14
分类专栏： 密码学 C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45358572/article/details/118699071
版权

文章目录


高级加密标准（Advanced Encryption Standard，AES），又称Rijndael加密法，是美国联邦政府采用的一种分组加密标准。若按算法描述进行加解密运算，就会出现计算量大、耗时长之类的问题，为解决这个问题，我们将一些复杂的过程通过查表运算代替，这样就可以通过增加存储复杂度来减少时间复杂度，从而达到在时间程度上优化算法的目的。
在AES算法中，整个加解密的过程可以归纳为字节替代（SubBytes）、行移位（ShiftRows）、列混合（MixColumns）和轮密钥加（AddRoundKey）这四种变换，如图：

在这里插入图片描述
其中，字节代替和列混合都可以通过查表的方式实现。

S盒生成

根据资料，AES的S盒的通过下式生成的：
在这里插入图片描述
而b0到b7则是原位置通过有限域GF(28)上的求逆运算得到的结果（如果想深入了解，可以学习近世代数），由于数据量较小，我们就不使用欧几里得算法求逆，而是直接利用域上逆元的定义进行求解，所以这里先定义GF(28)上的乘法运算：

word_8 mul(word_8 a,word_8 b)
{
	word_8 data[8],dat;
	data[0] = a;
	data[1] = data[0] << 1;
	if((data[0] & 0x80) == 0x80) data[1] ^= 0x1b;
	data[2] = data[1] << 1;
	if((data[1] & 0x80) == 0x80) data[2] ^= 0x1b;
	data[3] = data[2] << 1;
	if((data[2] & 0x80) == 0x80) data[3] ^= 0x1b;
	data[4] = data[3] << 1;
	if((data[3] & 0x80) == 0x80) data[4] ^= 0x1b;
	data[5] = data[4] << 1;
	if((data[4] & 0x80) == 0x80) data[5] ^= 0x1b;
	data[6] = data[5] << 1;
	if((data[5] & 0x80) == 0x80) data[6] ^= 0x1b;
	data[7] = data[6] << 1;
	if((data[6] & 0x80) == 0x80) data[7] ^= 0x1b;
	
	dat = 0x00;
	if((b & 0x01) == 0x01) dat ^= data[0];
	if((b & 0x02) == 0x02) dat ^= data[1];
	if((b & 0x04) == 0x04) dat ^= data[2];
	if((b & 0x08) == 0x08) dat ^= data[3];
	if((b & 0x10) == 0x10) dat ^= data[4];
	if((b & 0x20) == 0x20) dat ^= data[5];
	if((b & 0x40) == 0x40) dat ^= data[6];
	if((b & 0x80) == 0x80) dat ^= data[7];
	
	return dat;
}

接着就是通过遍历求逆元的运算：

word_8 tr(word_8 a)
{
	word_8 i;
	if(a == 0x00)
		return 0x00;
	else
		for(i = 0x01;i <= 0xff && i != 0x00;i++)
			if(mul(a,i) == 0x01)
				return i;
}

然后是主程序，这里我们将S盒生成到文件S.txt中：

int main()
{
	word_8 a[8] = {0xf1,0xe3,0xc7,0x8f,0x1f,0x3e,0x7c,0xf8},
			b = 0x63,x1,x,y,z,i = 0x00;
	FILE *p;
	int j,k;
	p = fopen("S.txt","wb");
	fprintf(p,"{");
	do
	{
		z = 0x00;
		x = tr(i);
		for(j = 0;j < 8;j++)
		{
			z = z >> 1;
			y = a[j] & x;
			x1 = 0x00;
			for(k = 0;k < 8;k++)
			{
				x1 ^= y & 0x80;
				y = y << 1;
			}
			z ^= x1;
		}
		z ^= b;
		fprintf(p,"0x%02x",z);
		if(i % 16 != 15)
			fprintf(p,",");
		if((i | 0xf0) == 0xff && i != 0xff)
			fprintf(p,",\n");
		i++;
	}while(i != 0x00);
	fprintf(p,"}");
	fclose(p);
	return 0;
}

这里只给出了生成正向S盒的算法，逆向S盒Un_S[]只需通过

word_8 i = 0x00;
do{
	Un_S[S[i]] = i;
}while(i != 0x00);

即可生成。

T表生成

如图，在AES中，列混合是计算复杂度最高的一个模块，矩阵中的乘法运算都是有限域GF(28)上的运算，如果能通过查表实现，那么算法的执行速度就会大大提升。
在这里插入图片描述
由于如果存一个大表的话，其所需的存储空间就会超出正常电脑的内存，所以这里我们先将如图列混合按列拆成四部分
在这里插入图片描述
可以证明，将每一个4*1的列向量左乘4*4的矩阵得到的4*1的矩阵按顺序拼接，最终得到的4*4矩阵就是所要求的矩阵，即：
在这里插入图片描述
由于这里的乘法运算只有在有限域GF(28)上任意数与01，02，03的乘法运算，所以这里我们只用建一个3*256的表进行查找即可：

void make_list()
{
	word_8 i = 0x00,j;
	do
	{
		mul_list[0][i] = i;
		j = i << 1;
		if((i & 0x80) == 0x80) j ^= 0x1b;
		mul_list[1][i] = j;
		mul_list[2][i] = i ^ j;
		i++;
	}while(i != 0x00);
}

接着我们接公式，遍历每一列的所有值，得到这一列对应的T表T1 ，T2 ，T3 ，T4 ，分别存入List_1.txt到List_4.txt中：

int main()
{
	word_8 i,j,k;
	make_list();
	FILE *p1,*p2,*p3,*p4;
	p1 = fopen("List_1.txt","wb");
	p2 = fopen("List_2.txt","wb");
	p3 = fopen("List_3.txt","wb");
	p4 = fopen("List_4.txt","wb");
	fprintf(p1,"{");
	fprintf(p2,"{");
	fprintf(p3,"{");
	fprintf(p4,"{");
	for(j = 0;j < 256;j++)//list_1
	{
		fprintf(p1,"{");
		for(i = 0;i < 4;i++)
		{
			k = mul_list[mix[i][0] - 1][j] ^
				mul_list[mix[i][1] - 1][0] ^
				mul_list[mix[i][2] - 1][0] ^
				mul_list[mix[i][3] - 1][0];
			fprintf(p1,"0x%02x",k);
			if(i != 3)
				fprintf(p1,",");
		}
		fprintf(p1,"}");
		if(j != 0xff)
			fprintf(p1,",\n");
		else
			break;
	}
	for(j = 0;j < 256;j++)//list_2
	{
		fprintf(p2,"{");
		for(i = 0;i < 4;i++)
		{
			k = mul_list[mix[i][0] - 1][0] ^
				mul_list[mix[i][1] - 1][j] ^
				mul_list[mix[i][2] - 1][0] ^
				mul_list[mix[i][3] - 1][0];
			fprintf(p2,"0x%02x",k);
			if(i != 3)
				fprintf(p2,",");
		}
		fprintf(p2,"}");
		if(j != 0xff)
			fprintf(p2,",\n");
		else
			break;
	}
	for(j = 0;j < 256;j++)//list_3
	{
		fprintf(p3,"{");
		for(i = 0;i < 4;i++)
		{
			k = mul_list[mix[i][0] - 1][0] ^
				mul_list[mix[i][1] - 1][0] ^
				mul_list[mix[i][2] - 1][j] ^
				mul_list[mix[i][3] - 1][0];
			fprintf(p3,"0x%02x",k);
			if(i != 3)
				fprintf(p3,",");
		}
		fprintf(p3,"}");
		if(j != 0xff)
			fprintf(p3,",\n");
		else
			break;
	}
	for(j = 0;j < 256;j++)//list_4
	{
		fprintf(p4,"{");
		for(i = 0;i < 4;i++)
		{
			k = mul_list[mix[i][0] - 1][0] ^
				mul_list[mix[i][1] - 1][0] ^
				mul_list[mix[i][2] - 1][0] ^
				mul_list[mix[i][3] - 1][j];
			fprintf(p4,"0x%02x",k);
			if(i != 3)
				fprintf(p4,",");
		}
		fprintf(p4,"}");
		if(j != 0xff)
			fprintf(p4,",\n");
		else
			break;
	}
	fprintf(p1,"}");
	fprintf(p2,"}");
	fprintf(p3,"}");
	fprintf(p4,"}");
	fclose(p1);
	fclose(p2);
	fclose(p3);
	fclose(p4);
	return 0;
}

同理可得解密的T表生成算法：

#include <stdio.h>
#include <stdlib.h>

typedef unsigned char word_8;

word_8 mul_list[4][256];//9,b,d,e
word_8 cipher[4][4];
int mix[4][4] = {
	{4,2,3,1},
	{1,4,2,3},
	{3,1,4,2},
	{2,3,1,4}};

word_8 mul(word_8 a,word_8 b)
{
	word_8 data[8],dat;
	data[0] = a;
	data[1] = data[0] << 1;
	if((data[0] & 0x80) == 0x80) data[1] ^= 0x1b;
	data[2] = data[1] << 1;
	if((data[1] & 0x80) == 0x80) data[2] ^= 0x1b;
	data[3] = data[2] << 1;
	if((data[2] & 0x80) == 0x80) data[3] ^= 0x1b;
	data[4] = data[3] << 1;
	if((data[3] & 0x80) == 0x80) data[4] ^= 0x1b;
	data[5] = data[4] << 1;
	if((data[4] & 0x80) == 0x80) data[5] ^= 0x1b;
	data[6] = data[5] << 1;
	if((data[5] & 0x80) == 0x80) data[6] ^= 0x1b;
	data[7] = data[6] << 1;
	if((data[6] & 0x80) == 0x80) data[7] ^= 0x1b;
	
	dat = 0x00;
	if((b & 0x01) == 0x01) dat ^= data[0];
	if((b & 0x02) == 0x02) dat ^= data[1];
	if((b & 0x04) == 0x04) dat ^= data[2];
	if((b & 0x08) == 0x08) dat ^= data[3];
	if((b & 0x10) == 0x10) dat ^= data[4];
	if((b & 0x20) == 0x20) dat ^= data[5];
	if((b & 0x40) == 0x40) dat ^= data[6];
	if((b & 0x80) == 0x80) dat ^= data[7];
	
	return dat;
}
	
void make_list()
{
	word_8 i = 0x00;
	do
	{
		mul_list[0][i] = mul(0x09,i);
		mul_list[1][i] = mul(0x0b,i);
		mul_list[2][i] = mul(0x0d,i);
		mul_list[3][i] = mul(0x0e,i);
		i++;
	}while(i != 0x00);
}

int main()
{
	word_8 i,j,k;
	make_list();
	FILE *p1,*p2,*p3,*p4;
	p1 = fopen("DeList_1.txt","wb");
	p2 = fopen("DeList_2.txt","wb");
	p3 = fopen("DeList_3.txt","wb");
	p4 = fopen("DeList_4.txt","wb");
	fprintf(p1,"{");
	fprintf(p2,"{");
	fprintf(p3,"{");
	fprintf(p4,"{");
	for(j = 0;j < 256;j++)//list_1
	{
		fprintf(p1,"{");
		for(i = 0;i < 4;i++)
		{
			k = mul_list[mix[i][0] - 1][j] ^
				mul_list[mix[i][1] - 1][0] ^
				mul_list[mix[i][2] - 1][0] ^
				mul_list[mix[i][3] - 1][0];
			fprintf(p1,"0x%02x",k);
			if(i != 3)
				fprintf(p1,",");
		}
		fprintf(p1,"}");
		if(j != 0xff)
			fprintf(p1,",\n");
		else
			break;
	}
	for(j = 0;j < 256;j++)//list_2
	{
		fprintf(p2,"{");
		for(i = 0;i < 4;i++)
		{
			k = mul_list[mix[i][0] - 1][0] ^
				mul_list[mix[i][1] - 1][j] ^
				mul_list[mix[i][2] - 1][0] ^
				mul_list[mix[i][3] - 1][0];
			fprintf(p2,"0x%02x",k);
			if(i != 3)
				fprintf(p2,",");
		}
		fprintf(p2,"}");
		if(j != 0xff)
			fprintf(p2,",\n");
		else
			break;
	}
	for(j = 0;j < 256;j++)//list_3
	{
		fprintf(p3,"{");
		for(i = 0;i < 4;i++)
		{
			k = mul_list[mix[i][0] - 1][0] ^
				mul_list[mix[i][1] - 1][0] ^
				mul_list[mix[i][2] - 1][j] ^
				mul_list[mix[i][3] - 1][0];
			fprintf(p3,"0x%02x",k);
			if(i != 3)
				fprintf(p3,",");
		}
		fprintf(p3,"}");
		if(j != 0xff)
			fprintf(p3,",\n");
		else
			break;
	}
	for(j = 0;j < 256;j++)//list_4
	{
		fprintf(p4,"{");
		for(i = 0;i < 4;i++)
		{
			k = mul_list[mix[i][0] - 1][0] ^
				mul_list[mix[i][1] - 1][0] ^
				mul_list[mix[i][2] - 1][0] ^
				mul_list[mix[i][3] - 1][j];
			fprintf(p4,"0x%02x",k);
			if(i != 3)
				fprintf(p4,",");
		}
		fprintf(p4,"}");
		if(j != 0xff)
			fprintf(p4,",\n");
		else
			break;
	}
	fprintf(p1,"}");
	fprintf(p2,"}");
	fprintf(p3,"}");
	fprintf(p4,"}");
	fclose(p1);
	fclose(p2);
	fclose(p3);
	fclose(p4);
	return 0;
}

主要函数

最后，我们通过查表实现AES算法的加解密：

#include <stdio.h>
#include <stdlib.h>
#include "Lists.h"

word_8 RoundK[11][16];
word_32 Key[4] = {0x2b7e1516,0x28aed2a6,0xabf71588,0x09cf4f3c};

void Look(word_8 Str[])
{
	int i;
	for(i = 0;i < 16;i++)
		printf("%02x",Str[i]);
	printf("\n");
}

void Make_Key()
{
	word_32 k[44] = {0};
	int i,j;
	for(i = 0;i < 4;i++)
		k[i] = Key[i];
	for(;i < 4 * 11;i++)
	{
		if(i % 4 == 0)
			k[i] = k[i - 4] ^ (
			(S_box[(k[i - 1] >> 16) & 0x000000ff] << 24) ^
			(S_box[(k[i - 1] >> 8) & 0x000000ff] << 16) ^
			(S_box[(k[i - 1]) & 0x000000ff] << 8) ^
			(S_box[(k[i - 1] >> 24) & 0x000000ff])) ^ Rcon[(i / 4) - 1];
		else
			k[i] = k[i - 4] ^ k[i - 1];
	}
	for(i = 0;i < 11;i++)
		for(j = 0;j < 16;j++)
			RoundK[i][j] = k[i * 4 + j / 4] >> (((3 - (j % 4)) * 8) & 0x000000ff);
}

void Sub_Bytes(word_8 plain[],word_8 cipher[])
{
	int i = 0;
	for(i = 0;i < 16;i++)
		cipher[i] = S_box[plain[i]];
}

void De_Sub_Bytes(word_8 cipher[],word_8 plain[])
{
	int i = 0;
	for(i = 0;i < 16;i++)
		plain[i] = De_S_box[cipher[i]];
}

void Shift_Rows(word_8 plain[],word_8 cipher[])
{
	cipher[0] = plain[0];
	cipher[1] = plain[5];
	cipher[2] = plain[10];
	cipher[3] = plain[15];
	cipher[4] = plain[4];
	cipher[5] = plain[9];
	cipher[6] = plain[14];
	cipher[7] = plain[3];
	cipher[8] = plain[8];
	cipher[9] = plain[13];
	cipher[10] = plain[2];
	cipher[11] = plain[7];
	cipher[12] = plain[12];
	cipher[13] = plain[1];
	cipher[14] = plain[6];
	cipher[15] = plain[11];
}

void De_Shift_Rows(word_8 cipher[],word_8 plain[])
{
	plain[0] = cipher[0];
	plain[1] = cipher[13];
	plain[2] = cipher[10];
	plain[3] = cipher[7];
	plain[4] = cipher[4];
	plain[5] = cipher[1];
	plain[6] = cipher[14];
	plain[7] = cipher[11];
	plain[8] = cipher[8];
	plain[9] = cipher[5];
	plain[10] = cipher[2];
	plain[11] = cipher[15];
	plain[12] = cipher[12];
	plain[13] = cipher[9];
	plain[14] = cipher[6];
	plain[15] = cipher[3];
}

void Mix_Columns(word_8 plain[],word_8 cipher[])
{
	word_8 a[4];
	int i,j;
	for(i = 0;i < 4;i++)
	{
		for(j = 0;j < 4;j++)
			a[j] = T1[plain[i * 4]][j] ^
					T2[plain[i * 4 + 1]][j] ^
					T3[plain[i * 4 + 2]][j] ^
					T4[plain[i * 4 + 3]][j];
		for(j = 0;j < 4;j++)
			cipher[i * 4 + j] = a[j];
	}
}

void De_Mix_Columns(word_8 cipher[],word_8 plain[])
{
	word_8 a[4];
	int i,j;
	for(i = 0;i < 4;i++)
	{
		for(j = 0;j < 4;j++)
			a[j] = De_T1[cipher[i * 4]][j] ^
					De_T2[cipher[i * 4 + 1]][j] ^
					De_T3[cipher[i * 4 + 2]][j] ^
					De_T4[cipher[i * 4 + 3]][j];
		for(j = 0;j < 4;j++)
			plain[i * 4 + j] = a[j];
	}
}

void Add_Round_Key(word_8 plain[],word_8 cipher[],int k)
{
	int i;
	for(i = 0;i < 16;i++)
		cipher[i] = plain[i] ^ RoundK[k][i];
}

void Encrypt(word_8 plain[],word_8 cipher[])
{
	int i;
	Make_Key();
//	Look(plain);
	Add_Round_Key(plain,cipher,0);
//	Look(cipher);
	for(i = 1;i <= 9;i++)
	{
		Sub_Bytes(cipher,plain);
//		Look(plain);
		Shift_Rows(plain,cipher);
//		Look(cipher);
		Mix_Columns(cipher,plain);
//		Look(plain);
		Add_Round_Key(plain,cipher,i);
//		Look(cipher);
	}
	Sub_Bytes(cipher,plain);
//	Look(plain);
	Shift_Rows(plain,cipher);
//	Look(cipher);
	Add_Round_Key(cipher,plain,i);
//	Look(plain);
	for(i = 0;i < 16;i++)
		cipher[i] = plain[i];
}

void Decrypt(word_8 cipher[],word_8 plain[])
{
	int i;
	Make_Key();
//	Look(cipher);
	Add_Round_Key(cipher,plain,10);
//	Look(plain);
	for(i = 9;i >= 1;i--)
	{
		De_Shift_Rows(plain,cipher);
//		Look(cipher);
		De_Sub_Bytes(cipher,plain);
//		Look(plain);
		Add_Round_Key(plain,cipher,i);
//		Look(cipher);
		De_Mix_Columns(cipher,plain);
//		Look(plain);
	}
	De_Shift_Rows(plain,cipher);
//	Look(cipher);
	De_Sub_Bytes(cipher,plain);
//	Look(plain);
	Add_Round_Key(plain,cipher,i);
//	Look(cipher);
	for(i = 0;i < 16;i++)
		plain[i] = cipher[i];
}

其中 Lists.h 头文件中存放的是所有的表。
加解密分别调用Encrypt与Decrypt即可。

注：若觉得速度还是不够快，可以将所有的函数调用都去掉，所有循环全部写开，虽然这样不利于阅读，但算法的运行速度又会有一个显著的提升。

梓丶城
关注
  • 14
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
c软件查表获得电量代码_AES对称密码算法介绍(2)——查表法软件实现
weixin_39761573的博客
12-22 648
现在，AES在软件层面和硬件层面都已经有了很多种实现方式。本文将介绍由Rijndael的设计者提议的一种快速软件实现——查表法。(由于硬件实现的内容较复杂，本文不会涉及，如果有兴趣的可自行查找相关资料。)查表法的核心思想是将字节代换层、ShiftRows层和MixColumn层融合为查找表：每个表的大小是32 bits(4字节)乘以256项，一般称为T盒(T-Box)或T表。加密过程4个表(Te)...
查表法优化简单加解密
pmunix的专栏
10-14 1037
xx服务中需要对IP包进行简单的加解密，以前有段时间也是用过简单加解密，通过测试发现占用了大量的时间， 如果能够提高其执行效率，那么对提升xx服务性能将有很好的帮助 oprfile测试结果：CPU: CPU with RTC device, speed 2800.22 MHz (estimated)Counted RTC_INTERRUPTS events (RTC int
AES128-cbc快速查表法
04-26
AES128-cbc快速查表法，c语言，使用查表进行实现，采用空间换时间的方法，大大减少了加密所需要的时间。亲手写完。
生成AES S盒的实现和解析
最新发布
密码学小白
06-06 242
在高级加密标准（AES）中，S盒（Substitution box）是一个非线性替换函数，用于提高加密的复杂性和安全性。本文将通过一个C程序，详细介绍如何生成AES S盒，并对代码进行解析，以帮助读者理解其实现原理。
基于SSE2和查表法的AES的软件优化
qq_43094622的博客
08-17 1196
AES的软件优化 实验环境 编程语言：C语言 编辑器（含调试）：VsCode 操作系统：Windows 10 AES的查表法与SSE2优化 一、算法原理 1、查表法简述 常规的AES实现中，每轮要经历四种运算：字节代替、行移位、列混淆和轮密钥加。如果严格遵照AES算法实现，无疑每轮加密会具有较大的运算量，因此寻找一种能够合并多个运算过程的算法是十分必要的。查表法通过查表的方式，采取空间效率换取时间效率的方式，通过建立多个查找表实行查找操作合并字节代替、移位运算和有限域运算，优点是加速了每轮的
【算法】AES算法优化
行路中
02-05 2547
算法优化主要就是在矩阵相乘中，优化的方式也很简单，就是空间换时间。 AES算法的矩阵是有特点的，矩阵如下： 02  03  01  01 01  02  03  01 01  01  02  03 03  01  01  02 每一竖行都是02 01 01 03 组成。 分析矩阵相乘 02  03  01  01         a1      02*a1 + 03
AES用到的11张表格
幽灵剑客的专栏
05-23 3075
const unsigned char Log_02[256] = { 0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34,
深入浅出密码学——常用加密技术原理与应用_深入浅出密码学——常用加密技术原理与应用_
10-03
深入浅出密码学——常用加密技术原理与应用Cryptanalysis in simple terms -- principle and application of common encryption technology
华科密码学实验spn线性分析查表版
11-13
华科密码学实验spn线性分析，采用查表，C++实现，通过8000对明密文破解32位密钥，可以通过OJ平台测试。
密码学系列（五）：B站Dan Boneh的密码学——学习笔记（Introduction）【英文】
Juno07的博客
07-14 1349
Bilibili上的Dan Boneh密码学，自学笔记
Matlab——AES_256.zip
03-30
在本案例中，"Matlab——AES_256.zip" 是一个包含MATLAB 2012B版本下实现AES 256位加密标准的代码文件。AES_256是指使用256位的密钥进行加密，提供更高级别的安全保护。 AES的核心内容主要包括以下几个部分： 1. *...
基于向量表的AES快速实现算法
04-27
基于轮密钥向量表的AES是快速实现算法是通过向量表和固定S盒的方法实现AES算法
自主构造S盒的AES加解密算法
05-26
编程实现AES的加、解密以及S盒的构造。 生成子秘钥，加、解密，实现自主构造S盒子，电子密码本模式ECB和密码分组链接模式CBC并适用于所有文件加密。 适合北航信息安全方向的同学 绝对拿来就能用的！
AES加密算法中的S盒及其C语言实现
05-20
AES加密算法中的S盒及其C语言实现，介绍了AES算法和S盒
密码学学习笔记【1】——计算机与网络安全概念
qq_40720540的博客
09-20 2837
密码学学习笔记【1】——计算机与网络安全概念密码与算法协议计算机安全的概念CIA三元组真实性可追溯性OSI安全架构安全攻击被动攻击主动攻击安全服务认证访问控制数据保密性数据完整性不可否认性安全机制特定安全机制普遍的安全机制安全服务与机制间的联系 在进入了研究生生活之后，突然发现学校的导师的研究方向都是偏向密码学和网络安全的方向，作为密码学方面的小白，属实觉得密码学相关的书籍实在是太容易看完就忘了…所以以后每读一章就分享一篇读书笔记，在督促自己好好读书的同时，也希望能够帮助到其他刚刚入门密码学的人们。 密码与
数据加密练习 简易转换法和查表法
m0_61382108的博客
04-19 79
除了计算的方式之外，查表法也是早期人工加解密时常用的一种方式。它通过一张转换用的表格对每一个字母进行查表转换，只要传送方和接收方都使用同一张转换表格（即密码本），在传递情报之前先使用此表格把情报明文转换成情报密文（加密），而接收端在收到情报密文之后再以同一张表格进行反向转换即可（解密）。
AES涉及的有限域乘法及字节填充方法
03-05 2421
　 非常值得参考的是官方文档，它详细介绍了AES及其实验过程。博文AES加密算法的C++实现就是基于该文档的介绍及实现，是难得的一篇好文，故在本文最后会附上该文，以作备份。 　　还有很值得推荐的就是AES的动画演示，做的很形象，非常有助于理解！ 　 对AES而言，它采用了“代换-置换网络”结构（Substitution-Permutation Network, SPN）。其最复...
AES详解（二）
旺旺的碎冰冰~的博客
07-11 4068
AES的加解密
密码学 AES算法实现 c语言
凌阳的博客
06-18 3815
最后轮没有列混合初始变换： 明文4*4=16字节=128bit 密钥4*4=128bit 明文和初始密钥 异或字节代换S-Box行移位 列混合乘法 乘2时 左移1位且分为当首位为0时；当首位为1时 两种情况乘3时 将3拆为2+1乘4时 将4拆为2*2轮密钥加子密钥获得（密钥扩展）AES算法主要包括以下几个部分：s盒模型，密钥扩充，轮密钥加，字节代换，行移位，列混合。而本文主要讨论AES-128，进行10轮迭代，在第10轮时少一次列混合。（1）密钥扩充 AES首先将初始密钥输入到一个4*4的
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

梓丶城

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值