对称密码的集中式密钥分配协议(C语言)

YSRM

已于 2024-06-12 13:06:44 修改

阅读量1.2k

点赞数 9

分类专栏：密码学文章标签：服务器运维 c语言

于 2022-12-09 12:54:56 首次发布

本文链接：https://blog.csdn.net/weixin_58628068/article/details/128245121

版权

密码学专栏收录该内容

6 篇文章 4 订阅

订阅专栏

实验内容

编程实现基于DES的集中式密钥分配协议的仿真过程，实验中包含至少10个用户，并可在任意两个用户间进行保密通信。会话内容以.txt文件格式传输。输出每一步所传递的信息和解密后的信息，并比较正式会话过程中解密后的明文信息同原来的会话文件是否一致。

实验原理

对称密码的集中式密钥分配协议

集中式密钥分配是由密钥分配中心KDC或由一组节点组成层次结构负责密钥的产生和分配给通信双方的任务。这样的分配方式可减少用户需要保存的会话密钥数量，用户仅需保存同KDC通信的加密密钥即可。

step1

A向KDC发送会话密钥请求。请求的消息包含A和B的身份信息及一个用于唯一标识本次业务的随机数N1。N1由会话密钥请求发起人每次请求时随机生成，常用一个时间戳、一个计数器或一个随机数作为这个标识符。并且为防止攻击者对N1的猜测，用随机数作为这个标识符最合适。

1. A->KDC: ID（A) || ID(B) || N1

step2

KDC对A的请求发出应答。应答包含密钥KA加密的信息，因此只有A才能成功对这一信息进行解密，并且A可以相信信息的确是由KDC发出的。信息中包括A希望得到的一次性会话密钥KS和step1中A发送的请求中的随机数N1。这样A可以验证应答与请求是否匹配，并验证自己发出的请求在被KDC收到之前是否被他人篡改。此外，A还可以根据一次性随机数相信自己收到的应答是否为重放的过去的应答。

除去A需要的必要信息，还包括B希望得到的两项内容。A的身份和一次性会话密钥KS，这两项用KB加密，并由A转发给B，以建立A和B之间的连接并用于向B证明A的身份。

2. KDC->A: E(Ka)[Ks || ID(A) || ID(B) || N1 || E(Kb)[Ks || ID(A)]]

step3

A存储会话密钥后，向B转发其所需的两项内容。因为转发的内容是由KB加密后的密文，所以转发的过程中不会被窃听。B收到后，可以获得会话密钥KS和A的身份确认，并且还可以从Ekb得知KS的确来自KDC。

3.A->B: E(Kb)[Ks || ID(A)]

step4

B用KS加密另一个一次性随机数N2后，并将其发送给A

4.B->A: E(Ks)[N2]

step5

A以f(N2) 作为对B的应答，其中f是对N2进行某种变换的函数，并将应答用会话密钥加密后发送给B

5.A->B: E(Ks)[f(N2)]

对称密码技术的密钥分配方案可参考这篇博客

对称密码技术的密钥分配_real_metrix的博客-CSDN博客

DES算法

DES算法，包括代码实现都在下面这篇博客

DES的加密与解密(C语言实现)——大三密码学实验_西瓜妹妹的唯一男朋友的博客-CSDN博客

ECB(电码本模式)

考虑到最后要以txt形式进行明文传输，可以用ECB

ECB与DES的结合，包括代码实现可以参考下面这篇博客

DES的加密解密在ECB上的使用(C语言实现)——大三密码学实验_西瓜妹妹的唯一男朋友的博客-CSDN博客

代码实现

用户结构体的声明

struct USER {
	char name;
	string key;
	string ID;
};
struct USER user[10] = {'A',"1234567a","11111111",'B',"1234567b","22222222",'C',"1234567c","33333333",'D',"1234567d","44444444",'E',"1234567e","55555555",'F',"1234567f","66666666",'G',"1234567g","77777777",'H',"1234567h","88888888",'I',"1234567i","99999999",'J',"1234567j","00000000"};

name即它的名字，一个字符

key为对应的字符串密钥

ID为身份信息

初始化10个用户，比如第一个用户为A，密钥为"1234567a",身份信息为"11111111"；

全局变量的声明

int key_3[17][48];//储存密钥的中间变量
int	zhihuan2[48] = { 14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10, 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2, 41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48, 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32 };  //置换2
int	e[48] = { 32, 1, 2, 3, 4, 5,4, 5, 6, 7, 8, 9,8, 9, 10, 11, 12, 13,12, 13, 14, 15, 16, 17,16, 17, 18, 19, 20, 21,20, 21, 22, 23, 24, 25,24, 25, 26, 27, 28, 29,28, 29, 30, 31, 32, 1 };    //E盒 
int	p[32] = { 16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10, 2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25 };     //P盒 
int zhihuan1[56] = { 57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36, 63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4 };      //置换1 
int IP[64] = { 58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, 62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8, 57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3, 61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7 };    //IP置换 
int IP_1[64] = { 40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31, 38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29, 36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27, 34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25 };    //IP_1置换
unsigned char IDa[8], IDb[8], N1[8],N2[8],temp1[16],temp2[8],temp3[8];//用户1和2的ID，N1识别业务,temp1第二步得到的kb加密的密文,temp2，temp3中间变量
unsigned char ka[8], kb[8];//用户1和2的密钥
unsigned char ks[8];//随机生成ks
unsigned char step_2[48];//第二步最后的加密
unsigned char step_4[8];//第四步要转发的密文
unsigned char step_5[8];//第五步最后的加密
int key_l[17][28];//16轮左密钥 
int key_r[17][28];//16轮右密钥
int key_2[17][56];//16轮总密钥
int users2[2];//用户的索引值
int index;//第四步得出的user1的索引值

各个变量的含义已经在注释中给出

find_number函数的构建

int find_number(char name) {
	int n=0;
	for (int i = 0; i < 10; i++) {
		if (user[i].name == name) {
			n = i;
			break;
		}
	}
	return n;
}

通过输入的用户名得到其对应的用户结构体数组中的索引值

finde_index函数的构建

int find_index(unsigned char temp[8]) {
	int flag = 0;
	for (int i = 0; i < 10; i++) {
		flag = 0;
		for (int j = 0; j < 8; j++) {
			if (user[i].ID[j] == temp[j]) {
				flag++;
			}
			else {
				break;
			}
		}
		if (flag == 8) {
			return i;
			break;
		}
	}
}

通过输入的用户身份信息来寻找其在用户结构体数组对应的索引值

DES和RE_DES函数的构建

关于DES算法所需要的函数都在下面这篇博客

DES的加密解密在ECB上的使用(C语言实现)——大三密码学实验_西瓜妹妹的唯一男朋友的博客-CSDN博客

ECB和RE_ECB函数的实现

与上面博客相比，对其做了一些改变

ECB函数的构建

int ECB(unsigned char b[8],char user1,char user2) {
	FILE* input = fopen("C:\\Users\\Administrator\\Desktop\\测试文件\\CKD_input.txt", "r");
	FILE* output = fopen("C:\\Users\\Administrator\\Desktop\\测试文件\\CKD_output.txt", "a");
	int size, size1;
	unsigned char a[8], plus3[8];
	fseek(input, 0, SEEK_END);
	size = ftell(input);
	fseek(input, 0, SEEK_SET);
	char c;
	cout << user1<< "发送的明文为" << endl;
	for (int i = 0; i < size; i++) {
		fread(&c, 1, 1, input);
		cout << c;
	}
	cout << endl;
	fseek(input, 0, SEEK_SET);
	for (int i = 0; i < size / 8; i++) {
		fread(a, 8, 1, input);
		DES(a, b, plus3);
		fwrite(plus3, 8, 1, output);
	}
	size1 = size % 8;
	fread(a, size1, 1, input);
	for (int i = size1; i < 8; i++) {
		a[size1] = '0';
	}
	DES(a, b, plus3);
	fwrite(plus3, 8, 1, output);
	fclose(input);
	fclose(output);
	return size;
}

主要添加了把明文文件的每个字节输出的功能

RE_ECB函数的构建

void RE_ECB(unsigned char b[8], int size,char user1,char user2) {
	FILE* input1 = fopen("C:\\Users\\Administrator\\Desktop\\测试文件\\CKD_output.txt", "r");
	FILE* output1 = fopen("C:\\Users\\Administrator\\Desktop\\测试文件\\CKD_reinput.txt", "a");
	unsigned char min_plus[8];
	int size1;
	unsigned char a[8];
	fseek(input1, 0, SEEK_END);
	size1 = ftell(input1);
	fseek(input1, 0, SEEK_SET);
	for (int i = 0; i < size / 8; i++) {
		fread(a, 8, 1, input1);
		RE_DES(a, b, min_plus);
		fwrite(min_plus, 8, 1, output1);
	}
	size1 = 8 - (size1 - size);
	fread(a, 8, 1, input1);
	RE_DES(a, b, min_plus);
	fwrite(min_plus, size1, 1, output1);
	fclose(input1);
	fclose(output1);
}

添加了将解密后得到的明文每个字节输出的功能

对称密码的集中式密钥分配协议的核心部分

step1函数的构建

void step1(char user1, char user2) {
	int temp;
	for (int i = 0; i < 8; i++) {//随机生成N1
		temp = 48 + rand() % 10;
		N1[i] = char(temp);
	}
	cout << "--------------------(1)" << user1 << "向KDC发出会话密钥请求：请求的消息由" << user1 << "和" << user2 << "的身份，惟一识别符N1。明文传输--------------------" << endl;
	cout << "生成随机标识符N1:";
	for (int i = 0; i < 8; i++) {
		cout << N1[i];
	}
	cout << endl;
	int n1, n2;//分别是通讯方和被通讯方的索引值
	n1 = find_number( user1);
	n2 = find_number( user2);
	users2[0] = n1;
	users2[1] = n2;
	cout << user[n1].ID << "|" << user[n2].ID << "|";
	for (int i = 0; i < 8; i++) {
		IDa[i] = user[n1].ID[i];
		IDb[i] = user[n2].ID[i];
	}
	for (int i = 0; i < 8; i++) {
		cout << N1[i];
	}
	cout << endl;
}

即实现分配协议的第一步

通过rand函数生成48-57之间的任意整数，通过char转类型，范围为'0'-'9'，这样方便带入DES算法进行加密(DES算法的参数为字符型数组)

然后将生成的标识符输出

再找到两个用户对应的索引值，进而找到他们的身份信息并将其输出

最后再把生成的标识符输出

表明两个用户的身份信息以及N1已经发送给KDC；

step2函数的构建

void step2(char user1, char user2) {
	cout << "--------------------(2)" << "KDC为" << user1 << "的请求发出应答 E(Ka)[Ks || ID(A) || ID(B) || N1 || E(Kb)[Ks || ID(A)]]--------------------" << endl;
	for (int i = 0; i < 8; i++) {//找密钥
		ka[i] = user[users2[0]].key[i];
		kb[i] = user[users2[1]].key[i];
	}
	int temp;
	for (int i = 0; i < 8; i++) {
		temp = 48 + rand() % 10;
		ks[i] = char(temp);
	}
	//E(kb)[ks||ID(A)]
	unsigned char temp2[8];
	DES(ks, kb, temp2);
	for (int i = 0; i < 8; i++) {
		temp1[i] = temp2[i];
	}
	DES(IDa, kb, temp2);
	for (int i = 0; i < 8; i++) {
		temp1[i+8] = temp2[i];
	}
	cout << "kb加密的部分为:" ;
	for (int i = 0; i < 16; i++) {
		cout << temp1[i];
	}
	cout << endl;
	//E(ka)[ks||IDa||IDb||N1]
	
	DES(ks, ka, temp2);
	for (int i = 0; i < 8; i++) {
		step_2[i] = temp2[i];
	}
	DES(IDa, ka, temp2);
	for (int i = 8; i < 16; i++) {
		step_2[i] = temp2[i-8];
	}
	DES(IDb, ka, temp2);
	for (int i = 16; i < 24; i++) {
		step_2[i] = temp2[i-16];
	}
	DES(N1, ka, temp2);
	for (int i = 24; i < 32; i++) {
		step_2[i] = temp2[i-24];
	}
	//把temp1分解成两个8字节加密
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 8; j++) {
			temp3[j] = temp1[i * 8 + j];
		}
		DES(temp3, ka, temp2);
		for (int j = 0; j < 8; j++) {
			step_2[32 + i * 8 + j] = temp2[j];
		}
	}
	cout << "KDC已经找到" << user1 << "的密钥:";
	for (int i = 0; i < 8; i++) {
		cout << ka[i];
	}
	cout << "," << user2 << "的密钥:";
	for (int i = 0; i < 8; i++) {
		cout << kb[i];
	}
	cout << endl;
}

先找到两个用户的密钥并将其存储下来

然后以类似于生成N1的方式生成一次性会话密钥KS

temp2为中间变量数组

接下来用DES算法对一次性会话密钥KS和用户1的身份信息加密，密钥为用户2的密钥

结果储存在数组temp1里

再通过DES算法依次对一次性会话密钥、用户1的身份信息、用户2的身份信息以及temp1进行加密，密钥为用户1的密钥，其中前几个变量都是8字节数组，而temp1为16进制数组，则temp1分两次处理，最后加密结果都放在step_2数组中

最后把用户1和用户2的密钥输出

step3函数的构建

void step3(char user1, char user2) {
	cout << "--------------------(3)";
	cout << user1 << "存储会话密钥，并向";
	cout << user2 << "转发EKB[KS||IDA]--------------------" << endl;
	cout << user1 << "向" << user2 << "转发: ";
	for (int i = 0; i < 16; i++) {
		cout << temp1[i];
	}
	cout << endl;
}

即将上一步用户2的密钥加密的部分输出

step4函数的构建

void step4(char user1, char user2) {
	cout << "--------------------(4)" << user2 << "用ks加密随机数N2，并将加密结果转发给" << user1<<"--------------------" << endl;
	for (int i = 0; i < 8; i++) {
		temp3[i] = temp1[i];
	}
	RE_DES(temp3, kb, temp2);//解密得出ks
	cout << user2;
	cout << "得到了会话密钥:";
	for (int i = 0; i < 8; i++) {
		cout << temp2[i];
	}
	for (int i = 0; i < 8; i++) {
		temp3[i] = temp1[i + 8];
	}
	RE_DES(temp3, kb, temp2);//解密得出发送者的ID
	index = find_index(temp2);
	cout << "得到" << user[index].name << "的身份信息ID: ";
	for (int i = 0; i < 8; i++) {
		cout << temp2[i];
	}
	cout << endl;
	int temp;
	for (int i = 0; i < 8; i++) {//生成随机数N2
		temp = 48 + rand() % 10;
		N2[i] = char(temp);
	}
	DES(N2, ks, temp2);//用ks加密N2
	cout << user2<<"向"<< user[index].name <<"转发: ";
	for (int i = 0; i < 8; i++) {
		cout << temp2[i];
	}
	cout << endl;
}

将上一步用户1发送给用户2的密文进行解密

密文加密的密钥是用户2的密钥，那么解密就要用用户2的密钥

解密出的结果就是KS和用户1的身份信息

先对KS进行解密，将其输出，再将用户1的身份信息进行解密，通过find_index函数确定通讯方确实是用户1

再生成随机标识符N2，用KS加密，储存在temp2中，并输出

step5函数的构建

void step5(char user1, char user2) {
	cout << "--------------------(5)" << user1 << "以f(N2)作为对" << user2 << "的应答，其中f是对N2进行某种变换的函数,并加密后发送给" << user2 << "--------------------" << endl;
	//user1对上一步user2发送的进行解密
	RE_DES(temp2, ks, temp3);
	cout << user1<<"解密得到的随机数为: ";
	for (int i = 0; i < 8; i++) {
		cout << temp3[i];
	}
	cout << endl;
	//对N2进行f变换，例如加1
	temp3[7] = char(int(temp3[7])+1);
	DES(temp3, ks, step_5);//对f(N2)进行加密
	cout << user1 << "要转发给" << user2 << "的是:";
	for (int i = 0; i < 8; i++) {
		cout << step_5[i];
	}
	cout << endl;
	//user2对user1的解密
	RE_DES(step_5, ks, temp3);
	temp3[7]= char(int(temp3[7]) -1);
	//验证
	int flag = 0; 
	for (int i = 0; i < 8; i++) {
		if (temp3[i] != N2[i]) {
			flag = 1;
			break;
		}
	}
	if (flag == 1) {
		cout << "验证失败";
	}
	else {
		cout << "验证成功";
		cout << endl;
		int size;
		size = ECB(ks,user1,user2);
		RE_ECB(ks, size,user1,user2);
		char c;
		FILE* output2 = fopen("C:\\Users\\Administrator\\Desktop\\测试文件\\CKD_reinput.txt", "r");
		cout << user2 << "解密得到的明文为:" << endl;
		for (int i = 0; i < size; i++) {
			fread(&c, 1, 1, output2);
			cout << c;
		}
		cout << endl;
		fclose(output2);
		FILE* min = fopen("C:\\Users\\Administrator\\Desktop\\测试文件\\CKD_reinput.txt", "r ");
		FILE* min1 = fopen("C:\\Users\\Administrator\\Desktop\\测试文件\\CKD_input.txt", "r");
		char p, q;
		flag = 0;
		for (int i = 0; i < size; i++) {
			fread(&p, 1, 1, min);
			fread(&q, 1, 1, min1);
			if (p != q) {
				flag = 1;
				break;
			}
		}
		fclose(min);
		fclose(min1);
		if (flag == 0) {
			cout << "解密成功";
		}
		else {
			cout << "解密失败";
		}
	}
}

将用户2发送给用户1的消息进行解密

再对N2做f改变，f自选，在这里的作用是把N2的最后一个字符加1

然后用KS加密加密改变后的N2，再发送给用户2

用户2进行解密，再用f函数的逆得到N2，与原来的N2做比较，如果是一样的，则验证成功，可以通过ECB来进行信息的发送，否则验证失败，不能进行信息发送