Cast: Added support for AES-CTR crypto.

media/cast/video_sender/video_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/video_sender/video_sender.h"
 
 #include <list>
 
 #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/cast_defines.h"
 #include "media/cast/pacing/paced_sender.h"
 #include "media/cast/video_sender/video_encoder.h"
 
 namespace media {
 namespace cast {
 
 const int64 kMinSchedulingDelayMs = 1;
 
 class LocalRtcpVideoSenderFeedback : public RtcpSenderFeedback {
@@ skipping 58 matching lines @@
       new LocalRtpVideoSenderStatistics(rtp_sender_.get()));
 
   if (video_config.use_external_encoder) {
     DCHECK(video_encoder_controller) << "Invalid argument";
     video_encoder_controller_ = video_encoder_controller;
   } else {
     video_encoder_ = new VideoEncoder(cast_environment, video_config,
         max_unacked_frames_);
     video_encoder_controller_ = video_encoder_.get();
   }
+
+  if (video_config.aes_iv_mask.size() == kAesKeySize &&
+      video_config.aes_key.size() == kAesKeySize) {
+    iv_mask_ = video_config.aes_iv_mask;
+    crypto::SymmetricKey* key = crypto::SymmetricKey::Import(
+        crypto::SymmetricKey::AES, video_config.aes_key);
+    encryptor_.reset(new crypto::Encryptor());
+    encryptor_->Init(key, crypto::Encryptor::CTR, std::string());
+  } else if (video_config.aes_iv_mask.size() != 0 ||
+             video_config.aes_key.size() != 0) {
+    DCHECK(false) << "Invalid crypto configuration";
+  }
+
   rtcp_.reset(new Rtcp(
       cast_environment_->Clock(),
       rtcp_feedback_.get(),
       paced_packet_sender,
       rtp_video_sender_statistics_.get(),
       NULL,
       video_config.rtcp_mode,
       base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
       video_config.sender_ssrc,
       video_config.incoming_feedback_ssrc,
@@ skipping 36 matching lines @@
   SendEncodedVideoFrame(encoded_frame, capture_time);
   cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE, callback);
 }
 
 void VideoSender::SendEncodedVideoFrameMainThread(
     scoped_ptr<EncodedVideoFrame> video_frame,
     const base::TimeTicks& capture_time) {
   SendEncodedVideoFrame(video_frame.get(), capture_time);
 }
 
+bool VideoSender::EncryptVideoFrame(const EncodedVideoFrame& video_frame,
+                                    EncodedVideoFrame* encrypted_frame) {
+  DCHECK(encryptor_) << "Invalid state";
+
+  if (!encryptor_->SetCounter(GetAesNonce(video_frame.frame_id, iv_mask_))) {
+    NOTREACHED() << "Failed to set counter";
+    return false;
+  }
+
+  if (!encryptor_->Encrypt(video_frame.data, &encrypted_frame->data)) {
+    NOTREACHED() << "Encrypt error";
+    return false;
+  }
+  encrypted_frame->codec = video_frame.codec;
+  encrypted_frame->key_frame = video_frame.key_frame;
+  encrypted_frame->frame_id = video_frame.frame_id;
+  encrypted_frame->last_referenced_frame_id =
+      video_frame.last_referenced_frame_id;
+  return true;
+}
+
 void VideoSender::SendEncodedVideoFrame(const EncodedVideoFrame* encoded_frame,
                                         const base::TimeTicks& capture_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   last_send_time_ = cast_environment_->Clock()->NowTicks();
-  rtp_sender_->IncomingEncodedVideoFrame(encoded_frame, capture_time);
+
+  if (encryptor_) {
+    EncodedVideoFrame encrypted_video_frame;
+
+    if (!EncryptVideoFrame(*encoded_frame, &encrypted_video_frame)) {
+      // Logging already done.
+      return;
+    }
+    rtp_sender_->IncomingEncodedVideoFrame(&encrypted_video_frame,
+                                           capture_time);
+  } else {
+    rtp_sender_->IncomingEncodedVideoFrame(encoded_frame, capture_time);
+  }
   if (encoded_frame->key_frame) {
     VLOG(1) << "Send encoded key frame; frame_id:"
             << static_cast<int>(encoded_frame->frame_id);
   }
   last_sent_frame_id_ = static_cast<int>(encoded_frame->frame_id);
   UpdateFramesInFlight();
   InitializeTimers();
 }
 
 void VideoSender::IncomingRtcpPacket(const uint8* packet, size_t length,
@@ skipping 185 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   MissingFramesAndPacketsMap missing_frames_and_packets;
   PacketIdSet missing;
   missing_frames_and_packets.insert(std::make_pair(resend_frame_id, missing));
   rtp_sender_->ResendPackets(missing_frames_and_packets);
   last_send_time_ = cast_environment_->Clock()->NowTicks();
 }
 
 }  // namespace cast
 }  // namespace media