Support encrypted RTP extensions (RFC 6904)

webrtc/pc/srtpfilter.cc

 /*
  *  Copyright 2009 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 51 matching lines @@
 
 bool SrtpFilter::SetProvisionalAnswer(
     const std::vector<CryptoParams>& answer_params,
     ContentSource source) {
   return DoSetAnswer(answer_params, source, false);
 }
 
 bool SrtpFilter::SetRtpParams(int send_cs,
                               const uint8_t* send_key,
                               int send_key_len,
+                              const std::vector<int>& send_encrypted_headers,
                               int recv_cs,
                               const uint8_t* recv_key,
-                              int recv_key_len) {
+                              int recv_key_len,
+                              const std::vector<int>& recv_encrypted_headers) {
   if (IsActive()) {
     LOG(LS_ERROR) << "Tried to set SRTP Params when filter already active";
     return false;
   }
   CreateSrtpSessions();
-  if (!send_session_->SetSend(send_cs, send_key, send_key_len))
+  if (!send_session_->SetSend(send_cs, send_key, send_key_len,
+      send_encrypted_headers)) {
     return false;
+  }
 
-  if (!recv_session_->SetRecv(recv_cs, recv_key, recv_key_len))
+  if (!recv_session_->SetRecv(recv_cs, recv_key, recv_key_len,
+      recv_encrypted_headers)) {
     return false;
+  }
 
   state_ = ST_ACTIVE;
 
   LOG(LS_INFO) << "SRTP activated with negotiated parameters:"
                << " send cipher_suite " << send_cs
                << " recv cipher_suite " << recv_cs;
   return true;
 }
 
 // This function is provided separately because DTLS-SRTP behaves
@@ skipping 10 matching lines @@
                                int recv_cs,
                                const uint8_t* recv_key,
                                int recv_key_len) {
   // This can only be called once, but can be safely called after
   // SetRtpParams
   if (send_rtcp_session_ || recv_rtcp_session_) {
     LOG(LS_ERROR) << "Tried to set SRTCP Params when filter already active";
     return false;
   }
 
+  // RTCP doesn't support header encryption.
+  std::vector<int> no_encrypted_headers;
   send_rtcp_session_.reset(new SrtpSession());
   SignalSrtpError.repeat(send_rtcp_session_->SignalSrtpError);
   send_rtcp_session_->set_signal_silent_time(signal_silent_time_in_ms_);
-  if (!send_rtcp_session_->SetRecv(send_cs, send_key, send_key_len))
+  if (!send_rtcp_session_->SetRecv(send_cs, send_key, send_key_len,
+      no_encrypted_headers)) {
     return false;
+  }
 
   recv_rtcp_session_.reset(new SrtpSession());
   SignalSrtpError.repeat(recv_rtcp_session_->SignalSrtpError);
   recv_rtcp_session_->set_signal_silent_time(signal_silent_time_in_ms_);
-  if (!recv_rtcp_session_->SetRecv(recv_cs, recv_key, recv_key_len))
+  if (!recv_rtcp_session_->SetRecv(recv_cs, recv_key, recv_key_len,
+      no_encrypted_headers)) {
     return false;
+  }
 
   LOG(LS_INFO) << "SRTCP activated with negotiated parameters:"
                << " send cipher_suite " << send_cs
                << " recv cipher_suite " << recv_cs;
 
   return true;
 }
 
 bool SrtpFilter::ProtectRtp(void* p, int in_len, int max_len, int* out_len) {
   if (!IsActive()) {
@@ skipping 264 matching lines @@
   // TODO(juberti): Zero these buffers after use.
   bool ret;
   rtc::Buffer send_key(send_key_len + send_salt_len);
   rtc::Buffer recv_key(recv_key_len + recv_salt_len);
   ret = (ParseKeyParams(send_params.key_params, send_key.data(),
                         send_key.size()) &&
          ParseKeyParams(recv_params.key_params, recv_key.data(),
                         recv_key.size()));
   if (ret) {
     CreateSrtpSessions();
+    std::vector<int> encrypted_headers;  // No encrypted headers in this case.

[Taylor Brandstetter, 2017/03/22 18:00:11]

Use the pattern of "no_encrypted_headers" here as well?

Also, if we don't support encrypted header extensions with SDES, that should be
documented somewhere, and we should make sure it doesn't result in them being
sent encrypted, but rather not sent at all.

[joachim, 2017/03/23 00:04:33]

I now also added support for encrypted header extensions with SDES.

     ret = (send_session_->SetSend(
                rtc::SrtpCryptoSuiteFromName(send_params.cipher_suite),
-               send_key.data(), send_key.size()) &&
+               send_key.data(), send_key.size(), encrypted_headers) &&
            recv_session_->SetRecv(
                rtc::SrtpCryptoSuiteFromName(recv_params.cipher_suite),
-               recv_key.data(), recv_key.size()));
+               recv_key.data(), recv_key.size(), encrypted_headers));
   }
   if (ret) {
     LOG(LS_INFO) << "SRTP activated with negotiated parameters:"
                  << " send cipher_suite " << send_params.cipher_suite
                  << " recv cipher_suite " << recv_params.cipher_suite;
     applied_send_params_ = send_params;
     applied_recv_params_ = recv_params;
   } else {
     LOG(LS_WARNING) << "Failed to apply negotiated SRTP parameters";
   }
@@ skipping 44 matching lines @@
   SignalSrtpError.repeat(srtp_stat_->SignalSrtpError);
 }
 
 SrtpSession::~SrtpSession() {
   if (session_) {
     srtp_set_user_data(session_, nullptr);
     srtp_dealloc(session_);
   }
 }
 
-bool SrtpSession::SetSend(int cs, const uint8_t* key, size_t len) {
-  return SetKey(ssrc_any_outbound, cs, key, len);
+bool SrtpSession::SetSend(int cs, const uint8_t* key, size_t len,
+    const std::vector<int>& encrypted_headers) {
+  return SetKey(ssrc_any_outbound, cs, key, len, encrypted_headers);
 }
 
-bool SrtpSession::SetRecv(int cs, const uint8_t* key, size_t len) {
-  return SetKey(ssrc_any_inbound, cs, key, len);
+bool SrtpSession::SetRecv(int cs, const uint8_t* key, size_t len,
+    const std::vector<int>& encrypted_headers) {
+  return SetKey(ssrc_any_inbound, cs, key, len, encrypted_headers);
 }
 
 bool SrtpSession::ProtectRtp(void* p, int in_len, int max_len, int* out_len) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!session_) {
     LOG(LS_WARNING) << "Failed to protect SRTP packet: no SRTP Session";
     return false;
   }
 
   int need_len = in_len + rtp_auth_tag_len_;  // NOLINT
@@ skipping 151 matching lines @@
   *index = static_cast<int64_t>(
       rtc::NetworkToHost64(
           srtp_rdbx_get_packet_index(&stream->rtp_rdbx) << 16));
   return true;
 }
 
 void SrtpSession::set_signal_silent_time(int signal_silent_time_in_ms) {
   srtp_stat_->set_signal_silent_time(signal_silent_time_in_ms);
 }
 
-bool SrtpSession::SetKey(int type, int cs, const uint8_t* key, size_t len) {
+bool SrtpSession::SetKey(int type, int cs, const uint8_t* key, size_t len,
+    const std::vector<int>& encrypted_headers) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (session_) {
     LOG(LS_ERROR) << "Failed to create SRTP session: "
                   << "SRTP session already created";
     return false;
   }
 
   if (!Init()) {
     return false;
   }
@@ skipping 44 matching lines @@
   // If external authentication option is enabled, supply custom auth module
   // id EXTERNAL_HMAC_SHA1 in the policy structure.
   // We want to set this option only for rtp packets.
   // By default policy structure is initialized to HMAC_SHA1.
   // Enable external HMAC authentication only for outgoing streams and only
   // for cipher suites that support it (i.e. only non-GCM cipher suites).
   if (type == ssrc_any_outbound && IsExternalAuthEnabled() &&
       !rtc::IsGcmCryptoSuite(cs)) {
     policy.rtp.auth_type = EXTERNAL_HMAC_SHA1;
   }
+  if (!encrypted_headers.empty()) {

[pthatcher1, 2017/03/21 07:07:06]

Please stick with "_header_extensions" or "hdr_exts" instead of just "headers".

[joachim, 2017/03/23 00:04:33]

Done (here and in various other places).

+    policy.enc_xtn_hdr = const_cast<int*>(&encrypted_headers[0]);
+    policy.enc_xtn_hdr_count = encrypted_headers.size();
+  }
   policy.next = nullptr;
 
   int err = srtp_create(&session_, &policy);
   if (err != srtp_err_status_ok) {
     session_ = nullptr;
     LOG(LS_ERROR) << "Failed to create SRTP session, err=" << err;
     return false;
   }
 
   srtp_set_user_data(session_, this);
@@ skipping 139 matching lines @@
     if (stat->last_signal_time == 0 ||
         rtc::TimeDiff(current_time, stat->last_signal_time) >
             signal_silent_time_) {
       SignalSrtpError(key.ssrc, key.mode, key.error);
       stat->last_signal_time = current_time;
     }
   }
 }
 
 }  // namespace cricket