Update libsrtp to upstream 1.5.0

srtp/test/srtp_driver.c

 /*
  * srtp_driver.c
  * 
  * a test driver for libSRTP
  *
  * David A. McGrew
  * Cisco Systems, Inc.
  */
 /*
  *      
@@ skipping 86 matching lines @@
 
 err_status_t
 srtp_print_policy(const srtp_policy_t *policy); 
 
 char *
 srtp_packet_to_string(srtp_hdr_t *hdr, int packet_len);
 
 double
 mips_estimate(int num_trials, int *ignore);
 
-extern uint8_t test_key[30];
+extern uint8_t test_key[46];
 
 void
 usage(char *prog_name) {
   printf("usage: %s [ -t ][ -c ][ -v ][-d <debug_module> ]* [ -l ]\n"
          "  -t         run timing test\n"
          "  -r         run rejection timing test\n"
          "  -c         run codec timing test\n"
          "  -v         run validation tests\n"
          "  -d <mod>   turn on debugging module <mod>\n"
          "  -l         list debugging modules\n", prog_name);
@@ skipping 163 matching lines @@
      */
     printf("testing srtp_protect and srtp_unprotect against "
            "reference packets\n");
     if (srtp_validate() == err_status_ok) 
       printf("passed\n\n");
     else {
       printf("failed\n");
        exit(1); 
     }
 
+//FIXME: need to get this working with the OpenSSL AES module
+#ifndef OPENSSL
     /*
      * run validation test against the reference packets for
      * AES-256
      */
     printf("testing srtp_protect and srtp_unprotect against "
            "reference packets (AES-256)\n");
     if (srtp_validate_aes_256() == err_status_ok) 
       printf("passed\n\n");
     else {
       printf("failed\n");
        exit(1); 
     }
+#endif
 
     /*
      * test the function srtp_remove_stream()
      */
     printf("testing srtp_remove_stream()...");
     if (srtp_test_remove_stream() == err_status_ok)
       printf("passed\n");
     else {
       printf("failed\n");
       exit(1);
@@ skipping 18 matching lines @@
     while (*policy != NULL) {
       srtp_print_policy(*policy);
       srtp_do_rejection_timing(*policy);
       policy++;
     }
   }
   
   if (do_codec_timing) {
     srtp_policy_t policy;
     int ignore;
-    double mips_value = mips_estimate(1000000000, &ignore);
+    double mips = mips_estimate(1000000000, &ignore);
 
     crypto_policy_set_rtp_default(&policy.rtp);
     crypto_policy_set_rtcp_default(&policy.rtcp);
     policy.ssrc.type  = ssrc_specific;
     policy.ssrc.value = 0xdecafbad;
     policy.key  = test_key;
     policy.ekt = NULL;
     policy.window_size = 128;
     policy.allow_repeat_tx = 0;
     policy.next = NULL;
 
-    printf("mips estimate: %e\n", mips_value);
+    printf("mips estimate: %e\n", mips);
 
     printf("testing srtp processing time for voice codecs:\n");
     printf("codec\t\tlength (octets)\t\tsrtp instructions/second\n");
     printf("G.711\t\t%d\t\t\t%e\n", 80, 
-           (double) mips_value * (80 * 8) /
+           (double) mips * (80 * 8) / 
            srtp_bits_per_second(80, &policy) / .01 );
     printf("G.711\t\t%d\t\t\t%e\n", 160, 
-           (double) mips_value * (160 * 8) /
+           (double) mips * (160 * 8) / 
            srtp_bits_per_second(160, &policy) / .02);
     printf("G.726-32\t%d\t\t\t%e\n", 40, 
-           (double) mips_value * (40 * 8) /
+           (double) mips * (40 * 8) / 
            srtp_bits_per_second(40, &policy) / .01 );
     printf("G.726-32\t%d\t\t\t%e\n", 80, 
-           (double) mips_value * (80 * 8) /
+           (double) mips * (80 * 8) / 
            srtp_bits_per_second(80, &policy) / .02);
     printf("G.729\t\t%d\t\t\t%e\n", 10, 
-           (double) mips_value * (10 * 8) /
+           (double) mips * (10 * 8) / 
            srtp_bits_per_second(10, &policy) / .01 );
     printf("G.729\t\t%d\t\t\t%e\n", 20, 
-           (double) mips_value * (20 * 8) /
+           (double) mips * (20 * 8) /
            srtp_bits_per_second(20, &policy) / .02 );
     printf("Wideband\t%d\t\t\t%e\n", 320, 
-           (double) mips_value * (320 * 8) /
+           (double) mips * (320 * 8) /
            srtp_bits_per_second(320, &policy) / .01 );
     printf("Wideband\t%d\t\t\t%e\n", 640, 
-           (double) mips_value * (640 * 8) /
+           (double) mips * (640 * 8) /
            srtp_bits_per_second(640, &policy) / .02 );
   }
 
   status = srtp_shutdown();
   if (status) {
     printf("error: srtp shutdown failed with error code %d\n", status);
     exit(1);
   }
 
   return 0;  
@@ skipping 1130 matching lines @@
   if (status != err_status_ok)
     return status;
 
   return err_status_ok;  
 }
 
 /*
  * srtp policy definitions - these definitions are used above
  */
 
-unsigned char test_key[30] = {
+unsigned char test_key[46] = {
     0xe1, 0xf9, 0x7a, 0x0d, 0x3e, 0x01, 0x8b, 0xe0,
     0xd6, 0x4f, 0xa3, 0x2c, 0x06, 0xde, 0x41, 0x39,
     0x0e, 0xc6, 0x75, 0xad, 0x49, 0x8a, 0xfe, 0xeb,
+    0xb6, 0x96, 0x0b, 0x3a, 0xab, 0xe6, 0xc1, 0x73,
+    0xc3, 0x17, 0xf2, 0xda, 0xbe, 0x35, 0x77, 0x93,
     0xb6, 0x96, 0x0b, 0x3a, 0xab, 0xe6
 };
 
 
 const srtp_policy_t default_policy = {
   { ssrc_any_outbound, 0 },  /* SSRC                           */
   {                      /* SRTP policy                    */                  
     AES_128_ICM,            /* cipher type                 */
     30,                     /* cipher key length in octets */
     HMAC_SHA1,              /* authentication func type    */
@@ skipping 109 matching lines @@
     4,                      /* auth tag length in octets   */
     sec_serv_auth           /* security services flag      */
   },
   test_key,
   NULL,        /* indicates that EKT is not in use */
   128,         /* replay window size */
   0,           /* retransmission not allowed */
   NULL
 };
 
+#ifdef OPENSSL
+const srtp_policy_t aes128_gcm_8_policy = {
+    { ssrc_any_outbound, 0 },  /* SSRC                           */
+    {                      /* SRTP policy                    */                  
+        AES_128_GCM,            /* cipher type                 */
+        AES_128_GCM_KEYSIZE_WSALT,  /* cipher key length in octets */
+        NULL_AUTH,              /* authentication func type    */
+        0,                      /* auth key length in octets   */
+        8,                      /* auth tag length in octets   */
+        sec_serv_conf_and_auth  /* security services flag      */
+    },
+    {                      /* SRTCP policy                   */
+        AES_128_GCM,            /* cipher type                 */
+        AES_128_GCM_KEYSIZE_WSALT,  /* cipher key length in octets */
+        NULL_AUTH,              /* authentication func type    */
+        0,                      /* auth key length in octets   */
+        8,                      /* auth tag length in octets   */
+        sec_serv_conf_and_auth /* security services flag      */
+    },
+    test_key,
+    NULL,        /* indicates that EKT is not in use */
+    128,         /* replay window size */
+    0,           /* retransmission not allowed */
+    NULL
+};
+
+const srtp_policy_t aes128_gcm_8_cauth_policy = {
+    { ssrc_any_outbound, 0 },  /* SSRC                           */
+    {                      /* SRTP policy                    */                  
+        AES_128_GCM,            /* cipher type                 */
+        AES_128_GCM_KEYSIZE_WSALT,  /* cipher key length in octets */
+        NULL_AUTH,              /* authentication func type    */
+        0,                      /* auth key length in octets   */
+        8,                      /* auth tag length in octets   */
+        sec_serv_conf_and_auth  /* security services flag      */
+    },
+    {                      /* SRTCP policy                   */
+        AES_128_GCM,            /* cipher type                 */
+        AES_128_GCM_KEYSIZE_WSALT,  /* cipher key length in octets */
+        NULL_AUTH,              /* authentication func type    */
+        0,                      /* auth key length in octets   */
+        8,                      /* auth tag length in octets   */
+        sec_serv_auth           /* security services flag      */
+    },
+    test_key,
+    NULL,        /* indicates that EKT is not in use */
+    128,         /* replay window size */
+    0,           /* retransmission not allowed */
+    NULL
+};
+ 
+const srtp_policy_t aes256_gcm_8_policy = {
+    { ssrc_any_outbound, 0 },  /* SSRC                           */
+    {                      /* SRTP policy                    */                  
+        AES_256_GCM,            /* cipher type                 */
+        AES_256_GCM_KEYSIZE_WSALT,  /* cipher key length in octets */
+        NULL_AUTH,              /* authentication func type    */
+        0,                      /* auth key length in octets   */
+        8,                      /* auth tag length in octets   */
+        sec_serv_conf_and_auth  /* security services flag      */
+    },
+    {                      /* SRTCP policy                   */
+        AES_256_GCM,            /* cipher type                 */
+        AES_256_GCM_KEYSIZE_WSALT,  /* cipher key length in octets */
+        NULL_AUTH,              /* authentication func type    */
+        0,                      /* auth key length in octets   */
+        8,                      /* auth tag length in octets   */
+        sec_serv_conf_and_auth  /* security services flag      */
+    },
+    test_key,
+    NULL,        /* indicates that EKT is not in use */
+    128,         /* replay window size */
+    0,           /* retransmission not allowed */
+    NULL
+};
+ 
+const srtp_policy_t aes256_gcm_8_cauth_policy = {
+    { ssrc_any_outbound, 0 },  /* SSRC                           */
+    {                      /* SRTP policy                    */                  
+        AES_256_GCM,            /* cipher type                 */
+        AES_256_GCM_KEYSIZE_WSALT,  /* cipher key length in octets */
+        NULL_AUTH,              /* authentication func type    */
+        0,                      /* auth key length in octets   */
+        8,                      /* auth tag length in octets   */
+        sec_serv_conf_and_auth  /* security services flag      */
+    },
+    {                      /* SRTCP policy                   */
+        AES_256_GCM,            /* cipher type                 */
+        AES_256_GCM_KEYSIZE_WSALT,  /* cipher key length in octets */
+        NULL_AUTH,              /* authentication func type    */
+        0,                      /* auth key length in octets   */
+        8,                      /* auth tag length in octets   */
+        sec_serv_auth           /* security services flag      */
+    },
+    test_key,
+    NULL,        /* indicates that EKT is not in use */
+    128,         /* replay window size */
+    0,           /* retransmission not allowed */
+    NULL
+};
+#endif
+
 const srtp_policy_t null_policy = {
   { ssrc_any_outbound, 0 },     /* SSRC                        */ 
   {
     NULL_CIPHER,            /* cipher type                 */
     0,                      /* cipher key length in octets */
     NULL_AUTH,              /* authentication func type    */
     0,                      /* auth key length in octets   */
     0,                      /* auth tag length in octets   */
     sec_serv_none           /* security services flag      */  
   },
@@ skipping 103 matching lines @@
 policy_array[] = {
   &hmac_only_policy,
 #if USE_TMMH
   &tmmh_only_policy,
 #endif
   &aes_only_policy,
 #if USE_TMMH
   &aes_tmmh_policy,
 #endif
   &default_policy,
+#ifdef OPENSSL
+  &aes128_gcm_8_policy,
+  &aes128_gcm_8_cauth_policy,
+  &aes256_gcm_8_policy,
+  &aes256_gcm_8_cauth_policy,
+#endif
   &null_policy,
   &aes_256_hmac_policy,
   &hmac_only_with_ekt_policy,
   NULL
 };
 
 const srtp_policy_t wildcard_policy = {
   { ssrc_any_outbound, 0 }, /* SSRC                        */
   {                      /* SRTP policy                    */                  
     AES_128_ICM,            /* cipher type                 */
@@ skipping 10 matching lines @@
     16,                     /* auth key length in octets   */
     10,                     /* auth tag length in octets   */
     sec_serv_conf_and_auth  /* security services flag      */
   },
   test_key,
   NULL,
   128,                   /* replay window size */
   0,                     /* retransmission not allowed */
   NULL
 };