des.c

des数据加密算法原理与实现。

			}
	}
}

p32init()				/* 初始化32bit换位表的中间过渡矩阵*/
{	register int l, j, k;
	int i,m;

	for (i=0; i<4; i++)			/* 以字节为单位输入,i为字节在输入矩阵中的位置*/
		for (j=0; j<256; j++)	/* j为所输入字节的可能值[0~256]*/
		for (k=0; k<4; k++)
			p32[i][j][k]=0;	
	for (i=0; i<4; i++)
		for (j=0; j<256; j++)
		for (k=0; k<32; k++)
		{   l=p32i[k]-1;
			if ((l>>3)!=i)
			continue;
			if (!(j&bytebit[l&07]))
			continue;
			m = k & 07;
			p32[i][j][k>>3] |= bytebit[m];
		}
}

perminit(perm,p)				/* 初始化换位表*/
char perm[16][16][8];			/* 64-bit, 完成换位的中间的过渡矩阵*/
char p[64];
{	register int l, j, k;
	int i,m;

	for (i=0; i<16; i++)			/* 每一个输入的4 bit*/
		for (j=0; j<16; j++)		/* 每一个4 bit的可能值~[0,16]*/
		for (k=0; k<8; k++)			/* 每一个屏蔽字*/
			perm[i][j][k]=0;		/* 过渡矩阵清零*/
	for (i=0; i<16; i++)			/* 每一个输入的4 bit*/
		for (j = 0; j < 16; j++)	/* 每一个4 bit的可能值~[0,16]*/
		for (k = 0; k < 64; k++)	/* 每一个输出bit的位置*/
		{   l = p[k] - 1;			/* p[k]最小值为l,l从0开始*/
			if ((l >> 2) != i)		/* l~[0,63],每四位一组,共十六组,因此要l>>2*/
			continue;	
			if (!(j & nibblebit[l & 3]))	/*确定第l~[0,63]位是一个四位组中的第几位*/
			continue;
			m = k & 07;						/*确定第k~[0,63]位是一个字节中的第几位*/
			perm[i][j][k>>3] |= bytebit[m];
		}
}

iter(num,inblock,outblock)		/* 完成第num层的变换*/
int num;
char *inblock, *outblock;			/* 64 bits	*/
{	char fret[4];					/* 放置f(R[i-1],key)的返回值*/
	register char *ib, *ob, *fb;


	ob = outblock;
	ib = &inblock[4];			/*右边32位*/
	f(ib, num, fret);
	*ob++ = *ib++;				/* L[i] = R[i-1]		*/
	*ob++ = *ib++;
	*ob++ = *ib++;
	*ob++ = *ib++;
	ib = inblock; fb = fret;	/* R[i]=L[i] XOR f(R[i-1],key)  */
	*ob++ = *ib++ ^ *fb++;
	*ob++ = *ib++ ^ *fb++;
	*ob++ = *ib++ ^ *fb++;
	*ob++ = *ib++ ^ *fb++;
}

f(right,num,fret)			/* 完成num层的f()函数*/
char *right, *fret;			/* 32 bits */
int num;
{	register char *kb, *rb, *bb;
	char bigright[6];
	char result[6];	
	char preout[4];

	kb = kn[num];
	bb = bigright;
	rb = result;
	expand(right,bb);			/*扩展成48bit*/
	*rb++ = *bb++ ^ *kb++;
	*rb++ = *bb++ ^ *kb++;		/*Kn与Rn异或操作*/
	*rb++ = *bb++ ^ *kb++;
	*rb++ = *bb++ ^ *kb++;
	*rb++ = *bb++ ^ *kb++;
	*rb++ = *bb++ ^ *kb++;
	contract(result,preout);	/*用s盒得到32bit输出*/
	perm32(preout,fret);		/*最后换位*/
}

perm32(inblock,outblock)		/* 单纯换位*/
char *inblock,*outblock;		/* of the f crypto function	*/
{	register int j;

	register char *ib, *ob;
	register char *q;

	ob = outblock;				/* 把输出的块清零*/
	*ob++ = 0; *ob++ = 0; *ob++ = 0; *ob++ = 0;
	ib=inblock;	
	for (j=0; j<4; j++, ib++)	/* 输入的每一字节*/
	{	q = p32[j][*ib & 0377];
		ob = outblock;			/* 每一输出的字节*/
		*ob++ |= *q++;	
		*ob++ |= *q++;
		*ob++ |= *q++;
		*ob++ |= *q++;
	}
}

expand(right,bigright)			/* 用E变换矩阵完成32---48扩展换位*/
char *right,*bigright;			/* right 32 bit, bigright 48 bit	*/
{
	register char *bb, *r, r0, r1, r2, r3;

	bb = bigright;
	r = right; r0 = *r++; r1 = *r++; r2 = *r++; r3 = *r++;
	*bb++ = ((r3 & 0001) << 7) |		/* 32				*/
		((r0 & 0370) >> 1) |			/* 1 2 3 4 5		*/
		((r0 & 0030) >> 3);				/* 4 5				*/
	*bb++ = ((r0 & 0007) << 5) |		/* 6 7 8			*/
		((r1 & 0200) >> 3) |			/* 9				*/
		((r0 & 0001) << 3) |			/* 8				*/
		((r1 & 0340) >> 5);				/* 9 10 11			*/
	*bb++ = ((r1 & 0030) << 3) |		/* 12 13			*/
		((r1 & 0037) << 1) |			/* 12 13 14 15 16	*/
		((r2 & 0200) >> 7);				/* 17				*/
	*bb++ = ((r1 & 0001) << 7) |		/* 16				*/
		((r2 & 0370) >> 1) |			/* 17 18 19 20 21	*/
		((r2 & 0030) >> 3);				/* 20 21			*/
	*bb++ = ((r2 & 0007) << 5) |		/* 22 23 24			*/
		((r3 & 0200) >> 3) |			/* 25				*/
		((r2 & 0001) << 3) |			/* 24				*/
		((r3 & 0340) >> 5);				/* 25 26 27			*/
	*bb++ = ((r3 & 0030) << 3) |		/* 28 29			*/
		((r3 & 0037) << 1) |			/* 28 29 30 31 32	*/
		((r0 & 0200) >> 7);				/* 1				*/
}

contract(in48,out32)			/* 48位经s盒后,输出32位*/
char *in48,*out32;
{	register char *c;
	register char *i;
	register int i0, i1, i2, i3, i4, i5;

	i = in48;
	i0 = *i++; i1 = *i++; i2 = *i++; i3 = *i++; i4 = *i++; i5 = *i++;
	c = out32;
	*c++ = s[0][07777 & ((i0 << 4) | ((i1 >> 4) & 017  ))];
	*c++ = s[1][07777 & ((i1 << 8) | ( i2	& 0377 ))];
	*c++ = s[2][07777 & ((i3 << 4) | ((i4 >> 4) & 017  ))];
	*c++ = s[3][07777 & ((i4 << 8) | ( i5	& 0377 ))];
}

/************************ 以上是DES 的全部算法************************/

char *inname, *outname;
FILE *infile, *outfile;

int encrypting;
char buf[512];
char keyx[9],keyy[9];

char *malloc(), *strcpy(), *strcat();

main(argc, argv)
int argc; char *argv[];
{	register char *u;
	char *filename;

	if (argc < 2)						/* 命令行是否给出了文件名? */
	{  fprintf(stderr, "Usage: des file ...\n");
	   exit(1); 	
	}

	for (++argv; --argc; ++argv)
	{	inname = *argv;
		outname = filename = malloc((unsigned) strlen(inname) + 5);
		strcpy(filename, inname);
		u = &filename[strlen(filename) - 4];	/* 检查最后4个字符*/

		encrypting = (strcmp(".des", u) != 0);
		if (!encrypting) *u = 0;			 /* 解密时输出文件去掉.des*/
		else strcat(filename, ".des");		 /* 加密时给输出文件加上.des*/

		if ((infile = fopen(inname, "rb")) == NULL)
		{	fprintf(stderr,"Can't read %s.\n", inname);
			exit(1);
		}
		if ((outfile = fopen(outname, "rb")) != NULL)
		{	fprintf(stderr, "%s would be overwritten.\n",outname);
			exit(1);
		}
		if ((outfile = fopen(outname, "wb")) == NULL)
		{	fprintf(stderr,"Can't write %s.\n", outname);
			exit(1);
		}

		key_get("Type password for ");
		for (;;)
		{	strcpy(keyx, keyy);
			key_get("Verify password for ");
			if (strcmp(keyx, keyy) == 0) break;
		}
		desinit(keyx);					 /*建立用于des运算的矩阵*/

		if (pfile() == 0) unlink(inname);
		else	fprintf(stderr,
			   "%s: I/O Error -- File unchanged\n", inname);

		fclose(outfile);
		fclose(infile);
	}
	exit(0);
}

key_get(mes)				/*输入密码*/
char *mes;
{	register int i, j;
	char linebuf[256];
	int count;

				//	for (i=0; i<14; i++) keyy[i]=0;

	printf("%s%s: ", mes, inname);
	fflush(stdout);		/*使用read(),fread()前先刷新文件*/

	count = read(0, linebuf, 256);  /* 输入密码*/
	printf("\n");


	linebuf[count] = 0;  /* 添加一个0作为字符串的结束*/
	if (linebuf[count-1] == '\n')
	{  linebuf[count-1] = 0;	/*把"\n"变成0*/
	   count--;
	}
	if (count > 8) count = 8;	/* 只取 8 字节 */
	for (i = j = 0; count--;)
	   keyy[i++] = linebuf[j++];
}

pfile()				 /* 文件加密处理*/
{	register int m, nsave;
	register char *b;
	int j;

	while (m = fread(buf, 1, 512, infile))
	{
		if ((nsave = m) < 0)	/* 读出错*/
		return(-1);
		for (b=buf; m>0;m -= 8, b += 8)		/* 加密解密一个缓冲区的块*/
		{   if (encrypting)
		{   if (m<8)						/* 不够一块---64 bits	*/
			{   for (j=0; j<8-m; j++)
				b[m+j]=garbage();			 /* 填充不够一块的部分*/
			nsave += 8-m;					/* 把nave凑成8的整数倍*/
			}
			else j=0;						/* 不足8字节时的缺额数量j=8-m*/
			endes(b,b);	
		}
		else								/* 解密*/
		{   if (m < 8) deout(b, 1);			/* 最后的几个字节*/
			else
			{   dedes(b, b);				/* 解密一个块*/
			deout(b, 0);					/*输出到文件*/
			}
		}
		}
		if (encrypting) if (fwrite(buf, 1, nsave, outfile) != nsave)
			return(-1);
	}
											/* 加密解密文件完成*/
	if (encrypting) fputc(8 - j, outfile);  /* 8-j=最后一个块的有效字节数*/
	return(0);
}

int outcount = 0;

deout(block,flag)			/* 根据flag标志来决定输出到文件的内容*/
char *block,flag;			/* char*block 64-bit 块, flag=1:处理的块是文件的最后的块
													  flag=0:处理的块不是文件的最后的块*/
{	static char last[8];		/*static char last[8] 前一个输入块,静态变量,初始化为零*/
	register int i;

	if (flag)			/* 输出的最后的几个字节*/
	{
		fwrite(last, 1, block[0] & 0377, outfile); /*block[0]包含内容"8-j*/
		return;
	}
	if (outcount++)			/* 以前是否处理过块,即输入的加密文件长度不到8字节*/
		fwrite(last, 1, 8, outfile);
	for (i = 0; i < 8; i++) last[i] = block[i]; /* 复制块*/
}

garbage()				/* 产生一些数字用以填充不足8字节的块*/
/*产生数据随机性大一些,加密效果会更好*/
{
	return 0;
}

/*********************程序结束**************************/