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/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 80 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() == kAesBlockSize * 2 &&
+      video_config.aes_key.size() == kAesBlockSize * 2) {
+    iv_mask_ = ConvertFromBase16String(video_config.aes_iv_mask);
+    crypto::SymmetricKey* key = crypto::SymmetricKey::Import(
+        crypto::SymmetricKey::AES,
+        ConvertFromBase16String(video_config.aes_key));

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

Again don't do the conversion here.

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

Done.

+    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_iv_mask.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),
       true,
       video_config.sender_ssrc,
@@ skipping 14 matching lines @@
   DCHECK(video_encoder_.get()) << "Invalid state";
 
   if (!video_encoder_->EncodeVideoFrame(video_frame, capture_time,
       base::Bind(&VideoSender::SendEncodedVideoFrameMainThread,
           weak_factory_.GetWeakPtr()), callback)) {
     VLOG(0) << "Failed to InsertRawVideoFrame";
     cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE, callback);
   }
 }
 
-void VideoSender::InsertCodedVideoFrame(const EncodedVideoFrame* encoded_frame,
+void VideoSender::InsertCodedVideoFrame(EncodedVideoFrame* encoded_frame,
                                         const base::TimeTicks& capture_time,
                                         const base::Closure callback) {
   DCHECK(!video_encoder_.get()) << "Invalid state";
   DCHECK(encoded_frame) << "Invalid argument";
 
   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);
 }
 
-void VideoSender::SendEncodedVideoFrame(const EncodedVideoFrame* encoded_frame,
+bool VideoSender::EncryptVideoFrame(const EncodedVideoFrame* video_frame,
+                                    EncodedVideoFrame* encrypted_frame) {
+  DCHECK(encryptor_) << "Invalid state";
+
+  encryptor_->SetCounter(GetAesNounce(video_frame->frame_id, iv_mask_));
+
+  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 encryptor_->Encrypt(video_frame->data, &encrypted_frame->data);
+}
+
+void VideoSender::SendEncodedVideoFrame(EncodedVideoFrame* encoded_frame,
                                         const base::TimeTicks& capture_time) {
   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)) {
+      rtp_sender_->IncomingEncodedVideoFrame(&encrypted_video_frame,
+                                             capture_time);
+    } else {
+      DCHECK(false) << "Encryption error";
+      return;
+    }
+  } 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_key_frame_id_ = encoded_frame->frame_id;
   }
   last_sent_frame_id_ = encoded_frame->frame_id;
   UpdateFramesInFlight();
 }
 
 void VideoSender::OnReceivedIntraFrameRequest() {
@@ skipping 192 matching lines @@
 void VideoSender::ResendFrame(uint8 resend_frame_id) {
   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