📄 des.cpp

📁 DES和MAC加解密算法
💻 CPP
📖 第 1 页 / 共 2 页
字号:
上一页 12
	0x40080100L, 0x00000100L, 0x02000000L, 0x42080000L,
	0x42080100L, 0x00080100L, 0x42000000L, 0x42080100L,
	0x02080000L, 0x00000000L, 0x40080000L, 0x42000000L,
	0x00080100L, 0x02000100L, 0x40000100L, 0x00080000L,
	0x00000000L, 0x40080000L, 0x02080100L, 0x40000100L };

static unsigned long SP6[64] = {
	0x20000010L, 0x20400000L, 0x00004000L, 0x20404010L,
	0x20400000L, 0x00000010L, 0x20404010L, 0x00400000L,
	0x20004000L, 0x00404010L, 0x00400000L, 0x20000010L,
	0x00400010L, 0x20004000L, 0x20000000L, 0x00004010L,
	0x00000000L, 0x00400010L, 0x20004010L, 0x00004000L,
	0x00404000L, 0x20004010L, 0x00000010L, 0x20400010L,
	0x20400010L, 0x00000000L, 0x00404010L, 0x20404000L,
	0x00004010L, 0x00404000L, 0x20404000L, 0x20000000L,
	0x20004000L, 0x00000010L, 0x20400010L, 0x00404000L,
	0x20404010L, 0x00400000L, 0x00004010L, 0x20000010L,
	0x00400000L, 0x20004000L, 0x20000000L, 0x00004010L,
	0x20000010L, 0x20404010L, 0x00404000L, 0x20400000L,
	0x00404010L, 0x20404000L, 0x00000000L, 0x20400010L,
	0x00000010L, 0x00004000L, 0x20400000L, 0x00404010L,
	0x00004000L, 0x00400010L, 0x20004010L, 0x00000000L,
	0x20404000L, 0x20000000L, 0x00400010L, 0x20004010L };

static unsigned long SP7[64] = {
	0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L,
	0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L,
	0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L,
	0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L,
	0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L,
	0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L,
	0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L,
	0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L,
	0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L,
	0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L,
	0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L,
	0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L,
	0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L,
	0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L,
	0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L,
	0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L };

static unsigned long SP8[64] = {
	0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L,
	0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L,
	0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L,
	0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L,
	0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L,
	0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L,
	0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L,
	0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L,
	0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L,
	0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L,
	0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L,
	0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L,
	0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L,
	0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L,
	0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L,
	0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L };

static void desfunc(register unsigned long *block,register unsigned long *keys)
{
	register unsigned long fval, work, right, leftt;
	register int round;

	leftt = block[0];
	right = block[1];
	work = ((leftt >> 4) ^ right) & 0x0f0f0f0fL;
	right ^= work;
	leftt ^= (work << 4);
	work = ((leftt >> 16) ^ right) & 0x0000ffffL;
	right ^= work;
	leftt ^= (work << 16);
	work = ((right >> 2) ^ leftt) & 0x33333333L;
	leftt ^= work;
	right ^= (work << 2);
	work = ((right >> 8) ^ leftt) & 0x00ff00ffL;
	leftt ^= work;
	right ^= (work << 8);
	right = ((right << 1) | ((right >> 31) & 1L)) & 0xffffffffL;
	work = (leftt ^ right) & 0xaaaaaaaaL;
	leftt ^= work;
	right ^= work;
	leftt = ((leftt << 1) | ((leftt >> 31) & 1L)) & 0xffffffffL;

	for( round = 0; round < 8; round++ ) {
		work  = (right << 28) | (right >> 4);
		work ^= *keys++;
		fval  = SP7[ work		 & 0x3fL];
		fval |= SP5[(work >>  8) & 0x3fL];
		fval |= SP3[(work >> 16) & 0x3fL];
		fval |= SP1[(work >> 24) & 0x3fL];
		work  = right ^ *keys++;
		fval |= SP8[ work		 & 0x3fL];
		fval |= SP6[(work >>  8) & 0x3fL];
		fval |= SP4[(work >> 16) & 0x3fL];
		fval |= SP2[(work >> 24) & 0x3fL];
		leftt ^= fval;
		work  = (leftt << 28) | (leftt >> 4);
		work ^= *keys++;
		fval  = SP7[ work		 & 0x3fL];
		fval |= SP5[(work >>  8) & 0x3fL];
		fval |= SP3[(work >> 16) & 0x3fL];
		fval |= SP1[(work >> 24) & 0x3fL];
		work  = leftt ^ *keys++;
		fval |= SP8[ work		 & 0x3fL];
		fval |= SP6[(work >>  8) & 0x3fL];
		fval |= SP4[(work >> 16) & 0x3fL];
		fval |= SP2[(work >> 24) & 0x3fL];
		right ^= fval;
		}

	right = (right << 31) | (right >> 1);
	work = (leftt ^ right) & 0xaaaaaaaaL;
	leftt ^= work;
	right ^= work;
	leftt = (leftt << 31) | (leftt >> 1);
	work = ((leftt >> 8) ^ right) & 0x00ff00ffL;
	right ^= work;
	leftt ^= (work << 8);
	work = ((leftt >> 2) ^ right) & 0x33333333L;
	right ^= work;
	leftt ^= (work << 2);
	work = ((right >> 16) ^ leftt) & 0x0000ffffL;
	leftt ^= work;
	right ^= (work << 16);
	work = ((right >> 4) ^ leftt) & 0x0f0f0f0fL;
	leftt ^= work;
	right ^= (work << 4);
	*block++ = right;
	*block = leftt;
	return;
	}

void des8(unsigned char *InData,unsigned char *key,unsigned char *OutData,short Mode,int readlen)
//参数:
//1.InData存放待加/解密的内存指针(长度为readlen,可能经过填充);
//2.Key存放用户输入的密钥内存的指针
//3.OutData存放输出结果
//4.Mode加/解密选择（加/解密=EN0/DE1=0/1）
//5.readlen待加/解密的长度(8字节的倍数，如：8字节数据readlen=1、16字节数据readlen=2等等)
//功能: 
//根据Mode生成16个48位的加/解密子密钥,
//把待加/解密的数据分割成64位的块,逐块完成16次迭代加/解密,
//结果存放在OutData所指向的内存中.
//说明：
//八字节输入、八字节密钥、八字节输出
{
	int i=0;
	unsigned long work[2];
	unsigned char *cpi,*cpo;

	cpi=InData;
	cpo=OutData;

	deskey(key,Mode);//由八字节key，根据Mode(加/解密=EN0/DE1=0/1)所指方式，生成16个48位的加/解密子密钥，子密钥存入KnL中。

	for(i=0;i<readlen;i++)
	{
		//cpi[0]->work[0]第三字节、cpi[1]->work[0]第二字节、cpi[2]->work[0]第一字节、cpi[3]->work[0]第零字节。
		//cpi[4]->work[1]第三字节、cpi[5]->work[1]第二字节、cpi[6]->work[1]第一字节、cpi[7]->work[1]第零字节。
		scrunch(cpi,work);

		//用KnL中的16个48位的加/解密子密钥，完成16次迭代加/解密
		desfunc(work,KnL);

		//work[0]第三字节->cpo[0]、work[0]第二字节->cpo[1]、work[0]第一字节->cpo[2]、work[0]第零字节->cpo[3]。
		//work[1]第三字节->cpo[4]、work[1]第二字节->cpo[5]、work[1]第一字节->cpo[6]、work[1]第零字节->cpo[7]。
		unscrun(work,cpo);

		//指向下一组数据
		cpi+=8; cpo+=8;
	}
}

void des16(unsigned char *InData,unsigned char *key,unsigned char *OutData,short Mode,int readlen)
//参数:
//1.InData存放待加/解密的内存指针(长度为readlen,可能经过填充);
//2.Key存放用户输入的密钥内存的指针
//3.OutData存放输出结果
//4.Mode加/解密选择（加/解密=EN0/DE1=0/1）
//5.readlen待加/解密的长度(8字节的倍数，如：8字节数据readlen=1、16字节数据readlen=2等等)
//功能: 
//根据Mode生成三组各16个48位的加/解密子密钥,
//把待加/解密的数据分割成64位的块,逐块由key左右各半部分进行三遍16次迭代加/解密,
//结果存放在OutData所指向的内存中.
//说明：
//八字节输入、十六字节密钥、八字节输出
{
	short revmod;
	int i=0;
	unsigned long work[2];
	unsigned char *cpi,*cpo;

	cpi=InData;
	cpo=OutData;

	revmod = (Mode == EN0) ? DE1 : EN0;
	deskey(&key[8], revmod);//由十六字节key的右半部分，根据Mode(加/解密=EN0/DE1=0/1)所指方式，生成16个48位的加/解密子密钥，子密钥存入KnL中。
	cpkey(KnR);//将KnL复制到KnR中
	deskey(key, Mode);//由十六字节key的左半部分，根据Mode(加/解密=EN0/DE1=0/1)所指方式，生成16个48位的加/解密子密钥，子密钥存入KnL中。
	cpkey(Kn3);//将KnL复制到Kn3中
	//此时KnL由key左半部分生成
	//    KnR由key右半部分生成
	//    Kn3由key左半部分生成，KnL==Kn3。

	for(i=0;i<readlen;i++)
	{
		//cpi[0]->work[0]第三字节、cpi[1]->work[0]第二字节、cpi[2]->work[0]第一字节、cpi[3]->work[0]第零字节。
		//cpi[4]->work[1]第三字节、cpi[5]->work[1]第二字节、cpi[6]->work[1]第一字节、cpi[7]->work[1]第零字节。
		scrunch(cpi, work);

		//用KnL中的16个48位的加/解密子密钥，完成16次迭代加/解密
		desfunc(work, KnL);

		//用KnR中的16个48位的加/解密子密钥，完成16次迭代加/解密
		desfunc(work, KnR);

		//用Kn3中的16个48位的加/解密子密钥，完成16次迭代加/解密
		desfunc(work, Kn3);

		//work[0]第三字节->cpo[0]、work[0]第二字节->cpo[1]、work[0]第一字节->cpo[2]、work[0]第零字节->cpo[3]。
		//work[1]第三字节->cpo[4]、work[1]第二字节->cpo[5]、work[1]第一字节->cpo[6]、work[1]第零字节->cpo[7]。
		unscrun(work, cpo);

		cpi+=8; cpo+=8;//指向下一组数据
	}
}
上一页 12
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -