rijndael.cpp

这个是基于混沌的AES加密算法

#define f_nround(bo, bi, k) \
    f_rn(bo, bi, 0, k);     \
    f_rn(bo, bi, 1, k);     \
    f_rn(bo, bi, 2, k);     \
    f_rn(bo, bi, 3, k);     \
    k += 4

#define f_lround(bo, bi, k) \
    f_rl(bo, bi, 0, k);     \
    f_rl(bo, bi, 1, k);     \
    f_rl(bo, bi, 2, k);     \
    f_rl(bo, bi, 3, k)

void encrypt(const u4byte in_blk[4], u4byte out_blk[4])
{   u4byte  b0[4], b1[4], *kp;

    b0[0] = in_blk[0] ^ e_key[0]; b0[1] = in_blk[1] ^ e_key[1];
    b0[2] = in_blk[2] ^ e_key[2]; b0[3] = in_blk[3] ^ e_key[3];

    kp = e_key + 4;

    if(k_len > 6)
    {
        f_nround(b1, b0, kp); f_nround(b0, b1, kp);
    }

    if(k_len > 4)
    {
        f_nround(b1, b0, kp); f_nround(b0, b1, kp);
    }

    f_nround(b1, b0, kp); f_nround(b0, b1, kp);
    f_nround(b1, b0, kp); f_nround(b0, b1, kp);
    f_nround(b1, b0, kp); f_nround(b0, b1, kp);
    f_nround(b1, b0, kp); f_nround(b0, b1, kp);
    f_nround(b1, b0, kp); f_lround(b0, b1, kp);

    out_blk[0] = b0[0]; out_blk[1] = b0[1];
    out_blk[2] = b0[2]; out_blk[3] = b0[3];
}

// decrypt a block of text  

#define i_nround(bo, bi, k) \
    i_rn(bo, bi, 0, k);     \
    i_rn(bo, bi, 1, k);     \
    i_rn(bo, bi, 2, k);     \
    i_rn(bo, bi, 3, k);     \
    k -= 4

#define i_lround(bo, bi, k) \
    i_rl(bo, bi, 0, k);     \
    i_rl(bo, bi, 1, k);     \
    i_rl(bo, bi, 2, k);     \
    i_rl(bo, bi, 3, k)

void decrypt(const u4byte in_blk[4], u4byte out_blk[4])
{   u4byte  b0[4], b1[4], *kp;

    b0[0] = in_blk[0] ^ e_key[4 * k_len + 24]; 
	b0[1] = in_blk[1] ^ e_key[4 * k_len + 25]; 
    b0[2] = in_blk[2] ^ e_key[4 * k_len + 26]; 
	b0[3] = in_blk[3] ^ e_key[4 * k_len + 27];

    kp = d_key + 4 * (k_len + 5);

    if(k_len > 6)
    {
        i_nround(b1, b0, kp); i_nround(b0, b1, kp);
    }

    if(k_len > 4)
    {
        i_nround(b1, b0, kp); i_nround(b0, b1, kp);
    }

    i_nround(b1, b0, kp); i_nround(b0, b1, kp);
    i_nround(b1, b0, kp); i_nround(b0, b1, kp);
    i_nround(b1, b0, kp); i_nround(b0, b1, kp);
    i_nround(b1, b0, kp); i_nround(b0, b1, kp);
    i_nround(b1, b0, kp); i_lround(b0, b1, kp);

    out_blk[0] = b0[0]; out_blk[1] = b0[1];
    out_blk[2] = b0[2]; out_blk[3] = b0[3];
}
//--------------------------------------------------------------------------------
void aes_enc(u4byte *data, u4byte *cipher, int blocks, u4byte *key, double *x)
{  
	int i,j;
	u4byte in_blk[4],out_blk[4];    
    u4byte *dp,*ep;
	dp= data;
    ep= cipher;
    
      

	//加密明文后存入到cipher[1000]中
	for (i=0;i<blocks;i++){
		chaos_key (key, x);	
		set_key(key,128);

		for (j=0;j<4;j++){
            in_blk[j]= *dp;
			dp++;
		}

		encrypt(in_blk, out_blk);

        for (j=0;j<4;j++){
            *ep= out_blk[j];
			ep++;
		}
	
	}

}
		

void aes_dec(u4byte *cipher, u4byte *data, int blocks, u4byte *key, double *x)
{
	int i,j;
	u4byte in_blk[4],out_blk[4];
    u4byte *dp,*ep;
	dp= data;
    ep= cipher;
    
	for (i=0;i<blocks;i++){
		chaos_key (key, x);	
		set_key(key,128);

		for (j=0;j<4;j++){
            in_blk[j]= *ep;
			ep++;
		}

		decrypt(in_blk, out_blk);

        for (j=0;j<4;j++){
            *dp= out_blk[j];
			dp++;
		}
	}

}

void chaos_key(u4byte *key, double *x){
	    double a[100];
	    int i;
		double u=3.8;
		u4byte *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;
        *keyy= (*keyy << 8);
		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;
        *keyy= (*keyy << 8);
		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;
        *keyy= (*keyy << 8);
		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);
		for(i=0;i<3;i++)
		{
		*keyy|= *bb;
        *keyy= (*keyy << 8);
		bb++;
		}
        *keyy|= *bb;
        		
}

void main()
{   
	int i,j=0;
    u4byte key[4];
	unsigned char c[1000],cc;
	printf("基于混沌技术的AES加密算法\n");
    printf("请输入明文:");
    scanf("%c",&cc);
	while(cc!='\n'){
		c[j]=cc;
		j++;
		scanf("%c",&cc);
		}
	c[j]='\0';
    int blocks=_mbslen(c)/16;
    
	
	//将4个char型转换成一个u4byte型
	unsigned char *cp;
	u4byte  *dp;
	dp= data;
	cp= c;
    
    for(i=0;i<4*blocks;i++){
		*dp= 0x00000000;
		for(j=0;j<3;j++){
			*dp|= *cp;
			*dp= (*dp << 8);
			cp++;
            }
		    *dp|= *cp;
			cp++;
            dp++;
		} 	

      double *x;
	  double m=0;
      printf("请输入加密密钥(0-1之间的任一实数):");
	  scanf("%lf",&m);
	  x=&m;
    printf("---------------------------------------------------------------------\n");
	printf("明文的十六进制形式如下:");
    printf("\n");
	printf("\n");
	for(i=0;i<4*blocks;i++)
		printf("%x",data[i]);
	    printf("\n");

	u4byte  *ep;
    ep= cipher;
	dp= data;
    aes_enc(dp, ep, blocks, key, x);
    printf("\n");
	printf("----------------------------------------------------------------------\n");
	printf("\n");
	printf("AES算法与混沌技术结合后,对明文加密如下:\n");
    printf("\n");
	for(i=0;i<4*blocks;i++)
	printf("%x",cipher[i]);
	printf("\n");    
   
    dp= data;
    ep= cipher;
	printf("\n");
	printf("请输入解密密钥(0-1之间的任一实数):");
	scanf("%lf",&m);
	x=&m; 

    aes_dec(ep, dp, blocks, key, x);
    printf("\n");
	printf("----------------------------------------------------------------------\n");
	printf("\n");
    printf("解密后十六进制形式如下:");
    printf("\n");
	for(i=0;i<4*blocks;i++)
		printf("%x",data[i]);
	    printf("\n");

	
    
}