chaos_des.cpp

这个是基于混沌的DES算法

	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 *block, *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;
	}



/* Validation sets:
 * Single-length key, single-length plaintext -
 * Key	  : 0123 4567 89ab cdef
 * Plain  : 0123 4567 89ab cde7
 * Cipher : c957 4425 6a5e d31d
 **********************************************************************/
void des_key(des_ctx *dc, unsigned char *key){
	    deskey(key,EN0);
		cpkey(dc->ek);
		deskey(key,DE1);
		cpkey(dc->dk);
}


void des_enc(des_ctx *dc, unsigned char *data, int blocks,unsigned char *key,double *x){
	    unsigned long work[2];
		int i;
		unsigned char *cp;

		cp=data;
		for(i=0;i<blocks;i++){
			    chaos_key(key,x);
			    deskey(key,EN0);
		        cpkey(dc->ek);			    
			    scrunch(cp,work);
				desfunc(work,dc->ek);
				unscrun(work,cp);
				cp+=8;
                              
				 
			


			
		}
}

void des_dec(des_ctx *dc, unsigned char *data, int blocks,unsigned char *key,double *x){
	    unsigned long work[2];
		int i;
		unsigned char *cp;

		cp=data;
		for(i=0;i<blocks;i++){
			    chaos_key(key,x);
			    deskey(key,DE1);
		        cpkey(dc->dk);
			    scrunch(cp,work);
				desfunc(work,dc->dk);
				unscrun(work,cp);
				cp+=8;
                
		}
}

//每迭代59次，取一个double型混沌数，转换成整型
//并对其进行位操作，取出其内存的32位比特
//等下一个混沌点再取32位，合成64位密钥
void chaos_key(unsigned char *key,double *x){
	    double a[100];
	    int i;
		double u=3.8;
		unsigned char *keyy;
		unsigned char * bb;
        keyy=key;		
		a[0]=*x;

		for(i=0;i<59;i++){
			    a[i+1]=u*a[i]*(1-a[i]);							
		}        
        *x=a[59];
		int nnn= int (a[59]*1000000000);
		bb= (unsigned char *)&nnn;
		for(i=0;i<4;i++){
            *keyy =*bb;
			bb++;
			keyy++;
		}

		a[0]=*x;
		for(i=0;i<59;i++){
			    a[i+1]=u*a[i]*(1-a[i]);							
		}        
        *x=a[59];
		nnn= int (a[59]*1000000000);
		bb= (unsigned char *)&nnn;
        for(i=0;i<4;i++){
            *keyy =*bb;
			bb++;
			keyy++;
		}

        keyy=key;
}
		


void main(void){
	    des_ctx dc;
		int i,j;
		j=0;
		unsigned char c[1000],cc;
		printf("基于混沌技术的DES加密算法\n");
        printf("请输入明文:");
        scanf("%c",&cc);
		while(cc!='\n'){
			c[j]=cc;
			j++;
			scanf("%c",&cc);
		}
		c[j]='\0';
        int blocks=_mbslen(c)/8;
		unsigned char *cp;
		unsigned char key[8];
        double *x;
		double m=0;
        printf("请输入加密密钥(0-1之间的任一实数):");
		scanf("%lf",&m);
		x=&m;
		cp=c;
		
		des_enc(&dc,cp,blocks,key,x);
        printf("\n");
		printf("DES算法与混沌技术结合后,对明文加密如下:\n");
        printf("\n");
        printf("*十六进制形式*\n");
		for(i=0;i<(8*blocks);i++) printf("%02x ", ((unsigned int) cp[i])&0x00ff);
        printf("\n");
		printf("\n");
        printf("*ASC码形式*\n");
		printf("%s",cp);
        printf("\n");
        printf("\n");
        
		
        printf("请输入解密密钥(0-1之间的任一实数):");
		scanf("%lf",&m);
		x=&m;
        des_dec(&dc,cp,blocks,key,x);
        printf("\n");
		printf("DES算法与混沌技术结合后,对密文解密如下:\n");
		printf("\n");
		printf("*十六进制形式*\n");
        for(i=0;i<(8*blocks);i++) printf("%02x ", ((unsigned int) cp[i])&0x00ff);
        printf("\n");
		printf("\n");
		printf("*ASC码形式*\n");
        printf("%s",cp);
        printf("\n");


	
}