Update libsrtp to upstream 1.5.0

srtp/crypto/cipher/aes_cbc.c

 /*
  * aes_cbc.c
  *
  * AES Cipher Block Chaining Mode
  *
  * David A. McGrew
  * Cisco Systems, Inc.
  */
 
 /*
@@ skipping 25 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 "aes_cbc.h"
 #include "alloc.h"
 
 debug_module_t mod_aes_cbc = {
   0,                 /* debugging is off by default */
   "aes cbc"          /* printable module name       */
 };
 
 
 
 err_status_t
-aes_cbc_alloc(cipher_t **c, int key_len) {
+aes_cbc_alloc(cipher_t **c, int key_len, int tlen) {
   extern cipher_type_t aes_cbc;
   uint8_t *pointer;
   int tmp;
 
   debug_print(mod_aes_cbc, 
               "allocating cipher with key length %d", key_len);
 
   if (key_len != 16 && key_len != 24 && key_len != 32)
     return err_status_bad_param;
   
   /* allocate memory a cipher of type aes_cbc */
   tmp = (sizeof(aes_cbc_ctx_t) + sizeof(cipher_t));
   pointer = (uint8_t*)crypto_alloc(tmp);
   if (pointer == NULL) 
     return err_status_alloc_fail;
 
   /* set pointers */
   *c = (cipher_t *)pointer;
+  (*c)->algorithm = AES_CBC;
   (*c)->type = &aes_cbc;
   (*c)->state = pointer + sizeof(cipher_t);
 
   /* increment ref_count */
   aes_cbc.ref_count++;
 
   /* set key size        */
   (*c)->key_len = key_len;
 
   return err_status_ok;  
@@ skipping 10 matching lines @@
   /* free memory */
   crypto_free(c);
 
   /* decrement ref_count */
   aes_cbc.ref_count--;
   
   return err_status_ok;  
 }
 
 err_status_t
-aes_cbc_context_init(aes_cbc_ctx_t *c, const uint8_t *key, int key_len,
-                     cipher_direction_t dir) {
-  err_status_t status;
+aes_cbc_context_init(aes_cbc_ctx_t *c, const uint8_t *key, int key_len) {
 
   debug_print(mod_aes_cbc, 
               "key:  %s", octet_string_hex_string(key, key_len)); 
 
-  /* expand key for the appropriate direction */
-  switch (dir) {
-  case (direction_encrypt):
-    status = aes_expand_encryption_key(key, key_len, &c->expanded_key);
-    if (status)
-      return status;
-    break;
-  case (direction_decrypt):
-    status = aes_expand_decryption_key(key, key_len, &c->expanded_key);
-    if (status)
-      return status;
-    break;
-  default:
-    return err_status_bad_param;
-  }
-
+  /*
+   * Save the key until we have the IV later.  We don't
+   * know the direction until the IV is set.
+   */
+  c->key_len = (key_len <= 32 ? key_len : 32);
+  memcpy(c->key, key, c->key_len);
 
   return err_status_ok;
 }
 
 
 err_status_t
-aes_cbc_set_iv(aes_cbc_ctx_t *c, void *iv) {
+aes_cbc_set_iv(aes_cbc_ctx_t *c, void *iv, int direction) {
+  err_status_t status;
   int i;
 /*   v128_t *input = iv; */
   uint8_t *input = (uint8_t*) iv;
  
   /* set state and 'previous' block to iv */
   for (i=0; i < 16; i++) 
     c->previous.v8[i] = c->state.v8[i] = input[i];
 
   debug_print(mod_aes_cbc, "setting iv: %s", v128_hex_string(&c->state)); 
 
+  /* expand key for the appropriate direction */
+  switch (direction) {
+  case (direction_encrypt):
+    status = aes_expand_encryption_key(c->key, c->key_len, &c->expanded_key);
+    memset(c->key, 0, 32);
+    if (status)
+      return status;
+    break;
+  case (direction_decrypt):
+    status = aes_expand_decryption_key(c->key, c->key_len, &c->expanded_key);
+    memset(c->key, 0, 32);
+    if (status)
+      return status;
+    break;
+  default:
+    return err_status_bad_param;
+  }
+
   return err_status_ok;
 }
 
 err_status_t
 aes_cbc_encrypt(aes_cbc_ctx_t *c,
                 unsigned char *data, 
                 unsigned int *bytes_in_data) {
   int i;
   unsigned char *input  = data;   /* pointer to data being read    */
   unsigned char *output = data;   /* pointer to data being written */
@@ skipping 211 matching lines @@
 
 
 cipher_test_case_t aes_cbc_test_case_0 = {
   16,                                    /* octets in key            */
   aes_cbc_test_case_0_key,               /* key                      */
   aes_cbc_test_case_0_iv,                /* initialization vector    */
   16,                                    /* octets in plaintext      */
   aes_cbc_test_case_0_plaintext,         /* plaintext                */
   32,                                    /* octets in ciphertext     */
   aes_cbc_test_case_0_ciphertext,        /* ciphertext               */
+  0,
+  NULL,
+  0,
   NULL                                   /* pointer to next testcase */
 };
 
 
 /*
  * this test case is taken directly from Appendix F.2 of NIST Special
  * Publication SP 800-38A
  */
 
 uint8_t aes_cbc_test_case_1_key[16] = {
@@ skipping 31 matching lines @@
 };
 
 cipher_test_case_t aes_cbc_test_case_1 = {
   16,                                    /* octets in key            */
   aes_cbc_test_case_1_key,               /* key                      */
   aes_cbc_test_case_1_iv,                /* initialization vector    */
   64,                                    /* octets in plaintext      */
   aes_cbc_test_case_1_plaintext,         /* plaintext                */
   80,                                    /* octets in ciphertext     */
   aes_cbc_test_case_1_ciphertext,        /* ciphertext               */
+  0,
+  NULL,
+  0,
   &aes_cbc_test_case_0                    /* pointer to next testcase */
 };
 
 /*
  * Test case 2 is like test case 0, but for 256-bit keys. (FIPS 197 
  * appendix C.3).
  */
 
 
 uint8_t aes_cbc_test_case_2_key[32] = {
@@ skipping 21 matching lines @@
 };
 
 cipher_test_case_t aes_cbc_test_case_2 = {
   32,                                    /* octets in key            */
   aes_cbc_test_case_2_key,               /* key                      */
   aes_cbc_test_case_2_iv,                /* initialization vector    */
   16,                                    /* octets in plaintext      */
   aes_cbc_test_case_2_plaintext,         /* plaintext                */
   32,                                    /* octets in ciphertext     */
   aes_cbc_test_case_2_ciphertext,        /* ciphertext               */
+  0,
+  NULL,
+  0,
   &aes_cbc_test_case_1                   /* pointer to next testcase */
 };
 
 
 /*
  * this test case is taken directly from Appendix F.2 of NIST Special
  * Publication SP 800-38A
  */
 
 uint8_t aes_cbc_test_case_3_key[32] = {
@@ skipping 33 matching lines @@
 };
 
 cipher_test_case_t aes_cbc_test_case_3 = {
   32,                                    /* octets in key            */
   aes_cbc_test_case_3_key,               /* key                      */
   aes_cbc_test_case_3_iv,                /* initialization vector    */
   64,                                    /* octets in plaintext      */
   aes_cbc_test_case_3_plaintext,         /* plaintext                */
   80,                                    /* octets in ciphertext     */
   aes_cbc_test_case_3_ciphertext,        /* ciphertext               */
+  0,
+  NULL,
+  0,
   &aes_cbc_test_case_2                    /* pointer to next testcase */
 };
 
 cipher_type_t aes_cbc = {
   (cipher_alloc_func_t)          aes_cbc_alloc,
   (cipher_dealloc_func_t)        aes_cbc_dealloc,  
   (cipher_init_func_t)           aes_cbc_context_init,
+  (cipher_set_aad_func_t)        0,
   (cipher_encrypt_func_t)        aes_cbc_nist_encrypt,
   (cipher_decrypt_func_t)        aes_cbc_nist_decrypt,
   (cipher_set_iv_func_t)         aes_cbc_set_iv,
+  (cipher_get_tag_func_t)        0,
   (char *)                       aes_cbc_description,
   (int)                          0,   /* instance count */
   (cipher_test_case_t *)        &aes_cbc_test_case_3,
   (debug_module_t *)            &mod_aes_cbc,
   (cipher_type_id_t)             AES_CBC
 };