Index: media/crypto/aes_decryptor_unittest.cc |
diff --git a/media/crypto/aes_decryptor_unittest.cc b/media/crypto/aes_decryptor_unittest.cc |
deleted file mode 100644 |
index 8feaec4b1addae61e2a227743e72a02a515eaa9f..0000000000000000000000000000000000000000 |
--- a/media/crypto/aes_decryptor_unittest.cc |
+++ /dev/null |
@@ -1,664 +0,0 @@ |
-// 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 "media/base/decoder_buffer.h" |
-#include "media/base/decrypt_config.h" |
-#include "media/base/mock_filters.h" |
-#include "media/crypto/aes_decryptor.h" |
-#include "media/webm/webm_constants.h" |
-#include "testing/gmock/include/gmock/gmock.h" |
-#include "testing/gtest/include/gtest/gtest.h" |
- |
-using ::testing::_; |
-using ::testing::ElementsAreArray; |
-using ::testing::Gt; |
-using ::testing::IsNull; |
-using ::testing::NotNull; |
-using ::testing::SaveArg; |
-using ::testing::StrEq; |
-using ::testing::StrNe; |
- |
-MATCHER(IsEmpty, "") { return arg.empty(); } |
- |
-namespace media { |
- |
-// |encrypted_data| is encrypted from |plain_text| using |key|. |key_id| is |
-// used to distinguish |key|. |
-struct WebmEncryptedData { |
- uint8 plain_text[32]; |
- int plain_text_size; |
- uint8 key_id[32]; |
- int key_id_size; |
- uint8 key[32]; |
- int key_size; |
- uint8 encrypted_data[64]; |
- int encrypted_data_size; |
-}; |
- |
-static const char kClearKeySystem[] = "org.w3.clearkey"; |
- |
-// Frames 0 & 1 are encrypted with the same key. Frame 2 is encrypted with a |
-// different key. Frame 3 is unencrypted. |
-const WebmEncryptedData kWebmEncryptedFrames[] = { |
- { |
- // plaintext |
- "Original data.", 14, |
- // key_id |
- { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, |
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, |
- 0x10, 0x11, 0x12, 0x13 |
- }, 20, |
- // key |
- { 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, |
- 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23 |
- }, 16, |
- // encrypted_data |
- { 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
- 0xff, 0xf0, 0xd1, 0x12, 0xd5, 0x24, 0x81, 0x96, |
- 0x55, 0x1b, 0x68, 0x9f, 0x38, 0x91, 0x85 |
- }, 23 |
- }, { |
- // plaintext |
- "Changed Original data.", 22, |
- // key_id |
- { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, |
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, |
- 0x10, 0x11, 0x12, 0x13 |
- }, 20, |
- // key |
- { 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, |
- 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23 |
- }, 16, |
- // encrypted_data |
- { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
- 0x00, 0x57, 0x66, 0xf4, 0x12, 0x1a, 0xed, 0xb5, |
- 0x79, 0x1c, 0x8e, 0x25, 0xd7, 0x17, 0xe7, 0x5e, |
- 0x16, 0xe3, 0x40, 0x08, 0x27, 0x11, 0xe9 |
- }, 31 |
- }, { |
- // plaintext |
- "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, 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, |
- // key |
- { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, |
- 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40 |
- }, 16, |
- // encrypted_data |
- { 0x00, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, |
- 0x20, 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, |
- 0x6c, 0x20, 0x64, 0x61, 0x74, 0x61, 0x2e |
- }, 23 |
- } |
-}; |
- |
-static const uint8 kWebmWrongSizedKey[] = { 0x20, 0x20 }; |
- |
-static const uint8 kSubsampleOriginalData[] = "Original subsample data."; |
-static const int kSubsampleOriginalDataSize = 24; |
- |
-static const uint8 kSubsampleKeyId[] = { 0x00, 0x01, 0x02, 0x03 }; |
- |
-static const uint8 kSubsampleKey[] = { |
- 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, |
- 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 |
-}; |
- |
-static const uint8 kSubsampleIv[] = { |
- 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, |
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
-}; |
- |
-// kSubsampleOriginalData encrypted with kSubsampleKey and kSubsampleIv using |
-// kSubsampleEntriesNormal. |
-static const uint8 kSubsampleEncryptedData[] = { |
- 0x4f, 0x72, 0x09, 0x16, 0x09, 0xe6, 0x79, 0xad, |
- 0x70, 0x73, 0x75, 0x62, 0x09, 0xbb, 0x83, 0x1d, |
- 0x4d, 0x08, 0xd7, 0x78, 0xa4, 0xa7, 0xf1, 0x2e |
-}; |
- |
-// kSubsampleEncryptedData with 8 bytes padding at the beginning. |
-static const uint8 kPaddedSubsampleEncryptedData[] = { |
- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, |
- 0x4f, 0x72, 0x09, 0x16, 0x09, 0xe6, 0x79, 0xad, |
- 0x70, 0x73, 0x75, 0x62, 0x09, 0xbb, 0x83, 0x1d, |
- 0x4d, 0x08, 0xd7, 0x78, 0xa4, 0xa7, 0xf1, 0x2e |
-}; |
- |
-// kSubsampleOriginalData encrypted with kSubsampleKey and kSubsampleIv but |
-// without any subsamples (or equivalently using kSubsampleEntriesCypherOnly). |
-static const uint8 kEncryptedData[] = { |
- 0x2f, 0x03, 0x09, 0xef, 0x71, 0xaf, 0x31, 0x16, |
- 0xfa, 0x9d, 0x18, 0x43, 0x1e, 0x96, 0x71, 0xb5, |
- 0xbf, 0xf5, 0x30, 0x53, 0x9a, 0x20, 0xdf, 0x95 |
-}; |
- |
-// Subsample entries for testing. The sum of |cypher_bytes| and |clear_bytes| of |
-// all entries must be equal to kSubsampleOriginalDataSize to make the subsample |
-// entries valid. |
- |
-static const SubsampleEntry kSubsampleEntriesNormal[] = { |
- { 2, 7 }, |
- { 3, 11 }, |
- { 1, 0 } |
-}; |
- |
-static const SubsampleEntry kSubsampleEntriesClearOnly[] = { |
- { 7, 0 }, |
- { 8, 0 }, |
- { 9, 0 } |
-}; |
- |
-static const SubsampleEntry kSubsampleEntriesCypherOnly[] = { |
- { 0, 6 }, |
- { 0, 8 }, |
- { 0, 10 } |
-}; |
- |
-// 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. |
-// |iv_size| is the size of |iv| in bytes. Returns a string of |
-// kDecryptionKeySize bytes. |
-static std::string GenerateCounterBlock(const uint8* iv, int iv_size) { |
- CHECK_GT(iv_size, 0); |
- CHECK_LE(iv_size, DecryptConfig::kDecryptionKeySize); |
- |
- std::string counter_block(reinterpret_cast<const char*>(iv), iv_size); |
- counter_block.append(DecryptConfig::kDecryptionKeySize - iv_size, 0); |
- 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.get()); |
- DCHECK_EQ(kWebMSignalByteSize, 1); |
- |
- uint8 signal_byte = data[0]; |
- int data_offset = kWebMSignalByteSize; |
- |
- // 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) { |
- counter_block_str = GenerateCounterBlock(data + data_offset, kWebMIvSize); |
- data_offset += kWebMIvSize; |
- } |
- |
- encrypted_buffer->set_decrypt_config( |
- 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; |
-} |
- |
-// TODO(xhwang): Refactor this function to encapsulate more details about |
-// creating an encrypted DecoderBuffer with subsamples so we don't have so much |
-// boilerplate code in each test before calling this function. |
-static scoped_refptr<DecoderBuffer> CreateSubsampleEncryptedBuffer( |
- const uint8* data, int data_size, |
- const uint8* key_id, int key_id_size, |
- const uint8* iv, int iv_size, |
- int data_offset, |
- const std::vector<SubsampleEntry>& subsample_entries) { |
- scoped_refptr<DecoderBuffer> encrypted_buffer = |
- DecoderBuffer::CopyFrom(data, data_size); |
- CHECK(encrypted_buffer.get()); |
- encrypted_buffer->set_decrypt_config( |
- scoped_ptr<DecryptConfig>(new DecryptConfig( |
- std::string(reinterpret_cast<const char*>(key_id), key_id_size), |
- std::string(reinterpret_cast<const char*>(iv), iv_size), |
- data_offset, |
- subsample_entries))); |
- return encrypted_buffer; |
-} |
- |
-class AesDecryptorTest : public testing::Test { |
- public: |
- AesDecryptorTest() |
- : decryptor_( |
- base::Bind(&AesDecryptorTest::KeyAdded, base::Unretained(this)), |
- base::Bind(&AesDecryptorTest::KeyError, base::Unretained(this)), |
- base::Bind(&AesDecryptorTest::KeyMessage, base::Unretained(this))), |
- decrypt_cb_(base::Bind(&AesDecryptorTest::BufferDecrypted, |
- base::Unretained(this))), |
- subsample_entries_normal_( |
- kSubsampleEntriesNormal, |
- kSubsampleEntriesNormal + arraysize(kSubsampleEntriesNormal)) { |
- } |
- |
- protected: |
- void GenerateKeyRequest(const uint8* key_id, int key_id_size) { |
- EXPECT_CALL(*this, KeyMessage( |
- StrNe(std::string()), ElementsAreArray(key_id, key_id_size), "")) |
- .WillOnce(SaveArg<0>(&session_id_string_)); |
- EXPECT_TRUE(decryptor_.GenerateKeyRequest( |
- std::string(), key_id, key_id_size)); |
- } |
- |
- void AddKeyAndExpectToSucceed(const uint8* key_id, int key_id_size, |
- const uint8* key, int key_size) { |
- EXPECT_CALL(*this, KeyAdded(session_id_string_)); |
- decryptor_.AddKey(key, key_size, key_id, key_id_size, |
- session_id_string_); |
- } |
- |
- void AddKeyAndExpectToFail(const uint8* key_id, int key_id_size, |
- const uint8* key, int key_size) { |
- EXPECT_CALL(*this, KeyError(session_id_string_, |
- MediaKeys::kUnknownError, 0)); |
- decryptor_.AddKey(key, key_size, key_id, key_id_size, session_id_string_); |
- } |
- |
- MOCK_METHOD2(BufferDecrypted, void(Decryptor::Status, |
- const scoped_refptr<DecoderBuffer>&)); |
- |
- void DecryptAndExpectToSucceed(const scoped_refptr<DecoderBuffer>& encrypted, |
- const uint8* plain_text, int plain_text_size) { |
- scoped_refptr<DecoderBuffer> decrypted; |
- EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kSuccess, NotNull())) |
- .WillOnce(SaveArg<1>(&decrypted)); |
- |
- decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_); |
- ASSERT_TRUE(decrypted.get()); |
- ASSERT_EQ(plain_text_size, decrypted->data_size()); |
- EXPECT_EQ(0, memcmp(plain_text, decrypted->data(), plain_text_size)); |
- } |
- |
- void DecryptAndExpectDataMismatch( |
- const scoped_refptr<DecoderBuffer>& encrypted, |
- const uint8* plain_text, int plain_text_size) { |
- scoped_refptr<DecoderBuffer> decrypted; |
- EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kSuccess, NotNull())) |
- .WillOnce(SaveArg<1>(&decrypted)); |
- |
- decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_); |
- ASSERT_TRUE(decrypted.get()); |
- ASSERT_EQ(plain_text_size, decrypted->data_size()); |
- EXPECT_NE(0, memcmp(plain_text, decrypted->data(), plain_text_size)); |
- } |
- |
- void DecryptAndExpectSizeDataMismatch( |
- const scoped_refptr<DecoderBuffer>& encrypted, |
- const uint8* plain_text, int plain_text_size) { |
- scoped_refptr<DecoderBuffer> decrypted; |
- EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kSuccess, NotNull())) |
- .WillOnce(SaveArg<1>(&decrypted)); |
- |
- decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_); |
- ASSERT_TRUE(decrypted.get()); |
- EXPECT_NE(plain_text_size, decrypted->data_size()); |
- EXPECT_NE(0, memcmp(plain_text, decrypted->data(), plain_text_size)); |
- } |
- |
- void DecryptAndExpectToFail(const scoped_refptr<DecoderBuffer>& encrypted) { |
- EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kError, IsNull())); |
- decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_); |
- } |
- |
- MOCK_METHOD1(KeyAdded, void(const std::string&)); |
- MOCK_METHOD3(KeyError, void(const std::string&, |
- MediaKeys::KeyError, int)); |
- MOCK_METHOD3(KeyMessage, void(const std::string& session_id, |
- const std::vector<uint8>& message, |
- const std::string& default_url)); |
- |
- AesDecryptor decryptor_; |
- std::string session_id_string_; |
- AesDecryptor::DecryptCB decrypt_cb_; |
- std::vector<SubsampleEntry> subsample_entries_normal_; |
-}; |
- |
-TEST_F(AesDecryptorTest, GenerateKeyRequestWithNullInitData) { |
- EXPECT_CALL(*this, KeyMessage(StrNe(std::string()), IsEmpty(), "")); |
- EXPECT_TRUE(decryptor_.GenerateKeyRequest(std::string(), NULL, 0)); |
-} |
- |
-TEST_F(AesDecryptorTest, NormalWebMDecryption) { |
- const WebmEncryptedData& frame = kWebmEncryptedFrames[0]; |
- GenerateKeyRequest(frame.key_id, frame.key_id_size); |
- AddKeyAndExpectToSucceed(frame.key_id, frame.key_id_size, |
- frame.key, frame.key_size); |
- scoped_refptr<DecoderBuffer> encrypted_data = |
- CreateWebMEncryptedBuffer(frame.encrypted_data, |
- frame.encrypted_data_size, |
- frame.key_id, frame.key_id_size); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed(encrypted_data, |
- frame.plain_text, |
- frame.plain_text_size)); |
-} |
- |
-TEST_F(AesDecryptorTest, UnencryptedFrameWebMDecryption) { |
- const WebmEncryptedData& frame = kWebmEncryptedFrames[3]; |
- GenerateKeyRequest(frame.key_id, frame.key_id_size); |
- AddKeyAndExpectToSucceed(frame.key_id, frame.key_id_size, |
- frame.key, frame.key_size); |
- scoped_refptr<DecoderBuffer> encrypted_data = |
- CreateWebMEncryptedBuffer(frame.encrypted_data, |
- frame.encrypted_data_size, |
- frame.key_id, frame.key_id_size); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed(encrypted_data, |
- frame.plain_text, |
- frame.plain_text_size)); |
-} |
- |
-TEST_F(AesDecryptorTest, WrongKey) { |
- const WebmEncryptedData& frame = kWebmEncryptedFrames[0]; |
- GenerateKeyRequest(frame.key_id, frame.key_id_size); |
- |
- // Change the first byte of the key. |
- std::vector<uint8> wrong_key(frame.key, frame.key + frame.key_size); |
- wrong_key[0]++; |
- |
- AddKeyAndExpectToSucceed(frame.key_id, frame.key_id_size, |
- &wrong_key[0], frame.key_size); |
- scoped_refptr<DecoderBuffer> encrypted_data = |
- CreateWebMEncryptedBuffer(frame.encrypted_data, |
- frame.encrypted_data_size, |
- frame.key_id, frame.key_id_size); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectDataMismatch(encrypted_data, |
- frame.plain_text, |
- frame.plain_text_size)); |
-} |
- |
-TEST_F(AesDecryptorTest, NoKey) { |
- const WebmEncryptedData& frame = kWebmEncryptedFrames[0]; |
- GenerateKeyRequest(frame.key_id, frame.key_id_size); |
- |
- scoped_refptr<DecoderBuffer> encrypted_data = |
- CreateWebMEncryptedBuffer(frame.encrypted_data, frame.encrypted_data_size, |
- frame.key_id, frame.key_id_size); |
- EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kNoKey, IsNull())); |
- decryptor_.Decrypt(Decryptor::kVideo, encrypted_data, decrypt_cb_); |
-} |
- |
-TEST_F(AesDecryptorTest, KeyReplacement) { |
- const WebmEncryptedData& frame = kWebmEncryptedFrames[0]; |
- GenerateKeyRequest(frame.key_id, frame.key_id_size); |
- |
- // Change the first byte of the key. |
- std::vector<uint8> wrong_key(frame.key, frame.key + frame.key_size); |
- wrong_key[0]++; |
- |
- AddKeyAndExpectToSucceed(frame.key_id, frame.key_id_size, |
- &wrong_key[0], frame.key_size); |
- scoped_refptr<DecoderBuffer> encrypted_data = |
- CreateWebMEncryptedBuffer(frame.encrypted_data, |
- frame.encrypted_data_size, |
- frame.key_id, frame.key_id_size); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectDataMismatch(encrypted_data, |
- frame.plain_text, |
- frame.plain_text_size)); |
- AddKeyAndExpectToSucceed(frame.key_id, frame.key_id_size, |
- frame.key, frame.key_size); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed(encrypted_data, |
- frame.plain_text, |
- frame.plain_text_size)); |
-} |
- |
-TEST_F(AesDecryptorTest, WrongSizedKey) { |
- const WebmEncryptedData& frame = kWebmEncryptedFrames[0]; |
- GenerateKeyRequest(frame.key_id, frame.key_id_size); |
- AddKeyAndExpectToFail(frame.key_id, frame.key_id_size, |
- kWebmWrongSizedKey, arraysize(kWebmWrongSizedKey)); |
-} |
- |
-TEST_F(AesDecryptorTest, MultipleKeysAndFrames) { |
- const WebmEncryptedData& frame = kWebmEncryptedFrames[0]; |
- GenerateKeyRequest(frame.key_id, frame.key_id_size); |
- AddKeyAndExpectToSucceed(frame.key_id, frame.key_id_size, |
- frame.key, frame.key_size); |
- scoped_refptr<DecoderBuffer> encrypted_data = |
- CreateWebMEncryptedBuffer(frame.encrypted_data, |
- frame.encrypted_data_size, |
- frame.key_id, frame.key_id_size); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed(encrypted_data, |
- frame.plain_text, |
- frame.plain_text_size)); |
- |
- const WebmEncryptedData& frame2 = kWebmEncryptedFrames[2]; |
- GenerateKeyRequest(frame2.key_id, frame2.key_id_size); |
- AddKeyAndExpectToSucceed(frame2.key_id, frame2.key_id_size, |
- 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 = |
- 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]; |
- GenerateKeyRequest(frame.key_id, frame.key_id_size); |
- AddKeyAndExpectToSucceed(frame.key_id, frame.key_id_size, |
- frame.key, frame.key_size); |
- |
- // Change byte 13 to modify the IV. Bytes 13-20 of WebM encrypted data |
- // contains the IV. |
- std::vector<uint8> frame_with_bad_iv( |
- frame.encrypted_data, frame.encrypted_data + frame.encrypted_data_size); |
- frame_with_bad_iv[1]++; |
- |
- scoped_refptr<DecoderBuffer> encrypted_data = |
- CreateWebMEncryptedBuffer(&frame_with_bad_iv[0], |
- frame.encrypted_data_size, |
- frame.key_id, frame.key_id_size); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectDataMismatch(encrypted_data, |
- frame.plain_text, |
- frame.plain_text_size)); |
-} |
- |
-TEST_F(AesDecryptorTest, CorruptedData) { |
- const WebmEncryptedData& frame = kWebmEncryptedFrames[0]; |
- GenerateKeyRequest(frame.key_id, frame.key_id_size); |
- AddKeyAndExpectToSucceed(frame.key_id, frame.key_id_size, |
- frame.key, frame.key_size); |
- |
- // Change last byte to modify the data. Bytes 21+ of WebM encrypted data |
- // contains the encrypted frame. |
- std::vector<uint8> frame_with_bad_vp8_data( |
- frame.encrypted_data, frame.encrypted_data + frame.encrypted_data_size); |
- frame_with_bad_vp8_data[frame.encrypted_data_size - 1]++; |
- |
- scoped_refptr<DecoderBuffer> encrypted_data = |
- CreateWebMEncryptedBuffer(&frame_with_bad_vp8_data[0], |
- frame.encrypted_data_size, |
- frame.key_id, frame.key_id_size); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectDataMismatch(encrypted_data, |
- frame.plain_text, |
- frame.plain_text_size)); |
-} |
- |
-TEST_F(AesDecryptorTest, EncryptedAsUnencryptedFailure) { |
- const WebmEncryptedData& frame = kWebmEncryptedFrames[0]; |
- GenerateKeyRequest(frame.key_id, frame.key_id_size); |
- AddKeyAndExpectToSucceed(frame.key_id, frame.key_id_size, |
- frame.key, frame.key_size); |
- |
- // Change signal byte from an encrypted frame to an unencrypted frame. Byte |
- // 12 of WebM encrypted data contains the signal byte. |
- std::vector<uint8> frame_with_wrong_signal_byte( |
- frame.encrypted_data, frame.encrypted_data + frame.encrypted_data_size); |
- frame_with_wrong_signal_byte[0] = 0; |
- |
- scoped_refptr<DecoderBuffer> encrypted_data = |
- CreateWebMEncryptedBuffer(&frame_with_wrong_signal_byte[0], |
- frame.encrypted_data_size, |
- frame.key_id, frame.key_id_size); |
- ASSERT_NO_FATAL_FAILURE( |
- DecryptAndExpectSizeDataMismatch(encrypted_data, |
- frame.plain_text, |
- frame.plain_text_size)); |
-} |
- |
-TEST_F(AesDecryptorTest, UnencryptedAsEncryptedFailure) { |
- const WebmEncryptedData& frame = kWebmEncryptedFrames[3]; |
- GenerateKeyRequest(frame.key_id, frame.key_id_size); |
- AddKeyAndExpectToSucceed(frame.key_id, frame.key_id_size, |
- frame.key, frame.key_size); |
- |
- // Change signal byte from an unencrypted frame to an encrypted frame. Byte |
- // 0 of WebM encrypted data contains the signal byte. |
- std::vector<uint8> frame_with_wrong_signal_byte( |
- frame.encrypted_data, frame.encrypted_data + frame.encrypted_data_size); |
- frame_with_wrong_signal_byte[0] = kWebMFlagEncryptedFrame; |
- |
- scoped_refptr<DecoderBuffer> encrypted_data = |
- CreateWebMEncryptedBuffer(&frame_with_wrong_signal_byte[0], |
- frame.encrypted_data_size, |
- frame.key_id, frame.key_id_size); |
- ASSERT_NO_FATAL_FAILURE( |
- DecryptAndExpectSizeDataMismatch(encrypted_data, |
- frame.plain_text, |
- frame.plain_text_size)); |
-} |
- |
-TEST_F(AesDecryptorTest, SubsampleDecryption) { |
- GenerateKeyRequest(kSubsampleKeyId, arraysize(kSubsampleKeyId)); |
- AddKeyAndExpectToSucceed(kSubsampleKeyId, arraysize(kSubsampleKeyId), |
- kSubsampleKey, arraysize(kSubsampleKey)); |
- scoped_refptr<DecoderBuffer> encrypted_data = CreateSubsampleEncryptedBuffer( |
- kSubsampleEncryptedData, arraysize(kSubsampleEncryptedData), |
- kSubsampleKeyId, arraysize(kSubsampleKeyId), |
- kSubsampleIv, arraysize(kSubsampleIv), |
- 0, |
- subsample_entries_normal_); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed( |
- encrypted_data, kSubsampleOriginalData, kSubsampleOriginalDataSize)); |
-} |
- |
-// Ensures noninterference of data offset and subsample mechanisms. We never |
-// expect to encounter this in the wild, but since the DecryptConfig doesn't |
-// disallow such a configuration, it should be covered. |
-TEST_F(AesDecryptorTest, SubsampleDecryptionWithOffset) { |
- GenerateKeyRequest(kSubsampleKeyId, arraysize(kSubsampleKeyId)); |
- AddKeyAndExpectToSucceed(kSubsampleKeyId, arraysize(kSubsampleKeyId), |
- kSubsampleKey, arraysize(kSubsampleKey)); |
- scoped_refptr<DecoderBuffer> encrypted_data = CreateSubsampleEncryptedBuffer( |
- kPaddedSubsampleEncryptedData, arraysize(kPaddedSubsampleEncryptedData), |
- kSubsampleKeyId, arraysize(kSubsampleKeyId), |
- kSubsampleIv, arraysize(kSubsampleIv), |
- arraysize(kPaddedSubsampleEncryptedData) |
- - arraysize(kSubsampleEncryptedData), |
- subsample_entries_normal_); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed( |
- encrypted_data, kSubsampleOriginalData, kSubsampleOriginalDataSize)); |
-} |
- |
-// No subsample or offset. |
-TEST_F(AesDecryptorTest, NormalDecryption) { |
- GenerateKeyRequest(kSubsampleKeyId, arraysize(kSubsampleKeyId)); |
- AddKeyAndExpectToSucceed(kSubsampleKeyId, arraysize(kSubsampleKeyId), |
- kSubsampleKey, arraysize(kSubsampleKey)); |
- scoped_refptr<DecoderBuffer> encrypted_data = CreateSubsampleEncryptedBuffer( |
- kEncryptedData, arraysize(kEncryptedData), |
- kSubsampleKeyId, arraysize(kSubsampleKeyId), |
- kSubsampleIv, arraysize(kSubsampleIv), |
- 0, |
- std::vector<SubsampleEntry>()); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed( |
- encrypted_data, kSubsampleOriginalData, kSubsampleOriginalDataSize)); |
-} |
- |
-TEST_F(AesDecryptorTest, IncorrectSubsampleSize) { |
- GenerateKeyRequest(kSubsampleKeyId, arraysize(kSubsampleKeyId)); |
- AddKeyAndExpectToSucceed(kSubsampleKeyId, arraysize(kSubsampleKeyId), |
- kSubsampleKey, arraysize(kSubsampleKey)); |
- std::vector<SubsampleEntry> entries = subsample_entries_normal_; |
- entries[2].cypher_bytes += 1; |
- |
- scoped_refptr<DecoderBuffer> encrypted_data = CreateSubsampleEncryptedBuffer( |
- kSubsampleEncryptedData, arraysize(kSubsampleEncryptedData), |
- kSubsampleKeyId, arraysize(kSubsampleKeyId), |
- kSubsampleIv, arraysize(kSubsampleIv), |
- 0, |
- entries); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToFail(encrypted_data)); |
-} |
- |
-// No cypher bytes in any of the subsamples. |
-TEST_F(AesDecryptorTest, SubsampleClearBytesOnly) { |
- GenerateKeyRequest(kSubsampleKeyId, arraysize(kSubsampleKeyId)); |
- AddKeyAndExpectToSucceed(kSubsampleKeyId, arraysize(kSubsampleKeyId), |
- kSubsampleKey, arraysize(kSubsampleKey)); |
- std::vector<SubsampleEntry> subsample_entries_clear_only( |
- kSubsampleEntriesClearOnly, |
- kSubsampleEntriesClearOnly + arraysize(kSubsampleEntriesClearOnly)); |
- scoped_refptr<DecoderBuffer> encrypted_data = CreateSubsampleEncryptedBuffer( |
- kSubsampleOriginalData, kSubsampleOriginalDataSize, |
- kSubsampleKeyId, arraysize(kSubsampleKeyId), |
- kSubsampleIv, arraysize(kSubsampleIv), |
- 0, |
- subsample_entries_clear_only); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed(encrypted_data, |
- kSubsampleOriginalData, kSubsampleOriginalDataSize)); |
-} |
- |
-// No clear bytes in any of the subsamples. |
-TEST_F(AesDecryptorTest, SubsampleCypherBytesOnly) { |
- GenerateKeyRequest(kSubsampleKeyId, arraysize(kSubsampleKeyId)); |
- AddKeyAndExpectToSucceed(kSubsampleKeyId, arraysize(kSubsampleKeyId), |
- kSubsampleKey, arraysize(kSubsampleKey)); |
- std::vector<SubsampleEntry> subsample_entries_cypher_only( |
- kSubsampleEntriesCypherOnly, |
- kSubsampleEntriesCypherOnly + arraysize(kSubsampleEntriesCypherOnly)); |
- scoped_refptr<DecoderBuffer> encrypted_data = CreateSubsampleEncryptedBuffer( |
- kEncryptedData, arraysize(kEncryptedData), |
- kSubsampleKeyId, arraysize(kSubsampleKeyId), |
- kSubsampleIv, arraysize(kSubsampleIv), |
- 0, |
- subsample_entries_cypher_only); |
- ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToSucceed(encrypted_data, |
- kSubsampleOriginalData, kSubsampleOriginalDataSize)); |
-} |
- |
-} // namespace media |