media/cdm/aes_decryptor_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6 #include <vector>
   7
   8 #include "base/basictypes.h"
   9 #include "base/bind.h"
  10 #include "media/base/decoder_buffer.h"
  11 #include "media/base/decrypt_config.h"
  12 #include "media/base/mock_filters.h"
  13 #include "media/cdm/aes_decryptor.h"
  14 #include "media/webm/webm_constants.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 using ::testing::_;
  19 using ::testing::Gt;
  20 using ::testing::IsNull;
  21 using ::testing::NotNull;
  22 using ::testing::SaveArg;
  23 using ::testing::StrNe;
  24
  25 MATCHER(IsEmpty, "") { return arg.empty(); }
  26
  27 namespace media {
  28
  29 const uint8 kOriginalData[] = "Original subsample data.";
  30 const int kOriginalDataSize = 24;
  31
  32 const uint8 kKeyId[] = {
  33     // base64 equivalent is AAECAw==
  34     0x00, 0x01, 0x02, 0x03
  35 };
  36
  37 const uint8 kKey[] = {
  38     // base64 equivalent is BAUGBwgJCgsMDQ4PEBESEw==
  39     0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
  40     0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13
  41 };
  42
  43 const char kKeyAsJWK[] =
  44     "{"
  45     "  \"keys\": ["
  46     "    {"
  47     "      \"kty\": \"oct\","
  48     "      \"kid\": \"AAECAw==\","
  49     "      \"k\": \"BAUGBwgJCgsMDQ4PEBESEw==\""
  50     "    }"
  51     "  ]"
  52     "}";
  53
  54 const char kWrongKeyAsJWK[] =
  55     "{"
  56     "  \"keys\": ["
  57     "    {"
  58     "      \"kty\": \"oct\","
  59     "      \"kid\": \"AAECAw==\","
  60     "      \"k\": \"7u7u7u7u7u7u7u7u7u7u7g==\""
  61     "    }"
  62     "  ]"
  63     "}";
  64
  65 const char kWrongSizedKeyAsJWK[] =
  66     "{"
  67     "  \"keys\": ["
  68     "    {"
  69     "      \"kty\": \"oct\","
  70     "      \"kid\": \"AAECAw==\","
  71     "      \"k\": \"AAECAw==\""
  72     "    }"
  73     "  ]"
  74     "}";
  75
  76 const uint8 kIv[] = {
  77   0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
  78   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  79 };
  80
  81 // kOriginalData encrypted with kKey and kIv but without any subsamples (or
  82 // equivalently using kSubsampleEntriesCypherOnly).
  83 const uint8 kEncryptedData[] = {
  84   0x2f, 0x03, 0x09, 0xef, 0x71, 0xaf, 0x31, 0x16,
  85   0xfa, 0x9d, 0x18, 0x43, 0x1e, 0x96, 0x71, 0xb5,
  86   0xbf, 0xf5, 0x30, 0x53, 0x9a, 0x20, 0xdf, 0x95
  87 };
  88
  89 // kOriginalData encrypted with kSubsampleKey and kSubsampleIv using
  90 // kSubsampleEntriesNormal.
  91 const uint8 kSubsampleEncryptedData[] = {
  92   0x4f, 0x72, 0x09, 0x16, 0x09, 0xe6, 0x79, 0xad,
  93   0x70, 0x73, 0x75, 0x62, 0x09, 0xbb, 0x83, 0x1d,
  94   0x4d, 0x08, 0xd7, 0x78, 0xa4, 0xa7, 0xf1, 0x2e
  95 };
  96
  97 const uint8 kOriginalData2[] = "Changed Original data.";
  98
  99 const uint8 kIv2[] = {
 100   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 101   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 102 };
 103
 104 const uint8 kKeyId2[] = {
 105     // base64 equivalent is AAECAwQFBgcICQoLDA0ODxAREhM=
 106     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 107     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 108     0x10, 0x11, 0x12, 0x13
 109 };
 110
 111 const char kKey2AsJWK[] =
 112     "{"
 113     "  \"keys\": ["
 114     "    {"
 115     "      \"kty\": \"oct\","
 116     "      \"kid\": \"AAECAwQFBgcICQoLDA0ODxAREhM=\","
 117     "      \"k\": \"FBUWFxgZGhscHR4fICEiIw==\""
 118     "    }"
 119     "  ]"
 120     "}";
 121
 122 // 'k' in bytes is x14x15x16x17x18x19x1ax1bx1cx1dx1ex1fx20x21x22x23
 123
 124 const uint8 kEncryptedData2[] = {
 125   0x57, 0x66, 0xf4, 0x12, 0x1a, 0xed, 0xb5, 0x79,
 126   0x1c, 0x8e, 0x25, 0xd7, 0x17, 0xe7, 0x5e, 0x16,
 127   0xe3, 0x40, 0x08, 0x27, 0x11, 0xe9
 128 };
 129
 130 // Subsample entries for testing. The sum of |cypher_bytes| and |clear_bytes| of
 131 // all entries must be equal to kOriginalDataSize to make the subsample entries
 132 // valid.
 133
 134 const SubsampleEntry kSubsampleEntriesNormal[] = {
 135   { 2, 7 },
 136   { 3, 11 },
 137   { 1, 0 }
 138 };
 139
 140 const SubsampleEntry kSubsampleEntriesWrongSize[] = {
 141   { 3, 6 }, // This entry doesn't match the correct entry.
 142   { 3, 11 },
 143   { 1, 0 }
 144 };
 145
 146 const SubsampleEntry kSubsampleEntriesInvalidTotalSize[] = {
 147   { 1, 1000 }, // This entry is too large.
 148   { 3, 11 },
 149   { 1, 0 }
 150 };
 151
 152 const SubsampleEntry kSubsampleEntriesClearOnly[] = {
 153   { 7, 0 },
 154   { 8, 0 },
 155   { 9, 0 }
 156 };
 157
 158 const SubsampleEntry kSubsampleEntriesCypherOnly[] = {
 159   { 0, 6 },
 160   { 0, 8 },
 161   { 0, 10 }
 162 };
 163
 164 static scoped_refptr<DecoderBuffer> CreateEncryptedBuffer(
 165     const std::vector<uint8>& data,
 166     const std::vector<uint8>& key_id,
 167     const std::vector<uint8>& iv,
 168     int offset,
 169     const std::vector<SubsampleEntry>& subsample_entries) {
 170   DCHECK(!data.empty());
 171   int padded_size = offset + data.size();
 172   scoped_refptr<DecoderBuffer> encrypted_buffer(new DecoderBuffer(padded_size));
 173   memcpy(encrypted_buffer->writable_data() + offset, &data[0], data.size());
 174   CHECK(encrypted_buffer.get());
 175   std::string key_id_string(
 176       reinterpret_cast<const char*>(key_id.empty() ? NULL : &key_id[0]),
 177       key_id.size());
 178   std::string iv_string(
 179       reinterpret_cast<const char*>(iv.empty() ? NULL : &iv[0]), iv.size());
 180   encrypted_buffer->set_decrypt_config(scoped_ptr<DecryptConfig>(
 181       new DecryptConfig(key_id_string, iv_string, offset, subsample_entries)));
 182   return encrypted_buffer;
 183 }
 184
 185 class AesDecryptorTest : public testing::Test {
 186  public:
 187   AesDecryptorTest()
 188       : decryptor_(
 189             base::Bind(&AesDecryptorTest::KeyAdded, base::Unretained(this)),
 190             base::Bind(&AesDecryptorTest::KeyError, base::Unretained(this)),
 191             base::Bind(&AesDecryptorTest::KeyMessage, base::Unretained(this))),
 192         decrypt_cb_(base::Bind(&AesDecryptorTest::BufferDecrypted,
 193                                base::Unretained(this))),
 194         original_data_(kOriginalData, kOriginalData + kOriginalDataSize),
 195         encrypted_data_(kEncryptedData,
 196                         kEncryptedData + arraysize(kEncryptedData)),
 197         subsample_encrypted_data_(
 198             kSubsampleEncryptedData,
 199             kSubsampleEncryptedData + arraysize(kSubsampleEncryptedData)),
 200         key_id_(kKeyId, kKeyId + arraysize(kKeyId)),
 201         iv_(kIv, kIv + arraysize(kIv)),
 202         normal_subsample_entries_(
 203             kSubsampleEntriesNormal,
 204             kSubsampleEntriesNormal + arraysize(kSubsampleEntriesNormal)) {
 205   }
 206
 207  protected:
 208   void GenerateKeyRequest(const std::vector<uint8>& key_id) {
 209     DCHECK(!key_id.empty());
 210     EXPECT_CALL(*this, KeyMessage(StrNe(std::string()), key_id, ""))
 211         .WillOnce(SaveArg<0>(&session_id_string_));
 212     EXPECT_TRUE(decryptor_.GenerateKeyRequest(
 213         std::string(), &key_id[0], key_id.size()));
 214   }
 215
 216   enum AddKeyExpectation {
 217     KEY_ADDED,
 218     KEY_ERROR
 219   };
 220
 221   void AddRawKeyAndExpect(const std::vector<uint8>& key_id,
 222                           const std::vector<uint8>& key,
 223                           AddKeyExpectation result) {
 224     // TODO(jrummell): Remove once raw keys no longer supported.
 225     DCHECK(!key_id.empty());
 226     DCHECK(!key.empty());
 227
 228     if (result == KEY_ADDED) {
 229       EXPECT_CALL(*this, KeyAdded(session_id_string_));
 230     } else if (result == KEY_ERROR) {
 231       EXPECT_CALL(*this, KeyError(session_id_string_,
 232                                   MediaKeys::kUnknownError, 0));
 233     } else {
 234       NOTREACHED();
 235     }
 236
 237     decryptor_.AddKey(&key[0], key.size(), &key_id[0], key_id.size(),
 238                       session_id_string_);
 239   }
 240
 241   void AddKeyAndExpect(const std::string& key, AddKeyExpectation result) {
 242     DCHECK(!key.empty());
 243
 244     if (result == KEY_ADDED) {
 245       EXPECT_CALL(*this, KeyAdded(session_id_string_));
 246     } else if (result == KEY_ERROR) {
 247       EXPECT_CALL(*this,
 248                   KeyError(session_id_string_, MediaKeys::kUnknownError, 0));
 249     } else {
 250       NOTREACHED();
 251     }
 252
 253     decryptor_.AddKey(reinterpret_cast<const uint8*>(key.c_str()), key.length(),
 254                       NULL, 0,
 255                       session_id_string_);
 256   }
 257
 258   MOCK_METHOD2(BufferDecrypted, void(Decryptor::Status,
 259                                      const scoped_refptr<DecoderBuffer>&));
 260
 261   enum DecryptExpectation {
 262     SUCCESS,
 263     DATA_MISMATCH,
 264     DATA_AND_SIZE_MISMATCH,
 265     DECRYPT_ERROR
 266   };
 267
 268   void DecryptAndExpect(const scoped_refptr<DecoderBuffer>& encrypted,
 269                         const std::vector<uint8>& plain_text,
 270                         DecryptExpectation result) {
 271     scoped_refptr<DecoderBuffer> decrypted;
 272
 273     if (result != DECRYPT_ERROR) {
 274       EXPECT_CALL(*this, BufferDecrypted(Decryptor::kSuccess, NotNull()))
 275           .WillOnce(SaveArg<1>(&decrypted));
 276     } else {
 277       EXPECT_CALL(*this, BufferDecrypted(Decryptor::kError, IsNull()))
 278           .WillOnce(SaveArg<1>(&decrypted));
 279     }
 280
 281     decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
 282
 283     std::vector<uint8> decrypted_text;
 284     if (decrypted && decrypted->data_size()) {
 285       decrypted_text.assign(
 286         decrypted->data(), decrypted->data() + decrypted->data_size());
 287     }
 288
 289     switch (result) {
 290       case SUCCESS:
 291         EXPECT_EQ(plain_text, decrypted_text);
 292         break;
 293       case DATA_MISMATCH:
 294         EXPECT_EQ(plain_text.size(), decrypted_text.size());
 295         EXPECT_NE(plain_text, decrypted_text);
 296         break;
 297       case DATA_AND_SIZE_MISMATCH:
 298         EXPECT_NE(plain_text.size(), decrypted_text.size());
 299         break;
 300       case DECRYPT_ERROR:
 301         EXPECT_TRUE(decrypted_text.empty());
 302         break;
 303     }
 304   }
 305
 306   MOCK_METHOD1(KeyAdded, void(const std::string&));
 307   MOCK_METHOD3(KeyError, void(const std::string&,
 308                               MediaKeys::KeyError, int));
 309   MOCK_METHOD3(KeyMessage, void(const std::string& session_id,
 310                                 const std::vector<uint8>& message,
 311                                 const std::string& default_url));
 312
 313   AesDecryptor decryptor_;
 314   std::string session_id_string_;
 315   AesDecryptor::DecryptCB decrypt_cb_;
 316
 317   // Constants for testing.
 318   const std::vector<uint8> original_data_;
 319   const std::vector<uint8> encrypted_data_;
 320   const std::vector<uint8> subsample_encrypted_data_;
 321   const std::vector<uint8> key_id_;
 322   const std::vector<uint8> iv_;
 323   const std::vector<SubsampleEntry> normal_subsample_entries_;
 324   const std::vector<SubsampleEntry> no_subsample_entries_;
 325 };
 326
 327 TEST_F(AesDecryptorTest, GenerateKeyRequestWithNullInitData) {
 328   EXPECT_CALL(*this, KeyMessage(StrNe(std::string()), IsEmpty(), ""));
 329   EXPECT_TRUE(decryptor_.GenerateKeyRequest(std::string(), NULL, 0));
 330 }
 331
 332 TEST_F(AesDecryptorTest, NormalDecryption) {
 333   GenerateKeyRequest(key_id_);
 334   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 335   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 336       encrypted_data_, key_id_, iv_, 0, no_subsample_entries_);
 337   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 338 }
 339
 340 TEST_F(AesDecryptorTest, DecryptionWithOffset) {
 341   GenerateKeyRequest(key_id_);
 342   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 343   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 344       encrypted_data_, key_id_, iv_, 23, no_subsample_entries_);
 345   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 346 }
 347
 348 TEST_F(AesDecryptorTest, UnencryptedFrame) {
 349   // An empty iv string signals that the frame is unencrypted.
 350   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 351       original_data_, key_id_, std::vector<uint8>(), 0, no_subsample_entries_);
 352   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 353 }
 354
 355 TEST_F(AesDecryptorTest, WrongKey) {
 356   GenerateKeyRequest(key_id_);
 357   AddKeyAndExpect(kWrongKeyAsJWK, KEY_ADDED);
 358   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 359       encrypted_data_, key_id_, iv_, 0, no_subsample_entries_);
 360   DecryptAndExpect(encrypted_buffer, original_data_, DATA_MISMATCH);
 361 }
 362
 363 TEST_F(AesDecryptorTest, NoKey) {
 364   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 365       encrypted_data_, key_id_, iv_, 0, no_subsample_entries_);
 366   EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kNoKey, IsNull()));
 367   decryptor_.Decrypt(Decryptor::kVideo, encrypted_buffer, decrypt_cb_);
 368 }
 369
 370 TEST_F(AesDecryptorTest, KeyReplacement) {
 371   GenerateKeyRequest(key_id_);
 372   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 373       encrypted_data_, key_id_, iv_, 0, no_subsample_entries_);
 374
 375   AddKeyAndExpect(kWrongKeyAsJWK, KEY_ADDED);
 376   ASSERT_NO_FATAL_FAILURE(DecryptAndExpect(
 377       encrypted_buffer, original_data_, DATA_MISMATCH));
 378
 379   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 380   ASSERT_NO_FATAL_FAILURE(
 381       DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
 382 }
 383
 384 TEST_F(AesDecryptorTest, WrongSizedKey) {
 385   GenerateKeyRequest(key_id_);
 386   AddKeyAndExpect(kWrongSizedKeyAsJWK, KEY_ERROR);
 387
 388   // Repeat for a raw key. Use "-1" to create a wrong sized key.
 389   std::vector<uint8> wrong_sized_key(kKey, kKey + arraysize(kKey) - 1);
 390   AddRawKeyAndExpect(key_id_, wrong_sized_key, KEY_ERROR);
 391 }
 392
 393 TEST_F(AesDecryptorTest, MultipleKeysAndFrames) {
 394   GenerateKeyRequest(key_id_);
 395   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 396   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 397       encrypted_data_, key_id_, iv_, 10, no_subsample_entries_);
 398   ASSERT_NO_FATAL_FAILURE(
 399       DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
 400
 401   AddKeyAndExpect(kKey2AsJWK, KEY_ADDED);
 402
 403   // The first key is still available after we added a second key.
 404   ASSERT_NO_FATAL_FAILURE(
 405       DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
 406
 407   // The second key is also available.
 408   encrypted_buffer = CreateEncryptedBuffer(
 409       std::vector<uint8>(kEncryptedData2,
 410                          kEncryptedData2 + arraysize(kEncryptedData2)),
 411       std::vector<uint8>(kKeyId2, kKeyId2 + arraysize(kKeyId2)),
 412       std::vector<uint8>(kIv2, kIv2 + arraysize(kIv2)),
 413       30,
 414       no_subsample_entries_);
 415   ASSERT_NO_FATAL_FAILURE(DecryptAndExpect(
 416       encrypted_buffer,
 417       std::vector<uint8>(kOriginalData2,
 418                          kOriginalData2 + arraysize(kOriginalData2) - 1),
 419       SUCCESS));
 420 }
 421
 422 TEST_F(AesDecryptorTest, CorruptedIv) {
 423   GenerateKeyRequest(key_id_);
 424   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 425
 426   std::vector<uint8> bad_iv = iv_;
 427   bad_iv[1]++;
 428
 429   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 430       encrypted_data_, key_id_, bad_iv, 0, no_subsample_entries_);
 431
 432   DecryptAndExpect(encrypted_buffer, original_data_, DATA_MISMATCH);
 433 }
 434
 435 TEST_F(AesDecryptorTest, CorruptedData) {
 436   GenerateKeyRequest(key_id_);
 437   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 438
 439   std::vector<uint8> bad_data = encrypted_data_;
 440   bad_data[1]++;
 441
 442   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 443       bad_data, key_id_, iv_, 0, no_subsample_entries_);
 444   DecryptAndExpect(encrypted_buffer, original_data_, DATA_MISMATCH);
 445 }
 446
 447 TEST_F(AesDecryptorTest, EncryptedAsUnencryptedFailure) {
 448   GenerateKeyRequest(key_id_);
 449   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 450   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 451       encrypted_data_, key_id_, std::vector<uint8>(), 0, no_subsample_entries_);
 452   DecryptAndExpect(encrypted_buffer, original_data_, DATA_MISMATCH);
 453 }
 454
 455 TEST_F(AesDecryptorTest, SubsampleDecryption) {
 456   GenerateKeyRequest(key_id_);
 457   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 458   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 459       subsample_encrypted_data_, key_id_, iv_, 0, normal_subsample_entries_);
 460   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 461 }
 462
 463 // Ensures noninterference of data offset and subsample mechanisms. We never
 464 // expect to encounter this in the wild, but since the DecryptConfig doesn't
 465 // disallow such a configuration, it should be covered.
 466 TEST_F(AesDecryptorTest, SubsampleDecryptionWithOffset) {
 467   GenerateKeyRequest(key_id_);
 468   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 469   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 470       subsample_encrypted_data_, key_id_, iv_, 23, normal_subsample_entries_);
 471   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 472 }
 473
 474 TEST_F(AesDecryptorTest, SubsampleWrongSize) {
 475   GenerateKeyRequest(key_id_);
 476   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 477
 478   std::vector<SubsampleEntry> subsample_entries_wrong_size(
 479       kSubsampleEntriesWrongSize,
 480       kSubsampleEntriesWrongSize + arraysize(kSubsampleEntriesWrongSize));
 481
 482   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 483       subsample_encrypted_data_, key_id_, iv_, 0, subsample_entries_wrong_size);
 484   DecryptAndExpect(encrypted_buffer, original_data_, DATA_MISMATCH);
 485 }
 486
 487 TEST_F(AesDecryptorTest, SubsampleInvalidTotalSize) {
 488   GenerateKeyRequest(key_id_);
 489   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 490
 491   std::vector<SubsampleEntry> subsample_entries_invalid_total_size(
 492       kSubsampleEntriesInvalidTotalSize,
 493       kSubsampleEntriesInvalidTotalSize +
 494           arraysize(kSubsampleEntriesInvalidTotalSize));
 495
 496   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 497       subsample_encrypted_data_, key_id_, iv_, 0,
 498       subsample_entries_invalid_total_size);
 499   DecryptAndExpect(encrypted_buffer, original_data_, DECRYPT_ERROR);
 500 }
 501
 502 // No cypher bytes in any of the subsamples.
 503 TEST_F(AesDecryptorTest, SubsampleClearBytesOnly) {
 504   GenerateKeyRequest(key_id_);
 505   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 506
 507   std::vector<SubsampleEntry> clear_only_subsample_entries(
 508       kSubsampleEntriesClearOnly,
 509       kSubsampleEntriesClearOnly + arraysize(kSubsampleEntriesClearOnly));
 510
 511   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 512       original_data_, key_id_, iv_, 0, clear_only_subsample_entries);
 513   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 514 }
 515
 516 // No clear bytes in any of the subsamples.
 517 TEST_F(AesDecryptorTest, SubsampleCypherBytesOnly) {
 518   GenerateKeyRequest(key_id_);
 519   AddKeyAndExpect(kKeyAsJWK, KEY_ADDED);
 520
 521   std::vector<SubsampleEntry> cypher_only_subsample_entries(
 522       kSubsampleEntriesCypherOnly,
 523       kSubsampleEntriesCypherOnly + arraysize(kSubsampleEntriesCypherOnly));
 524
 525   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 526       encrypted_data_, key_id_, iv_, 0, cypher_only_subsample_entries);
 527   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 528 }
 529
 530 TEST_F(AesDecryptorTest, JWKKey) {
 531   // Try a simple JWK key (i.e. not in a set)
 532   const std::string key1 =
 533       "{"
 534       "  \"kty\": \"oct\","
 535       "  \"kid\": \"AAECAwQFBgcICQoLDA0ODxAREhM=\","
 536       "  \"k\": \"FBUWFxgZGhscHR4fICEiIw==\""
 537       "}";
 538   AddKeyAndExpect(key1, KEY_ERROR);
 539
 540   // Try a key list with multiple entries.
 541   const std::string key2 =
 542       "{"
 543       "  \"keys\": ["
 544       "    {"
 545       "      \"kty\": \"oct\","
 546       "      \"kid\": \"AAECAwQFBgcICQoLDA0ODxAREhM=\","
 547       "      \"k\": \"FBUWFxgZGhscHR4fICEiIw==\""
 548       "    },"
 549       "    {"
 550       "      \"kty\": \"oct\","
 551       "      \"kid\": \"JCUmJygpKissLS4vMA==\","
 552       "      \"k\":\"MTIzNDU2Nzg5Ojs8PT4/QA==\""
 553       "    }"
 554       "  ]"
 555       "}";
 556   AddKeyAndExpect(key2, KEY_ADDED);
 557
 558   // Try a key with no spaces and some \n plus additional fields.
 559   const std::string key3 =
 560       "\n\n{\"something\":1,\"keys\":[{\n\n\"kty\":\"oct\",\"alg\":\"A128KW\","
 561       "\"kid\":\"AAECAwQFBgcICQoLDA0ODxAREhM=\",\"k\":\"GawgguFyGrWKav7AX4VKUg="
 562       "=\",\"foo\":\"bar\"}]}\n\n";
 563   AddKeyAndExpect(key3, KEY_ADDED);
 564
 565   // Try some non-ASCII characters.
 566   AddKeyAndExpect("This is not ASCII due to \xff\xfe\xfd in it.", KEY_ERROR);
 567
 568   // Try a badly formatted key. Assume that the JSON parser is fully tested,
 569   // so we won't try a lot of combinations. However, need a test to ensure
 570   // that the code doesn't crash if invalid JSON received.
 571   AddKeyAndExpect("This is not a JSON key.", KEY_ERROR);
 572
 573   // Try passing some valid JSON that is not a dictionary at the top level.
 574   AddKeyAndExpect("40", KEY_ERROR);
 575
 576   // Try an empty dictionary.
 577   AddKeyAndExpect("{ }", KEY_ERROR);
 578
 579   // Try an empty 'keys' dictionary.
 580   AddKeyAndExpect("{ \"keys\": [] }", KEY_ERROR);
 581
 582   // Try with 'keys' not a dictionary.
 583   AddKeyAndExpect("{ \"keys\":\"1\" }", KEY_ERROR);
 584
 585   // Try with 'keys' a list of integers.
 586   AddKeyAndExpect("{ \"keys\": [ 1, 2, 3 ] }", KEY_ERROR);
 587
 588   // Try a key missing padding(=) at end of base64 string.
 589   const std::string key4 =
 590       "{"
 591       "  \"keys\": ["
 592       "    {"
 593       "      \"kty\": \"oct\","
 594       "      \"kid\": \"AAECAw==\","
 595       "      \"k\": \"BAUGBwgJCgsMDQ4PEBESEw\""
 596       "    }"
 597       "  ]"
 598       "}";
 599   AddKeyAndExpect(key4, KEY_ERROR);
 600
 601   // Try a key ID missing padding(=) at end of base64 string.
 602   const std::string key5 =
 603       "{"
 604       "  \"keys\": ["
 605       "    {"
 606       "      \"kty\": \"oct\","
 607       "      \"kid\": \"AAECAw\","
 608       "      \"k\": \"BAUGBwgJCgsMDQ4PEBESEw==\""
 609       "    }"
 610       "  ]"
 611       "}";
 612   AddKeyAndExpect(key5, KEY_ERROR);
 613
 614   // Try a key with invalid base64 encoding.
 615   const std::string key6 =
 616       "{"
 617       "  \"keys\": ["
 618       "    {"
 619       "      \"kty\": \"oct\","
 620       "      \"kid\": \"!@#$%^&*()==\","
 621       "      \"k\": \"BAUGBwgJCgsMDQ4PEBESEw==\""
 622       "    }"
 623       "  ]"
 624       "}";
 625   AddKeyAndExpect(key6, KEY_ERROR);
 626 }
 627
 628 TEST_F(AesDecryptorTest, RawKey) {
 629   // Verify that v0.1b keys (raw key) is still supported. Raw keys are
 630   // 16 bytes long. Use the undecoded value of |kKey|.
 631   GenerateKeyRequest(key_id_);
 632   AddRawKeyAndExpect(
 633       key_id_, std::vector<uint8>(kKey, kKey + arraysize(kKey)), KEY_ADDED);
 634   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
 635       encrypted_data_, key_id_, iv_, 0, no_subsample_entries_);
 636   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 637 }
 638
 639 }  // namespace media