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

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 <vector>
 
 #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.
 // Returns a string of kDecryptionKeySize bytes.
-static std::string GenerateCounterBlock(uint64 iv) {
-  std::string counter_block(reinterpret_cast<char*>(&iv), sizeof(iv));
-  counter_block.append(DecryptConfig::kDecryptionKeySize - sizeof(iv), 0);
+static std::string GenerateCounterBlock(const uint8* iv, size_t iv_size) {
+  std::string counter_block(reinterpret_cast<const char*>(iv), iv_size);

[ddorwin, 2012/10/13 17:21:27]

Should we counter_block.resize(DecryptConfig::kDecryptionKeySize);?

[fgalligan1, 2012/10/14 16:45:24]

What about this?
std::string counter_block(DecryptConfig::kDecryptionKeySize, 0);
memcpy(&counter_block[0], reinterpret_cast<const char*>(iv), iv_size);

[ddorwin, 2012/10/15 02:32:49]

SGTM

+  counter_block.append(DecryptConfig::kDecryptionKeySize - iv_size, 0);
   return counter_block;
 }
 
 WebMClusterParser::WebMClusterParser(int64 timecode_scale,
                                      int audio_track_num,
                                      int video_track_num,
                                      const std::string& audio_encryption_key_id,
                                      const std::string& video_encryption_key_id)
     : timecode_multiplier_(timecode_scale / 1000.0),
       audio_encryption_key_id_(audio_encryption_key_id),
@@ skipping 144 matching lines @@
 
   block_data_.reset(new uint8[size]);
   memcpy(block_data_.get(), data, size);
   block_data_size_ = size;
   return true;
 }
 
 bool WebMClusterParser::OnBlock(int track_num, int timecode,
                                 int  block_duration,
                                 int flags,
                                 const uint8* data, int size) {

[ddorwin, 2012/10/13 17:21:27]

There is no check that size is not negative. DCHECK is fine.

[fgalligan1, 2012/10/14 16:45:24]

Done.

   if (cluster_timecode_ == -1) {
     DVLOG(1) << "Got a block before cluster timecode.";
     return false;
   }
 
   if (timecode < 0) {
     DVLOG(1) << "Got a block with negative timecode offset " << timecode;
     return false;
   }
 
@@ skipping 23 matching lines @@
   // 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, size, is_keyframe);
 
   // Every encrypted Block has a signal byte and IV prepended to it. Current
   // encrypted WebM request for comments specification is here
   // http://wiki.webmproject.org/encryption/webm-encryption-rfc
   if (!encryption_key_id.empty()) {
     uint8 signal_byte = data[0];

[ddorwin, 2012/10/13 17:21:27]

We don't check that size is >0 here or >8 at 239. Do we have guarantees
somewhere? One check for all of these would be nice, but I'm not sure how.

[fgalligan1, 2012/10/14 16:45:24]

I don't think we can do one check as we need to check the first byte to see if
the IV is appended. I added 2 checks. 

     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;
 
     if (signal_byte & kWebMFlagEncryptedFrame) {
-      uint64 network_iv;
-      memcpy(&network_iv, data + data_offset, sizeof(network_iv));
-      data_offset += sizeof(network_iv);
-      counter_block = GenerateCounterBlock(base::NetToHost64(network_iv));
+      counter_block = GenerateCounterBlock(data + data_offset, kWebMIvSize);
+      data_offset += kWebMIvSize;
     }
 
     // TODO(fgalligan): Revisit if DecryptConfig needs to be set on unencrypted
     // frames after the CDM API is finalized.
     // Unencrypted frames of potentially encrypted streams currently set
     // DecryptConfig.
     buffer->SetDecryptConfig(scoped_ptr<DecryptConfig>(new DecryptConfig(
         encryption_key_id,
         counter_block,
         data_offset,
@@ skipping 28 matching lines @@
 
   buffers_.push_back(buffer);
   return true;
 }
 
 void WebMClusterParser::Track::Reset() {
   buffers_.clear();
 }
 
 }  // namespace media