From 5ca765b420d772f256a9f7ee73a8e4b9398d0d77 Mon Sep 17 00:00:00 2001
From: couturie <you@example.com>
Date: Sun, 27 May 2018 16:18:30 +0200
Subject: [PATCH] ida_gf64

---
 Arduino/sketch_AES/sketch_AES.ino |   2 +-
 IDA/Makefile                      |   6 +-
 IDA/ida.cpp                       |  53 ++-
 IDA/ida_gf64.cpp                  | 538 ++++++++++++++++++++++++++++++
 IDA/lena_small.png                | Bin 2525 -> 0 bytes
 IDA/lena_small2.png               | Bin 308 -> 0 bytes
 SboxAES/IOT/main.c                |  59 +++-
 7 files changed, 628 insertions(+), 30 deletions(-)
 create mode 100644 IDA/ida_gf64.cpp
 delete mode 100644 IDA/lena_small.png
 delete mode 100644 IDA/lena_small2.png

diff --git a/Arduino/sketch_AES/sketch_AES.ino b/Arduino/sketch_AES/sketch_AES.ino
index dcd8883..998f763 100644
--- a/Arduino/sketch_AES/sketch_AES.ino
+++ b/Arduino/sketch_AES/sketch_AES.ino
@@ -6,7 +6,7 @@
 AES aes ;
 
 byte *key = (unsigned char*)"0123456789010123";
-const int size_mesg=16;
+const int size_mesg=64;
 
 
 
diff --git a/IDA/Makefile b/IDA/Makefile
index a2afb98..8d7d811 100644
--- a/IDA/Makefile
+++ b/IDA/Makefile
@@ -11,5 +11,9 @@ test_mat2: test_mat2.cpp
 ida: ida.cpp
 	g++ -std=c++11 $(CPP_FLAGS)  -o $@ $<   $(LIBS)
 
+
+ida_gf64: ida_gf64.cpp
+	g++  -o $@ $<  -std=c++11 -O3 -lm  -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -mavx -g -O3 -Wall   -I/home/couturie/ajeter/jerasure/include  /home/couturie/ajeter/jerasure/src/.libs/jerasure.o /home/couturie/ajeter/jerasure/src/.libs/galois.o -lgf_complete -fpermissive
+
 clean:
-	rm test_mat2 ida
+	rm test_mat2 ida ida_gf64
diff --git a/IDA/ida.cpp b/IDA/ida.cpp
index dd7791a..e854c3a 100644
--- a/IDA/ida.cpp
+++ b/IDA/ida.cpp
@@ -1,6 +1,3 @@
-// g++ -std=c++11 -O4 -msse2 -msse3 -msse4 -fopenmp  -O3   test_mat2.cpp -o test_mat2   -I /home/couturie/tools/armadillo-6.200.5/include/ -lc   -lm -lpthread -lgfortran -DMAX_STACK_ALLOC=2048 -Wall -m64 -DF_INTERFACE_GFORT -fPIC -DSMP_SERVER -DNO_WARMUP -DMAX_CPU_NUMBER=8  -DNO_AFFINITY   -UCOMPLEX -DDOUBLE -I/home/couturie/tools/openblas/include -I/home/couturie/Downloads/OpenBLAS-0.2.15/  /home/couturie/tools/openblas/lib/libopenblas_haswellp-r0.2.15.a
-
-
 
 #include <armadillo>
 #include <stdlib.h>
@@ -158,13 +155,16 @@ convert_vec250_to_vec256(vector<uint8_t> vec250){
 Mat<byte> readFullFile(int n, int k, long& sizeFile, int &lc) {
 
 //  ifstream stream("lena.png", ios::in | ios::binary | ios::ate);
-  ifstream stream("/home/couturie/Downloads/CARCARIASS.zip", ios::in | ios::binary | ios::ate);
-//  ifstream stream("lena_small2.png", ios::in | ios::binary | ios::ate);
+  ifstream stream("lena_small2.png", ios::in | ios::binary | ios::ate);
+//  ifstream stream("/home/couturie/Downloads/CARCARIASS.zip", ios::in | ios::binary | ios::ate);
+
   sizeFile=stream.tellg();
   cout<<sizeFile<<endl;
   stream.seekg(0, ios::beg);
 
 
+
+//Used to convert the size (in long) in 8 bytes  
   uint8_t mysize[8];
   
 
@@ -176,6 +176,7 @@ Mat<byte> readFullFile(int n, int k, long& sizeFile, int &lc) {
     tmpSize>>=8;
   }
 
+//we rebuild the size in order to check that the routine is correct  
   cout<<"rebuild"<<endl;
   long res=0;
   for(int i=8-1;i>=0;i--) {
@@ -193,6 +194,14 @@ Mat<byte> readFullFile(int n, int k, long& sizeFile, int &lc) {
 //  for(int i=0;i<8;i++)
 //    contents.insert(i,mysize[i]);
   contents.insert (contents.begin(), mysize, mysize+8);
+
+  cout<<"start of the vector"<<endl;
+  for(int i=0;i<8;i++)
+    cout<<(int)contents[i]<<" ";
+  cout<<endl;
+
+
+  
   cout<<"res contents "<<contents.size()<<endl;
   vector<uint8_t> contents2=convert_vec256_to_vec250(contents);
   cout<<"res contents2 "<<contents2.size()<<endl;
@@ -218,8 +227,8 @@ if (std::equal(contents.begin(), contents.begin() + contents.size(), contents3.b
     cout << "success" << endl;
   */
 
-lc=ceil(contents2.size()/k);
-  cout<<lc<<endl;
+  lc=ceil(contents2.size()/k);
+  cout<<"size lc "<<lc<<endl;
   Mat<byte> matData(&contents2[0],1,contents2.size());
 
 
@@ -242,12 +251,9 @@ int main( int argc, char *argv[] ) {
 
 
 
-  int full=0;
   
   int n=8;
   int k=4;
-  int Tb=64;
-  int l=10;//399*Tb;
 
 
   
@@ -292,15 +298,21 @@ int main( int argc, char *argv[] ) {
   cout<<"tatat"<<endl;
   Mat<byte> C3;
 
+
+  int off=0;
   
   //read k files among n
-  for(int i=0;i<k;i++) {
+
+  int l=0;
+//  for(int i=k-1;i>=0;i--) {
+  for(int i=0+off;i<k+off;i++) {
     stringstream ss;
     ss <<"lena_"<<i<<".png";
     string str = ss.str();
-
+    cout<<str<<endl;
     Row<byte> d2=readFile(str.c_str());
-    C3.insert_rows(i,d2);
+    C3.insert_rows(l,d2);
+    l++;
   }
 
     
@@ -311,6 +323,7 @@ int main( int argc, char *argv[] ) {
   Mat<int> Cs=conv_to<Mat<int>>::from(C3);
 
   cout<<size(Cs)<<" "<<size(C3)<<endl;
+  cout<<"S "<<" "<<S<<endl;
 
 
   
@@ -332,7 +345,6 @@ int main( int argc, char *argv[] ) {
 
   mat Gsi=round(inv(Gs)*det(Gs)*r);
   Gsi=mod(Gsi,mm);
-  Gsi=mod(Gsi,mm);
 
   cout<<Gsi<<endl;
   
@@ -340,9 +352,9 @@ int main( int argc, char *argv[] ) {
   mat SS2=mod(temp,mm);
   Mat<byte> S2=conv_to<Mat<byte>>::from(SS2);
   S2=mod(S2,mm);
-//  cout<<S2<<endl;
-//  cout<<"max"<<endl;
-//  cout<<max(S2-S,1)<<endl;
+  cout<<"S2 "<<S2<<endl;
+  cout<<"max"<<endl;
+  cout<<max(S2-S,1)<<endl;
 
 
 
@@ -352,6 +364,13 @@ int main( int argc, char *argv[] ) {
 
   vector<uint8_t> res =conv_to< vector<uint8_t> >::from(S2.row(0));
   cout<<"res size "<<res.size()<<endl;
+
+  cout<<"start of file"<<endl;
+  for(int i=0;i<8;i++)
+    cout<<(int)res[i]<<" ";
+  cout<<endl;
+
+  
   vector<uint8_t> res2=convert_vec250_to_vec256(res);
   cout<<"res2 size "<<res2.size()<<endl;
 
diff --git a/IDA/ida_gf64.cpp b/IDA/ida_gf64.cpp
new file mode 100644
index 0000000..a18a06f
--- /dev/null
+++ b/IDA/ida_gf64.cpp
@@ -0,0 +1,538 @@
+
+
+#include <iostream>
+#include <fstream>
+#include <chrono>
+#include <sstream>
+#include <ctime>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <algorithm>    // std::random_shuffle
+#include <vector>       // std::vector
+extern "C" {
+  #include "jerasure.h"
+}
+
+typedef unsigned long mylong;
+#define LLUI (long long unsigned int)
+
+
+using namespace std;
+
+
+void display(mylong *mat, int r, int c) {
+ for(int i=0;i<r;i++) {
+    for(int j=0;j<c;j++) {
+      printf("%016llu ",LLUI mat[i*c+j]);
+    }
+    printf("\n");
+  }
+ printf("\n");
+}
+
+mylong *matrix_multiply(gf_t *gf, mylong *m1, mylong *m2, int r1, int c1, int r2, int c2, int w)
+{
+  mylong *product;
+  int i, j, k;
+
+  product = (mylong *) malloc(sizeof(mylong)*r1*c2);
+  for (i = 0; i < r1*c2; i++) product[i] = 0;
+
+  for (i = 0; i < r1; i++) {
+    for (j = 0; j < c2; j++) {
+      for (k = 0; k < r2; k++) {
+        product[i*c2+j] ^= gf->multiply.w64(gf,m1[i*c1+k], m2[k*c2+j]);
+      }
+    }
+  }
+  return product;
+}
+
+
+
+int invert_matrix(gf_t *gf, mylong *mat, mylong *inv, int rows)
+{
+  int cols, i, j, k, x, rs2;
+  int row_start;
+  mylong tmp, inverse;
+ 
+  cols = rows;
+
+  k = 0;
+  for (i = 0; i < rows; i++) {
+    for (j = 0; j < cols; j++) {
+      inv[k] = (i == j) ? 1 : 0;
+      k++;
+    }
+  }
+//  display(inv, rows, rows);
+//  printf("\n");
+  
+  /* First -- convert into upper triangular  */
+  for (i = 0; i < cols; i++) {
+    row_start = cols*i;
+
+    /* Swap rows if we ave a zero i,i element.  If we can't swap, then the
+       matrix was not invertible  */
+
+    if (mat[row_start+i] == 0) {
+      for (j = i+1; j < rows && mat[cols*j+i] == 0; j++) ;
+      if (j == rows) return -1;
+      rs2 = j*cols;
+      for (k = 0; k < cols; k++) {
+        tmp = mat[row_start+k];
+        mat[row_start+k] = mat[rs2+k];
+        mat[rs2+k] = tmp;
+        tmp = inv[row_start+k];
+        inv[row_start+k] = inv[rs2+k];
+        inv[rs2+k] = tmp;
+      }
+    }
+ 
+    /* Multiply the row by 1/element i,i  */
+    tmp = mat[row_start+i];
+    if (tmp != 1) {
+      inverse = gf->divide.w64(gf,1, tmp);
+      for (j = 0; j < cols; j++) {
+        mat[row_start+j] = gf->multiply.w64(gf,mat[row_start+j], inverse);
+        inv[row_start+j] = gf->multiply.w64(gf,inv[row_start+j], inverse);
+      }
+    }
+
+    /* Now for each j>i, add A_ji*Ai to Aj  */
+    k = row_start+i;
+    for (j = i+1; j != cols; j++) {
+      k += cols;
+      if (mat[k] != 0) {
+        if (mat[k] == 1) {
+          rs2 = cols*j;
+          for (x = 0; x < cols; x++) {
+            mat[rs2+x] ^= mat[row_start+x];
+            inv[rs2+x] ^= inv[row_start+x];
+          }
+        } else {
+          tmp = mat[k];
+          rs2 = cols*j;
+          for (x = 0; x < cols; x++) {
+            mat[rs2+x] ^= gf->multiply.w64(gf,tmp, mat[row_start+x]);
+            inv[rs2+x] ^= gf->multiply.w64(gf,tmp, inv[row_start+x]);
+          }
+        }
+      }
+    }
+  }
+
+  /* Now the matrix is upper triangular.  Start at the top and multiply down  */
+
+  for (i = rows-1; i >= 0; i--) {
+    row_start = i*cols;
+    for (j = 0; j < i; j++) {
+      rs2 = j*cols;
+      if (mat[rs2+i] != 0) {
+        tmp = mat[rs2+i];
+        mat[rs2+i] = 0;
+        for (k = 0; k < cols; k++) {
+          inv[rs2+k] ^= gf->multiply.w64(gf,tmp, inv[row_start+k]);
+        }
+      }
+    }
+  }
+
+/*  printf("mat\n");
+  display(mat, rows, rows);
+  printf("\n");
+   printf("inv\n");
+  display(inv, rows, rows);
+  printf("\n");
+*/
+  return 0;
+}
+
+
+
+
+int invertible_matrix(gf_t *gf, int *mat, int rows, int w)
+{
+  int cols, i, j, k, x, rs2;
+  int row_start;
+  mylong tmp, inverse;
+ 
+  cols = rows;
+
+  /* First -- convert into upper triangular  */
+  for (i = 0; i < cols; i++) {
+    row_start = cols*i;
+
+    /* Swap rows if we ave a zero i,i element.  If we can't swap, then the 
+       matrix was not invertible  */
+
+    if (mat[row_start+i] == 0) { 
+      for (j = i+1; j < rows && mat[cols*j+i] == 0; j++) ;
+      if (j == rows) return 0;
+      rs2 = j*cols;
+      for (k = 0; k < cols; k++) {
+        tmp = mat[row_start+k];
+        mat[row_start+k] = mat[rs2+k];
+        mat[rs2+k] = tmp;
+      }
+    }
+ 
+    /* Multiply the row by 1/element i,i  */
+    tmp = mat[row_start+i];
+    if (tmp != 1) {
+      inverse =  gf->divide.w64(gf,1, tmp);
+      for (j = 0; j < cols; j++) { 
+        mat[row_start+j] =  gf->multiply.w64(gf,mat[row_start+j], inverse);
+      }
+    }
+
+    /* Now for each j>i, add A_ji*Ai to Aj  */
+    k = row_start+i;
+    for (j = i+1; j != cols; j++) {
+      k += cols;
+      if (mat[k] != 0) {
+        if (mat[k] == 1) {
+          rs2 = cols*j;
+          for (x = 0; x < cols; x++) {
+            mat[rs2+x] ^= mat[row_start+x];
+          }
+        } else {
+          tmp = mat[k];
+          rs2 = cols*j;
+          for (x = 0; x < cols; x++) {
+            mat[rs2+x] ^=  gf->multiply.w64(gf,tmp,mat[row_start+x]);
+          }
+        }
+      }
+    }
+  }
+  return 1;
+}
+
+
+
+
+
+mylong*  readFullFile(int n, int t, mylong& sizeFile, mylong & padded_size) {
+
+//  ifstream stream("lena.png", ios::in | ios::binary | ios::ate);
+//  ifstream stream("lena_small.png", ios::in | ios::binary | ios::ate);
+  ifstream stream("/home/couturie/Downloads/CARCARIASS.zip", ios::in | ios::binary | ios::ate);
+
+  sizeFile=stream.tellg();
+  std::cout << sizeFile << std::endl;
+  stream.seekg(0, ios::beg);
+
+
+
+  
+  
+
+  vector<uint8_t> contents((istreambuf_iterator<char>(stream)), istreambuf_iterator<char>());
+ 
+    
+
+
+  
+
+  
+  //make padding, we need to pad to be divisible by 8*t, we
+  if((sizeFile+8)%(8*t)!=0) {
+    cout<<(int)(sizeFile/(8*t))<<endl;
+    
+    int remainder=(8*t)*(1+(int)((sizeFile+8)/(8*t)))-sizeFile-8;
+    cout << "remainder " << remainder << endl;
+    uint8_t vec[remainder];
+    for(int i=0;i<remainder;i++)
+      vec[i]=0;
+    //add remainder elements at the end
+    contents.insert(contents.end(),vec,vec+remainder);
+    //add 8 elements at the beginning for the size
+    contents.insert(contents.begin(),vec,vec+8);
+  }
+  
+
+  
+  cout << "res contents " << contents.size() << endl;  
+
+//  for(int i=0;i<contents.size();i++)
+//    cout << (int)contents[i] << " ";
+  cout << endl;
+
+  uint8_t *p_contents=&contents[0];
+//  mylong *p_contents2=reinterpret_cast<mylong*>(p_contents);
+
+  padded_size=contents.size()/8;
+  
+  mylong *p_contents2=new mylong[padded_size];
+  memcpy(p_contents2,p_contents,sizeof(mylong)*padded_size);
+	 //mylong *p_contents2=(mylong*)p_contents;
+
+  p_contents2[0]=sizeFile;
+
+  
+
+  
+/*  for(int i=0;i<padded_size;i++)
+    cout << p_contents2[i] << " ";
+  cout << endl;
+*/
+  /* long res=0;
+  for(int i=8-1;i>=0;i--) {
+    res<<=8;
+    res+=p_contents[i];
+  }
+
+  cout << "convert val " << (long)res << endl;
+
+  res=0;
+  for(int i=16-1;i>=8;i--) {
+    res<<=8;
+    res+=p_contents[i];
+  }
+
+  cout << "convert val " << (long)res << endl;
+  */
+
+  return p_contents2;
+}
+
+
+void saveFile(uint8_t *data, const char *fileName,long size_file) {
+  cout<<"size file "<<size_file<<endl;
+  FILE* pFile = fopen (fileName, "wb");
+  fwrite (data , sizeof(uint8_t), size_file, pFile);
+
+  fclose (pFile);
+}
+
+
+void readFile(uint8_t *data, const char *fileName,long size_file) {
+  cout<<"size file "<<size_file<<endl;
+  FILE* pFile = fopen (fileName, "rb");
+
+  fseek(pFile, 0L, SEEK_END);
+  int sz = ftell(pFile);
+  rewind(pFile);
+  if(sz!=size_file) {
+    cout << "error : size of this chunk is not correct !! " << endl;
+    exit(0);
+  }
+  fread (data , sizeof(uint8_t), size_file, pFile);  
+
+  fclose (pFile);
+}
+
+
+void saveFile8(mylong *data, const char *fileName,long size_file) {
+
+  cout<<"size file 8 "<<size_file<<endl;
+      display(data,1,1);    
+    FILE* pFile = fopen (fileName, "wb");
+
+
+
+    fwrite (data , sizeof(mylong), size_file, pFile);
+    fclose (pFile);
+
+
+    
+}
+
+
+int main(int argc, char **argv)
+{
+  unsigned int  w;
+  int invert;
+  mylong *matS;
+  mylong *matG;
+  mylong *matC;
+  mylong *inverse;
+  mylong *identity;
+
+
+  int size=5000000;
+  int t=4;
+  int n=8;
+
+
+  w=64;
+  gf_t gf;
+  gf_init_easy(&gf, w);  
+
+  mylong padded_size;
+  mylong sizeFile;
+  matS=readFullFile(n,t,sizeFile,padded_size);
+
+  cout<<padded_size*8<<endl;
+  
+/* for(int i=0;i<padded_size;i++)
+    cout << matS[i] << " ";
+  cout << endl;
+*/
+  
+  int len=padded_size/t;
+//  int len=size/t;
+  cout<<" len "<<len<<" "<<padded_size<<endl;
+
+  // matS = malloc(sizeof(mylong)*t*len);
+  matG = malloc(sizeof(mylong)*t*n);
+
+
+
+
+  srand48(time(0));
+  std::srand ( unsigned ( std::time(0) ) );
+  
+/*
+  for(int i=0;i<t;i++) { 
+    for(int j=0;j<len;j++) {
+      matS[i*len+j]=lrand48()<<32|lrand48();
+    }
+  }
+  */
+
+  for(int i=0;i<n;i++) { 
+    for(int j=0;j<t;j++) {
+      matG[i*t+j]=lrand48()<<32|lrand48();
+    }
+  }
+
+
+
+  printf("Matrix S:\n");
+//  display(matS, len, t);
+  display(matS, t, t);
+
+  printf("Matrix G:\n");
+  display(matG, n, t);
+
+
+  auto start = std::chrono::system_clock::now();
+  matC=matrix_multiply(&gf, matG, matS, n, t, t, len, w);
+  auto end = std::chrono::system_clock::now();
+  std::chrono::duration<double> elapsed_seconds = end-start;
+  std::cout << "elapsed time: " << elapsed_seconds.count() << "s\n";
+
+//  display(matC,t,t);
+
+  
+  //Save trunks
+  for(int i=0;i<n;i++) {
+    stringstream ss;
+    ss <<"lena_"<<i<<".png";
+    string str = ss.str();
+    saveFile((uint8_t*)&matC[i*len], str.c_str(),len*sizeof(mylong));
+  }
+
+  
+
+  mylong *matCs = malloc(sizeof(mylong)*t*len);
+  mylong *matGs = malloc(sizeof(mylong)*t*t);
+
+
+  std::vector<int> myvector;
+  
+  // set some values:
+  for (int i=0; i<n; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9
+
+  // using built-in random generator:
+  random_shuffle ( myvector.begin(), myvector.end() );
+
+
+
+  std::cout << "random chunk" << std::endl;  
+  int ind=0;
+  for(int ii=0;ii<t;ii++) {
+//  for(int i=n-1;i>=t;i--) {
+//  for(int i=0;i<n;i+=2) {
+
+    auto i=myvector[ii];
+    std::cout << myvector[i] << " ";
+
+
+    stringstream ss;
+    ss <<"lena_"<<i<<".png";
+    string str = ss.str();
+    readFile((uint8_t*)&matCs[ind*len], str.c_str(),len*sizeof(mylong));
+
+//    display(&matCs[ind*len],1,1);
+//    display(&matC[i*len],1,1);
+    
+    /*for(int j=0;j<len;j++) {
+      matCs[ind*len+j]=matC[i*len+j];
+      }*/
+    
+
+    
+    for(int j=0;j<t;j++) {
+      matGs[ind*t+j]=matG[i*t+j];
+    }
+    ind++;
+  }
+  std::cout << std::endl;
+
+  
+  printf("Matrix Gs:\n");
+  display(matGs, t, t);
+
+//  printf("Matrix Cs:\n");
+//  display(matCs, t, len);
+  
+  mylong* matGs_copy = malloc(sizeof(mylong)* t*t);
+
+  //WARNING invert changes the matrix
+//  invert = invertible_matrix(&gf,matGs, t, w);
+//  printf("\nInvertible Gs: %s\n", (invert == 1) ? "Yes" : "No");
+
+  memcpy(matGs_copy, matGs, sizeof(mylong)*t*t);
+  mylong *matInvGs = malloc(sizeof(mylong)*t*t);
+  invert_matrix(&gf, matGs_copy, matInvGs, t);
+
+  /*
+  WARNING   this changes matGs
+  identity=matrix_multiply(&gf, matInvGs, matGs, t, t, t, t, w);
+  printf("Identity:\n");
+  display(identity, t, t);
+  */
+
+  
+  //printf("Matrix Gs:\n");
+  //display(matGs, t, t);
+  
+  mylong *matS2 = malloc(sizeof(mylong)*t*len);
+
+
+  start = std::chrono::system_clock::now();
+  matS2=matrix_multiply(&gf, matInvGs, matCs, t, t, t, len, w);
+  end = std::chrono::system_clock::now();
+  elapsed_seconds = end-start;
+  std::cout << "elapsed time: " << elapsed_seconds.count() << "s\n";
+
+
+  printf("Matrix S2:\n");
+//  display(matS2, len, t);
+  display(matS2, t, t);
+  
+  int equal=1;
+  for(int i=0;i<padded_size && equal;i++) {
+      equal=matS[i]==matS2[i];
+//      if(!equal)
+//	printf("ARGH\n");
+  }
+  if(equal)
+    printf("EQUAL !!!\n");
+
+
+  mylong new_size=matS2[0];
+  cout << "size of data " << new_size << endl;
+
+  
+  //first elements that contains the size is removed
+  uint8_t *reconstucted_data=reinterpret_cast<uint8_t*>(&matS2[1]);
+  saveFile(reconstucted_data, "lena2.png",new_size);
+  return 0;
+}
+
+ 
diff --git a/IDA/lena_small.png b/IDA/lena_small.png
deleted file mode 100644
index 872ef3ae8beed21e1eeb6558607a29a5849c2784..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2525
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

diff --git a/IDA/lena_small2.png b/IDA/lena_small2.png
deleted file mode 100644
index d02501f89fe9ad2b6b605d84c5bd5dd3523a21e5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 308
zcmV-40n7f0P)<h;3K|Lk000e1NJLTq000O8000OG0ssI2OKmCK00009a7bBm000XU
z000XU0RWnu7ytkO2XskIMF-&t8V@2Qvz1c80002fNkl<Z2-g9~05|^u=ZI~~z2qPr
z5c~}c`|I!y9S;f|3$Uiw0_foJ_WJ(u_xuAO91vYn;o0ln((mp51_A^G0tgEO1_cBC
z^ZoDI<0xuX((wdVP%8of0t5N)`Re@#r?J)#3I)-w$NcW^`UC+2^7#Dp4jQ%0??f>V
z0^{l7)8i;96a)(Z0{Z^~-|hb>Di_|)-3ayd=I-+o77QRX9s~dk3+M9Z1p5>N`TqV5
z13OJI^6~e}sLBEZ3I_T2`Rd~0J0uJN@9r-)B=+v?&&TI$f@R;vv4~>;0000<MNUMn
GLSTYbCw~+G

diff --git a/SboxAES/IOT/main.c b/SboxAES/IOT/main.c
index 34d24c2..90f4369 100644
--- a/SboxAES/IOT/main.c
+++ b/SboxAES/IOT/main.c
@@ -4,13 +4,14 @@
 #include<stdlib.h>
 #include <stdint.h>
 #include <string.h>
+#include <sys/time.h>
 #include"aes.h"
 #define CTR 1
 
 
 
 
-const int size_mesg=64;
+const int size_mesg=1024;
 
 typedef unsigned char byte;
 
@@ -19,6 +20,22 @@ typedef unsigned char byte;
 
 
 
+double TimeStart()
+{
+  struct timeval tstart;
+  gettimeofday(&tstart,0);
+  return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) );
+}
+
+double TimeStop(double t)
+{
+  struct timeval tend;
+
+  gettimeofday(&tend,0);
+  t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t;
+  return (t);
+}
+
 
 
 
@@ -63,26 +80,46 @@ int main(int argc, char** argv) {
   for(int i=0;i<size_mesg;i++) {
     plain[i]=i;
   }
-  for(int i=0;i<size_mesg;i++) {
+/*  for(int i=0;i<size_mesg;i++) {
     printf("%d ",plain[i]);
   }
   printf("\n\n");
-  
+*/
   struct AES_ctx ctx;
-  rc4key(mykey, 8);
 
+  int nb_times=1000;
+  
+  double time=0;
+  double t=TimeStart();
+  for(int i=0;i<nb_times;i++)
+    rc4key(mykey, 8);
+  time+=TimeStop(t);
+  printf("time generate sbox %f\n",time);
+  
     
 //  AES_init_ctx_iv(&ctx, mykey, iv);
-  My_KeyExpansion(ctx.RoundKey, mykey);
-  memcpy (ctx.Iv, iv, AES_BLOCKLEN);
-  My_AES_CTR_xcrypt_buffer(&ctx, plain, size_mesg);
+  time=0;
+  t=TimeStart();
+  for(int i=0;i<nb_times;i++) {
+    My_KeyExpansion(ctx.RoundKey, mykey);
+    memcpy (ctx.Iv, iv, AES_BLOCKLEN);
+  }
 
+  time+=TimeStop(t);
+  printf("time key expansion %f\n",time);
 
+  time=0;
+  t=TimeStart();
+  for(int i=0;i<nb_times;i++)
+    My_AES_CTR_xcrypt_buffer(&ctx, plain, size_mesg);
+  time+=TimeStop(t);
+  printf("time cipher %f size %d\n",time,size_mesg);
 
-  for(int i=0;i<size_mesg;i++) {
+
+/*  for(int i=0;i<size_mesg;i++) {
     printf("%d ",plain[i]);
   }
-
+*/
   printf("\n\n");
 //  AES_init_ctx_iv(&ctx, mykey, iv);
   My_KeyExpansion(ctx.RoundKey, mykey);
@@ -92,9 +129,9 @@ int main(int argc, char** argv) {
   My_AES_CTR_xcrypt_buffer(&ctx, plain, size_mesg);
 
 
-  for(int i=0;i<size_mesg;i++) {
+  /* for(int i=0;i<size_mesg;i++) {
     printf("%d ",plain[i]);
-  }
+    }*/
 
   printf("\n\n");
 
-- 
2.39.5