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/encryptor.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 44 matching lines @@
               paced_packet_sender,
               rtp_audio_sender_statistics_.get(),
               NULL,
               audio_config.rtcp_mode,
               base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval),
               audio_config.sender_ssrc,
               audio_config.incoming_feedback_ssrc,
               audio_config.rtcp_c_name),
         initialized_(false),
         weak_factory_(this) {
+  if (audio_config.aes_iv_mask.size() == kAesKeySize &&
+      audio_config.aes_key.size() == kAesKeySize) {
+    iv_mask_ = audio_config.aes_iv_mask;
+    crypto::SymmetricKey* key = crypto::SymmetricKey::Import(
+        crypto::SymmetricKey::AES, audio_config.aes_key);
+    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_key.size() != 0) {
+    DCHECK(false) << "Invalid crypto configuration";
+  }
   if (!audio_config.use_external_encoder) {
     audio_encoder_ = new AudioEncoder(
         cast_environment, audio_config,
         base::Bind(&AudioSender::SendEncodedAudioFrame,
                    weak_factory_.GetWeakPtr()));
   }
 }
 
 AudioSender::~AudioSender() {}
 
@@ skipping 11 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(audio_encoder_.get()) << "Invalid internal state";
   audio_encoder_->InsertAudio(audio_bus, recorded_time, done_callback);
 }
 
 void AudioSender::InsertCodedAudioFrame(const EncodedAudioFrame* audio_frame,
                                         const base::TimeTicks& recorded_time,
                                         const base::Closure callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   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)) {
+      // Logging already done.
+      return;
+    }
+    rtp_sender_.IncomingEncodedAudioFrame(&encrypted_frame, recorded_time);
+  } else {
+    rtp_sender_.IncomingEncodedAudioFrame(audio_frame, recorded_time);
+  }
   callback.Run();
 }
 
 void AudioSender::SendEncodedAudioFrame(
     scoped_ptr<EncodedAudioFrame> audio_frame,
     const base::TimeTicks& recorded_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   InitializeTimers();
-  rtp_sender_.IncomingEncodedAudioFrame(audio_frame.get(), recorded_time);
+  if (encryptor_) {
+    EncodedAudioFrame encrypted_frame;
+    if (!EncryptAudioFrame(*audio_frame.get(), &encrypted_frame)) {
+      // Logging already done.
+      return;
+    }
+    rtp_sender_.IncomingEncodedAudioFrame(&encrypted_frame, recorded_time);
+  } else {
+    rtp_sender_.IncomingEncodedAudioFrame(audio_frame.get(), recorded_time);
+  }
+}
+
+bool AudioSender::EncryptAudioFrame(const EncodedAudioFrame& audio_frame,
+                                    EncodedAudioFrame* encrypted_frame) {
+  DCHECK(encryptor_) << "Invalid state";
+
+  if (!encryptor_->SetCounter(GetAesNonce(audio_frame.frame_id, iv_mask_))) {
+    NOTREACHED() << "Failed to set counter";
+    return false;
+  }
+  if (!encryptor_->Encrypt(audio_frame.data, &encrypted_frame->data)) {
+    NOTREACHED() << "Encrypt error";
+    return false;
+  }
+  encrypted_frame->codec = audio_frame.codec;
+  encrypted_frame->frame_id = audio_frame.frame_id;
+  encrypted_frame->samples = audio_frame.samples;
+  return true;
 }
 
 void AudioSender::ResendPackets(
     const MissingFramesAndPacketsMap& missing_frames_and_packets) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtp_sender_.ResendPackets(missing_frames_and_packets);
 }
 
 void AudioSender::IncomingRtcpPacket(const uint8* packet, size_t length,
                                      const base::Closure callback) {
@@ skipping 16 matching lines @@
 }
 
 void AudioSender::SendRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtcp_.SendRtcpFromRtpSender(NULL);  // TODO(pwestin): add logging.
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media