X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/Cipher_code.git/blobdiff_plain/a1bf55298885bab573938b35a5738bbf54b717c6..1c5994c77784086a9fc557f039afc3c03847e249:/LightweightARM/LWARM/lwarm.cpp

diff --git a/LightweightARM/LWARM/lwarm.cpp b/LightweightARM/LWARM/lwarm.cpp
index 165fb19..8a736a4 100644
--- a/LightweightARM/LWARM/lwarm.cpp
+++ b/LightweightARM/LWARM/lwarm.cpp
@@ -9,6 +9,7 @@
 #include<string.h>
 #include <fstream>
 #include <sys/time.h>
+#include <arm_neon.h>
 
 /*#include <cryptopp/hex.h>
 #include <cryptopp/sha.h>
@@ -359,6 +360,346 @@ void decrypt(uchar* seq_in, uchar *seq_out, int len,uchar* RM1,int *Pbox, int *P
 
 }
 
+uchar sbox[256] =   {
+  //0     1    2      3     4    5     6     7      8    9     A      B    C     D     E     F
+  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, //0
+  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, //1
+  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, //2
+  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, //3
+  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, //4
+  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, //5
+  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, //6
+  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, //7
+  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, //8
+  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, //9
+  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, //A
+  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, //B
+  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, //C
+  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, //D
+  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, //E
+  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 }; //F
+
+
+int Rcon[255] = {
+  0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
+  0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,
+  0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
+  0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
+  0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
+  0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
+  0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
+  0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
+  0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
+  0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
+  0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
+  0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
+  0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
+  0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
+  0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
+  0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb
+};
+
+
+
+void KeyExpansion(uchar *RoundKey, uchar *key, int NN )
+{
+  int i,j;
+  uchar temp[4],k;
+  int Nk = NN / 32;
+  int Nr = Nk + 6;
+
+  // The first round key is the key itself.
+  for(i=0;i<Nk;i++)
+    {
+      RoundKey[i*4]=key[i*4];
+      RoundKey[i*4+1]=key[i*4+1];
+      RoundKey[i*4+2]=key[i*4+2];
+      RoundKey[i*4+3]=key[i*4+3];
+    }
+
+  // All other round keys are found from the previous round keys.
+  while (i < 256)
+    {
+      for(j=0;j<4;j++)
+	{
+	  temp[j]=RoundKey[(i-1) * 4 + j];
+	}
+      if (i % Nk == 0)
+	{
+	  // This function rotates the 4 bytes in a word to the left once.
+	  // [a0,a1,a2,a3] becomes [a1,a2,a3,a0]
+
+	  // Function RotWord()
+	  {
+	    k = temp[0];
+	    temp[0] = temp[1];
+	    temp[1] = temp[2];
+	    temp[2] = temp[3];
+	    temp[3] = k;
+	  }
+
+	  // SubWord() is a function that takes a four-byte input word and
+	  // applies the S-box to each of the four bytes to produce an output word.
+
+	  // Function Subword()
+	  {
+	    temp[0]=sbox[temp[0]];
+	    temp[1]=sbox[temp[1]];
+	    temp[2]=sbox[temp[2]];
+	    temp[3]=sbox[temp[3]];
+	  }
+
+	  temp[0] =  temp[0] ^ Rcon[i/Nk];
+	}
+      else if (Nk > 6 && i % Nk == 4)
+	{
+	  // Function Subword()
+	  {
+	    temp[0]=sbox[temp[0]];
+	    temp[1]=sbox[temp[1]];
+	    temp[2]=sbox[temp[2]];
+	    temp[3]=sbox[temp[3]];
+	  }
+	}
+      RoundKey[i*4+0] = RoundKey[(i-Nk)*4+0] ^ temp[0];
+      RoundKey[i*4+1] = RoundKey[(i-Nk)*4+1] ^ temp[1];
+      RoundKey[i*4+2] = RoundKey[(i-Nk)*4+2] ^ temp[2];
+      RoundKey[i*4+3] = RoundKey[(i-Nk)*4+3] ^ temp[3];
+      i++;
+    }
+
+  printf("i %d\n",i);
+}
+
+
+
+
+
+
+
+
+#define key_size 256
+
+uint8_t enc_key[key_size];
+
+
+
+
+
+
+void AES_encrypt(const uint8_t *in, uint8_t *out, const uint8x16_t  *rdkeys, unsigned int rounds, int val_i,char** target)
+{
+
+
+
+
+  // Load the block
+  uint8x16_t data = vld1q_u8(in);
+  uint8x16_t tmp;
+
+
+
+  uint64x2_t v1=vdupq_n_u64(val_i);
+
+  uint8x16_t key=reinterpret_cast<uint8x16_t>(v1);
+
+
+
+
+  tmp = veorq_u8(key, rdkeys[0]);
+  /*
+    if(val_i<1) {
+        static uint8_t p[16];
+
+        vst1q_u8 (p, key);
+
+        for(int i=0;i<16;i++)
+	*target += sprintf(*target, "%d ", p[i]);
+        *target += sprintf(*target, "\n ");
+
+        vst1q_u8 (p, rdkeys[0]);
+
+        for(int i=0;i<16;i++)
+	*target += sprintf(*target, "%d ", p[i]);
+        *target += sprintf(*target, "\n ");
+
+    }
+  */
+
+  // AES encryption with ARM intrinsics:
+  // rnds-1 (9 for AES128) cycles of AES:
+  // (Add, Shift, Sub) plus Mix Columns
+  unsigned int i;
+  for (i=1; i<rounds; ++i)
+    {
+      // AES single round encryption
+      tmp = vaeseq_u8(tmp, rdkeys[i]);
+      // AES mix columns
+      tmp = vaesmcq_u8(tmp);
+
+    }
+
+
+
+  tmp = veorq_u8(tmp, data);
+
+
+
+  vst1q_u8(out, tmp);
+
+
+
+}
+
+
+
+__attribute__((always_inline))
+uint32x4_t _mm_shuffle_epi32_splat(uint32x4_t a)
+{
+  return vdupq_n_u32(vgetq_lane_u32(a, 3));
+}
+
+__attribute__((always_inline))
+uint8x16_t _mm_slli_si128(uint8x16_t a, int imm ) {
+  //return (int8x16_t) vextq_s8(vdupq_n_s8(0), (int8x16_t)a, 16 - (imm));
+  return (vextq_u8(vdupq_n_u8(0), a, 12));
+}
+
+__attribute__((always_inline))
+uint8x16_t _mm_xor_si128(uint8x16_t a, uint8x16_t b)
+{
+  return veorq_u8(a, b);
+}
+
+__attribute__((always_inline))
+void print128_num(uint8x16_t v) {
+  uint8_t p[16];
+  vst1q_u8 (p, v);
+
+  for(int j=0;j<16;j++) {
+    cout<<(int)p[j]<<" ";
+  }
+  cout<<endl;
+
+}
+
+
+__attribute__((always_inline))
+uint8x16_t AES_128_key_exp(uint8x16_t key, int val){
+
+  uint64x2_t v1=vdupq_n_u64(val);
+  cout<<"val "<<val;
+  uint8x16_t keygened=reinterpret_cast<uint8x16_t>(v1);
+  print128_num(keygened);
+  //  cout<<"keygened "<<keygened;
+  keygened = (uint8x16_t) _mm_shuffle_epi32_splat(keygened);
+
+  cout<<" la "<<endl;  
+  print128_num(key);
+  
+  key = _mm_xor_si128(key, _mm_slli_si128(key, 4));
+  key = _mm_xor_si128(key, _mm_slli_si128(key, 4));
+  key = _mm_xor_si128(key, _mm_slli_si128(key, 4));
+  key = _mm_xor_si128(key, keygened);
+  cout<<" la2 "<<endl;  
+  print128_num(keygened);
+
+  return key; 
+}
+
+
+__attribute__((always_inline))
+void aes128_load_key_enc_only(uint8_t *enc_key, uint8x16_t *key_schedule) {
+  key_schedule[0] = vld1q_u8(enc_key);
+  key_schedule[1] = AES_128_key_exp(key_schedule[0], 0x01);
+  key_schedule[2] = AES_128_key_exp(key_schedule[1], 0x02);
+  key_schedule[3] = AES_128_key_exp(key_schedule[2], 0x04);
+  key_schedule[4] = AES_128_key_exp(key_schedule[3], 0x08);
+  key_schedule[5] = AES_128_key_exp(key_schedule[4], 0x10);
+  key_schedule[6] = AES_128_key_exp(key_schedule[5], 0x20);
+  key_schedule[7] = AES_128_key_exp(key_schedule[6], 0x40);
+  key_schedule[8] = AES_128_key_exp(key_schedule[7], 0x80);
+  key_schedule[9] = AES_128_key_exp(key_schedule[8], 0x1B);
+  key_schedule[10] = AES_128_key_exp(key_schedule[9], 0x36);
+  key_schedule[11] = AES_128_key_exp(key_schedule[10], 0x51);
+  key_schedule[12] = AES_128_key_exp(key_schedule[11], 0x6C);
+  key_schedule[13] = AES_128_key_exp(key_schedule[12], 0x87);
+  key_schedule[14] = AES_128_key_exp(key_schedule[13], 0xA2);
+  key_schedule[15] = AES_128_key_exp(key_schedule[14], 0xBD);
+}
+
+
+void AES_encrypt4(const uint8_t *in, uint8_t *out, const uint8x16_t *rdkeys, unsigned int rounds, int val_i,char** target)
+{
+
+
+
+
+  // Load the block
+  uint8x16_t data1 = vld1q_u8(in);
+  uint8x16_t data2 = vld1q_u8(in+16);
+  uint8x16_t data3 = vld1q_u8(in+32);
+  uint8x16_t data4 = vld1q_u8(in+48);
+  uint8x16_t tmp1,tmp2,tmp3,tmp4;
+
+
+
+  uint64x2_t v1=vdupq_n_u64(val_i);
+  uint8x16_t key1=reinterpret_cast<uint8x16_t>(v1);
+  v1=vdupq_n_u64(val_i+1);
+  uint8x16_t key2=reinterpret_cast<uint8x16_t>(v1);
+  v1=vdupq_n_u64(val_i+2);
+  uint8x16_t key3=reinterpret_cast<uint8x16_t>(v1);
+  v1=vdupq_n_u64(val_i+3);
+  uint8x16_t key4=reinterpret_cast<uint8x16_t>(v1);
+
+  tmp1 = veorq_u8(key1, rdkeys[0]);
+  tmp2 = veorq_u8(key2, rdkeys[0]);
+  tmp3 = veorq_u8(key3, rdkeys[0]);
+  tmp4 = veorq_u8(key4, rdkeys[0]);
+
+
+  // AES encryption with ARM intrinsics:
+  // rnds-1 (9 for AES128) cycles of AES:
+  // (Add, Shift, Sub) plus Mix Columns
+  unsigned int i;
+  for (i=1; i<rounds; ++i)
+    {
+      // AES single round encryption
+      tmp1 = vaeseq_u8(tmp1, rdkeys[i]);
+      // AES mix columns
+      tmp1 = vaesmcq_u8(tmp1);
+      tmp2 = vaeseq_u8(tmp2, rdkeys[i]);
+      tmp2 = vaesmcq_u8(tmp2);
+      tmp3 = vaeseq_u8(tmp3, rdkeys[i]);
+      tmp3 = vaesmcq_u8(tmp3);
+      tmp4 = vaeseq_u8(tmp4, rdkeys[i]);
+      tmp4 = vaesmcq_u8(tmp4);
+
+
+    }
+
+
+
+  tmp1 = veorq_u8(tmp1, data1);
+  vst1q_u8(out, tmp1);
+  tmp2 = veorq_u8(tmp2, data2);
+  vst1q_u8(out+16, tmp2);
+  tmp3 = veorq_u8(tmp3, data3);
+  vst1q_u8(out+32, tmp3);
+  tmp4 = veorq_u8(tmp4, data4);
+  vst1q_u8(out+48, tmp4);
+
+
+
+}
+
+
+
+
+
+
+
 
 int main(int argc, char** argv) {
 
@@ -367,7 +708,12 @@ int main(int argc, char** argv) {
   int lena=0;
   int size_buf=1;
 
+  int NN=128;
 
+  unsigned char RoundKey[256];
+  for(int i=0;i<256;i++) {
+    RoundKey[i]=0;
+  }
   
   for(int i=1; i<argc; i++){
     if(strncmp(argv[i],"nb",2)==0)    nb_test = atoi(&(argv[i][2]));    //nb of test         
@@ -388,6 +734,7 @@ int main(int argc, char** argv) {
 
       
   int seed=time(NULL);
+  seed=12;
   cout<<seed<<endl;
   srand48(seed);
 
@@ -396,10 +743,46 @@ int main(int argc, char** argv) {
   uchar counter[key_size];
 
   for(int i=0;i<key_size;i++) {
-    Secretkey[i]=lrand48()&0xFF;
-    counter[i]=lrand48()&0xFF;
+    Secretkey[i]=0;//lrand48()&0xFF;
+    counter[i]=0;//lrand48()&0xFF;
+  }
+
+
+  uint8x16_t *rdkeys=(uint8x16_t *)malloc(sizeof(uint8x16_t)*16);
+
+  char mystr[10000];
+  char *target = mystr;
+
+
+
+
+  uint8_t *enc_key = (uint8_t *)malloc(sizeof(uint8_t) * 16);
+  for (int i = 0; i < 16; i++) {
+    enc_key[i] = lrand48() & 0xFF;
+    //    cout<<(int)enc_key[i]<<endl;
+  }
+
+  //aes128_load_key_enc_only(enc_key, rdkeys);
+
+
+  KeyExpansion(RoundKey, enc_key, NN);
+
+
+  for (size_t i=0; i<256/16; ++i) {
+    rdkeys[i] = vld1q_u8(&RoundKey[i*16]);
+    print128_num(rdkeys[i]);
   }
 
+
+  
+  
+  /*  cout<<"start of useless computation"<<endl;
+  double dummy=0;
+  for(int i=0;i<40000000;i++) {
+    dummy+=0.000000001*log(i+10);
+  }
+  cout<<"end of useless computation"<<dummy<<endl;
+  */
   
   int size = 64;
   uchar DK[size];
@@ -435,6 +818,10 @@ int main(int argc, char** argv) {
   uchar* seq= new uchar[imsize];
   uchar* seq2= new uchar[imsize];
 
+  for(int i=0;i<imsize;i++) {
+    seq2[i]=0;
+  }
+  
   int oneD=width*height;
   if(lena) {
     for(int i=0;i<oneD;i++) {
@@ -455,9 +842,10 @@ int main(int argc, char** argv) {
 
   int total_len=imsize;
   int rp=1;
-  int len= total_len/h2;
+  int len= total_len;
 
 
+  cout<<"len "<<len<<endl;
   
   uchar *mix=new uchar[256];
 
@@ -533,58 +921,15 @@ int main(int argc, char** argv) {
   double t=TimeStart();
 
   int i;
-  switch(h) {
-  case 4: 
-    for(i=0;i<nb_test;i++)
-    {
-      if(ctr)
-	encrypt_ctr<4*4>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,1);
-      else
-	encrypt<4*4>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,0);
-      
-    }
-    break;
-  case 8: 
-    for(i=0;i<nb_test;i++)
-    {
-      if(ctr)
-	encrypt_ctr<8*8>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,1);
-      else
-	encrypt<8*8>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,0);
-      
-    }
-    break;
-  case 16: 
-    for(i=0;i<nb_test;i++)
-    {
-      if(ctr)
-	encrypt_ctr<16*16>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,1);
-      else
-	encrypt<16*16>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,0);
-      
-    }
-    break;
-  case 32: 
-    for(i=0;i<nb_test;i++)
-    {
-      if(ctr)
-	encrypt_ctr<32*32>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,1);
-      else
-	encrypt<32*32>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,0);
-      
-    }
-    break;
-  case 64: 
-    for(i=0;i<nb_test;i++)
-    {
-      if(ctr)
-	encrypt_ctr<64*64>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,1);
-      else
-	encrypt<64*64>(seq, seq2,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,0);
-      
+
+  const int ROUNDS=10;
+  for(int a=0;a<nb_test;a++) {
+    for(int i=0;i<len/16/4;i++) {
+      AES_encrypt4((uint8_t *)&seq[i*64], (uint8_t *)&seq2[i*64], rdkeys, ROUNDS,i, &target);
     }
-    break;
   }
+
+
   time+=TimeStop(t);
   cout<<"Time encrypt "<<time<<endl;
 
@@ -599,51 +944,23 @@ int main(int argc, char** argv) {
   }
   
 
+
+  for(int i=0;i<imsize;i++) {
+    seq[i]=0;
+  }
+
+  
   time=0;
   t=TimeStart();
-  switch(h) {
-  case 4:
-    for(i=0;i<nb_test;i++) {
-      if(ctr)
-	encrypt_ctr<4*4>(seq2, seq,len,RM2,Pbox,PboxRM,Sbox1,Sbox2,0);
-      else
-	decrypt<4*4>(seq2,seq,len,RM2,Pbox,PboxRM,Sbox1,Sbox2,0);
-    }
-    break;
-  case 8:
-    for(i=0;i<nb_test;i++) {
-      if(ctr)
-	encrypt_ctr<8*8>(seq2, seq,len,RM2,Pbox,PboxRM,Sbox1,Sbox2,0);
-      else
-	decrypt<8*8>(seq2,seq,len,RM2,Pbox,PboxRM,Sbox1,Sbox2,0);
-    }
-    break;
-  case 16:
-    for(i=0;i<nb_test;i++) {
-      if(ctr)
-	encrypt_ctr<16*16>(seq2, seq,len,RM2,Pbox,PboxRM,Sbox1,Sbox2,0);
-      else
-	decrypt<16*16>(seq2,seq,len,RM2,Pbox,PboxRM,Sbox1,Sbox2,0);
-    }
-    break;
-  case 32:
-    for(i=0;i<nb_test;i++) {
-      if(ctr)
-	encrypt_ctr<32*32>(seq2, seq,len,RM2,Pbox,PboxRM,Sbox1,Sbox2,0);
-      else
-	decrypt<32*32>(seq2,seq,len,RM2,Pbox,PboxRM,Sbox1,Sbox2,0);
-    }
-    break;
-  case 64:
-    for(i=0;i<nb_test;i++) {
-      if(ctr)
-	encrypt_ctr<64*64>(seq2, seq,len,RM2,Pbox,PboxRM,Sbox1,Sbox2,0);
-      else
-	decrypt<64*64>(seq2,seq,len,RM2,Pbox,PboxRM,Sbox1,Sbox2,0);
-    }
-    break;
+  
+  for(int a=0;a<nb_test;a++) {
+    for(int i=0;i<len/16/4;i++) {
+      AES_encrypt4((uint8_t *)&seq2[i*64], (uint8_t *)&seq[i*64], rdkeys, ROUNDS,i, &target);
+    }
   }
 
+
+
   time+=TimeStop(t);
   cout<<"Time decrypt "<<time<<endl;