Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(930)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: media/crypto/aes_decryptor_unittest.cc

Issue 22362007: Relocate last remnants of webkit/renderer/media code. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Make chromeos crypto dep explicit. Created 7 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « media/crypto/aes_decryptor.cc ('k') | media/filters/pipeline_integration_test.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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
« no previous file with comments | « media/crypto/aes_decryptor.cc ('k') | media/filters/pipeline_integration_test.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698