FS-9785: upgrade libsrtp to 2.1

libs/srtp/crypto/test/cipher_driver.c

@@ -9,7 +9,7 @@
 
 /*
  *	
- * Copyright (c) 2001-2006,2013 Cisco Systems, Inc.
+ * Copyright (c) 2001-2017 Cisco Systems, Inc.
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
@@ -43,10 +43,14 @@
  *
  */
 
+#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 "getopt_s.h"
 #include "cipher.h"
 #ifdef OPENSSL
 #include "aes_icm_ossl.h"
@@ -54,15 +58,14 @@
 #else
 #include "aes_icm.h"
 #endif
-#include "null_cipher.h"
 
 #define PRINT_DEBUG 0
 
 void
-cipher_driver_test_throughput(cipher_t *c);
+cipher_driver_test_throughput(srtp_cipher_t *c);
 
-err_status_t
-cipher_driver_self_test(cipher_type_t *ct);
+srtp_err_status_t
+cipher_driver_self_test(srtp_cipher_type_t *ct);
 
 
 /*
@@ -71,30 +74,30 @@ cipher_driver_self_test(cipher_type_t *ct);
  * calls
  */
 
-err_status_t
-cipher_driver_test_buffering(cipher_t *c);
+srtp_err_status_t
+cipher_driver_test_buffering(srtp_cipher_t *c);
 
 
 /*
  * functions for testing cipher cache thrash
  */
-err_status_t
-cipher_driver_test_array_throughput(cipher_type_t *ct, 
+srtp_err_status_t
+cipher_driver_test_array_throughput(srtp_cipher_type_t *ct, 
 				    int klen, int num_cipher);
 
 void
-cipher_array_test_throughput(cipher_t *ca[], int num_cipher);
+cipher_array_test_throughput(srtp_cipher_t *ca[], int num_cipher);
 
 uint64_t
-cipher_array_bits_per_second(cipher_t *cipher_array[], int num_cipher, 
+cipher_array_bits_per_second(srtp_cipher_t *cipher_array[], int num_cipher, 
 			     unsigned octets_in_buffer, int num_trials);
 
-err_status_t
-cipher_array_delete(cipher_t *cipher_array[], int num_cipher);
+srtp_err_status_t
+cipher_array_delete(srtp_cipher_t *cipher_array[], int num_cipher);
 
-err_status_t
-cipher_array_alloc_init(cipher_t ***cipher_array, int num_ciphers,
-			cipher_type_t *ctype, int klen);
+srtp_err_status_t
+cipher_array_alloc_init(srtp_cipher_t ***cipher_array, int num_ciphers,
+			srtp_cipher_type_t *ctype, int klen);
 
 void
 usage(char *prog_name) {
@@ -103,7 +106,7 @@ usage(char *prog_name) {
 }
 
 void
-check_status(err_status_t s) {
+check_status(srtp_err_status_t s) {
   if (s) {
     printf("error (code %d)\n", s);
     exit(s);
@@ -112,26 +115,24 @@ check_status(err_status_t s) {
 }
 
 /*
- * null_cipher, aes_icm, and aes_cbc are the cipher meta-objects
+ * null_cipher and srtp_aes_icm 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
-extern cipher_type_t aes_icm_192;
-extern cipher_type_t aes_icm_256;
-extern cipher_type_t aes_gcm_128_openssl;
-extern cipher_type_t aes_gcm_256_openssl;
+extern srtp_cipher_type_t srtp_null_cipher;
+extern srtp_cipher_type_t srtp_aes_icm_128;
+extern srtp_cipher_type_t srtp_aes_icm_256;
+#ifdef OPENSSL
+extern srtp_cipher_type_t srtp_aes_icm_192;
+extern srtp_cipher_type_t srtp_aes_gcm_128_openssl;
+extern srtp_cipher_type_t srtp_aes_gcm_256_openssl;
 #endif
 
 int
 main(int argc, char *argv[]) {
-  cipher_t *c = NULL;
-  err_status_t status;
+  srtp_cipher_t *c = NULL;
+  srtp_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,
@@ -147,7 +148,7 @@ main(int argc, char *argv[]) {
 
   /* process input arguments */
   while (1) {
-    q = getopt(argc, argv, "tva");
+    q = getopt_s(argc, argv, "tva");
     if (q == -1) 
       break;
     switch (q) {
@@ -164,7 +165,7 @@ main(int argc, char *argv[]) {
       usage(argv[0]);
     }    
   }
-   
+
   printf("cipher test driver\n"
 	 "David A. McGrew\n"
 	 "Cisco Systems, Inc.\n");
@@ -178,55 +179,44 @@ main(int argc, char *argv[]) {
     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); 
+      cipher_driver_test_array_throughput(&srtp_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); 
+      cipher_driver_test_array_throughput(&srtp_aes_icm_128, SRTP_AES_ICM_128_KEY_LEN_WSALT, 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
-    for (num_cipher=1; num_cipher < max_num_cipher; num_cipher *=8)
-      cipher_driver_test_array_throughput(&aes_icm_192, 38, num_cipher); 
+      cipher_driver_test_array_throughput(&srtp_aes_icm_256, SRTP_AES_ICM_256_KEY_LEN_WSALT, num_cipher);
 
+#ifdef OPENSSL
     for (num_cipher=1; num_cipher < max_num_cipher; num_cipher *=8)
-      cipher_driver_test_array_throughput(&aes_icm_256, 46, num_cipher); 
+      cipher_driver_test_array_throughput(&srtp_aes_icm_192, SRTP_AES_ICM_192_KEY_LEN_WSALT, 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);         
+      cipher_driver_test_array_throughput(&srtp_aes_gcm_128_openssl, SRTP_AES_GCM_128_KEY_LEN_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);         
+      cipher_driver_test_array_throughput(&srtp_aes_gcm_256_openssl, SRTP_AES_GCM_256_KEY_LEN_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
-    cipher_driver_self_test(&aes_icm_192);
-    cipher_driver_self_test(&aes_icm_256);
-    cipher_driver_self_test(&aes_gcm_128_openssl);
-    cipher_driver_self_test(&aes_gcm_256_openssl);
+    cipher_driver_self_test(&srtp_null_cipher);
+    cipher_driver_self_test(&srtp_aes_icm_128);
+    cipher_driver_self_test(&srtp_aes_icm_256);
+#ifdef OPENSSL
+    cipher_driver_self_test(&srtp_aes_icm_192);
+    cipher_driver_self_test(&srtp_aes_gcm_128_openssl);
+    cipher_driver_self_test(&srtp_aes_gcm_256_openssl);
 #endif
   }
 
-  /* do timing and/or buffer_test on null_cipher */
-  status = cipher_type_alloc(&null_cipher, &c, 0, 0); 
+  /* do timing and/or buffer_test on srtp_null_cipher */
+  status = srtp_cipher_type_alloc(&srtp_null_cipher, &c, 0, 0); 
   check_status(status);
 
-  status = cipher_init(c, NULL);
+  status = srtp_cipher_init(c, NULL);
   check_status(status);
 
   if (do_timing_test) 
@@ -235,18 +225,18 @@ main(int argc, char *argv[]) {
     status = cipher_driver_test_buffering(c);
     check_status(status);
   }
-  status = cipher_dealloc(c);
+  status = srtp_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, 0);  
+    status = srtp_cipher_type_alloc(&srtp_aes_icm_128, &c, SRTP_AES_ICM_128_KEY_LEN_WSALT, 0);
     if (status) {
       fprintf(stderr, "error: can't allocate cipher\n");
       exit(status);
     }
 
-    status = cipher_init(c, test_key);
+    status = srtp_cipher_init(c, test_key);
     check_status(status);
 
     if (do_timing_test)
@@ -257,21 +247,17 @@ main(int argc, char *argv[]) {
       check_status(status);
     }
     
-    status = cipher_dealloc(c);
+    status = srtp_cipher_dealloc(c);
     check_status(status);
 
   /* repeat the tests with 256-bit keys */
-#ifndef OPENSSL
-    status = cipher_type_alloc(&aes_icm, &c, 46, 0);  
-#else
-    status = cipher_type_alloc(&aes_icm_256, &c, 46, 0);  
-#endif
+    status = srtp_cipher_type_alloc(&srtp_aes_icm_256, &c, SRTP_AES_ICM_256_KEY_LEN_WSALT, 0);
     if (status) {
       fprintf(stderr, "error: can't allocate cipher\n");
       exit(status);
     }
 
-    status = cipher_init(c, test_key);
+    status = srtp_cipher_init(c, test_key);
     check_status(status);
 
     if (do_timing_test)
@@ -282,17 +268,17 @@ main(int argc, char *argv[]) {
       check_status(status);
     }
     
-    status = cipher_dealloc(c);
+    status = srtp_cipher_dealloc(c);
     check_status(status);
 
 #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);
+    status = srtp_cipher_type_alloc(&srtp_aes_gcm_128_openssl, &c, SRTP_AES_GCM_128_KEY_LEN_WSALT, 8);
     if (status) {
         fprintf(stderr, "error: can't allocate GCM 128 cipher\n");
         exit(status);
     }
-    status = cipher_init(c, test_key);
+    status = srtp_cipher_init(c, test_key);
     check_status(status);
     if (do_timing_test) {
         cipher_driver_test_throughput(c);
@@ -302,16 +288,16 @@ main(int argc, char *argv[]) {
         status = cipher_driver_test_buffering(c);
         check_status(status);
     }
-    status = cipher_dealloc(c);
+    status = srtp_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);
+    status = srtp_cipher_type_alloc(&srtp_aes_gcm_256_openssl, &c, SRTP_AES_GCM_256_KEY_LEN_WSALT, 16);
     if (status) {
         fprintf(stderr, "error: can't allocate GCM 256 cipher\n");
         exit(status);
     }
-    status = cipher_init(c, test_key);
+    status = srtp_cipher_init(c, test_key);
     check_status(status);
     if (do_timing_test) {
         cipher_driver_test_throughput(c);
@@ -321,7 +307,7 @@ main(int argc, char *argv[]) {
         status = cipher_driver_test_buffering(c);
         check_status(status);
     }
-    status = cipher_dealloc(c);
+    status = srtp_cipher_dealloc(c);
     check_status(status);
 #endif 
 
@@ -329,7 +315,7 @@ main(int argc, char *argv[]) {
 }
 
 void
-cipher_driver_test_throughput(cipher_t *c) {
+cipher_driver_test_throughput(srtp_cipher_t *c) {
   int i;
   int min_enc_len = 32;     
   int max_enc_len = 2048;   /* should be a power of two */
@@ -339,23 +325,23 @@ cipher_driver_test_throughput(cipher_t *c) {
   fflush(stdout);
   for (i=min_enc_len; i <= max_enc_len; i = i * 2)
     printf("msg len: %d\tgigabits per second: %f\n",
-	   i, cipher_bits_per_second(c, i, num_trials) / 1e9);
+	   i, srtp_cipher_bits_per_second(c, i, num_trials) / 1e9);
 
 }
 
-err_status_t
-cipher_driver_self_test(cipher_type_t *ct) {
-  err_status_t status;
+srtp_err_status_t
+cipher_driver_self_test(srtp_cipher_type_t *ct) {
+  srtp_err_status_t status;
   
   printf("running cipher self-test for %s...", ct->description);
-  status = cipher_type_self_test(ct);
+  status = srtp_cipher_type_self_test(ct);
   if (status) {
     printf("failed with error code %d\n", status);
     exit(status);
   }
   printf("passed\n");
   
-  return err_status_ok;
+  return srtp_err_status_ok;
 }
 
 /*
@@ -364,16 +350,17 @@ cipher_driver_self_test(cipher_type_t *ct) {
  * calls
  */
 
-err_status_t
-cipher_driver_test_buffering(cipher_t *c) {
+#define INITIAL_BUFLEN 1024
+srtp_err_status_t
+cipher_driver_test_buffering(srtp_cipher_t *c) {
   int i, j, num_trials = 1000;
-  unsigned len, buflen = 1024;
-  uint8_t buffer0[buflen], buffer1[buflen], *current, *end;
+  unsigned len, buflen = INITIAL_BUFLEN;
+  uint8_t buffer0[INITIAL_BUFLEN], buffer1[INITIAL_BUFLEN], *current, *end;
   uint8_t idx[16] = { 
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x34
   };
-  err_status_t status;
+  srtp_err_status_t status;
   
   printf("testing output buffering for cipher %s...",
 	 c->type->description);
@@ -381,21 +368,22 @@ cipher_driver_test_buffering(cipher_t *c) {
   for (i=0; i < num_trials; i++) {
 
    /* set buffers to zero */
-    for (j=0; j < buflen; j++) 
+    for (j=0; j < (int) buflen; j++) {
       buffer0[j] = buffer1[j] = 0;
+    }
     
     /* initialize cipher  */
-    status = cipher_set_iv(c, idx, direction_encrypt);
+    status = srtp_cipher_set_iv(c, (uint8_t*)idx, srtp_direction_encrypt);
     if (status)
       return status;
 
     /* generate 'reference' value by encrypting all at once */
-    status = cipher_encrypt(c, buffer0, &buflen);
+    status = srtp_cipher_encrypt(c, buffer0, &buflen);
     if (status)
       return status;
 
     /* re-initialize cipher */
-    status = cipher_set_iv(c, idx, direction_encrypt);
+    status = srtp_cipher_set_iv(c, (uint8_t*)idx, srtp_direction_encrypt);
     if (status)
       return status;
     
@@ -411,7 +399,7 @@ cipher_driver_test_buffering(cipher_t *c) {
       if (current + len > end)
 	len = end - current;
 
-      status = cipher_encrypt(c, current, &len);
+      status = srtp_cipher_encrypt(c, current, &len);
       if (status) 
 	return status;
       
@@ -424,20 +412,21 @@ cipher_driver_test_buffering(cipher_t *c) {
     }
 
     /* compare buffers */
-    for (j=0; j < buflen; j++)
+    for (j=0; j < (int) buflen; j++) {
       if (buffer0[j] != buffer1[j]) {
 #if PRINT_DEBUG
 	printf("test case %d failed at byte %d\n", i, j);
 	printf("computed: %s\n", octet_string_hex_string(buffer1, buflen));
 	printf("expected: %s\n", octet_string_hex_string(buffer0, buflen));
 #endif 
-	return err_status_algo_fail;
+	return srtp_err_status_algo_fail;
       }
+    }
   }
   
   printf("passed\n");
 
-  return err_status_ok;
+  return srtp_err_status_ok;
 }
 
 
@@ -446,40 +435,40 @@ cipher_driver_test_buffering(cipher_t *c) {
  * cache thrash on cipher throughput.  
  *
  * cipher_array_alloc_init(ctype, array, num_ciphers) creates an array
- * of cipher_t of type ctype
+ * of srtp_cipher_t of type ctype
  */
 
-err_status_t
-cipher_array_alloc_init(cipher_t ***ca, int num_ciphers,
-			cipher_type_t *ctype, int klen) {
+srtp_err_status_t
+cipher_array_alloc_init(srtp_cipher_t ***ca, int num_ciphers,
+			srtp_cipher_type_t *ctype, int klen) {
   int i, j;
-  err_status_t status;
+  srtp_err_status_t status;
   uint8_t *key;
-  cipher_t **cipher_array;
+  srtp_cipher_t **cipher_array;
   /* pad klen allocation, to handle aes_icm reading 16 bytes for the
      14-byte salt */
   int klen_pad = ((klen + 15) >> 4) << 4;
 
   /* allocate array of pointers to ciphers */
-  cipher_array = (cipher_t **) malloc(sizeof(cipher_t *) * num_ciphers);
+  cipher_array = (srtp_cipher_t **) malloc(sizeof(srtp_cipher_t *) * num_ciphers);
   if (cipher_array == NULL)
-    return err_status_alloc_fail;
+    return srtp_err_status_alloc_fail;
 
   /* set ca to location of cipher_array */
   *ca = cipher_array;
 
   /* allocate key */
-  key = crypto_alloc(klen_pad);
+  key = srtp_crypto_alloc(klen_pad);
   if (key == NULL) {
     free(cipher_array);
-    return err_status_alloc_fail;
+    return srtp_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, 16);
+    status = srtp_cipher_type_alloc(ctype, cipher_array, klen, 16);
     if (status)
       return status;
     
@@ -488,7 +477,7 @@ cipher_array_alloc_init(cipher_t ***ca, int num_ciphers,
       key[j] = (uint8_t) rand();
     for (; j < klen_pad; j++)
       key[j] = 0;
-    status = cipher_init(*cipher_array, key);
+    status = srtp_cipher_init(*cipher_array, key);
     if (status)
       return status;
 
@@ -500,22 +489,22 @@ cipher_array_alloc_init(cipher_t ***ca, int num_ciphers,
     cipher_array++;
   }
 
-  crypto_free(key);
+  srtp_crypto_free(key);
 
-  return err_status_ok;
+  return srtp_err_status_ok;
 }
 
-err_status_t
-cipher_array_delete(cipher_t *cipher_array[], int num_cipher) {
+srtp_err_status_t
+cipher_array_delete(srtp_cipher_t *cipher_array[], int num_cipher) {
   int i;
   
   for (i=0; i < num_cipher; i++) {
-    cipher_dealloc(cipher_array[i]);
+    srtp_cipher_dealloc(cipher_array[i]);
   }
 
   free(cipher_array);
   
-  return err_status_ok;
+  return srtp_err_status_ok;
 }
 
 
@@ -532,7 +521,7 @@ cipher_array_delete(cipher_t *cipher_array[], int num_cipher) {
  */
 
 uint64_t
-cipher_array_bits_per_second(cipher_t *cipher_array[], int num_cipher, 
+cipher_array_bits_per_second(srtp_cipher_t *cipher_array[], int num_cipher, 
 			      unsigned octets_in_buffer, int num_trials) {
   int i;
   v128_t nonce;
@@ -541,7 +530,7 @@ cipher_array_bits_per_second(cipher_t *cipher_array[], int num_cipher,
   int cipher_index = rand() % num_cipher;
 
   /* Over-alloc, for NIST CBC padding */
-  enc_buf = crypto_alloc(octets_in_buffer+17);
+  enc_buf = srtp_crypto_alloc(octets_in_buffer+17);
   if (enc_buf == NULL)
     return 0;  /* indicate bad parameters by returning null */
   memset(enc_buf, 0, octets_in_buffer);
@@ -550,13 +539,13 @@ cipher_array_bits_per_second(cipher_t *cipher_array[], int num_cipher,
   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 parameter to srtp_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, direction_encrypt);
-    cipher_encrypt(cipher_array[cipher_index], enc_buf, &octets_to_encrypt);
+    srtp_cipher_set_iv(cipher_array[cipher_index], (uint8_t*)&nonce, srtp_direction_encrypt);
+    srtp_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;
@@ -574,7 +563,7 @@ cipher_array_bits_per_second(cipher_t *cipher_array[], int num_cipher,
 }
 
 void
-cipher_array_test_throughput(cipher_t *ca[], int num_cipher) {
+cipher_array_test_throughput(srtp_cipher_t *ca[], int num_cipher) {
   int i;
   int min_enc_len = 16;     
   int max_enc_len = 2048;   /* should be a power of two */
@@ -589,11 +578,11 @@ cipher_array_test_throughput(cipher_t *ca[], int num_cipher) {
 
 }
 
-err_status_t
-cipher_driver_test_array_throughput(cipher_type_t *ct, 
+srtp_err_status_t
+cipher_driver_test_array_throughput(srtp_cipher_type_t *ct, 
 				    int klen, int num_cipher) {
-  cipher_t **ca = NULL;
-  err_status_t status;
+  srtp_cipher_t **ca = NULL;
+  srtp_err_status_t status;
 
   status = cipher_array_alloc_init(&ca, num_cipher, ct, klen);
   if (status) {
@@ -606,5 +595,5 @@ cipher_driver_test_array_throughput(cipher_type_t *ct,
   
   cipher_array_delete(ca, num_cipher);    
  
-  return err_status_ok;
+  return srtp_err_status_ok;
 }