Cast: Added support for AES-CTR crypto.

media/cast/video_receiver/video_receiver.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_receiver/video_receiver.h"
 
 #include <algorithm>
+
 #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/framer/framer.h"
 #include "media/cast/video_receiver/video_decoder.h"
 
 namespace media {
 namespace cast {
 
 const int64 kMinSchedulingDelayMs = 1;
 
 static const int64 kMinTimeBetweenOffsetUpdatesMs = 2000;
@@ skipping 97 matching lines @@
         incoming_payload_feedback_(new LocalRtpVideoFeedback(this)),
         rtp_receiver_(cast_environment_->Clock(), NULL, &video_config,
                       incoming_payload_callback_.get()),
         rtp_video_receiver_statistics_(
             new LocalRtpReceiverStatistics(&rtp_receiver_)),
         weak_factory_(this) {
   int max_unacked_frames = video_config.rtp_max_delay_ms *
       video_config.max_frame_rate / 1000;
   DCHECK(max_unacked_frames) << "Invalid argument";
 
+  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 in this low level step.

[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";
+  }
+
   framer_.reset(new Framer(cast_environment->Clock(),
                            incoming_payload_feedback_.get(),
                            video_config.incoming_ssrc,
                            video_config.decoder_faster_than_max_frame_rate,
                            max_unacked_frames));
   if (!video_config.use_external_decoder) {
     video_decoder_.reset(new VideoDecoder(video_config));
   }
 
   rtcp_.reset(
@@ skipping 55 matching lines @@
           base::Bind(frame_decoded_callback,
                      base::Passed(&video_frame), render_time));
   } else {
     // This will happen if we decide to decode but not show a frame.
     cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
         base::Bind(&VideoReceiver::GetRawVideoFrame,
             weak_factory_.GetWeakPtr(), frame_decoded_callback));
   }
 }
 
+bool VideoReceiver::DecryptVideoFrame(
+    const EncodedVideoFrame* encrypted_frame,
+    EncodedVideoFrame* video_frame) {
+  DCHECK(encryptor_) << "Invalid state";
+
+  // TODO(pwestin): the frame id must be a 32 bit number.
+  encryptor_->SetCounter(GetAesNounce(encrypted_frame->frame_id, iv_mask_));
+
+  video_frame->codec = encrypted_frame->codec;
+  video_frame->key_frame = encrypted_frame->key_frame;
+  video_frame->frame_id = encrypted_frame->frame_id;
+  video_frame->last_referenced_frame_id =
+      encrypted_frame->last_referenced_frame_id;
+
+  return encryptor_->Decrypt(encrypted_frame->data, &video_frame->data);
+}
+
 // Called from the main cast thread.
 void VideoReceiver::GetEncodedVideoFrame(
     const VideoFrameEncodedCallback& callback) {
   scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
 
   if (!framer_->GetEncodedVideoFrame(encoded_frame.get(), &rtp_timestamp,
                                      &next_frame)) {
     // We have no video frames. Wait for new packet(s).
     queued_encoded_callbacks_.push_back(callback);
     return;
   }
+
+  if (encryptor_) {
+    EncodedVideoFrame* decrypted_video_frame = new EncodedVideoFrame();

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

This should be a scoped_ptr<T>.

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

Done.

+
+    if (DecryptVideoFrame(encoded_frame.get(), decrypted_video_frame)) {
+      encoded_frame.reset(decrypted_video_frame);
+    } else {
+      DCHECK(false) << "Decryption error";
+      return;
+    }
+  }
+
   base::TimeTicks render_time;
   if (PullEncodedVideoFrame(rtp_timestamp, next_frame, &encoded_frame,
                             &render_time)) {
     cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
         base::Bind(callback, base::Passed(&encoded_frame), render_time));
   } else {
     // We have a video frame; however we are missing packets and we have time
     // to wait for new packet(s).
     queued_encoded_callbacks_.push_back(callback);
   }
@@ skipping 60 matching lines @@
     // We have no video frames. Wait for new packet(s).
     // Since the application can post multiple VideoFrameEncodedCallback and
     // we only check the next frame to play out we might have multiple timeout
     // events firing after each other; however this should be a rare event.
     VLOG(1) << "Failed to retrieved a complete frame at this point in time";
     return;
   }
   VLOG(1) << "PlayoutTimeout retrieved frame "
           << static_cast<int>(encoded_frame->frame_id);
 
+  if (encryptor_) {
+    EncodedVideoFrame* decrypted_video_frame = new EncodedVideoFrame();

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

Same here, use scoped_ptr<T>.

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

Done.

+
+    if (DecryptVideoFrame(encoded_frame.get(), decrypted_video_frame)) {
+      encoded_frame.reset(decrypted_video_frame);
+    } else {
+      DCHECK(false) << "Decryption error";
+      delete decrypted_video_frame;
+      return;
+    }
+  }
+
   base::TimeTicks render_time;
   if (PullEncodedVideoFrame(rtp_timestamp, next_frame, &encoded_frame,
                             &render_time)) {
     if (!queued_encoded_callbacks_.empty()) {
       VideoFrameEncodedCallback callback = queued_encoded_callbacks_.front();
       queued_encoded_callbacks_.pop_front();
       cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
           base::Bind(callback, base::Passed(&encoded_frame), render_time));
     }
   } else {
@@ skipping 113 matching lines @@
                 weak_factory_.GetWeakPtr()), time_to_next);
 }
 
 void VideoReceiver::SendNextRtcpReport() {
   rtcp_->SendRtcpReport(incoming_ssrc_);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media