drivers/char/mxhwenp/test/test_ssl.c

   1 #include <unistd.h>
   2 #include <sys/types.h>
   3 #ifdef MODULE
   4 #define PTIME printk
   5 #else
   6 #include <time.h>
   7 #include <sys/times.h>
   8 #include <mxhw_crypto_wrapper.h>
   9 #define PTIME printf
  10 #endif
  11 #include <test_ssl.h>
  12
  13 int
  14 BIO_snprintf(char *buf, size_t size, const char *format, ...){return 0;}
  15
  16 static double timeSWT[16],timeHWU[16],timeHWS[16];
  17
  18 u_int
  19 fill_data(u_char *buf, u_int size)
  20 {
  21         u_char  *p = buf;
  22         int     i;
  23         static int first=1;
  24
  25         if (first)
  26         {
  27                 srand(time(0));
  28                 first=0;
  29         }
  30         if (size==0)
  31                 size = 160+((rand()%(MAX_BUF-160))&0xfffffff0);
  32
  33         for(i=0; i<size ;i++,p++)
  34                 *p = rand()&0xff;
  35
  36     return size;
  37 }
  38
  39
  40 void
  41 times_reset(u_int numPktSizes)
  42 {
  43         memset(timeSWT, 0, 16*sizeof(unsigned int));
  44         memset(timeHWU, 0, 16*sizeof(unsigned int));
  45         memset(timeHWS, 0, 16*sizeof(unsigned int));
  46 }
  47
  48 unsigned int ixOsServTimestampGet(void);
  49
  50 u_int
  51 timestamps()
  52 {
  53 #ifdef MODULE
  54         return ixOsServTimestampGet();
  55 #else
  56         return times(0);
  57 #endif
  58 }
  59
  60 void
  61 timeswhw(double *swT, double *hwT, int idx)
  62 {
  63         *hwT = timeHWU[idx];
  64         *swT = timeSWT[idx];
  65 }
  66
  67 void
  68 timereport(char *name, u_int *pktSizes, u_int max, u_int numPkt, u_int total)
  69 {
  70         unsigned int m;
  71         double bytes;
  72
  73         if (max<2)
  74                 return;
  75
  76         PTIME("\n%ld/%ld\t%s*\t%s\t(M)\t(M)\tRATE\t%s*K\n",numPkt, total,name, name, name);
  77         for(m=0; m < max; m++)
  78         {
  79                 bytes = (double) pktSizes[m]*numPkt/1e6;
  80
  81                 PTIME("%d\t%.2lf\t%.2lf\t%.2lf\t%.2lf\t%.2lf\t%.2lf\n",
  82                         pktSizes[m],                                                    /* # of packets */
  83                         timeHWU[m],                                                     /* hw total time */
  84                         timeSWT[m],                                                     /* hw system time */
  85                         (timeHWU[m]!=0)? bytes/timeHWU[m]:0,    /* hw in M bytes */
  86                         (timeSWT[m]!=0)? bytes/timeSWT[m]:0,    /* sw in M bytes */
  87                         (timeHWU[m]!=0)? timeSWT[m]/timeHWU[m]:0, /* rate */
  88                         timeHWS[m]);
  89         }
  90 }
  91
  92 static unsigned int
  93 timestick(unsigned int end, unsigned int start)
  94 {
  95         return (end<start)? (0xffffffff-start+end+1):(end-start);
  96 }
  97
  98 void
  99 timeit(u_int hwsw, u_int idx, int type, int add)
 100 {
 101         static struct tms tstart, tend;
 102         static clock_t s, e;
 103
 104         if (idx>15)
 105                 return;
 106
 107         if (type==TSTART)
 108         {
 109                 s = times(&tstart);
 110         }
 111         else
 112         {
 113                 double d;
 114
 115                 e = times(&tend);
 116
 117                 if (hwsw==ISSW)
 118                 {
 119                         d = (double) timestick(e, s)/sysconf(_SC_CLK_TCK);
 120                         if (add)
 121                                 timeSWT[idx] += d;
 122                         else
 123                                 timeSWT[idx] = d;
 124                 }
 125                 else
 126                 {
 127                         d = (double) timestick(e, s)/sysconf(_SC_CLK_TCK);
 128                         if (add)
 129                                 timeHWU[idx] += d;
 130                         else
 131                                 timeHWU[idx] = d;
 132                         d = (double) timestick(tend.tms_stime,tstart.tms_stime)/sysconf(_SC_CLK_TCK);
 133                         if (add)
 134                                 timeHWS[idx] += d;
 135                         else
 136                                 timeHWS[idx] = d;
 137                 }
 138         }
 139 }
 140
 141 void
 142 test_set_keys(TESTHW *t, u_char *keys, int IS_AES)
 143 {
 144         if (IS_AES)
 145         {
 146 #if OPENSSL_VERSION_NUMBER >= 0x00907000L
 147                 if (AES_set_encrypt_key(keys, t->klen<<3, &t->AESKey1) ||
 148                         AES_set_decrypt_key(keys, t->klen<<3, &t->AESKey2))
 149                         return;
 150                 t->key1 = &t->AESKey1;
 151                 t->key2 = &t->AESKey2;
 152                 t->key3 = NULL;
 153 #endif
 154         }
 155         else
 156         {
 157                 DES_set_key_unchecked((DES_cblock*) keys,               &t->DESks1);
 158                 DES_set_key_unchecked((DES_cblock*) (keys+8),   &t->DESks2);
 159                 DES_set_key_unchecked((DES_cblock*) (keys+16),  &t->DESks3);
 160                 t->key1 = &t->DESks1;
 161                 t->key2 = &t->DESks2;
 162                 t->key3 = &t->DESks3;
 163         }
 164 }
 165
 166 TCIPHER(test_DES_ecb_encrypt)
 167 {
 168         if (length < HWACC_PKTLEN_MIN_DES || mxcrypto_perfrom(MXCIPHER_ALGO_DES, MXCIPHER_MODE_ECB,
 169                                 (const u_char *) input, output, length, ks1, NULL, NULL, NULL,0, enc))
 170         {
 171                 u_int len=0;
 172                 while (len < length)
 173                 {
 174                         DES_ecb_encrypt((const_DES_cblock*) (input+len),(DES_cblock*)(output+len),
 175                                 (DES_key_schedule*) ks1,enc);
 176                         len+=8;
 177                 }
 178         }
 179 }
 180
 181 TCIPHER(test_DES_cbc_encrypt)
 182 {
 183         DES_ncbc_encrypt(input,output, length,(DES_key_schedule*)ks1,(DES_cblock*)ivec, enc);
 184 }
 185
 186 #ifdef CPE_ENGINE
 187 TCIPHER(test_DES_cfb_encrypt)
 188 {
 189         DES_cfb_encrypt(input,output,8,length,(DES_key_schedule*)ks1,(DES_cblock*)ivec, enc);
 190 }
 191
 192 TCIPHER(test_DES_ofb_encrypt)
 193 {
 194         int blks = 0;
 195         DES_ofb64_encrypt(input,output,length,(DES_key_schedule*)ks1,(DES_cblock*)ivec, &blks);
 196 }
 197
 198 /* not supported by CPE */
 199 TCIPHER(test_DES_cfb64_encrypt)
 200 {
 201         int blks=0;
 202         DES_cfb64_encrypt(input,output,length,(DES_key_schedule*)ks1,(DES_cblock*)ivec, &blks, enc);
 203 }
 204
 205 #endif
 206
 207 TCIPHER(test_DES_ecb3_encrypt)
 208 {
 209         if (length < HWACC_PKTLEN_MIN || mxcrypto_perfrom(MXCIPHER_ALGO_3DES, MXCIPHER_MODE_ECB,
 210                                         (const u_char *) input, output, length, ks1, ks2, ks3, NULL,0, enc))
 211         {
 212                 u_int len=0;
 213
 214                 while (len < length)
 215                 {
 216                         DES_ecb3_encrypt(input+len, output+len,
 217                         (DES_key_schedule*)ks1, (DES_key_schedule*)ks2, (DES_key_schedule*)ks3, enc);
 218                         len+=8;
 219                 }
 220         }
 221 }
 222
 223 TCIPHER(test_DES_ede3_cbc_encrypt)
 224 {
 225         DES_ede3_cbc_encrypt(input, output, length,
 226                 (DES_key_schedule*)ks1, (DES_key_schedule*)ks2, (DES_key_schedule*)ks3, (DES_cblock*)ivec, enc);
 227 }
 228
 229 #ifdef CPE_ENGINE
 230 TCIPHER(test_DES_ede3_ofb64_encrypt)
 231 {
 232         int blks = 0;
 233         DES_ede3_ofb64_encrypt(input, output, length,
 234                 (DES_key_schedule*)ks1, (DES_key_schedule*)ks2, (DES_key_schedule*)ks3, (DES_cblock*)ivec, &blks);
 235 }
 236
 237 TCIPHER(test_DES_ede3_cfb64_encrypt)
 238 {
 239         DES_ede3_cfb_encrypt(input, output, 8, length,
 240                 (DES_key_schedule*)ks1, (DES_key_schedule*)ks2, (DES_key_schedule*)ks3, (DES_cblock*)ivec, enc);
 241 }
 242 #endif
 243
 244 #if OPENSSL_VERSION_NUMBER >= 0x00907000L
 245 TCIPHER(test_AES_ecb_encrypt)
 246 {
 247         if (length < HWACC_PKTLEN_MIN || mxcrypto_perfrom(MXCIPHER_ALGO_AES, MXCIPHER_MODE_ECB,
 248                                         (const u_char *) input, output, length, ks1, NULL, NULL, NULL, 0, enc)!=0)
 249         {
 250         u_int len=0;
 251         while (len < length)
 252         {
 253                 AES_ecb_encrypt(input+len, output+len, (const AES_KEY *) (enc? ks1:ks2), enc);
 254                 len+=AES_BLOCK_SIZE;
 255         }
 256         }
 257 }
 258
 259 TCIPHER(test_AES_cbc_encrypt)
 260 {
 261         AES_cbc_encrypt(input, output, length, (const AES_KEY *) (enc? ks1:ks2), ivec, enc);
 262 }
 263
 264 TCIPHER(test_AES_ctr_encrypt)
 265 {
 266         unsigned char ctr[AES_BLOCK_SIZE];
 267         int blks=0;
 268
 269         memset(ctr, 0, AES_BLOCK_SIZE);
 270         AES_ctr128_encrypt(input, output, length, (const AES_KEY *) ks1, ivec, ctr, &blks);
 271 }
 272
 273 #ifdef CPE_ENGINE
 274 TCIPHER(test_AES_cfb_encrypt)
 275 {
 276         int blks=0;
 277         AES_cfb8_encrypt(input, output, length, (const AES_KEY *) ks1, ivec, &blks, enc);
 278 }
 279
 280 TCIPHER(test_AES_cfb128_encrypt)
 281 {
 282         int blks=0;
 283         AES_cfb128_encrypt(input, output, length, (const AES_KEY *) ks1, ivec, &blks, enc);
 284 }
 285
 286 TCIPHER(test_AES_ofb_encrypt)
 287 {
 288         int blks=0;
 289         AES_ofb128_encrypt(input, output, length, (const AES_KEY *) ks1, ivec, &blks);
 290 }
 291 #endif
 292 #endif