res_srtp: Move SDP SRTP code from the core to res_srtp.
authorRichard Mudgett <rmudgett@digium.com>
Mon, 8 Aug 2016 19:50:53 +0000 (14:50 -0500)
committerRichard Mudgett <rmudgett@digium.com>
Wed, 10 Aug 2016 22:43:15 +0000 (17:43 -0500)
A patch made to the master branch (Now the 14 branch) inadvertently made
libsrtp a required dependency in order to compile Asterisk.  Rather than
create dummy defines to substitute for the defines supplied by libsrtp
when libsrtp is not available, most of the code in sdp_srtp.c is moved
into res_srtp.c.  This gets more code out of Asterisk's core that isn't
used when SRTP is not available.  This also makes another inadvertent
required dependency on libsrtp by Asterisk's core unlikely.

ASTERISK-26253 #close
Reported by: Ben Merrills

Change-Id: I0a46cde81501c0405399c2588633ae32706d1ee7

include/asterisk/sdp_srtp.h
main/sdp_srtp.c
res/res_srtp.c

index 5d8f0e7..cf89fa9 100644 (file)
@@ -63,6 +63,100 @@ struct ast_sdp_srtp *ast_sdp_srtp_alloc(void);
 */
 void ast_sdp_srtp_destroy(struct ast_sdp_srtp *srtp);
 
+/*! \brief Destroy a previously allocated ast_sdp_crypto struct */
+typedef void (*sdp_crypto_destroy_cb)(struct ast_sdp_crypto *crypto);
+
+/*!
+ * \brief Initialize and return an ast_sdp_crypto struct
+ *
+ * \details
+ * This function allocates a new ast_sdp_crypto struct and initializes its values
+ *
+ * \retval NULL on failure
+ * \retval a pointer to a  new ast_sdp_crypto structure
+ */
+typedef struct ast_sdp_crypto *(*sdp_crypto_alloc_cb)(void);
+
+/*!
+ * \brief Generate an SRTP a=crypto offer
+ *
+ * \details
+ * The offer is stored on the ast_sdp_crypto struct in a_crypto
+ *
+ * \param crypto A valid ast_sdp_crypto struct
+ * \param taglen Length
+ *
+ * \retval 0 success
+ * \retval nonzero failure
+ */
+typedef int (*sdp_crypto_build_offer_cb)(struct ast_sdp_crypto *crypto, int taglen);
+
+/*!
+ * \brief Parse the a=crypto line from SDP and set appropriate values on the
+ * ast_sdp_crypto struct.
+ *
+ * The attribute line should already have "a=crypto:" removed.
+ *
+ * \param p A valid ast_sdp_crypto struct
+ * \param attr the a:crypto line from SDP
+ * \param rtp The rtp instance associated with the SDP being parsed
+ * \param srtp SRTP structure
+ *
+ * \retval 0 success
+ * \retval nonzero failure
+ */
+typedef int (*sdp_crypto_parse_offer_cb)(struct ast_rtp_instance *rtp, struct ast_sdp_srtp *srtp, const char *attr);
+
+/*!
+ * \brief Get the crypto attribute line for the srtp structure
+ *
+ * \details
+ * The attribute line does not contain the initial "a=crypto:" and does
+ * not terminate with "\r\n".
+ *
+ * \param srtp The ast_sdp_srtp structure for which to get an attribute line
+ * \param dtls_enabled Whether this connection is encrypted with datagram TLS
+ * \param default_taglen_32 Whether to default to a tag length of 32 instead of 80
+ *
+ * \retval An attribute line containing cryptographic information
+ * \retval NULL if the srtp structure does not require an attribute line containing crypto information
+ */
+typedef const char *(*sdp_srtp_get_attr_cb)(struct ast_sdp_srtp *srtp, int dtls_enabled, int default_taglen_32);
+
+struct ast_sdp_crypto_api {
+       /*! Destroy a crypto struct */
+       sdp_crypto_destroy_cb dtor;
+       /*! Allocate a crypto struct */
+       sdp_crypto_alloc_cb alloc;
+       /*! Build a SDP a=crypto offer line parameter string */
+       sdp_crypto_build_offer_cb build_offer;
+       /*! Parse a SDP a=crypto offer line parameter string */
+       sdp_crypto_parse_offer_cb parse_offer;
+       /*! Get the SDP a=crypto offer line parameter string */
+       sdp_srtp_get_attr_cb get_attr;
+};
+
+/*!
+ * \brief Register SDP SRTP crypto processing routines.
+ * \since 14.0.0
+ *
+ * \param api Callbacks to register.
+ *
+ * \retval 0 on success.
+ * \retval -1 on error.
+ */
+int ast_sdp_crypto_register(struct ast_sdp_crypto_api *api);
+
+/*!
+ * \brief Unregister SDP SRTP crypto processing routines.
+ * \since 14.0.0
+ *
+ * \param api Callbacks to unregister.
+ *
+ * \return Nothing
+ */
+void ast_sdp_crypto_unregister(struct ast_sdp_crypto_api *api);
+
 /*! \brief Initialize an return an ast_sdp_crypto struct
  *
  * \details
@@ -104,7 +198,6 @@ int ast_sdp_crypto_process(struct ast_rtp_instance *rtp, struct ast_sdp_srtp *sr
  */
 int ast_sdp_crypto_build_offer(struct ast_sdp_crypto *p, int taglen);
 
-
 /*! \brief Get the crypto attribute line for the srtp structure
  *
  * The attribute line does not contain the initial "a=crypto:" and does
index a55aedf..940a619 100644 (file)
 
 ASTERISK_REGISTER_FILE()
 
-#include <math.h>                       /* for pow */
-#include <srtp/srtp.h>                  /* for SRTP_MAX_KEY_LEN, etc */
-
 #include "asterisk/linkedlists.h"       /* for AST_LIST_NEXT, etc */
 #include "asterisk/logger.h"            /* for ast_log, LOG_ERROR, etc */
-#include "asterisk/rtp_engine.h"        /* for ast_rtp_engine_dtls, etc */
 #include "asterisk/sdp_srtp.h"          /* for ast_sdp_srtp, etc */
-#include "asterisk/strings.h"           /* for ast_strlen_zero */
-#include "asterisk/utils.h"             /* for ast_set_flag, ast_test_flag, etc */
 
-extern struct ast_srtp_res *res_srtp;
-extern struct ast_srtp_policy_res *res_srtp_policy;
+/*! Registered SDP crypto API */
+static struct ast_sdp_crypto_api *sdp_crypto_api;
 
 struct ast_sdp_srtp *ast_sdp_srtp_alloc(void)
 {
@@ -63,603 +57,49 @@ void ast_sdp_srtp_destroy(struct ast_sdp_srtp *srtp)
        for (next = AST_LIST_NEXT(srtp, sdp_srtp_list);
             srtp;
             srtp = next, next = srtp ? AST_LIST_NEXT(srtp, sdp_srtp_list) : NULL) {
-               if (srtp->crypto) {
-                       ast_sdp_crypto_destroy(srtp->crypto);
-               }
+               ast_sdp_crypto_destroy(srtp->crypto);
                srtp->crypto = NULL;
                ast_free(srtp);
        }
 }
 
-struct ast_sdp_crypto {
-       char *a_crypto;
-       unsigned char local_key[SRTP_MAX_KEY_LEN];
-       int tag;
-       char local_key64[((SRTP_MAX_KEY_LEN) * 8 + 5) / 6 + 1];
-       unsigned char remote_key[SRTP_MAX_KEY_LEN];
-       int key_len;
-};
-
-static struct ast_sdp_crypto *sdp_crypto_alloc(const int key_len);
-static struct ast_sdp_crypto *crypto_init_keys(struct ast_sdp_crypto *p, const int key_len);
-static int set_crypto_policy(struct ast_srtp_policy *policy, int suite_val, const unsigned char *master_key, int key_len, unsigned long ssrc, int inbound);
-
 void ast_sdp_crypto_destroy(struct ast_sdp_crypto *crypto)
 {
-       ast_free(crypto->a_crypto);
-       crypto->a_crypto = NULL;
-       ast_free(crypto);
-}
-
-static struct ast_sdp_crypto *crypto_init_keys(struct ast_sdp_crypto *p, const int key_len)
-{
-       unsigned char remote_key[key_len];
-
-       if (res_srtp->get_random(p->local_key, key_len) < 0) {
-               return NULL;
-       }
-
-       ast_base64encode(p->local_key64, p->local_key, key_len, sizeof(p->local_key64));
-
-       p->key_len = ast_base64decode(remote_key, p->local_key64, sizeof(remote_key));
-
-       if (p->key_len != key_len) {
-               ast_log(LOG_ERROR, "base64 encode/decode bad len %d != %d\n", p->key_len, key_len);
-               return NULL;
-       }
-
-       if (memcmp(remote_key, p->local_key, p->key_len)) {
-               ast_log(LOG_ERROR, "base64 encode/decode bad key\n");
-               return NULL;
-       }
-
-       ast_debug(1 , "local_key64 %s len %zu\n", p->local_key64, strlen(p->local_key64));
-
-       return p;
-}
-
-static struct ast_sdp_crypto *sdp_crypto_alloc(const int key_len)
-{
-       struct ast_sdp_crypto *p, *result;
-
-       if (!ast_rtp_engine_srtp_is_registered()) {
-               return NULL;
-       }
-
-       if (!(p = ast_calloc(1, sizeof(*p)))) {
-               return NULL;
+       if (sdp_crypto_api) {
+               sdp_crypto_api->dtor(crypto);
        }
-       p->tag = 1;
-
-       /* default is a key which uses AST_AES_CM_128_HMAC_SHA1_xx */
-       result = crypto_init_keys(p, key_len);
-       if (!result) {
-               ast_sdp_crypto_destroy(p);
-       }
-
-       return result;
 }
 
 struct ast_sdp_crypto *ast_sdp_crypto_alloc(void)
 {
-       return sdp_crypto_alloc(SRTP_MASTER_KEY_LEN);
-}
-
-static int set_crypto_policy(struct ast_srtp_policy *policy, int suite_val, const unsigned char *master_key, int key_len, unsigned long ssrc, int inbound)
-{
-       if (!ast_rtp_engine_srtp_is_registered()) {
-               return -1;
-       }
-
-       if (res_srtp_policy->set_master_key(policy, master_key, key_len, NULL, 0) < 0) {
-               return -1;
-       }
-
-       if (res_srtp_policy->set_suite(policy, suite_val)) {
-               ast_log(LOG_WARNING, "Could not set remote SRTP suite\n");
-               return -1;
-       }
-
-       res_srtp_policy->set_ssrc(policy, ssrc, inbound);
-
-       return 0;
-}
-
-static int crypto_activate(struct ast_sdp_crypto *p, int suite_val, unsigned char *remote_key, int key_len, struct ast_rtp_instance *rtp)
-{
-       struct ast_srtp_policy *local_policy = NULL;
-       struct ast_srtp_policy *remote_policy = NULL;
-       struct ast_rtp_instance_stats stats = {0,};
-       int res = -1;
-
-       if (!ast_rtp_engine_srtp_is_registered()) {
-               return -1;
-       }
-
-       if (!p) {
-               return -1;
-       }
-
-       if (!(local_policy = res_srtp_policy->alloc())) {
-               return -1;
-       }
-
-       if (!(remote_policy = res_srtp_policy->alloc())) {
-               goto err;
-       }
-
-       if (ast_rtp_instance_get_stats(rtp, &stats, AST_RTP_INSTANCE_STAT_LOCAL_SSRC)) {
-               goto err;
-       }
-
-       if (set_crypto_policy(local_policy, suite_val, p->local_key, key_len, stats.local_ssrc, 0) < 0) {
-               goto err;
-       }
-
-       if (set_crypto_policy(remote_policy, suite_val, remote_key, key_len, 0, 1) < 0) {
-               goto err;
-       }
-
-       /* Add the SRTP policies */
-       if (ast_rtp_instance_add_srtp_policy(rtp, remote_policy, local_policy, 0)) {
-               ast_log(LOG_WARNING, "Could not set SRTP policies\n");
-               goto err;
-       }
-
-       ast_debug(1 , "SRTP policy activated\n");
-       res = 0;
-
-err:
-       if (local_policy) {
-               res_srtp_policy->destroy(local_policy);
-       }
-
-       if (remote_policy) {
-               res_srtp_policy->destroy(remote_policy);
+       if (!sdp_crypto_api) {
+               return NULL;
        }
-
-       return res;
+       return sdp_crypto_api->alloc();
 }
 
 int ast_sdp_crypto_process(struct ast_rtp_instance *rtp, struct ast_sdp_srtp *srtp, const char *attr)
 {
-       char *str = NULL;
-       char *tag = NULL;
-       char *suite = NULL;
-       char *key_params = NULL;
-       char *key_param = NULL;
-       char *session_params = NULL;
-       char *key_salt = NULL;       /* The actual master key and key salt */
-       char *lifetime = NULL;       /* Key lifetime (# of RTP packets) */
-       char *mki = NULL;            /* Master Key Index */
-       int found = 0;
-       int key_len_from_sdp;
-       int key_len_expected;
-       int tag_from_sdp;
-       int suite_val = 0;
-       unsigned char remote_key[SRTP_MAX_KEY_LEN];
-       int taglen;
-       double sdes_lifetime;
-       struct ast_sdp_crypto *crypto;
-       struct ast_sdp_srtp *tmp;
-
-       if (!ast_rtp_engine_srtp_is_registered()) {
+       if (!sdp_crypto_api) {
                return -1;
        }
-
-       str = ast_strdupa(attr);
-
-       tag = strsep(&str, " ");
-       suite = strsep(&str, " ");
-       key_params = strsep(&str, " ");
-       session_params = strsep(&str, " ");
-
-       if (!tag || !suite) {
-               ast_log(LOG_WARNING, "Unrecognized crypto attribute a=%s\n", attr);
-               return -1;
-       }
-
-       /* RFC4568 9.1 - tag is 1-9 digits, greater than zero */
-       if (sscanf(tag, "%30d", &tag_from_sdp) != 1 || tag_from_sdp <= 0 || tag_from_sdp > 999999999) {
-               ast_log(LOG_WARNING, "Unacceptable a=crypto tag: %s\n", tag);
-               return -1;
-       }
-
-       if (!ast_strlen_zero(session_params)) {
-               ast_log(LOG_WARNING, "Unsupported crypto parameters: %s\n", session_params);
-               return -1;
-       }
-
-       /* On egress, Asterisk sent several crypto lines in the SIP/SDP offer
-          The remote party might have choosen another line than the first */
-       for (tmp = srtp; tmp && tmp->crypto && tmp->crypto->tag != tag_from_sdp;) {
-               tmp = AST_LIST_NEXT(tmp, sdp_srtp_list);
-       }
-       if (tmp) { /* tag matched an already created crypto line */
-               unsigned int flags = tmp->flags;
-
-               /* Make that crypto line the head of the list, not by changing the
-                  list structure but by exchanging the content of the list members */
-               crypto = tmp->crypto;
-               tmp->crypto = srtp->crypto;
-               tmp->flags = srtp->flags;
-               srtp->crypto = crypto;
-               srtp->flags = flags;
-       } else {
-               crypto = srtp->crypto;
-               crypto->tag = tag_from_sdp;
-       }
-
-       if (!strcmp(suite, "AES_CM_128_HMAC_SHA1_80")) {
-               suite_val = AST_AES_CM_128_HMAC_SHA1_80;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_80);
-               key_len_expected = 30;
-       } else if (!strcmp(suite, "AES_CM_128_HMAC_SHA1_32")) {
-               suite_val = AST_AES_CM_128_HMAC_SHA1_32;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_32);
-               key_len_expected = 30;
-#ifdef HAVE_SRTP_192
-       } else if (!strcmp(suite, "AES_192_CM_HMAC_SHA1_80")) {
-               suite_val = AST_AES_CM_192_HMAC_SHA1_80;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_80);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_192);
-               key_len_expected = 38;
-       } else if (!strcmp(suite, "AES_192_CM_HMAC_SHA1_32")) {
-               suite_val = AST_AES_CM_192_HMAC_SHA1_32;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_32);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_192);
-               key_len_expected = 38;
-       /* RFC used a different name while in draft, some still use that */
-       } else if (!strcmp(suite, "AES_CM_192_HMAC_SHA1_80")) {
-               suite_val = AST_AES_CM_192_HMAC_SHA1_80;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_80);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_192);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_OLD_NAME);
-               key_len_expected = 38;
-       } else if (!strcmp(suite, "AES_CM_192_HMAC_SHA1_32")) {
-               suite_val = AST_AES_CM_192_HMAC_SHA1_32;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_32);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_192);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_OLD_NAME);
-               key_len_expected = 38;
-#endif
-#ifdef HAVE_SRTP_256
-       } else if (!strcmp(suite, "AES_256_CM_HMAC_SHA1_80")) {
-               suite_val = AST_AES_CM_256_HMAC_SHA1_80;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_80);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_256);
-               key_len_expected = 46;
-       } else if (!strcmp(suite, "AES_256_CM_HMAC_SHA1_32")) {
-               suite_val = AST_AES_CM_256_HMAC_SHA1_32;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_32);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_256);
-               key_len_expected = 46;
-       /* RFC used a different name while in draft, some still use that */
-       } else if (!strcmp(suite, "AES_CM_256_HMAC_SHA1_80")) {
-               suite_val = AST_AES_CM_256_HMAC_SHA1_80;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_80);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_256);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_OLD_NAME);
-               key_len_expected = 46;
-       } else if (!strcmp(suite, "AES_CM_256_HMAC_SHA1_32")) {
-               suite_val = AST_AES_CM_256_HMAC_SHA1_32;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_32);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_256);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_OLD_NAME);
-               key_len_expected = 46;
-#endif
-#ifdef HAVE_SRTP_GCM
-       } else if (!strcmp(suite, "AEAD_AES_128_GCM")) {
-               suite_val = AST_AES_GCM_128;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_16);
-               key_len_expected = AES_128_GCM_KEYSIZE_WSALT;
-       } else if (!strcmp(suite, "AEAD_AES_256_GCM")) {
-               suite_val = AST_AES_GCM_256;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_16);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_256);
-               key_len_expected = AES_256_GCM_KEYSIZE_WSALT;
-       /* RFC contained a (too) short auth tag for RTP media, some still use that */
-       } else if (!strcmp(suite, "AEAD_AES_128_GCM_8")) {
-               suite_val = AST_AES_GCM_128_8;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_8);
-               key_len_expected = AES_128_GCM_KEYSIZE_WSALT;
-       } else if (!strcmp(suite, "AEAD_AES_256_GCM_8")) {
-               suite_val = AST_AES_GCM_256_8;
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_8);
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_256);
-               key_len_expected = AES_256_GCM_KEYSIZE_WSALT;
-#endif
-       } else {
-               ast_verb(1, "Unsupported crypto suite: %s\n", suite);
-               return -1;
-       }
-
-       while ((key_param = strsep(&key_params, ";"))) {
-               unsigned int n_lifetime;
-               char *method = NULL;
-               char *info = NULL;
-
-               method = strsep(&key_param, ":");
-               info = strsep(&key_param, ";");
-               sdes_lifetime = 0;
-
-               if (strcmp(method, "inline")) {
-                       continue;
-               }
-
-               key_salt = strsep(&info, "|");
-
-               /* The next parameter can be either lifetime or MKI */
-               lifetime = strsep(&info, "|");
-               if (!lifetime) {
-                       found = 1;
-                       break;
-               }
-
-               mki = strchr(lifetime, ':');
-               if (mki) {
-                       mki = lifetime;
-                       lifetime = NULL;
-               } else {
-                       mki = strsep(&info, "|");
-               }
-
-               if (mki && *mki != '1') {
-                       ast_log(LOG_NOTICE, "Crypto MKI handling is not supported: ignoring attribute %s\n", attr);
-                       continue;
-               }
-
-               if (lifetime) {
-                       if (!strncmp(lifetime, "2^", 2)) {
-                               char *lifetime_val = lifetime + 2;
-
-                               /* Exponential lifetime */
-                               if (sscanf(lifetime_val, "%30u", &n_lifetime) != 1) {
-                                       ast_log(LOG_NOTICE, "Failed to parse lifetime value in crypto attribute: %s\n", attr);
-                                       continue;
-                               }
-
-                               if (n_lifetime > 48) {
-                                       /* Yeah... that's a bit big. */
-                                       ast_log(LOG_NOTICE, "Crypto lifetime exponent of '%u' is a bit large; using 48\n", n_lifetime);
-                                       n_lifetime = 48;
-                               }
-                               sdes_lifetime = pow(2, n_lifetime);
-                       } else {
-                               /* Decimal lifetime */
-                               if (sscanf(lifetime, "%30u", &n_lifetime) != 1) {
-                                       ast_log(LOG_NOTICE, "Failed to parse lifetime value in crypto attribute: %s\n", attr);
-                                       continue;
-                               }
-                               sdes_lifetime = n_lifetime;
-                       }
-
-                       /* Accept anything above 10 hours. Less than 10; reject. */
-                       if (sdes_lifetime < 1800000) {
-                               ast_log(LOG_NOTICE, "Rejecting crypto attribute '%s': lifetime '%f' too short\n", attr, sdes_lifetime);
-                               continue;
-                       }
-               }
-
-               ast_debug(2, "Crypto attribute '%s' accepted with lifetime '%f', MKI '%s'\n",
-                       attr, sdes_lifetime, mki ? mki : "-");
-
-               found = 1;
-               break;
-       }
-
-       if (!found) {
-               ast_log(LOG_NOTICE, "SRTP crypto offer not acceptable: '%s'\n", attr);
-               return -1;
-       }
-
-       key_len_from_sdp = ast_base64decode(remote_key, key_salt, sizeof(remote_key));
-       if (key_len_from_sdp != key_len_expected) {
-               ast_log(LOG_WARNING, "SRTP descriptions key length is '%d', not '%d'\n",
-                       key_len_from_sdp, key_len_expected);
-               return -1;
-       }
-
-       /* on default, the key is 30 (AES-128); throw that away (only) when the suite changed actually */
-       /* ingress: optional, but saves one expensive call to get_random(.) */
-       /*  egress: required, because the local key was communicated before the remote key is processed */
-       if (crypto->key_len != key_len_from_sdp) {
-               if (!crypto_init_keys(crypto, key_len_from_sdp)) {
-                       return -1;
-               }
-       } else if (!memcmp(crypto->remote_key, remote_key, key_len_from_sdp)) {
-               ast_debug(1, "SRTP remote key unchanged; maintaining current policy\n");
-               ast_set_flag(srtp, AST_SRTP_CRYPTO_OFFER_OK);
-               return 0;
-       }
-
-       if (key_len_from_sdp > sizeof(crypto->remote_key)) {
-               ast_log(LOG_ERROR,
-                       "SRTP key buffer is %zu although it must be at least %d bytes\n",
-                       sizeof(crypto->remote_key), key_len_from_sdp);
-               return -1;
-       }
-       memcpy(crypto->remote_key, remote_key, key_len_from_sdp);
-
-       if (crypto_activate(crypto, suite_val, remote_key, key_len_from_sdp, rtp) < 0) {
-               return -1;
-       }
-
-       if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_32)) {
-               taglen = 32;
-       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_16)) {
-               taglen = 16;
-       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_8)) {
-               taglen = 8;
-       } else {
-               taglen = 80;
-       }
-       if (ast_test_flag(srtp, AST_SRTP_CRYPTO_AES_256)) {
-               taglen |= 0x0200;
-       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_AES_192)) {
-               taglen |= 0x0100;
-       }
-       if (ast_test_flag(srtp, AST_SRTP_CRYPTO_OLD_NAME)) {
-               taglen |= 0x0080;
-       }
-
-       /* Finally, rebuild the crypto line */
-       if (ast_sdp_crypto_build_offer(crypto, taglen)) {
-               return -1;
-       }
-
-       ast_set_flag(srtp, AST_SRTP_CRYPTO_OFFER_OK);
-       return 0;
+       return sdp_crypto_api->parse_offer(rtp, srtp, attr);
 }
 
 int ast_sdp_crypto_build_offer(struct ast_sdp_crypto *p, int taglen)
 {
-       /* Rebuild the crypto line */
-       if (p->a_crypto) {
-               ast_free(p->a_crypto);
-       }
-
-       if ((taglen & 0x007f) == 8) {
-               if (ast_asprintf(&p->a_crypto, "%d AEAD_AES_%d_GCM_%d inline:%s",
-                                p->tag, 128 + ((taglen & 0x0300) >> 2), taglen & 0x007f, p->local_key64) == -1) {
-                                ast_log(LOG_ERROR, "Could not allocate memory for crypto line\n");
-                       return -1;
-               }
-       } else if ((taglen & 0x007f) == 16) {
-               if (ast_asprintf(&p->a_crypto, "%d AEAD_AES_%d_GCM inline:%s",
-                                p->tag, 128 + ((taglen & 0x0300) >> 2), p->local_key64) == -1) {
-                                ast_log(LOG_ERROR, "Could not allocate memory for crypto line\n");
-                       return -1;
-               }
-       } else if ((taglen & 0x0300) && !(taglen & 0x0080)) {
-               if (ast_asprintf(&p->a_crypto, "%d AES_%d_CM_HMAC_SHA1_%d inline:%s",
-                                p->tag, 128 + ((taglen & 0x0300) >> 2), taglen & 0x007f, p->local_key64) == -1) {
-                                ast_log(LOG_ERROR, "Could not allocate memory for crypto line\n");
-                       return -1;
-               }
-       } else {
-               if (ast_asprintf(&p->a_crypto, "%d AES_CM_%d_HMAC_SHA1_%d inline:%s",
-                                p->tag, 128 + ((taglen & 0x0300) >> 2), taglen & 0x007f, p->local_key64) == -1) {
-                                ast_log(LOG_ERROR, "Could not allocate memory for crypto line\n");
-                       return -1;
-               }
+       if (!sdp_crypto_api) {
+               return -1;
        }
-
-       ast_debug(1, "Crypto line: a=crypto:%s\n", p->a_crypto);
-
-       return 0;
+       return sdp_crypto_api->build_offer(p, taglen);
 }
 
 const char *ast_sdp_srtp_get_attrib(struct ast_sdp_srtp *srtp, int dtls_enabled, int default_taglen_32)
 {
-       int taglen;
-
-       if (!srtp) {
+       if (!sdp_crypto_api) {
                return NULL;
        }
-
-       /* Set encryption properties */
-       if (!srtp->crypto) {
-
-               if (AST_LIST_NEXT(srtp, sdp_srtp_list)) {
-                       srtp->crypto = ast_sdp_crypto_alloc();
-                       ast_log(LOG_ERROR, "SRTP SDP list was not empty\n");
-               } else {
-                       const int len = default_taglen_32 ? AST_SRTP_CRYPTO_TAG_32 : AST_SRTP_CRYPTO_TAG_80;
-                       const int attr[][3] = {
-                       /* This array creates the following list:
-                        * a=crypto:1 AES_CM_128_HMAC_SHA1_ ...
-                        * a=crypto:2 AEAD_AES_128_GCM ...
-                        * a=crypto:3 AES_256_CM_HMAC_SHA1_ ...
-                        * a=crypto:4 AEAD_AES_256_GCM ...
-                        * a=crypto:5 AES_192_CM_HMAC_SHA1_ ...
-                        * something like 'AEAD_AES_192_GCM' is not specified by the RFCs
-                        *
-                        * If you want to prefer another crypto suite or you want to
-                        * exclude a suite, change this array and recompile Asterisk.
-                        * This list cannot be changed from rtp.conf because you should
-                        * know what you are doing. Especially AES-192 and AES-GCM are
-                        * broken in many VoIP clients, see
-                        * https://github.com/cisco/libsrtp/pull/170
-                        * https://github.com/cisco/libsrtp/pull/184
-                        * Furthermore, AES-GCM uses a shorter crypto-suite string which
-                        * causes Nokia phones based on Symbian/S60 to reject the whole
-                        * INVITE with status 500, even if a matching suite was offered.
-                        * AES-256 might just waste your processor cycles, especially if
-                        * your TLS transport is not secured with equivalent grade, see
-                        * https://security.stackexchange.com/q/61361
-                        * Therefore, AES-128 was preferred here.
-                        *
-                        * If you want to enable one of those defines, please, go for
-                        * CFLAGS='-DENABLE_SRTP_AES_GCM' ./configure && sudo make install
-                        */
-                               { len, 0, 30 },
-#if defined(HAVE_SRTP_GCM) && defined(ENABLE_SRTP_AES_GCM)
-                               { AST_SRTP_CRYPTO_TAG_16, 0, AES_128_GCM_KEYSIZE_WSALT },
-#endif
-#if defined(HAVE_SRTP_256) && defined(ENABLE_SRTP_AES_256)
-                               { len, AST_SRTP_CRYPTO_AES_256, 46 },
-#endif
-#if defined(HAVE_SRTP_GCM) && defined(ENABLE_SRTP_AES_GCM) && defined(ENABLE_SRTP_AES_256)
-                               { AST_SRTP_CRYPTO_TAG_16, AST_SRTP_CRYPTO_AES_256, AES_256_GCM_KEYSIZE_WSALT },
-#endif
-#if defined(HAVE_SRTP_192) && defined(ENABLE_SRTP_AES_192)
-                               { len, AST_SRTP_CRYPTO_AES_192, 38 },
-#endif
-                       };
-                       struct ast_sdp_srtp *tmp = srtp;
-                       int i;
-
-                       for (i = 0; i < ARRAY_LEN(attr); i++) {
-                               if (attr[i][0]) {
-                                       ast_set_flag(tmp, attr[i][0]);
-                               }
-                               if (attr[i][1]) {
-                                       ast_set_flag(tmp, attr[i][1]);
-                               }
-                               tmp->crypto = sdp_crypto_alloc(attr[i][2]); /* key_len */
-                               tmp->crypto->tag = (i + 1); /* tag starts at 1 */
-
-                               if (i < ARRAY_LEN(attr) - 1) {
-                                       AST_LIST_NEXT(tmp, sdp_srtp_list) = ast_sdp_srtp_alloc();
-                                       tmp = AST_LIST_NEXT(tmp, sdp_srtp_list);
-                               }
-                       }
-               }
-       }
-
-       if (dtls_enabled) {
-               /* If DTLS-SRTP is enabled the key details will be pulled from TLS */
-               return NULL;
-       }
-
-       /* set the key length based on INVITE or settings */
-       if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_80)) {
-               taglen = 80;
-       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_32)) {
-               taglen = 32;
-       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_16)) {
-               taglen = 16;
-       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_8)) {
-               taglen = 8;
-       } else {
-               taglen = default_taglen_32 ? 32 : 80;
-       }
-       if (ast_test_flag(srtp, AST_SRTP_CRYPTO_AES_256)) {
-               taglen |= 0x0200;
-       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_AES_192)) {
-               taglen |= 0x0100;
-       }
-       if (ast_test_flag(srtp, AST_SRTP_CRYPTO_OLD_NAME)) {
-               taglen |= 0x0080;
-       }
-
-       if (srtp->crypto && (ast_sdp_crypto_build_offer(srtp->crypto, taglen) >= 0)) {
-               return srtp->crypto->a_crypto;
-       }
-
-       ast_log(LOG_WARNING, "No SRTP key management enabled\n");
-       return NULL;
+       return sdp_crypto_api->get_attr(srtp, dtls_enabled, default_taglen_32);
 }
 
 char *ast_sdp_get_rtp_profile(unsigned int sdes_active, struct ast_rtp_instance *instance, unsigned int using_avpf,
@@ -682,3 +122,19 @@ char *ast_sdp_get_rtp_profile(unsigned int sdes_active, struct ast_rtp_instance
        }
 }
 
+int ast_sdp_crypto_register(struct ast_sdp_crypto_api *api)
+{
+       if (sdp_crypto_api) {
+               return -1;
+       }
+       sdp_crypto_api = api;
+       return 0;
+}
+
+void ast_sdp_crypto_unregister(struct ast_sdp_crypto_api *api)
+{
+       if (sdp_crypto_api == api) {
+               sdp_crypto_api = NULL;
+       }
+}
+
index 59fda76..1fb16ce 100644 (file)
@@ -39,6 +39,7 @@
 
 ASTERISK_REGISTER_FILE()
 
+#include <math.h>                       /* for pow */
 #include <srtp/srtp.h>
 #ifdef HAVE_OPENSSL
 #include <openssl/rand.h>
@@ -50,6 +51,7 @@ ASTERISK_REGISTER_FILE()
 #include "asterisk/frame.h"             /* for AST_FRIENDLY_OFFSET */
 #include "asterisk/logger.h"            /* for ast_log, ast_debug, etc */
 #include "asterisk/module.h"            /* for ast_module_info, etc */
+#include "asterisk/sdp_srtp.h"
 #include "asterisk/res_srtp.h"          /* for ast_srtp_cb, ast_srtp_suite, etc */
 #include "asterisk/rtp_engine.h"        /* for ast_rtp_engine_register_srtp, etc */
 #include "asterisk/utils.h"             /* for ast_free, ast_calloc */
@@ -578,10 +580,587 @@ static int ast_srtp_change_source(struct ast_srtp *srtp, unsigned int from_ssrc,
        return 0;
 }
 
+struct ast_sdp_crypto {
+       char *a_crypto;
+       unsigned char local_key[SRTP_MAX_KEY_LEN];
+       int tag;
+       char local_key64[((SRTP_MAX_KEY_LEN) * 8 + 5) / 6 + 1];
+       unsigned char remote_key[SRTP_MAX_KEY_LEN];
+       int key_len;
+};
+
+static void res_sdp_crypto_dtor(struct ast_sdp_crypto *crypto)
+{
+       if (crypto) {
+               ast_free(crypto->a_crypto);
+               crypto->a_crypto = NULL;
+               ast_free(crypto);
+
+               ast_module_unref(ast_module_info->self);
+       }
+}
+
+static struct ast_sdp_crypto *crypto_init_keys(struct ast_sdp_crypto *p, const int key_len)
+{
+       unsigned char remote_key[key_len];
+
+       if (srtp_res.get_random(p->local_key, key_len) < 0) {
+               return NULL;
+       }
+
+       ast_base64encode(p->local_key64, p->local_key, key_len, sizeof(p->local_key64));
+
+       p->key_len = ast_base64decode(remote_key, p->local_key64, sizeof(remote_key));
+
+       if (p->key_len != key_len) {
+               ast_log(LOG_ERROR, "base64 encode/decode bad len %d != %d\n", p->key_len, key_len);
+               return NULL;
+       }
+
+       if (memcmp(remote_key, p->local_key, p->key_len)) {
+               ast_log(LOG_ERROR, "base64 encode/decode bad key\n");
+               return NULL;
+       }
+
+       ast_debug(1 , "local_key64 %s len %zu\n", p->local_key64, strlen(p->local_key64));
+
+       return p;
+}
+
+static struct ast_sdp_crypto *sdp_crypto_alloc(const int key_len)
+{
+       struct ast_sdp_crypto *p, *result;
+
+       if (!(p = ast_calloc(1, sizeof(*p)))) {
+               return NULL;
+       }
+       p->tag = 1;
+       ast_module_ref(ast_module_info->self);
+
+       /* default is a key which uses AST_AES_CM_128_HMAC_SHA1_xx */
+       result = crypto_init_keys(p, key_len);
+       if (!result) {
+               res_sdp_crypto_dtor(p);
+       }
+
+       return result;
+}
+
+static struct ast_sdp_crypto *res_sdp_crypto_alloc(void)
+{
+       return sdp_crypto_alloc(SRTP_MASTER_KEY_LEN);
+}
+
+static int res_sdp_crypto_build_offer(struct ast_sdp_crypto *p, int taglen)
+{
+       int res;
+
+       /* Rebuild the crypto line */
+       ast_free(p->a_crypto);
+       p->a_crypto = NULL;
+
+       if ((taglen & 0x007f) == 8) {
+               res = ast_asprintf(&p->a_crypto, "%d AEAD_AES_%d_GCM_%d inline:%s",
+                       p->tag, 128 + ((taglen & 0x0300) >> 2), taglen & 0x007f, p->local_key64);
+       } else if ((taglen & 0x007f) == 16) {
+               res = ast_asprintf(&p->a_crypto, "%d AEAD_AES_%d_GCM inline:%s",
+                       p->tag, 128 + ((taglen & 0x0300) >> 2), p->local_key64);
+       } else if ((taglen & 0x0300) && !(taglen & 0x0080)) {
+               res = ast_asprintf(&p->a_crypto, "%d AES_%d_CM_HMAC_SHA1_%d inline:%s",
+                       p->tag, 128 + ((taglen & 0x0300) >> 2), taglen & 0x007f, p->local_key64);
+       } else {
+               res = ast_asprintf(&p->a_crypto, "%d AES_CM_%d_HMAC_SHA1_%d inline:%s",
+                       p->tag, 128 + ((taglen & 0x0300) >> 2), taglen & 0x007f, p->local_key64);
+       }
+       if (res == -1 || !p->a_crypto) {
+               ast_log(LOG_ERROR, "Could not allocate memory for crypto line\n");
+               return -1;
+       }
+
+       ast_debug(1, "Crypto line: a=crypto:%s\n", p->a_crypto);
+
+       return 0;
+}
+
+static int set_crypto_policy(struct ast_srtp_policy *policy, int suite_val, const unsigned char *master_key, int key_len, unsigned long ssrc, int inbound)
+{
+       if (policy_res.set_master_key(policy, master_key, key_len, NULL, 0) < 0) {
+               return -1;
+       }
+
+       if (policy_res.set_suite(policy, suite_val)) {
+               ast_log(LOG_WARNING, "Could not set remote SRTP suite\n");
+               return -1;
+       }
+
+       policy_res.set_ssrc(policy, ssrc, inbound);
+
+       return 0;
+}
+
+static int crypto_activate(struct ast_sdp_crypto *p, int suite_val, unsigned char *remote_key, int key_len, struct ast_rtp_instance *rtp)
+{
+       struct ast_srtp_policy *local_policy = NULL;
+       struct ast_srtp_policy *remote_policy = NULL;
+       struct ast_rtp_instance_stats stats = {0,};
+       int res = -1;
+
+       if (!p) {
+               return -1;
+       }
+
+       if (!(local_policy = policy_res.alloc())) {
+               return -1;
+       }
+
+       if (!(remote_policy = policy_res.alloc())) {
+               goto err;
+       }
+
+       if (ast_rtp_instance_get_stats(rtp, &stats, AST_RTP_INSTANCE_STAT_LOCAL_SSRC)) {
+               goto err;
+       }
+
+       if (set_crypto_policy(local_policy, suite_val, p->local_key, key_len, stats.local_ssrc, 0) < 0) {
+               goto err;
+       }
+
+       if (set_crypto_policy(remote_policy, suite_val, remote_key, key_len, 0, 1) < 0) {
+               goto err;
+       }
+
+       /* Add the SRTP policies */
+       if (ast_rtp_instance_add_srtp_policy(rtp, remote_policy, local_policy, 0)) {
+               ast_log(LOG_WARNING, "Could not set SRTP policies\n");
+               goto err;
+       }
+
+       ast_debug(1 , "SRTP policy activated\n");
+       res = 0;
+
+err:
+       if (local_policy) {
+               policy_res.destroy(local_policy);
+       }
+
+       if (remote_policy) {
+               policy_res.destroy(remote_policy);
+       }
+
+       return res;
+}
+
+static int res_sdp_crypto_parse_offer(struct ast_rtp_instance *rtp, struct ast_sdp_srtp *srtp, const char *attr)
+{
+       char *str = NULL;
+       char *tag = NULL;
+       char *suite = NULL;
+       char *key_params = NULL;
+       char *key_param = NULL;
+       char *session_params = NULL;
+       char *key_salt = NULL;       /* The actual master key and key salt */
+       char *lifetime = NULL;       /* Key lifetime (# of RTP packets) */
+       char *mki = NULL;            /* Master Key Index */
+       int found = 0;
+       int key_len_from_sdp;
+       int key_len_expected;
+       int tag_from_sdp;
+       int suite_val = 0;
+       unsigned char remote_key[SRTP_MAX_KEY_LEN];
+       int taglen;
+       double sdes_lifetime;
+       struct ast_sdp_crypto *crypto;
+       struct ast_sdp_srtp *tmp;
+
+       str = ast_strdupa(attr);
+
+       tag = strsep(&str, " ");
+       suite = strsep(&str, " ");
+       key_params = strsep(&str, " ");
+       session_params = strsep(&str, " ");
+
+       if (!tag || !suite) {
+               ast_log(LOG_WARNING, "Unrecognized crypto attribute a=%s\n", attr);
+               return -1;
+       }
+
+       /* RFC4568 9.1 - tag is 1-9 digits, greater than zero */
+       if (sscanf(tag, "%30d", &tag_from_sdp) != 1 || tag_from_sdp <= 0 || tag_from_sdp > 999999999) {
+               ast_log(LOG_WARNING, "Unacceptable a=crypto tag: %s\n", tag);
+               return -1;
+       }
+
+       if (!ast_strlen_zero(session_params)) {
+               ast_log(LOG_WARNING, "Unsupported crypto parameters: %s\n", session_params);
+               return -1;
+       }
+
+       /* On egress, Asterisk sent several crypto lines in the SIP/SDP offer
+          The remote party might have choosen another line than the first */
+       for (tmp = srtp; tmp && tmp->crypto && tmp->crypto->tag != tag_from_sdp;) {
+               tmp = AST_LIST_NEXT(tmp, sdp_srtp_list);
+       }
+       if (tmp) { /* tag matched an already created crypto line */
+               unsigned int flags = tmp->flags;
+
+               /* Make that crypto line the head of the list, not by changing the
+                  list structure but by exchanging the content of the list members */
+               crypto = tmp->crypto;
+               tmp->crypto = srtp->crypto;
+               tmp->flags = srtp->flags;
+               srtp->crypto = crypto;
+               srtp->flags = flags;
+       } else {
+               crypto = srtp->crypto;
+               crypto->tag = tag_from_sdp;
+       }
+
+       if (!strcmp(suite, "AES_CM_128_HMAC_SHA1_80")) {
+               suite_val = AST_AES_CM_128_HMAC_SHA1_80;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_80);
+               key_len_expected = 30;
+       } else if (!strcmp(suite, "AES_CM_128_HMAC_SHA1_32")) {
+               suite_val = AST_AES_CM_128_HMAC_SHA1_32;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_32);
+               key_len_expected = 30;
+#ifdef HAVE_SRTP_192
+       } else if (!strcmp(suite, "AES_192_CM_HMAC_SHA1_80")) {
+               suite_val = AST_AES_CM_192_HMAC_SHA1_80;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_80);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_192);
+               key_len_expected = 38;
+       } else if (!strcmp(suite, "AES_192_CM_HMAC_SHA1_32")) {
+               suite_val = AST_AES_CM_192_HMAC_SHA1_32;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_32);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_192);
+               key_len_expected = 38;
+       /* RFC used a different name while in draft, some still use that */
+       } else if (!strcmp(suite, "AES_CM_192_HMAC_SHA1_80")) {
+               suite_val = AST_AES_CM_192_HMAC_SHA1_80;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_80);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_192);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_OLD_NAME);
+               key_len_expected = 38;
+       } else if (!strcmp(suite, "AES_CM_192_HMAC_SHA1_32")) {
+               suite_val = AST_AES_CM_192_HMAC_SHA1_32;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_32);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_192);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_OLD_NAME);
+               key_len_expected = 38;
+#endif
+#ifdef HAVE_SRTP_256
+       } else if (!strcmp(suite, "AES_256_CM_HMAC_SHA1_80")) {
+               suite_val = AST_AES_CM_256_HMAC_SHA1_80;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_80);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_256);
+               key_len_expected = 46;
+       } else if (!strcmp(suite, "AES_256_CM_HMAC_SHA1_32")) {
+               suite_val = AST_AES_CM_256_HMAC_SHA1_32;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_32);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_256);
+               key_len_expected = 46;
+       /* RFC used a different name while in draft, some still use that */
+       } else if (!strcmp(suite, "AES_CM_256_HMAC_SHA1_80")) {
+               suite_val = AST_AES_CM_256_HMAC_SHA1_80;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_80);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_256);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_OLD_NAME);
+               key_len_expected = 46;
+       } else if (!strcmp(suite, "AES_CM_256_HMAC_SHA1_32")) {
+               suite_val = AST_AES_CM_256_HMAC_SHA1_32;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_32);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_256);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_OLD_NAME);
+               key_len_expected = 46;
+#endif
+#ifdef HAVE_SRTP_GCM
+       } else if (!strcmp(suite, "AEAD_AES_128_GCM")) {
+               suite_val = AST_AES_GCM_128;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_16);
+               key_len_expected = AES_128_GCM_KEYSIZE_WSALT;
+       } else if (!strcmp(suite, "AEAD_AES_256_GCM")) {
+               suite_val = AST_AES_GCM_256;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_16);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_256);
+               key_len_expected = AES_256_GCM_KEYSIZE_WSALT;
+       /* RFC contained a (too) short auth tag for RTP media, some still use that */
+       } else if (!strcmp(suite, "AEAD_AES_128_GCM_8")) {
+               suite_val = AST_AES_GCM_128_8;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_8);
+               key_len_expected = AES_128_GCM_KEYSIZE_WSALT;
+       } else if (!strcmp(suite, "AEAD_AES_256_GCM_8")) {
+               suite_val = AST_AES_GCM_256_8;
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_TAG_8);
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_AES_256);
+               key_len_expected = AES_256_GCM_KEYSIZE_WSALT;
+#endif
+       } else {
+               ast_verb(1, "Unsupported crypto suite: %s\n", suite);
+               return -1;
+       }
+
+       while ((key_param = strsep(&key_params, ";"))) {
+               unsigned int n_lifetime;
+               char *method = NULL;
+               char *info = NULL;
+
+               method = strsep(&key_param, ":");
+               info = strsep(&key_param, ";");
+               sdes_lifetime = 0;
+
+               if (strcmp(method, "inline")) {
+                       continue;
+               }
+
+               key_salt = strsep(&info, "|");
+
+               /* The next parameter can be either lifetime or MKI */
+               lifetime = strsep(&info, "|");
+               if (!lifetime) {
+                       found = 1;
+                       break;
+               }
+
+               mki = strchr(lifetime, ':');
+               if (mki) {
+                       mki = lifetime;
+                       lifetime = NULL;
+               } else {
+                       mki = strsep(&info, "|");
+               }
+
+               if (mki && *mki != '1') {
+                       ast_log(LOG_NOTICE, "Crypto MKI handling is not supported: ignoring attribute %s\n", attr);
+                       continue;
+               }
+
+               if (lifetime) {
+                       if (!strncmp(lifetime, "2^", 2)) {
+                               char *lifetime_val = lifetime + 2;
+
+                               /* Exponential lifetime */
+                               if (sscanf(lifetime_val, "%30u", &n_lifetime) != 1) {
+                                       ast_log(LOG_NOTICE, "Failed to parse lifetime value in crypto attribute: %s\n", attr);
+                                       continue;
+                               }
+
+                               if (n_lifetime > 48) {
+                                       /* Yeah... that's a bit big. */
+                                       ast_log(LOG_NOTICE, "Crypto lifetime exponent of '%u' is a bit large; using 48\n", n_lifetime);
+                                       n_lifetime = 48;
+                               }
+                               sdes_lifetime = pow(2, n_lifetime);
+                       } else {
+                               /* Decimal lifetime */
+                               if (sscanf(lifetime, "%30u", &n_lifetime) != 1) {
+                                       ast_log(LOG_NOTICE, "Failed to parse lifetime value in crypto attribute: %s\n", attr);
+                                       continue;
+                               }
+                               sdes_lifetime = n_lifetime;
+                       }
+
+                       /* Accept anything above 10 hours. Less than 10; reject. */
+                       if (sdes_lifetime < 1800000) {
+                               ast_log(LOG_NOTICE, "Rejecting crypto attribute '%s': lifetime '%f' too short\n", attr, sdes_lifetime);
+                               continue;
+                       }
+               }
+
+               ast_debug(2, "Crypto attribute '%s' accepted with lifetime '%f', MKI '%s'\n",
+                       attr, sdes_lifetime, mki ? mki : "-");
+
+               found = 1;
+               break;
+       }
+
+       if (!found) {
+               ast_log(LOG_NOTICE, "SRTP crypto offer not acceptable: '%s'\n", attr);
+               return -1;
+       }
+
+       key_len_from_sdp = ast_base64decode(remote_key, key_salt, sizeof(remote_key));
+       if (key_len_from_sdp != key_len_expected) {
+               ast_log(LOG_WARNING, "SRTP descriptions key length is '%d', not '%d'\n",
+                       key_len_from_sdp, key_len_expected);
+               return -1;
+       }
+
+       /* on default, the key is 30 (AES-128); throw that away (only) when the suite changed actually */
+       /* ingress: optional, but saves one expensive call to get_random(.) */
+       /*  egress: required, because the local key was communicated before the remote key is processed */
+       if (crypto->key_len != key_len_from_sdp) {
+               if (!crypto_init_keys(crypto, key_len_from_sdp)) {
+                       return -1;
+               }
+       } else if (!memcmp(crypto->remote_key, remote_key, key_len_from_sdp)) {
+               ast_debug(1, "SRTP remote key unchanged; maintaining current policy\n");
+               ast_set_flag(srtp, AST_SRTP_CRYPTO_OFFER_OK);
+               return 0;
+       }
+
+       if (key_len_from_sdp > sizeof(crypto->remote_key)) {
+               ast_log(LOG_ERROR,
+                       "SRTP key buffer is %zu although it must be at least %d bytes\n",
+                       sizeof(crypto->remote_key), key_len_from_sdp);
+               return -1;
+       }
+       memcpy(crypto->remote_key, remote_key, key_len_from_sdp);
+
+       if (crypto_activate(crypto, suite_val, remote_key, key_len_from_sdp, rtp) < 0) {
+               return -1;
+       }
+
+       if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_32)) {
+               taglen = 32;
+       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_16)) {
+               taglen = 16;
+       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_8)) {
+               taglen = 8;
+       } else {
+               taglen = 80;
+       }
+       if (ast_test_flag(srtp, AST_SRTP_CRYPTO_AES_256)) {
+               taglen |= 0x0200;
+       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_AES_192)) {
+               taglen |= 0x0100;
+       }
+       if (ast_test_flag(srtp, AST_SRTP_CRYPTO_OLD_NAME)) {
+               taglen |= 0x0080;
+       }
+
+       /* Finally, rebuild the crypto line */
+       if (res_sdp_crypto_build_offer(crypto, taglen)) {
+               return -1;
+       }
+
+       ast_set_flag(srtp, AST_SRTP_CRYPTO_OFFER_OK);
+       return 0;
+}
+
+static const char *res_sdp_srtp_get_attr(struct ast_sdp_srtp *srtp, int dtls_enabled, int default_taglen_32)
+{
+       int taglen;
+
+       if (!srtp) {
+               return NULL;
+       }
+
+       /* Set encryption properties */
+       if (!srtp->crypto) {
+               if (AST_LIST_NEXT(srtp, sdp_srtp_list)) {
+                       srtp->crypto = res_sdp_crypto_alloc();
+                       ast_log(LOG_ERROR, "SRTP SDP list was not empty\n");
+               } else {
+                       const int len = default_taglen_32 ? AST_SRTP_CRYPTO_TAG_32 : AST_SRTP_CRYPTO_TAG_80;
+                       const int attr[][3] = {
+                       /* This array creates the following list:
+                        * a=crypto:1 AES_CM_128_HMAC_SHA1_ ...
+                        * a=crypto:2 AEAD_AES_128_GCM ...
+                        * a=crypto:3 AES_256_CM_HMAC_SHA1_ ...
+                        * a=crypto:4 AEAD_AES_256_GCM ...
+                        * a=crypto:5 AES_192_CM_HMAC_SHA1_ ...
+                        * something like 'AEAD_AES_192_GCM' is not specified by the RFCs
+                        *
+                        * If you want to prefer another crypto suite or you want to
+                        * exclude a suite, change this array and recompile Asterisk.
+                        * This list cannot be changed from rtp.conf because you should
+                        * know what you are doing. Especially AES-192 and AES-GCM are
+                        * broken in many VoIP clients, see
+                        * https://github.com/cisco/libsrtp/pull/170
+                        * https://github.com/cisco/libsrtp/pull/184
+                        * Furthermore, AES-GCM uses a shorter crypto-suite string which
+                        * causes Nokia phones based on Symbian/S60 to reject the whole
+                        * INVITE with status 500, even if a matching suite was offered.
+                        * AES-256 might just waste your processor cycles, especially if
+                        * your TLS transport is not secured with equivalent grade, see
+                        * https://security.stackexchange.com/q/61361
+                        * Therefore, AES-128 was preferred here.
+                        *
+                        * If you want to enable one of those defines, please, go for
+                        * CFLAGS='-DENABLE_SRTP_AES_GCM' ./configure && sudo make install
+                        */
+                               { len, 0, 30 },
+#if defined(HAVE_SRTP_GCM) && defined(ENABLE_SRTP_AES_GCM)
+                               { AST_SRTP_CRYPTO_TAG_16, 0, AES_128_GCM_KEYSIZE_WSALT },
+#endif
+#if defined(HAVE_SRTP_256) && defined(ENABLE_SRTP_AES_256)
+                               { len, AST_SRTP_CRYPTO_AES_256, 46 },
+#endif
+#if defined(HAVE_SRTP_GCM) && defined(ENABLE_SRTP_AES_GCM) && defined(ENABLE_SRTP_AES_256)
+                               { AST_SRTP_CRYPTO_TAG_16, AST_SRTP_CRYPTO_AES_256, AES_256_GCM_KEYSIZE_WSALT },
+#endif
+#if defined(HAVE_SRTP_192) && defined(ENABLE_SRTP_AES_192)
+                               { len, AST_SRTP_CRYPTO_AES_192, 38 },
+#endif
+                       };
+                       struct ast_sdp_srtp *tmp = srtp;
+                       int i;
+
+                       for (i = 0; i < ARRAY_LEN(attr); i++) {
+                               if (attr[i][0]) {
+                                       ast_set_flag(tmp, attr[i][0]);
+                               }
+                               if (attr[i][1]) {
+                                       ast_set_flag(tmp, attr[i][1]);
+                               }
+                               tmp->crypto = sdp_crypto_alloc(attr[i][2]); /* key_len */
+                               tmp->crypto->tag = (i + 1); /* tag starts at 1 */
+
+                               if (i < ARRAY_LEN(attr) - 1) {
+                                       AST_LIST_NEXT(tmp, sdp_srtp_list) = ast_sdp_srtp_alloc();
+                                       tmp = AST_LIST_NEXT(tmp, sdp_srtp_list);
+                               }
+                       }
+               }
+       }
+
+       if (dtls_enabled) {
+               /* If DTLS-SRTP is enabled the key details will be pulled from TLS */
+               return NULL;
+       }
+
+       /* set the key length based on INVITE or settings */
+       if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_80)) {
+               taglen = 80;
+       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_32)) {
+               taglen = 32;
+       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_16)) {
+               taglen = 16;
+       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_TAG_8)) {
+               taglen = 8;
+       } else {
+               taglen = default_taglen_32 ? 32 : 80;
+       }
+       if (ast_test_flag(srtp, AST_SRTP_CRYPTO_AES_256)) {
+               taglen |= 0x0200;
+       } else if (ast_test_flag(srtp, AST_SRTP_CRYPTO_AES_192)) {
+               taglen |= 0x0100;
+       }
+       if (ast_test_flag(srtp, AST_SRTP_CRYPTO_OLD_NAME)) {
+               taglen |= 0x0080;
+       }
+
+       if (srtp->crypto && (res_sdp_crypto_build_offer(srtp->crypto, taglen) >= 0)) {
+               return srtp->crypto->a_crypto;
+       }
+
+       ast_log(LOG_WARNING, "No SRTP key management enabled\n");
+       return NULL;
+}
+
+static struct ast_sdp_crypto_api res_sdp_crypto_api = {
+       .dtor = res_sdp_crypto_dtor,
+       .alloc = res_sdp_crypto_alloc,
+       .build_offer = res_sdp_crypto_build_offer,
+       .parse_offer = res_sdp_crypto_parse_offer,
+       .get_attr = res_sdp_srtp_get_attr,
+};
+
 static void res_srtp_shutdown(void)
 {
-       srtp_install_event_handler(NULL);
+       ast_sdp_crypto_unregister(&res_sdp_crypto_api);
        ast_rtp_engine_unregister_srtp();
+       srtp_install_event_handler(NULL);
 #ifdef HAVE_SRTP_SHUTDOWN
        srtp_shutdown();
 #endif
@@ -607,6 +1186,12 @@ static int res_srtp_init(void)
                return -1;
        }
 
+       if (ast_sdp_crypto_register(&res_sdp_crypto_api)) {
+               ast_log(AST_LOG_WARNING, "Failed to register SDP SRTP crypto API\n");
+               res_srtp_shutdown();
+               return -1;
+       }
+
        g_initialized = 1;
        return 0;
 }