timing_aes.c

voice test voice test

#include <openssl/crypto.h>
#include <openssl/aes.h>

#include "ippcp.h"
#include "ippcore.h"


static
Ipp8u* SetRandom8u(Ipp8u* pData, int len)
{
   int i;
   for(i=0; i<len; i++ )
      pData[i] = (Ipp8u)(rand( ) >> 4);
   return pData;
}


int compareCycles(const void* pt1, const void* pt2)
{
   Ipp64s t = *((Ipp64s*)pt1) - *((Ipp64s*)pt2);
   return t==0? 0 : (t>0)? 1 : -1;
}

#define MAX_LOOPS (21)

int TimingAES_CBC(int minLen, int maxLen)
{
   Ipp8u* pPText = malloc(maxLen);
   Ipp8u* pCText = malloc(maxLen);

   if(pPText && pCText) {
      int keySize[] = {128,192,256};
      int ks;

      Ipp8u iv[16];
      Ipp8u secret_key[32];

      SetRandom8u(secret_key, 32);
      SetRandom8u(iv, 16);

      SetRandom8u(pPText, maxLen);


      for(ks=0; ks<sizeof(keySize)/sizeof(keySize[0]); ks++) {
         AES_KEY aes_enc;
         AES_KEY aes_dec;

         Ipp64s t[MAX_LOOPS];
         int len;

         AES_set_encrypt_key(secret_key, keySize[ks], &aes_enc);
         AES_set_decrypt_key(secret_key, keySize[ks], &aes_dec);

         for(len=minLen; len<=maxLen; len*=2) {
            Ipp64s start, stop;
            int n;

            for(n=0; n<MAX_LOOPS; n++) {
               //sysTimeTicks(&start);
               start = ippGetCpuClocks();
               AES_cbc_encrypt(pPText, pCText, len, &aes_enc, iv, 1);
               //sysTimeTicks(&stop);
               stop = ippGetCpuClocks();
               t[n] = (stop-start);
            }
            qsort(t, MAX_LOOPS, sizeof(Ipp64s), compareCycles);
            fprintf(stdout, "AES_CBC,enc,%d,%5d,%6.2f\n", keySize[ks], len, (double)t[MAX_LOOPS/2]/len);

            for(n=0; n<MAX_LOOPS; n++) {
               //sysTimeTicks(&start);
               start = ippGetCpuClocks();
               AES_cbc_encrypt(pPText, pCText, len, &aes_dec, iv, 0);
               //sysTimeTicks(&stop);
               stop = ippGetCpuClocks();
               t[n] = (stop-start);
            }
            qsort(t, MAX_LOOPS, sizeof(Ipp64s), compareCycles);
            fprintf(stdout, "AES_CBC,dec,%d,%5d,%6.2f\n", keySize[ks], len, (double)t[MAX_LOOPS/2]/len);
         }
      }

      free(pCText);
      free(pPText);
      return 1;
   }
   return 0;
}

int TimingAES_CFB(int minLen, int maxLen)
{
   Ipp8u* pPText = malloc(maxLen);
   Ipp8u* pCText = malloc(maxLen);

   if(pPText && pCText) {
      int keySize[] = {128,192,256};
      int ks;

      Ipp8u iv[16];
      Ipp8u secret_key[32];

      SetRandom8u(secret_key, 32);
      SetRandom8u(iv, 16);

      SetRandom8u(pPText, maxLen);


      for(ks=0; ks<sizeof(keySize)/sizeof(keySize[0]); ks++) {
         AES_KEY aes;

         Ipp64s t[MAX_LOOPS];
         int len;

         AES_set_encrypt_key(secret_key, keySize[ks], &aes);

         for(len=minLen; len<=maxLen; len*=2) {
            Ipp64s start, stop;
            int n;
            int num = 0;

            for(n=0; n<MAX_LOOPS; n++) {
               //sysTimeTicks(&start);
               start = ippGetCpuClocks();
               AES_cfb128_encrypt(pPText, pCText, len, &aes, iv, &num, 1);
               //sysTimeTicks(&stop);
               stop = ippGetCpuClocks();
               t[n] = (stop-start);
            }
            qsort(t, MAX_LOOPS, sizeof(Ipp64s), compareCycles);
            fprintf(stdout, "AES_CFB,enc,%d,%5d,%6.2f\n", keySize[ks], len, (double)t[MAX_LOOPS/2]/len);

            for(n=0; n<MAX_LOOPS; n++) {
               //sysTimeTicks(&start);
               start = ippGetCpuClocks();
               AES_cfb128_encrypt(pPText, pCText, len, &aes, iv, &num, 0);
               //sysTimeTicks(&stop);
               stop = ippGetCpuClocks();
               t[n] = (stop-start);
            }
            qsort(t, MAX_LOOPS, sizeof(Ipp64s), compareCycles);
            fprintf(stdout, "AES_CFB,dec,%d,%5d,%6.2f\n", keySize[ks], len, (double)t[MAX_LOOPS/2]/len);
         }
      }

      free(pCText);
      free(pPText);
      return 1;
   }
   return 0;
}

int TimingAES_OFB(int minLen, int maxLen)
{
   Ipp8u* pPText = malloc(maxLen);
   Ipp8u* pCText = malloc(maxLen);

   if(pPText && pCText) {
      int keySize[] = {128,192,256};
      int ks;

      Ipp8u iv[16];
      Ipp8u secret_key[32];

      SetRandom8u(secret_key, 32);
      SetRandom8u(iv, 16);

      SetRandom8u(pPText, maxLen);


      for(ks=0; ks<sizeof(keySize)/sizeof(keySize[0]); ks++) {
         AES_KEY aes;

         Ipp64s t[MAX_LOOPS];
         int len;

         AES_set_encrypt_key(secret_key, keySize[ks], &aes);

         for(len=minLen; len<=maxLen; len*=2) {
            Ipp64s start, stop;
            int n;
            int num = 0;

            for(n=0; n<MAX_LOOPS; n++) {
               //sysTimeTicks(&start);
               start = ippGetCpuClocks();
               AES_ofb128_encrypt(pPText, pCText, len, &aes, iv, &num);
               //sysTimeTicks(&stop);
               stop = ippGetCpuClocks();
               t[n] = (stop-start);
            }
            qsort(t, MAX_LOOPS, sizeof(Ipp64s), compareCycles);
            fprintf(stdout, "AES_OFB,enc,%d,%5d,%6.2f\n", keySize[ks], len, (double)t[MAX_LOOPS/2]/len);
         }
      }

      free(pCText);
      free(pPText);
      return 1;
   }
   return 0;
}


#define MIN_LEN   (256)
#define MAX_LEN   (16384)


int main(void)
{
   fprintf(stdout, "mode,operation,keysize,data length,cycles/byte\n");

   TimingAES_CBC(MIN_LEN, MAX_LEN);
   TimingAES_CFB(MIN_LEN, MAX_LEN);
   TimingAES_OFB(MIN_LEN, MAX_LEN);
   return 0;
}