Cast: Added support for AES-CTR crypto.

media/cast/audio_sender/audio_sender.cc

 // Copyright 2013 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 "media/cast/audio_sender/audio_sender.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "crypto/symmetric_key.h"
 #include "media/cast/audio_sender/audio_encoder.h"
 #include "media/cast/rtcp/rtcp.h"
 #include "media/cast/rtp_sender/rtp_sender.h"
 
 namespace media {
 namespace cast {
 
 const int64 kMinSchedulingDelayMs = 1;
 
 class LocalRtcpAudioSenderFeedback : public RtcpSenderFeedback {
@@ skipping 66 matching lines @@
               rtcp_feedback_.get(),
               paced_packet_sender,
               rtp_audio_sender_statistics_.get(),
               NULL,
               audio_config.rtcp_mode,
               base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval),
               true,
               audio_config.sender_ssrc,
               audio_config.rtcp_c_name),
         weak_factory_(this) {
+  if (audio_config.aes_iv_mask.size() == kAesBlockSize * 2 &&
+      audio_config.aes_key.size() == kAesBlockSize * 2) {
+    iv_mask_ = ConvertFromBase16String(audio_config.aes_iv_mask);

[Alpha Left Google, 2013/11/07 01:10:11]

The IV should be a binary string instead of a base64. It should the
application's join to convert from base64 to binary.

[pwestin, 2013/11/07 17:16:04]

Done.

+    crypto::SymmetricKey* key = crypto::SymmetricKey::Import(
+        crypto::SymmetricKey::AES,
+        ConvertFromBase16String(audio_config.aes_key));

[Alpha Left Google, 2013/11/07 01:10:11]

The key should be a binary string instead of a base64. It should the
application's join to convert from base64 to binary.

[pwestin, 2013/11/07 17:16:04]

Done.

+    encryptor_.reset(new crypto::Encryptor());
+    encryptor_->Init(key, crypto::Encryptor::CTR, std::string());
+  } else if (audio_config.aes_iv_mask.size() != 0 ||
+             audio_config.aes_iv_mask.size() != 0) {
+    DCHECK(false) << "Invalid crypto configuration";
+  }
+
   rtcp_.SetRemoteSSRC(audio_config.incoming_feedback_ssrc);
 
   if (!audio_config.use_external_encoder) {
     audio_encoder_ = new AudioEncoder(cast_environment, audio_config);
   }
   ScheduleNextRtcpReport();
 }
 
 AudioSender::~AudioSender() {}
 
 void AudioSender::InsertRawAudioFrame(
     const PcmAudioFrame* audio_frame,
     const base::TimeTicks& recorded_time,
     const base::Closure callback) {
   DCHECK(audio_encoder_.get()) << "Invalid internal state";
 
   audio_encoder_->InsertRawAudioFrame(audio_frame, recorded_time,
       base::Bind(&AudioSender::SendEncodedAudioFrame,
                  weak_factory_.GetWeakPtr()),
       callback);
 }
 
 void AudioSender::InsertCodedAudioFrame(const EncodedAudioFrame* audio_frame,
                                         const base::TimeTicks& recorded_time,
                                         const base::Closure callback) {
   DCHECK(audio_encoder_.get() == NULL) << "Invalid internal state";
-  rtp_sender_.IncomingEncodedAudioFrame(audio_frame, recorded_time);
+
+  if (encryptor_) {
+    EncodedAudioFrame encrypted_frame;
+    if (EncryptAudioFrame(audio_frame, &encrypted_frame)) {
+      rtp_sender_.IncomingEncodedAudioFrame(&encrypted_frame, recorded_time);
+    } else {
+      DCHECK(false) << "Encryption error";
+      return;
+    }
+  } else {
+    rtp_sender_.IncomingEncodedAudioFrame(audio_frame, recorded_time);
+  }
   callback.Run();
 }
 
+bool AudioSender::EncryptAudioFrame(const EncodedAudioFrame* audio_frame,
+                                    EncodedAudioFrame* encrypted_frame) {
+  DCHECK(encryptor_) << "Invalid state";
+
+  encryptor_->SetCounter(GetAesNounce(audio_frame->frame_id, iv_mask_));
+
+  encrypted_frame->codec = audio_frame->codec;
+  encrypted_frame->frame_id = audio_frame->frame_id;
+  encrypted_frame->samples = audio_frame->samples;
+
+  return encryptor_->Encrypt(audio_frame->data, &encrypted_frame->data);
+}
+
 void AudioSender::SendEncodedAudioFrame(
     scoped_ptr<EncodedAudioFrame> audio_frame,
     const base::TimeTicks& recorded_time) {
-  rtp_sender_.IncomingEncodedAudioFrame(audio_frame.get(), recorded_time);
+  if (encryptor_) {
+    EncodedAudioFrame encrypted_frame;
+    if (EncryptAudioFrame(audio_frame.get(), &encrypted_frame)) {
+      rtp_sender_.IncomingEncodedAudioFrame(&encrypted_frame, recorded_time);
+    } else {
+      DCHECK(false) << "Encryption error";
+      return;
+    }
+  } else {
+    rtp_sender_.IncomingEncodedAudioFrame(audio_frame.get(), recorded_time);
+  }
 }
 
 void AudioSender::ResendPackets(
     const MissingFramesAndPacketsMap& missing_frames_and_packets) {
   rtp_sender_.ResendPackets(missing_frames_and_packets);
 }
 
 void AudioSender::IncomingRtcpPacket(const uint8* packet, size_t length,
                                      const base::Closure callback) {
   rtcp_.IncomingRtcpPacket(packet, length);
@@ skipping 12 matching lines @@
                  time_to_next);
 }
 
 void AudioSender::SendRtcpReport() {
   rtcp_.SendRtcpReport(incoming_feedback_ssrc_);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media