Changeset 5614 for pjproject/trunk/third_party/srtp/srtp/srtp.c

Timestamp:

Jul 4, 2017 5:22:51 AM (7 years ago)

Author:

nanang

Message:

Close #1993: Updated bundled libSRTP version to 2.1.0.

File:

• pjproject/trunk/third_party/srtp/srtp/srtp.c (modified) (159 diffs)

pjproject/trunk/third_party/srtp/srtp/srtp.c

@@ -9 +9 @@
 /*
  *      
- * Copyright (c) 2001-2006, Cisco Systems, Inc.
+ * Copyright (c) 2001-2017, Cisco Systems, Inc.
  * All rights reserved.
  * 
@@ -43 +43 @@
  */
 
+// Leave this as the top level import. Ensures the existence of defines
+#include "config.h"
 
 #include "srtp_priv.h"
+#include "crypto_types.h"
+#include "err.h"
 #include "ekt.h"             /* for SRTP Encrypted Key Transport */
-#include "alloc.h"           /* for crypto_alloc()          */
+#include "alloc.h"           /* for srtp_crypto_alloc()          */
 #ifdef OPENSSL
 #include "aes_gcm_ossl.h"    /* for AES GCM mode  */
+# ifdef OPENSSL_KDF
+# include <openssl/kdf.h>
+# include "aes_icm_ossl.h"    /* for AES GCM mode  */
+# endif
 #endif
 
-#ifndef SRTP_KERNEL
-# include <limits.h>
-# ifdef HAVE_NETINET_IN_H
-#  include <netinet/in.h>
-# elif defined(HAVE_WINSOCK2_H)
-#  include <winsock2.h>
-# endif
-#endif /* ! SRTP_KERNEL */
+#include <limits.h>
+#ifdef HAVE_NETINET_IN_H
+# include <netinet/in.h>
+#elif defined(HAVE_WINSOCK2_H)
+# include <winsock2.h>
+#endif
 
 
 /* the debug module for srtp */
 
-debug_module_t mod_srtp = {
+srtp_debug_module_t mod_srtp = {
   0,                  /* debugging is off by default */
   "srtp"              /* printable name for module   */
@@ -74 +80 @@
 #define octets_in_rtp_extn_hdr 4
 
-static err_status_t
+static srtp_err_status_t
 srtp_validate_rtp_header(void *rtp_hdr, int *pkt_octet_len) {
   srtp_hdr_t *hdr = (srtp_hdr_t *)rtp_hdr;
+  int rtp_header_len = octets_in_rtp_header + 4 * hdr->cc;
+
+  if (*pkt_octet_len < octets_in_rtp_header)
+    return srtp_err_status_bad_param;
 
   /* Check RTP header length */
-  int rtp_header_len = octets_in_rtp_header + 4 * hdr->cc;
   if (hdr->x == 1)
     rtp_header_len += octets_in_rtp_extn_hdr;
 
   if (*pkt_octet_len < rtp_header_len)
-    return err_status_bad_param;
+    return srtp_err_status_bad_param;
 
   /* Verifing profile length. */
@@ -94 +103 @@
     /* profile length counts the number of 32-bit words */
     if (*pkt_octet_len < rtp_header_len)
-      return err_status_bad_param;
-  }
-  return err_status_ok;
+      return srtp_err_status_bad_param;
+  }
+  return srtp_err_status_ok;
 }
 
@@ -138 +147 @@
 }
 
-err_status_t
+/* Release (maybe partially allocated) stream. */
+static void
+srtp_stream_free(srtp_stream_ctx_t *str) {
+  unsigned int i = 0;
+  srtp_session_keys_t *session_keys = NULL;
+
+  for (i = 0; i < str->num_master_keys; i++) {
+    session_keys = &str->session_keys[i];
+
+    if (session_keys->rtp_xtn_hdr_cipher) {
+      srtp_cipher_dealloc(session_keys->rtp_xtn_hdr_cipher);
+    }
+
+    if (session_keys->rtcp_cipher) {
+      srtp_cipher_dealloc(session_keys->rtcp_cipher);
+    }
+
+    if (session_keys->rtcp_auth) {
+      srtp_auth_dealloc(session_keys->rtcp_auth);
+    }
+
+    if (session_keys->rtp_cipher) {
+      srtp_cipher_dealloc(session_keys->rtp_cipher);
+    }
+
+    if (session_keys->rtp_auth) {
+      srtp_auth_dealloc(session_keys->rtp_auth);
+    }
+
+    if (session_keys->mki_id) {
+      srtp_crypto_free(session_keys->mki_id);
+    }
+
+    if (session_keys->limit) {
+      srtp_crypto_free(session_keys->limit);
+    }
+  }
+
+  srtp_crypto_free(str->session_keys);
+
+  if (str->enc_xtn_hdr) {
+    srtp_crypto_free(str->enc_xtn_hdr);
+  }
+
+  srtp_crypto_free(str);
+}
+
+srtp_err_status_t
 srtp_stream_alloc(srtp_stream_ctx_t **str_ptr,
                   const srtp_policy_t *p) {
   srtp_stream_ctx_t *str;
-  err_status_t stat;
+  srtp_err_status_t stat;
+  unsigned int i = 0;
+  srtp_session_keys_t *session_keys = NULL;
 
   /*
@@ -153 +211 @@
 
   /* allocate srtp stream and set str_ptr */
-  str = (srtp_stream_ctx_t *) crypto_alloc(sizeof(srtp_stream_ctx_t));
+  str = (srtp_stream_ctx_t *) srtp_crypto_alloc(sizeof(srtp_stream_ctx_t));
   if (str == NULL)
-    return err_status_alloc_fail;
-  *str_ptr = str;  
-  
-  /* allocate cipher */
-  stat = crypto_kernel_alloc_cipher(p->rtp.cipher_type, 
-                                    &str->rtp_cipher, 
-                                    p->rtp.cipher_key_len,
-                                    p->rtp.auth_tag_len); 
+    return srtp_err_status_alloc_fail;
+
+  memset(str, 0, sizeof(srtp_stream_ctx_t));
+  *str_ptr = str;
+
+  /* To keep backwards API compatible if someone is using multiple master
+   * keys then key should be set to NULL
+   */
+  if (p->key != NULL) {
+      str->num_master_keys = 1;
+  } else {
+      str->num_master_keys = p->num_master_keys;
+  }
+
+  str->session_keys = (srtp_session_keys_t *)srtp_crypto_alloc(
+      sizeof(srtp_session_keys_t) * str->num_master_keys);
+
+  if (str->session_keys == NULL) {
+      srtp_stream_free(str);
+      return srtp_err_status_alloc_fail;
+  }
+
+  memset(str->session_keys, 0, sizeof(srtp_session_keys_t) * str->num_master_keys);
+
+  for (i = 0; i < str->num_master_keys; i++) {
+    session_keys = &str->session_keys[i];
+
+    /* allocate cipher */ 
+    stat = srtp_crypto_kernel_alloc_cipher(p->rtp.cipher_type,
+                                           &session_keys->rtp_cipher,
+                                           p->rtp.cipher_key_len,
+                                           p->rtp.auth_tag_len);
+    if (stat) {
+      srtp_stream_free(str);
+      return stat;
+    }
+
+    /* allocate auth function */
+    stat = srtp_crypto_kernel_alloc_auth(p->rtp.auth_type,
+                                         &session_keys->rtp_auth,
+                                         p->rtp.auth_key_len,
+                                         p->rtp.auth_tag_len);
+    if (stat) {
+      srtp_stream_free(str);
+      return stat;
+    }
+
+    /*
+     * ...and now the RTCP-specific initialization - first, allocate
+     * the cipher 
+     */
+    stat = srtp_crypto_kernel_alloc_cipher(p->rtcp.cipher_type,
+                                           &session_keys->rtcp_cipher,
+                                           p->rtcp.cipher_key_len,
+                                           p->rtcp.auth_tag_len);
+    if (stat) {
+      srtp_stream_free(str);
+      return stat;
+    }
+
+    /* allocate auth function */
+    stat = srtp_crypto_kernel_alloc_auth(p->rtcp.auth_type,
+                                         &session_keys->rtcp_auth,
+                                         p->rtcp.auth_key_len,
+                                         p->rtcp.auth_tag_len);
+    if (stat) {
+      srtp_stream_free(str);
+      return stat;
+    }
+   
+    session_keys->mki_id = NULL;
+
+    /* allocate key limit structure */
+    session_keys->limit = (srtp_key_limit_ctx_t*) srtp_crypto_alloc(sizeof(srtp_key_limit_ctx_t));
+    if (session_keys->limit == NULL) {
+        srtp_stream_free(str);
+        return srtp_err_status_alloc_fail;
+    }
+  }
+
+  /* allocate ekt data associated with stream */
+  stat = srtp_ekt_alloc(&str->ekt, p->ekt);
   if (stat) {
-    crypto_free(str);
+    srtp_stream_free(str);
     return stat;
   }
 
-  /* allocate auth function */
-  stat = crypto_kernel_alloc_auth(p->rtp.auth_type, 
-                                  &str->rtp_auth,
-                                  p->rtp.auth_key_len, 
-                                  p->rtp.auth_tag_len); 
-  if (stat) {
-    cipher_dealloc(str->rtp_cipher);
-    crypto_free(str);
-    return stat;
-  }
-  
-  /* allocate key limit structure */
-  str->limit = (key_limit_ctx_t*) crypto_alloc(sizeof(key_limit_ctx_t));
-  if (str->limit == NULL) {
-    auth_dealloc(str->rtp_auth);
-    cipher_dealloc(str->rtp_cipher);
-    crypto_free(str); 
-    return err_status_alloc_fail;
-  }
-
-  /*
-   * ...and now the RTCP-specific initialization - first, allocate
-   * the cipher 
-   */
-  stat = crypto_kernel_alloc_cipher(p->rtcp.cipher_type, 
-                                    &str->rtcp_cipher, 
-                                    p->rtcp.cipher_key_len, 
-                                    p->rtcp.auth_tag_len); 
-  if (stat) {
-    auth_dealloc(str->rtp_auth);
-    cipher_dealloc(str->rtp_cipher);
-    crypto_free(str->limit);
-    crypto_free(str);
-    return stat;
-  }
-
-  /* allocate auth function */
-  stat = crypto_kernel_alloc_auth(p->rtcp.auth_type, 
-                                  &str->rtcp_auth,
-                                  p->rtcp.auth_key_len, 
-                                  p->rtcp.auth_tag_len); 
-  if (stat) {
-    cipher_dealloc(str->rtcp_cipher);
-    auth_dealloc(str->rtp_auth);
-    cipher_dealloc(str->rtp_cipher);
-    crypto_free(str->limit);
-    crypto_free(str);
-   return stat;
-  }  
-
-  /* allocate ekt data associated with stream */
-  stat = ekt_alloc(&str->ekt, p->ekt);
-  if (stat) {
-    auth_dealloc(str->rtcp_auth);
-    cipher_dealloc(str->rtcp_cipher);
-    auth_dealloc(str->rtp_auth);
-    cipher_dealloc(str->rtp_cipher);
-    crypto_free(str->limit);
-    crypto_free(str);
-   return stat;    
-  }
-
-  return err_status_ok;
-}
-
-err_status_t
-srtp_stream_dealloc(srtp_t session, srtp_stream_ctx_t *stream) { 
-  err_status_t status;
-  
+  if (p->enc_xtn_hdr && p->enc_xtn_hdr_count > 0) {
+    srtp_cipher_type_id_t enc_xtn_hdr_cipher_type;
+    int enc_xtn_hdr_cipher_key_len;
+
+    str->enc_xtn_hdr = (int*) srtp_crypto_alloc(p->enc_xtn_hdr_count * sizeof(p->enc_xtn_hdr[0]));
+    if (!str->enc_xtn_hdr) {
+      srtp_stream_free(str);
+      return srtp_err_status_alloc_fail;
+    }
+    memcpy(str->enc_xtn_hdr, p->enc_xtn_hdr, p->enc_xtn_hdr_count * sizeof(p->enc_xtn_hdr[0]));
+    str->enc_xtn_hdr_count = p->enc_xtn_hdr_count;
+
+    /* For GCM ciphers, the corresponding ICM cipher is used for header extensions encryption. */
+    switch (p->rtp.cipher_type) {
+    case SRTP_AES_GCM_128:
+      enc_xtn_hdr_cipher_type = SRTP_AES_ICM_128;
+      enc_xtn_hdr_cipher_key_len = SRTP_AES_ICM_128_KEY_LEN_WSALT;
+      break;
+    case SRTP_AES_GCM_256:
+      enc_xtn_hdr_cipher_type = SRTP_AES_ICM_256;
+      enc_xtn_hdr_cipher_key_len = SRTP_AES_ICM_256_KEY_LEN_WSALT;
+      break;
+    default:
+      enc_xtn_hdr_cipher_type = p->rtp.cipher_type;
+      enc_xtn_hdr_cipher_key_len = p->rtp.cipher_key_len;
+      break;
+    }
+
+    for (i = 0; i < str->num_master_keys; i++) {
+      session_keys = &str->session_keys[i];
+
+      /* allocate cipher for extensions header encryption */
+      stat = srtp_crypto_kernel_alloc_cipher(enc_xtn_hdr_cipher_type,
+                                             &session_keys->rtp_xtn_hdr_cipher,
+                                             enc_xtn_hdr_cipher_key_len,
+                                             0);
+      if (stat) {
+        srtp_stream_free(str);
+        return stat;
+      }
+    }
+  } else {
+    for (i = 0; i < str->num_master_keys; i++) {
+      session_keys = &str->session_keys[i];
+      session_keys->rtp_xtn_hdr_cipher = NULL;
+    }
+
+    str->enc_xtn_hdr = NULL;
+    str->enc_xtn_hdr_count = 0;
+  }
+
+  return srtp_err_status_ok;
+}
+
+srtp_err_status_t
+srtp_stream_dealloc(srtp_stream_ctx_t *stream, srtp_stream_ctx_t *stream_template) {
+  srtp_err_status_t status;
+  unsigned int i = 0;
+  srtp_session_keys_t *session_keys = NULL;
+  srtp_session_keys_t *template_session_keys = NULL;
+
   /*
    * we use a conservative deallocation strategy - if any deallocation
@@ -242 +366 @@
    * anything else
    */
-
-  /* deallocate cipher, if it is not the same as that in template */
-  if (session->stream_template
-      && stream->rtp_cipher == session->stream_template->rtp_cipher) {
-    /* do nothing */
+  for ( i = 0; i < stream->num_master_keys; i++) {
+    session_keys = &stream->session_keys[i];
+
+    if (stream_template) {
+      template_session_keys = &stream_template->session_keys[i];
+    } else {
+      template_session_keys = NULL;
+    }
+
+    /* deallocate cipher, if it is not the same as that in template */
+    if (template_session_keys
+        && session_keys->rtp_cipher == template_session_keys->rtp_cipher) {
+       /* do nothing */
+    } else {
+       status = srtp_cipher_dealloc(session_keys->rtp_cipher);
+       if (status)
+         return status;
+    }
+
+    /* deallocate auth function, if it is not the same as that in template */
+    if (template_session_keys
+        && session_keys->rtp_auth == template_session_keys->rtp_auth) {
+       /* do nothing */
+    } else {
+      status = srtp_auth_dealloc(session_keys->rtp_auth);
+      if (status)
+        return status;
+    }
+
+    if (template_session_keys
+        && session_keys->rtp_xtn_hdr_cipher == template_session_keys->rtp_xtn_hdr_cipher) {
+       /* do nothing */
+    } else if (session_keys->rtp_xtn_hdr_cipher) {
+      status = srtp_cipher_dealloc(session_keys->rtp_xtn_hdr_cipher);
+      if (status)
+        return status;
+    }
+
+    /*
+     * deallocate rtcp cipher, if it is not the same as that in
+     * template
+     */
+    if (template_session_keys
+        && session_keys->rtcp_cipher == template_session_keys->rtcp_cipher) {
+      /* do nothing */
+    } else {
+      status = srtp_cipher_dealloc(session_keys->rtcp_cipher);
+      if (status)
+        return status;
+    }
+
+    /*
+     * deallocate rtcp auth function, if it is not the same as that in
+     * template
+     */
+    if (template_session_keys
+        && session_keys->rtcp_auth == template_session_keys->rtcp_auth) {
+      /* do nothing */
+    } else {
+      status = srtp_auth_dealloc(session_keys->rtcp_auth);
+      if (status)
+        return status;
+    }
+
+    /*
+     * zeroize the salt value
+     */
+    octet_string_set_to_zero(session_keys->salt, SRTP_AEAD_SALT_LEN);
+    octet_string_set_to_zero(session_keys->c_salt, SRTP_AEAD_SALT_LEN);
+
+    if (session_keys->mki_id) {
+      octet_string_set_to_zero(session_keys->mki_id, session_keys->mki_size);
+      srtp_crypto_free(session_keys->mki_id);
+      session_keys->mki_id = NULL;
+    }
+
+    /* deallocate key usage limit, if it is not the same as that in template */
+    if (template_session_keys
+        && session_keys->limit == template_session_keys->limit) {
+        /* do nothing */
+    } else {
+      srtp_crypto_free(session_keys->limit);
+    }
+
+  }
+
+  if (stream_template
+      && stream->session_keys == stream_template->session_keys) {
+      /* do nothing */
   } else {
-    status = cipher_dealloc(stream->rtp_cipher); 
-    if (status) 
-      return status;
-  }
-
-  /* deallocate auth function, if it is not the same as that in template */
-  if (session->stream_template
-      && stream->rtp_auth == session->stream_template->rtp_auth) {
-    /* do nothing */
-  } else {
-    status = auth_dealloc(stream->rtp_auth);
-    if (status)
-      return status;
-  }
-
-  /* deallocate key usage limit, if it is not the same as that in template */
-  if (session->stream_template
-      && stream->limit == session->stream_template->limit) {
-    /* do nothing */
-  } else {
-    crypto_free(stream->limit);
-  }   
-
-  /* 
-   * deallocate rtcp cipher, if it is not the same as that in
-   * template 
-   */
-  if (session->stream_template
-      && stream->rtcp_cipher == session->stream_template->rtcp_cipher) {
-    /* do nothing */
-  } else {
-    status = cipher_dealloc(stream->rtcp_cipher); 
-    if (status) 
-      return status;
-  }
-
-  /*
-   * deallocate rtcp auth function, if it is not the same as that in
-   * template 
-   */
-  if (session->stream_template
-      && stream->rtcp_auth == session->stream_template->rtcp_auth) {
-    /* do nothing */
-  } else {
-    status = auth_dealloc(stream->rtcp_auth);
-    if (status)
-      return status;
-  }
-
-  status = rdbx_dealloc(&stream->rtp_rdbx);
+    srtp_crypto_free(stream->session_keys);
+  }
+
+  status = srtp_rdbx_dealloc(&stream->rtp_rdbx);
   if (status)
     return status;
@@ -303 +465 @@
   /* DAM - need to deallocate EKT here */
 
-  /*
-   * zeroize the salt value
-   */
-  memset(stream->salt, 0, SRTP_AEAD_SALT_LEN);
-  memset(stream->c_salt, 0, SRTP_AEAD_SALT_LEN);
-
-  
+  if (stream_template
+      && stream->enc_xtn_hdr == stream_template->enc_xtn_hdr) {
+    /* do nothing */
+  } else if (stream->enc_xtn_hdr) {
+    srtp_crypto_free(stream->enc_xtn_hdr);
+  }
+
   /* deallocate srtp stream context */
-  crypto_free(stream);
-
-  return err_status_ok;
+  srtp_crypto_free(stream);
+
+  return srtp_err_status_ok;
 }
 
@@ -325 +487 @@
  */
 
-err_status_t
+srtp_err_status_t
 srtp_stream_clone(const srtp_stream_ctx_t *stream_template, 
                   uint32_t ssrc, 
                   srtp_stream_ctx_t **str_ptr) {
-  err_status_t status;
+  srtp_err_status_t status;
   srtp_stream_ctx_t *str;
-
-  debug_print(mod_srtp, "cloning stream (SSRC: 0x%08x)", ssrc);
+  unsigned int i = 0;
+  srtp_session_keys_t *session_keys = NULL;
+  const srtp_session_keys_t *template_session_keys = NULL;
+
+  debug_print(mod_srtp, "cloning stream (SSRC: 0x%08x)", ntohl(ssrc));
 
   /* allocate srtp stream and set str_ptr */
-  str = (srtp_stream_ctx_t *) crypto_alloc(sizeof(srtp_stream_ctx_t));
+  str = (srtp_stream_ctx_t *) srtp_crypto_alloc(sizeof(srtp_stream_ctx_t));
   if (str == NULL)
-    return err_status_alloc_fail;
+    return srtp_err_status_alloc_fail;
   *str_ptr = str;  
 
-  /* set cipher and auth pointers to those of the template */
-  str->rtp_cipher  = stream_template->rtp_cipher;
-  str->rtp_auth    = stream_template->rtp_auth;
-  str->rtcp_cipher = stream_template->rtcp_cipher;
-  str->rtcp_auth   = stream_template->rtcp_auth;
-
-  /* set key limit to point to that of the template */
-  status = key_limit_clone(stream_template->limit, &str->limit);
-  if (status) { 
-    crypto_free(*str_ptr);
+  str->num_master_keys = stream_template->num_master_keys;
+  str->session_keys = (srtp_session_keys_t *)srtp_crypto_alloc(
+      sizeof(srtp_session_keys_t) * str->num_master_keys);
+
+  if (str->session_keys == NULL) {
+    srtp_crypto_free(*str_ptr);
+    *str_ptr = NULL;
+    return srtp_err_status_alloc_fail;
+  }
+
+  for (i = 0; i < stream_template->num_master_keys; i++){
+    session_keys = &str->session_keys[i];
+    template_session_keys = &stream_template->session_keys[i];
+
+    /* set cipher and auth pointers to those of the template */
+    session_keys->rtp_cipher  = template_session_keys->rtp_cipher;
+    session_keys->rtp_auth    = template_session_keys->rtp_auth;
+    session_keys->rtp_xtn_hdr_cipher = template_session_keys->rtp_xtn_hdr_cipher;
+    session_keys->rtcp_cipher = template_session_keys->rtcp_cipher;
+    session_keys->rtcp_auth   = template_session_keys->rtcp_auth;
+    session_keys->mki_size = template_session_keys->mki_size;
+
+    if (template_session_keys->mki_size == 0) {
+      session_keys->mki_id = NULL;
+    } else {
+      session_keys->mki_id = srtp_crypto_alloc(template_session_keys->mki_size);
+
+      if (session_keys->mki_id == NULL) {
+        return srtp_err_status_init_fail;
+      }
+      memset(session_keys->mki_id, 0x0, session_keys->mki_size);
+      memcpy(session_keys->mki_id, template_session_keys->mki_id, session_keys->mki_size);
+    }
+    /* Copy the salt values */
+    memcpy(session_keys->salt, template_session_keys->salt, SRTP_AEAD_SALT_LEN);
+    memcpy(session_keys->c_salt, template_session_keys->c_salt, SRTP_AEAD_SALT_LEN);
+
+    /* set key limit to point to that of the template */
+    status = srtp_key_limit_clone(template_session_keys->limit, &session_keys->limit);
+    if (status) { 
+      srtp_crypto_free(*str_ptr);
+      *str_ptr = NULL;
+      return status;
+    }
+  }
+
+
+  /* initialize replay databases */
+  status = srtp_rdbx_init(&str->rtp_rdbx,
+                     srtp_rdbx_get_window_size(&stream_template->rtp_rdbx));
+  if (status) {
+    srtp_crypto_free(*str_ptr);
     *str_ptr = NULL;
     return status;
   }
-
-  /* initialize replay databases */
-  status = rdbx_init(&str->rtp_rdbx,
-                     rdbx_get_window_size(&stream_template->rtp_rdbx));
-  if (status) {
-    crypto_free(*str_ptr);
-    *str_ptr = NULL;
-    return status;
-  }
-  rdb_init(&str->rtcp_rdb);
+  srtp_rdb_init(&str->rtcp_rdb);
   str->allow_repeat_tx = stream_template->allow_repeat_tx;
-  
+
   /* set ssrc to that provided */
   str->ssrc = ssrc;
+
+  /* reset pending ROC */
+  str->pending_roc = 0;
 
   /* set direction and security services */
@@ -376 +577 @@
   str->ekt = stream_template->ekt;
 
-  /* Copy the salt values */
-  memcpy(str->salt, stream_template->salt, SRTP_AEAD_SALT_LEN);
-  memcpy(str->c_salt, stream_template->c_salt, SRTP_AEAD_SALT_LEN);
+  /* copy information about extensions header encryption */
+  str->enc_xtn_hdr = stream_template->enc_xtn_hdr;
+  str->enc_xtn_hdr_count = stream_template->enc_xtn_hdr_count;
 
   /* defensive coding */
   str->next = NULL;
-
-  return err_status_ok;
+  return srtp_err_status_ok;
 }
 
@@ -409 +609 @@
   label_rtcp_encryption = 0x03,
   label_rtcp_msg_auth   = 0x04,
-  label_rtcp_salt       = 0x05
+  label_rtcp_salt       = 0x05,
+  label_rtp_header_encryption = 0x06,
+  label_rtp_header_salt = 0x07
 } srtp_prf_label;
 
+#define MAX_SRTP_KEY_LEN 256
+
+#if defined(OPENSSL) && defined(OPENSSL_KDF)
+#define MAX_SRTP_AESKEY_LEN 32
+#define MAX_SRTP_SALT_LEN 14 
 
 /*
@@ -417 +624 @@
  * default KDF is the only one implemented at present.
  */
-
 typedef struct { 
-  cipher_t *cipher;    /* cipher used for key derivation  */  
+    uint8_t master_key[MAX_SRTP_AESKEY_LEN];
+    uint8_t master_salt[MAX_SRTP_SALT_LEN];
+    const EVP_CIPHER *evp;
 } srtp_kdf_t;
 
-err_status_t
-srtp_kdf_init(srtp_kdf_t *kdf, cipher_type_id_t cipher_id, const uint8_t *key, int length) {
-
-  err_status_t stat;
-  stat = crypto_kernel_alloc_cipher(cipher_id, &kdf->cipher, length, 0);
-  if (stat)
-    return stat;
-
-  stat = cipher_init(kdf->cipher, key);
-  if (stat) {
-    cipher_dealloc(kdf->cipher);
-    return stat;
-  }
-
-  return err_status_ok;
-}
-
-err_status_t
-srtp_kdf_generate(srtp_kdf_t *kdf, srtp_prf_label label,
-                  uint8_t *key, unsigned int length) {
-
-  v128_t nonce;
-  err_status_t status;
+
+static srtp_err_status_t srtp_kdf_init(srtp_kdf_t *kdf, const uint8_t *key, int key_len, int salt_len) 
+{
+    memset(kdf, 0x0, sizeof(srtp_kdf_t));
+
+    /* The NULL cipher has zero key length */
+    if (key_len == 0) return srtp_err_status_ok;
+
+    if ((key_len > MAX_SRTP_AESKEY_LEN) || (salt_len > MAX_SRTP_SALT_LEN)) {
+        return srtp_err_status_bad_param;
+    }
+    switch (key_len) {
+    case SRTP_AES_256_KEYSIZE:
+        kdf->evp = EVP_aes_256_ctr();
+        break;
+    case SRTP_AES_192_KEYSIZE:
+        kdf->evp = EVP_aes_192_ctr();
+        break;
+    case SRTP_AES_128_KEYSIZE:
+        kdf->evp = EVP_aes_128_ctr();
+        break;
+    default:
+        return srtp_err_status_bad_param;
+        break;
+    }
+    memcpy(kdf->master_key, key, key_len); 
+    memcpy(kdf->master_salt, key+key_len, salt_len); 
+    return srtp_err_status_ok;
+}
+
+static srtp_err_status_t srtp_kdf_generate(srtp_kdf_t *kdf, srtp_prf_label label, uint8_t *key, unsigned int length) 
+{
+    int ret;
+
+    /* The NULL cipher will not have an EVP */
+    if (!kdf->evp) return srtp_err_status_ok;
+    octet_string_set_to_zero(key, length);
+
+    /*
+     * Invoke the OpenSSL SRTP KDF function
+     * This is useful if OpenSSL is in FIPS mode and FIP
+     * compliance is required for SRTP.
+     */
+    ret = kdf_srtp(kdf->evp, (char *)&kdf->master_key, (char *)&kdf->master_salt, NULL, NULL, label, (char *)key);
+    if (ret == -1) {
+        return (srtp_err_status_algo_fail);
+    }
+
+    return srtp_err_status_ok;
+}
+
+static srtp_err_status_t srtp_kdf_clear(srtp_kdf_t *kdf) {
+    octet_string_set_to_zero(kdf->master_key, MAX_SRTP_AESKEY_LEN);
+    octet_string_set_to_zero(kdf->master_salt, MAX_SRTP_SALT_LEN);
+    kdf->evp = NULL;
+
+    return srtp_err_status_ok;  
+}
+
+#else /* if OPENSSL_KDF */
+
+/*
+ * srtp_kdf_t represents a key derivation function.  The SRTP
+ * default KDF is the only one implemented at present.
+ */
+typedef struct { 
+    srtp_cipher_t *cipher;    /* cipher used for key derivation  */  
+} srtp_kdf_t;
+
+static srtp_err_status_t srtp_kdf_init(srtp_kdf_t *kdf, const uint8_t *key, int key_len)
+{
+    srtp_cipher_type_id_t cipher_id;
+    srtp_err_status_t stat;
+    switch (key_len) {
+    case SRTP_AES_ICM_256_KEY_LEN_WSALT:
+        cipher_id = SRTP_AES_ICM_256;
+        break;
+    case SRTP_AES_ICM_192_KEY_LEN_WSALT:
+        cipher_id = SRTP_AES_ICM_192;
+        break;
+    case SRTP_AES_ICM_128_KEY_LEN_WSALT:
+        cipher_id = SRTP_AES_ICM_128;
+        break;
+    default:
+        return srtp_err_status_bad_param;
+        break;
+    }
+
+    stat = srtp_crypto_kernel_alloc_cipher(cipher_id, &kdf->cipher, key_len, 0);
+    if (stat) return stat;
+
+    stat = srtp_cipher_init(kdf->cipher, key);
+    if (stat) {
+        srtp_cipher_dealloc(kdf->cipher);
+        return stat;
+    }
+    return srtp_err_status_ok;
+}
+
+static srtp_err_status_t srtp_kdf_generate(srtp_kdf_t *kdf, srtp_prf_label label, uint8_t *key, unsigned int length) 
+{
+    srtp_err_status_t status;
+    v128_t nonce;
   
-  /* set eigth octet of nonce to <label>, set the rest of it to zero */
-  v128_set_to_zero(&nonce);
-  nonce.v8[7] = label;
+    /* set eigth octet of nonce to <label>, set the rest of it to zero */
+    v128_set_to_zero(&nonce);
+    nonce.v8[7] = label;
  
-  status = cipher_set_iv(kdf->cipher, &nonce, direction_encrypt);
-  if (status)
-    return status;
+    status = srtp_cipher_set_iv(kdf->cipher, (uint8_t*)&nonce, srtp_direction_encrypt);
+    if (status) return status;
   
-  /* generate keystream output */
-  octet_string_set_to_zero(key, length);
-  status = cipher_encrypt(kdf->cipher, key, &length);
-  if (status)
-    return status;
-
-  return err_status_ok;
-}
-
-err_status_t
-srtp_kdf_clear(srtp_kdf_t *kdf) {
-  err_status_t status;
-  status = cipher_dealloc(kdf->cipher);
-  if (status)
-    return status;
-  kdf->cipher = NULL;
-
-  return err_status_ok;  
-}
+    /* generate keystream output */
+    octet_string_set_to_zero(key, length);
+    status = srtp_cipher_encrypt(kdf->cipher, key, &length);
+    if (status) return status;
+
+    return srtp_err_status_ok;
+}
+
+static srtp_err_status_t srtp_kdf_clear(srtp_kdf_t *kdf) {
+    srtp_err_status_t status;
+    status = srtp_cipher_dealloc(kdf->cipher);
+    if (status) return status;
+    kdf->cipher = NULL;
+    return srtp_err_status_ok;  
+}
+#endif /* else OPENSSL_KDF */
 
 /*
@@ -478 +762 @@
  */
 
-#define MAX_SRTP_KEY_LEN 256
 
 
 /* Get the base key length corresponding to a given combined key+salt
  * length for the given cipher.
- * Assumption is that for AES-ICM a key length < 30 is Ismacryp using
- * AES-128 and short salts; everything else uses a salt length of 14.
  * TODO: key and salt lengths should be separate fields in the policy.  */
-static inline int base_key_length(const cipher_type_t *cipher, int key_length)
+static inline int base_key_length(const srtp_cipher_type_t *cipher, int key_length)
 {
   switch (cipher->id) {
-  case AES_128_ICM:
-  case AES_192_ICM:
-  case AES_256_ICM:
+  case SRTP_AES_ICM_128:
+  case SRTP_AES_ICM_192:
+  case SRTP_AES_ICM_256:
     /* The legacy modes are derived from
      * the configured key length on the policy */
-    return key_length - 14;
+    return key_length - SRTP_SALT_LEN;
     break;
-  case AES_128_GCM:
-    return 16;
+  case SRTP_AES_GCM_128:
+    return key_length - SRTP_AEAD_SALT_LEN;
     break;
-  case AES_256_GCM:
-    return 32;
+  case SRTP_AES_GCM_256:
+      return key_length - SRTP_AEAD_SALT_LEN;
     break;
   default:
@@ -508 +789 @@
 }
 
-err_status_t
-srtp_stream_init_keys(srtp_stream_ctx_t *srtp, const void *key) {
-  err_status_t stat;
+unsigned int
+srtp_validate_policy_master_keys(const srtp_policy_t *policy)
+{
+    int i = 0;
+
+    if (policy->key == NULL) {
+        if (policy->num_master_keys <= 0)
+            return 0;
+
+        if (policy->num_master_keys > SRTP_MAX_NUM_MASTER_KEYS)
+            return 0;
+        
+        for (i = 0; i < policy->num_master_keys; i++) {
+            if (policy->keys[i]->key == NULL)
+                return 0;
+            if (policy->keys[i]->mki_size > SRTP_MAX_MKI_LEN)
+                return 0;
+        }
+    }
+
+    return 1;
+}
+
+srtp_session_keys_t*
+srtp_get_session_keys_with_mki_index(srtp_stream_ctx_t *stream,
+                                     unsigned int use_mki,
+                                     unsigned int mki_index) {
+    if (use_mki) {
+        if (mki_index < stream->num_master_keys) {
+            return &stream->session_keys[mki_index];
+        }
+    }
+
+    return &stream->session_keys[0];
+}
+
+unsigned int
+srtp_inject_mki(uint8_t *mki_tag_location, srtp_session_keys_t* session_keys,
+                unsigned int use_mki)
+{
+    unsigned int mki_size = 0;
+
+    if (use_mki) {
+        mki_size = session_keys->mki_size;
+
+        if (mki_size != 0) {
+            // Write MKI into memory
+            memcpy(mki_tag_location, session_keys->mki_id, mki_size);
+        }
+    }
+
+    return mki_size;
+}
+
+srtp_err_status_t
+srtp_stream_init_all_master_keys(srtp_stream_ctx_t *srtp,
+                                 unsigned char *key,
+                                 srtp_master_key_t **keys,
+                                 const unsigned int max_master_keys) {
+    int i = 0;
+    srtp_err_status_t status = srtp_err_status_ok;
+    srtp_master_key_t single_master_key;
+
+    if ( key != NULL ) {
+        srtp->num_master_keys = 1;
+        single_master_key.key = key;
+        single_master_key.mki_id = NULL;
+        single_master_key.mki_size = 0;
+        status = srtp_stream_init_keys(srtp, &single_master_key, 0);
+    } else {
+        srtp->num_master_keys = max_master_keys;
+
+        for (i = 0; i < srtp->num_master_keys && i < SRTP_MAX_NUM_MASTER_KEYS; i++) {
+            status = srtp_stream_init_keys(srtp, keys[i], i);
+
+            if (status) {
+                return status;
+            }
+        }
+    }
+
+    return status;
+}
+
+srtp_err_status_t
+srtp_stream_init_keys(srtp_stream_ctx_t *srtp, srtp_master_key_t *master_key,
+                      const unsigned int current_mki_index) {
+  srtp_err_status_t stat;
   srtp_kdf_t kdf;
   uint8_t tmp_key[MAX_SRTP_KEY_LEN];
@@ -516 +882 @@
   int rtp_base_key_len, rtp_salt_len;
   int rtcp_base_key_len, rtcp_salt_len;
+  srtp_session_keys_t *session_keys = NULL;
+  unsigned char *key = master_key->key;
 
   /* If RTP or RTCP have a key length > AES-128, assume matching kdf. */
   /* TODO: kdf algorithm, master key length, and master salt length should
    * be part of srtp_policy_t. */
-  rtp_keylen = cipher_get_key_length(srtp->rtp_cipher);
-  rtcp_keylen = cipher_get_key_length(srtp->rtcp_cipher);
-  rtp_base_key_len = base_key_length(srtp->rtp_cipher->type, rtp_keylen);
+  session_keys = &srtp->session_keys[current_mki_index];
+
+   /* initialize key limit to maximum value */
+#ifdef NO_64BIT_MATH
+{
+   uint64_t temp;
+   temp = make64(UINT_MAX,UINT_MAX);
+   srtp_key_limit_set(session_keys->limit, temp);
+}
+#else
+   srtp_key_limit_set(session_keys->limit, 0xffffffffffffLL);
+#endif
+
+
+  if ( master_key->mki_size != 0 ) {
+      session_keys->mki_id = srtp_crypto_alloc(master_key->mki_size);
+
+      if (session_keys->mki_id == NULL) {
+        return srtp_err_status_init_fail;
+      }
+      memset(session_keys->mki_id, 0x0, master_key->mki_size);
+      memcpy(session_keys->mki_id, master_key->mki_id, master_key->mki_size);
+  } else {
+      session_keys->mki_id = NULL;
+  }
+
+  session_keys->mki_size = master_key->mki_size;
+
+  rtp_keylen = srtp_cipher_get_key_length(session_keys->rtp_cipher);
+  rtcp_keylen = srtp_cipher_get_key_length(session_keys->rtcp_cipher);
+  rtp_base_key_len = base_key_length(session_keys->rtp_cipher->type, rtp_keylen);
   rtp_salt_len = rtp_keylen - rtp_base_key_len;
 
@@ -548 +944 @@
 
   /* initialize KDF state     */
-  stat = srtp_kdf_init(&kdf, AES_ICM, (const uint8_t *)tmp_key, kdf_keylen);
+#if defined(OPENSSL) && defined(OPENSSL_KDF)
+  stat = srtp_kdf_init(&kdf, (const uint8_t *)tmp_key, rtp_base_key_len, rtp_salt_len); 
+#else
+  stat = srtp_kdf_init(&kdf, (const uint8_t *)tmp_key, kdf_keylen);
+#endif
   if (stat) {
-    return err_status_init_fail;
+    /* zeroize temp buffer */
+    octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
+    return srtp_err_status_init_fail;
   }
   
@@ -559 +961 @@
     /* zeroize temp buffer */
     octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
-    return err_status_init_fail;
+    return srtp_err_status_init_fail;
   }
   debug_print(mod_srtp, "cipher key: %s", 
-              octet_string_hex_string(tmp_key, rtp_base_key_len));
+              srtp_octet_string_hex_string(tmp_key, rtp_base_key_len));
 
   /* 
@@ -577 +979 @@
       /* zeroize temp buffer */
       octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
-      return err_status_init_fail;
-    }
-    memcpy(srtp->salt, tmp_key + rtp_base_key_len, SRTP_AEAD_SALT_LEN);
+      return srtp_err_status_init_fail;
+    }
+    memcpy(session_keys->salt, tmp_key + rtp_base_key_len, SRTP_AEAD_SALT_LEN);
   }
   if (rtp_salt_len > 0) {
     debug_print(mod_srtp, "cipher salt: %s",
-                octet_string_hex_string(tmp_key + rtp_base_key_len, rtp_salt_len));
+                srtp_octet_string_hex_string(tmp_key + rtp_base_key_len, rtp_salt_len));
   }
 
   /* initialize cipher */
-  stat = cipher_init(srtp->rtp_cipher, tmp_key);
+  stat = srtp_cipher_init(session_keys->rtp_cipher, tmp_key);
   if (stat) {
     /* zeroize temp buffer */
     octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
-    return err_status_init_fail;
+    return srtp_err_status_init_fail;
+  }
+
+  if (session_keys->rtp_xtn_hdr_cipher) {
+    /* generate extensions header encryption key  */
+    int rtp_xtn_hdr_keylen;
+    int rtp_xtn_hdr_base_key_len;
+    int rtp_xtn_hdr_salt_len;
+    srtp_kdf_t tmp_kdf;
+    srtp_kdf_t *xtn_hdr_kdf;
+
+    if (session_keys->rtp_xtn_hdr_cipher->type != session_keys->rtp_cipher->type) {
+      /* With GCM ciphers, the header extensions are still encrypted using the corresponding ICM cipher. */
+      /* See https://tools.ietf.org/html/rfc7714#section-8.3 */
+      uint8_t tmp_xtn_hdr_key[MAX_SRTP_KEY_LEN];
+      rtp_xtn_hdr_keylen = srtp_cipher_get_key_length(session_keys->rtp_xtn_hdr_cipher);
+      rtp_xtn_hdr_base_key_len = base_key_length(session_keys->rtp_xtn_hdr_cipher->type,
+                                                 rtp_xtn_hdr_keylen);
+      rtp_xtn_hdr_salt_len = rtp_xtn_hdr_keylen - rtp_xtn_hdr_base_key_len;
+      if (rtp_xtn_hdr_salt_len > rtp_salt_len) {
+        switch (session_keys->rtp_cipher->type->id) {
+        case SRTP_AES_GCM_128:
+        case SRTP_AES_GCM_256:
+          /* The shorter GCM salt is padded to the required ICM salt length. */
+          rtp_xtn_hdr_salt_len = rtp_salt_len;
+          break;
+        default:
+          /* zeroize temp buffer */
+          octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
+          return srtp_err_status_bad_param;
+        }
+      }
+      memset(tmp_xtn_hdr_key, 0x0, MAX_SRTP_KEY_LEN);
+      memcpy(tmp_xtn_hdr_key, key, (rtp_xtn_hdr_base_key_len + rtp_xtn_hdr_salt_len));
+      xtn_hdr_kdf = &tmp_kdf;
+
+      /* initialize KDF state     */
+#if defined(OPENSSL) && defined(OPENSSL_KDF)
+      stat = srtp_kdf_init(xtn_hdr_kdf, (const uint8_t *)tmp_xtn_hdr_key, rtp_xtn_hdr_base_key_len, rtp_xtn_hdr_salt_len);
+#else
+      stat = srtp_kdf_init(xtn_hdr_kdf, (const uint8_t *)tmp_xtn_hdr_key, kdf_keylen);
+#endif
+      octet_string_set_to_zero(tmp_xtn_hdr_key, MAX_SRTP_KEY_LEN);
+      if (stat) {
+        /* zeroize temp buffer */
+        octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
+        return srtp_err_status_init_fail;
+      }
+    } else {
+      /* Reuse main KDF. */
+      rtp_xtn_hdr_keylen = rtp_keylen;
+      rtp_xtn_hdr_base_key_len = rtp_base_key_len;
+      rtp_xtn_hdr_salt_len = rtp_salt_len;
+      xtn_hdr_kdf = &kdf;
+    }
+
+    stat = srtp_kdf_generate(xtn_hdr_kdf, label_rtp_header_encryption,
+           tmp_key, rtp_xtn_hdr_base_key_len);
+    if (stat) {
+      /* zeroize temp buffer */
+      octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
+      return srtp_err_status_init_fail;
+    }
+    debug_print(mod_srtp, "extensions cipher key: %s",
+          srtp_octet_string_hex_string(tmp_key, rtp_xtn_hdr_base_key_len));
+
+    /*
+     * if the cipher in the srtp context uses a salt, then we need
+     * to generate the salt value
+     */
+    if (rtp_xtn_hdr_salt_len > 0) {
+      debug_print(mod_srtp, "found rtp_xtn_hdr_salt_len > 0, generating salt", NULL);
+
+      /* generate encryption salt, put after encryption key */
+      stat = srtp_kdf_generate(xtn_hdr_kdf, label_rtp_header_salt,
+             tmp_key + rtp_xtn_hdr_base_key_len, rtp_xtn_hdr_salt_len);
+      if (stat) {
+        /* zeroize temp buffer */
+        octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
+        return srtp_err_status_init_fail;
+      }
+    }
+    if (rtp_xtn_hdr_salt_len > 0) {
+      debug_print(mod_srtp, "extensions cipher salt: %s",
+      srtp_octet_string_hex_string(tmp_key + rtp_xtn_hdr_base_key_len, rtp_xtn_hdr_salt_len));
+    }
+
+    /* initialize extensions header cipher */
+    stat = srtp_cipher_init(session_keys->rtp_xtn_hdr_cipher, tmp_key);
+    if (stat) {
+      /* zeroize temp buffer */
+      octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
+      return srtp_err_status_init_fail;
+    }
+
+    if (xtn_hdr_kdf != &kdf) {
+      /* release memory for custom header extension encryption kdf */
+      stat = srtp_kdf_clear(xtn_hdr_kdf);
+      if (stat) {
+        /* zeroize temp buffer */
+        octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
+        return srtp_err_status_init_fail;
+      }
+    }
   }
 
   /* generate authentication key */
   stat = srtp_kdf_generate(&kdf, label_rtp_msg_auth,
-                           tmp_key, auth_get_key_length(srtp->rtp_auth));
+                           tmp_key, srtp_auth_get_key_length(session_keys->rtp_auth));
   if (stat) {
     /* zeroize temp buffer */
     octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
-    return err_status_init_fail;
+    return srtp_err_status_init_fail;
   }
   debug_print(mod_srtp, "auth key:   %s",
-              octet_string_hex_string(tmp_key, 
-                                      auth_get_key_length(srtp->rtp_auth))); 
+              srtp_octet_string_hex_string(tmp_key, 
+                                      srtp_auth_get_key_length(session_keys->rtp_auth))); 
 
   /* initialize auth function */
-  stat = auth_init(srtp->rtp_auth, tmp_key);
+  stat = srtp_auth_init(session_keys->rtp_auth, tmp_key);
   if (stat) {
     /* zeroize temp buffer */
     octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
-    return err_status_init_fail;
+    return srtp_err_status_init_fail;
   }
 
@@ -618 +1123 @@
    */
 
-  rtcp_base_key_len = base_key_length(srtp->rtcp_cipher->type, rtcp_keylen);
+  rtcp_base_key_len = base_key_length(session_keys->rtcp_cipher->type, rtcp_keylen);
   rtcp_salt_len = rtcp_keylen - rtcp_base_key_len;
   debug_print(mod_srtp, "rtcp salt len: %d", rtcp_salt_len);
@@ -628 +1133 @@
     /* zeroize temp buffer */
     octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
-    return err_status_init_fail;
+    return srtp_err_status_init_fail;
   }
 
@@ -645 +1150 @@
       /* zeroize temp buffer */
       octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
-      return err_status_init_fail;
-    }
-    memcpy(srtp->c_salt, tmp_key + rtcp_base_key_len, SRTP_AEAD_SALT_LEN);
+      return srtp_err_status_init_fail;
+    }
+    memcpy(session_keys->c_salt, tmp_key + rtcp_base_key_len, SRTP_AEAD_SALT_LEN);
   }
   debug_print(mod_srtp, "rtcp cipher key: %s", 
-              octet_string_hex_string(tmp_key, rtcp_base_key_len));  
+              srtp_octet_string_hex_string(tmp_key, rtcp_base_key_len));  
   if (rtcp_salt_len > 0) {
     debug_print(mod_srtp, "rtcp cipher salt: %s",
-                octet_string_hex_string(tmp_key + rtcp_base_key_len, rtcp_salt_len));
+                srtp_octet_string_hex_string(tmp_key + rtcp_base_key_len, rtcp_salt_len));
   }
 
   /* initialize cipher */
-  stat = cipher_init(srtp->rtcp_cipher, tmp_key);
+  stat = srtp_cipher_init(session_keys->rtcp_cipher, tmp_key);
   if (stat) {
     /* zeroize temp buffer */
     octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
-    return err_status_init_fail;
+    return srtp_err_status_init_fail;
   }
 
   /* generate authentication key */
   stat = srtp_kdf_generate(&kdf, label_rtcp_msg_auth,
-                           tmp_key, auth_get_key_length(srtp->rtcp_auth));
+                           tmp_key, srtp_auth_get_key_length(session_keys->rtcp_auth));
   if (stat) {
     /* zeroize temp buffer */
     octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
-    return err_status_init_fail;
+    return srtp_err_status_init_fail;
   }
 
   debug_print(mod_srtp, "rtcp auth key:   %s",
-              octet_string_hex_string(tmp_key, 
-                     auth_get_key_length(srtp->rtcp_auth))); 
+              srtp_octet_string_hex_string(tmp_key, 
+                     srtp_auth_get_key_length(session_keys->rtcp_auth))); 
 
   /* initialize auth function */
-  stat = auth_init(srtp->rtcp_auth, tmp_key);
+  stat = srtp_auth_init(session_keys->rtcp_auth, tmp_key);
   if (stat) {
     /* zeroize temp buffer */
     octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
-    return err_status_init_fail;
+    return srtp_err_status_init_fail;
   }
 
   /* clear memory then return */
   stat = srtp_kdf_clear(&kdf);
-  octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);  
+  octet_string_set_to_zero(tmp_key, MAX_SRTP_KEY_LEN);
   if (stat)
-    return err_status_init_fail;
-
-  return err_status_ok;
-}
-
-err_status_t
+    return srtp_err_status_init_fail;
+
+  return srtp_err_status_ok;
+}
+
+srtp_err_status_t
 srtp_stream_init(srtp_stream_ctx_t *srtp, 
                   const srtp_policy_t *p) {
-  err_status_t err;
+  srtp_err_status_t err;
 
    debug_print(mod_srtp, "initializing stream (SSRC: 0x%08x)", 
@@ -708 +1213 @@
 
    if (p->window_size != 0 && (p->window_size < 64 || p->window_size >= 0x8000))
-     return err_status_bad_param;
+     return srtp_err_status_bad_param;
 
    if (p->window_size != 0)
-     err = rdbx_init(&srtp->rtp_rdbx, p->window_size);
+     err = srtp_rdbx_init(&srtp->rtp_rdbx, p->window_size);
    else
-     err = rdbx_init(&srtp->rtp_rdbx, 128);
+     err = srtp_rdbx_init(&srtp->rtp_rdbx, 128);
    if (err) return err;
-
-   /* initialize key limit to maximum value */
-#ifdef NO_64BIT_MATH
-{
-   uint64_t temp;
-   temp = make64(UINT_MAX,UINT_MAX);
-   key_limit_set(srtp->limit, temp);
-}
-#else
-   key_limit_set(srtp->limit, 0xffffffffffffLL);
-#endif
 
    /* set the SSRC value */
    srtp->ssrc = htonl(p->ssrc.value);
+
+   /* reset pending ROC */
+   srtp->pending_roc = 0;
 
    /* set the security service flags */
@@ -742 +1239 @@
 
    /* initialize SRTCP replay database */
-   rdb_init(&srtp->rtcp_rdb);
+   srtp_rdb_init(&srtp->rtcp_rdb);
 
    /* initialize allow_repeat_tx */
    /* guard against uninitialized memory: allow only 0 or 1 here */
    if (p->allow_repeat_tx != 0 && p->allow_repeat_tx != 1) {
-     rdbx_dealloc(&srtp->rtp_rdbx);
-     return err_status_bad_param;
+     srtp_rdbx_dealloc(&srtp->rtp_rdbx);
+     return srtp_err_status_bad_param;
    }
    srtp->allow_repeat_tx = p->allow_repeat_tx;
@@ -755 +1252 @@
 
    /* initialize keys */
-   err = srtp_stream_init_keys(srtp, p->key);
+   err = srtp_stream_init_all_master_keys(srtp, p->key, p->keys, p->num_master_keys);
    if (err) {
-     rdbx_dealloc(&srtp->rtp_rdbx);
+     srtp_rdbx_dealloc(&srtp->rtp_rdbx);
      return err;
    }
@@ -765 +1262 @@
     * the stream
     */
-   err = ekt_stream_init_from_policy(srtp->ekt, p->ekt);
+   err = srtp_ekt_stream_init_from_policy(srtp->ekt, p->ekt);
    if (err) {
-     rdbx_dealloc(&srtp->rtp_rdbx);
+     srtp_rdbx_dealloc(&srtp->rtp_rdbx);
      return err;
    }
 
-   return err_status_ok;  
+   return srtp_err_status_ok;  
  }
 
@@ -783 +1280 @@
  srtp_event_reporter(srtp_event_data_t *data) {
 
-   err_report(err_level_warning, "srtp: in stream 0x%x: ", 
-              data->stream->ssrc);
+   srtp_err_report(srtp_err_level_warning, "srtp: in stream 0x%x: ", 
+                   data->ssrc);
 
    switch(data->event) {
    case event_ssrc_collision:
-     err_report(err_level_warning, "\tSSRC collision\n");
+     srtp_err_report(srtp_err_level_warning, "\tSSRC collision\n");
      break;
    case event_key_soft_limit:
-     err_report(err_level_warning, "\tkey usage soft limit reached\n");
+     srtp_err_report(srtp_err_level_warning, "\tkey usage soft limit reached\n");
      break;
    case event_key_hard_limit:
-     err_report(err_level_warning, "\tkey usage hard limit reached\n");
+     srtp_err_report(srtp_err_level_warning, "\tkey usage hard limit reached\n");
      break;
    case event_packet_index_limit:
-     err_report(err_level_warning, "\tpacket index limit reached\n");
+     srtp_err_report(srtp_err_level_warning, "\tpacket index limit reached\n");
      break;
    default:
-     err_report(err_level_warning, "\tunknown event reported to handler\n");
+     srtp_err_report(srtp_err_level_warning, "\tunknown event reported to handler\n");
    }
  }
@@ -816 +1313 @@
  static srtp_event_handler_func_t *srtp_event_handler = srtp_event_reporter;
 
- err_status_t
+ srtp_err_status_t
  srtp_install_event_handler(srtp_event_handler_func_t func) {
 
@@ -827 +1324 @@
    /* set global event handling function */
    srtp_event_handler = func;
-   return err_status_ok;
+   return srtp_err_status_ok;
  }
+
+
+/*
+ * Check if the given extension header id is / should be encrypted.
+ * Returns 1 if yes, otherwise 0.
+ */
+static int
+srtp_protect_extension_header(srtp_stream_ctx_t *stream, int id) {
+  int* enc_xtn_hdr = stream->enc_xtn_hdr;
+  int count = stream->enc_xtn_hdr_count;
+
+  if (!enc_xtn_hdr || count <= 0) {
+    return 0;
+  }
+
+  while (count > 0) {
+    if (*enc_xtn_hdr == id) {
+      return 1;
+    }
+
+    enc_xtn_hdr++;
+    count--;
+  }
+  return 0;
+}
+
+
+/*
+ * extensions header encryption RFC 6904
+ */
+static srtp_err_status_t
+srtp_process_header_encryption(srtp_stream_ctx_t *stream,
+                               srtp_hdr_xtnd_t *xtn_hdr,
+                               srtp_session_keys_t *session_keys) {
+  srtp_err_status_t status;
+  uint8_t keystream[257];  /* Maximum 2 bytes header + 255 bytes data. */
+  int keystream_pos;
+  uint8_t* xtn_hdr_data = ((uint8_t *)xtn_hdr) + octets_in_rtp_extn_hdr;
+  uint8_t* xtn_hdr_end = xtn_hdr_data + (ntohs(xtn_hdr->length) * sizeof(uint32_t));
+
+  if (ntohs(xtn_hdr->profile_specific) == 0xbede) {
+    /* RFC 5285, section 4.2. One-Byte Header */
+    while (xtn_hdr_data < xtn_hdr_end) {
+      uint8_t xid = (*xtn_hdr_data & 0xf0) >> 4;
+      unsigned int xlen = (*xtn_hdr_data & 0x0f) + 1;
+      uint32_t xlen_with_header = 1+xlen;
+      xtn_hdr_data++;
+
+      if (xtn_hdr_data + xlen > xtn_hdr_end)
+        return srtp_err_status_parse_err;
+
+      if (xid == 15) {
+        /* found header 15, stop further processing. */
+        break;
+      }
+
+      status = srtp_cipher_output(session_keys->rtp_xtn_hdr_cipher,
+                                  keystream, &xlen_with_header);
+      if (status)
+        return srtp_err_status_cipher_fail;
+
+      if (srtp_protect_extension_header(stream, xid)) {
+        keystream_pos = 1;
+        while (xlen > 0) {
+          *xtn_hdr_data ^= keystream[keystream_pos++];
+          xtn_hdr_data++;
+          xlen--;
+        }
+      } else {
+        xtn_hdr_data += xlen;
+      }
+
+      /* skip padding bytes. */
+      while (xtn_hdr_data < xtn_hdr_end && *xtn_hdr_data == 0) {
+        xtn_hdr_data++;
+      }
+    }
+  } else if ((ntohs(xtn_hdr->profile_specific) & 0x1fff) == 0x100) {
+    /* RFC 5285, section 4.3. Two-Byte Header */
+    while (xtn_hdr_data + 1 < xtn_hdr_end) {
+      uint8_t xid = *xtn_hdr_data;
+      unsigned int xlen = *(xtn_hdr_data+1);
+      uint32_t xlen_with_header = 2+xlen;
+      xtn_hdr_data += 2;
+
+      if (xtn_hdr_data + xlen > xtn_hdr_end)
+        return srtp_err_status_parse_err;
+
+      status = srtp_cipher_output(session_keys->rtp_xtn_hdr_cipher,
+                                  keystream, &xlen_with_header);
+      if (status)
+        return srtp_err_status_cipher_fail;
+
+      if (xlen > 0 && srtp_protect_extension_header(stream, xid)) {
+        keystream_pos = 2;
+        while (xlen > 0) {
+          *xtn_hdr_data ^= keystream[keystream_pos++];
+          xtn_hdr_data++;
+          xlen--;
+        }
+      } else {
+        xtn_hdr_data += xlen;
+      }
+
+      /* skip padding bytes. */
+      while (xtn_hdr_data < xtn_hdr_end && *xtn_hdr_data == 0) {
+        xtn_hdr_data++;
+      }
+    }
+  } else {
+    /* unsupported extension header format. */
+    return srtp_err_status_parse_err;
+  }
+
+  return srtp_err_status_ok;
+}
+
 
 /*
  * AEAD uses a new IV formation method.  This function implements
- * section 9.1 from draft-ietf-avtcore-srtp-aes-gcm-07.txt.  The
- * calculation is defined as, where (+) is the xor operation:
+ * section 8.1. (SRTP IV Formation for AES-GCM) of RFC7714.
+ * The calculation is defined as, where (+) is the xor operation:
  *
  *
@@ -850 +1464 @@
  *            +--+--+--+--+--+--+--+--+--+--+--+--+*
  *
- * Input:  *stream - pointer to SRTP stream context, used to retrieve
- *                   the SALT 
+ * Input:  *session_keys - pointer to SRTP stream context session keys,
+ *                         used to retrieve the SALT 
  *         *iv     - Pointer to receive the calculated IV
  *         *seq    - The ROC and SEQ value to use for the
@@ -858 +1472 @@
  *
  */
-static void srtp_calc_aead_iv(srtp_stream_ctx_t *stream, v128_t *iv, 
-                              xtd_seq_num_t *seq, srtp_hdr_t *hdr)
+
+static void srtp_calc_aead_iv(srtp_session_keys_t *session_keys, v128_t *iv,
+                              srtp_xtd_seq_num_t *seq, srtp_hdr_t *hdr)
 {
     v128_t      in;
@@ -889 +1504 @@
      * Get the SALT value from the context
      */
-    memcpy(salt.v8, stream->salt, SRTP_AEAD_SALT_LEN);
+    memcpy(salt.v8, session_keys->salt, SRTP_AEAD_SALT_LEN);
     debug_print(mod_srtp, "RTP SALT = %s\n", v128_hex_string(&salt));
 
@@ -898 +1513 @@
 }
 
+
+srtp_session_keys_t* 
+srtp_get_session_keys(srtp_stream_ctx_t *stream, uint8_t* hdr,
+                      const unsigned int* pkt_octet_len,
+                      unsigned int* mki_size) {
+  unsigned int base_mki_start_location = *pkt_octet_len;
+  unsigned int mki_start_location = 0;
+  unsigned int tag_len = 0;
+  unsigned int i = 0;
+
+  // Determine the authentication tag size
+  if (stream->session_keys[0].rtp_cipher->algorithm == SRTP_AES_GCM_128 ||
+      stream->session_keys[0].rtp_cipher->algorithm == SRTP_AES_GCM_256) {
+      tag_len = 0;
+  } else {
+      tag_len = srtp_auth_get_tag_length(stream->session_keys[0].rtp_auth);
+  }
+
+  if (tag_len > base_mki_start_location) {
+     *mki_size = 0;
+     return NULL;
+  }
+
+  base_mki_start_location -= tag_len;
+
+  for (i = 0; i < stream->num_master_keys; i++) {
+      if (stream->session_keys[i].mki_size != 0) {
+          *mki_size = stream->session_keys[i].mki_size;
+          mki_start_location = base_mki_start_location - *mki_size;
+
+          if ( mki_start_location >= *mki_size &&
+              memcmp(hdr + mki_start_location, stream->session_keys[i].mki_id, *mki_size) == 0 ) {
+              return &stream->session_keys[i];
+          }
+      }
+  }
+
+  *mki_size = 0;
+  return NULL;
+}
+
+static srtp_err_status_t
+srtp_estimate_index(srtp_rdbx_t *rdbx,
+                    uint32_t roc,
+                    srtp_xtd_seq_num_t *est,
+                    srtp_sequence_number_t seq,
+                    int *delta)
+{
+#ifdef NO_64BIT_MATH
+  uint32_t internal_pkt_idx_reduced;
+  uint32_t external_pkt_idx_reduced;
+  uint32_t internal_roc;
+  uint32_t roc_difference;
+#endif
+
+#ifdef NO_64BIT_MATH
+  *est = (srtp_xtd_seq_num_t)make64(roc >> 16, (roc << 16) | seq);
+  *delta = low32(est) - rdbx->index;
+#else
+  *est = (srtp_xtd_seq_num_t)(((uint64_t)roc) << 16) | seq;
+  *delta = (int)(*est - rdbx->index);
+#endif
+
+  if (*est > rdbx->index) {
+#ifdef NO_64BIT_MATH
+    internal_roc = (uint32_t)(rdbx->index >> 16);
+    roc_difference = roc - internal_roc;
+    if (roc_difference > 1) {
+      *delta = 0;
+      return srtp_err_status_pkt_idx_adv;
+    }
+
+    internal_pkt_idx_reduced = (uint32_t)(rdbx->index & 0xFFFF);
+    external_pkt_idx_reduced = (uint32_t)((roc_difference << 16) | seq);
+
+    if (external_pkt_idx_reduced - internal_pkt_idx_reduced >
+                                                    seq_num_median) {
+      *delta = 0;
+      return srtp_err_status_pkt_idx_adv;
+    }
+#else
+    if (*est - rdbx->index > seq_num_median) {
+      *delta = 0;
+      return srtp_err_status_pkt_idx_adv;
+    }
+#endif
+  } else if (*est < rdbx->index) {
+#ifdef NO_64BIT_MATH
+
+    internal_roc = (uint32_t)(rdbx->index >> 16);
+    roc_difference = internal_roc - roc;
+    if (roc_difference > 1) {
+      *delta = 0;
+      return srtp_err_status_pkt_idx_adv;
+    }
+
+    internal_pkt_idx_reduced =
+                (uint32_t)((roc_difference << 16) | rdbx->index & 0xFFFF);
+    external_pkt_idx_reduced = (uint32_t)(seq);
+
+    if (internal_pkt_idx_reduced - external_pkt_idx_reduced >
+                                                    seq_num_median) {
+      *delta = 0;
+      return srtp_err_status_pkt_idx_old;
+    }
+#else
+    if (rdbx->index - *est > seq_num_median) {
+      *delta = 0;
+      return srtp_err_status_pkt_idx_old;
+    }
+#endif
+  }
+
+  return srtp_err_status_ok;
+}
+
+static srtp_err_status_t
+srtp_get_est_pkt_index(srtp_hdr_t *hdr,
+                       srtp_stream_ctx_t *stream,
+                       srtp_xtd_seq_num_t *est,
+                       int *delta)
+{
+  srtp_err_status_t result = srtp_err_status_ok;
+
+  if (stream->pending_roc) {
+    result = srtp_estimate_index(&stream->rtp_rdbx,
+                                 stream->pending_roc,
+                                 est,
+                                 ntohs(hdr->seq),
+                                 delta);
+  } else {
+    /* estimate packet index from seq. num. in header */
+    *delta = srtp_rdbx_estimate_index(&stream->rtp_rdbx,
+                                      est,
+                                      ntohs(hdr->seq));
+  }
+
+#ifdef NO_64BIT_MATH
+  debug_print2(mod_srtp, "estimated u_packet index: %08x%08x", high32(*est), low32(*est));
+#else
+  debug_print(mod_srtp, "estimated u_packet index: %016llx", *est);
+#endif
+  return result;
+}
 
 /*
@@ -904 +1663 @@
  * encrypted and authenticated.
  */
-static err_status_t
-srtp_protect_aead (srtp_ctx_t *ctx, srtp_stream_ctx_t *stream, 
-                   void *rtp_hdr, unsigned int *pkt_octet_len)
+static srtp_err_status_t
+srtp_protect_aead (srtp_ctx_t *ctx, srtp_stream_ctx_t *stream,
+                   void *rtp_hdr, unsigned int *pkt_octet_len,
+                   srtp_session_keys_t *session_keys, unsigned int use_mki)
 {
     srtp_hdr_t *hdr = (srtp_hdr_t*)rtp_hdr;
     uint32_t *enc_start;        /* pointer to start of encrypted portion  */
     int enc_octet_len = 0; /* number of octets in encrypted portion  */
-    xtd_seq_num_t est;          /* estimated xtd_seq_num_t of *hdr        */
+    srtp_xtd_seq_num_t est;          /* estimated xtd_seq_num_t of *hdr        */
     int delta;                  /* delta of local pkt idx and that in hdr */
-    err_status_t status;
-    int tag_len;
+    srtp_err_status_t status;
+    uint32_t tag_len;
     v128_t iv;
     unsigned int aad_len;
+    srtp_hdr_xtnd_t *xtn_hdr = NULL;
+    unsigned int mki_size = 0;
+    uint8_t *mki_location = NULL;
 
     debug_print(mod_srtp, "function srtp_protect_aead", NULL);
@@ -925 +1688 @@
      * the event handler if we hit either.
      */
-    switch (key_limit_update(stream->limit)) {
-    case key_event_normal:
+    switch (srtp_key_limit_update(session_keys->limit)) {
+    case srtp_key_event_normal:
         break;
-    case key_event_hard_limit:
+    case srtp_key_event_hard_limit:
         srtp_handle_event(ctx, stream, event_key_hard_limit);
-        return err_status_key_expired;
-    case key_event_soft_limit:
+        return srtp_err_status_key_expired;
+    case srtp_key_event_soft_limit:
     default:
         srtp_handle_event(ctx, stream, event_key_soft_limit);
@@ -938 +1701 @@
 
     /* get tag length from stream */
-    tag_len = auth_get_tag_length(stream->rtp_auth);
+    tag_len = srtp_auth_get_tag_length(session_keys->rtp_auth);
 
     /*
@@ -948 +1711 @@
      enc_start = (uint32_t*)hdr + uint32s_in_rtp_header + hdr->cc;
      if (hdr->x == 1) {
-         srtp_hdr_xtnd_t *xtn_hdr = (srtp_hdr_xtnd_t*)enc_start;
+         xtn_hdr = (srtp_hdr_xtnd_t*)enc_start;
          enc_start += (ntohs(xtn_hdr->length) + 1);
      }
+     /* note: the passed size is without the auth tag */
      if (!((uint8_t*)enc_start <= (uint8_t*)hdr + *pkt_octet_len))
-         return err_status_parse_err;
+         return srtp_err_status_parse_err;
      enc_octet_len = (int)(*pkt_octet_len -
                                     ((uint8_t*)enc_start - (uint8_t*)hdr));
-     if (enc_octet_len < 0) return err_status_parse_err;
+     if (enc_octet_len < 0) return srtp_err_status_parse_err;
 
     /*
@@ -961 +1725 @@
      * and the sequence number from the header
      */
-    delta = rdbx_estimate_index(&stream->rtp_rdbx, &est, ntohs(hdr->seq));
-    status = rdbx_check(&stream->rtp_rdbx, delta);
+    delta = srtp_rdbx_estimate_index(&stream->rtp_rdbx, &est, ntohs(hdr->seq));
+    status = srtp_rdbx_check(&stream->rtp_rdbx, delta);
     if (status) {
-        if (status != err_status_replay_fail || !stream->allow_repeat_tx) {
+        if (status != srtp_err_status_replay_fail || !stream->allow_repeat_tx) {
             return status;  /* we've been asked to reuse an index */
         }
     } else {
-        rdbx_add_index(&stream->rtp_rdbx, delta);
+        srtp_rdbx_add_index(&stream->rtp_rdbx, delta);
     }
 
@@ -981 +1745 @@
      * AEAD uses a new IV formation method
      */
-    srtp_calc_aead_iv(stream, &iv, &est, hdr);
-    status = cipher_set_iv(stream->rtp_cipher, &iv, direction_encrypt);
-    if (status) {
-        return err_status_cipher_fail;
-    }
-
+    srtp_calc_aead_iv(session_keys, &iv, &est, hdr);
     /* shift est, put into network byte order */
 #ifdef NO_64BIT_MATH
@@ -996 +1755 @@
 #endif
 
+    status = srtp_cipher_set_iv(session_keys->rtp_cipher,
+                                (uint8_t*)&iv, srtp_direction_encrypt);
+    if (!status && session_keys->rtp_xtn_hdr_cipher) {
+      iv.v32[0] = 0;
+      iv.v32[1] = hdr->ssrc;
+      iv.v64[1] = est;
+      status = srtp_cipher_set_iv(session_keys->rtp_xtn_hdr_cipher,
+                                  (uint8_t*)&iv, srtp_direction_encrypt);
+    }
+    if (status) {
+        return srtp_err_status_cipher_fail;
+    }
+
+    if (xtn_hdr && session_keys->rtp_xtn_hdr_cipher) {
+      /*
+       * extensions header encryption RFC 6904
+       */
+        status = srtp_process_header_encryption(stream, xtn_hdr, session_keys);
+      if (status) {
+        return status;
+      }
+    }
+
     /*
      * Set the AAD over the RTP header 
      */
     aad_len = (uint8_t *)enc_start - (uint8_t *)hdr;
-    status = cipher_set_aad(stream->rtp_cipher, (uint8_t*)hdr, aad_len);
+    status = srtp_cipher_set_aad(session_keys->rtp_cipher, (uint8_t*)hdr, aad_len);
     if (status) {
-        return ( err_status_cipher_fail);
+        return ( srtp_err_status_cipher_fail);
     }
 
     /* Encrypt the payload  */
-    status = cipher_encrypt(stream->rtp_cipher,
+    status = srtp_cipher_encrypt(session_keys->rtp_cipher,
                             (uint8_t*)enc_start, (unsigned int *)&enc_octet_len);
     if (status) {
-        return err_status_cipher_fail;
+        return srtp_err_status_cipher_fail;
     }
     /*
@@ -1015 +1797 @@
      * and append that to the output
      */
-    status = cipher_get_tag(stream->rtp_cipher, 
+    status = srtp_cipher_get_tag(session_keys->rtp_cipher, 
                             (uint8_t*)enc_start+enc_octet_len, &tag_len);
     if (status) {
-        return ( err_status_cipher_fail);
-    }
+        return ( srtp_err_status_cipher_fail);
+    }
+
+    mki_location = (uint8_t *)hdr + *pkt_octet_len + tag_len;
+    mki_size = srtp_inject_mki(mki_location, session_keys, use_mki);
 
     /* increase the packet length by the length of the auth tag */
     *pkt_octet_len += tag_len;
 
-    return err_status_ok;
+    /* increase the packet length by the length of the mki_size */
+    *pkt_octet_len += mki_size;
+
+    return srtp_err_status_ok;
 }
 
@@ -1035 +1823 @@
  * when decrypting the payload.
  */
-static err_status_t
+static srtp_err_status_t
 srtp_unprotect_aead (srtp_ctx_t *ctx, srtp_stream_ctx_t *stream, int delta, 
-                     xtd_seq_num_t est, void *srtp_hdr, unsigned int *pkt_octet_len)
+                     srtp_xtd_seq_num_t est, void *srtp_hdr, unsigned int *pkt_octet_len,
+                     srtp_session_keys_t *session_keys, unsigned int mki_size)
 {
     srtp_hdr_t *hdr = (srtp_hdr_t*)srtp_hdr;
@@ -1043 +1832 @@
     unsigned int enc_octet_len = 0; /* number of octets in encrypted portion */
     v128_t iv;
-    err_status_t status;
+    srtp_err_status_t status;
     int tag_len;
     unsigned int aad_len;
+    srtp_hdr_xtnd_t *xtn_hdr = NULL;
 
     debug_print(mod_srtp, "function srtp_unprotect_aead", NULL);
@@ -1056 +1846 @@
 
     /* get tag length from stream */
-    tag_len = auth_get_tag_length(stream->rtp_auth);
+    tag_len = srtp_auth_get_tag_length(session_keys->rtp_auth);
 
     /*
      * AEAD uses a new IV formation method 
      */
-    srtp_calc_aead_iv(stream, &iv, &est, hdr);
-    status = cipher_set_iv(stream->rtp_cipher, &iv, direction_decrypt);
+    srtp_calc_aead_iv(session_keys, &iv, &est, hdr);
+    status = srtp_cipher_set_iv(session_keys->rtp_cipher,
+                                (uint8_t*)&iv, srtp_direction_decrypt);
+    if (!status && session_keys->rtp_xtn_hdr_cipher) {
+      iv.v32[0] = 0;
+      iv.v32[1] = hdr->ssrc;
+#ifdef NO_64BIT_MATH
+      iv.v64[1] = be64_to_cpu(make64((high32(est) << 16) | (low32(est) >> 16),
+                  low32(est) << 16));
+#else
+      iv.v64[1] = be64_to_cpu(est << 16);
+#endif
+      status = srtp_cipher_set_iv(session_keys->rtp_xtn_hdr_cipher, (uint8_t*)&iv, srtp_direction_encrypt);
+    }
     if (status) {
-        return err_status_cipher_fail;
+        return srtp_err_status_cipher_fail;
     }
 
@@ -1075 +1877 @@
     enc_start = (uint32_t*)hdr + uint32s_in_rtp_header + hdr->cc;
     if (hdr->x == 1) {
-        srtp_hdr_xtnd_t *xtn_hdr = (srtp_hdr_xtnd_t*)enc_start;
+        xtn_hdr = (srtp_hdr_xtnd_t*)enc_start;
         enc_start += (ntohs(xtn_hdr->length) + 1);
     }
-    if (!((uint8_t*)enc_start <= (uint8_t*)hdr + (*pkt_octet_len - tag_len)))
-        return err_status_parse_err;
+    if (!((uint8_t*)enc_start <= (uint8_t*)hdr + (*pkt_octet_len - tag_len - mki_size)))
+        return srtp_err_status_parse_err;
     /*
      * We pass the tag down to the cipher when doing GCM mode 
      */
-    enc_octet_len = (unsigned int)(*pkt_octet_len - 
+    enc_octet_len = (unsigned int)(*pkt_octet_len - mki_size -
                                    ((uint8_t*)enc_start - (uint8_t*)hdr));
 
@@ -1092 +1894 @@
      */
     if (enc_octet_len < (unsigned int) tag_len) {
-        return err_status_cipher_fail;
+        return srtp_err_status_cipher_fail;
     }
 
@@ -1100 +1902 @@
      * the event handler if we hit either.
      */
-    switch (key_limit_update(stream->limit)) {
-    case key_event_normal:
+    switch (srtp_key_limit_update(session_keys->limit)) {
+    case srtp_key_event_normal:
         break;
-    case key_event_soft_limit:
+    case srtp_key_event_soft_limit:
         srtp_handle_event(ctx, stream, event_key_soft_limit);
         break;
-    case key_event_hard_limit:
+    case srtp_key_event_hard_limit:
         srtp_handle_event(ctx, stream, event_key_hard_limit);
-        return err_status_key_expired;
+        return srtp_err_status_key_expired;
     default:
         break;
@@ -1117 +1919 @@
      */
     aad_len = (uint8_t *)enc_start - (uint8_t *)hdr;
-    status = cipher_set_aad(stream->rtp_cipher, (uint8_t*)hdr, aad_len);
+    status = srtp_cipher_set_aad(session_keys->rtp_cipher, (uint8_t*)hdr, aad_len);
     if (status) {
-        return ( err_status_cipher_fail);
-    }
-
-    /* Decrypt the ciphertext.  This also checks the auth tag based 
+        return ( srtp_err_status_cipher_fail);
+    }
+
+    /* Decrypt the ciphertext.  This also checks the auth tag based
      * on the AAD we just specified above */
-    status = cipher_decrypt(stream->rtp_cipher,
-                            (uint8_t*)enc_start, &enc_octet_len);
+    status = srtp_cipher_decrypt(session_keys->rtp_cipher,
+                                 (uint8_t*)enc_start, &enc_octet_len);
     if (status) {
         return status;
+    }
+
+    if (xtn_hdr && session_keys->rtp_xtn_hdr_cipher) {
+      /*
+       * extensions header encryption RFC 6904
+       */
+      status = srtp_process_header_encryption(stream, xtn_hdr, session_keys);
+      if (status) {
+        return status;
+      }
     }
 
@@ -1180 +1992 @@
      * index into the replay database
      */
-    rdbx_add_index(&stream->rtp_rdbx, delta);
+    srtp_rdbx_add_index(&stream->rtp_rdbx, delta);
 
     /* decrease the packet length by the length of the auth tag */
     *pkt_octet_len -= tag_len;
 
-    return err_status_ok;
-}
-
-
-
-
- err_status_t
+    /* decrease the packet length by the length of the mki_size */
+    *pkt_octet_len -= mki_size;
+
+    return srtp_err_status_ok;
+}
+
+
+ srtp_err_status_t
  srtp_protect(srtp_ctx_t *ctx, void *rtp_hdr, int *pkt_octet_len) {
+   return srtp_protect_mki(ctx, rtp_hdr, pkt_octet_len, 0, 0);
+ }
+
+srtp_err_status_t
+srtp_protect_mki(srtp_ctx_t *ctx, void *rtp_hdr, int *pkt_octet_len,
+                 unsigned int use_mki, unsigned int mki_index ) {
    srtp_hdr_t *hdr = (srtp_hdr_t *)rtp_hdr;
    uint32_t *enc_start;        /* pointer to start of encrypted portion  */
    uint32_t *auth_start;       /* pointer to start of auth. portion      */
    int enc_octet_len = 0; /* number of octets in encrypted portion  */
-   xtd_seq_num_t est;          /* estimated xtd_seq_num_t of *hdr        */
+   srtp_xtd_seq_num_t est;          /* estimated xtd_seq_num_t of *hdr        */
    int delta;                  /* delta of local pkt idx and that in hdr */
    uint8_t *auth_tag = NULL;   /* location of auth_tag within packet     */
-   err_status_t status;   
+   srtp_err_status_t status;   
    int tag_len;
    srtp_stream_ctx_t *stream;
-   int prefix_len;
+   uint32_t prefix_len;
+   srtp_hdr_xtnd_t *xtn_hdr = NULL;
+   unsigned int mki_size = 0;
+   srtp_session_keys_t *session_keys = NULL;
+   uint8_t* mki_location = NULL;
+   int advance_packet_index = 0;
 
    debug_print(mod_srtp, "function srtp_protect", NULL);
@@ -1216 +2040 @@
    /* check the packet length - it must at least contain a full header */
    if (*pkt_octet_len < octets_in_rtp_header)
-     return err_status_bad_param;
+     return srtp_err_status_bad_param;
 
    /*
@@ -1247 +2071 @@
      } else {
        /* no template stream, so we return an error */
-       return err_status_no_ctx;
+       return srtp_err_status_no_ctx;
      } 
    }
@@ -1257 +2081 @@
     * those functions.
     */
+
   if (stream->direction != dir_srtp_sender) {
      if (stream->direction == dir_unknown) {
@@ -1265 +2090 @@
   }
 
+  session_keys = srtp_get_session_keys_with_mki_index(stream, use_mki, mki_index);
+
    /*
     * Check if this is an AEAD stream (GCM mode).  If so, then dispatch
     * the request to our AEAD handler.
     */
-  if (stream->rtp_cipher->algorithm == AES_128_GCM ||
-      stream->rtp_cipher->algorithm == AES_256_GCM) {
-      return srtp_protect_aead(ctx, stream, rtp_hdr, (unsigned int*)pkt_octet_len);
+  if (session_keys->rtp_cipher->algorithm == SRTP_AES_GCM_128 ||
+      session_keys->rtp_cipher->algorithm == SRTP_AES_GCM_256) {
+      return srtp_protect_aead(ctx, stream, rtp_hdr,
+                               (unsigned int*)pkt_octet_len, session_keys,
+                               use_mki);
   }
 
@@ -1279 +2108 @@
    * the event handler if we hit either.
    */
-  switch(key_limit_update(stream->limit)) {
-  case key_event_normal:
+  switch(srtp_key_limit_update(session_keys->limit)) {
+  case srtp_key_event_normal:
     break;
-  case key_event_soft_limit: 
+  case srtp_key_event_soft_limit: 
     srtp_handle_event(ctx, stream, event_key_soft_limit);
     break; 
-  case key_event_hard_limit:
+  case srtp_key_event_hard_limit:
     srtp_handle_event(ctx, stream, event_key_hard_limit);
-        return err_status_key_expired;
+        return srtp_err_status_key_expired;
   default:
     break;
@@ -1293 +2122 @@
 
    /* get tag length from stream */
-   tag_len = auth_get_tag_length(stream->rtp_auth); 
+   tag_len = srtp_auth_get_tag_length(session_keys->rtp_auth); 
 
    /*
@@ -1306 +2135 @@
      enc_start = (uint32_t *)hdr + uint32s_in_rtp_header + hdr->cc;  
      if (hdr->x == 1) {
-       srtp_hdr_xtnd_t *xtn_hdr = (srtp_hdr_xtnd_t *)enc_start;
+       xtn_hdr = (srtp_hdr_xtnd_t *)enc_start;
        enc_start += (ntohs(xtn_hdr->length) + 1);
      }
+     /* note: the passed size is without the auth tag */
      if (!((uint8_t*)enc_start <= (uint8_t*)hdr + *pkt_octet_len))
-       return err_status_parse_err;
+       return srtp_err_status_parse_err;
      enc_octet_len = (int)(*pkt_octet_len -
                                     ((uint8_t*)enc_start - (uint8_t*)hdr));
-     if (enc_octet_len < 0) return err_status_parse_err;
+     if (enc_octet_len < 0) return srtp_err_status_parse_err;
    } else {
      enc_start = NULL;
    }
+
+   mki_location = (uint8_t *)hdr + *pkt_octet_len;
+   mki_size = srtp_inject_mki(mki_location, session_keys, use_mki);
 
    /* 
@@ -1325 +2158 @@
    if (stream->rtp_services & sec_serv_auth) {
      auth_start = (uint32_t *)hdr;
-     auth_tag = (uint8_t *)hdr + *pkt_octet_len;
+     auth_tag = (uint8_t *)hdr + *pkt_octet_len + mki_size;
    } else {
      auth_start = NULL;
@@ -1331 +2164 @@
    }
 
-   /*
-    * estimate the packet index using the start of the replay window   
-    * and the sequence number from the header
-    */
-   delta = rdbx_estimate_index(&stream->rtp_rdbx, &est, ntohs(hdr->seq));
-   status = rdbx_check(&stream->rtp_rdbx, delta);
-   if (status) {
-     if (status != err_status_replay_fail || !stream->allow_repeat_tx)
-       return status;  /* we've been asked to reuse an index */
-   }
-   else
-     rdbx_add_index(&stream->rtp_rdbx, delta);
+  /*
+   * estimate the packet index using the start of the replay window
+   * and the sequence number from the header
+   */
+  status = srtp_get_est_pkt_index(hdr,
+                                  stream,
+                                  &est,
+                                  &delta);
+
+  if (status && (status != srtp_err_status_pkt_idx_adv))
+    return status;
+
+  if (status == srtp_err_status_pkt_idx_adv)
+    advance_packet_index = 1;
+
+  if (advance_packet_index) {
+    srtp_rdbx_set_roc_seq(&stream->rtp_rdbx,
+                          (uint32_t)(est >> 16),
+                          (uint16_t)(est & 0xFFFF));
+    stream->pending_roc = 0;
+    srtp_rdbx_add_index(&stream->rtp_rdbx, 0);
+  } else {
+    status = srtp_rdbx_check(&stream->rtp_rdbx, delta);
+    if (status) {
+      if (status != srtp_err_status_replay_fail || !stream->allow_repeat_tx)
+        return status; /* we've been asked to reuse an index */
+    }
+    srtp_rdbx_add_index(&stream->rtp_rdbx, delta);
+  }
 
 #ifdef NO_64BIT_MATH
@@ -1354 +2204 @@
     * if we're using rindael counter mode, set nonce and seq 
     */
-   if (stream->rtp_cipher->type->id == AES_ICM ||
-       stream->rtp_cipher->type->id == AES_256_ICM) {
+   if (session_keys->rtp_cipher->type->id == SRTP_AES_ICM_128 ||
+       session_keys->rtp_cipher->type->id == SRTP_AES_ICM_192 ||
+       session_keys->rtp_cipher->type->id == SRTP_AES_ICM_256) {
      v128_t iv;
 
@@ -1366 +2217 @@
      iv.v64[1] = be64_to_cpu(est << 16);
 #endif
-     status = cipher_set_iv(stream->rtp_cipher, &iv, direction_encrypt);
-
+     status = srtp_cipher_set_iv(session_keys->rtp_cipher, (uint8_t*)&iv, srtp_direction_encrypt);
+     if (!status && session_keys->rtp_xtn_hdr_cipher) {
+       status = srtp_cipher_set_iv(session_keys->rtp_xtn_hdr_cipher, (uint8_t*)&iv, srtp_direction_encrypt);
+     }
    } else {  
      v128_t iv;
@@ -1379 +2232 @@
 #endif
      iv.v64[1] = be64_to_cpu(est);
-     status = cipher_set_iv(stream->rtp_cipher, &iv, direction_encrypt);
+     status = srtp_cipher_set_iv(session_keys->rtp_cipher, (uint8_t*)&iv, srtp_direction_encrypt);
+     if (!status && session_keys->rtp_xtn_hdr_cipher) {
+       status = srtp_cipher_set_iv(session_keys->rtp_xtn_hdr_cipher, (uint8_t*)&iv, srtp_direction_encrypt);
+     }
    }
    if (status)
-     return err_status_cipher_fail;
+     return srtp_err_status_cipher_fail;
 
    /* shift est, put into network byte order */
@@ -1399 +2255 @@
    if (auth_start) {
      
-    prefix_len = auth_get_prefix_length(stream->rtp_auth);    
+    prefix_len = srtp_auth_get_prefix_length(session_keys->rtp_auth);    
     if (prefix_len) {
-      status = cipher_output(stream->rtp_cipher, auth_tag, prefix_len);
+      status = srtp_cipher_output(session_keys->rtp_cipher, auth_tag, &prefix_len);
       if (status)
-        return err_status_cipher_fail;
+        return srtp_err_status_cipher_fail;
       debug_print(mod_srtp, "keystream prefix: %s", 
-                  octet_string_hex_string(auth_tag, prefix_len));
+                  srtp_octet_string_hex_string(auth_tag, prefix_len));
+    }
+  }
+
+  if (xtn_hdr && session_keys->rtp_xtn_hdr_cipher) {
+    /*
+     * extensions header encryption RFC 6904
+     */
+      status = srtp_process_header_encryption(stream, xtn_hdr, session_keys);
+    if (status) {
+      return status;
     }
   }
@@ -1411 +2277 @@
   /* if we're encrypting, exor keystream into the message */
   if (enc_start) {
-    status = cipher_encrypt(stream->rtp_cipher, 
-                            (uint8_t *)enc_start, (unsigned int*)&enc_octet_len);
+    status = srtp_cipher_encrypt(session_keys->rtp_cipher, 
+                                (uint8_t *)enc_start, (unsigned int *)&enc_octet_len);
     if (status)
-      return err_status_cipher_fail;
+      return srtp_err_status_cipher_fail;
   }
 
@@ -1424 +2290 @@
 
     /* initialize auth func context */
-    status = auth_start(stream->rtp_auth);
+    status = srtp_auth_start(session_keys->rtp_auth);
     if (status) return status;
 
     /* run auth func over packet */
-    status = auth_update(stream->rtp_auth, 
+    status = srtp_auth_update(session_keys->rtp_auth,
                          (uint8_t *)auth_start, *pkt_octet_len);
     if (status) return status;
@@ -1434 +2300 @@
     /* run auth func over ROC, put result into auth_tag */
     debug_print(mod_srtp, "estimated packet index: %016llx", est);
-    status = auth_compute(stream->rtp_auth, (uint8_t *)&est, 4, auth_tag); 
+    status = srtp_auth_compute(session_keys->rtp_auth, (uint8_t *)&est, 4, auth_tag);
     debug_print(mod_srtp, "srtp auth tag:    %s", 
-                octet_string_hex_string(auth_tag, tag_len));
+                srtp_octet_string_hex_string(auth_tag, tag_len));
     if (status)
-      return err_status_auth_fail;   
+      return srtp_err_status_auth_fail;   
 
   }
@@ -1448 +2314 @@
   }
 
-  return err_status_ok;  
-}
-
-
-err_status_t
+  if (use_mki) {
+    /* increate the packet length by the mki size */
+    *pkt_octet_len += mki_size;
+  }
+
+  return srtp_err_status_ok;  
+}
+
+
+srtp_err_status_t
 srtp_unprotect(srtp_ctx_t *ctx, void *srtp_hdr, int *pkt_octet_len) {
+    return srtp_unprotect_mki(ctx, srtp_hdr, pkt_octet_len, 0);
+}
+
+srtp_err_status_t
+srtp_unprotect_mki(srtp_ctx_t *ctx, void *srtp_hdr, int *pkt_octet_len,
+                   unsigned int use_mki) {
   srtp_hdr_t *hdr = (srtp_hdr_t *)srtp_hdr;
   uint32_t *enc_start;      /* pointer to start of encrypted portion  */
@@ -1459 +2336 @@
   unsigned int enc_octet_len = 0;/* number of octets in encrypted portion */
   uint8_t *auth_tag = NULL; /* location of auth_tag within packet     */
-  xtd_seq_num_t est;        /* estimated xtd_seq_num_t of *hdr        */
+  srtp_xtd_seq_num_t est;        /* estimated xtd_seq_num_t of *hdr        */
   int delta;                /* delta of local pkt idx and that in hdr */
   v128_t iv;
-  err_status_t status;
+  srtp_err_status_t status;
   srtp_stream_ctx_t *stream;
   uint8_t tmp_tag[SRTP_MAX_TAG_LEN];
-  int tag_len, prefix_len;
+  uint32_t tag_len, prefix_len;
+  srtp_hdr_xtnd_t *xtn_hdr = NULL;
+  unsigned int mki_size = 0;
+  srtp_session_keys_t *session_keys = NULL;
+  int advance_packet_index = 0;
+  uint32_t roc_to_set = 0;
+  uint16_t seq_to_set = 0;
 
   debug_print(mod_srtp, "function srtp_unprotect", NULL);
@@ -1478 +2361 @@
   /* check the packet length - it must at least contain a full header */
   if (*pkt_octet_len < octets_in_rtp_header)
-    return err_status_bad_param;
+    return srtp_err_status_bad_param;
 
   /*
@@ -1492 +2375 @@
       stream = ctx->stream_template;
       debug_print(mod_srtp, "using provisional stream (SSRC: 0x%08x)",
-                  hdr->ssrc);
+                  ntohl(hdr->ssrc));
       
       /* 
@@ -1499 +2382 @@
        */
 #ifdef NO_64BIT_MATH
-      est = (xtd_seq_num_t) make64(0,ntohs(hdr->seq));
+      est = (srtp_xtd_seq_num_t) make64(0,ntohs(hdr->seq));
       delta = low32(est);
 #else
-      est = (xtd_seq_num_t) ntohs(hdr->seq);
+      est = (srtp_xtd_seq_num_t) ntohs(hdr->seq);
       delta = (int)est;
 #endif
@@ -1511 +2394 @@
        * key-sharing, so return an error
        */
-      return err_status_no_ctx;
+      return srtp_err_status_no_ctx;
     }
   } else {
-  
-    /* estimate packet index from seq. num. in header */
-    delta = rdbx_estimate_index(&stream->rtp_rdbx, &est, ntohs(hdr->seq));
-    
+    status = srtp_get_est_pkt_index(hdr,
+                                    stream,
+                                    &est,
+                                    &delta);
+
+    if (status && (status != srtp_err_status_pkt_idx_adv))
+      return status;
+
+    if (status == srtp_err_status_pkt_idx_adv) {
+      advance_packet_index = 1;
+      roc_to_set = (uint32_t)(est >> 16);
+      seq_to_set = (uint16_t)(est & 0xFFFF);
+    }
+
     /* check replay database */
-    status = rdbx_check(&stream->rtp_rdbx, delta);
-    if (status)
-      return status;
+    if (!advance_packet_index) {
+      status = srtp_rdbx_check(&stream->rtp_rdbx, delta);
+      if (status)
+        return status;
+    }
   }
 
@@ -1531 +2426 @@
 
   /*
+   * Determine if MKI is being used and what session keys should be used
+   */
+  if (use_mki) {
+      session_keys = srtp_get_session_keys(stream, (uint8_t *)hdr,
+                                           (const unsigned int*)pkt_octet_len,
+                                           &mki_size);
+
+      if (session_keys == NULL) 
+         return srtp_err_status_bad_mki;
+  } else {
+      session_keys = &stream->session_keys[0];
+  }
+
+  /*
    * Check if this is an AEAD stream (GCM mode).  If so, then dispatch
    * the request to our AEAD handler.
    */
-  if (stream->rtp_cipher->algorithm == AES_128_GCM ||
-      stream->rtp_cipher->algorithm == AES_256_GCM) {
-      return srtp_unprotect_aead(ctx, stream, delta, est, srtp_hdr, (unsigned int*)pkt_octet_len);
+  if (session_keys->rtp_cipher->algorithm == SRTP_AES_GCM_128 ||
+      session_keys->rtp_cipher->algorithm == SRTP_AES_GCM_256) {
+      return srtp_unprotect_aead(ctx, stream, delta, est, srtp_hdr,
+                                 (unsigned int*)pkt_octet_len, session_keys,
+                                 mki_size);
   }
 
   /* get tag length from stream */
-  tag_len = auth_get_tag_length(stream->rtp_auth); 
+  tag_len = srtp_auth_get_tag_length(session_keys->rtp_auth); 
 
   /* 
@@ -1546 +2457 @@
    * happen to be using
    */
-  if (stream->rtp_cipher->type->id == AES_ICM ||
-      stream->rtp_cipher->type->id == AES_256_ICM) {
-
+  if (session_keys->rtp_cipher->type->id == SRTP_AES_ICM_128 ||
+      session_keys->rtp_cipher->type->id == SRTP_AES_ICM_192 ||
+      session_keys->rtp_cipher->type->id == SRTP_AES_ICM_256) {
     /* aes counter mode */
     iv.v32[0] = 0;
@@ -1558 +2469 @@
     iv.v64[1] = be64_to_cpu(est << 16);
 #endif
-    status = cipher_set_iv(stream->rtp_cipher, &iv, direction_decrypt);
+    status = srtp_cipher_set_iv(session_keys->rtp_cipher,
+                                (uint8_t*)&iv, srtp_direction_decrypt);
+    if (!status && session_keys->rtp_xtn_hdr_cipher) {
+      status = srtp_cipher_set_iv(session_keys->rtp_xtn_hdr_cipher,
+                                  (uint8_t*)&iv, srtp_direction_decrypt);
+    }
   } else {  
     
@@ -1569 +2485 @@
 #endif
     iv.v64[1] = be64_to_cpu(est);
-    status = cipher_set_iv(stream->rtp_cipher, &iv, direction_decrypt);
+    status = srtp_cipher_set_iv(session_keys->rtp_cipher, (uint8_t*)&iv, srtp_direction_decrypt);
+    if (!status && session_keys->rtp_xtn_hdr_cipher) {
+      status = srtp_cipher_set_iv(session_keys->rtp_xtn_hdr_cipher, (uint8_t*)&iv, srtp_direction_decrypt);
+    }
   }
   if (status)
-    return err_status_cipher_fail;
+    return srtp_err_status_cipher_fail;
 
   /* shift est, put into network byte order */
@@ -1594 +2513 @@
     enc_start = (uint32_t *)hdr + uint32s_in_rtp_header + hdr->cc;  
     if (hdr->x == 1) {
-      srtp_hdr_xtnd_t *xtn_hdr = (srtp_hdr_xtnd_t *)enc_start;
+      xtn_hdr = (srtp_hdr_xtnd_t *)enc_start;
       enc_start += (ntohs(xtn_hdr->length) + 1);
     }  
-    if (!((uint8_t*)enc_start <= (uint8_t*)hdr + (*pkt_octet_len - tag_len)))
-      return err_status_parse_err;
-    enc_octet_len = (uint32_t)(*pkt_octet_len - tag_len -
+    if (!((uint8_t*)enc_start <= (uint8_t*)hdr + (*pkt_octet_len - tag_len - mki_size)))
+      return srtp_err_status_parse_err;
+    enc_octet_len = (uint32_t)(*pkt_octet_len - tag_len - mki_size -
                                ((uint8_t*)enc_start - (uint8_t*)hdr));
   } else {
@@ -1631 +2550 @@
      * the authenticator isn't using a universal hash function
      */  
-    if (stream->rtp_auth->prefix_len != 0) {
+    if (session_keys->rtp_auth->prefix_len != 0) {
       
-      prefix_len = auth_get_prefix_length(stream->rtp_auth);    
-      status = cipher_output(stream->rtp_cipher, tmp_tag, prefix_len);
+      prefix_len = srtp_auth_get_prefix_length(session_keys->rtp_auth);    
+      status = srtp_cipher_output(session_keys->rtp_cipher, tmp_tag, &prefix_len);
       debug_print(mod_srtp, "keystream prefix: %s", 
-                  octet_string_hex_string(tmp_tag, prefix_len));
+                  srtp_octet_string_hex_string(tmp_tag, prefix_len));
       if (status)
-        return err_status_cipher_fail;
+        return srtp_err_status_cipher_fail;
     } 
 
     /* initialize auth func context */
-    status = auth_start(stream->rtp_auth);
+    status = srtp_auth_start(session_keys->rtp_auth);
     if (status) return status;
  
     /* now compute auth function over packet */
-    status = auth_update(stream->rtp_auth, (uint8_t *)auth_start,  
-                         *pkt_octet_len - tag_len);
+    status = srtp_auth_update(session_keys->rtp_auth, (uint8_t *)auth_start,
+                         *pkt_octet_len - tag_len - mki_size);
 
     /* run auth func over ROC, then write tmp tag */
-    status = auth_compute(stream->rtp_auth, (uint8_t *)&est, 4, tmp_tag);  
+    status = srtp_auth_compute(session_keys->rtp_auth, (uint8_t *)&est, 4, tmp_tag);
 
     debug_print(mod_srtp, "computed auth tag:    %s", 
-                octet_string_hex_string(tmp_tag, tag_len));
+                srtp_octet_string_hex_string(tmp_tag, tag_len));
     debug_print(mod_srtp, "packet auth tag:      %s", 
-                octet_string_hex_string(auth_tag, tag_len));
+                srtp_octet_string_hex_string(auth_tag, tag_len));
     if (status)
-      return err_status_auth_fail;   
+      return srtp_err_status_auth_fail;   
 
     if (octet_string_is_eq(tmp_tag, auth_tag, tag_len))
-      return err_status_auth_fail;
+      return srtp_err_status_auth_fail;
   }
 
@@ -1668 +2587 @@
    * the event handler if we hit either.
    */
-  switch(key_limit_update(stream->limit)) {
-  case key_event_normal:
+  switch(srtp_key_limit_update(session_keys->limit)) {
+  case srtp_key_event_normal:
     break;
-  case key_event_soft_limit: 
+  case srtp_key_event_soft_limit: 
     srtp_handle_event(ctx, stream, event_key_soft_limit);
     break; 
-  case key_event_hard_limit:
+  case srtp_key_event_hard_limit:
     srtp_handle_event(ctx, stream, event_key_hard_limit);
-    return err_status_key_expired;
+    return srtp_err_status_key_expired;
   default:
     break;
   }
 
+  if (xtn_hdr && session_keys->rtp_xtn_hdr_cipher) {
+    /*
+     * extensions header encryption RFC 6904
+     */
+      status = srtp_process_header_encryption(stream, xtn_hdr, session_keys);
+    if (status) {
+      return status;
+    }
+  }
+
   /* if we're decrypting, add keystream into ciphertext */
   if (enc_start) {
-    status = cipher_decrypt(stream->rtp_cipher, 
-                            (uint8_t *)enc_start, &enc_octet_len);
+    status = srtp_cipher_decrypt(session_keys->rtp_cipher,
+                                 (uint8_t *)enc_start, &enc_octet_len);
     if (status)
-      return err_status_cipher_fail;
+      return srtp_err_status_cipher_fail;
   }
 
@@ -1733 +2662 @@
     stream = new_stream;
   }
-  
+
   /* 
    * the message authentication function passed, so add the packet
    * index into the replay database 
    */
-  rdbx_add_index(&stream->rtp_rdbx, delta);
+  if (advance_packet_index) {
+    srtp_rdbx_set_roc_seq(&stream->rtp_rdbx,
+                           roc_to_set,
+                           seq_to_set);
+    stream->pending_roc = 0;
+    srtp_rdbx_add_index(&stream->rtp_rdbx, 0);
+  } else {
+    srtp_rdbx_add_index(&stream->rtp_rdbx, delta);
+  }
 
   /* decrease the packet length by the length of the auth tag */
   *pkt_octet_len -= tag_len;
 
-  return err_status_ok;  
-}
-
-err_status_t
+  /* decrease the packet length by the mki size */
+  *pkt_octet_len -= mki_size;
+
+  return srtp_err_status_ok;  
+}
+
+srtp_err_status_t
 srtp_init() {
-  err_status_t status;
+  srtp_err_status_t status;
 
   /* initialize crypto kernel */
-  status = crypto_kernel_init();
+  status = srtp_crypto_kernel_init();
   if (status) 
     return status;
 
   /* load srtp debug module into the kernel */
-  status = crypto_kernel_load_debug_module(&mod_srtp);
+  status = srtp_crypto_kernel_load_debug_module(&mod_srtp);
   if (status)
     return status;
 
-  return err_status_ok;
-}
-
-err_status_t
+  return srtp_err_status_ok;
+}
+
+srtp_err_status_t
 srtp_shutdown() {
-  err_status_t status;
+  srtp_err_status_t status;
 
   /* shut down crypto kernel */
-  status = crypto_kernel_shutdown();
+  status = srtp_crypto_kernel_shutdown();
   if (status) 
     return status;
@@ -1774 +2714 @@
   /* shutting down crypto kernel frees the srtp debug module as well */
 
-  return err_status_ok;
+  return srtp_err_status_ok;
 }
 
@@ -1792 +2732 @@
 int
 srtp_get_trailer_length(const srtp_stream_t s) {
-  return auth_get_tag_length(s->rtp_auth);
+  return srtp_auth_get_tag_length(s->rtp_auth);
 }
 
@@ -1820 +2760 @@
 }
 
-err_status_t
+srtp_err_status_t
 srtp_dealloc(srtp_t session) {
   srtp_stream_ctx_t *stream;
-  err_status_t status;
+  srtp_err_status_t status;
 
   /*
@@ -1835 +2775 @@
   while (stream != NULL) {
     srtp_stream_t next = stream->next;
-    status = srtp_stream_dealloc(session, stream);
+    status = srtp_stream_dealloc(stream, session->stream_template);
     if (status)
       return status;
@@ -1843 +2783 @@
   /* deallocate stream template, if there is one */
   if (session->stream_template != NULL) {
-    status = auth_dealloc(session->stream_template->rtcp_auth); 
-    if (status) 
-      return status; 
-    status = cipher_dealloc(session->stream_template->rtcp_cipher); 
-    if (status) 
-      return status; 
-    crypto_free(session->stream_template->limit);
-    status = cipher_dealloc(session->stream_template->rtp_cipher); 
-    if (status) 
-      return status; 
-    status = auth_dealloc(session->stream_template->rtp_auth);
+    status = srtp_stream_dealloc(session->stream_template, NULL);
     if (status)
       return status;
-    status = rdbx_dealloc(&session->stream_template->rtp_rdbx);
-    if (status)
-      return status;
-    crypto_free(session->stream_template);
   }
 
   /* deallocate session context */
-  crypto_free(session);
-
-  return err_status_ok;
-}
-
-
-err_status_t
+  srtp_crypto_free(session);
+
+  return srtp_err_status_ok;
+}
+
+
+srtp_err_status_t
 srtp_add_stream(srtp_t session, 
                 const srtp_policy_t *policy)  {
-  err_status_t status;
+  srtp_err_status_t status;
   srtp_stream_t tmp;
 
   /* sanity check arguments */
-  if ((session == NULL) || (policy == NULL) || (policy->key == NULL))
-    return err_status_bad_param;
+  if ((session == NULL) || (policy == NULL) || (!srtp_validate_policy_master_keys(policy)))
+    return srtp_err_status_bad_param;
 
   /* allocate stream  */
@@ -1888 +2814 @@
   status = srtp_stream_init(tmp, policy);
   if (status) {
-    crypto_free(tmp);
+    srtp_crypto_free(tmp);
     return status;
   }
@@ -1903 +2829 @@
   case (ssrc_any_outbound):
     if (session->stream_template) {
-      return err_status_bad_param;
+      return srtp_err_status_bad_param;
     }
     session->stream_template = tmp;
@@ -1910 +2836 @@
   case (ssrc_any_inbound):
     if (session->stream_template) {
-      return err_status_bad_param;
+      return srtp_err_status_bad_param;
     }
     session->stream_template = tmp;
@@ -1921 +2847 @@
   case (ssrc_undefined):
   default:
-    crypto_free(tmp);
-    return err_status_bad_param;
+    srtp_crypto_free(tmp);
+    return srtp_err_status_bad_param;
   }
     
-  return err_status_ok;
-}
-
-
-err_status_t
+  return srtp_err_status_ok;
+}
+
+
+srtp_err_status_t
 srtp_create(srtp_t *session,               /* handle for session     */ 
             const srtp_policy_t *policy) { /* SRTP policy (list)     */
-  err_status_t stat;
+  srtp_err_status_t stat;
   srtp_ctx_t *ctx;
 
   /* sanity check arguments */
   if (session == NULL)
-    return err_status_bad_param;
+    return srtp_err_status_bad_param;
 
   /* allocate srtp context and set ctx_ptr */
-  ctx = (srtp_ctx_t *) crypto_alloc(sizeof(srtp_ctx_t));
+  ctx = (srtp_ctx_t *) srtp_crypto_alloc(sizeof(srtp_ctx_t));
   if (ctx == NULL)
-    return err_status_alloc_fail;
+    return srtp_err_status_alloc_fail;
   *session = ctx;
 
@@ -1958 +2884 @@
       /* clean up everything */
       srtp_dealloc(*session);
+      *session = NULL;
       return stat;
     }    
@@ -1965 +2892 @@
   }
 
-  return err_status_ok;
-}
-
-
-err_status_t
+  return srtp_err_status_ok;
+}
+
+
+srtp_err_status_t
 srtp_remove_stream(srtp_t session, uint32_t ssrc) {
   srtp_stream_ctx_t *stream, *last_stream;
-  err_status_t status;
+  srtp_err_status_t status;
 
   /* sanity check arguments */
   if (session == NULL)
-    return err_status_bad_param;
+    return srtp_err_status_bad_param;
   
   /* find stream in list; complain if not found */
@@ -1985 +2912 @@
   }
   if (stream == NULL)
-    return err_status_no_ctx;
+    return srtp_err_status_no_ctx;
 
   /* remove stream from the list */
@@ -1995 +2922 @@
 
   /* deallocate the stream */
-  status = srtp_stream_dealloc(session, stream);
+  status = srtp_stream_dealloc(stream, session->stream_template);
   if (status)
     return status;
 
-  return err_status_ok;
+  return srtp_err_status_ok;
+}
+
+
+srtp_err_status_t
+srtp_update(srtp_t session, const srtp_policy_t *policy) {
+  srtp_err_status_t stat;
+
+  /* sanity check arguments */
+  if ((session == NULL) || (policy == NULL) || (!srtp_validate_policy_master_keys(policy))) {
+    return srtp_err_status_bad_param;
+  }
+
+  while (policy != NULL) {
+    stat = srtp_update_stream(session, policy);
+    if (stat) {
+      return stat;
+    }
+
+    /* set policy to next item in list  */
+    policy = policy->next;
+  }
+  return srtp_err_status_ok;
+}
+
+
+static srtp_err_status_t
+update_template_streams(srtp_t session, const srtp_policy_t *policy) {
+  srtp_err_status_t status;
+  srtp_stream_t new_stream_template;
+  srtp_stream_t new_stream_list = NULL;
+
+  if (session->stream_template == NULL) {
+    return srtp_err_status_bad_param;
+  }
+
+  /* allocate new template stream  */
+  status = srtp_stream_alloc(&new_stream_template, policy);
+  if (status) {
+    return status;
+  }
+
+  /* initialize new template stream  */
+  status = srtp_stream_init(new_stream_template, policy);
+  if (status) {
+    srtp_crypto_free(new_stream_template);
+    return status;
+  }
+
+  /* for all old templated streams */
+  for (;;) {
+    srtp_stream_t stream;
+    uint32_t ssrc;
+    srtp_xtd_seq_num_t old_index;
+    srtp_rdb_t old_rtcp_rdb;
+
+    stream = session->stream_list;
+    while ((stream != NULL) &&
+           (stream->session_keys[0].rtp_auth !=
+            session->stream_template->session_keys[0].rtp_auth)) {
+      stream = stream->next;
+    }
+    if (stream == NULL) {
+      /* no more templated streams */
+      break;
+    }
+
+    /* save old extendard seq */
+    ssrc = stream->ssrc;
+    old_index = stream->rtp_rdbx.index;
+    old_rtcp_rdb = stream->rtcp_rdb;
+
+    /* remove stream */
+    status = srtp_remove_stream(session, ssrc);
+    if (status) {
+      /* free new allocations */
+      while (new_stream_list != NULL) {
+        srtp_stream_t next = new_stream_list->next;
+        srtp_stream_dealloc(new_stream_list, new_stream_template);
+        new_stream_list = next;
+      }
+      srtp_stream_dealloc(new_stream_template, NULL);
+      return status;
+    }
+
+    /* allocate and initialize a new stream */
+    status = srtp_stream_clone(new_stream_template, ssrc, &stream);
+    if (status) {
+      /* free new allocations */
+      while (new_stream_list != NULL) {
+        srtp_stream_t next = new_stream_list->next;
+        srtp_stream_dealloc(new_stream_list, new_stream_template);
+        new_stream_list = next;
+      }
+      srtp_stream_dealloc(new_stream_template, NULL);
+      return status;
+    }
+
+    /* add new stream to the head of the new_stream_list */
+    stream->next = new_stream_list;
+    new_stream_list = stream;
+
+    /* restore old extended seq */
+    stream->rtp_rdbx.index = old_index;
+    stream->rtcp_rdb = old_rtcp_rdb;
+  }
+  /* dealloc old template */
+  srtp_stream_dealloc(session->stream_template, NULL);
+  /* set new template */
+  session->stream_template = new_stream_template;
+  /* add new list */
+  if (new_stream_list) {
+    srtp_stream_t tail = new_stream_list;
+    while (tail->next) {
+      tail = tail->next;
+    }
+    tail->next = session->stream_list;
+    session->stream_list = new_stream_list;
+  }
+  return status;
+}
+
+
+static srtp_err_status_t
+update_stream(srtp_t session, const srtp_policy_t *policy) {
+  srtp_err_status_t status;
+  srtp_xtd_seq_num_t old_index;
+  srtp_rdb_t old_rtcp_rdb;
+  srtp_stream_t stream;
+
+  stream = srtp_get_stream(session, htonl(policy->ssrc.value));
+  if (stream == NULL) {
+    return srtp_err_status_bad_param;
+  }
+
+  /* save old extendard seq */
+  old_index = stream->rtp_rdbx.index;
+  old_rtcp_rdb = stream->rtcp_rdb;
+
+  status = srtp_remove_stream(session, htonl(policy->ssrc.value));
+  if (status) {
+    return status;
+  }
+
+  status = srtp_add_stream(session, policy);
+  if (status) {
+    return status;
+  }
+
+  stream = srtp_get_stream(session, htonl(policy->ssrc.value));
+  if (stream == NULL) {
+    return srtp_err_status_fail;
+  }
+
+  /* restore old extended seq */
+  stream->rtp_rdbx.index = old_index;
+  stream->rtcp_rdb = old_rtcp_rdb;
+
+  return srtp_err_status_ok;
+}
+
+
+srtp_err_status_t
+srtp_update_stream(srtp_t session, const srtp_policy_t *policy) {
+  srtp_err_status_t status;
+
+  /* sanity check arguments */
+  if ((session == NULL) || (policy == NULL) || (!srtp_validate_policy_master_keys(policy)))
+    return srtp_err_status_bad_param;
+
+  switch (policy->ssrc.type) {
+  case (ssrc_any_outbound):
+  case (ssrc_any_inbound):
+    status = update_template_streams(session, policy);
+    break;
+  case (ssrc_specific):
+    status = update_stream(session, policy);
+    break;
+  case (ssrc_undefined):
+  default:
+    return srtp_err_status_bad_param;
+  }
+
+  return status;
 }
 
 
 /*
- * the default policy - provides a convenient way for callers to use
+ * The default policy - provides a convenient way for callers to use
  * the default security policy
- * 
- * this policy is that defined in the current SRTP internet draft.
+ *
+ * The default policy is defined in RFC 3711
+ * (Section 5. Default and mandatory-to-implement Transforms)
  *
  */
@@ -2018 +3129 @@
 
 void
-crypto_policy_set_rtp_default(crypto_policy_t *p) {
-
-  p->cipher_type     = AES_ICM;           
-  p->cipher_key_len  = 30;                /* default 128 bits per RFC 3711 */
-  p->auth_type       = HMAC_SHA1;             
+srtp_crypto_policy_set_rtp_default(srtp_crypto_policy_t *p) {
+
+  p->cipher_type     = SRTP_AES_ICM_128;
+  p->cipher_key_len  = SRTP_AES_ICM_128_KEY_LEN_WSALT; /* default 128 bits per RFC 3711 */
+  p->auth_type       = SRTP_HMAC_SHA1;             
   p->auth_key_len    = 20;                /* default 160 bits per RFC 3711 */
   p->auth_tag_len    = 10;                /* default 80 bits per RFC 3711 */
@@ -2030 +3141 @@
 
 void
-crypto_policy_set_rtcp_default(crypto_policy_t *p) {
-
-  p->cipher_type     = AES_ICM;           
-  p->cipher_key_len  = 30;                 /* default 128 bits per RFC 3711 */
-  p->auth_type       = HMAC_SHA1;             
+srtp_crypto_policy_set_rtcp_default(srtp_crypto_policy_t *p) {
+
+  p->cipher_type     = SRTP_AES_ICM_128;
+  p->cipher_key_len  = SRTP_AES_ICM_128_KEY_LEN_WSALT; /* default 128 bits per RFC 3711 */
+  p->auth_type       = SRTP_HMAC_SHA1;             
   p->auth_key_len    = 20;                 /* default 160 bits per RFC 3711 */
   p->auth_tag_len    = 10;                 /* default 80 bits per RFC 3711 */
@@ -2042 +3153 @@
 
 void
-crypto_policy_set_aes_cm_128_hmac_sha1_32(crypto_policy_t *p) {
+srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32(srtp_crypto_policy_t *p) {
 
   /*
@@ -2050 +3161 @@
    */
 
-  p->cipher_type     = AES_ICM;           
-  p->cipher_key_len  = 30;                /* 128 bit key, 112 bit salt */
-  p->auth_type       = HMAC_SHA1;             
+  p->cipher_type     = SRTP_AES_ICM_128;
+  p->cipher_key_len  = SRTP_AES_ICM_128_KEY_LEN_WSALT; /* 128 bit key, 112 bit salt */
+  p->auth_type       = SRTP_HMAC_SHA1;             
   p->auth_key_len    = 20;                /* 160 bit key               */
   p->auth_tag_len    = 4;                 /* 32 bit tag                */
@@ -2061 +3172 @@
 
 void
-crypto_policy_set_aes_cm_128_null_auth(crypto_policy_t *p) {
+srtp_crypto_policy_set_aes_cm_128_null_auth(srtp_crypto_policy_t *p) {
 
   /*
@@ -2069 +3180 @@
    */
 
-  p->cipher_type     = AES_ICM;           
-  p->cipher_key_len  = 30;                /* 128 bit key, 112 bit salt */
-  p->auth_type       = NULL_AUTH;             
+  p->cipher_type     = SRTP_AES_ICM_128;
+  p->cipher_key_len  = SRTP_AES_ICM_128_KEY_LEN_WSALT; /* 128 bit key, 112 bit salt */
+  p->auth_type       = SRTP_NULL_AUTH;             
   p->auth_key_len    = 0; 
   p->auth_tag_len    = 0; 
@@ -2080 +3191 @@
 
 void
-crypto_policy_set_null_cipher_hmac_sha1_80(crypto_policy_t *p) {
+srtp_crypto_policy_set_null_cipher_hmac_sha1_80(srtp_crypto_policy_t *p) {
 
   /*
@@ -2086 +3197 @@
    */
 
-  p->cipher_type     = NULL_CIPHER;           
+  p->cipher_type     = SRTP_NULL_CIPHER;           
   p->cipher_key_len  = 0;
-  p->auth_type       = HMAC_SHA1;             
+  p->auth_type       = SRTP_HMAC_SHA1;             
   p->auth_key_len    = 20; 
   p->auth_tag_len    = 10; 
@@ -2095 +3206 @@
 }
 
-
 void
-crypto_policy_set_aes_cm_256_hmac_sha1_80(crypto_policy_t *p) {
+srtp_crypto_policy_set_null_cipher_hmac_null(srtp_crypto_policy_t *p) {
 
   /*
-   * corresponds to draft-ietf-avt-big-aes-03.txt
-   */
-
-  p->cipher_type     = AES_ICM;           
-  p->cipher_key_len  = 46;
-  p->auth_type       = HMAC_SHA1;             
+   * Should only be used for testing
+   */
+
+  p->cipher_type     = SRTP_NULL_CIPHER;           
+  p->cipher_key_len  = 0;
+  p->auth_type       = SRTP_NULL_AUTH;             
+  p->auth_key_len    = 0; 
+  p->auth_tag_len    = 0; 
+  p->sec_serv        = sec_serv_none;
+  
+}
+
+
+void
+srtp_crypto_policy_set_aes_cm_256_hmac_sha1_80(srtp_crypto_policy_t *p) {
+
+  /*
+   * corresponds to RFC 6188
+   */
+
+  p->cipher_type     = SRTP_AES_ICM_256;
+  p->cipher_key_len  = SRTP_AES_ICM_256_KEY_LEN_WSALT;
+  p->auth_type       = SRTP_HMAC_SHA1;             
   p->auth_key_len    = 20;                /* default 160 bits per RFC 3711 */
   p->auth_tag_len    = 10;                /* default 80 bits per RFC 3711 */
@@ -2113 +3240 @@
 
 void
-crypto_policy_set_aes_cm_256_hmac_sha1_32(crypto_policy_t *p) {
+srtp_crypto_policy_set_aes_cm_256_hmac_sha1_32(srtp_crypto_policy_t *p) {
 
   /*
-   * corresponds to draft-ietf-avt-big-aes-03.txt
+   * corresponds to RFC 6188
    *
    * note that this crypto policy is intended for SRTP, but not SRTCP
    */
 
-  p->cipher_type     = AES_ICM;           
-  p->cipher_key_len  = 46;
-  p->auth_type       = HMAC_SHA1;             
+  p->cipher_type     = SRTP_AES_ICM_256;
+  p->cipher_key_len  = SRTP_AES_ICM_256_KEY_LEN_WSALT;
+  p->auth_type       = SRTP_HMAC_SHA1;             
   p->auth_key_len    = 20;                /* default 160 bits per RFC 3711 */
   p->auth_tag_len    = 4;                 /* default 80 bits per RFC 3711 */
@@ -2133 +3260 @@
  */
 void
-crypto_policy_set_aes_cm_256_null_auth (crypto_policy_t *p)
+srtp_crypto_policy_set_aes_cm_256_null_auth (srtp_crypto_policy_t *p)
 {
-    p->cipher_type     = AES_ICM;
-    p->cipher_key_len  = 46;
-    p->auth_type       = NULL_AUTH;
+    p->cipher_type     = SRTP_AES_ICM_256;
+    p->cipher_key_len  = SRTP_AES_ICM_256_KEY_LEN_WSALT;
+    p->auth_type       = SRTP_NULL_AUTH;
     p->auth_key_len    = 0;
     p->auth_tag_len    = 0;
@@ -2144 +3271 @@
 
 #ifdef OPENSSL
+void
+srtp_crypto_policy_set_aes_cm_192_hmac_sha1_80(srtp_crypto_policy_t *p) {
+
+  /*
+   * corresponds to RFC 6188
+   */
+
+  p->cipher_type     = SRTP_AES_ICM_192;
+  p->cipher_key_len  = SRTP_AES_ICM_192_KEY_LEN_WSALT;
+  p->auth_type       = SRTP_HMAC_SHA1;
+  p->auth_key_len    = 20;                /* default 160 bits per RFC 3711 */
+  p->auth_tag_len    = 10;                /* default 80 bits per RFC 3711 */
+  p->sec_serv        = sec_serv_conf_and_auth;
+}
+
+
+void
+srtp_crypto_policy_set_aes_cm_192_hmac_sha1_32(srtp_crypto_policy_t *p) {
+
+  /*
+   * corresponds to RFC 6188
+   *
+   * note that this crypto policy is intended for SRTP, but not SRTCP
+   */
+
+  p->cipher_type     = SRTP_AES_ICM_192;
+  p->cipher_key_len  = SRTP_AES_ICM_192_KEY_LEN_WSALT;
+  p->auth_type       = SRTP_HMAC_SHA1;
+  p->auth_key_len    = 20;                /* default 160 bits per RFC 3711 */
+  p->auth_tag_len    = 4;                 /* default 80 bits per RFC 3711 */
+  p->sec_serv        = sec_serv_conf_and_auth;
+}
+
+/*
+ * AES-192 with no authentication.
+ */
+void
+srtp_crypto_policy_set_aes_cm_192_null_auth (srtp_crypto_policy_t *p)
+{
+    p->cipher_type     = SRTP_AES_ICM_192;
+    p->cipher_key_len  = SRTP_AES_ICM_192_KEY_LEN_WSALT;
+    p->auth_type       = SRTP_NULL_AUTH;
+    p->auth_key_len    = 0;
+    p->auth_tag_len    = 0;
+    p->sec_serv        = sec_serv_conf;
+}
+
 /*
  * AES-128 GCM mode with 8 octet auth tag. 
  */
 void
-crypto_policy_set_aes_gcm_128_8_auth(crypto_policy_t *p) {
-  p->cipher_type     = AES_128_GCM;           
-  p->cipher_key_len  = AES_128_GCM_KEYSIZE_WSALT; 
-  p->auth_type       = NULL_AUTH; /* GCM handles the auth for us */            
+srtp_crypto_policy_set_aes_gcm_128_8_auth(srtp_crypto_policy_t *p) {
+  p->cipher_type     = SRTP_AES_GCM_128;
+  p->cipher_key_len  = SRTP_AES_GCM_128_KEY_LEN_WSALT;
+  p->auth_type       = SRTP_NULL_AUTH; /* GCM handles the auth for us */            
   p->auth_key_len    = 0; 
   p->auth_tag_len    = 8;   /* 8 octet tag length */
@@ -2161 +3335 @@
  */
 void
-crypto_policy_set_aes_gcm_256_8_auth(crypto_policy_t *p) {
-  p->cipher_type     = AES_256_GCM;           
-  p->cipher_key_len  = AES_256_GCM_KEYSIZE_WSALT; 
-  p->auth_type       = NULL_AUTH; /* GCM handles the auth for us */ 
+srtp_crypto_policy_set_aes_gcm_256_8_auth(srtp_crypto_policy_t *p) {
+  p->cipher_type     = SRTP_AES_GCM_256;
+  p->cipher_key_len  = SRTP_AES_GCM_256_KEY_LEN_WSALT;
+  p->auth_type       = SRTP_NULL_AUTH; /* GCM handles the auth for us */ 
   p->auth_key_len    = 0; 
   p->auth_tag_len    = 8;   /* 8 octet tag length */
@@ -2174 +3348 @@
  */
 void
-crypto_policy_set_aes_gcm_128_8_only_auth(crypto_policy_t *p) {
-  p->cipher_type     = AES_128_GCM;           
-  p->cipher_key_len  = AES_128_GCM_KEYSIZE_WSALT; 
-  p->auth_type       = NULL_AUTH; /* GCM handles the auth for us */ 
+srtp_crypto_policy_set_aes_gcm_128_8_only_auth(srtp_crypto_policy_t *p) {
+  p->cipher_type     = SRTP_AES_GCM_128;
+  p->cipher_key_len  = SRTP_AES_GCM_128_KEY_LEN_WSALT;
+  p->auth_type       = SRTP_NULL_AUTH; /* GCM handles the auth for us */ 
   p->auth_key_len    = 0; 
   p->auth_tag_len    = 8;   /* 8 octet tag length */
@@ -2187 +3361 @@
  */
 void
-crypto_policy_set_aes_gcm_256_8_only_auth(crypto_policy_t *p) {
-  p->cipher_type     = AES_256_GCM;           
-  p->cipher_key_len  = AES_256_GCM_KEYSIZE_WSALT; 
-  p->auth_type       = NULL_AUTH; /* GCM handles the auth for us */ 
+srtp_crypto_policy_set_aes_gcm_256_8_only_auth(srtp_crypto_policy_t *p) {
+  p->cipher_type     = SRTP_AES_GCM_256;
+  p->cipher_key_len  = SRTP_AES_GCM_256_KEY_LEN_WSALT;
+  p->auth_type       = SRTP_NULL_AUTH; /* GCM handles the auth for us */ 
   p->auth_key_len    = 0; 
   p->auth_tag_len    = 8;   /* 8 octet tag length */
@@ -2200 +3374 @@
  */
 void
-crypto_policy_set_aes_gcm_128_16_auth(crypto_policy_t *p) {
-  p->cipher_type     = AES_128_GCM;           
-  p->cipher_key_len  = AES_128_GCM_KEYSIZE_WSALT; 
-  p->auth_type       = NULL_AUTH; /* GCM handles the auth for us */            
+srtp_crypto_policy_set_aes_gcm_128_16_auth(srtp_crypto_policy_t *p) {
+  p->cipher_type     = SRTP_AES_GCM_128;
+  p->cipher_key_len  = SRTP_AES_GCM_128_KEY_LEN_WSALT;
+  p->auth_type       = SRTP_NULL_AUTH; /* GCM handles the auth for us */            
   p->auth_key_len    = 0; 
   p->auth_tag_len    = 16;   /* 16 octet tag length */
@@ -2213 +3387 @@
  */
 void
-crypto_policy_set_aes_gcm_256_16_auth(crypto_policy_t *p) {
-  p->cipher_type     = AES_256_GCM;           
-  p->cipher_key_len  = AES_256_GCM_KEYSIZE_WSALT; 
-  p->auth_type       = NULL_AUTH; /* GCM handles the auth for us */ 
+srtp_crypto_policy_set_aes_gcm_256_16_auth(srtp_crypto_policy_t *p) {
+  p->cipher_type     = SRTP_AES_GCM_256;
+  p->cipher_key_len  = SRTP_AES_GCM_256_KEY_LEN_WSALT;
+  p->auth_type       = SRTP_NULL_AUTH; /* GCM handles the auth for us */ 
   p->auth_key_len    = 0; 
   p->auth_tag_len    = 16;   /* 16 octet tag length */
@@ -2230 +3404 @@
 /*
  * AEAD uses a new IV formation method.  This function implements
- * section 10.1 from draft-ietf-avtcore-srtp-aes-gcm-07.txt.  The
- * calculation is defined as, where (+) is the xor operation:
+ * section 9.1 (SRTCP IV Formation for AES-GCM) from RFC7714.
+ * The calculation is defined as, where (+) is the xor operation:
  *
  *                0  1  2  3  4  5  6  7  8  9 10 11
@@ -2246 +3420 @@
  *               +--+--+--+--+--+--+--+--+--+--+--+--+*
  *
- * Input:  *stream - pointer to SRTP stream context, used to retrieve
- *                   the SALT 
- *         *iv     - Pointer to recieve the calculated IV
- *         seq_num - The SEQ value to use for the IV calculation.
- *         *hdr    - The RTP header, used to get the SSRC value
+ * Input:  *session_keys - pointer to SRTP stream context session keys,
+ *                        used to retrieve the SALT 
+ *         *iv           - Pointer to recieve the calculated IV
+ *         seq_num       - The SEQ value to use for the IV calculation.
+ *         *hdr          - The RTP header, used to get the SSRC value
+ *
+ * Returns: srtp_err_status_ok if no error or srtp_err_status_bad_param
+ *          if seq_num is invalid
  *
  */
-static void srtp_calc_aead_iv_srtcp(srtp_stream_ctx_t *stream, v128_t *iv, 
-                                    uint32_t seq_num, srtcp_hdr_t *hdr)
+static srtp_err_status_t
+srtp_calc_aead_iv_srtcp(srtp_session_keys_t *session_keys, v128_t *iv,
+                        uint32_t seq_num, srtcp_hdr_t *hdr)
 {
     v128_t      in;
@@ -2265 +3443 @@
     memcpy(&in.v16[1], &hdr->ssrc, 4); /* still in network order! */
     in.v16[3] = 0;
-    in.v32[2] = 0x7FFFFFFF & htonl(seq_num); /* bit 32 is suppose to be zero */
+
+    /*
+     *  The SRTCP index (seq_num) spans bits 0 through 30 inclusive.
+     *  The most significant bit should be zero.
+     */
+    if (seq_num & 0x80000000UL) {
+        return srtp_err_status_bad_param;
+    }
+    in.v32[2] = htonl(seq_num);
 
     debug_print(mod_srtp, "Pre-salted RTCP IV = %s\n", v128_hex_string(&in));
@@ -2272 +3458 @@
      * Get the SALT value from the context
      */
-    memcpy(salt.v8, stream->c_salt, 12);
+    memcpy(salt.v8, session_keys->c_salt, 12);
     debug_print(mod_srtp, "RTCP SALT = %s\n", v128_hex_string(&salt));
 
@@ -2279 +3465 @@
      */
     v128_xor(iv, &in, &salt);
+
+    return srtp_err_status_ok;
 }
 
@@ -2285 +3473 @@
  * AES-GCM mode with 128 or 256 bit keys. 
  */
-static err_status_t
+static srtp_err_status_t
 srtp_protect_rtcp_aead (srtp_t ctx, srtp_stream_ctx_t *stream, 
-                        void *rtcp_hdr, unsigned int *pkt_octet_len)
+                        void *rtcp_hdr, unsigned int *pkt_octet_len,
+                        srtp_session_keys_t *session_keys, unsigned int use_mki)
 {
     srtcp_hdr_t *hdr = (srtcp_hdr_t*)rtcp_hdr;
@@ -2294 +3483 @@
     unsigned int enc_octet_len = 0; /* number of octets in encrypted portion */
     uint8_t *auth_tag = NULL;   /* location of auth_tag within packet     */
-    err_status_t status;
-    int tag_len;
+    srtp_err_status_t status;
+    uint32_t tag_len;
     uint32_t seq_num;
     v128_t iv;
     uint32_t tseq;
+    unsigned int mki_size = 0;
 
     /* get tag length from stream context */
-    tag_len = auth_get_tag_length(stream->rtcp_auth);
+    tag_len = srtp_auth_get_tag_length(session_keys->rtcp_auth);
 
     /*
@@ -2325 +3515 @@
     }
 
+    mki_size = srtp_inject_mki((uint8_t *)hdr + *pkt_octet_len + tag_len + sizeof(srtcp_trailer_t),
+                               session_keys, use_mki);
+
     /*
      * set the auth_tag pointer to the proper location, which is after
@@ -2337 +3530 @@
      * if its value isn't too big
      */
-    status = rdb_increment(&stream->rtcp_rdb);
+    status = srtp_rdb_increment(&stream->rtcp_rdb);
     if (status) {
         return status;
     }
-    seq_num = rdb_get_value(&stream->rtcp_rdb);
+    seq_num = srtp_rdb_get_value(&stream->rtcp_rdb);
     *trailer |= htonl(seq_num);
     debug_print(mod_srtp, "srtcp index: %x", seq_num);
 
     /*
-     * Calculating the IV and pass it down to the cipher 
-     */
-    srtp_calc_aead_iv_srtcp(stream, &iv, seq_num, hdr);
-    status = cipher_set_iv(stream->rtcp_cipher, &iv, direction_encrypt);
+     * Calculate and set the IV
+     */
+    status = srtp_calc_aead_iv_srtcp(session_keys, &iv, seq_num, hdr);
     if (status) {
-        return err_status_cipher_fail;
+        return srtp_err_status_cipher_fail;
+    }
+    status = srtp_cipher_set_iv(session_keys->rtcp_cipher,
+                                (uint8_t*)&iv, srtp_direction_encrypt);
+    if (status) {
+        return srtp_err_status_cipher_fail;
     }
 
@@ -2358 +3555 @@
      */
     if (enc_start) {
-        /*
-         * If payload encryption is enabled, then the AAD consist of
-         * the RTCP header and the seq# at the end of the packet
-         */
-        status = cipher_set_aad(stream->rtcp_cipher, (uint8_t*)hdr, 
-                                octets_in_rtcp_header);
-        if (status) {
-            return ( err_status_cipher_fail);
-        }
+        /*
+         * If payload encryption is enabled, then the AAD consist of
+         * the RTCP header and the seq# at the end of the packet
+         */
+        status = srtp_cipher_set_aad(session_keys->rtcp_cipher,
+                                 (uint8_t*)hdr, octets_in_rtcp_header);
+        if (status) {
+            return ( srtp_err_status_cipher_fail);
+        }
     } else {
-        /*
-         * Since payload encryption is not enabled, we must authenticate
-         * the entire packet as described in section 10.3 in revision 07
-         * of the draft.
-         */
-        status = cipher_set_aad(stream->rtcp_cipher, (uint8_t*)hdr, 
-                                *pkt_octet_len);
-        if (status) {
-            return ( err_status_cipher_fail);
-        }
-    }
-    /* 
+        /*
+         * Since payload encryption is not enabled, we must authenticate
+         * the entire packet as described in RFC 7714 (Section 9.3. Data
+         * Types in Unencrypted SRTCP Compound Packets)
+         */
+        status = srtp_cipher_set_aad(session_keys->rtcp_cipher,
+                                 (uint8_t*)hdr, *pkt_octet_len);
+        if (status) {
+            return ( srtp_err_status_cipher_fail);
+        }
+    }
+    /*
      * Process the sequence# as AAD
      */
     tseq = *trailer;
-    status = cipher_set_aad(stream->rtcp_cipher, (uint8_t*)&tseq, 
-                            sizeof(srtcp_trailer_t));
+    status = srtp_cipher_set_aad(session_keys->rtcp_cipher, (uint8_t*)&tseq,
+                                 sizeof(srtcp_trailer_t));
     if (status) {
-        return ( err_status_cipher_fail);
+        return ( srtp_err_status_cipher_fail);
     }
 
     /* if we're encrypting, exor keystream into the message */
     if (enc_start) {
-        status = cipher_encrypt(stream->rtcp_cipher,
-                                (uint8_t*)enc_start, &enc_octet_len);
+        status = srtp_cipher_encrypt(session_keys->rtcp_cipher,
+                                     (uint8_t*)enc_start, &enc_octet_len);
         if (status) {
-            return err_status_cipher_fail;
+            return srtp_err_status_cipher_fail;
         }
-        /*
-         * Get the tag and append that to the output
-         */
-        status = cipher_get_tag(stream->rtcp_cipher, (uint8_t*)auth_tag, 
-                                &tag_len);
-        if (status) {
-            return ( err_status_cipher_fail);
-        }
-        enc_octet_len += tag_len;
+        /*
+         * Get the tag and append that to the output
+         */
+        status = srtp_cipher_get_tag(session_keys->rtcp_cipher, (uint8_t*)auth_tag,
+                                     &tag_len);
+        if (status) {
+            return ( srtp_err_status_cipher_fail);
+        }
+        enc_octet_len += tag_len;
     } else {
-        /*
-         * Even though we're not encrypting the payload, we need
-         * to run the cipher to get the auth tag.
-         */
-        unsigned int nolen = 0;
-        status = cipher_encrypt(stream->rtcp_cipher, NULL, &nolen);
+        /*
+         * Even though we're not encrypting the payload, we need
+         * to run the cipher to get the auth tag.
+         */
+        unsigned int nolen = 0;
+        status = srtp_cipher_encrypt(session_keys->rtcp_cipher, NULL, &nolen);
         if (status) {
-            return err_status_cipher_fail;
+            return srtp_err_status_cipher_fail;
         }
-        /*
-         * Get the tag and append that to the output
-         */
-        status = cipher_get_tag(stream->rtcp_cipher, (uint8_t*)auth_tag, 
-                                &tag_len);
-        if (status) {
-            return ( err_status_cipher_fail);
-        }
-        enc_octet_len += tag_len;
+        /*
+         * Get the tag and append that to the output
+         */
+        status = srtp_cipher_get_tag(session_keys->rtcp_cipher, (uint8_t*)auth_tag,
+                                     &tag_len);
+        if (status) {
+            return ( srtp_err_status_cipher_fail);
+        }
+        enc_octet_len += tag_len;
     }
 
@@ -2429 +3626 @@
     *pkt_octet_len += (tag_len + sizeof(srtcp_trailer_t));
 
-    return err_status_ok;
+    /* increase the packet by the mki_size */
+    *pkt_octet_len += mki_size;
+
+    return srtp_err_status_ok;
 }
 
@@ -2438 +3638 @@
  * when decrypting the payload.
  */
-static err_status_t
+static srtp_err_status_t
 srtp_unprotect_rtcp_aead (srtp_t ctx, srtp_stream_ctx_t *stream, 
-                          void *srtcp_hdr, unsigned int *pkt_octet_len)
+                          void *srtcp_hdr, unsigned int *pkt_octet_len,
+                          srtp_session_keys_t *session_keys, unsigned int use_mki)
 {
     srtcp_hdr_t *hdr = (srtcp_hdr_t*)srtcp_hdr;
@@ -2447 +3648 @@
     unsigned int enc_octet_len = 0; /* number of octets in encrypted portion */
     uint8_t *auth_tag = NULL;   /* location of auth_tag within packet     */
-    err_status_t status;
+    srtp_err_status_t status;
     int tag_len;
     unsigned int tmp_len;
@@ -2453 +3654 @@
     v128_t iv;
     uint32_t tseq;
+    unsigned int mki_size = 0;
 
     /* get tag length from stream context */
-    tag_len = auth_get_tag_length(stream->rtcp_auth);
+    tag_len = srtp_auth_get_tag_length(session_keys->rtcp_auth);
+
+    if (use_mki) {
+      mki_size = session_keys->mki_size;
+    }
 
     /*
@@ -2469 +3675 @@
      *   multiples of 32-bits (RFC 3550 6.1)
      */
-    trailer = (uint32_t*)((char*)hdr + *pkt_octet_len - sizeof(srtcp_trailer_t));
+    trailer = (uint32_t*)((char*)hdr + *pkt_octet_len - sizeof(srtcp_trailer_t) - mki_size);
     /*
      * We pass the tag down to the cipher when doing GCM mode 
      */
     enc_octet_len = *pkt_octet_len - (octets_in_rtcp_header + 
-                                      sizeof(srtcp_trailer_t));
-    auth_tag = (uint8_t*)hdr + *pkt_octet_len - tag_len - sizeof(srtcp_trailer_t);
+                                      sizeof(srtcp_trailer_t) + mki_size);
+    auth_tag = (uint8_t*)hdr + *pkt_octet_len - tag_len - mki_size - sizeof(srtcp_trailer_t);
 
     if (*((unsigned char*)trailer) & SRTCP_E_BYTE_BIT) {
@@ -2490 +3696 @@
     seq_num = ntohl(*trailer) & SRTCP_INDEX_MASK;
     debug_print(mod_srtp, "srtcp index: %x", seq_num);
-    status = rdb_check(&stream->rtcp_rdb, seq_num);
+    status = srtp_rdb_check(&stream->rtcp_rdb, seq_num);
     if (status) {
         return status;
@@ -2498 +3704 @@
      * Calculate and set the IV
      */
-    srtp_calc_aead_iv_srtcp(stream, &iv, seq_num, hdr);
-    status = cipher_set_iv(stream->rtcp_cipher, &iv, direction_decrypt);
+    status = srtp_calc_aead_iv_srtcp(session_keys, &iv, seq_num, hdr);
     if (status) {
-        return err_status_cipher_fail;
+        return srtp_err_status_cipher_fail;
+    }
+    status = srtp_cipher_set_iv(session_keys->rtcp_cipher,
+                                (uint8_t*)&iv, srtp_direction_decrypt);
+    if (status) {
+        return srtp_err_status_cipher_fail;
     }
 
@@ -2508 +3718 @@
      */
     if (enc_start) {
-        /*
-         * If payload encryption is enabled, then the AAD consist of
-         * the RTCP header and the seq# at the end of the packet
-         */
-        status = cipher_set_aad(stream->rtcp_cipher, (uint8_t*)hdr, 
-                                octets_in_rtcp_header);
-        if (status) {
-            return ( err_status_cipher_fail);
-        }
+        /*
+         * If payload encryption is enabled, then the AAD consist of
+         * the RTCP header and the seq# at the end of the packet
+         */
+        status = srtp_cipher_set_aad(session_keys->rtcp_cipher,
+                                   (uint8_t*)hdr, octets_in_rtcp_header);
+        if (status) {
+            return ( srtp_err_status_cipher_fail);
+        }
     } else {
-        /*
-         * Since payload encryption is not enabled, we must authenticate
-         * the entire packet as described in section 10.3 in revision 07
-         * of the draft.
-         */
-        status = cipher_set_aad(stream->rtcp_cipher, (uint8_t*)hdr, 
-                               (*pkt_octet_len - tag_len - sizeof(srtcp_trailer_t)));
-        if (status) {
-            return ( err_status_cipher_fail);
-        }
-    }
-
-    /* 
-     * Process the sequence# as AAD 
+        /*
+         * Since payload encryption is not enabled, we must authenticate
+         * the entire packet as described in RFC 7714 (Section 9.3. Data
+         * Types in Unencrypted SRTCP Compound Packets)
+         */
+        status = srtp_cipher_set_aad(
+          session_keys->rtcp_cipher, (uint8_t*)hdr,
+          (*pkt_octet_len - tag_len - sizeof(srtcp_trailer_t) - mki_size));
+        if (status) {
+            return ( srtp_err_status_cipher_fail);
+        }
+    }
+
+    /*
+     * Process the sequence# as AAD
      */
     tseq = *trailer;
-    status = cipher_set_aad(stream->rtcp_cipher, (uint8_t*)&tseq, 
-                            sizeof(srtcp_trailer_t));
+    status = srtp_cipher_set_aad(session_keys->rtcp_cipher,
+                                 (uint8_t*)&tseq, sizeof(srtcp_trailer_t));
     if (status) {
-        return ( err_status_cipher_fail);
+        return ( srtp_err_status_cipher_fail);
     }
 
     /* if we're decrypting, exor keystream into the message */
     if (enc_start) {
-        status = cipher_decrypt(stream->rtcp_cipher,
-                                (uint8_t*)enc_start, &enc_octet_len);
+        status = srtp_cipher_decrypt(session_keys->rtcp_cipher, (uint8_t*)enc_start, &enc_octet_len);
         if (status) {
             return status;
         }
     } else {
-        /*
-         * Still need to run the cipher to check the tag
-         */
-        tmp_len = tag_len;
-        status = cipher_decrypt(stream->rtcp_cipher, (uint8_t*)auth_tag, 
-                                &tmp_len);
+        /*
+         * Still need to run the cipher to check the tag
+         */
+        tmp_len = tag_len;
+        status = srtp_cipher_decrypt(session_keys->rtcp_cipher, (uint8_t*)auth_tag, &tmp_len);
         if (status) {
             return status;
@@ -2560 +3769 @@
 
     /* decrease the packet length by the length of the auth tag and seq_num*/
-    *pkt_octet_len -= (tag_len + sizeof(srtcp_trailer_t));
+    *pkt_octet_len -= (tag_len + sizeof(srtcp_trailer_t) + mki_size);
 
     /*
@@ -2609 +3818 @@
 
     /* we've passed the authentication check, so add seq_num to the rdb */
-    rdb_add_index(&stream->rtcp_rdb, seq_num);
-
-    return err_status_ok;
-}
-
-err_status_t 
+    srtp_rdb_add_index(&stream->rtcp_rdb, seq_num);
+
+    return srtp_err_status_ok;
+}
+
+srtp_err_status_t 
 srtp_protect_rtcp(srtp_t ctx, void *rtcp_hdr, int *pkt_octet_len) {
+  return srtp_protect_rtcp_mki(ctx, rtcp_hdr, pkt_octet_len, 0, 0);
+}
+
+srtp_err_status_t 
+srtp_protect_rtcp_mki(srtp_t ctx, void *rtcp_hdr, int *pkt_octet_len,
+                      unsigned int use_mki, unsigned int mki_index) {
   srtcp_hdr_t *hdr = (srtcp_hdr_t *)rtcp_hdr;
   uint32_t *enc_start;      /* pointer to start of encrypted portion  */
@@ -2622 +3837 @@
   unsigned int enc_octet_len = 0;/* number of octets in encrypted portion */
   uint8_t *auth_tag = NULL; /* location of auth_tag within packet     */
-  err_status_t status;   
+  srtp_err_status_t status;   
   int tag_len;
   srtp_stream_ctx_t *stream;
-  int prefix_len;
+  uint32_t prefix_len;
   uint32_t seq_num;
+  unsigned int mki_size = 0;
+  srtp_session_keys_t *session_keys = NULL;
 
   /* we assume the hdr is 32-bit aligned to start */
@@ -2632 +3849 @@
   /* check the packet length - it must at least contain a full header */
   if (*pkt_octet_len < octets_in_rtcp_header)
-    return err_status_bad_param;
+    return srtp_err_status_bad_param;
 
   /*
@@ -2660 +3877 @@
     } else {
       /* no template stream, so we return an error */
-      return err_status_no_ctx;
+      return srtp_err_status_no_ctx;
     } 
   }
@@ -2678 +3895 @@
   }  
 
+  session_keys = srtp_get_session_keys_with_mki_index(stream, use_mki, mki_index);
+
   /*
    * Check if this is an AEAD stream (GCM mode).  If so, then dispatch
    * the request to our AEAD handler.
    */
-  if (stream->rtp_cipher->algorithm == AES_128_GCM ||
-      stream->rtp_cipher->algorithm == AES_256_GCM) {
-      return srtp_protect_rtcp_aead(ctx, stream, rtcp_hdr, (unsigned int*)pkt_octet_len);
+  if (session_keys->rtp_cipher->algorithm == SRTP_AES_GCM_128 ||
+      session_keys->rtp_cipher->algorithm == SRTP_AES_GCM_256) {
+      return srtp_protect_rtcp_aead(ctx, stream, rtcp_hdr,
+                                    (unsigned int*)pkt_octet_len, session_keys,
+                                    use_mki);
   }
 
   /* get tag length from stream context */
-  tag_len = auth_get_tag_length(stream->rtcp_auth); 
+  tag_len = srtp_auth_get_tag_length(session_keys->rtcp_auth); 
 
   /*
@@ -2713 +3934 @@
   }
 
+  mki_size = srtp_inject_mki((uint8_t *)hdr + *pkt_octet_len + sizeof(srtcp_trailer_t),
+                             session_keys, use_mki);
+
   /* 
    * set the auth_start and auth_tag pointers to the proper locations
@@ -2719 +3943 @@
   /* Note: This would need to change for optional mikey data */
   auth_start = (uint32_t *)hdr;
-  auth_tag = (uint8_t *)hdr + *pkt_octet_len + sizeof(srtcp_trailer_t); 
+  auth_tag = (uint8_t *)hdr + *pkt_octet_len + sizeof(srtcp_trailer_t) + mki_size; 
 
   /* perform EKT processing if needed */
-  ekt_write_data(stream->ekt, auth_tag, tag_len, pkt_octet_len, 
-                 rdbx_get_packet_index(&stream->rtp_rdbx));
+  srtp_ekt_write_data(stream->ekt, auth_tag, tag_len, pkt_octet_len, 
+                      srtp_rdbx_get_packet_index(&stream->rtp_rdbx));
 
   /* 
@@ -2729 +3953 @@
    * if its value isn't too big
    */
-  status = rdb_increment(&stream->rtcp_rdb);
+  status = srtp_rdb_increment(&stream->rtcp_rdb);
   if (status)
     return status;
-  seq_num = rdb_get_value(&stream->rtcp_rdb);
+  seq_num = srtp_rdb_get_value(&stream->rtcp_rdb);
   *trailer |= htonl(seq_num);
   debug_print(mod_srtp, "srtcp index: %x", seq_num);
@@ -2739 +3963 @@
    * if we're using rindael counter mode, set nonce and seq 
    */
-  if (stream->rtcp_cipher->type->id == AES_ICM) {
+  if (session_keys->rtcp_cipher->type->id == SRTP_AES_ICM_128 ||
+      session_keys->rtcp_cipher->type->id == SRTP_AES_ICM_192 ||
+      session_keys->rtcp_cipher->type->id == SRTP_AES_ICM_256) {
     v128_t iv;
     
@@ -2746 +3972 @@
     iv.v32[2] = htonl(seq_num >> 16);
     iv.v32[3] = htonl(seq_num << 16);
-    status = cipher_set_iv(stream->rtcp_cipher, &iv, direction_encrypt);
+    status = srtp_cipher_set_iv(session_keys->rtcp_cipher, (uint8_t*)&iv,
+                                srtp_direction_encrypt);
 
   } else {  
@@ -2756 +3983 @@
     iv.v32[2] = 0;
     iv.v32[3] = htonl(seq_num);
-    status = cipher_set_iv(stream->rtcp_cipher, &iv, direction_encrypt);
+    status = srtp_cipher_set_iv(session_keys->rtcp_cipher,
+                                (uint8_t*)&iv, srtp_direction_encrypt);
   }
   if (status)
-    return err_status_cipher_fail;
+    return srtp_err_status_cipher_fail;
 
   /* 
@@ -2770 +3998 @@
 
     /* put keystream prefix into auth_tag */
-    prefix_len = auth_get_prefix_length(stream->rtcp_auth);    
-    status = cipher_output(stream->rtcp_cipher, auth_tag, prefix_len);
+    prefix_len = srtp_auth_get_prefix_length(session_keys->rtcp_auth);    
+    status = srtp_cipher_output(session_keys->rtcp_cipher, auth_tag, &prefix_len);
 
     debug_print(mod_srtp, "keystream prefix: %s", 
-                octet_string_hex_string(auth_tag, prefix_len));
+                srtp_octet_string_hex_string(auth_tag, prefix_len));
 
     if (status)
-      return err_status_cipher_fail;
+      return srtp_err_status_cipher_fail;
   }
 
   /* if we're encrypting, exor keystream into the message */
   if (enc_start) {
-    status = cipher_encrypt(stream->rtcp_cipher, 
-                            (uint8_t *)enc_start, &enc_octet_len);
+    status = srtp_cipher_encrypt(session_keys->rtcp_cipher, 
+                                (uint8_t *)enc_start, &enc_octet_len);
     if (status)
-      return err_status_cipher_fail;
+      return srtp_err_status_cipher_fail;
   }
 
   /* initialize auth func context */
-  auth_start(stream->rtcp_auth);
+  srtp_auth_start(session_keys->rtcp_auth);
 
   /* 
@@ -2795 +4023 @@
    * result at auth_tag 
    */
-  status = auth_compute(stream->rtcp_auth, 
+  status = srtp_auth_compute(session_keys->rtcp_auth,
                         (uint8_t *)auth_start, 
                         (*pkt_octet_len) + sizeof(srtcp_trailer_t), 
                         auth_tag);
   debug_print(mod_srtp, "srtcp auth tag:    %s", 
-              octet_string_hex_string(auth_tag, tag_len));
+              srtp_octet_string_hex_string(auth_tag, tag_len));
   if (status)
-    return err_status_auth_fail;   
+    return srtp_err_status_auth_fail;   
     
   /* increase the packet length by the length of the auth tag and seq_num*/
   *pkt_octet_len += (tag_len + sizeof(srtcp_trailer_t));
+
+  /* increase the packet by the mki_size */
+  *pkt_octet_len += mki_size;
     
-  return err_status_ok;  
-}
-
-
-err_status_t 
+  return srtp_err_status_ok;  
+}
+
+
+srtp_err_status_t 
 srtp_unprotect_rtcp(srtp_t ctx, void *srtcp_hdr, int *pkt_octet_len) {
+    return srtp_unprotect_rtcp_mki(ctx, srtcp_hdr, pkt_octet_len, 0);
+}
+
+srtp_err_status_t
+srtp_unprotect_rtcp_mki(srtp_t ctx, void *srtcp_hdr, int *pkt_octet_len,
+                        unsigned int use_mki) {
   srtcp_hdr_t *hdr = (srtcp_hdr_t *)srtcp_hdr;
   uint32_t *enc_start;      /* pointer to start of encrypted portion  */
@@ -2821 +4058 @@
   uint8_t tmp_tag[SRTP_MAX_TAG_LEN];
   uint8_t tag_copy[SRTP_MAX_TAG_LEN];
-  err_status_t status;   
+  srtp_err_status_t status;   
   unsigned int auth_len;
   int tag_len;
   srtp_stream_ctx_t *stream;
-  int prefix_len;
+  uint32_t prefix_len;
   uint32_t seq_num;
   int e_bit_in_packet;     /* whether the E-bit was found in the packet */
   int sec_serv_confidentiality; /* whether confidentiality was requested */
+  unsigned int mki_size = 0;
+  srtp_session_keys_t *session_keys = NULL;
 
   /* we assume the hdr is 32-bit aligned to start */
@@ -2836 +4075 @@
      a positive value */
   if (*pkt_octet_len < octets_in_rtcp_header + sizeof(srtcp_trailer_t))
-    return err_status_bad_param;
+    return srtp_err_status_bad_param;
 
   /*
@@ -2867 +4106 @@
 
       debug_print(mod_srtp, "srtcp using provisional stream (SSRC: 0x%08x)", 
-                  hdr->ssrc);
+                  ntohl(hdr->ssrc));
     } else {
       /* no template stream, so we return an error */
-      return err_status_no_ctx;
+      return srtp_err_status_no_ctx;
     } 
   }
-  
+
+  /*
+   * Determine if MKI is being used and what session keys should be used
+   */
+  if (use_mki) {
+      session_keys = srtp_get_session_keys(stream, (uint8_t *)hdr,
+                                           (const unsigned int*)pkt_octet_len,
+                                           &mki_size);
+
+      if (session_keys == NULL) 
+         return srtp_err_status_bad_mki;
+  } else {
+      session_keys = &stream->session_keys[0];
+  }  
+
+
   /* get tag length from stream context */
-  tag_len = auth_get_tag_length(stream->rtcp_auth);
+  tag_len = srtp_auth_get_tag_length(session_keys->rtcp_auth);
 
   /* check the packet length - it must contain at least a full RTCP
      header, an auth tag (if applicable), and the SRTCP encrypted flag
      and 31-bit index value */
-  if (*pkt_octet_len < (int) (octets_in_rtcp_header + tag_len + sizeof(srtcp_trailer_t))) {
-    return err_status_bad_param;
+  if (*pkt_octet_len < (int) (octets_in_rtcp_header + tag_len + mki_size + sizeof(srtcp_trailer_t))) {
+    return srtp_err_status_bad_param;
   }
 
@@ -2888 +4142 @@
    * the request to our AEAD handler.
    */
-  if (stream->rtp_cipher->algorithm == AES_128_GCM ||
-      stream->rtp_cipher->algorithm == AES_256_GCM) {
-      return srtp_unprotect_rtcp_aead(ctx, stream, srtcp_hdr, (unsigned int*)pkt_octet_len);
+  if (session_keys->rtp_cipher->algorithm == SRTP_AES_GCM_128 ||
+      session_keys->rtp_cipher->algorithm == SRTP_AES_GCM_256) {
+      return srtp_unprotect_rtcp_aead(ctx, stream, srtcp_hdr,
+                                      (unsigned int*)pkt_octet_len, session_keys,
+                                      mki_size);
   }
 
@@ -2900 +4156 @@
    */
   enc_octet_len = *pkt_octet_len - 
-                  (octets_in_rtcp_header + tag_len + sizeof(srtcp_trailer_t));
+                  (octets_in_rtcp_header + tag_len + mki_size + sizeof(srtcp_trailer_t));
   /* index & E (encryption) bit follow normal data.  hdr->len
          is the number of words (32-bit) in the normal packet minus 1 */
@@ -2911 +4167 @@
    */
   trailer = (uint32_t *) ((char *) hdr +
-      *pkt_octet_len -(tag_len + sizeof(srtcp_trailer_t)));
+      *pkt_octet_len -(tag_len + mki_size + sizeof(srtcp_trailer_t)));
   e_bit_in_packet =
       (*((unsigned char *) trailer) & SRTCP_E_BYTE_BIT) == SRTCP_E_BYTE_BIT;
   if (e_bit_in_packet != sec_serv_confidentiality) {
-    return err_status_cant_check;
+    return srtp_err_status_cant_check;
   }
   if (sec_serv_confidentiality) {
@@ -2929 +4185 @@
    */
   auth_start = (uint32_t *)hdr;
-  auth_len = *pkt_octet_len - tag_len;
-  auth_tag = (uint8_t *)hdr + auth_len;
+
+  /*
+   * The location of the auth tag in the packet needs to know MKI 
+   * could be present.  The data needed to calculate the Auth tag
+   * must not include the MKI
+   */
+  auth_len = *pkt_octet_len - tag_len - mki_size;
+  auth_tag = (uint8_t *)hdr + auth_len + mki_size;
 
   /* 
@@ -2940 +4202 @@
    */
   if (stream->ekt) {
-    auth_tag -= ekt_octets_after_base_tag(stream->ekt);
+    auth_tag -= srtp_ekt_octets_after_base_tag(stream->ekt);
     memcpy(tag_copy, auth_tag, tag_len);
     octet_string_set_to_zero(auth_tag, tag_len);
@@ -2953 +4215 @@
   seq_num = ntohl(*trailer) & SRTCP_INDEX_MASK;
   debug_print(mod_srtp, "srtcp index: %x", seq_num);
-  status = rdb_check(&stream->rtcp_rdb, seq_num);
+  status = srtp_rdb_check(&stream->rtcp_rdb, seq_num);
   if (status)
     return status;
@@ -2960 +4222 @@
    * if we're using aes counter mode, set nonce and seq 
    */
-  if (stream->rtcp_cipher->type->id == AES_ICM) {
+  if (session_keys->rtcp_cipher->type->id == SRTP_AES_ICM_128 ||
+      session_keys->rtcp_cipher->type->id == SRTP_AES_ICM_192 ||
+      session_keys->rtcp_cipher->type->id == SRTP_AES_ICM_256) {
     v128_t iv;
 
@@ -2967 +4231 @@
     iv.v32[2] = htonl(seq_num >> 16);
     iv.v32[3] = htonl(seq_num << 16);
-    status = cipher_set_iv(stream->rtcp_cipher, &iv, direction_decrypt);
+    status = srtp_cipher_set_iv(session_keys->rtcp_cipher,
+                                (uint8_t*)&iv, srtp_direction_decrypt);
 
   } else {  
@@ -2977 +4242 @@
     iv.v32[2] = 0;
     iv.v32[3] = htonl(seq_num);
-    status = cipher_set_iv(stream->rtcp_cipher, &iv, direction_decrypt);
+    status = srtp_cipher_set_iv(session_keys->rtcp_cipher,
+                                (uint8_t*)&iv, srtp_direction_decrypt);
 
   }
   if (status)
-    return err_status_cipher_fail;
+    return srtp_err_status_cipher_fail;
 
   /* initialize auth func context */
-  auth_start(stream->rtcp_auth);
+  srtp_auth_start(session_keys->rtcp_auth);
 
   /* run auth func over packet, put result into tmp_tag */
-  status = auth_compute(stream->rtcp_auth, (uint8_t *)auth_start,  
+  status = srtp_auth_compute(session_keys->rtcp_auth, (uint8_t *)auth_start,
                         auth_len, tmp_tag);
   debug_print(mod_srtp, "srtcp computed tag:       %s", 
-              octet_string_hex_string(tmp_tag, tag_len));
+              srtp_octet_string_hex_string(tmp_tag, tag_len));
   if (status)
-    return err_status_auth_fail;   
+    return srtp_err_status_auth_fail;   
   
   /* compare the tag just computed with the one in the packet */
   debug_print(mod_srtp, "srtcp tag from packet:    %s", 
-              octet_string_hex_string(auth_tag, tag_len));  
+              srtp_octet_string_hex_string(auth_tag, tag_len));  
   if (octet_string_is_eq(tmp_tag, auth_tag, tag_len))
-    return err_status_auth_fail;
+    return srtp_err_status_auth_fail;
 
   /* 
@@ -3004 +4270 @@
    * prefix into the authentication tag
    */
-  prefix_len = auth_get_prefix_length(stream->rtcp_auth);    
+  prefix_len = srtp_auth_get_prefix_length(session_keys->rtcp_auth);    
   if (prefix_len) {
-    status = cipher_output(stream->rtcp_cipher, auth_tag, prefix_len);
+    status = srtp_cipher_output(session_keys->rtcp_cipher, auth_tag, &prefix_len);
     debug_print(mod_srtp, "keystream prefix: %s", 
-                octet_string_hex_string(auth_tag, prefix_len));
+                srtp_octet_string_hex_string(auth_tag, prefix_len));
     if (status)
-      return err_status_cipher_fail;
+      return srtp_err_status_cipher_fail;
   }
 
   /* if we're decrypting, exor keystream into the message */
   if (enc_start) {
-    status = cipher_decrypt(stream->rtcp_cipher, 
-                            (uint8_t *)enc_start, &enc_octet_len);
+    status = srtp_cipher_decrypt(session_keys->rtcp_cipher, (uint8_t *)enc_start,
+                                 &enc_octet_len);
     if (status)
-      return err_status_cipher_fail;
+      return srtp_err_status_cipher_fail;
   }
 
   /* decrease the packet length by the length of the auth tag and seq_num */
   *pkt_octet_len -= (tag_len + sizeof(srtcp_trailer_t));
+
+  /* decrease the packet length by the length of the mki_size */
+  *pkt_octet_len -= mki_size;
 
   /*
@@ -3028 +4297 @@
    * length
    */
-  *pkt_octet_len -= ekt_octets_after_base_tag(stream->ekt);
+  *pkt_octet_len -= srtp_ekt_octets_after_base_tag(stream->ekt);
 
   /* 
@@ -3076 +4345 @@
 
   /* we've passed the authentication check, so add seq_num to the rdb */
-  rdb_add_index(&stream->rtcp_rdb, seq_num);
+  srtp_rdb_add_index(&stream->rtcp_rdb, seq_num);
     
     
-  return err_status_ok;  
+  return srtp_err_status_ok;  
 }
 
@@ -3102 +4371 @@
  */
 
-err_status_t
-crypto_policy_set_from_profile_for_rtp(crypto_policy_t *policy, 
-                                       srtp_profile_t profile) {
+srtp_err_status_t
+srtp_crypto_policy_set_from_profile_for_rtp(srtp_crypto_policy_t *policy, 
+                                            srtp_profile_t profile) {
 
   /* set SRTP policy from the SRTP profile in the key set */
   switch(profile) {
   case srtp_profile_aes128_cm_sha1_80:
-    crypto_policy_set_aes_cm_128_hmac_sha1_80(policy);
+    srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(policy);
     break;
   case srtp_profile_aes128_cm_sha1_32:
-    crypto_policy_set_aes_cm_128_hmac_sha1_32(policy);
+    srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32(policy);
     break;
   case srtp_profile_null_sha1_80:
-    crypto_policy_set_null_cipher_hmac_sha1_80(policy);
+    srtp_crypto_policy_set_null_cipher_hmac_sha1_80(policy);
     break;
-  case srtp_profile_aes256_cm_sha1_80:
-    crypto_policy_set_aes_cm_256_hmac_sha1_80(policy);
+#if defined(OPENSSL)
+  case srtp_profile_aead_aes_128_gcm:
+    srtp_crypto_policy_set_aes_gcm_128_16_auth(policy);
     break;
-  case srtp_profile_aes256_cm_sha1_32:
-    crypto_policy_set_aes_cm_256_hmac_sha1_32(policy);
+  case srtp_profile_aead_aes_256_gcm:
+    srtp_crypto_policy_set_aes_gcm_256_16_auth(policy);
     break;
+#endif
     /* the following profiles are not (yet) supported */
   case srtp_profile_null_sha1_32:
   default:
-    return err_status_bad_param;
-  }
-
-  return err_status_ok;
-}
-
-err_status_t
-crypto_policy_set_from_profile_for_rtcp(crypto_policy_t *policy, 
-                                        srtp_profile_t profile) {
+    return srtp_err_status_bad_param;
+  }
+
+  return srtp_err_status_ok;
+}
+
+srtp_err_status_t
+srtp_crypto_policy_set_from_profile_for_rtcp(srtp_crypto_policy_t *policy, 
+                                             srtp_profile_t profile) {
 
   /* set SRTP policy from the SRTP profile in the key set */
   switch(profile) {
   case srtp_profile_aes128_cm_sha1_80:
-    crypto_policy_set_aes_cm_128_hmac_sha1_80(policy);
+    srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(policy);
     break;
   case srtp_profile_aes128_cm_sha1_32:
     /* We do not honor the 32-bit auth tag request since
      * this is not compliant with RFC 3711 */
-    crypto_policy_set_aes_cm_128_hmac_sha1_80(policy);
+    srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(policy);
     break;
   case srtp_profile_null_sha1_80:
-    crypto_policy_set_null_cipher_hmac_sha1_80(policy);
+    srtp_crypto_policy_set_null_cipher_hmac_sha1_80(policy);
     break;
-  case srtp_profile_aes256_cm_sha1_80:
-    crypto_policy_set_aes_cm_256_hmac_sha1_80(policy);
+#if defined(OPENSSL)
+  case srtp_profile_aead_aes_128_gcm:
+    srtp_crypto_policy_set_aes_gcm_128_16_auth(policy);
     break;
-  case srtp_profile_aes256_cm_sha1_32:
-    /* We do not honor the 32-bit auth tag request since
-     * this is not compliant with RFC 3711 */
-    crypto_policy_set_aes_cm_256_hmac_sha1_80(policy);
+  case srtp_profile_aead_aes_256_gcm:
+    srtp_crypto_policy_set_aes_gcm_256_16_auth(policy);
     break;
+#endif
     /* the following profiles are not (yet) supported */
   case srtp_profile_null_sha1_32:
   default:
-    return err_status_bad_param;
-  }
-
-  return err_status_ok;
-}
-
-void
-append_salt_to_key(uint8_t *key, unsigned int bytes_in_key,
-                   uint8_t *salt, unsigned int bytes_in_salt) {
-
+    return srtp_err_status_bad_param;
+  }
+
+  return srtp_err_status_ok;
+}
+
+void srtp_append_salt_to_key(uint8_t *key, unsigned int bytes_in_key, uint8_t *salt, unsigned int bytes_in_salt) {
   memcpy(key + bytes_in_key, salt, bytes_in_salt);
-
 }
 
@@ -3179 +4446 @@
   switch(profile) {
   case srtp_profile_aes128_cm_sha1_80:
-    return 16;
+    return SRTP_AES_128_KEY_LEN;
     break;
   case srtp_profile_aes128_cm_sha1_32:
-    return 16;
+    return SRTP_AES_128_KEY_LEN;
     break;
   case srtp_profile_null_sha1_80:
-    return 16;
+    return SRTP_AES_128_KEY_LEN;
     break;
-  case srtp_profile_aes256_cm_sha1_80:
-    return 32;
+  case srtp_profile_aead_aes_128_gcm:
+    return SRTP_AES_128_KEY_LEN;
     break;
-  case srtp_profile_aes256_cm_sha1_32:
-    return 32;
+  case srtp_profile_aead_aes_256_gcm:
+    return SRTP_AES_256_KEY_LEN;
     break;
     /* the following profiles are not (yet) supported */
@@ -3205 +4472 @@
   switch(profile) {
   case srtp_profile_aes128_cm_sha1_80:
-    return 14;
+    return SRTP_SALT_LEN;
     break;
   case srtp_profile_aes128_cm_sha1_32:
-    return 14;
+    return SRTP_SALT_LEN;
     break;
   case srtp_profile_null_sha1_80:
-    return 14;
+    return SRTP_SALT_LEN;
     break;
-  case srtp_profile_aes256_cm_sha1_80:
-    return 14;
+  case srtp_profile_aead_aes_128_gcm:
+    return SRTP_AEAD_SALT_LEN;
     break;
-  case srtp_profile_aes256_cm_sha1_32:
-    return 14;
+  case srtp_profile_aead_aes_256_gcm:
+    return SRTP_AEAD_SALT_LEN;
     break;
     /* the following profiles are not (yet) supported */
@@ -3225 +4492 @@
   }
 }
+
+srtp_err_status_t
+srtp_get_protect_trailer_length(srtp_t session,
+                                uint32_t use_mki,
+                                uint32_t mki_index,
+                                uint32_t *length) 
+{
+    srtp_stream_ctx_t *stream;
+
+    if (session == NULL)
+      return srtp_err_status_bad_param;
+
+    *length = 0;
+
+    /* Try obtaining stream from stream_list */
+    stream = session->stream_list;
+
+    if (stream == NULL) {
+        /* Try obtaining the template stream */
+        stream = session->stream_template;
+    }
+
+    if (stream == NULL) {
+        return srtp_err_status_bad_param;
+    }
+
+    if (use_mki) {
+       if (mki_index > stream->num_master_keys)
+           return srtp_err_status_bad_mki;
+
+       *length += stream->session_keys[mki_index].mki_size;
+       *length += srtp_auth_get_tag_length(stream->session_keys[mki_index].rtp_auth);
+    } else {
+       *length += srtp_auth_get_tag_length(stream->session_keys[0].rtp_auth);
+    }
+
+    return srtp_err_status_ok;
+}
+
+srtp_err_status_t
+srtp_get_protect_rtcp_trailer_length(srtp_t session,
+                                     uint32_t use_mki,
+                                     uint32_t mki_index,
+                                     uint32_t *length) 
+{
+    srtp_stream_ctx_t *stream;
+
+    if (session == NULL)
+      return srtp_err_status_bad_param;
+
+    *length = 0;
+
+    /* Try obtaining stream from stream_list */
+    stream = session->stream_list;
+
+    if (stream == NULL) {
+        /* Try obtaining the template stream */
+        stream = session->stream_template;
+    }
+
+    if (stream == NULL) {
+        return srtp_err_status_bad_param;
+    }
+
+    if (use_mki) {
+       if (mki_index > stream->num_master_keys)
+           return srtp_err_status_bad_mki;
+
+       *length += stream->session_keys[mki_index].mki_size;
+       *length += srtp_auth_get_tag_length(stream->session_keys[mki_index].rtcp_auth);
+    } else {
+       *length += srtp_auth_get_tag_length(stream->session_keys[0].rtcp_auth);
+    }
+ 
+    *length += sizeof(srtcp_trailer_t);
+
+    return srtp_err_status_ok;
+}
+
+
+/*
+ * SRTP debug interface
+ */
+srtp_err_status_t srtp_set_debug_module(const char *mod_name, int v)
+{
+    return srtp_crypto_kernel_set_debug_module(mod_name, v);
+}
+
+srtp_err_status_t srtp_list_debug_modules(void)
+{
+    return srtp_crypto_kernel_list_debug_modules();
+}
+
+/*
+ * srtp_log_handler is a global variable holding a pointer to the
+ * log handler function; this function is called for any log
+ * output.
+ */
+
+static srtp_log_handler_func_t *srtp_log_handler = NULL;
+static void * srtp_log_handler_data = NULL;
+
+void srtp_err_handler(srtp_err_reporting_level_t level, const char * msg)
+{
+    if (srtp_log_handler) {
+        srtp_log_level_t log_level = srtp_log_level_error;
+        switch(level) {
+            case srtp_err_level_error: log_level = srtp_log_level_error; break;
+            case srtp_err_level_warning: log_level = srtp_log_level_warning; break;
+            case srtp_err_level_info: log_level = srtp_log_level_info; break;
+            case srtp_err_level_debug: log_level = srtp_log_level_debug; break;
+        }
+
+        srtp_log_handler(log_level, msg, srtp_log_handler_data);
+    }
+}
+
+srtp_err_status_t srtp_install_log_handler(srtp_log_handler_func_t func, void * data)
+{
+
+    /*
+     * note that we accept NULL arguments intentionally - calling this
+     * function with a NULL arguments removes a log handler that's
+     * been previously installed
+     */
+
+    if (srtp_log_handler) {
+        srtp_install_err_report_handler(NULL);
+    }
+    srtp_log_handler = func;
+    srtp_log_handler_data = data;
+    if (srtp_log_handler) {
+        srtp_install_err_report_handler(srtp_err_handler);
+    }
+    return srtp_err_status_ok;
+}
+
+srtp_err_status_t
+srtp_set_stream_roc(srtp_t session, uint32_t ssrc, uint32_t roc) {
+    srtp_stream_t stream;
+
+    stream = srtp_get_stream(session, htonl(ssrc));
+    if (stream == NULL)
+        return srtp_err_status_bad_param;
+
+    stream->pending_roc = roc;
+
+    return srtp_err_status_ok;
+}
+
+srtp_err_status_t
+srtp_get_stream_roc(srtp_t session, uint32_t ssrc, uint32_t *roc) {
+    srtp_stream_t stream;
+
+    stream = srtp_get_stream(session, htonl(ssrc));
+    if (stream == NULL)
+        return srtp_err_status_bad_param;
+
+    *roc = srtp_rdbx_get_roc(&stream->rtp_rdbx);
+
+    return srtp_err_status_ok;
+}