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 48 matching lines @@
                            ContentSource source) {
   return DoSetAnswer(answer_params, source, true);
 }
 
 bool SrtpFilter::SetProvisionalAnswer(
     const std::vector<CryptoParams>& answer_params,
     ContentSource source) {
   return DoSetAnswer(answer_params, source, false);
 }
 
+void SrtpFilter::GetSendRecvEncryptedHeaderExtensions(
+    std::vector<int>* send_extensions, std::vector<int>* recv_extensions) {
+  // Send local extension header encrypted if the remote also uses it
+  // encrypted and vice versa.
+  for (const webrtc::RtpExtension& extension :
+       local_encrypted_header_extensions_) {
+    if (webrtc::RtpExtension::FindHeaderExtensionByUri(
+        remote_encrypted_header_extensions_, extension.uri)) {
+      send_extensions->push_back(extension.id);
+    }
+  }
+  for (const webrtc::RtpExtension& extension :
+       remote_encrypted_header_extensions_) {
+    if (webrtc::RtpExtension::FindHeaderExtensionByUri(
+        local_encrypted_header_extensions_, extension.uri)) {
+      recv_extensions->push_back(extension.id);
+    }
+  }
+}
+
 bool SrtpFilter::SetRtpParams(int send_cs,
                               const uint8_t* send_key,
                               int send_key_len,
                               int recv_cs,
                               const uint8_t* recv_key,
                               int recv_key_len) {
   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))
+  std::vector<int> send_encrypted_header_extensions;
+  std::vector<int> recv_encrypted_header_extensions;
+
+  GetSendRecvEncryptedHeaderExtensions(&send_encrypted_header_extensions,
+      &recv_encrypted_header_extensions);
+  if (!send_session_->SetSend(send_cs, send_key, send_key_len,
+      send_encrypted_header_extensions)) {
     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_header_extensions)) {
     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_header_extensions;
   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_header_extensions)) {
     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_header_extensions)) {
     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 99 matching lines @@
     send_session_->set_signal_silent_time(signal_silent_time_in_ms);
     RTC_CHECK(recv_session_);
     recv_session_->set_signal_silent_time(signal_silent_time_in_ms);
     if (send_rtcp_session_)
       send_rtcp_session_->set_signal_silent_time(signal_silent_time_in_ms);
     if (recv_rtcp_session_)
       recv_rtcp_session_->set_signal_silent_time(signal_silent_time_in_ms);
   }
 }
 
+void SrtpFilter::SetEncryptedHeaderExtensions(ContentSource source,
+    const std::vector<webrtc::RtpExtension>& extensions) {

[Taylor Brandstetter, 2017/03/23 20:10:56]

The situation that's not being handled right now is when this is called while
"IsActive" is already true.

[joachim, 2017/03/30 22:43:49]

This is now supported. Encrypted header extensions can be changed.

+  if (source == CS_LOCAL) {
+    local_encrypted_header_extensions_ = extensions;
+  } else {
+    remote_encrypted_header_extensions_ = extensions;
+  }
+}
+
 bool SrtpFilter::ExpectOffer(ContentSource source) {
   return ((state_ == ST_INIT) ||
           (state_ == ST_ACTIVE) ||
           (state_  == ST_SENTOFFER && source == CS_LOCAL) ||
           (state_  == ST_SENTUPDATEDOFFER && source == CS_LOCAL) ||
           (state_ == ST_RECEIVEDOFFER && source == CS_REMOTE) ||
           (state_ == ST_RECEIVEDUPDATEDOFFER && source == CS_REMOTE));
 }
 
 bool SrtpFilter::StoreParams(const std::vector<CryptoParams>& params,
@@ skipping 145 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> send_encrypted_header_extensions;
+    std::vector<int> recv_encrypted_header_extensions;
+
+    GetSendRecvEncryptedHeaderExtensions(&send_encrypted_header_extensions,
+        &recv_encrypted_header_extensions);
     ret = (send_session_->SetSend(
                rtc::SrtpCryptoSuiteFromName(send_params.cipher_suite),
-               send_key.data(), send_key.size()) &&
+               send_key.data(), send_key.size(),
+               send_encrypted_header_extensions) &&
            recv_session_->SetRecv(
                rtc::SrtpCryptoSuiteFromName(recv_params.cipher_suite),
-               recv_key.data(), recv_key.size()));
+               recv_key.data(), recv_key.size(),
+               recv_encrypted_header_extensions));
   }
   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";
   }
   return ret;
 }
 
 bool SrtpFilter::ResetParams() {
   offer_params_.clear();
   state_ = ST_INIT;
   send_session_ = nullptr;
   recv_session_ = nullptr;
   send_rtcp_session_ = nullptr;
   recv_rtcp_session_ = nullptr;
+  local_encrypted_header_extensions_.clear();
+  remote_encrypted_header_extensions_.clear();
   LOG(LS_INFO) << "SRTP reset to init state";
   return true;
 }
 
 bool SrtpFilter::ParseKeyParams(const std::string& key_params,
                                 uint8_t* key,
                                 size_t len) {
   // example key_params: "inline:YUJDZGVmZ2hpSktMbW9QUXJzVHVWd3l6MTIzNDU2"
 
   // Fail if key-method is wrong.
@@ skipping 24 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_header_extensions) {
+  return SetKeyAndEncryptedHeaderExtensions(ssrc_any_outbound, cs, key, len,
+      encrypted_header_extensions);
 }
 
-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_header_extensions) {
+  return SetKeyAndEncryptedHeaderExtensions(ssrc_any_inbound, cs, key, len,
+      encrypted_header_extensions);
 }
 
 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::SetKeyAndEncryptedHeaderExtensions(int type, int cs,
+    const uint8_t* key, size_t len,
+    const std::vector<int>& encrypted_header_extensions) {
   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_header_extensions.empty()) {
+    policy.enc_xtn_hdr = const_cast<int*>(&encrypted_header_extensions[0]);
+    policy.enc_xtn_hdr_count = encrypted_header_extensions.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