The Tor Browser: media/webrtc/signaling/src/mediapipeline/SrtpFlow.cpp@ac0c01689b40 (annotated)

media/webrtc/signaling/src/mediapipeline/SrtpFlow.cpp@ac0c01689b40 (annotated)

media/webrtc/signaling/src/mediapipeline/SrtpFlow.cpp

Thu, 15 Jan 2015 15:59:08 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:59:08 +0100
branch: TOR_BUG_9701
changeset 10: ac0c01689b40
permissions: -rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 // Original author: ekr@rtfm.com
 #include "logging.h"
 #include "SrtpFlow.h"
 #include "srtp.h"
 #include "ssl.h"
 #include "sslproto.h"
 #include "mozilla/RefPtr.h"
 // Logging context
 using namespace mozilla;
 MOZ_MTLOG_MODULE("mediapipeline")
 namespace mozilla {
 bool SrtpFlow::initialized;  // Static
 SrtpFlow::~SrtpFlow() {
   if (session_) {
     srtp_dealloc(session_);
   }
 }
 RefPtr<SrtpFlow> SrtpFlow::Create(int cipher_suite,
                                            bool inbound,
                                            const void *key,
                                            size_t key_len) {
   nsresult res = Init();
   if (!NS_SUCCEEDED(res))
     return nullptr;
   RefPtr<SrtpFlow> flow = new SrtpFlow();
   if (!key) {
     MOZ_MTLOG(ML_ERROR, "Null SRTP key specified");
     return nullptr;
   }
   if (key_len != SRTP_TOTAL_KEY_LENGTH) {
     MOZ_MTLOG(ML_ERROR, "Invalid SRTP key length");
     return nullptr;
   }
   srtp_policy_t policy;
   memset(&policy, 0, sizeof(srtp_policy_t));
   // Note that we set the same cipher suite for RTP and RTCP
   // since any flow can only have one cipher suite with DTLS-SRTP
   switch (cipher_suite) {
     case SRTP_AES128_CM_HMAC_SHA1_80:
       MOZ_MTLOG(ML_DEBUG,
                 "Setting SRTP cipher suite SRTP_AES128_CM_HMAC_SHA1_80");
       crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtp);
       crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtcp);
       break;
     case SRTP_AES128_CM_HMAC_SHA1_32:
       MOZ_MTLOG(ML_DEBUG,
                 "Setting SRTP cipher suite SRTP_AES128_CM_HMAC_SHA1_32");
       crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy.rtp);
       crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtcp); // 80-bit per RFC 5764
       break;                                                   // S 4.1.2.
     default:
       MOZ_MTLOG(ML_ERROR, "Request to set unknown SRTP cipher suite");
       return nullptr;
   }
   // This key is copied into the srtp_t object, so we don't
   // need to keep it.
   policy.key = const_cast<unsigned char *>(
       static_cast<const unsigned char *>(key));
   policy.ssrc.type = inbound ? ssrc_any_inbound : ssrc_any_outbound;
   policy.ssrc.value = 0;
   policy.ekt = nullptr;
   policy.window_size = 1024;   // Use the Chrome value.  Needs to be revisited.  Default is 128
   policy.allow_repeat_tx = 1;  // Use Chrome value; needed for NACK mode to work
   policy.next = nullptr;
   // Now make the session
   err_status_t r = srtp_create(&flow->session_, &policy);
   if (r != err_status_ok) {
     MOZ_MTLOG(ML_ERROR, "Error creating srtp session");
     return nullptr;
   }
   return flow;
 }
 nsresult SrtpFlow::CheckInputs(bool protect, void *in, int in_len,
                                int max_len, int *out_len) {
   MOZ_ASSERT(in);
   if (!in) {
     MOZ_MTLOG(ML_ERROR, "NULL input value");
     return NS_ERROR_NULL_POINTER;
   }
   if (in_len < 0) {
     MOZ_MTLOG(ML_ERROR, "Input length is negative");
     return NS_ERROR_ILLEGAL_VALUE;
   }
   if (max_len < 0) {
     MOZ_MTLOG(ML_ERROR, "Max output length is negative");
     return NS_ERROR_ILLEGAL_VALUE;
   }
   if (protect) {
     if ((max_len < SRTP_MAX_EXPANSION) ||
         ((max_len - SRTP_MAX_EXPANSION) < in_len)) {
       MOZ_MTLOG(ML_ERROR, "Output too short");
       return NS_ERROR_ILLEGAL_VALUE;
     }
   }
   else {
     if (in_len > max_len) {
       MOZ_MTLOG(ML_ERROR, "Output too short");
       return NS_ERROR_ILLEGAL_VALUE;
     }
   }
   return NS_OK;
 }
 nsresult SrtpFlow::ProtectRtp(void *in, int in_len,
                               int max_len, int *out_len) {
   nsresult res = CheckInputs(true, in, in_len, max_len, out_len);
   if (NS_FAILED(res))
     return res;
   int len = in_len;
   err_status_t r = srtp_protect(session_, in, &len);
   if (r != err_status_ok) {
     MOZ_MTLOG(ML_ERROR, "Error protecting SRTP packet");
     return NS_ERROR_FAILURE;
   }
   MOZ_ASSERT(len <= max_len);
   *out_len = len;
   MOZ_MTLOG(ML_DEBUG, "Successfully protected an SRTP packet of len "
             << *out_len);
   return NS_OK;
 }
 nsresult SrtpFlow::UnprotectRtp(void *in, int in_len,
                                 int max_len, int *out_len) {
   nsresult res = CheckInputs(false, in, in_len, max_len, out_len);
   if (NS_FAILED(res))
     return res;
   int len = in_len;
   err_status_t r = srtp_unprotect(session_, in, &len);
   if (r != err_status_ok) {
     MOZ_MTLOG(ML_ERROR, "Error unprotecting SRTP packet error=" << (int)r);
     return NS_ERROR_FAILURE;
   }
   MOZ_ASSERT(len <= max_len);
   *out_len = len;
   MOZ_MTLOG(ML_DEBUG, "Successfully unprotected an SRTP packet of len "
             << *out_len);
   return NS_OK;
 }
 nsresult SrtpFlow::ProtectRtcp(void *in, int in_len,
                                int max_len, int *out_len) {
   nsresult res = CheckInputs(true, in, in_len, max_len, out_len);
   if (NS_FAILED(res))
     return res;
   int len = in_len;
   err_status_t r = srtp_protect_rtcp(session_, in, &len);
   if (r != err_status_ok) {
     MOZ_MTLOG(ML_ERROR, "Error protecting SRTCP packet");
     return NS_ERROR_FAILURE;
   }
   MOZ_ASSERT(len <= max_len);
   *out_len = len;
   MOZ_MTLOG(ML_DEBUG, "Successfully protected an SRTCP packet of len "
             << *out_len);
   return NS_OK;
 }
 nsresult SrtpFlow::UnprotectRtcp(void *in, int in_len,
                                  int max_len, int *out_len) {
   nsresult res = CheckInputs(false, in, in_len, max_len, out_len);
   if (NS_FAILED(res))
     return res;
   int len = in_len;
   err_status_t r = srtp_unprotect_rtcp(session_, in, &len);
   if (r != err_status_ok) {
     MOZ_MTLOG(ML_ERROR, "Error unprotecting SRTCP packet error=" << (int)r);
     return NS_ERROR_FAILURE;
   }
   MOZ_ASSERT(len <= max_len);
   *out_len = len;
   MOZ_MTLOG(ML_DEBUG, "Successfully unprotected an SRTCP packet of len "
             << *out_len);
   return NS_OK;
 }
 // Statics
 void SrtpFlow::srtp_event_handler(srtp_event_data_t *data) {
   // TODO(ekr@rtfm.com): Implement this
   MOZ_CRASH();
 }
 nsresult SrtpFlow::Init() {
   if (!initialized) {
     err_status_t r = srtp_init();
     if (r != err_status_ok) {
       MOZ_MTLOG(ML_ERROR, "Could not initialize SRTP");
       MOZ_ASSERT(PR_FALSE);
       return NS_ERROR_FAILURE;
     }
     r = srtp_install_event_handler(&SrtpFlow::srtp_event_handler);
     if (r != err_status_ok) {
       MOZ_MTLOG(ML_ERROR, "Could not install SRTP event handler");
       MOZ_ASSERT(PR_FALSE);
       return NS_ERROR_FAILURE;
     }
     initialized = true;
   }
   return NS_OK;
 }
 }  // end of namespace

The Tor Browser / annotate

media/webrtc/signaling/src/mediapipeline/SrtpFlow.cpp@ac0c01689b40 (annotated)

media/webrtc/signaling/src/mediapipeline/SrtpFlow.cpp