Add support for v0.3 of the encrypted WebM specification.

media/webm/webm_cluster_parser.cc

 // Copyright (c) 2012 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/webm/webm_cluster_parser.h"
 
 #include "base/logging.h"
 #include "base/sys_byteorder.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/webm/webm_constants.h"
 
 namespace media {
 
 // Generates a 16 byte CTR counter block. The CTR counter block format is a
 // CTR IV appended with a CTR block counter. |iv| is an 8 byte CTR IV.
 // Always returns a valid pointer to a buffer of kDecryptionKeySize bytes.
 static scoped_array<uint8> GenerateCounterBlock(uint64 iv) {

[xhwang, 2012/08/01 00:45:41]

CounterBlock is only 16bytes, let's just make it a std::string instead of a
scoped_array.

[fgalligan1, 2012/08/01 01:36:10]

Done.

   scoped_array<uint8> counter_block_data(
       new uint8[DecryptConfig::kDecryptionKeySize]);
 
   // Set the IV.
   memcpy(counter_block_data.get(), &iv, sizeof(iv));
 
   // Set block counter to all 0's.
   memset(counter_block_data.get() + sizeof(iv),
          0,
          DecryptConfig::kDecryptionKeySize - sizeof(iv));
@@ skipping 184 matching lines @@
   }
 
   last_block_timecode_ = timecode;
 
   base::TimeDelta timestamp = base::TimeDelta::FromMicroseconds(
       (cluster_timecode_ + timecode) * timecode_multiplier_);
 
   // Every encrypted Block has an HMAC and IV prepended to it. Current encrypted
   // WebM request for comments specification is here
   // http://wiki.webmproject.org/encryption/webm-encryption-rfc
-  bool encrypted = track_num == video_.track_num() &&
-                   video_encryption_key_id_.get();
-  // If encrypted skip past the HMAC. Encrypted buffers must include the IV and
-  // the encrypted frame because the decryptor will verify this data before
-  // decryption. The HMAC and IV will be copied into DecryptConfig.
-  int offset = (encrypted) ? kWebMHmacSize : 0;
+  bool encrypted_stream = track_num == video_.track_num() &&

[xhwang, 2012/08/01 00:45:41]

"encrypted_stream" is a noun. How about something like "is_stream_encrypted".

Also, in WebM, we use "track" instead of "stream", correct? If so,
"is_track_encrypted"?

[fgalligan1, 2012/08/01 01:36:10]

Done.

+                          video_encryption_key_id_.get();
+
+  // If stream is encrypted skip past the HMAC. Encrypted buffers must include
+  // the signal byte, the IV (if frame is encrypted) and
+  // the frame because the decryptor will verify this data before decryption.
+  // The HMAC and IV will be copied into DecryptConfig.
+  int offset = (encrypted_stream) ? kWebMHmacSize : 0;
 
   // The first bit of the flags is set when the block contains only keyframes.
   // http://www.matroska.org/technical/specs/index.html
   bool is_keyframe = (flags & 0x80) != 0;
   scoped_refptr<StreamParserBuffer> buffer =
       StreamParserBuffer::CopyFrom(data + offset, size - offset, is_keyframe);
 
-  if (encrypted) {
-    uint64 network_iv;
-    memcpy(&network_iv, data + kWebMHmacSize, sizeof(network_iv));
-    const uint64 iv = base::NetToHost64(network_iv);
+  if (encrypted_stream) {
+    int data_offset = 1;
+    uint8 signal_byte = data[kWebMHmacSize];

[xhwang, 2012/08/01 00:45:41]

How about moving "int data_offset = 1" after this line and change it to:
int data_offset = sizeof(signal_byte);

[fgalligan1, 2012/08/01 01:36:10]

Done.

 
-    scoped_array<uint8> counter_block(GenerateCounterBlock(iv));
+    // Setting the DecryptConfig object of the buffer while leaving the
+    // initialization vector empty will tell the decryptor that the frame is
+    // unencrypted but integrity should still be checked.
+    std::string counter_block_str;
+
+    if (signal_byte & kWebMEncryptedFrame) {
+      uint64 network_iv;
+      memcpy(&network_iv, data + kWebMHmacSize + 1, sizeof(network_iv));

[xhwang, 2012/08/01 00:45:41]

s/1/data_offset/

[fgalligan1, 2012/08/01 01:36:10]

Done.

+      const uint64 iv = base::NetToHost64(network_iv);
+
+      scoped_array<uint8> counter_block(GenerateCounterBlock(iv));
+      counter_block_str.assign(
+          reinterpret_cast<const char*>(counter_block.get()),
+          DecryptConfig::kDecryptionKeySize);

[xhwang, 2012/08/01 00:45:41]

This code will be much easier if GenerateCounterBlock() returns std::string. See
comment above.

[fgalligan1, 2012/08/01 01:36:10]

Done.

+      data_offset += sizeof(iv);
+    }
+
     buffer->SetDecryptConfig(scoped_ptr<DecryptConfig>(new DecryptConfig(
         std::string(
             reinterpret_cast<const char*>(video_encryption_key_id_.get()),
             video_encryption_key_id_size_),
-        std::string(
-            reinterpret_cast<const char*>(counter_block.get()),
-            DecryptConfig::kDecryptionKeySize),
+        counter_block_str,
         std::string(reinterpret_cast<const char*>(data), kWebMHmacSize),
-        sizeof(iv),
+        data_offset,
         std::vector<SubsampleEntry>())));
   }
 
   buffer->SetTimestamp(timestamp);
   if (cluster_start_time_ == kNoTimestamp())
     cluster_start_time_ = timestamp;
 
   if (block_duration >= 0) {
     buffer->SetDuration(base::TimeDelta::FromMicroseconds(
         block_duration * timecode_multiplier_));
@@ skipping 25 matching lines @@
 
   buffers_.push_back(buffer);
   return true;
 }
 
 void WebMClusterParser::Track::Reset() {
   buffers_.clear();
 }
 
 }  // namespace media