Cast: Added support for AES-CTR crypto.

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/symmetric_key.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"
 
 // 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 {
@@ skipping 72 matching lines @@
   incoming_payload_feedback_.reset(new LocalRtpAudioFeedback(this));
   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_ = new AudioDecoder(audio_config);
   }
+  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);
+    decryptor_.reset(new crypto::Encryptor());
+    decryptor_->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";
+  }
+
   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->Clock(),
                        NULL,
@@ skipping 16 matching lines @@
                                             size_t payload_size,
                                             const RtpCastHeader& rtp_header) {
   // TODO(pwestin): update this as video to refresh over time.
   if (time_first_incoming_packet_.is_null()) {
     first_incoming_rtp_timestamp_ = rtp_header.webrtc.header.timestamp;
     time_first_incoming_packet_ =  cast_environment_->Clock()->NowTicks();
   }
 
   if (audio_decoder_) {
     DCHECK(!audio_buffer_) << "Invalid internal state";
-    audio_decoder_->IncomingParsedRtpPacket(payload_data, payload_size,
-                                            rtp_header);
+    if (decryptor_) {
+      // TODO(pwestin): we need to change to 32 bits frame id.
+      decryptor_->SetCounter(GetAesNounce(rtp_header.frame_id, iv_mask_));

[wtc, 2013/11/13 20:57:17]

GetAesNounce seems to be a typo. Should it be GetAesNonce?

We should check the return value of decryptor_->SetCounter().

[pwestin, 2013/11/15 19:38:17]

Done.

+      std::string plaintext;
+      if (!decryptor_->Decrypt(base::StringPiece(reinterpret_cast<const char*>(
+          payload_data), payload_size), &plaintext)) {
+        DCHECK(false) << "Decryption error";

[wtc, 2013/11/13 20:57:17]

This should be a LOG statement rather than a DCHECK if decryption error may
result from network errors.

[pwestin, 2013/11/15 19:38:17]

Done.

+        return;
+      }
+      audio_decoder_->IncomingParsedRtpPacket(
+          reinterpret_cast<const uint8*>(plaintext.data()), plaintext.size(),
+          rtp_header);
+    } else {
+      audio_decoder_->IncomingParsedRtpPacket(payload_data, payload_size,
+                                              rtp_header);

[wtc, 2013/11/13 20:57:17]

Nit: ideally, this code should look like:

  if (audio_decoder_) {
    DCHECK(!audio_buffer_) << "Invalid internal state";
    ... initialize plaintext to be payload_data ...
    if (decryptor_) {
      ... decrypt payload_data into plaintext ...
    }
    audio_decoder_->IncomingParsedRtpPacket(... plaintext ...,
                                            rtp_header);
  }

[pwestin, 2013/11/15 19:38:17]

Done.

+    }
     return;
   }
   DCHECK(audio_buffer_) << "Invalid internal state";
   DCHECK(!audio_decoder_) << "Invalid internal state";
   bool complete = audio_buffer_->InsertPacket(payload_data, payload_size,
                                               rtp_header);
   if (!complete) return;  // Audio frame not complete; wait for more packets.
   if (queued_encoded_callbacks_.empty()) return;  // No pending callback.
 
   AudioFrameEncodedCallback callback = queued_encoded_callbacks_.front();
@@ skipping 52 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_) {
+    if (!DecryptAudioFrame(&encoded_frame)) {
+      DCHECK(false) << "Decryption error";

[wtc, 2013/11/13 20:57:17]

This should be a LOG statement rather than a DCHECK if decryption error may
result from network errors.

Similarly for the DCHECK on line 271.

[pwestin, 2013/11/15 19:38:17]

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();
   }
 }
 
 void AudioReceiver::GetEncodedAudioFrame(
     const AudioFrameEncodedCallback& callback) {
   DCHECK(audio_buffer_) << "Invalid function call in this configuration";
 
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
   scoped_ptr<EncodedAudioFrame> encoded_frame(new 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_) {
+    if (!DecryptAudioFrame(&encoded_frame)) {
+      DCHECK(false) << "Decryption error";
+      return;

[wtc, 2013/11/13 20:57:17]

Do we need to do
    queued_encoded_callbacks_.push_back(callback);
before returning?

[pwestin, 2013/11/15 19:38:17]

Done.

+    }
+  }
   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);
   }
 }
 
 bool AudioReceiver::PostEncodedAudioFrame(
     const AudioFrameEncodedCallback& callback,
@@ skipping 63 matching lines @@
                             base::TimeDelta());
     }
   }
   // This can fail if we have not received any RTCP packets in a long time.
   return rtcp_->RtpTimestampInSenderTime(frequency_, rtp_timestamp,
                                          &rtp_timestamp_in_ticks) ?
     rtp_timestamp_in_ticks + time_offset_ + target_delay_delta_ :
     now;
 }
 
+bool AudioReceiver::DecryptAudioFrame(
+    scoped_ptr<EncodedAudioFrame>* audio_frame) {
+  DCHECK(decryptor_) << "Invalid state";
+
+  scoped_ptr<EncodedAudioFrame> decrypted_audio_frame(
+      new EncodedAudioFrame());

[wtc, 2013/11/13 20:57:17]

I think we just need a std::string for the decrypted data, rather than an
EncodedAudioFrame:
  
  decryptor_->SetCounter(GetAesNounce((*audio_frame)->frame_id, iv_mask_));
  
  std::string decrypted_data;
  if (!decryptor_->Decrypt((*audio_frame)->data, &decrypted_data))
    return false;

  (*audio_frame)->data.swap(decrypted_data);
  return true;

Would this work?

[pwestin, 2013/11/15 19:38:17]

Done.

+
+  // TODO(pwestin): the frame id must be a 32 bit number.
+  decryptor_->SetCounter(GetAesNounce((*audio_frame)->frame_id, iv_mask_));
+
+  if (!decryptor_->Decrypt((*audio_frame)->data,
+                           &decrypted_audio_frame->data)) {
+    return false;
+  }
+  decrypted_audio_frame->codec = (*audio_frame)->codec;
+  decrypted_audio_frame->frame_id = (*audio_frame)->frame_id;

[wtc, 2013/11/13 20:57:17]

Do we need to copy the "samples" field?

[pwestin, 2013/11/15 19:38:17]

Done.

+
+  audio_frame->swap(decrypted_audio_frame);
+  return true;
+}
+
 void AudioReceiver::ScheduleNextRtcpReport() {
   base::TimeDelta time_to_send = rtcp_->TimeToSendNextRtcpReport() -
       cast_environment_->Clock()->NowTicks();
 
   time_to_send = std::max(time_to_send,
       base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
 
   cast_environment_->PostDelayedTask(CastEnvironment::MAIN, FROM_HERE,
       base::Bind(&AudioReceiver::SendNextRtcpReport,
       weak_factory_.GetWeakPtr()), time_to_send);
@@ skipping 22 matching lines @@
 }
 
 void AudioReceiver::SendNextCastMessage() {
   DCHECK(audio_buffer_) << "Invalid function call in this configuration";
   audio_buffer_->SendCastMessage();  // Will only send a message if it is time.
   ScheduleNextCastMessage();
 }
 
 }  // namespace cast
 }  // namespace media