aes.cpp

网络安全加密的AES算法代码

#include<stdio.h>
#include<iostream.h>
#define NB 8
#define NK 4
#define NR 14
void convert_binarym( int a[32*NB], int b[4*NB])
{ int i,j,k;
  k=0;
  for(i=0;i<4*NB;i++)
  {      k=8*i+7;	
	  for(j=0;j<8;j++)
	  {   
		  a[k--]=b[i]%2;
	       b[i]=b[i]/2;
	  }
  }
}
void convert_binaryk( int a[32*NK], int b[4*NK])
{ int i,j,k;
  k=0;
  for(i=0;i<4*NK;i++)
  {      k=8*i+7;	
	  for(j=0;j<8;j++)
	  {   
		  a[k--]=b[i]%2;
	     
           b[i]=b[i]/2;
	  }
  }
}
void convert_decimal( int a[4*NB],int b[32*NB])
{ int i,j,k;
    k=0;
  for(i=0;i<4*NB;i++)
  { 
    a[i]=0;
	for(j=0;j<8;j++)
		a[i]=(2*a[i]+b[k++]);
  }
}
void njz(int a[8][8])
{static int table[8][16]=
{{1,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0},
{ 1,1,0,0,0,1,1,1,0,1,0,0,0,0,0,0},
{ 1,1,1,0,0,0,1,1,0,0,1,0,0,0,0,0},
{ 1,1,1,1,0,0,0,1,0,0,0,1,0,0,0,0},
{ 1,1,1,1,1,0,0,0,0,0,0,0,1,0,0,0},
{ 0,1,1,1,1,1,0,0,0,0,0,0,0,1,0,0},
{ 0,0,1,1,1,1,1,0,0,0,0,0,0,0,1,0},
{ 0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,1}};
  int i,j,k;
  static int t[16];
  for(i=0;i<8;i++)
  { if(table[i][i]==0)
    for(j=i+1;j<8;j++)
	  if(table[j][i]==1)
	  {for(k=i;k<16;k++)
	   {t[k]=table[j][k];
		table[j][k]=table[i][k];
		table[i][k]=t[k];}
        break;
	  }
	    for(j=i+1;j<8;j++)
		 if(table[j][i]==1)
		   for(k=i;k<16;k++)
		    table[j][k]=(table[j][k]+table[i][k])%2;
		 
  }
   for(i=7;i>=0;i--)
     for(j=i-1;j>=0;j--)
	   if(table[j][i]==1)
		   for(k=0;k<16;k++)
		   table[j][k]=(table[j][k]+table[i][k])%2;
		   for(i=0;i<8;i++)
		     for(j=0;j<8;j++)
			 a[i][j]=table[i][j+8];
}
void mul(int a[8],int b[8],int c[16])
{   int i,j,k;
    static int d[9]={1,1,0,1,1,0,0,0,1};
	for(k=15;k>=0;k--)
			c[k]=0;
       for(i=0;i<8;i++)
	     for(j=0;j<8;j++)
		   c[i+j]=(c[i+j]+a[i]*b[j])%2;
		 for(i=15;i>=8;i--)
		  if(c[i]==1)
		  {  k=i;
	         for(j=8;j>=0;j--)
			 {c[k]=(c[k]+d[j])%2;
		       k--;
			 }
		  }
}		
void nxl(int p[256])    //求逆向量
{ static int c[16];
static int a[8];
static int b[8];
int i,i1,i2,j,k;
  for(i1=0;i1<256;i1++)
  {   k=i1;
      j=0;
	  for(i=0;i<8;i++)
		  a[i]=0;
      while(k>0)
	  {a[j++]=k%2;
	   k=k/2;
	  }
	  for(i2=0;i2<256;i2++)
	  {	  for(i=7;i>=0;i--)
	         b[i]=0;
		  k=i2;
        j=0;
        while(k>0)
		{b[j++]=k%2;
	     k=k/2;
		}
		 mul(a,b,c);
		for(k=7;k>=0;k--)
		  if(c[k]==1)
			  break;
		  if(k==0)
		  {   
			  int sum=0;
			  for(k=7;k>=0;k--)
               sum=2*sum+b[k];
                p[i1]=sum;
		}
	  }
      if(i1==0)
	  p[i1]=0;
	}
}
void bytesub(int x[8],const int a[256])
{ const static int table[8][8]=
{{1,0,0,0,1,1,1,1},
{ 1,1,0,0,0,1,1,1},
{ 1,1,1,0,0,0,1,1},
{ 1,1,1,1,0,0,0,1},
{ 1,1,1,1,1,0,0,0},
{ 0,1,1,1,1,1,0,0},
{ 0,0,1,1,1,1,1,0},
{ 0,0,0,1,1,1,1,1}};
  const static int t[8]={1,1,0,0,0,1,1,0};	  
  static int y[8];
  int j,k,sum;
  sum=0;
    for(j=0;j<8;j++)
	 sum=2*sum+x[j];
      sum=a[sum];
     for(j=0;j<8;j++)
	   x[j]=0;
     j=0;
    while(sum>0)
	{ x[j++]=sum%2;
	  sum=sum/2;
	}
     for(j=7;j>=0;j--)
		 y[j]=0;
	for(j=0;j<8;j++)
       for(k=0;k<8;k++)
		   y[j]=(y[j]+table[j][k]*x[k])%2;
       for(k=0;k<8;k++)
		   y[k]=(y[k]+t[k])%2;
	   
	   for(k=0;k<8;k++)
	      x[k]=y[7-k];
}
void xtime(int a[8])
{  static int b[8]={0,1,0,0,0,0,0,0};
   static int c[16];
   int i;
   mul(a,b,c);
   for(i=7;i>=0;i--)
	   a[i]=c[i];
}
void moveleft1(int t[8*NB],int i)
{  static int b[8*NB];
   int j;
   for(j=0;j<8*NB;j++)
	   b[j]=t[(j+i)%(8*NB)];
     for(j=8*NB-1;j>=0;j--)     //关键点
		 t[j]=b[j];
}
void moveleft2(int a[32],int i)
{  static int b[32];
   int j;
   for(j=0;j<32;j++)
	   b[j]=a[(j+i)%32];
     for(j=31;j>=0;j--)
		 a[j]=b[j];
}
void shiftrow(int m3[4][NB][8])
{ int i,j,k;
  static int table[3][4]={{0,1,2,3},{0,1,2,3},{0,1,3,4}};
  static int t[8*NB];
  for(i=0;i<4;i++)
  {for(j=0;j<NB;j++)
	for(k=0;k<8;k++)
	 t[8*j+k]=m3[i][j][k];
	 moveleft1(t,8*table[(NB-4)/2][i]);
	 for(j=0;j<NB;j++)
	 for(k=0;k<8;k++)
       m3[i][j][k]=t[8*j+k];
  }
}
void mixcolumn(int m3[4][NB][8])
{  static int a0[8]={0,1,0,0,0,0,0,0};
   static int a1[8]={1,0,0,0,0,0,0,0};
   static int a2[8]={1,0,0,0,0,0,0,0};
   static int a3[8]={1,1,0,0,0,0,0,0};
   static int b0[8],b1[8],b2[8],b3[8];
   static int d0[8],d1[8],d2[8],d3[8];
   static int c[16];
   int j,k;
   for(j=0;j<NB;j++)
   { for(k=0;k<8;k++)
   {    b0[k]=m3[0][j][7-k];
        b1[k]=m3[1][j][7-k];
		b2[k]=m3[2][j][7-k];
        b3[k]=m3[3][j][7-k];
   }
     mul(a0,b0,c);
	 for(k=0;k<8;k++)
		 d0[k]=c[k];
     mul(a3,b1,c);
	 for(k=0;k<8;k++)
		 d0[k]=(d0[k]+c[k])%2;
	 mul(a2,b2,c);
	 for(k=0;k<8;k++)
		 d0[k]=(d0[k]+c[k])%2;
	 mul(a1,b3,c);
	 for(k=0;k<8;k++)
	   d0[k]=(d0[k]+c[k])%2;
     mul(a1,b0,c);
	 for(k=0;k<8;k++)
		 d1[k]=c[k];
	 mul(a0,b1,c);
	 for(k=0;k<8;k++)
		 d1[k]=(d1[k]+c[k])%2;
	 mul(a3,b2,c);
	 for(k=0;k<8;k++)
		 d1[k]=(d1[k]+c[k])%2;
	 mul(a2,b3,c);
	 for(k=0;k<8;k++)
	    d1[k]=(d1[k]+c[k])%2;
     mul(a2,b0,c);
	 for(k=0;k<8;k++)
		 d2[k]=c[k];
	 mul(a1,b1,c);
	 for(k=0;k<8;k++)
		 d2[k]=(d2[k]+c[k])%2;
	 mul(a0,b2,c);
	 for(k=0;k<8;k++)
		 d2[k]=(d2[k]+c[k])%2;
	 mul(a3,b3,c);
	 for(k=0;k<8;k++)
	   d2[k]=(d2[k]+c[k])%2;
      mul(a3,b0,c);
	 for(k=0;k<8;k++)
		 d3[k]=c[k];
	 mul(a2,b1,c);
	 for(k=0;k<8;k++)
		 d3[k]=(d3[k]+c[k])%2;
	 mul(a1,b2,c);
	 for(k=0;k<8;k++)
		 d3[k]=(d3[k]+c[k])%2;
	 mul(a0,b3,c);
	 for(k=0;k<8;k++)
	   d3[k]=(d3[k]+c[k])%2;
	 for(k=0;k<8;k++)
	 { m3[0][j][7-k]=d0[k];
       m3[1][j][7-k]=d1[k];
	   m3[2][j][7-k]=d2[k];
       m3[3][j][7-k]=d3[k];
	 }
   }
}

void rcon(int a[32],int i)
{  static rc[8]={1,0,0,0,0,0,0,0};
   int k;
   for(k=1;k<i;k++)
    xtime(rc);
	for(k=0;k<8;k++)
   a[k]=rc[7-k];
   for(k=8;k<32;k++)
	   a[k]=0;
   rc[0]=1;
   for(k=1;k<8;k++)
	   rc[k]=0;
}
void keyexpansion(int k2[256],int w[NB*(NR+1)][32],int a[256])
{  static int k3[4][8][8];
   static int t1[32];
   static int t2[32],t[8];
   int i,j,k,m,n;  
	for(j=0;j<NK;j++)
	   for(i=0;i<4;i++)
	   for(k=0;k<8;k++)
	   k3[i][j][k]=k2[32*j+8*i+k];
	     for(j=0;j<NK;j++)     //
		{for(i=0;i<4;i++)
			for(k=0;k<8;k++)
             w[j][8*i+k]=k3[i][j][k];
        }
		for(j=NK;j<NB*(NR+1);j+=NK)
		{   for(m=0;m<32;m++)
		     t1[m]=w[j-1][m];    
		     moveleft2(t1,8);     //t1--rotl(w[j-1])
			  for(m=0;m<4;m++)
			 { for(n=0;n<8;n++)
			    t[n]=t1[8*m+n];
			    bytesub(t,a);  //4       
               for(n=0;n<8;n++)
				   t1[8*m+n]=t[n];  //t1--bytesub(rotl(w[j-1)
			 }
			 for(m=0;m<32;m++)
				 t2[m]=0;
			 rcon(t2,j/NK);   //t2--rcon(j/nk)
			 
			   for(k=0;k<32;k++)
				 w[j][k]=(w[j-NK][k]+t1[k]+t2[k])%2;
			     if(NK>6)
				 {for(i=1;(i<4)&&(i+j<NB*(NR+1));i++)
				 for(k=0;k<32;k++)
				 w[i+j][k]=(w[i+j-NK][k]+w[i+j-1][k])%2;   //
				  for(m=0;m<32;m++)
				   if(j+3<NB*(NR+1))
		        t1[m]=w[j+3][m];
				  if(j+3<NB*(NR+1))
				   { for(m=0;m<4;m++)
			 { for(n=0;n<8;n++)
			    t[n]=t1[8*m+n];
				   bytesub(t,a);       
               for(n=0;n<8;n++)
				   t1[8*m+n]=t[n];  //t1--bytesub(w[j+3])
				   }}
                for(k=0;k<32;k++)
				   if(j+4<NB*(NR+1))
			   w[j+4][k]=(w[j+4-NK][k]+t1[k])%2;
			 for(i=5;(i<NK)&&(i+j<NB*(NR+1));i++)
				 for(k=0;k<32;k++)
					 w[i+j][k]=(w[i+j-NK][k]+w[i+j-1][k])%2;
				 }
				 else
				 {   for(i=1;i<NK&&(i+j<NB*(NR+1));i++)
				     for(k=0;k<32;k++)
					 w[i+j][k]=(w[i+j-NK][k]+w[i+j-1][k])%2;
				 }
		}
}		
void addroundkey(int m3[4][NB][8],int w[NB*(NR+1)][32],int i)
{  int i1,j,k;
   for(j=0;j<NB;j++)
   {for(i1=0;i1<4;i1++)
	 for(k=0;k<8;k++)
      m3[i1][j][k]=(m3[i1][j][k]+w[i*NB+j][8*i1+k])%2;
   }
}
void round(int m3[4][NB][8],int w[NB*(NR+1)][32],int n,int a[256])
{    int i,j,k;
    static int t[8];
     for(i=0;i<4;i++)
	 for(j=0;j<NB;j++)
	 {   for(k=0;k<8;k++)       
	     t[k]=m3[i][j][k];
          bytesub(t,a);    //Bytesub
          for(k=0;k<8;k++)       
	     m3[i][j][k]=t[k];
	 }
	shiftrow(m3);      //shiftrow
    mixcolumn(m3);       //mixcolumn  
	addroundkey(m3,w,n);     //addroundkey
}
void finalround(int m3[4][NB][8],int w[NB*(NR+1)][32],int n,int a[256])
{    int i,j,k; 
     static int t[8];
     for(i=0;i<4;i++)
	 for(j=0;j<NB;j++)
	 {   for(k=0;k<8;k++)       
	     t[k]=m3[i][j][k];
	     bytesub(t,a);           //Bytesub
		 for(k=0;k<8;k++)       
	     m3[i][j][k]=t[k];
	 }
      shiftrow(m3);       //shiftrow
      addroundkey(m3,w,n);//addroundkey
}
void main()
{ char m[4*NB]={'h','e','l','l','o',' ','w','o','r','l',
              'd',' ','g','o','o','d',' ','m','o','r','n','i','n','g',
                ' ','m','o','r','n','i','n','g'};
char key[4*NK]={'g','r','e','a','t','w','a','l',
                'l','c','h','i','n','a','t','o'};
   int i,j,k;
   static int m1[4*NB];
   static int k1[4*NK];
   static int m2[32*NB];
   static int m3[4][NB][8];  //将明文分块放置
   static int k2[32*NK];
   static int t[8];
   static int w[NB*(NR+1)][32];
   static int a[256];
   nxl(a);
    for(i=0;i<4*NB;i++)
     m1[i]=(int)m[i];
     convert_binarym(m2,m1);
	 for(i=0;i<32;i++)
		 k1[i]=(int)key[i];
	 convert_binaryk(k2,k1);
       keyexpansion(k2,w,a);
       for(j=0;j<NB;j++)
	   for(i=0;i<4;i++)
	   for(k=0;k<8;k++)
	    m3[i][j][k]=m2[32*j+8*i+k];
        addroundkey(m3,w,0);
        for(i=1;i<NR;i++)
	   round(m3,w,i,a);
       finalround(m3,w,NR,a);
      for(j=0;j<NB;j++)
	   for(i=0;i<4;i++)
	   for(k=0;k<8;k++)
	     m2[32*j+8*i+k]=m3[i][j][k];
	   /*for(i=0;i<4;i++)
		   for(j=0;j<NB;j++)
			   for(k=0;k<8;k++)
			   m2[8*NB*i+8*j+k]=m3[i][j][k];*/
	     convert_decimal(m1,m2);
		 for(i=0;i<4*NB;i++)
			 cout<<m1[i]<<" ";
}