Land https://codereview.chromium.org/889083003/ to update libsrtp to upstream 1.5.0

srtp/crypto/kernel/crypto_kernel.c

 /*
  * crypto_kernel.c
  *
  * header for the cryptographic kernel
  *
  * 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 14 matching lines @@
  * (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 "alloc.h"
 
 #include "crypto_kernel.h"
 
 /* the debug module for the crypto_kernel */
 
 debug_module_t mod_crypto_kernel = {
   0,                  /* debugging is off by default */
   "crypto kernel"     /* printable name for module   */
 };
 
 /*
  * other debug modules that can be included in the kernel
  */
 
 extern debug_module_t mod_auth;
 extern debug_module_t mod_cipher;
 extern debug_module_t mod_stat;
 extern debug_module_t mod_alloc;
 
 /* 
  * cipher types that can be included in the kernel
  */ 
 
 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_gcm_128_openssl;
+extern cipher_type_t aes_gcm_256_openssl;
+#endif
 
 
 /*
  * auth func types that can be included in the kernel
  */
 
 extern auth_type_t null_auth;
 extern auth_type_t hmac;
 
 /* crypto_kernel is a global variable, the only one of its datatype */
@@ skipping 47 matching lines @@
   /* initialize random number generator */
   status = rand_source_init();
   if (status)
     return status;
 
   /* run FIPS-140 statistical tests on rand_source */  
   status = stat_test_rand_source_with_repetition(rand_source_get_octet_string, MAX_RNG_TRIALS);
   if (status)
     return status;
 
+#ifndef OPENSSL
   /* initialize pseudorandom number generator */
   status = ctr_prng_init(rand_source_get_octet_string);
   if (status)
     return status;
 
   /* run FIPS-140 statistical tests on ctr_prng */  
   status = stat_test_rand_source_with_repetition(ctr_prng_get_octet_string, MAX_RNG_TRIALS);
   if (status)
     return status;
+#endif
  
   /* load cipher types */
   status = crypto_kernel_load_cipher_type(&null_cipher, NULL_CIPHER);
   if (status) 
     return status;
   status = crypto_kernel_load_cipher_type(&aes_icm, AES_ICM);
   if (status) 
     return status;
+#ifndef OPENSSL
   status = crypto_kernel_load_cipher_type(&aes_cbc, AES_CBC);
   if (status) 
     return status;
+#else
+  status = crypto_kernel_load_cipher_type(&aes_gcm_128_openssl, AES_128_GCM);
+  if (status) {
+      return status;
+  }
+  status = crypto_kernel_load_cipher_type(&aes_gcm_256_openssl, AES_256_GCM);
+  if (status) {
+      return status;
+  }
+#endif
 
   /* load auth func types */
   status = crypto_kernel_load_auth_type(&null_auth, NULL_AUTH);
   if (status)
     return status;
   status = crypto_kernel_load_auth_type(&hmac, HMAC_SHA1);
   if (status)
     return status;
 
   /* change state to secure */
@@ skipping 120 matching lines @@
   /* de-initialize random number generator */  status = rand_source_deinit();
   if (status)
     return status;
 
   /* return to insecure state */
   crypto_kernel.state = crypto_kernel_state_insecure;
   
   return err_status_ok;
 }
 
-static INLINE err_status_t
+static inline err_status_t
 crypto_kernel_do_load_cipher_type(cipher_type_t *new_ct, cipher_type_id_t id,
                                   int replace) {
   kernel_cipher_type_t *ctype, *new_ctype;
   err_status_t status;
 
   /* defensive coding */
   if (new_ct == NULL)
     return err_status_bad_param;
 
   if (new_ct->id != id)
@@ skipping 141 matching lines @@
   } 
 
   /* haven't found the right one, indicate failure by returning NULL */
   return NULL;
 }
 
 
 err_status_t
 crypto_kernel_alloc_cipher(cipher_type_id_t id, 
                               cipher_pointer_t *cp, 
-                              int key_len) {
+                              int key_len,
+                              int tag_len) {
   cipher_type_t *ct;
 
   /* 
    * if the crypto_kernel is not yet initialized, we refuse to allocate
    * any ciphers - this is a bit extra-paranoid
    */
   if (crypto_kernel.state != crypto_kernel_state_secure)
     return err_status_init_fail;
 
   ct = crypto_kernel_get_cipher_type(id);
   if (!ct)
     return err_status_fail;
   
-  return ((ct)->alloc(cp, key_len));
+  return ((ct)->alloc(cp, key_len, tag_len));
 }
 
 
 
 auth_type_t *
 crypto_kernel_get_auth_type(auth_type_id_t id) {
   kernel_auth_type_t *atype;
   
   /* walk down list, looking for id  */
   atype = crypto_kernel.auth_type_list;
@@ skipping 73 matching lines @@
     }
     kdm = kdm->next;
   }
 
   return err_status_fail;
 }
 
 err_status_t
 crypto_get_random(unsigned char *buffer, unsigned int length) {
   if (crypto_kernel.state == crypto_kernel_state_secure)
+#ifdef OPENSSL
+    return rand_source_get_octet_string(buffer, length);
+#else
     return ctr_prng_get_octet_string(buffer, length);
+#endif
   else
     return err_status_fail;
 }