aes_sbox.v

aes加密算法实现

// AES S-BOX for GF(2(8))
// created by cyc June.5th.2006
//

`timescale 1ns / 10ps

module aes_sbox(a, d);
input	[7:0]	a;
//input           en_dec;   // indicate cipher---1 or inv_cipher------0;
output	[7:0]	d;



wire a0,a1,a2,a3,a4,a5,a6,a7;
wire al0,al1,al2,al3;
wire ah0,ah1,ah2,ah3;
wire aa,ab,ac;
wire aa_inv,ab_inv;
wire s0,s1,s2,s3,s4,s5,s6,s7;
wire m0,m1,m2,m3,m4,m5,m6,m7;
wire b0,b1,b2,b3,b4,b5,b6,b7;
wire q0,q1,q2,q3,q4,q5,q6,q7;

wire [3:0] ah,al;
wire [3:0] ah_inverse, al_inverse;
wire [3:0] ah_squre,al_squre;
wire [3:0] ah_mult_al;
wire [3:0] ah_squre_m_e;
wire [3:0] d_inverse;
wire [3:0] ds;
wire       aff_aa,aff_ab,aff_ac,aff_ad;
wire       aff_1_aa, aff_1_ab, aff_1_ac, aff_1_ad;
wire           en_dec;
parameter delay=1; 

assign en_dec=1;
assign b0=a[0];
assign b1=a[1];
assign b2=a[2];
assign b3=a[3];
assign b4=a[4];
assign b5=a[5];
assign b6=a[6];
assign b7=a[7];

//************* map(a),transition from GF(2(8)) to GF(2(4))**********************//
assign #delay aa=a1^a7;
assign #delay ab=a5^a7;
assign #delay ac=a4^a6;

assign #delay al0=ac^a0^a5;
assign #delay al1=a1^a2;
assign #delay al2=aa;
assign #delay al3=a2^a4;

assign #delay ah0=ac^a5;
assign #delay ah1=aa^ac;
assign #delay ah2=ab^a2^a3;
assign #delay ah3=ab;

assign ah={ah3,ah2,ah1,ah0};
assign al={al3,al2,al1,al0};

//******* calculate the inverse of the(((ah*ah)*{e})+(ah*al)+(al*al))********//
 sbox_square sbox_square1(
                    .a(ah),
                    .q(ah_squre)
                    );          //*****************  ah*ah
                    
sbox_square sbox_square2(
                    .a(al),
                    .q(al_squre)
                    );         //******************  al*al
                    
 sbox_multip sbox_multip1(
                    .a(ah),
                    .b(al),
                    .q(ah_mult_al)
                    );         //******************  ah*al

 sbox_multip_e sbox_multip_e1(
                      .a(ah_squre),
                      .q(ah_squre_m_e)
                      );       //******************  ah_squre*e
                   
assign d_inverse=ah_squre_m_e^ah_mult_al^al_squre;
                      
 sbox_inverse sbox_inverse1(
                            .a(d_inverse),
                            .q(ds)
                            );  //******************* d    

 sbox_multip sbox_multip2(
                    .a(ah),
                    .b(ds),
                    .q(ah_inverse)
                    );         //******************  ah_inverse=ah*d
                    
  sbox_multip sbox_multip3(
                    .a(ah^al),
                    .b(ds),
                    .q(al_inverse)
                    );         //******************  al_inverse=(ah+al)*d                  

//************* map(a)(-1),transition from GF(2(4)) to GF(2(8))**********************//
assign #delay aa_inv=al_inverse[1]^ah_inverse[3];
assign #delay ab_inv=ah_inverse[0]^ah_inverse[1];


assign #delay s0=al_inverse[0]^ah_inverse[0];
assign #delay s1=ab_inv^ah_inverse[3];
assign #delay s2=aa_inv^ab_inv;
assign #delay s3=ab_inv^al_inverse[1]^ah_inverse[2];

assign #delay s4=aa_inv^ab_inv^al_inverse[3];
assign #delay s5=ab_inv^al_inverse[2];
assign #delay s6=aa_inv^al_inverse[2]^al_inverse[3]^ah_inverse[0];
assign #delay s7=ab_inv^al_inverse[2]^ah_inverse[3];

//************** affine transmation***************************************//
assign #delay aff_aa=s0^s1;
assign #delay aff_ab=s2^s3;
assign #delay aff_ac=s4^s5;
assign #delay aff_ad=s6^s7;

assign #delay q0=(~s0)^aff_ac^aff_ad;
assign #delay q1=(~s5)^aff_aa^aff_ad;
assign #delay q2= s2^aff_aa^aff_ad;
assign #delay q3= s7^aff_aa^aff_ab;
assign #delay q4= s4^aff_aa^aff_ab;
assign #delay q5=(~s1)^aff_ab^aff_ac;
assign #delay q6=(~s6)^aff_ab^aff_ac;
assign #delay q7= s3^aff_ac^aff_ad;

//************** inverse affine transmation***********************************//

assign #delay aff_1_aa=b0^b5;
assign #delay aff_1_ab=b1^b4;
assign #delay aff_1_ac=b2^b7;
assign #delay aff_1_ad=b3^b6;

assign #delay m0=(~b5)^aff_1_ac;
assign #delay m1= b0^aff_1_ad;
assign #delay m2=(~b7)^aff_1_ab;
assign #delay m3= b2^aff_1_aa;
assign #delay m4= b1^aff_1_ad;
assign #delay m5= b4^aff_1_ac;
assign #delay m6= b3^aff_1_aa;
assign #delay m7= b6^aff_1_ab;
// indicate cipher---1 or inv_cipher------0;
assign d=en_dec? {q7,q6,q5,q4,q3,q2,q1,q0}: {s7,s6,s5,s4,s3,s2,s1,s0};
assign {a7,a6,a5,a4,a3,a2,a1,a0}=en_dec? {b7,b6,b5,b4,b3,b2,b1,b0}: {m7,m6,m5,m4,m3,m2,m1,m0};

wire [7:0] m;
assign m=  {s7,s6,s5,s4,s3,s2,s1,s0};               
endmodule

module sbox_inverse(a,q);
input	[3:0]	a;
output	[3:0]	q;

wire aa;
wire q0,q1,q2,q3;
wire a0,a1,a2,a3;

assign a0=a[0];
assign a1=a[1];
assign a2=a[2];
assign a3=a[3];

assign aa=a1^a2^a3^(a1&a2&a3);
assign q0=aa^a0^(a0&a2)^(a1&a2)^(a0&a1&a2);
assign q1=(a0&a1)^(a0&a2)^(a1&a2)^a3^(a1&a3)^(a0&a1&a3);
assign q2=(a0&a1)^a2^(a0&a2)^a3^(a0&a3)^(a0&a2&a3);
assign q3=aa^(a0&a3)^(a1&a3)^(a2&a3);

assign q={q3,q2,q1,q0};
endmodule

module sbox_multip(a,b,q);
input	[3:0]	a;
input   [3:0]   b;
output	[3:0]	q;


wire a0,a1,a2,a3;
wire b0,b1,b2,b3;
wire aa,ab;
wire q0,q1,q2,q3;
parameter delay=1; 

assign a0=a[0];
assign a1=a[1];
assign a2=a[2];
assign a3=a[3];

assign b0=b[0];
assign b1=b[1];
assign b2=b[2];
assign b3=b[3];

//************* calculate the aa,ab **********************//
assign #delay aa=a0^a3;
assign #delay ab=a2^a3;

assign q0=(a0&b0)^(a3&b1)^(a2&b2)^(a1&b3);
assign q1=(a1&b0)^(aa&b1)^(ab&b2)^((a1^a2)&b3);
assign q2=(a2&b0)^(a1&b1)^(aa&b2)^(ab&b3);
assign q3=(a3&b0)^(a2&b1)^(a1&b2)^(aa&b3);
assign q={q3,q2,q1,q0};


endmodule

module sbox_multip_e(a,q);
input	[3:0]	a;
output	[3:0]	q;


wire a0,a1,a2,a3;
wire aa,ab;
wire q0,q1,q2,q3;

parameter delay=1; 

assign a0=a[0];
assign a1=a[1];
assign a2=a[2];
assign a3=a[3];

//************* calculate the aa,ab **********************//
assign #delay aa=a0^a1;
assign #delay ab=a2^a3;

assign q0=a1^ab;
assign q1=aa;
assign q2=aa^a2;
assign q3=aa^ab;
assign q={q3,q2,q1,q0};

endmodule

module sbox_square(a,q);
input	[3:0]	a;
output	[3:0]	q;

wire a0,a1,a2,a3;
wire q0,q1,q2,q3;
parameter delay=1; 

assign a0=a[0];
assign a1=a[1];
assign a2=a[2];
assign a3=a[3];

assign q0=a0^a2;
assign q1=a2;
assign q2=a1^a3;
assign q3=a3;
assign q={q3,q2,q1,q0};

endmodule