#include<string.h>
#include <fstream>
#include <sys/time.h>
+#include <arm_neon.h>
/*#include <cryptopp/hex.h>
#include <cryptopp/sha.h>
for(int i=0;i<size_tab;i++) {
inv_perm_tabs[tab[i]] = i;
}
-
}
}
+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) {
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
int seed=time(NULL);
+ seed=12;
cout<<seed<<endl;
srand48(seed);
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];
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++) {
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];
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;
}
+
+ 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;
