Upgrade libsrtp to version 2.0

testing/libfuzzer/fuzzers/libsrtp_fuzzer.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <vector>
 
-#include "third_party/libsrtp/srtp/include/rtp.h"
-#include "third_party/libsrtp/srtp/include/rtp_priv.h"
-#include "third_party/libsrtp/srtp/include/srtp.h"
+#include "third_party/libsrtp/include/rtp.h"
+#include "third_party/libsrtp/include/rtp_priv.h"
+#include "third_party/libsrtp/include/srtp.h"
 
 // TODO(katrielc) Also test the authenticated path, which is what
 // WebRTC uses.  This is nontrivial because you need to bypass the MAC
 // check. Two options: add a UNSAFE_FUZZER_MODE flag to libsrtp (or
 // the chromium fork of it), or compute the HMAC of whatever gibberish
 // the fuzzer produces and write it into the packet manually.
 
 namespace LibSrtpFuzzer {
 enum CryptoPolicy {
   NONE,
   LIKE_WEBRTC,
   LIKE_WEBRTC_WITHOUT_AUTH,
   AES_GCM,
   NUMBER_OF_POLICIES,
 };
 }
 
 struct Environment {
   srtp_policy_t GetCryptoPolicy(LibSrtpFuzzer::CryptoPolicy crypto_policy,
                                 const unsigned char* replacement_key) {
     switch (crypto_policy) {
       case LibSrtpFuzzer::NUMBER_OF_POLICIES:
       case LibSrtpFuzzer::NONE:
-        crypto_policy_set_null_cipher_null_auth(&policy.rtp);
-        crypto_policy_set_null_cipher_null_auth(&policy.rtcp);
+        srtp_crypto_policy_set_null_cipher_null_auth(&policy.rtp);
+        srtp_crypto_policy_set_null_cipher_null_auth(&policy.rtcp);
         break;
       case LibSrtpFuzzer::LIKE_WEBRTC:
-        crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtp);
-        crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtcp);
+        srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtp);
+        srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtcp);
+        break;
       case LibSrtpFuzzer::LIKE_WEBRTC_WITHOUT_AUTH:
-        crypto_policy_set_aes_cm_128_null_auth(&policy.rtp);
-        crypto_policy_set_aes_cm_128_null_auth(&policy.rtcp);
+        srtp_crypto_policy_set_aes_cm_128_null_auth(&policy.rtp);
+        srtp_crypto_policy_set_aes_cm_128_null_auth(&policy.rtcp);
         break;
       case LibSrtpFuzzer::AES_GCM:
         // There was a security bug in the GCM mode in libsrtp 1.5.2.
-        crypto_policy_set_aes_gcm_128_8_auth(&policy.rtp);
-        crypto_policy_set_aes_gcm_128_8_auth(&policy.rtcp);
+        srtp_crypto_policy_set_aes_gcm_128_8_auth(&policy.rtp);
+        srtp_crypto_policy_set_aes_gcm_128_8_auth(&policy.rtcp);
         break;
     }
 
     memcpy(key, replacement_key, SRTP_MASTER_KEY_LEN);
     return policy;
   };
 
   Environment() {
     srtp_init();
 
     memset(&policy, 0, sizeof(policy));
     policy.allow_repeat_tx = 1;
     policy.ekt = nullptr;
     policy.key = key;
     policy.next = nullptr;
     policy.ssrc.type = ssrc_any_inbound;
     policy.ssrc.value = 0xdeadbeef;
     policy.window_size = 1024;
   }
 
  private:
   srtp_policy_t policy;
   unsigned char key[SRTP_MASTER_KEY_LEN] = {0};
 
-  static void crypto_policy_set_null_cipher_null_auth(crypto_policy_t* p) {
-    p->cipher_type = NULL_CIPHER;
+  static void srtp_crypto_policy_set_null_cipher_null_auth(
+      srtp_crypto_policy_t* p) {
+    p->cipher_type = SRTP_NULL_CIPHER;
     p->cipher_key_len = 0;
-    p->auth_type = NULL_AUTH;
+    p->auth_type = SRTP_NULL_AUTH;
     p->auth_key_len = 0;
     p->auth_tag_len = 0;
     p->sec_serv = sec_serv_none;
   };
 };
 
 size_t ReadLength(const uint8_t* data, size_t size) {
   // Read one byte of input and interpret it as a length to read from
   // data. Don't return more bytes than are available.
   size_t n = static_cast<size_t>(data[0]);
@@ skipping 12 matching lines @@
   size -= 1;
 
   // Read some more bytes to use as a key.
   if (size <= SRTP_MASTER_KEY_LEN)
     return 0;
   srtp_policy_t srtp_policy = env->GetCryptoPolicy(policy, data);
   data += SRTP_MASTER_KEY_LEN;
   size -= SRTP_MASTER_KEY_LEN;
 
   srtp_t session;
-  err_status_t error = srtp_create(&session, &srtp_policy);
-  assert(error == err_status_ok);
+  srtp_err_status_t error = srtp_create(&session, &srtp_policy);
+  if (error != srtp_err_status_ok) {
+    assert(false);
+    return 0;
+  }
 
   // Read one byte as a packet length N, then feed the next N bytes
   // into srtp_unprotect. Keep going until we run out of data.
   size_t packet_size;
   while (size > 0 && (packet_size = ReadLength(data, size)) > 0) {
     // One byte was used by ReadLength.
     data++;
     size--;
 
     size_t header_size = std::min(sizeof(srtp_hdr_t), packet_size);
     size_t body_size = packet_size - header_size;
 
     // We deliberately do not initialise this struct. MSAN will catch
     // usage of the uninitialised memory.
     rtp_msg_t message;
     memcpy(&message.header, data, header_size);
     memcpy(&message.body, data + header_size, body_size);
 
     int out_len = static_cast<int>(packet_size);
     srtp_unprotect(session, &message, &out_len);
 
     // |packet_size| bytes were used above.
     data += packet_size;
     size -= packet_size;
   }
 
   srtp_dealloc(session);
   return 0;
 }