Update libsrtp to upstream 1.5.0

srtp/crypto/test/cipher_driver.c

 /*
  * cipher_driver.c
  *
  * A driver for the generic cipher type
  *
  * David A. McGrew
  * Cisco Systems, Inc.
  */
 
 /*
  *      
- * Copyright (c) 2001-2006, Cisco Systems, Inc.
+ * Copyright (c) 2001-2006,2013 Cisco Systems, Inc.
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 
  *   Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
  * 
  *   Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
 
+#ifdef HAVE_CONFIG_H
+    #include <config.h>
+#endif
+
 #include <stdio.h>           /* for printf() */
 #include <stdlib.h>          /* for rand() */
 #include <string.h>          /* for memset() */
 #include <unistd.h>          /* for getopt() */
 #include "cipher.h"
+#ifdef OPENSSL
+#include "aes_icm_ossl.h"
+#include "aes_gcm_ossl.h"
+#else
 #include "aes_icm.h"
+#endif
 #include "null_cipher.h"
 
 #define PRINT_DEBUG 0
 
 void
 cipher_driver_test_throughput(cipher_t *c);
 
 err_status_t
 cipher_driver_self_test(cipher_type_t *ct);
 
@@ skipping 45 matching lines @@
 }
 
 /*
  * null_cipher, aes_icm, and aes_cbc are the cipher meta-objects
  * defined in the files in crypto/cipher subdirectory.  these are
  * declared external so that we can use these cipher types here
  */
 
 extern cipher_type_t null_cipher;
 extern cipher_type_t aes_icm;
+#ifndef OPENSSL
 extern cipher_type_t aes_cbc;
+#else
+#ifndef SRTP_NO_AES192
+extern cipher_type_t aes_icm_192;
+#endif
+extern cipher_type_t aes_icm_256;
+extern cipher_type_t aes_gcm_128_openssl;
+extern cipher_type_t aes_gcm_256_openssl;
+#endif
 
 int
 main(int argc, char *argv[]) {
   cipher_t *c = NULL;
   err_status_t status;
   unsigned char test_key[48] = {
     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
@@ skipping 36 matching lines @@
   if (do_array_timing_test) {
     int max_num_cipher = 1 << 16;   /* number of ciphers in cipher_array */
     int num_cipher;
     
     for (num_cipher=1; num_cipher < max_num_cipher; num_cipher *=8)
       cipher_driver_test_array_throughput(&null_cipher, 0, num_cipher); 
 
     for (num_cipher=1; num_cipher < max_num_cipher; num_cipher *=8)
       cipher_driver_test_array_throughput(&aes_icm, 30, num_cipher); 
 
+#ifndef OPENSSL
     for (num_cipher=1; num_cipher < max_num_cipher; num_cipher *=8)
       cipher_driver_test_array_throughput(&aes_icm, 46, num_cipher); 
 
     for (num_cipher=1; num_cipher < max_num_cipher; num_cipher *=8)
       cipher_driver_test_array_throughput(&aes_cbc, 16, num_cipher); 
  
     for (num_cipher=1; num_cipher < max_num_cipher; num_cipher *=8)
       cipher_driver_test_array_throughput(&aes_cbc, 32, num_cipher); 
+#else
+#ifndef SRTP_NO_AES192
+    for (num_cipher=1; num_cipher < max_num_cipher; num_cipher *=8)
+      cipher_driver_test_array_throughput(&aes_icm_192, 38, num_cipher); 
+#endif
+    for (num_cipher=1; num_cipher < max_num_cipher; num_cipher *=8)
+      cipher_driver_test_array_throughput(&aes_icm_256, 46, num_cipher); 
+
+    for (num_cipher=1; num_cipher < max_num_cipher; num_cipher *=8) {
+        cipher_driver_test_array_throughput(&aes_gcm_128_openssl, AES_128_GCM_KEYSIZE_WSALT, num_cipher);         
+    }
+
+    for (num_cipher=1; num_cipher < max_num_cipher; num_cipher *=8) {
+        cipher_driver_test_array_throughput(&aes_gcm_256_openssl, AES_256_GCM_KEYSIZE_WSALT, num_cipher);         
+    }
+#endif
   }
 
   if (do_validation) {
     cipher_driver_self_test(&null_cipher);
     cipher_driver_self_test(&aes_icm);
+#ifndef OPENSSL
     cipher_driver_self_test(&aes_cbc);
+#else
+#ifndef SRTP_NO_AES192
+    cipher_driver_self_test(&aes_icm_192);
+#endif
+    cipher_driver_self_test(&aes_icm_256);
+    cipher_driver_self_test(&aes_gcm_128_openssl);
+    cipher_driver_self_test(&aes_gcm_256_openssl);
+#endif
   }
 
   /* do timing and/or buffer_test on null_cipher */
-  status = cipher_type_alloc(&null_cipher, &c, 0); 
+  status = cipher_type_alloc(&null_cipher, &c, 0, 0); 
   check_status(status);
 
-  status = cipher_init(c, NULL, direction_encrypt);
+  status = cipher_init(c, NULL);
   check_status(status);
 
   if (do_timing_test) 
     cipher_driver_test_throughput(c);
   if (do_validation) {
     status = cipher_driver_test_buffering(c);
     check_status(status);
   }
   status = cipher_dealloc(c);
   check_status(status);
   
 
   /* run the throughput test on the aes_icm cipher (128-bit key) */
-    status = cipher_type_alloc(&aes_icm, &c, 30);  
+    status = cipher_type_alloc(&aes_icm, &c, 30, 0);  
     if (status) {
       fprintf(stderr, "error: can't allocate cipher\n");
       exit(status);
     }
 
-    status = cipher_init(c, test_key, direction_encrypt);
+    status = cipher_init(c, test_key);
     check_status(status);
 
     if (do_timing_test)
       cipher_driver_test_throughput(c);
     
     if (do_validation) {
       status = cipher_driver_test_buffering(c);
       check_status(status);
     }
     
     status = cipher_dealloc(c);
     check_status(status);
 
   /* repeat the tests with 256-bit keys */
-    status = cipher_type_alloc(&aes_icm, &c, 46);  
+#ifndef OPENSSL
+    status = cipher_type_alloc(&aes_icm, &c, 46, 0);  
+#else
+    status = cipher_type_alloc(&aes_icm_256, &c, 46, 0);  
+#endif
     if (status) {
       fprintf(stderr, "error: can't allocate cipher\n");
       exit(status);
     }
 
-    status = cipher_init(c, test_key, direction_encrypt);
+    status = cipher_init(c, test_key);
     check_status(status);
 
     if (do_timing_test)
       cipher_driver_test_throughput(c);
     
     if (do_validation) {
       status = cipher_driver_test_buffering(c);
       check_status(status);
     }
     
     status = cipher_dealloc(c);
     check_status(status);
-  
-  return 0;
+
+#ifdef OPENSSL
+    /* run the throughput test on the aes_gcm_128_openssl cipher */
+    status = cipher_type_alloc(&aes_gcm_128_openssl, &c, AES_128_GCM_KEYSIZE_WSALT, 8);
+    if (status) {
+        fprintf(stderr, "error: can't allocate GCM 128 cipher\n");
+        exit(status);
+    }
+    status = cipher_init(c, test_key);
+    check_status(status);
+    if (do_timing_test) {
+        cipher_driver_test_throughput(c);
+    }
+
+    if (do_validation) {
+        status = cipher_driver_test_buffering(c);
+        check_status(status);
+    }
+    status = cipher_dealloc(c);
+    check_status(status);
+
+    /* run the throughput test on the aes_gcm_256_openssl cipher */
+    status = cipher_type_alloc(&aes_gcm_256_openssl, &c, AES_256_GCM_KEYSIZE_WSALT, 16);
+    if (status) {
+        fprintf(stderr, "error: can't allocate GCM 256 cipher\n");
+        exit(status);
+    }
+    status = cipher_init(c, test_key);
+    check_status(status);
+    if (do_timing_test) {
+        cipher_driver_test_throughput(c);
+    }
+
+    if (do_validation) {
+        status = cipher_driver_test_buffering(c);
+        check_status(status);
+    }
+    status = cipher_dealloc(c);
+    check_status(status);
+#endif 
+
+    return 0;
 }
 
 void
 cipher_driver_test_throughput(cipher_t *c) {
   int i;
   int min_enc_len = 32;     
   int max_enc_len = 2048;   /* should be a power of two */
   int num_trials = 1000000;  
   
   printf("timing %s throughput, key length %d:\n", c->type->description, c->key_len);
@@ skipping 39 matching lines @@
   printf("testing output buffering for cipher %s...",
          c->type->description);
 
   for (i=0; i < num_trials; i++) {
 
    /* set buffers to zero */
     for (j=0; j < buflen; j++) 
       buffer0[j] = buffer1[j] = 0;
     
     /* initialize cipher  */
-    status = cipher_set_iv(c, idx);
+    status = cipher_set_iv(c, idx, direction_encrypt);
     if (status)
       return status;
 
     /* generate 'reference' value by encrypting all at once */
     status = cipher_encrypt(c, buffer0, &buflen);
     if (status)
       return status;
 
     /* re-initialize cipher */
-    status = cipher_set_iv(c, idx);
+    status = cipher_set_iv(c, idx, direction_encrypt);
     if (status)
       return status;
     
     /* now loop over short lengths until buffer1 is encrypted */
     current = buffer1;
     end = buffer1 + buflen;
     while (current < end) {
 
       /* choose a short length */
       len = rand() & 0x01f;
@@ skipping 63 matching lines @@
   key = crypto_alloc(klen_pad);
   if (key == NULL) {
     free(cipher_array);
     return err_status_alloc_fail;
   }
   
   /* allocate and initialize an array of ciphers */
   for (i=0; i < num_ciphers; i++) {
 
     /* allocate cipher */
-    status = cipher_type_alloc(ctype, cipher_array, klen);
+    status = cipher_type_alloc(ctype, cipher_array, klen, 16);
     if (status)
       return status;
     
     /* generate random key and initialize cipher */
     for (j=0; j < klen; j++)
       key[j] = (uint8_t) rand();
     for (; j < klen_pad; j++)
       key[j] = 0;
-    status = cipher_init(*cipher_array, key, direction_encrypt);
+    status = cipher_init(*cipher_array, key);
     if (status)
       return status;
 
 /*     printf("%dth cipher is at %p\n", i, *cipher_array); */
 /*     printf("%dth cipher description: %s\n", i,  */
 /*         (*cipher_array)->type->description); */
     
     /* advance cipher array pointer */
     cipher_array++;
   }
@@ skipping 46 matching lines @@
   
   /* time repeated trials */
   v128_set_to_zero(&nonce);
   timer = clock();
   for(i=0; i < num_trials; i++, nonce.v32[3] = i) {
     /* length parameter to cipher_encrypt is in/out -- out is total, padded
      * length -- so reset it each time. */
     unsigned octets_to_encrypt = octets_in_buffer;
 
     /* encrypt buffer with cipher */
-    cipher_set_iv(cipher_array[cipher_index], &nonce);
+    cipher_set_iv(cipher_array[cipher_index], &nonce, direction_encrypt);
     cipher_encrypt(cipher_array[cipher_index], enc_buf, &octets_to_encrypt);
 
     /* choose a cipher at random from the array*/
     cipher_index = (*((uint32_t *)enc_buf)) % num_cipher;
   }
   timer = clock() - timer;
 
   free(enc_buf);
 
   if (timer == 0) {
@@ skipping 32 matching lines @@
            status);
     return status;
   }
   
   cipher_array_test_throughput(ca, num_cipher);
   
   cipher_array_delete(ca, num_cipher);    
  
   return err_status_ok;
 }