Change WebM parser to treat IVs from encrypted WebM as raw data.

media/crypto/aes_decryptor_unittest.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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/sys_byteorder.h"
@@ skipping 74 matching lines @@
     "Original data.", 14,
     // key_id
     { 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
       0x2c, 0x2d, 0x2e, 0x2f, 0x30
       }, 13,
     // key
     { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
       0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40
       }, 16,
     // encrypted_data
-    { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-      0x01, 0x9c, 0x71, 0x26, 0x57, 0x3e, 0x25, 0x37,
+    { 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x9c, 0x71, 0x26, 0x57, 0x3e, 0x25, 0x37,
       0xf7, 0x31, 0x81, 0x19, 0x64, 0xce, 0xbc
       }, 23
   },
   {
     // plaintext
     "Changed Original data.", 22,
     // key_id
     { 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
       0x2c, 0x2d, 0x2e, 0x2f, 0x30
       }, 13,
@@ skipping 50 matching lines @@
 
 static const SubsampleEntry kSubsampleEntries[] = {
   { 2, 7 },
   { 3, 11 },
   { 1, 0 }
 };
 
 // Returns a 16 byte CTR counter block. The CTR counter block format is a
 // CTR IV appended with a CTR block counter. |iv| is a CTR IV. |iv_size| is
 // the size of |iv| in bytes.
-static std::string GenerateCounterBlock(const uint8* iv, int iv_size) {
-  const int kDecryptionKeySize = 16;
-  CHECK_GT(iv_size, 0);
-  CHECK_LE(iv_size, kDecryptionKeySize);
+static std::string GenerateCounterBlock(const std::string& iv) {
+  CHECK_GT(iv.size(), 0UL);
+  CHECK_LE(iv.size(), static_cast<size_t>(DecryptConfig::kDecryptionKeySize));
 
-  std::string counter_block(reinterpret_cast<const char*>(iv), iv_size);
-  counter_block.append(kDecryptionKeySize - iv_size, 0);
+  std::string counter_block(iv);
+  counter_block.append(DecryptConfig::kDecryptionKeySize - iv.size(), 0);

[ddorwin, 2012/10/13 00:26:17]

Why wasn't the scoping necessary before?

[fgalligan1, 2012/10/13 06:20:31]

The old version defined the value at the top of the function for some reason. We
are including decrypt_config.h so that seems like a better value to use. Also
changed the function to perform one less copy.

   return counter_block;
 }
 
 // Creates a WebM encrypted buffer that the demuxer would pass to the
 // decryptor. |data| is the payload of a WebM encrypted Block. |key_id| is
 // initialization data from the WebM file. Every encrypted Block has
 // a signal byte prepended to a frame. If the frame is encrypted then an IV is
 // prepended to the Block. Current encrypted WebM request for comments
 // specification is here
 // http://wiki.webmproject.org/encryption/webm-encryption-rfc
 static scoped_refptr<DecoderBuffer> CreateWebMEncryptedBuffer(
     const uint8* data, int data_size,
     const uint8* key_id, int key_id_size) {
   scoped_refptr<DecoderBuffer> encrypted_buffer = DecoderBuffer::CopyFrom(
       data, data_size);
   CHECK(encrypted_buffer);
 
   uint8 signal_byte = data[0];
   int data_offset = sizeof(signal_byte);
 
   // Setting the DecryptConfig object of the buffer while leaving the
   // initialization vector empty will tell the decryptor that the frame is
   // unencrypted.
   std::string counter_block_str;
 
   if (signal_byte & kWebMFlagEncryptedFrame) {
-    uint64 network_iv;
-    memcpy(&network_iv, data + data_offset, sizeof(network_iv));
-    const uint64 iv = base::NetToHost64(network_iv);
-    counter_block_str =
-        GenerateCounterBlock(reinterpret_cast<const uint8*>(&iv), sizeof(iv));
-    data_offset += sizeof(iv);
+    const std::string iv(reinterpret_cast<const char*>(data + data_offset),
+                         kWebMIvSize);
+    data_offset += kWebMIvSize;
+    counter_block_str = GenerateCounterBlock(iv);
   }
 
   encrypted_buffer->SetDecryptConfig(
       scoped_ptr<DecryptConfig>(new DecryptConfig(
           std::string(reinterpret_cast<const char*>(key_id), key_id_size),
           counter_block_str,
           data_offset,
           std::vector<SubsampleEntry>())));
   return encrypted_buffer;
 }
@@ skipping 211 matching lines @@
                            frame2.key, frame2.key_size);
 
   const WebmEncryptedData& frame1 = kWebmEncryptedFrames[1];
   scoped_refptr<DecoderBuffer> encrypted_data1 =
       CreateWebMEncryptedBuffer(frame1.encrypted_data,
                                 frame1.encrypted_data_size,
                                 frame1.key_id, frame1.key_id_size);
   ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed(encrypted_data1,
                                                     frame1.plain_text,
                                                     frame1.plain_text_size));
-
   scoped_refptr<DecoderBuffer> encrypted_data2 =

[ddorwin, 2012/10/13 00:26:17]

Is there a reason the empty line was removed?

[fgalligan1, 2012/10/13 06:20:31]

No. I'll put it back to make less noise.

       CreateWebMEncryptedBuffer(frame2.encrypted_data,
                                 frame2.encrypted_data_size,
                                 frame2.key_id, frame2.key_id_size);
   ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed(encrypted_data2,
                                                     frame2.plain_text,
                                                     frame2.plain_text_size));
 }
 
 TEST_F(AesDecryptorTest, CorruptedIv) {
   const WebmEncryptedData& frame = kWebmEncryptedFrames[0];
@@ skipping 137 matching lines @@
   scoped_refptr<DecoderBuffer> encrypted_data = CreateSubsampleEncryptedBuffer(
       kSubsampleData, arraysize(kSubsampleData),
       kSubsampleKeyId, arraysize(kSubsampleKeyId),
       kSubsampleIv, arraysize(kSubsampleIv),
       0,
       entries);
   ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToFail(encrypted_data));
 }
 
 }  // namespace media