Cast: Adding helper crypto classes

media/cast/audio_receiver/audio_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/audio_receiver/audio_receiver.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 "base/strings/string_piece.h"
 #include "media/cast/audio_receiver/audio_decoder.h"
 #include "media/cast/framer/framer.h"
 #include "media/cast/rtcp/rtcp.h"
 #include "media/cast/rtp_receiver/rtp_receiver.h"
+#include "media/cast/transport/cast_transport_defines.h"
 
 // Max time we wait until an audio frame is due to be played out is released.
 static const int64 kMaxAudioFrameWaitMs = 20;
 static const int64 kMinSchedulingDelayMs = 1;
 
 namespace media {
 namespace cast {
 
 DecodedAudioCallbackData::DecodedAudioCallbackData()
     : number_of_10ms_blocks(0), desired_frequency(0), callback() {}
@@ skipping 67 matching lines @@
   if (audio_config.use_external_decoder) {
     audio_buffer_.reset(new Framer(cast_environment->Clock(),
                                    incoming_payload_feedback_.get(),
                                    audio_config.incoming_ssrc,
                                    true,
                                    0));
   } else {
     audio_decoder_.reset(new AudioDecoder(
         cast_environment, audio_config, incoming_payload_feedback_.get()));
   }
-  if (audio_config.aes_iv_mask.size() == kAesKeySize &&
-      audio_config.aes_key.size() == kAesKeySize) {
-    iv_mask_ = audio_config.aes_iv_mask;
-    decryption_key_.reset(crypto::SymmetricKey::Import(
-        crypto::SymmetricKey::AES, audio_config.aes_key));
-    decryptor_.reset(new crypto::Encryptor());
-    decryptor_->Init(
-        decryption_key_.get(), 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";
-  }
-
+  decryptor_.Initialize(audio_config.aes_key, audio_config.aes_iv_mask);
   rtp_receiver_.reset(new RtpReceiver(cast_environment->Clock(),
                                       &audio_config,
                                       NULL,
                                       incoming_payload_callback_.get()));
   rtp_audio_receiver_statistics_.reset(
       new LocalRtpReceiverStatistics(rtp_receiver_.get()));
   base::TimeDelta rtcp_interval_delta =
       base::TimeDelta::FromMilliseconds(audio_config.rtcp_interval);
   rtcp_.reset(new Rtcp(cast_environment,
                        NULL,
@@ skipping 34 matching lines @@
   // TODO(pwestin): update this as video to refresh over time.
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (time_first_incoming_packet_.is_null()) {
     InitializeTimers();
     first_incoming_rtp_timestamp_ = rtp_header.webrtc.header.timestamp;
     time_first_incoming_packet_ = now;
   }
 
   if (audio_decoder_) {
     DCHECK(!audio_buffer_) << "Invalid internal state";
-    std::string plaintext(reinterpret_cast<const char*>(payload_data),
-                          payload_size);
-    if (decryptor_) {
-      plaintext.clear();
-      if (!decryptor_->SetCounter(GetAesNonce(rtp_header.frame_id, iv_mask_))) {
-        NOTREACHED() << "Failed to set counter";
-        return;
-      }
-      if (!decryptor_->Decrypt(
+    std::string plaintext;
+    if (decryptor_.initialized()) {
+      if (!decryptor_.Decrypt(
+               rtp_header.frame_id,
                base::StringPiece(reinterpret_cast<const char*>(payload_data),
                                  payload_size),
-               &plaintext)) {
-        VLOG(1) << "Decryption error";
+               &plaintext))
         return;
-      }
+    } else {
+      plaintext = std::string(reinterpret_cast<const char*>(payload_data),

[hubbe, 2014/01/31 18:30:39]

Won't this copy the data twice?
Perhaps use append() instead?

+                              payload_size);
     }
     audio_decoder_->IncomingParsedRtpPacket(
         reinterpret_cast<const uint8*>(plaintext.data()),
         plaintext.size(),
         rtp_header);
     if (!queued_decoded_callbacks_.empty()) {
       DecodedAudioCallbackData decoded_data = queued_decoded_callbacks_.front();
       queued_decoded_callbacks_.pop_front();
       cast_environment_->PostTask(
           CastEnvironment::AUDIO_DECODER,
@@ skipping 125 matching lines @@
   if (!audio_buffer_->GetEncodedAudioFrame(
            encoded_frame.get(), &rtp_timestamp, &next_frame)) {
     // We have no audio frames. Wait for new packet(s).
     // Since the application can post multiple AudioFrameEncodedCallback 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;
   }
 
-  if (decryptor_ && !DecryptAudioFrame(&encoded_frame)) {
+  if (decryptor_.initialized() && !DecryptAudioFrame(&encoded_frame)) {
     // Logging already done.
     return;
   }
 
   if (PostEncodedAudioFrame(queued_encoded_callbacks_.front(),
                             rtp_timestamp,
                             next_frame,
                             &encoded_frame)) {
     // Call succeed remove callback from list.
     queued_encoded_callbacks_.pop_front();
@@ skipping 10 matching lines @@
   scoped_ptr<transport::EncodedAudioFrame> encoded_frame(
       new transport::EncodedAudioFrame());
 
   if (!audio_buffer_->GetEncodedAudioFrame(
            encoded_frame.get(), &rtp_timestamp, &next_frame)) {
     // We have no audio frames. Wait for new packet(s).
     VLOG(1) << "Wait for more audio packets in frame";
     queued_encoded_callbacks_.push_back(callback);
     return;
   }
-  if (decryptor_ && !DecryptAudioFrame(&encoded_frame)) {
+  if (decryptor_.initialized() && !DecryptAudioFrame(&encoded_frame)) {
     // Logging already done.
     queued_encoded_callbacks_.push_back(callback);
     return;
   }
   if (!PostEncodedAudioFrame(
            callback, rtp_timestamp, next_frame, &encoded_frame)) {
     // We have an audio frame; however we are missing packets and we have time
     // to wait for new packet(s).
     queued_encoded_callbacks_.push_back(callback);
   }
@@ skipping 115 matching lines @@
   }
   // Don't allow the playout time to go backwards.
   if (last_playout_time_ > playout_time)
     playout_time = last_playout_time_;
   last_playout_time_ = playout_time;
   return playout_time;
 }
 
 bool AudioReceiver::DecryptAudioFrame(
     scoped_ptr<transport::EncodedAudioFrame>* audio_frame) {
-  DCHECK(decryptor_) << "Invalid state";
+  if (!decryptor_.initialized())
+    return false;
 
-  if (!decryptor_->SetCounter(
-           GetAesNonce((*audio_frame)->frame_id, iv_mask_))) {
-    NOTREACHED() << "Failed to set counter";
-    return false;
-  }
   std::string decrypted_audio_data;
-  if (!decryptor_->Decrypt((*audio_frame)->data, &decrypted_audio_data)) {
-    VLOG(1) << "Decryption error";
-    // Give up on this frame, release it from jitter buffer.
+  if (!decryptor_.Decrypt((*audio_frame)->frame_id,
+                          (*audio_frame)->data,
+                          &decrypted_audio_data)) {
+    // Give up on this frame, release it from the jitter buffer.
     audio_buffer_->ReleaseFrame((*audio_frame)->frame_id);
     return false;
   }
   (*audio_frame)->data.swap(decrypted_audio_data);
   return true;
 }
 
 void AudioReceiver::ScheduleNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeDelta time_to_send = rtcp_->TimeToSendNextRtcpReport() -
@@ skipping 50 matching lines @@
   }
   if (audio_decoder_) {
     // Will only send a message if it is time.
     audio_decoder_->SendCastMessage();
   }
   ScheduleNextCastMessage();
 }
 
 }  // namespace cast
 }  // namespace media