URL
https://opencores.org/ocsvn/systemcaes/systemcaes/trunk
Subversion Repositories systemcaes
Compare Revisions
- This comparison shows the changes necessary to convert path
/
- from Rev 21 to Rev 22
- ↔ Reverse comparison
Rev 21 → Rev 22
/trunk/rtl/systemc/aes192lowarea/adapt.h
0,0 → 1,68
////////////////////////////////////////////////////////////////////// |
//// //// |
//// sc_fifo to sc_signal adapter //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
|
#include "systemc.h" |
|
SC_MODULE(adapter){ |
|
sc_in<bool> clk; |
sc_in<bool> rt_ready_i; |
sc_in<sc_biguint<128> > rt_aes_data_i; |
|
sc_fifo_out<sc_biguint<128> > rt_aes_data_o; |
|
void adapt(){ |
|
while(1){ |
wait(clk->posedge_event()); |
if(rt_ready_i.read()) |
rt_aes_data_o.write(rt_aes_data_i.read()); |
} |
|
} |
|
SC_CTOR(adapter){ |
SC_THREAD(adapt); |
} |
}; |
/trunk/rtl/systemc/aes192lowarea/aesmodel.h
0,0 → 1,115
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES C behavioral model //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// C behavioral model used as golden model //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "systemc.h" |
|
SC_MODULE(aesmodel){ |
|
sc_fifo_in<bool> decrypt; |
sc_fifo_in<sc_biguint<192> > aes_key_i; |
sc_fifo_in<sc_biguint<128> > aes_data_i; |
|
sc_fifo_out<sc_biguint<128> > aes_data_o; |
|
void aes_thread(){ |
unsigned char aes_key[24],aes_data[16],aes_out[16]; |
sc_biguint<128> aes_data_i_var,aes_data_o_var; |
sc_biguint<192> aes_key_i_var; |
|
aes_context ctx; |
|
while(1){ |
|
aes_data_i_var=aes_data_i.read(); |
aes_key_i_var=aes_key_i.read(); |
|
//Convert a sc_biguint<128> to an array of 8 char |
aes_key[0]=(sc_uint<8>)aes_key_i_var.range(191,184);aes_key[1]=(sc_uint<8>)aes_key_i_var.range(183,176);aes_key[2]=(sc_uint<8>)aes_key_i_var.range(175,168);aes_key[3]=(sc_uint<8>)aes_key_i_var.range(167,160); |
aes_key[4]=(sc_uint<8>)aes_key_i_var.range(159,152);aes_key[5]=(sc_uint<8>)aes_key_i_var.range(151,144);aes_key[6]=(sc_uint<8>)aes_key_i_var.range(143,136);aes_key[7]=(sc_uint<8>)aes_key_i_var.range(135,128); |
aes_key[8]=(sc_uint<8>)aes_key_i_var.range(127,120);aes_key[9]=(sc_uint<8>)aes_key_i_var.range(119,112);aes_key[10]=(sc_uint<8>)aes_key_i_var.range(111,104);aes_key[11]=(sc_uint<8>)aes_key_i_var.range(103,96); |
aes_key[12]=(sc_uint<8>)aes_key_i_var.range(95,88);aes_key[13]=(sc_uint<8>)aes_key_i_var.range(87,80);aes_key[14]=(sc_uint<8>)aes_key_i_var.range(79,72);aes_key[15]=(sc_uint<8>)aes_key_i_var.range(71,64); |
aes_key[16]=(sc_uint<8>)aes_key_i_var.range(63,56);aes_key[17]=(sc_uint<8>)aes_key_i_var.range(55,48);aes_key[18]=(sc_uint<8>)aes_key_i_var.range(47,40);aes_key[19]=(sc_uint<8>)aes_key_i_var.range(39,32); |
aes_key[20]=(sc_uint<8>)aes_key_i_var.range(31,24);aes_key[21]=(sc_uint<8>)aes_key_i_var.range(23,16);aes_key[22]=(sc_uint<8>)aes_key_i_var.range(15,8);aes_key[23]=(sc_uint<8>)aes_key_i_var.range(7,0); |
|
|
aes_data[0]=(sc_uint<8>)aes_data_i_var.range(127,120);aes_data[1]=(sc_uint<8>)aes_data_i_var.range(119,112);aes_data[2]=(sc_uint<8>)aes_data_i_var.range(111,104);aes_data[3]=(sc_uint<8>)aes_data_i_var.range(103,96); |
aes_data[4]=(sc_uint<8>)aes_data_i_var.range(95,88);aes_data[5]=(sc_uint<8>)aes_data_i_var.range(87,80);aes_data[6]=(sc_uint<8>)aes_data_i_var.range(79,72);aes_data[7]=(sc_uint<8>)aes_data_i_var.range(71,64); |
aes_data[8]=(sc_uint<8>)aes_data_i_var.range(63,56);aes_data[9]=(sc_uint<8>)aes_data_i_var.range(55,48);aes_data[10]=(sc_uint<8>)aes_data_i_var.range(47,40);aes_data[11]=(sc_uint<8>)aes_data_i_var.range(39,32); |
aes_data[12]=(sc_uint<8>)aes_data_i_var.range(31,24);aes_data[13]=(sc_uint<8>)aes_data_i_var.range(23,16);aes_data[14]=(sc_uint<8>)aes_data_i_var.range(15,8);aes_data[15]=(sc_uint<8>)aes_data_i_var.range(7,0); |
|
|
if(!decrypt.read()){ |
// printf("C data: %X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X\n",aes_data[0],aes_data[1],aes_data[2],aes_data[3],aes_data[4],aes_data[5],aes_data[6],aes_data[7],aes_data[8],aes_data[9],aes_data[10],aes_data[11],aes_data[12],aes_data[13],aes_data[14],aes_data[15]); |
// printf("C key: 0x%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X\n",aes_key[0],aes_key[1],aes_key[2],aes_key[3],aes_key[4],aes_key[5],aes_key[6],aes_key[7],aes_key[8],aes_key[9],aes_key[10],aes_key[11],aes_key[12],aes_key[13],aes_key[14],aes_key[15],aes_key[16],aes_key[17],aes_key[18],aes_key[19],aes_key[20],aes_key[21],aes_key[22],aes_key[23]); |
aes_set_key( &ctx, aes_key, 192); |
aes_encrypt( &ctx, aes_data, aes_data ); |
}else{ |
// cout << "Key_i: 0x" << (int)(sc_uint<32>)aes_key_i_var.range(191,160) << (int)(sc_uint<32>)aes_key_i_var.range(159,128) << (int)(sc_uint<32>)aes_key_i_var.range(127,96) << (int)(sc_uint<32>)aes_key_i_var.range(95,64) << (int)(sc_uint<32>)aes_key_i_var.range(63,32) << (int)(sc_uint<32>)aes_key_i_var.range(31,0) << endl; |
// printf("C key: 0x%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X\n",aes_key[0],aes_key[1],aes_key[2],aes_key[3],aes_key[4],aes_key[5],aes_key[6],aes_key[7],aes_key[8],aes_key[9],aes_key[10],aes_key[11],aes_key[12],aes_key[13],aes_key[14],aes_key[15],aes_key[16],aes_key[17],aes_key[18],aes_key[19],aes_key[20],aes_key[21],aes_key[22],aes_key[23]); |
aes_set_key( &ctx, aes_key, 192); |
aes_decrypt( &ctx, aes_data, aes_data ); |
} |
|
for(int i=0;i<16;i++) |
aes_out[i]=aes_data[i]; |
|
aes_data_o_var.range(127,120)=aes_out[0];aes_data_o_var.range(119,112)=aes_out[1];aes_data_o_var.range(111,104)=aes_out[2];aes_data_o_var.range(103,96)=aes_out[3]; |
aes_data_o_var.range(95,88)=aes_out[4];aes_data_o_var.range(87,80)=aes_out[5];aes_data_o_var.range(79,72)=aes_out[6];aes_data_o_var.range(71,64)=aes_out[7]; |
aes_data_o_var.range(63,56)=aes_out[8];aes_data_o_var.range(55,48)=aes_out[9];aes_data_o_var.range(47,40)=aes_out[10];aes_data_o_var.range(39,32)=aes_out[11]; |
aes_data_o_var.range(31,24)=aes_out[12];aes_data_o_var.range(23,16)=aes_out[13];aes_data_o_var.range(15,8)=aes_out[14];aes_data_o_var.range(7,0)=aes_out[15]; |
|
aes_data_o.write(aes_data_o_var); |
} |
} |
|
|
|
SC_CTOR(aesmodel){ |
|
SC_THREAD(aes_thread); |
|
} |
}; |
/trunk/rtl/systemc/aes192lowarea/subbytes.cpp
0,0 → 1,202
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES subbytes module implementation //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Subbytes stage implementation for AES algorithm //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "subbytes.h" |
|
#define assign_array_to_128() \ |
{ \ |
data_reg_128.range(127,120)=data_reg_var[0]; \ |
data_reg_128.range(119,112)=data_reg_var[1]; \ |
data_reg_128.range(111,104)=data_reg_var[2]; \ |
data_reg_128.range(103,96)=data_reg_var[3]; \ |
data_reg_128.range(95,88)=data_reg_var[4]; \ |
data_reg_128.range(87,80)=data_reg_var[5]; \ |
data_reg_128.range(79,72)=data_reg_var[6]; \ |
data_reg_128.range(71,64)=data_reg_var[7]; \ |
data_reg_128.range(63,56)=data_reg_var[8]; \ |
data_reg_128.range(55,48)=data_reg_var[9]; \ |
data_reg_128.range(47,40)=data_reg_var[10]; \ |
data_reg_128.range(39,32)=data_reg_var[11]; \ |
data_reg_128.range(31,24)=data_reg_var[12]; \ |
data_reg_128.range(23,16)=data_reg_var[13]; \ |
data_reg_128.range(15,8)=data_reg_var[14]; \ |
data_reg_128.range(7,0)=data_reg_var[15]; \ |
} |
|
#define shift_array_to_128() \ |
{ \ |
data_reg_128.range(127,120)=data_reg_var[0]; \ |
data_reg_128.range(119,112)=data_reg_var[5]; \ |
data_reg_128.range(111,104)=data_reg_var[10]; \ |
data_reg_128.range(103,96)=data_reg_var[15]; \ |
data_reg_128.range(95,88)=data_reg_var[4]; \ |
data_reg_128.range(87,80)=data_reg_var[9]; \ |
data_reg_128.range(79,72)=data_reg_var[14]; \ |
data_reg_128.range(71,64)=data_reg_var[3]; \ |
data_reg_128.range(63,56)=data_reg_var[8]; \ |
data_reg_128.range(55,48)=data_reg_var[13]; \ |
data_reg_128.range(47,40)=data_reg_var[2]; \ |
data_reg_128.range(39,32)=data_reg_var[7]; \ |
data_reg_128.range(31,24)=data_reg_var[12]; \ |
data_reg_128.range(23,16)=data_reg_var[1]; \ |
data_reg_128.range(15,8)=data_reg_var[6]; \ |
data_reg_128.range(7,0)=data_reg_var[11]; \ |
} |
|
#define invert_shift_array_to_128() \ |
{ \ |
data_reg_128.range(127,120)=data_reg_var[0]; \ |
data_reg_128.range(119,112)=data_reg_var[13]; \ |
data_reg_128.range(111,104)=data_reg_var[10]; \ |
data_reg_128.range(103,96)=data_reg_var[7]; \ |
data_reg_128.range(95,88)=data_reg_var[4]; \ |
data_reg_128.range(87,80)=data_reg_var[1]; \ |
data_reg_128.range(79,72)=data_reg_var[14]; \ |
data_reg_128.range(71,64)=data_reg_var[11]; \ |
data_reg_128.range(63,56)=data_reg_var[8]; \ |
data_reg_128.range(55,48)=data_reg_var[5]; \ |
data_reg_128.range(47,40)=data_reg_var[2]; \ |
data_reg_128.range(39,32)=data_reg_var[15]; \ |
data_reg_128.range(31,24)=data_reg_var[12]; \ |
data_reg_128.range(23,16)=data_reg_var[9]; \ |
data_reg_128.range(15,8)=data_reg_var[6]; \ |
data_reg_128.range(7,0)=data_reg_var[3]; \ |
} |
|
|
void subbytes::sub(){ |
sc_biguint<128> data_i_var,data_reg_128; |
sc_uint<8> data_array[16],data_reg_var[16]; |
|
data_i_var=data_i.read(); |
|
data_array[0]=data_i_var.range(127,120); |
data_array[1]=data_i_var.range(119,112); |
data_array[2]=data_i_var.range(111,104); |
data_array[3]=data_i_var.range(103,96); |
data_array[4]=data_i_var.range(95,88); |
data_array[5]=data_i_var.range(87,80); |
data_array[6]=data_i_var.range(79,72); |
data_array[7]=data_i_var.range(71,64); |
data_array[8]=data_i_var.range(63,56); |
data_array[9]=data_i_var.range(55,48); |
data_array[10]=data_i_var.range(47,40); |
data_array[11]=data_i_var.range(39,32); |
data_array[12]=data_i_var.range(31,24); |
data_array[13]=data_i_var.range(23,16); |
data_array[14]=data_i_var.range(15,8); |
data_array[15]=data_i_var.range(7,0); |
|
data_reg_var[0]=data_reg.read().range(127,120); |
data_reg_var[1]=data_reg.read().range(119,112); |
data_reg_var[2]=data_reg.read().range(111,104); |
data_reg_var[3]=data_reg.read().range(103,96); |
data_reg_var[4]=data_reg.read().range(95,88); |
data_reg_var[5]=data_reg.read().range(87,80); |
data_reg_var[6]=data_reg.read().range(79,72); |
data_reg_var[7]=data_reg.read().range(71,64); |
data_reg_var[8]=data_reg.read().range(63,56); |
data_reg_var[9]=data_reg.read().range(55,48); |
data_reg_var[10]=data_reg.read().range(47,40); |
data_reg_var[11]=data_reg.read().range(39,32); |
data_reg_var[12]=data_reg.read().range(31,24); |
data_reg_var[13]=data_reg.read().range(23,16); |
data_reg_var[14]=data_reg.read().range(15,8); |
data_reg_var[15]=data_reg.read().range(7,0); |
|
|
sbox_decrypt_o.write(decrypt_i.read()); |
sbox_data_o.write(0); |
next_state.write(state.read()); |
next_data_reg.write(data_reg.read()); |
|
next_ready_o.write(0); |
data_o.write(data_reg.read()); |
|
switch(state.read()){ |
|
case 0: |
if(start_i.read()){ |
sbox_data_o.write(data_array[0]); |
next_state.write(1); |
} |
break; |
case 16: |
data_reg_var[15]=sbox_data_i.read(); |
//Make shift rows stage |
switch(decrypt_i.read()){ |
case 0: |
shift_array_to_128(); |
break; |
case 1: |
invert_shift_array_to_128(); |
break; |
} |
next_data_reg.write(data_reg_128); |
next_ready_o.write(1); |
next_state.write(0); |
break; |
default: |
sbox_data_o.write(data_array[(int)state.read()]); |
data_reg_var[(int)state.read()-1]=sbox_data_i.read(); |
assign_array_to_128(); |
next_data_reg.write(data_reg_128); |
next_state.write(state.read()+1); |
break; |
} |
} |
|
void subbytes::registers(){ |
if(!reset.read()){ |
data_reg.write(0); |
state.write(0); |
ready_o.write(0); |
}else{ |
data_reg.write(next_data_reg.read()); |
state.write(next_state.read()); |
ready_o.write(next_ready_o.read()); |
} |
} |
/trunk/rtl/systemc/aes192lowarea/keysched192.h
0,0 → 1,91
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES key schedule implementation //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Generate the next round key from the previous one //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "systemc.h" |
|
SC_MODULE(keysched){ |
|
sc_in<bool> clk; |
sc_in<bool> reset; |
|
sc_in<bool> start_i; |
sc_in<sc_uint<4> > round_i; |
sc_in<sc_biguint<192> > last_key_i; |
sc_out<sc_biguint<192> > new_key_o; |
sc_out<bool> ready_o; |
|
//To Sbox |
//Indicates an access to sbox to arbitrate with the subbytes stage |
sc_out<bool> sbox_access_o; |
sc_out<sc_uint<8> > sbox_data_o; |
sc_in<sc_uint<8> > sbox_data_i; |
sc_out<bool> sbox_decrypt_o; //Always 0 |
|
void rcon(); |
void generate_key(); |
void registers(); |
void muxes(); |
|
sc_signal<sc_uint<3> > next_state,state; |
sc_signal<sc_uint<8> > rcon_o; |
sc_signal<sc_uint<32> > next_col,col; |
sc_signal<sc_biguint<192> > key_reg,next_key_reg; |
sc_signal<bool> next_ready_o; |
|
SC_CTOR(keysched){ |
|
SC_METHOD(rcon); |
sensitive << round_i; |
|
SC_METHOD(registers); |
sensitive_pos << clk; |
sensitive_neg << reset; |
|
SC_METHOD(generate_key); |
sensitive << start_i << last_key_i << sbox_data_i << state << rcon_o << col << key_reg; |
|
} |
}; |
/trunk/rtl/systemc/aes192lowarea/mixcolum.h
0,0 → 1,100
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES moxcolum module implementation //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Mixcolum stage implementation for AES algorithm //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "systemc.h" |
#include "word_mixcolum.h" |
|
SC_MODULE(mixcolum){ |
|
sc_in<bool> clk; |
sc_in<bool> reset; |
|
sc_in<bool> decrypt_i; |
sc_in<bool> start_i; |
sc_in<sc_biguint<128> > data_i; |
|
sc_out<bool> ready_o; |
sc_out<sc_biguint<128> > data_o; |
|
sc_signal<sc_biguint<128> > data_reg,next_data_reg,data_o_reg,next_data_o; |
sc_signal<bool> next_ready_o; |
|
void mixcol(); |
void registers(); |
void mux(); |
void assign_data_o(); |
|
sc_signal<sc_uint<2> > state,next_state; |
|
sc_signal<sc_uint<32> > outx,outy,mix_word,outmux; |
|
word_mixcolum *w1; |
|
SC_CTOR(mixcolum){ |
|
w1=new word_mixcolum("w1"); |
|
w1->in(mix_word); |
w1->outx(outx); |
w1->outy(outy); |
|
SC_METHOD(assign_data_o); |
sensitive << data_o_reg; |
|
SC_METHOD(mux); |
sensitive << outx << outy; |
|
SC_METHOD(registers); |
sensitive_pos << clk; |
sensitive_neg << reset; |
|
SC_METHOD(mixcol); |
sensitive << decrypt_i << start_i << state << data_reg << outmux << data_o_reg; |
|
|
|
} |
}; |
/trunk/rtl/systemc/aes192lowarea/subbytes.h
0,0 → 1,83
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES subbytes module header //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Subbytes stage header for AES algorithm //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "systemc.h" |
|
SC_MODULE(subbytes){ |
|
sc_in<bool> clk; |
sc_in<bool> reset; |
|
sc_in<bool> start_i; |
sc_in<bool> decrypt_i; |
sc_in<sc_biguint<128> > data_i; |
|
sc_out<bool> ready_o; |
sc_out<sc_biguint<128> > data_o; |
|
//To sbox |
sc_out<sc_uint<8> > sbox_data_o; |
sc_in<sc_uint<8> > sbox_data_i; |
sc_out<bool> sbox_decrypt_o; |
|
void sub(); |
void registers(); |
|
sc_signal<sc_uint<5> > state,next_state; |
sc_signal<sc_biguint<128> > data_reg,next_data_reg; |
sc_signal<bool> next_ready_o; |
|
SC_CTOR(subbytes){ |
|
SC_METHOD(registers); |
sensitive_pos << clk; |
sensitive_neg << reset; |
|
SC_METHOD(sub); |
sensitive << decrypt_i << start_i << state << data_i << sbox_data_i << data_reg; |
|
} |
}; |
/trunk/rtl/systemc/aes192lowarea/aesfunctions.h
0,0 → 1,761
#ifndef _AES_H |
#define _AES_H |
|
#ifndef uint8 |
#define uint8 unsigned char |
#endif |
|
#ifndef uint32 |
#define uint32 unsigned long int |
#endif |
|
typedef struct |
{ |
uint32 erk[64]; /* encryption round keys */ |
uint32 drk[64]; /* decryption round keys */ |
int nr; /* number of rounds */ |
} |
aes_context; |
|
int aes_set_key( aes_context *ctx, uint8 *key, int nbits ); |
void aes_encrypt( aes_context *ctx, uint8 input[16], uint8 output[16] ); |
void aes_decrypt( aes_context *ctx, uint8 input[16], uint8 output[16] ); |
|
#endif /* aes.h */ |
|
|
#define FIXED_TABLES |
|
#ifndef FIXED_TABLES |
|
/* forward S-box & tables */ |
|
uint32 FSb[256]; |
uint32 FT0[256]; |
uint32 FT1[256]; |
uint32 FT2[256]; |
uint32 FT3[256]; |
|
/* reverse S-box & tables */ |
|
uint32 RSb[256]; |
uint32 RT0[256]; |
uint32 RT1[256]; |
uint32 RT2[256]; |
uint32 RT3[256]; |
|
/* round constants */ |
|
uint32 RCON[10]; |
|
/* tables generation flag */ |
|
int do_init = 1; |
|
/* tables generation routine */ |
|
#define ROTR8(x) ( ( ( x << 24 ) & 0xFFFFFFFF ) | \ |
( ( x & 0xFFFFFFFF ) >> 8 ) ) |
|
#define XTIME(x) ( ( x << 1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) ) |
#define MUL(x,y) ( ( x && y ) ? pow[(log[x] + log[y]) % 255] : 0 ) |
|
void aes_gen_tables( void ) |
{ |
int i; |
uint8 x, y; |
uint8 pow[256]; |
uint8 log[256]; |
|
/* compute pow and log tables over GF(2^8) */ |
|
for( i = 0, x = 1; i < 256; i++, x ^= XTIME( x ) ) |
{ |
pow[i] = x; |
log[x] = i; |
} |
|
/* calculate the round constants */ |
|
for( i = 0, x = 1; i < 10; i++, x = XTIME( x ) ) |
{ |
RCON[i] = (uint32) x << 24; |
} |
|
/* generate the forward and reverse S-boxes */ |
|
FSb[0x00] = 0x63; |
RSb[0x63] = 0x00; |
|
for( i = 1; i < 256; i++ ) |
{ |
x = pow[255 - log[i]]; |
|
y = x; y = ( y << 1 ) | ( y >> 7 ); |
x ^= y; y = ( y << 1 ) | ( y >> 7 ); |
x ^= y; y = ( y << 1 ) | ( y >> 7 ); |
x ^= y; y = ( y << 1 ) | ( y >> 7 ); |
x ^= y ^ 0x63; |
|
FSb[i] = x; |
RSb[x] = i; |
} |
|
/* generate the forward and reverse tables */ |
|
for( i = 0; i < 256; i++ ) |
{ |
x = (unsigned char) FSb[i]; y = XTIME( x ); |
|
FT0[i] = (uint32) ( x ^ y ) ^ |
( (uint32) x << 8 ) ^ |
( (uint32) x << 16 ) ^ |
( (uint32) y << 24 ); |
|
FT0[i] &= 0xFFFFFFFF; |
|
FT1[i] = ROTR8( FT0[i] ); |
FT2[i] = ROTR8( FT1[i] ); |
FT3[i] = ROTR8( FT2[i] ); |
|
y = (unsigned char) RSb[i]; |
|
RT0[i] = ( (uint32) MUL( 0x0B, y ) ) ^ |
( (uint32) MUL( 0x0D, y ) << 8 ) ^ |
( (uint32) MUL( 0x09, y ) << 16 ) ^ |
( (uint32) MUL( 0x0E, y ) << 24 ); |
|
RT0[i] &= 0xFFFFFFFF; |
|
RT1[i] = ROTR8( RT0[i] ); |
RT2[i] = ROTR8( RT1[i] ); |
RT3[i] = ROTR8( RT2[i] ); |
} |
} |
|
#else |
|
/* forward S-box */ |
|
static const uint32 FSb[256] = |
{ |
0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, |
0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76, |
0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, |
0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, |
0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, |
0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15, |
0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, |
0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75, |
0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, |
0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, |
0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, |
0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, |
0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, |
0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8, |
0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, |
0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, |
0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, |
0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73, |
0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, |
0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB, |
0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, |
0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, |
0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, |
0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08, |
0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, |
0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, |
0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, |
0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, |
0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, |
0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF, |
0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, |
0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16 |
}; |
|
/* forward tables */ |
|
#define FT \ |
\ |
V(C6,63,63,A5), V(F8,7C,7C,84), V(EE,77,77,99), V(F6,7B,7B,8D), \ |
V(FF,F2,F2,0D), V(D6,6B,6B,BD), V(DE,6F,6F,B1), V(91,C5,C5,54), \ |
V(60,30,30,50), V(02,01,01,03), V(CE,67,67,A9), V(56,2B,2B,7D), \ |
V(E7,FE,FE,19), V(B5,D7,D7,62), V(4D,AB,AB,E6), V(EC,76,76,9A), \ |
V(8F,CA,CA,45), V(1F,82,82,9D), V(89,C9,C9,40), V(FA,7D,7D,87), \ |
V(EF,FA,FA,15), V(B2,59,59,EB), V(8E,47,47,C9), V(FB,F0,F0,0B), \ |
V(41,AD,AD,EC), V(B3,D4,D4,67), V(5F,A2,A2,FD), V(45,AF,AF,EA), \ |
V(23,9C,9C,BF), V(53,A4,A4,F7), V(E4,72,72,96), V(9B,C0,C0,5B), \ |
V(75,B7,B7,C2), V(E1,FD,FD,1C), V(3D,93,93,AE), V(4C,26,26,6A), \ |
V(6C,36,36,5A), V(7E,3F,3F,41), V(F5,F7,F7,02), V(83,CC,CC,4F), \ |
V(68,34,34,5C), V(51,A5,A5,F4), V(D1,E5,E5,34), V(F9,F1,F1,08), \ |
V(E2,71,71,93), V(AB,D8,D8,73), V(62,31,31,53), V(2A,15,15,3F), \ |
V(08,04,04,0C), V(95,C7,C7,52), V(46,23,23,65), V(9D,C3,C3,5E), \ |
V(30,18,18,28), V(37,96,96,A1), V(0A,05,05,0F), V(2F,9A,9A,B5), \ |
V(0E,07,07,09), V(24,12,12,36), V(1B,80,80,9B), V(DF,E2,E2,3D), \ |
V(CD,EB,EB,26), V(4E,27,27,69), V(7F,B2,B2,CD), V(EA,75,75,9F), \ |
V(12,09,09,1B), V(1D,83,83,9E), V(58,2C,2C,74), V(34,1A,1A,2E), \ |
V(36,1B,1B,2D), V(DC,6E,6E,B2), V(B4,5A,5A,EE), V(5B,A0,A0,FB), \ |
V(A4,52,52,F6), V(76,3B,3B,4D), V(B7,D6,D6,61), V(7D,B3,B3,CE), \ |
V(52,29,29,7B), V(DD,E3,E3,3E), V(5E,2F,2F,71), V(13,84,84,97), \ |
V(A6,53,53,F5), V(B9,D1,D1,68), V(00,00,00,00), V(C1,ED,ED,2C), \ |
V(40,20,20,60), V(E3,FC,FC,1F), V(79,B1,B1,C8), V(B6,5B,5B,ED), \ |
V(D4,6A,6A,BE), V(8D,CB,CB,46), V(67,BE,BE,D9), V(72,39,39,4B), \ |
V(94,4A,4A,DE), V(98,4C,4C,D4), V(B0,58,58,E8), V(85,CF,CF,4A), \ |
V(BB,D0,D0,6B), V(C5,EF,EF,2A), V(4F,AA,AA,E5), V(ED,FB,FB,16), \ |
V(86,43,43,C5), V(9A,4D,4D,D7), V(66,33,33,55), V(11,85,85,94), \ |
V(8A,45,45,CF), V(E9,F9,F9,10), V(04,02,02,06), V(FE,7F,7F,81), \ |
V(A0,50,50,F0), V(78,3C,3C,44), V(25,9F,9F,BA), V(4B,A8,A8,E3), \ |
V(A2,51,51,F3), V(5D,A3,A3,FE), V(80,40,40,C0), V(05,8F,8F,8A), \ |
V(3F,92,92,AD), V(21,9D,9D,BC), V(70,38,38,48), V(F1,F5,F5,04), \ |
V(63,BC,BC,DF), V(77,B6,B6,C1), V(AF,DA,DA,75), V(42,21,21,63), \ |
V(20,10,10,30), V(E5,FF,FF,1A), V(FD,F3,F3,0E), V(BF,D2,D2,6D), \ |
V(81,CD,CD,4C), V(18,0C,0C,14), V(26,13,13,35), V(C3,EC,EC,2F), \ |
V(BE,5F,5F,E1), V(35,97,97,A2), V(88,44,44,CC), V(2E,17,17,39), \ |
V(93,C4,C4,57), V(55,A7,A7,F2), V(FC,7E,7E,82), V(7A,3D,3D,47), \ |
V(C8,64,64,AC), V(BA,5D,5D,E7), V(32,19,19,2B), V(E6,73,73,95), \ |
V(C0,60,60,A0), V(19,81,81,98), V(9E,4F,4F,D1), V(A3,DC,DC,7F), \ |
V(44,22,22,66), V(54,2A,2A,7E), V(3B,90,90,AB), V(0B,88,88,83), \ |
V(8C,46,46,CA), V(C7,EE,EE,29), V(6B,B8,B8,D3), V(28,14,14,3C), \ |
V(A7,DE,DE,79), V(BC,5E,5E,E2), V(16,0B,0B,1D), V(AD,DB,DB,76), \ |
V(DB,E0,E0,3B), V(64,32,32,56), V(74,3A,3A,4E), V(14,0A,0A,1E), \ |
V(92,49,49,DB), V(0C,06,06,0A), V(48,24,24,6C), V(B8,5C,5C,E4), \ |
V(9F,C2,C2,5D), V(BD,D3,D3,6E), V(43,AC,AC,EF), V(C4,62,62,A6), \ |
V(39,91,91,A8), V(31,95,95,A4), V(D3,E4,E4,37), V(F2,79,79,8B), \ |
V(D5,E7,E7,32), V(8B,C8,C8,43), V(6E,37,37,59), V(DA,6D,6D,B7), \ |
V(01,8D,8D,8C), V(B1,D5,D5,64), V(9C,4E,4E,D2), V(49,A9,A9,E0), \ |
V(D8,6C,6C,B4), V(AC,56,56,FA), V(F3,F4,F4,07), V(CF,EA,EA,25), \ |
V(CA,65,65,AF), V(F4,7A,7A,8E), V(47,AE,AE,E9), V(10,08,08,18), \ |
V(6F,BA,BA,D5), V(F0,78,78,88), V(4A,25,25,6F), V(5C,2E,2E,72), \ |
V(38,1C,1C,24), V(57,A6,A6,F1), V(73,B4,B4,C7), V(97,C6,C6,51), \ |
V(CB,E8,E8,23), V(A1,DD,DD,7C), V(E8,74,74,9C), V(3E,1F,1F,21), \ |
V(96,4B,4B,DD), V(61,BD,BD,DC), V(0D,8B,8B,86), V(0F,8A,8A,85), \ |
V(E0,70,70,90), V(7C,3E,3E,42), V(71,B5,B5,C4), V(CC,66,66,AA), \ |
V(90,48,48,D8), V(06,03,03,05), V(F7,F6,F6,01), V(1C,0E,0E,12), \ |
V(C2,61,61,A3), V(6A,35,35,5F), V(AE,57,57,F9), V(69,B9,B9,D0), \ |
V(17,86,86,91), V(99,C1,C1,58), V(3A,1D,1D,27), V(27,9E,9E,B9), \ |
V(D9,E1,E1,38), V(EB,F8,F8,13), V(2B,98,98,B3), V(22,11,11,33), \ |
V(D2,69,69,BB), V(A9,D9,D9,70), V(07,8E,8E,89), V(33,94,94,A7), \ |
V(2D,9B,9B,B6), V(3C,1E,1E,22), V(15,87,87,92), V(C9,E9,E9,20), \ |
V(87,CE,CE,49), V(AA,55,55,FF), V(50,28,28,78), V(A5,DF,DF,7A), \ |
V(03,8C,8C,8F), V(59,A1,A1,F8), V(09,89,89,80), V(1A,0D,0D,17), \ |
V(65,BF,BF,DA), V(D7,E6,E6,31), V(84,42,42,C6), V(D0,68,68,B8), \ |
V(82,41,41,C3), V(29,99,99,B0), V(5A,2D,2D,77), V(1E,0F,0F,11), \ |
V(7B,B0,B0,CB), V(A8,54,54,FC), V(6D,BB,BB,D6), V(2C,16,16,3A) |
|
#define V(a,b,c,d) 0x##a##b##c##d |
static const uint32 FT0[256] = { FT }; |
#undef V |
|
#define V(a,b,c,d) 0x##d##a##b##c |
static const uint32 FT1[256] = { FT }; |
#undef V |
|
#define V(a,b,c,d) 0x##c##d##a##b |
static const uint32 FT2[256] = { FT }; |
#undef V |
|
#define V(a,b,c,d) 0x##b##c##d##a |
static const uint32 FT3[256] = { FT }; |
#undef V |
|
#undef FT |
|
/* reverse S-box */ |
|
static const uint32 RSb[256] = |
{ |
0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, |
0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB, |
0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, |
0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB, |
0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, |
0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E, |
0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, |
0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25, |
0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, |
0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92, |
0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, |
0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84, |
0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, |
0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06, |
0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, |
0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B, |
0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, |
0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73, |
0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, |
0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E, |
0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, |
0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B, |
0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, |
0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4, |
0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, |
0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F, |
0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, |
0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF, |
0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, |
0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61, |
0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, |
0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D |
}; |
|
/* reverse tables */ |
|
#define RT \ |
\ |
V(51,F4,A7,50), V(7E,41,65,53), V(1A,17,A4,C3), V(3A,27,5E,96), \ |
V(3B,AB,6B,CB), V(1F,9D,45,F1), V(AC,FA,58,AB), V(4B,E3,03,93), \ |
V(20,30,FA,55), V(AD,76,6D,F6), V(88,CC,76,91), V(F5,02,4C,25), \ |
V(4F,E5,D7,FC), V(C5,2A,CB,D7), V(26,35,44,80), V(B5,62,A3,8F), \ |
V(DE,B1,5A,49), V(25,BA,1B,67), V(45,EA,0E,98), V(5D,FE,C0,E1), \ |
V(C3,2F,75,02), V(81,4C,F0,12), V(8D,46,97,A3), V(6B,D3,F9,C6), \ |
V(03,8F,5F,E7), V(15,92,9C,95), V(BF,6D,7A,EB), V(95,52,59,DA), \ |
V(D4,BE,83,2D), V(58,74,21,D3), V(49,E0,69,29), V(8E,C9,C8,44), \ |
V(75,C2,89,6A), V(F4,8E,79,78), V(99,58,3E,6B), V(27,B9,71,DD), \ |
V(BE,E1,4F,B6), V(F0,88,AD,17), V(C9,20,AC,66), V(7D,CE,3A,B4), \ |
V(63,DF,4A,18), V(E5,1A,31,82), V(97,51,33,60), V(62,53,7F,45), \ |
V(B1,64,77,E0), V(BB,6B,AE,84), V(FE,81,A0,1C), V(F9,08,2B,94), \ |
V(70,48,68,58), V(8F,45,FD,19), V(94,DE,6C,87), V(52,7B,F8,B7), \ |
V(AB,73,D3,23), V(72,4B,02,E2), V(E3,1F,8F,57), V(66,55,AB,2A), \ |
V(B2,EB,28,07), V(2F,B5,C2,03), V(86,C5,7B,9A), V(D3,37,08,A5), \ |
V(30,28,87,F2), V(23,BF,A5,B2), V(02,03,6A,BA), V(ED,16,82,5C), \ |
V(8A,CF,1C,2B), V(A7,79,B4,92), V(F3,07,F2,F0), V(4E,69,E2,A1), \ |
V(65,DA,F4,CD), V(06,05,BE,D5), V(D1,34,62,1F), V(C4,A6,FE,8A), \ |
V(34,2E,53,9D), V(A2,F3,55,A0), V(05,8A,E1,32), V(A4,F6,EB,75), \ |
V(0B,83,EC,39), V(40,60,EF,AA), V(5E,71,9F,06), V(BD,6E,10,51), \ |
V(3E,21,8A,F9), V(96,DD,06,3D), V(DD,3E,05,AE), V(4D,E6,BD,46), \ |
V(91,54,8D,B5), V(71,C4,5D,05), V(04,06,D4,6F), V(60,50,15,FF), \ |
V(19,98,FB,24), V(D6,BD,E9,97), V(89,40,43,CC), V(67,D9,9E,77), \ |
V(B0,E8,42,BD), V(07,89,8B,88), V(E7,19,5B,38), V(79,C8,EE,DB), \ |
V(A1,7C,0A,47), V(7C,42,0F,E9), V(F8,84,1E,C9), V(00,00,00,00), \ |
V(09,80,86,83), V(32,2B,ED,48), V(1E,11,70,AC), V(6C,5A,72,4E), \ |
V(FD,0E,FF,FB), V(0F,85,38,56), V(3D,AE,D5,1E), V(36,2D,39,27), \ |
V(0A,0F,D9,64), V(68,5C,A6,21), V(9B,5B,54,D1), V(24,36,2E,3A), \ |
V(0C,0A,67,B1), V(93,57,E7,0F), V(B4,EE,96,D2), V(1B,9B,91,9E), \ |
V(80,C0,C5,4F), V(61,DC,20,A2), V(5A,77,4B,69), V(1C,12,1A,16), \ |
V(E2,93,BA,0A), V(C0,A0,2A,E5), V(3C,22,E0,43), V(12,1B,17,1D), \ |
V(0E,09,0D,0B), V(F2,8B,C7,AD), V(2D,B6,A8,B9), V(14,1E,A9,C8), \ |
V(57,F1,19,85), V(AF,75,07,4C), V(EE,99,DD,BB), V(A3,7F,60,FD), \ |
V(F7,01,26,9F), V(5C,72,F5,BC), V(44,66,3B,C5), V(5B,FB,7E,34), \ |
V(8B,43,29,76), V(CB,23,C6,DC), V(B6,ED,FC,68), V(B8,E4,F1,63), \ |
V(D7,31,DC,CA), V(42,63,85,10), V(13,97,22,40), V(84,C6,11,20), \ |
V(85,4A,24,7D), V(D2,BB,3D,F8), V(AE,F9,32,11), V(C7,29,A1,6D), \ |
V(1D,9E,2F,4B), V(DC,B2,30,F3), V(0D,86,52,EC), V(77,C1,E3,D0), \ |
V(2B,B3,16,6C), V(A9,70,B9,99), V(11,94,48,FA), V(47,E9,64,22), \ |
V(A8,FC,8C,C4), V(A0,F0,3F,1A), V(56,7D,2C,D8), V(22,33,90,EF), \ |
V(87,49,4E,C7), V(D9,38,D1,C1), V(8C,CA,A2,FE), V(98,D4,0B,36), \ |
V(A6,F5,81,CF), V(A5,7A,DE,28), V(DA,B7,8E,26), V(3F,AD,BF,A4), \ |
V(2C,3A,9D,E4), V(50,78,92,0D), V(6A,5F,CC,9B), V(54,7E,46,62), \ |
V(F6,8D,13,C2), V(90,D8,B8,E8), V(2E,39,F7,5E), V(82,C3,AF,F5), \ |
V(9F,5D,80,BE), V(69,D0,93,7C), V(6F,D5,2D,A9), V(CF,25,12,B3), \ |
V(C8,AC,99,3B), V(10,18,7D,A7), V(E8,9C,63,6E), V(DB,3B,BB,7B), \ |
V(CD,26,78,09), V(6E,59,18,F4), V(EC,9A,B7,01), V(83,4F,9A,A8), \ |
V(E6,95,6E,65), V(AA,FF,E6,7E), V(21,BC,CF,08), V(EF,15,E8,E6), \ |
V(BA,E7,9B,D9), V(4A,6F,36,CE), V(EA,9F,09,D4), V(29,B0,7C,D6), \ |
V(31,A4,B2,AF), V(2A,3F,23,31), V(C6,A5,94,30), V(35,A2,66,C0), \ |
V(74,4E,BC,37), V(FC,82,CA,A6), V(E0,90,D0,B0), V(33,A7,D8,15), \ |
V(F1,04,98,4A), V(41,EC,DA,F7), V(7F,CD,50,0E), V(17,91,F6,2F), \ |
V(76,4D,D6,8D), V(43,EF,B0,4D), V(CC,AA,4D,54), V(E4,96,04,DF), \ |
V(9E,D1,B5,E3), V(4C,6A,88,1B), V(C1,2C,1F,B8), V(46,65,51,7F), \ |
V(9D,5E,EA,04), V(01,8C,35,5D), V(FA,87,74,73), V(FB,0B,41,2E), \ |
V(B3,67,1D,5A), V(92,DB,D2,52), V(E9,10,56,33), V(6D,D6,47,13), \ |
V(9A,D7,61,8C), V(37,A1,0C,7A), V(59,F8,14,8E), V(EB,13,3C,89), \ |
V(CE,A9,27,EE), V(B7,61,C9,35), V(E1,1C,E5,ED), V(7A,47,B1,3C), \ |
V(9C,D2,DF,59), V(55,F2,73,3F), V(18,14,CE,79), V(73,C7,37,BF), \ |
V(53,F7,CD,EA), V(5F,FD,AA,5B), V(DF,3D,6F,14), V(78,44,DB,86), \ |
V(CA,AF,F3,81), V(B9,68,C4,3E), V(38,24,34,2C), V(C2,A3,40,5F), \ |
V(16,1D,C3,72), V(BC,E2,25,0C), V(28,3C,49,8B), V(FF,0D,95,41), \ |
V(39,A8,01,71), V(08,0C,B3,DE), V(D8,B4,E4,9C), V(64,56,C1,90), \ |
V(7B,CB,84,61), V(D5,32,B6,70), V(48,6C,5C,74), V(D0,B8,57,42) |
|
#define V(a,b,c,d) 0x##a##b##c##d |
static const uint32 RT0[256] = { RT }; |
#undef V |
|
#define V(a,b,c,d) 0x##d##a##b##c |
static const uint32 RT1[256] = { RT }; |
#undef V |
|
#define V(a,b,c,d) 0x##c##d##a##b |
static const uint32 RT2[256] = { RT }; |
#undef V |
|
#define V(a,b,c,d) 0x##b##c##d##a |
static const uint32 RT3[256] = { RT }; |
#undef V |
|
#undef RT |
|
/* round constants */ |
|
static const uint32 RCON[10] = |
{ |
0x01000000, 0x02000000, 0x04000000, 0x08000000, |
0x10000000, 0x20000000, 0x40000000, 0x80000000, |
0x1B000000, 0x36000000 |
}; |
|
int do_init = 0; |
|
void aes_gen_tables( void ) |
{ |
} |
|
#endif |
|
/* platform-independant 32-bit integer manipulation macros */ |
|
#define GET_UINT32(n,b,i) \ |
{ \ |
(n) = ( (uint32) (b)[(i) ] << 24 ) \ |
| ( (uint32) (b)[(i) + 1] << 16 ) \ |
| ( (uint32) (b)[(i) + 2] << 8 ) \ |
| ( (uint32) (b)[(i) + 3] ); \ |
} |
|
#define PUT_UINT32(n,b,i) \ |
{ \ |
(b)[(i) ] = (uint8) ( (n) >> 24 ); \ |
(b)[(i) + 1] = (uint8) ( (n) >> 16 ); \ |
(b)[(i) + 2] = (uint8) ( (n) >> 8 ); \ |
(b)[(i) + 3] = (uint8) ( (n) ); \ |
} |
|
/* decryption key schedule tables */ |
|
int KT_init = 1; |
|
uint32 KT0[256]; |
uint32 KT1[256]; |
uint32 KT2[256]; |
uint32 KT3[256]; |
|
/* AES key scheduling routine */ |
|
int aes_set_key( aes_context *ctx, uint8 *key, int nbits ) |
{ |
int i; |
uint32 *RK, *SK; |
|
if( do_init ) |
{ |
aes_gen_tables(); |
|
do_init = 0; |
} |
|
switch( nbits ) |
{ |
case 128: ctx->nr = 10; break; |
case 192: ctx->nr = 12; break; |
case 256: ctx->nr = 14; break; |
default : return( 1 ); |
} |
|
RK = ctx->erk; |
|
for( i = 0; i < (nbits >> 5); i++ ) |
{ |
GET_UINT32( RK[i], key, i * 4 ); |
} |
|
/* setup encryption round keys */ |
|
switch( nbits ) |
{ |
case 128: |
|
for( i = 0; i < 10; i++, RK += 4 ) |
{ |
RK[4] = RK[0] ^ RCON[i] ^ |
( FSb[ (uint8) ( RK[3] >> 16 ) ] << 24 ) ^ |
( FSb[ (uint8) ( RK[3] >> 8 ) ] << 16 ) ^ |
( FSb[ (uint8) ( RK[3] ) ] << 8 ) ^ |
( FSb[ (uint8) ( RK[3] >> 24 ) ] ); |
|
RK[5] = RK[1] ^ RK[4]; |
RK[6] = RK[2] ^ RK[5]; |
RK[7] = RK[3] ^ RK[6]; |
} |
break; |
|
case 192: |
|
for( i = 0; i < 8; i++, RK += 6 ) |
{ |
RK[6] = RK[0] ^ RCON[i] ^ |
( FSb[ (uint8) ( RK[5] >> 16 ) ] << 24 ) ^ |
( FSb[ (uint8) ( RK[5] >> 8 ) ] << 16 ) ^ |
( FSb[ (uint8) ( RK[5] ) ] << 8 ) ^ |
( FSb[ (uint8) ( RK[5] >> 24 ) ] ); |
|
RK[7] = RK[1] ^ RK[6]; |
RK[8] = RK[2] ^ RK[7]; |
RK[9] = RK[3] ^ RK[8]; |
RK[10] = RK[4] ^ RK[9]; |
RK[11] = RK[5] ^ RK[10]; |
} |
break; |
|
case 256: |
|
for( i = 0; i < 7; i++, RK += 8 ) |
{ |
RK[8] = RK[0] ^ RCON[i] ^ |
( FSb[ (uint8) ( RK[7] >> 16 ) ] << 24 ) ^ |
( FSb[ (uint8) ( RK[7] >> 8 ) ] << 16 ) ^ |
( FSb[ (uint8) ( RK[7] ) ] << 8 ) ^ |
( FSb[ (uint8) ( RK[7] >> 24 ) ] ); |
|
RK[9] = RK[1] ^ RK[8]; |
RK[10] = RK[2] ^ RK[9]; |
RK[11] = RK[3] ^ RK[10]; |
|
RK[12] = RK[4] ^ |
( FSb[ (uint8) ( RK[11] >> 24 ) ] << 24 ) ^ |
( FSb[ (uint8) ( RK[11] >> 16 ) ] << 16 ) ^ |
( FSb[ (uint8) ( RK[11] >> 8 ) ] << 8 ) ^ |
( FSb[ (uint8) ( RK[11] ) ] ); |
|
RK[13] = RK[5] ^ RK[12]; |
RK[14] = RK[6] ^ RK[13]; |
RK[15] = RK[7] ^ RK[14]; |
} |
break; |
} |
|
/* setup decryption round keys */ |
|
if( KT_init ) |
{ |
for( i = 0; i < 256; i++ ) |
{ |
KT0[i] = RT0[ FSb[i] ]; |
KT1[i] = RT1[ FSb[i] ]; |
KT2[i] = RT2[ FSb[i] ]; |
KT3[i] = RT3[ FSb[i] ]; |
} |
|
KT_init = 0; |
} |
|
SK = ctx->drk; |
|
*SK++ = *RK++; |
*SK++ = *RK++; |
*SK++ = *RK++; |
*SK++ = *RK++; |
|
for( i = 1; i < ctx->nr; i++ ) |
{ |
RK -= 8; |
|
*SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^ |
KT1[ (uint8) ( *RK >> 16 ) ] ^ |
KT2[ (uint8) ( *RK >> 8 ) ] ^ |
KT3[ (uint8) ( *RK ) ]; RK++; |
|
*SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^ |
KT1[ (uint8) ( *RK >> 16 ) ] ^ |
KT2[ (uint8) ( *RK >> 8 ) ] ^ |
KT3[ (uint8) ( *RK ) ]; RK++; |
|
*SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^ |
KT1[ (uint8) ( *RK >> 16 ) ] ^ |
KT2[ (uint8) ( *RK >> 8 ) ] ^ |
KT3[ (uint8) ( *RK ) ]; RK++; |
|
*SK++ = KT0[ (uint8) ( *RK >> 24 ) ] ^ |
KT1[ (uint8) ( *RK >> 16 ) ] ^ |
KT2[ (uint8) ( *RK >> 8 ) ] ^ |
KT3[ (uint8) ( *RK ) ]; RK++; |
} |
|
RK -= 8; |
|
*SK++ = *RK++; |
*SK++ = *RK++; |
*SK++ = *RK++; |
*SK++ = *RK++; |
|
return( 0 ); |
} |
|
/* AES 128-bit block encryption routine */ |
|
void aes_encrypt( aes_context *ctx, uint8 input[16], uint8 output[16] ) |
{ |
uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3; |
|
RK = ctx->erk; |
|
GET_UINT32( X0, input, 0 ); X0 ^= RK[0]; |
GET_UINT32( X1, input, 4 ); X1 ^= RK[1]; |
GET_UINT32( X2, input, 8 ); X2 ^= RK[2]; |
GET_UINT32( X3, input, 12 ); X3 ^= RK[3]; |
|
#define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3) \ |
{ \ |
RK += 4; \ |
\ |
X0 = RK[0] ^ FT0[ (uint8) ( Y0 >> 24 ) ] ^ \ |
FT1[ (uint8) ( Y1 >> 16 ) ] ^ \ |
FT2[ (uint8) ( Y2 >> 8 ) ] ^ \ |
FT3[ (uint8) ( Y3 ) ]; \ |
\ |
X1 = RK[1] ^ FT0[ (uint8) ( Y1 >> 24 ) ] ^ \ |
FT1[ (uint8) ( Y2 >> 16 ) ] ^ \ |
FT2[ (uint8) ( Y3 >> 8 ) ] ^ \ |
FT3[ (uint8) ( Y0 ) ]; \ |
\ |
X2 = RK[2] ^ FT0[ (uint8) ( Y2 >> 24 ) ] ^ \ |
FT1[ (uint8) ( Y3 >> 16 ) ] ^ \ |
FT2[ (uint8) ( Y0 >> 8 ) ] ^ \ |
FT3[ (uint8) ( Y1 ) ]; \ |
\ |
X3 = RK[3] ^ FT0[ (uint8) ( Y3 >> 24 ) ] ^ \ |
FT1[ (uint8) ( Y0 >> 16 ) ] ^ \ |
FT2[ (uint8) ( Y1 >> 8 ) ] ^ \ |
FT3[ (uint8) ( Y2 ) ]; \ |
} |
|
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 1 */ |
AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); /* round 2 */ |
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 3 */ |
AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); /* round 4 */ |
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 5 */ |
AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); /* round 6 */ |
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 7 */ |
AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); /* round 8 */ |
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 9 */ |
|
if( ctx->nr > 10 ) |
{ |
AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); /* round 10 */ |
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 11 */ |
} |
|
if( ctx->nr > 12 ) |
{ |
AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); /* round 12 */ |
AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 13 */ |
} |
|
/* last round */ |
|
RK += 4; |
|
X0 = RK[0] ^ ( FSb[ (uint8) ( Y0 >> 24 ) ] << 24 ) ^ |
( FSb[ (uint8) ( Y1 >> 16 ) ] << 16 ) ^ |
( FSb[ (uint8) ( Y2 >> 8 ) ] << 8 ) ^ |
( FSb[ (uint8) ( Y3 ) ] ); |
|
X1 = RK[1] ^ ( FSb[ (uint8) ( Y1 >> 24 ) ] << 24 ) ^ |
( FSb[ (uint8) ( Y2 >> 16 ) ] << 16 ) ^ |
( FSb[ (uint8) ( Y3 >> 8 ) ] << 8 ) ^ |
( FSb[ (uint8) ( Y0 ) ] ); |
|
X2 = RK[2] ^ ( FSb[ (uint8) ( Y2 >> 24 ) ] << 24 ) ^ |
( FSb[ (uint8) ( Y3 >> 16 ) ] << 16 ) ^ |
( FSb[ (uint8) ( Y0 >> 8 ) ] << 8 ) ^ |
( FSb[ (uint8) ( Y1 ) ] ); |
|
X3 = RK[3] ^ ( FSb[ (uint8) ( Y3 >> 24 ) ] << 24 ) ^ |
( FSb[ (uint8) ( Y0 >> 16 ) ] << 16 ) ^ |
( FSb[ (uint8) ( Y1 >> 8 ) ] << 8 ) ^ |
( FSb[ (uint8) ( Y2 ) ] ); |
|
PUT_UINT32( X0, output, 0 ); |
PUT_UINT32( X1, output, 4 ); |
PUT_UINT32( X2, output, 8 ); |
PUT_UINT32( X3, output, 12 ); |
} |
|
/* AES 128-bit block decryption routine */ |
|
void aes_decrypt( aes_context *ctx, uint8 input[16], uint8 output[16] ) |
{ |
uint32 *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3; |
|
RK = ctx->drk; |
|
GET_UINT32( X0, input, 0 ); X0 ^= RK[0]; |
GET_UINT32( X1, input, 4 ); X1 ^= RK[1]; |
GET_UINT32( X2, input, 8 ); X2 ^= RK[2]; |
GET_UINT32( X3, input, 12 ); X3 ^= RK[3]; |
|
#define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3) \ |
{ \ |
RK += 4; \ |
\ |
X0 = RK[0] ^ RT0[ (uint8) ( Y0 >> 24 ) ] ^ \ |
RT1[ (uint8) ( Y3 >> 16 ) ] ^ \ |
RT2[ (uint8) ( Y2 >> 8 ) ] ^ \ |
RT3[ (uint8) ( Y1 ) ]; \ |
\ |
X1 = RK[1] ^ RT0[ (uint8) ( Y1 >> 24 ) ] ^ \ |
RT1[ (uint8) ( Y0 >> 16 ) ] ^ \ |
RT2[ (uint8) ( Y3 >> 8 ) ] ^ \ |
RT3[ (uint8) ( Y2 ) ]; \ |
\ |
X2 = RK[2] ^ RT0[ (uint8) ( Y2 >> 24 ) ] ^ \ |
RT1[ (uint8) ( Y1 >> 16 ) ] ^ \ |
RT2[ (uint8) ( Y0 >> 8 ) ] ^ \ |
RT3[ (uint8) ( Y3 ) ]; \ |
\ |
X3 = RK[3] ^ RT0[ (uint8) ( Y3 >> 24 ) ] ^ \ |
RT1[ (uint8) ( Y2 >> 16 ) ] ^ \ |
RT2[ (uint8) ( Y1 >> 8 ) ] ^ \ |
RT3[ (uint8) ( Y0 ) ]; \ |
} |
|
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 1 */ |
AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); /* round 2 */ |
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 3 */ |
AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); /* round 4 */ |
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 5 */ |
AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); /* round 6 */ |
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 7 */ |
AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); /* round 8 */ |
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 9 */ |
|
if( ctx->nr > 10 ) |
{ |
AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); /* round 10 */ |
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 11 */ |
} |
|
if( ctx->nr > 12 ) |
{ |
AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); /* round 12 */ |
AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); /* round 13 */ |
} |
|
/* last round */ |
|
RK += 4; |
|
X0 = RK[0] ^ ( RSb[ (uint8) ( Y0 >> 24 ) ] << 24 ) ^ |
( RSb[ (uint8) ( Y3 >> 16 ) ] << 16 ) ^ |
( RSb[ (uint8) ( Y2 >> 8 ) ] << 8 ) ^ |
( RSb[ (uint8) ( Y1 ) ] ); |
|
X1 = RK[1] ^ ( RSb[ (uint8) ( Y1 >> 24 ) ] << 24 ) ^ |
( RSb[ (uint8) ( Y0 >> 16 ) ] << 16 ) ^ |
( RSb[ (uint8) ( Y3 >> 8 ) ] << 8 ) ^ |
( RSb[ (uint8) ( Y2 ) ] ); |
|
X2 = RK[2] ^ ( RSb[ (uint8) ( Y2 >> 24 ) ] << 24 ) ^ |
( RSb[ (uint8) ( Y1 >> 16 ) ] << 16 ) ^ |
( RSb[ (uint8) ( Y0 >> 8 ) ] << 8 ) ^ |
( RSb[ (uint8) ( Y3 ) ] ); |
|
X3 = RK[3] ^ ( RSb[ (uint8) ( Y3 >> 24 ) ] << 24 ) ^ |
( RSb[ (uint8) ( Y2 >> 16 ) ] << 16 ) ^ |
( RSb[ (uint8) ( Y1 >> 8 ) ] << 8 ) ^ |
( RSb[ (uint8) ( Y0 ) ] ); |
|
PUT_UINT32( X0, output, 0 ); |
PUT_UINT32( X1, output, 4 ); |
PUT_UINT32( X2, output, 8 ); |
PUT_UINT32( X3, output, 12 ); |
} |
/trunk/rtl/systemc/aes192lowarea/aes.cpp
0,0 → 1,252
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES Top module //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// TOP module //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "aes.h" |
|
void aes::registers(){ |
if(!reset.read()){ |
state.write(IDLE); |
ready_o.write(0); |
round.write(0); |
addroundkey_round.write(0); |
addroundkey_data_reg.write(0); |
addroundkey_ready_o.write(0); |
addroundkey_start_i.write(0); |
first_round_reg.write(0); |
last_key_half.write(0); |
}else{ |
state.write(next_state.read()); |
ready_o.write(next_ready_o.read()); |
round.write(next_round.read()); |
addroundkey_round.write(next_addroundkey_round.read()); |
addroundkey_data_reg.write(next_addroundkey_data_reg.read()); |
addroundkey_ready_o.write(next_addroundkey_ready_o); |
first_round_reg.write(next_first_round_reg.read()); |
addroundkey_start_i.write(next_addroundkey_start_i.read()); |
last_key_half.write(next_last_key_half.read()); |
} |
} |
|
|
void aes::addroundkey(){ |
sc_biguint<128> data_var,round_data_var,concat; |
sc_biguint<128> key; |
sc_uint<4> one,two,three,four; |
sc_uint<13> roundvalue; |
|
one=round.read()-1; |
two=round.read()-2; |
three=round.read()-3; |
four=round.read()-4; |
|
roundvalue=0; |
roundvalue[(int)round.read()]=true; |
|
data_var=addroundkey_data_i.read(); |
round_data_var=addroundkey_data_reg.read(); |
next_addroundkey_data_reg.write(addroundkey_data_reg.read()); |
next_addroundkey_ready_o.write(0); |
next_addroundkey_round.write(addroundkey_round.read()); |
next_last_key_half.write(last_key_half.read()); |
addroundkey_data_o.write(addroundkey_data_reg.read()); |
keysched_start_i.write(0); |
keysched_round_i.write(addroundkey_round.read()); |
|
if(addroundkey_round.read()==1 || addroundkey_round.read()==0) |
keysched_last_key_i.write(key_i.read()); |
else |
keysched_last_key_i.write(keysched_new_key_o.read()); |
|
|
if(round.read()==0 && addroundkey_start_i.read()){ |
//Take the input and xor them with data if round==0; |
round_data_var=key_i.read().range(191,64)^data_var; |
next_addroundkey_data_reg.write(round_data_var); |
next_addroundkey_ready_o.write(1); |
next_last_key_half.write((sc_uint<64>)key_i.read().range(63,0)); |
}else if(addroundkey_start_i.read() && round.read()!=0){ |
//Calculate the round i key |
keysched_last_key_i.write(key_i.read()); |
keysched_start_i.write(1); |
keysched_round_i.write(1); |
next_addroundkey_round.write(1); |
|
}else if( keysched_ready_o.read() && ( (addroundkey_round.read()==one && roundvalue[3]) |
|| (addroundkey_round.read()==two && roundvalue[6]) |
|| (addroundkey_round.read()==three && roundvalue[9]) |
|| (addroundkey_round.read()==four && roundvalue[12]))){ |
round_data_var=keysched_new_key_o.read().range(191,64)^data_var; |
next_addroundkey_data_reg.write(round_data_var); |
next_addroundkey_ready_o.write(1); |
next_addroundkey_round.write(0); |
next_last_key_half.write((sc_uint<64>)keysched_new_key_o.read().range(63,0)); |
}else if( keysched_ready_o.read() && ( (addroundkey_round.read()==one && roundvalue[2]) |
|| (addroundkey_round.read()==two && roundvalue[5]) |
|| (addroundkey_round.read()==three && roundvalue[8]) |
|| (addroundkey_round.read()==four && roundvalue[11]))){ |
round_data_var=keysched_new_key_o.read().range(127,0)^data_var; |
next_addroundkey_data_reg.write(round_data_var); |
next_addroundkey_ready_o.write(1); |
next_addroundkey_round.write(0); |
next_last_key_half.write((sc_uint<64>)keysched_new_key_o.read().range(63,0)); |
}else if( keysched_ready_o.read() && ( ((addroundkey_round.read()==one || roundvalue[1]) && (roundvalue[1] || roundvalue[4])) |
|| (addroundkey_round.read()==two && roundvalue[7]) |
|| (addroundkey_round.read()==three && roundvalue[10]))){ |
|
(round.read()==1)? concat.range(127,64)=(sc_uint<64>)key_i.read().range(63,0):concat.range(127,64)=(sc_uint<64>)last_key_half.read(); |
concat.range(63,0)=(sc_uint<64>)keysched_new_key_o.read().range(191,128); |
|
round_data_var=concat^data_var; |
next_addroundkey_data_reg.write(round_data_var); |
next_addroundkey_ready_o.write(1); |
next_addroundkey_round.write(0); |
next_last_key_half.write((sc_uint<64>)keysched_new_key_o.read().range(63,0)); |
}else if(keysched_ready_o.read()){ |
//Round key output but not the one we want |
next_addroundkey_round.write(addroundkey_round.read()+1); |
keysched_last_key_i.write(keysched_new_key_o.read()); |
keysched_start_i.write(1); |
keysched_round_i.write(addroundkey_round.read()+1); |
next_last_key_half.write((sc_uint<64>)keysched_new_key_o.read().range(63,0)); |
} |
} |
|
void aes::sbox_muxes(){ |
|
if(keysched_sbox_access_o.read()){ |
sbox_decrypt_i.write(keysched_sbox_decrypt_o.read()); |
sbox_data_i.write(keysched_sbox_data_o.read()); |
}else{ |
sbox_decrypt_i.write(subbytes_sbox_decrypt_o.read()); |
sbox_data_i.write(subbytes_sbox_data_o.read()); |
} |
} |
|
|
void aes::control(){ |
|
next_state.write(state.read()); |
next_round.write(round.read()); |
data_o.write(addroundkey_data_o.read()); |
next_ready_o.write(0); |
|
//To key schedule module |
|
next_first_round_reg.write(0); |
|
subbytes_data_i.write(0); |
mixcol_data_i.write(0); |
addroundkey_data_i.write(0); |
|
next_addroundkey_start_i.write(first_round_reg.read()); |
mixcol_start_i.write((addroundkey_ready_o.read() & decrypt_i.read() & round.read()!=12) | (subbytes_ready_o.read() & !decrypt_i.read())); |
subbytes_start_i.write((addroundkey_ready_o.read() & !decrypt_i.read()) | (mixcol_ready_o.read() & decrypt_i.read()) | (addroundkey_ready_o.read() & decrypt_i.read() & round.read()==12)); |
|
if(decrypt_i.read() && round.read()!=12){ |
addroundkey_data_i.write(subbytes_data_o.read()); |
subbytes_data_i.write(mixcol_data_o.read()); |
mixcol_data_i.write(addroundkey_data_o.read()); |
}else if(!decrypt_i.read() && round.read()!=0){ |
addroundkey_data_i.write(mixcol_data_o.read()); |
subbytes_data_i.write(addroundkey_data_o.read()); |
mixcol_data_i.write(subbytes_data_o.read()); |
}else{ |
mixcol_data_i.write(subbytes_data_o.read()); |
subbytes_data_i.write(addroundkey_data_o.read()); |
addroundkey_data_i.write(data_i.read()); |
} |
|
switch(state.read()){ |
|
case IDLE: |
if(load_i.read()){ |
next_state.write(ROUNDS); |
decrypt_i.read()?next_round.write(12):next_round.write(0); |
next_first_round_reg.write(1); |
} |
break; |
|
case ROUNDS: |
|
//Counter |
if(!decrypt_i.read() && mixcol_ready_o.read()){ |
next_addroundkey_start_i.write(1); |
addroundkey_data_i.write(mixcol_data_o.read()); |
next_round.write(round.read()+1); |
}else if(decrypt_i.read() && subbytes_ready_o.read()){ |
next_addroundkey_start_i.write(1); |
addroundkey_data_i.write(subbytes_data_o.read()); |
next_round.write(round.read()-1); |
} |
|
//Output |
if((round.read()==11 && !decrypt_i.read()) || (round.read()==0 && decrypt_i.read())){ |
next_addroundkey_start_i.write(0); |
mixcol_start_i.write(0); |
if(subbytes_ready_o.read()){ |
addroundkey_data_i.write(subbytes_data_o.read()); |
next_addroundkey_start_i.write(1); |
next_round.write(round.read()+1); |
} |
} |
if((round.read()==12 && !decrypt_i.read()) || (round.read()==0 && decrypt_i.read())){ |
addroundkey_data_i.write(subbytes_data_o.read()); |
subbytes_start_i.write(0); |
if(addroundkey_ready_o.read()){ |
next_ready_o.write(1); |
next_state.write(IDLE); |
next_addroundkey_start_i.write(0); |
next_round.write(0); |
} |
} |
|
break; |
|
default: |
next_state.write(IDLE); |
break; |
} |
} |
/trunk/rtl/systemc/aes192lowarea/checker.h
0,0 → 1,81
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Checker //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Check that the outputs from the RTL model and the C model //// |
//// used as golden model are the same //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
|
#include "systemc.h" |
|
SC_MODULE(checker){ |
|
sc_in<bool> reset; |
|
sc_fifo_in<sc_biguint<128> > rt_aes_data_i; |
sc_fifo_in<sc_biguint<128> > c_aes_data_i; |
|
void check(){ |
sc_biguint<128> rt_data_var,c_data_var; |
|
wait(reset->posedge_event()); |
|
while(1){ |
if(reset.read()){ |
rt_data_var=rt_aes_data_i.read(); |
c_data_var=c_aes_data_i.read(); |
if(rt_data_var!=c_data_var){ |
cout << "Simulation mismatch: 0x" << (int)(sc_uint<32>)rt_data_var.range(127,96) << (int)(sc_uint<32>)rt_data_var.range(95,64) << (int)(sc_uint<32>)rt_data_var.range(63,32) << (int)(sc_uint<32>)rt_data_var.range(31,0) << " 0x" << (int)(sc_uint<32>)c_data_var.range(127,96) << (int)(sc_uint<32>)c_data_var.range(95,64) << (int)(sc_uint<32>)c_data_var.range(63,32) << (int)(sc_uint<32>)c_data_var.range(31,0) << " " << sc_time_stamp() << endl; |
exit(0); |
}else{ |
cout << "OK: 0x" << (int)(sc_uint<32>)rt_data_var.range(127,96) << (int)(sc_uint<32>)rt_data_var.range(95,64) << (int)(sc_uint<32>)c_data_var.range(63,32) << (int)(sc_uint<32>)rt_data_var.range(31,0) << " 0x" << (int)(sc_uint<32>)c_data_var.range(127,96) << (int)(sc_uint<32>)c_data_var.range(95,64) << (int)(sc_uint<32>)c_data_var.range(63,32) << (int)(sc_uint<32>)c_data_var.range(31,0) << " " << sc_time_stamp() << endl; |
} |
}else |
wait(reset->posedge_event()); |
} |
} |
|
SC_CTOR(checker){ |
SC_THREAD(check); |
} |
}; |
/trunk/rtl/systemc/aes192lowarea/sbox.cpp
0,0 → 1,292
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES sbox module implementation //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// S-box calculation calculating inverse on gallois field //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "sbox.h" |
|
void sbox::registers(){ |
if(!reset.read()){ |
to_invert.write(0); |
ah_reg.write(0); |
alph.write(0); |
}else{ |
to_invert.write(next_to_invert.read()); |
ah_reg.write(next_ah_reg.read()); |
alph.write(next_alph.read()); |
} |
} |
|
void sbox::first_mux(){ |
sc_uint<8> data_var; |
sc_uint<8> InvInput; |
sc_uint<4> ah_t,al_t; |
bool aA,aB,aC,aD; |
|
data_var=data_i.read(); |
InvInput=data_var; |
|
switch(decrypt_i.read()){ |
case 1: |
//Apply inverse affine trasformation |
aA=data_var[0]^data_var[5]; aB=data_var[1]^data_var[4]; |
aC=data_var[2]^data_var[7]; aD=data_var[3]^data_var[6]; |
InvInput[0]=(!data_var[5])^aC; |
InvInput[1]=data_var[0]^aD; |
InvInput[2]=(!data_var[7])^aB; |
InvInput[3]=data_var[2]^aA; |
InvInput[4]=data_var[1]^aD; |
InvInput[5]=data_var[4]^aC; |
InvInput[6]=data_var[3]^aA; |
InvInput[7]=data_var[6]^aB; |
break; |
default: |
InvInput=data_var; |
break; |
} |
|
//Convert elements from GF(2^8) into two elements of GF(2^4^2) |
|
aA=InvInput[1]^InvInput[7]; |
aB=InvInput[5]^InvInput[7]; |
aC=InvInput[4]^InvInput[6]; |
|
|
al_t[0]=aC^InvInput[0]^InvInput[5]; |
al_t[1]=InvInput[1]^InvInput[2]; |
al_t[2]=aA; |
al_t[3]=InvInput[2]^InvInput[4]; |
|
ah_t[0]=aC^InvInput[5]; |
ah_t[1]=aA^aC; |
ah_t[2]=aB^InvInput[2]^InvInput[3]; |
ah_t[3]=aB; |
|
al.write(al_t); |
ah.write(ah_t); |
next_ah_reg.write(ah_t); |
} |
|
void sbox::end_mux(){ |
sc_uint<8> data_var,data_o_var; |
bool aA,aB,aC,aD; |
|
|
//Take the output of the inverter |
data_var=inva.read(); |
|
switch(decrypt_i.read()){ |
case 0: |
//Apply affine trasformation |
aA=data_var[0]^data_var[1]; aB=data_var[2]^data_var[3]; |
aC=data_var[4]^data_var[5]; aD=data_var[6]^data_var[7]; |
data_o_var[0]=(!data_var[0])^aC^aD; |
data_o_var[1]=(!data_var[5])^aA^aD; |
data_o_var[2]=data_var[2]^aA^aD; |
data_o_var[3]=data_var[7]^aA^aB; |
data_o_var[4]=data_var[4]^aA^aB; |
data_o_var[5]=(!data_var[1])^aB^aC; |
data_o_var[6]=(!data_var[6])^aB^aC; |
data_o_var[7]=data_var[3]^aC^aD; |
data_o.write(data_o_var); |
break; |
default: |
data_o.write(data_var); |
break; |
} |
|
} |
|
//Four operations in parallel |
void sbox::square1(){ |
sc_uint<4> ah_t; |
|
ah_t[0]=ah.read()[0]^ah.read()[2]; |
ah_t[1]=ah.read()[2]; |
ah_t[2]=ah.read()[1]^ah.read()[3]; |
ah_t[3]=ah.read()[3]; |
|
ah2.write(ah_t); |
} |
|
void sbox::square2(){ |
sc_uint<4> al_t; |
|
al_t[0]=al.read()[0]^al.read()[2]; |
al_t[1]=al.read()[2]; |
al_t[2]=al.read()[1]^al.read()[3]; |
al_t[3]=al.read()[3]; |
|
al2.write(al_t); |
} |
|
void sbox::mul1(){ |
//al x ah |
sc_uint<4> alxh_t; |
sc_uint<4> aA,aB; |
|
aA=al.read()[0]^al.read()[3]; |
aB=al.read()[2]^al.read()[3]; |
|
alxh_t[0]=(al.read()[0]&ah.read()[0])^(al.read()[3]&ah.read()[1])^(al.read()[2]&ah.read()[2])^(al.read()[1]&ah.read()[3]); |
alxh_t[1]=(al.read()[1]&ah.read()[0])^(aA&ah.read()[1])^(aB&ah.read()[2])^((al.read()[1]^al.read()[2])&ah.read()[3]); |
alxh_t[2]=(al.read()[2]&ah.read()[0])^(al.read()[1]&ah.read()[1])^(aA&ah.read()[2])^(aB&ah.read()[3]); |
alxh_t[3]=(al.read()[3]&ah.read()[0])^(al.read()[2]&ah.read()[1])^(al.read()[1]&ah.read()[2])^(aA&ah.read()[3]); |
|
alxh.write(alxh_t); |
} |
|
void sbox::sum1(){ |
sc_uint<4> alph_t; |
|
alph_t[0]=al.read()[0]^ah.read()[0]; |
alph_t[1]=al.read()[1]^ah.read()[1]; |
alph_t[2]=al.read()[2]^ah.read()[2]; |
alph_t[3]=al.read()[3]^ah.read()[3]; |
|
next_alph.write(alph_t); |
} |
|
//Secuential operations |
void sbox::intermediate(){ |
sc_uint<4> aA,aB; |
sc_uint<4> ah2e,ah2epl2,to_invert_var; |
|
//ah square is multiplied with e |
aA=ah2.read()[0]^ah2.read()[1]; |
aB=ah2.read()[2]^ah2.read()[3]; |
ah2e[0]=ah2.read()[1]^aB; |
ah2e[1]=aA; |
ah2e[2]=aA^ah2.read()[2]; |
ah2e[3]=aA^aB; |
|
//Addition of ah2e plus al2 |
ah2epl2[0]=ah2e[0]^al2.read()[0]; |
ah2epl2[1]=ah2e[1]^al2.read()[1]; |
ah2epl2[2]=ah2e[2]^al2.read()[2]; |
ah2epl2[3]=ah2e[3]^al2.read()[3]; |
|
//Addition of last result with the result of (al x ah) |
to_invert_var[0]=ah2epl2[0]^alxh.read()[0]; |
to_invert_var[1]=ah2epl2[1]^alxh.read()[1]; |
to_invert_var[2]=ah2epl2[2]^alxh.read()[2]; |
to_invert_var[3]=ah2epl2[3]^alxh.read()[3]; |
|
//Registers |
next_to_invert.write(to_invert_var); |
} |
|
|
void sbox::inversion(){ |
sc_uint<4> to_invert_var; |
sc_uint<4> aA,d_t; |
|
to_invert_var=to_invert.read(); |
|
//Invert the result in GF(2^4) |
aA=to_invert_var[1]^to_invert_var[2]^to_invert_var[3]^(to_invert_var[1]&to_invert_var[2]&to_invert_var[3]); |
d_t[0]=aA^to_invert_var[0]^(to_invert_var[0]&to_invert_var[2])^(to_invert_var[1]&to_invert_var[2])^(to_invert_var[0]&to_invert_var[1]&to_invert_var[2]); |
d_t[1]=(to_invert_var[0]&to_invert_var[1])^(to_invert_var[0]&to_invert_var[2])^(to_invert_var[1]&to_invert_var[2])^to_invert_var[3]^(to_invert_var[1]&to_invert_var[3])^(to_invert_var[0]&to_invert_var[1]&to_invert_var[3]); |
d_t[2]=(to_invert_var[0]&to_invert_var[1])^to_invert_var[2]^(to_invert_var[0]&to_invert_var[2])^to_invert_var[3]^(to_invert_var[0]&to_invert_var[3])^(to_invert_var[0]&to_invert_var[2]&to_invert_var[3]); |
d_t[3]=aA^(to_invert_var[0]&to_invert_var[3])^(to_invert_var[1]&to_invert_var[3])^(to_invert_var[2]&to_invert_var[3]); |
|
d.write(d_t); |
|
} |
|
void sbox::mul2(){ |
//ah x d |
sc_uint<4> ahp_t; |
sc_uint<4> aA,aB; |
|
aA=ah_reg.read()[0]^ah_reg.read()[3]; |
aB=ah_reg.read()[2]^ah_reg.read()[3]; |
|
ahp_t[0]=(ah_reg.read()[0]&d.read()[0])^(ah_reg.read()[3]&d.read()[1])^(ah_reg.read()[2]&d.read()[2])^(ah_reg.read()[1]&d.read()[3]); |
ahp_t[1]=(ah_reg.read()[1]&d.read()[0])^(aA&d.read()[1])^(aB&d.read()[2])^((ah_reg.read()[1]^ah_reg.read()[2])&d.read()[3]); |
ahp_t[2]=(ah_reg.read()[2]&d.read()[0])^(ah_reg.read()[1]&d.read()[1])^(aA&d.read()[2])^(aB&d.read()[3]); |
ahp_t[3]=(ah_reg.read()[3]&d.read()[0])^(ah_reg.read()[2]&d.read()[1])^(ah_reg.read()[1]&d.read()[2])^(aA&d.read()[3]); |
|
ahp.write(ahp_t); |
} |
|
void sbox::mul3(){ |
//d x al |
sc_uint<4> alp_t; |
sc_uint<4> aA,aB; |
|
aA=d.read()[0]^d.read()[3]; |
aB=d.read()[2]^d.read()[3]; |
|
alp_t[0]=(d.read()[0]&alph.read()[0])^(d.read()[3]&alph.read()[1])^(d.read()[2]&alph.read()[2])^(d.read()[1]&alph.read()[3]); |
alp_t[1]=(d.read()[1]&alph.read()[0])^(aA&alph.read()[1])^(aB&alph.read()[2])^((d.read()[1]^d.read()[2])&alph.read()[3]); |
alp_t[2]=(d.read()[2]&alph.read()[0])^(d.read()[1]&alph.read()[1])^(aA&alph.read()[2])^(aB&alph.read()[3]); |
alp_t[3]=(d.read()[3]&alph.read()[0])^(d.read()[2]&alph.read()[1])^(d.read()[1]&alph.read()[2])^(aA&alph.read()[3]); |
|
alp.write(alp_t); |
} |
|
//Convert again to GF(2^8); |
void sbox::inversemap(){ |
sc_uint<4> aA,aB; |
sc_uint<4> alp_t,ahp_t; |
sc_uint<8> inva_t; |
|
alp_t=alp.read(); |
ahp_t=ahp.read(); |
|
aA=alp_t[1]^ahp_t[3]; |
aB=ahp_t[0]^ahp_t[1]; |
|
inva_t[0]=alp_t[0]^ahp_t[0]; |
inva_t[1]=aB^ahp_t[3]; |
inva_t[2]=aA^aB; |
inva_t[3]=aB^alp_t[1]^ahp_t[2]; |
inva_t[4]=aA^aB^alp_t[3]; |
inva_t[5]=aB^alp_t[2]; |
inva_t[6]=aA^alp_t[2]^alp_t[3]^ahp_t[0]; |
inva_t[7]=aB^alp_t[2]^ahp_t[3]; |
|
inva.write(inva_t); |
} |
/trunk/rtl/systemc/aes192lowarea/Makefile.defs
0,0 → 1,35
## Variable that points to SystemC installation path |
SYSTEMC = $(SYSTEMC_HOME) |
SCV = $(SCV_HOME) |
|
INCDIR = -I. -I.. -I../../bench -I$(SYSTEMC)/include -I$(SCV)/include |
LIBDIR = -L. -L.. -L$(SYSTEMC)/lib-$(TARGET_ARCH) -L$(SCV)/lib-$(TARGET_ARCH) |
|
# Build with maximum gcc warning level |
CFLAGS = $(PLATFORM_SPECIFIC_FLAGS) $(EXTRA_CFLAGS) |
|
LIBS = -lm -lsystemc -lscv $(EXTRA_LIBS) |
|
EXE = $(MODULE).x |
|
.SUFFIXES: .cpp .cc .o .x |
|
$(EXE): $(OBJS) $(SYSTEMC)/lib-$(TARGET_ARCH)/libsystemc.a $(SCV)/lib-$(TARGET_ARCH)/libscv.a |
$(CC) $(CFLAGS) $(INCDIR) $(LIBDIR) -o $@ $(OBJS) $(LIBS) $(SYSTEMC)/lib-$(TARGET_ARCH)/libsystemc.a $(SCV)/lib-$(TARGET_ARCH)/libscv.a 2>&1 | c++filt |
|
.cpp.o: |
$(CC) $(CFLAGS) $(INCDIR) -c $< $(USB_FLAGS) |
|
.cc.o: |
$(CC) $(CFLAGS) $(INCDIR) -c $< $(USB_FLAGS) |
|
clean:: |
rm -f $(OBJS) *~ $(EXE) |
|
ultraclean: clean |
rm -f Makefile.deps |
|
Makefile.deps: |
$(CC) $(CFLAGS) $(INCDIR) -M $(SRCS) >> Makefile.deps |
|
#include Makefile.deps |
/trunk/rtl/systemc/aes192lowarea/aes.h
0,0 → 1,189
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES top file header //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// AES top file header //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "systemc.h" |
//Include modules |
#include "subbytes.h" |
#include "mixcolum.h" |
#include "sbox.h" |
#include "keysched192.h" |
|
|
|
SC_MODULE(aes){ |
|
sc_in<bool> clk; |
sc_in<bool> reset; |
|
sc_in<bool> load_i; |
sc_in<bool> decrypt_i; |
sc_in<sc_biguint<128> > data_i; |
sc_in<sc_biguint<192> > key_i; |
|
sc_out<bool> ready_o; |
sc_out<sc_biguint<128> > data_o; |
|
//Output registers |
sc_signal<bool> next_ready_o; |
|
//To key schedule module |
sc_signal<bool> keysched_start_i; |
sc_signal<sc_uint<4> > keysched_round_i; |
sc_signal<sc_biguint<192> > keysched_last_key_i; |
sc_signal<sc_biguint<192> > keysched_new_key_o; |
sc_signal<bool> keysched_ready_o; |
sc_signal<bool> keysched_sbox_access_o; |
sc_signal<sc_uint<8> > keysched_sbox_data_o; |
sc_signal<bool> keysched_sbox_decrypt_o; |
|
//From mixcolums |
sc_signal<bool> mixcol_start_i; |
sc_signal<sc_biguint<128> > mixcol_data_i; |
sc_signal<bool> mixcol_ready_o; |
sc_signal<sc_biguint<128> > mixcol_data_o; |
|
//From subbytes |
sc_signal<bool> subbytes_start_i; |
sc_signal<sc_biguint<128> > subbytes_data_i; |
sc_signal<bool> subbytes_ready_o; |
sc_signal<sc_biguint<128> > subbytes_data_o; |
sc_signal<sc_uint<8> > subbytes_sbox_data_o; |
sc_signal<bool> subbytes_sbox_decrypt_o; |
|
//To SBOX |
sc_signal<sc_uint<8> > sbox_data_o; |
sc_signal<sc_uint<8> > sbox_data_i; |
sc_signal<bool> sbox_decrypt_i; |
|
enum state_t{IDLE,ROUNDS}; |
|
sc_signal<state_t> state,next_state; |
sc_signal<sc_uint<4> > round,next_round; |
|
sc_signal<sc_biguint<128> > addroundkey_data_o,next_addroundkey_data_reg,addroundkey_data_reg; |
sc_signal<sc_biguint<128> > addroundkey_data_i; |
sc_signal<bool> addroundkey_ready_o,next_addroundkey_ready_o; |
sc_signal<bool> addroundkey_start_i,next_addroundkey_start_i; |
sc_signal<sc_uint<4> > addroundkey_round,next_addroundkey_round; |
sc_signal<sc_uint<64> > next_last_key_half,last_key_half; |
|
sc_signal<bool> first_round_reg, next_first_round_reg; |
int state_var; |
sc_biguint<128> t_concat; |
|
void registers(); |
void control(); |
void addroundkey(); |
void sbox_muxes(); |
|
sbox *sbox1; |
subbytes *sub1; |
mixcolum *mix1; |
keysched *ks1; |
|
|
SC_CTOR(aes){ |
|
sbox1=new sbox("sbox"); |
sub1= new subbytes("subbytes"); |
mix1= new mixcolum("mixcolum"); |
ks1= new keysched("keysched"); |
|
sbox1->clk(clk); |
sbox1->reset(reset); |
sbox1->data_i(sbox_data_i); |
sbox1->decrypt_i(sbox_decrypt_i); |
sbox1->data_o(sbox_data_o); |
|
sub1->clk(clk); |
sub1->reset(reset); |
sub1->start_i(subbytes_start_i); |
sub1->decrypt_i(decrypt_i); |
sub1->data_i(subbytes_data_i); |
sub1->ready_o(subbytes_ready_o); |
sub1->data_o(subbytes_data_o); |
sub1->sbox_data_o(subbytes_sbox_data_o); |
sub1->sbox_data_i(sbox_data_o); |
sub1->sbox_decrypt_o(subbytes_sbox_decrypt_o); |
|
mix1->clk(clk); |
mix1->reset(reset); |
mix1->decrypt_i(decrypt_i); |
mix1->start_i(mixcol_start_i); |
mix1->data_i(mixcol_data_i); |
mix1->ready_o(mixcol_ready_o); |
mix1->data_o(mixcol_data_o); |
|
ks1->clk(clk); |
ks1->reset(reset); |
ks1->start_i(keysched_start_i); |
ks1->round_i(keysched_round_i); |
ks1->last_key_i(keysched_last_key_i); |
ks1->new_key_o(keysched_new_key_o); |
ks1->ready_o(keysched_ready_o); |
ks1->sbox_access_o(keysched_sbox_access_o); |
ks1->sbox_data_o(keysched_sbox_data_o); |
ks1->sbox_data_i(sbox_data_o); |
ks1->sbox_decrypt_o(keysched_sbox_decrypt_o); //Always 0 |
|
SC_METHOD(registers); |
sensitive_pos << clk; |
sensitive_neg << reset; |
|
SC_METHOD(control); |
sensitive << state << round << addroundkey_data_o << data_i << load_i; |
sensitive << decrypt_i << addroundkey_ready_o << mixcol_ready_o << subbytes_ready_o; |
sensitive << subbytes_data_o << mixcol_data_o << first_round_reg; |
|
SC_METHOD(addroundkey); |
sensitive << addroundkey_data_i << addroundkey_start_i << addroundkey_data_reg << addroundkey_round << keysched_new_key_o << keysched_ready_o; |
sensitive << key_i << round << last_key_half; |
|
SC_METHOD(sbox_muxes); |
sensitive << keysched_sbox_access_o << keysched_sbox_decrypt_o << keysched_sbox_data_o << subbytes_sbox_decrypt_o << subbytes_sbox_data_o; |
|
} |
}; |
/trunk/rtl/systemc/aes192lowarea/sbox.h
0,0 → 1,131
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES sboc module header //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// S-box calculation calculating inverse on gallois field //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "systemc.h" |
|
|
SC_MODULE(sbox){ |
|
sc_in<bool> clk; |
sc_in<bool> reset; |
sc_in<sc_uint<8> > data_i; |
sc_in<bool> decrypt_i; |
sc_out<sc_uint<8> > data_o; |
|
void registers(); |
void first_mux(); |
void end_mux(); |
void inversemap(); |
void mul1(); |
void mul2(); |
void mul3(); |
void intermediate(); |
void inversion(); |
void sum1(); |
void square1(); |
void square2(); |
|
//Output from inverter to mux |
sc_signal<sc_uint<8> > inva; |
|
//Elements in GF(2^4^2) |
sc_signal<sc_uint<4> > ah,al; |
//Squares of ah and al; |
sc_signal<sc_uint<4> > ah2,al2; |
//al multiplied by ah |
sc_signal<sc_uint<4> > alxh; |
//al plus ah |
sc_signal<sc_uint<4> > alph; |
//output from inverter in GF(2^4) |
sc_signal<sc_uint<4> > d; |
//output from final multipliers |
sc_signal<sc_uint<4> > ahp,alp; |
|
|
//Registers |
sc_signal<sc_uint<4> > to_invert,next_to_invert; |
sc_signal<sc_uint<4> > ah_reg,next_ah_reg,next_alph; |
|
SC_CTOR(sbox){ |
|
SC_METHOD(registers); |
sensitive_pos << clk; |
sensitive_neg << reset; |
|
SC_METHOD(first_mux); |
sensitive << data_i << decrypt_i; |
|
SC_METHOD(end_mux); |
sensitive << decrypt_i << inva; |
|
SC_METHOD(inversemap); |
sensitive << alp << ahp; |
|
SC_METHOD(mul1); |
sensitive << ah << al; |
|
SC_METHOD(mul2); |
sensitive << d << ah_reg; |
|
SC_METHOD(mul3); |
sensitive << d << alph; |
|
SC_METHOD(intermediate); |
sensitive << ah2 << al2 << alxh; |
|
SC_METHOD(inversion); |
sensitive << to_invert; |
|
SC_METHOD(sum1); |
sensitive << ah << al; |
|
SC_METHOD(square1); |
sensitive << ah; |
|
SC_METHOD(square2); |
sensitive << al; |
} |
}; |
/trunk/rtl/systemc/aes192lowarea/byte_mixcolum.cpp
0,0 → 1,81
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES mixcolums 8 bit module implementation //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Submodule of mixcolums stage implementation for //// |
/// AES algorithm //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "byte_mixcolum.h" |
|
sc_uint<8> xtime(sc_uint<8> in){ |
sc_uint<4> xtime_t; |
sc_uint<8> out; |
|
out.range(7,5)=in.range(6,4); |
xtime_t[3]=in[7];xtime_t[2]=in[7];xtime_t[1]=0;xtime_t[0]=in[7]; |
out.range(4,1)=xtime_t^in.range(3,0); |
out[0]=in[7]; |
return out; |
} |
|
void byte_mixcolum::dataflow(){ |
|
sc_uint<8> w1,w2,w3,w4,w5,w6,w7,w8,outx_var; |
|
w1=a.read()^b.read(); |
w2=a.read()^c.read(); |
w3=c.read()^d.read(); |
|
w4=xtime(w1); |
w5=xtime(w3); |
|
w6=w2^w4^w5; |
|
w7=xtime(w6); |
w8=xtime(w7); |
|
outx_var=b.read()^w3^w4; |
outx.write(outx_var); |
outy.write(w8^outx_var); |
|
} |
/trunk/rtl/systemc/aes192lowarea/main.cpp
0,0 → 1,132
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Main simulation file //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Connect all the modules and begin the simulation //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "systemc.h" |
#include "iostream.h" |
#include "aes.h" |
#include "aesfunctions.h" |
#include "aesmodel.h" |
#include "stimulus.h" |
#include "adapt.h" |
#include "checker.h" |
|
int sc_main(int argc, char* argv[]){ |
|
sc_clock clk("clk",20); |
|
test *t; |
aes_transactor *tr; |
aes *ae1; |
aesmodel *am1; |
adapter *ad1; |
checker *ch1; |
|
t=new test("testbench"); |
tr=new aes_transactor("aes_transactor"); |
am1=new aesmodel("aes_C_model"); |
ae1=new aes("aes"); |
ad1=new adapter("adapter"); |
ch1=new checker("checker"); |
|
t->transactor(*tr); |
|
sc_signal<bool> reset; |
sc_signal<bool> rt_load; |
sc_signal<bool> rt_decrypt; |
sc_signal<sc_biguint<128> > rt_data_i; |
sc_signal<sc_biguint<192> > rt_key; |
|
sc_signal<sc_biguint<128> > rt_data_o; |
sc_signal<bool> rt_ready; |
|
sc_fifo<sc_biguint<128> > rt_aes_data_ck; |
sc_fifo<sc_biguint<128> > c_aes_data_ck; |
|
sc_fifo<bool> c_decrypt; |
sc_fifo<sc_biguint<192> > c_key; |
sc_fifo<sc_biguint<128> > c_data; |
|
ch1->reset(reset); |
ch1->rt_aes_data_i(rt_aes_data_ck); |
ch1->c_aes_data_i(c_aes_data_ck); |
|
ad1->clk(clk); |
ad1->rt_ready_i(rt_ready); |
ad1->rt_aes_data_i(rt_data_o); |
ad1->rt_aes_data_o(rt_aes_data_ck); |
|
am1->decrypt(c_decrypt); |
am1->aes_key_i(c_key); |
am1->aes_data_i(c_data); |
am1->aes_data_o(c_aes_data_ck); |
|
ae1->clk(clk); |
ae1->reset(reset); |
ae1->load_i(rt_load); |
ae1->decrypt_i(rt_decrypt); |
ae1->data_i(rt_data_i); |
ae1->key_i(rt_key); |
ae1->data_o(rt_data_o); |
ae1->ready_o(rt_ready); |
|
tr->clk(clk); |
tr->reset(reset); |
//Ports to RT model |
tr->rt_load_o(rt_load); |
tr->rt_decrypt_o(rt_decrypt); |
tr->rt_aes_data_o(rt_data_i); |
tr->rt_aes_key_o(rt_key); |
tr->rt_aes_ready_i(rt_ready); |
//Ports to C model |
tr->c_decrypt_o(c_decrypt); |
tr->c_aes_key_o(c_key); |
tr->c_aes_data_o(c_data); |
|
sc_start(-1); |
|
return 0; |
|
} |
/trunk/rtl/systemc/aes192lowarea/byte_mixcolum.h
0,0 → 1,61
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Byte mixcolum header //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Header file for 8-bit mixcolum submodule //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "systemc.h" |
|
SC_MODULE(byte_mixcolum){ |
|
sc_in<sc_uint<8> > a,b,c,d; |
sc_out<sc_uint<8> > outx,outy; |
|
void dataflow(); |
|
SC_CTOR(byte_mixcolum){ |
|
SC_METHOD(dataflow); |
sensitive << a << b << c << d; |
} |
}; |
/trunk/rtl/systemc/aes192lowarea/stimulus.cpp
0,0 → 1,80
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Random testbench stimulus generation //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Generate random stimulus to the core //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "stimulus.h" |
|
void test::tb(){ |
|
sc_biguint<192> aes_key_var; |
sc_biguint<128> aes_data_var; |
|
bool decrypt_var; |
|
scv_random::set_global_seed(12659); |
|
random_generator rg("random_generator"); |
|
transactor->resetea(); |
|
while(1){ |
|
rg.aes_key->next(); |
rg.aes_data->next(); |
rg.decrypt->next(); |
|
|
aes_data_var=*(rg.aes_data); |
aes_key_var=*(rg.aes_key); |
decrypt_var=*(rg.decrypt); |
|
if(!decrypt_var){ |
transactor->encrypt(aes_data_var,aes_key_var); |
}else{ |
transactor->decrypt(aes_data_var,aes_key_var); |
} |
} |
|
} |
/trunk/rtl/systemc/aes192lowarea/transactor.h
0,0 → 1,153
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Transactor for AES ramdom verification //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Transactor acording to TLM for SystemC AES project //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "systemc.h" |
|
class transactor_ports:public sc_module{ |
public: |
|
// Ports |
sc_in<bool> clk; |
sc_out<bool> reset; |
|
//Ports to RT model |
sc_out<bool> rt_load_o; |
sc_out<bool> rt_decrypt_o; |
sc_out<sc_biguint<128> > rt_aes_data_o; |
sc_out<sc_biguint<192> > rt_aes_key_o; |
sc_in<bool> rt_aes_ready_i; |
|
//Ports to C model |
sc_fifo_out<bool> c_decrypt_o; |
sc_fifo_out<sc_biguint<192> > c_aes_key_o; |
sc_fifo_out<sc_biguint<128> > c_aes_data_o; |
|
}; |
|
|
class rw_task_if : virtual public sc_interface { |
|
public: |
//Funciones para el transactor |
virtual void resetea(void)=0; |
virtual void encrypt(sc_biguint<128> data, sc_biguint<192> key)=0; |
virtual void decrypt(sc_biguint<128> data, sc_biguint<192> key)=0; |
virtual void wait_cycles(int cycles)=0; |
|
}; |
|
|
//Transactor |
class aes_transactor:public rw_task_if,public transactor_ports { |
|
public: |
|
SC_CTOR(aes_transactor){ |
|
cout.unsetf(ios::dec); |
cout.setf(ios::hex); |
|
} |
|
|
void resetea(void){ |
reset.write(0); |
wait(clk->posedge_event()); |
reset.write(1); |
cout << "Reseted" << endl; |
} |
|
void encrypt(sc_biguint<128> data, sc_biguint<192> key){ |
|
wait(clk->posedge_event()); |
|
//To RT model |
rt_load_o.write(1); |
rt_aes_data_o.write(data); |
rt_aes_key_o.write(key); |
rt_decrypt_o.write(0); |
|
//To C model through fifos |
c_aes_data_o.write(data); |
c_aes_key_o.write(key); |
c_decrypt_o.write(0); |
|
//cout << "Encripting data 0x" << (int)(sc_uint<32>)data.range(127,96) << " " << (int)(sc_uint<32>)data.range(95,64) << " " << (int)(sc_uint<32>)data.range(63,32) <<" " << (int)(sc_uint<32>)data.range(31,0) << endl; |
//cout << "Encripting with key 0x" << (int)(sc_uint<32>)key.range(191,160) <<" " << (int)(sc_uint<32>)key.range(159,128) << " " <<(int)(sc_uint<32>)key.range(127,96) <<" " << (int)(sc_uint<32>)key.range(95,64) <<" " << (int)(sc_uint<32>)key.range(63,32) <<" " <<(int)(sc_uint<32>)key.range(31,0) << endl; |
|
wait(clk->posedge_event()); |
rt_load_o.write(0); |
wait(rt_aes_ready_i->posedge_event()); |
} |
|
void decrypt(sc_biguint<128> data, sc_biguint<192> key){ |
|
wait(clk->posedge_event()); |
|
//To RT model |
rt_load_o.write(1); |
rt_aes_data_o.write(data); |
rt_aes_key_o.write(key); |
rt_decrypt_o.write(1); |
|
//To C model through fifos |
c_aes_data_o.write(data); |
c_aes_key_o.write(key); |
c_decrypt_o.write(1); |
|
wait(clk->posedge_event()); |
rt_load_o.write(0); |
wait(rt_aes_ready_i->posedge_event()); |
|
} |
|
void wait_cycles(int cycles){ |
for(int i=0;i<cycles;i++){ |
wait(clk->posedge_event()); |
} |
} |
|
}; |
/trunk/rtl/systemc/aes192lowarea/word_mixcolum.cpp
0,0 → 1,74
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Mixcolumns for a 16 bit word module implementation //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Mixcolum for a 16 bit word //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "word_mixcolum.h" |
|
void word_mixcolum::mix(){ |
sc_uint<32> outx_var, outy_var; |
|
outx_var.range(31, 24) = x1.read(); |
outx_var.range(23, 16) = x2.read(); |
outx_var.range(15, 8) = x3.read(); |
outx_var.range(7, 0) = x4.read(); |
outy_var.range(31, 24) = y1.read(); |
outy_var.range(23, 16) = y2.read(); |
outy_var.range(15, 8) = y3.read(); |
outy_var.range(7, 0) = y4.read(); |
|
outx.write(outx_var); |
outy.write(outy_var); |
} |
|
void word_mixcolum::split() |
{ |
sc_uint<32> in_var; |
|
in_var = in.read(); |
a.write(in_var.range(31, 24)); |
b.write(in_var.range(23, 16)); |
c.write(in_var.range(15, 8)); |
d.write(in_var.range(7, 0)); |
} |
/trunk/rtl/systemc/aes192lowarea/stimulus.h
0,0 → 1,73
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Random testbench declation //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Declare ramdom testbench class and data //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "transactor.h" |
#include "scv.h" |
|
//Random number generator |
|
class random_generator:virtual public scv_constraint_base{ |
public: |
|
scv_smart_ptr<sc_biguint<192> > aes_key; |
scv_smart_ptr<sc_biguint<128> > aes_data; |
|
scv_smart_ptr<bool> decrypt; |
|
SCV_CONSTRAINT_CTOR(random_generator){ } |
}; |
|
class test : public sc_module{ |
public: |
|
sc_port<rw_task_if> transactor; |
|
void tb(); |
|
SC_CTOR(test){ |
SC_THREAD(tb); |
} |
}; |
/trunk/rtl/systemc/aes192lowarea/keysched192.cpp
0,0 → 1,182
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES key schedule implementation //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Generate the next round key from the previous one //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "keysched192.h" |
|
//Rcon ROM |
void keysched::rcon(){ |
|
switch(round_i.read()){ |
case 1: |
rcon_o.write(1); |
break; |
case 2: |
rcon_o.write(2); |
break; |
case 3: |
rcon_o.write(4); |
break; |
case 4: |
rcon_o.write(8); |
break; |
case 5: |
rcon_o.write(0x10); |
break; |
case 6: |
rcon_o.write(0x20); |
break; |
case 7: |
rcon_o.write(0x40); |
break; |
case 8: |
rcon_o.write(0x80); |
break; |
case 9: |
rcon_o.write(0x1B); |
break; |
case 10: |
rcon_o.write(0x36); |
break; |
case 11: |
rcon_o.write(0x6C); |
break; |
case 12: |
rcon_o.write(0xD8); |
break; |
default: |
rcon_o.write(0); |
break; |
} |
} |
|
void keysched::generate_key(){ |
sc_biguint<384> K_var,W_var; |
sc_uint<32> col_t; |
sc_uint<24> zero; |
|
zero=0; |
|
col_t=col.read(); |
W_var=0; |
|
next_state.write(state.read()); |
next_col.write(col.read()); |
|
next_ready_o.write(0); |
next_key_reg.write(key_reg.read()); |
new_key_o.write(key_reg.read()); |
|
sbox_decrypt_o.write(0); |
sbox_access_o.write(0); |
sbox_data_o.write(0); |
K_var=last_key_i.read(); |
|
switch(state.read()){ |
//Substitute the bytes while rotating them |
//Four accesses to SBox are needed |
case 0: |
if(start_i.read()){ |
col_t=0; |
sbox_access_o.write(1); |
sbox_data_o.write((sc_uint<8>)K_var.range(31,24)); |
next_state.write(1); |
} |
break; |
case 1: |
sbox_access_o.write(1); |
sbox_data_o.write((sc_uint<8>)K_var.range(23,16)); |
col_t.range(7,0)=sbox_data_i.read(); |
next_col.write(col_t); |
next_state.write(2); |
break; |
case 2: |
sbox_access_o.write(1); |
sbox_data_o.write((sc_uint<8>)K_var.range(15,8)); |
col_t.range(31,24)=sbox_data_i.read(); |
next_col.write(col_t); |
next_state.write(3); |
break; |
case 3: |
sbox_access_o.write(1); |
sbox_data_o.write((sc_uint<8>)K_var.range(7,0)); |
col_t.range(23,16)=sbox_data_i.read(); |
next_col.write(col_t); |
next_state.write(4); |
break; |
case 4: |
sbox_access_o.write(1); |
col_t.range(15,8)=sbox_data_i.read(); |
next_col.write(col_t); |
W_var.range(191,160)=col_t^K_var.range(191,160)^(rcon_o.read(),zero); |
W_var.range(159,128)=W_var.range(191,160)^K_var.range(159,128); |
W_var.range(127,96)=W_var.range(159,128)^K_var.range(127,96); |
W_var.range(95,64)=W_var.range(127,96)^K_var.range(95,64); |
W_var.range(63,32)=W_var.range(95,64)^K_var.range(63,32); |
W_var.range(31,0)=W_var.range(63,32)^K_var.range(31,0); |
next_ready_o.write(1); |
next_key_reg.write(W_var); |
next_state.write(0); |
break; |
|
default: |
next_state.write(0); |
break; |
} |
} |
|
void keysched::registers(){ |
if(!reset.read()){ |
state.write(0); |
col.write(0); |
key_reg.write(0); |
ready_o.write(0); |
}else{ |
state.write(next_state.read()); |
col.write(next_col.read()); |
key_reg.write(next_key_reg.read()); |
ready_o.write(next_ready_o.read()); |
} |
} |
/trunk/rtl/systemc/aes192lowarea/Makefile
0,0 → 1,14
TARGET_ARCH = linux |
|
CC = g++ |
OPT = -O3 |
DEBUG = -g |
OTHER = -Wall -Wno-deprecated |
EXTRA_CFLAGS = $(OPT) $(OTHER) |
# EXTRA_CFLAGS = $(DEBUG) $(OTHER) |
|
MODULE = aes |
SRCS = byte_mixcolum.cpp word_mixcolum.cpp keysched192.cpp sbox.cpp mixcolum.cpp subbytes.cpp aes.cpp stimulus.cpp main.cpp |
OBJS = $(SRCS:.cpp=.o) |
|
include Makefile.defs |
/trunk/rtl/systemc/aes192lowarea/mixcolum.cpp
0,0 → 1,122
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES mixcolum module implementation //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Mixcolum stage implementation for AES algorithm //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "mixcolum.h" |
|
void mixcolum::mux(){ |
outmux.write(decrypt_i.read() ? outy.read() : outx.read()); |
} |
|
void mixcolum::mixcol(){ |
sc_biguint<128> data_i_var; |
sc_uint<32> aux; |
sc_biguint<128> data_reg_var; |
|
data_i_var=data_i.read(); |
data_reg_var=data_reg.read(); |
next_data_reg.write(data_reg.read()); |
next_state.write(state.read()); |
|
mix_word.write(0); |
|
next_ready_o.write(0); |
next_data_o.write(data_o_reg.read()); |
|
switch(state.read()){ |
|
case 0: |
if(start_i.read()){ |
aux=data_i_var.range(127,96); |
mix_word.write(aux); |
data_reg_var.range(127,96)=outmux.read(); |
next_data_reg.write(data_reg_var); |
next_state.write(1); |
} |
break; |
case 1: |
aux=data_i_var.range(95,64); |
mix_word.write(aux); |
data_reg_var.range(95,64)=outmux.read(); |
next_data_reg.write(data_reg_var); |
next_state.write(2); |
break; |
case 2: |
aux=data_i_var.range(63,32); |
mix_word.write(aux); |
data_reg_var.range(63,32)=outmux.read(); |
next_data_reg.write(data_reg_var); |
next_state.write(3); |
break; |
case 3: |
aux=data_i_var.range(31,0); |
mix_word.write(aux); |
data_reg_var.range(31,0)=outmux.read(); |
next_data_o.write(data_reg_var); |
next_ready_o.write(1); |
next_state.write(0); |
break; |
default: |
break; |
} |
} |
|
void mixcolum::registers(){ |
if(!reset.read()){ |
data_reg.write(0); |
state.write(0); |
ready_o.write(0); |
data_o_reg.write(0); |
}else{ |
data_reg.write(next_data_reg.read()); |
state.write(next_state.read()); |
ready_o.write(next_ready_o.read()); |
data_o_reg.write(next_data_o.read()); |
} |
} |
|
void mixcolum::assign_data_o(){ |
data_o.write(data_o_reg.read()); |
} |
/trunk/rtl/systemc/aes192lowarea/word_mixcolum.h
0,0 → 1,106
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Word mixcolum header //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
//// Description: //// |
//// Header file for 16-bit mixcolum submodule //// |
//// //// |
//// To Do: //// |
//// - done //// |
//// //// |
//// Author(s): //// |
//// - Javier Castillo, jcastilo@opencores.org //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
//// //// |
//// Copyright (C) 2000 Authors and OPENCORES.ORG //// |
//// //// |
//// This source file may be used and distributed without //// |
//// restriction provided that this copyright statement is not //// |
//// removed from the file and that any derivative work contains //// |
//// the original copyright notice and the associated disclaimer. //// |
//// //// |
//// This source file is free software; you can redistribute it //// |
//// and/or modify it under the terms of the GNU Lesser General //// |
//// Public License as published by the Free Software Foundation; //// |
//// either version 2.1 of the License, or (at your option) any //// |
//// later version. //// |
//// //// |
//// This source is distributed in the hope that it will be //// |
//// useful, but WITHOUT ANY WARRANTY; without even the implied //// |
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //// |
//// PURPOSE. See the GNU Lesser General Public License for more //// |
//// details. //// |
//// //// |
//// You should have received a copy of the GNU Lesser General //// |
//// Public License along with this source; if not, download it //// |
//// from http://www.opencores.org/lgpl.shtml //// |
//// //// |
////////////////////////////////////////////////////////////////////// |
// |
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
|
#include "systemc.h" |
#include "byte_mixcolum.h" |
|
SC_MODULE(word_mixcolum){ |
|
sc_in<sc_uint<32> > in; |
sc_out<sc_uint<32> > outx,outy; |
|
sc_signal<sc_uint<8> > a,b,c,d; |
sc_signal<sc_uint<8> > x1,x2,x3,x4,y1,y2,y3,y4; |
|
void split(); |
void mix(); |
|
byte_mixcolum *bm1; |
byte_mixcolum *bm2; |
byte_mixcolum *bm3; |
byte_mixcolum *bm4; |
|
SC_CTOR(word_mixcolum){ |
|
SC_METHOD(split); |
sensitive << in; |
SC_METHOD(mix); |
sensitive << x1 << x2 << x3 << x4 << y1 << y2 << y3 << y4; |
|
bm1=new byte_mixcolum("bm1"); |
bm2=new byte_mixcolum("bm2"); |
bm3=new byte_mixcolum("bm3"); |
bm4=new byte_mixcolum("bm4"); |
|
bm1->a(a); |
bm1->b(b); |
bm1->c(c); |
bm1->d(d); |
bm1->outx(x1); |
bm1->outy(y1); |
|
bm2->a(b); |
bm2->b(c); |
bm2->c(d); |
bm2->d(a); |
bm2->outx(x2); |
bm2->outy(y2); |
|
bm3->a(c); |
bm3->b(d); |
bm3->c(a); |
bm3->d(b); |
bm3->outx(x3); |
bm3->outy(y3); |
|
bm4->a(d); |
bm4->b(a); |
bm4->c(b); |
bm4->d(c); |
bm4->outx(x4); |
bm4->outy(y4); |
} |
}; |
/trunk/rtl/systemc/aes128lowarea/sbox.cpp
1,6 → 1,6
////////////////////////////////////////////////////////////////////// |
//// //// |
//// AES sboc module implementation //// |
//// AES sbox module implementation //// |
//// //// |
//// This file is part of the SystemC AES //// |
//// //// |
43,6 → 43,9
// CVS Revision History |
// |
// $Log: not supported by cvs2svn $ |
// Revision 1.1 2005/02/14 11:18:31 jcastillo |
// Moved |
// |
// Revision 1.2 2004/08/30 14:44:44 jcastillo |
// Code Formater used to give better appearance to SystemC code |
// |