1 /* 2 * Copyright (C) 2019 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "drm_hal_test (at) 1.2" 18 19 #include <gtest/gtest.h> 20 #include <hidl/HidlSupport.h> 21 #include <log/log.h> 22 #include <openssl/aes.h> 23 24 #include "drm_hal_common.h" 25 26 using ::android::hardware::drm::V1_0::Status; 27 using ::android::hardware::drm::V1_1::KeyRequestType; 28 using ::android::hardware::drm::V1_1::SecurityLevel; 29 using ::android::hardware::drm::V1_2::HdcpLevel; 30 using ::android::hardware::drm::V1_2::KeySetId; 31 using ::android::hardware::drm::V1_2::KeyStatus; 32 using ::android::hardware::drm::V1_2::KeyStatusType; 33 using ::android::hardware::drm::V1_2::OfflineLicenseState; 34 35 using ::android::hardware::drm::V1_2::vts::DrmHalClearkeyTest; 36 using ::android::hardware::drm::V1_2::vts::DrmHalPluginListener; 37 using ::android::hardware::drm::V1_2::vts::DrmHalTest; 38 using ::android::hardware::drm::V1_2::vts::DrmHidlEnvironment; 39 using ::android::hardware::drm::V1_2::vts::kCallbackLostState; 40 using ::android::hardware::drm::V1_2::vts::kCallbackKeysChange; 41 42 using ::android::hardware::hidl_string; 43 44 static const char* const kVideoMp4 = "video/mp4"; 45 static const char* const kBadMime = "video/unknown"; 46 static const char* const kDrmErrorTestKey = "drmErrorTest"; 47 static const char* const kDrmErrorInvalidState = "invalidState"; 48 static const char* const kDrmErrorResourceContention = "resourceContention"; 49 static const SecurityLevel kSwSecureCrypto = SecurityLevel::SW_SECURE_CRYPTO; 50 51 /** 52 * Ensure drm factory supports module UUID Scheme 53 */ 54 TEST_P(DrmHalTest, VendorUuidSupported) { 55 auto res = drmFactory->isCryptoSchemeSupported_1_2(getVendorUUID(), kVideoMp4, kSwSecureCrypto); 56 ALOGI("kVideoMp4 = %s res %d", kVideoMp4, (bool)res); 57 EXPECT_TRUE(res); 58 } 59 60 /** 61 * Ensure drm factory doesn't support an invalid scheme UUID 62 */ 63 TEST_P(DrmHalTest, InvalidPluginNotSupported) { 64 const uint8_t kInvalidUUID[16] = { 65 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 66 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80}; 67 EXPECT_FALSE(drmFactory->isCryptoSchemeSupported_1_2(kInvalidUUID, kVideoMp4, kSwSecureCrypto)); 68 } 69 70 /** 71 * Ensure drm factory doesn't support an empty UUID 72 */ 73 TEST_P(DrmHalTest, EmptyPluginUUIDNotSupported) { 74 hidl_array<uint8_t, 16> emptyUUID; 75 memset(emptyUUID.data(), 0, 16); 76 EXPECT_FALSE(drmFactory->isCryptoSchemeSupported_1_2(emptyUUID, kVideoMp4, kSwSecureCrypto)); 77 } 78 79 /** 80 * Ensure drm factory doesn't support an invalid mime type 81 */ 82 TEST_P(DrmHalTest, BadMimeNotSupported) { 83 EXPECT_FALSE(drmFactory->isCryptoSchemeSupported_1_2(getVendorUUID(), kBadMime, kSwSecureCrypto)); 84 } 85 86 /** 87 * DrmPlugin tests 88 */ 89 90 /** 91 * Test that a DRM plugin can handle provisioning. While 92 * it is not required that a DRM scheme require provisioning, 93 * it should at least return appropriate status values. If 94 * a provisioning request is returned, it is passed to the 95 * vendor module which should provide a provisioning response 96 * that is delivered back to the HAL. 97 */ 98 TEST_P(DrmHalTest, DoProvisioning) { 99 RETURN_IF_SKIPPED; 100 hidl_string certificateType; 101 hidl_string certificateAuthority; 102 hidl_vec<uint8_t> provisionRequest; 103 hidl_string defaultUrl; 104 auto res = drmPlugin->getProvisionRequest_1_2( 105 certificateType, certificateAuthority, 106 [&](StatusV1_2 status, const hidl_vec<uint8_t>& request, 107 const hidl_string& url) { 108 if (status == StatusV1_2::OK) { 109 EXPECT_NE(request.size(), 0u); 110 provisionRequest = request; 111 defaultUrl = url; 112 } else if (status == StatusV1_2::ERROR_DRM_CANNOT_HANDLE) { 113 EXPECT_EQ(0u, request.size()); 114 } 115 }); 116 EXPECT_OK(res); 117 118 if (provisionRequest.size() > 0) { 119 vector<uint8_t> response = vendorModule->handleProvisioningRequest( 120 provisionRequest, defaultUrl); 121 ASSERT_NE(0u, response.size()); 122 123 auto res = drmPlugin->provideProvisionResponse( 124 response, [&](Status status, const hidl_vec<uint8_t>&, 125 const hidl_vec<uint8_t>&) { 126 EXPECT_EQ(Status::OK, status); 127 }); 128 EXPECT_OK(res); 129 } 130 } 131 132 /** 133 * A get key request should fail if no sessionId is provided 134 */ 135 TEST_P(DrmHalTest, GetKeyRequestNoSession) { 136 SessionId invalidSessionId; 137 hidl_vec<uint8_t> initData; 138 KeyedVector optionalParameters; 139 auto res = drmPlugin->getKeyRequest_1_2( 140 invalidSessionId, initData, kVideoMp4, KeyType::STREAMING, 141 optionalParameters, 142 [&](StatusV1_2 status, const hidl_vec<uint8_t>&, KeyRequestType, 143 const hidl_string&) { EXPECT_EQ(StatusV1_2::BAD_VALUE, status); }); 144 EXPECT_OK(res); 145 } 146 147 /** 148 * Test that the plugin returns the documented error for the 149 * case of attempting to generate a key request using an 150 * invalid mime type 151 */ 152 TEST_P(DrmHalTest, GetKeyRequestBadMime) { 153 auto sessionId = openSession(); 154 hidl_vec<uint8_t> initData; 155 KeyedVector optionalParameters; 156 auto res = drmPlugin->getKeyRequest_1_2( 157 sessionId, initData, kBadMime, KeyType::STREAMING, 158 optionalParameters, [&](StatusV1_2 status, const hidl_vec<uint8_t>&, 159 KeyRequestType, const hidl_string&) { 160 EXPECT_NE(StatusV1_2::OK, status); 161 }); 162 EXPECT_OK(res); 163 closeSession(sessionId); 164 } 165 166 template <Status S, size_t N> 167 void checkKeySetIds(Status status, const hidl_vec<KeySetId>& keySetIds) { 168 EXPECT_EQ(S, status); 169 if (S == Status::OK) { 170 EXPECT_EQ(N, keySetIds.size()); 171 } 172 } 173 174 template <Status S, OfflineLicenseState T> 175 void checkKeySetIdState(Status status, OfflineLicenseState state) { 176 if (S == Status::OK) { 177 EXPECT_TRUE(T == OfflineLicenseState::USABLE || T == OfflineLicenseState::INACTIVE); 178 } else { 179 EXPECT_TRUE(T == OfflineLicenseState::UNKNOWN); 180 } 181 EXPECT_EQ(S, status); 182 EXPECT_EQ(T, state); 183 } 184 185 /** 186 * Test drm plugin offline key support 187 */ 188 TEST_P(DrmHalTest, OfflineLicenseTest) { 189 auto sessionId = openSession(); 190 hidl_vec<uint8_t> keySetId = loadKeys(sessionId, KeyType::OFFLINE); 191 192 auto res = drmPlugin->getOfflineLicenseKeySetIds( 193 [&](Status status, const hidl_vec<KeySetId>& keySetIds) { 194 bool found = false; 195 EXPECT_EQ(Status::OK, status); 196 for (KeySetId keySetId2: keySetIds) { 197 if (keySetId == keySetId2) { 198 found = true; 199 break; 200 } 201 } 202 EXPECT_TRUE(found) << "keySetId not found"; 203 }); 204 EXPECT_OK(res); 205 206 Status err = drmPlugin->removeOfflineLicense(keySetId); 207 EXPECT_EQ(Status::OK, err); 208 209 res = drmPlugin->getOfflineLicenseKeySetIds( 210 [&](Status status, const hidl_vec<KeySetId>& keySetIds) { 211 EXPECT_EQ(Status::OK, status); 212 for (KeySetId keySetId2: keySetIds) { 213 EXPECT_NE(keySetId, keySetId2); 214 } 215 }); 216 EXPECT_OK(res); 217 218 err = drmPlugin->removeOfflineLicense(keySetId); 219 EXPECT_EQ(Status::BAD_VALUE, err); 220 221 closeSession(sessionId); 222 } 223 224 /** 225 * Test drm plugin offline key state 226 */ 227 TEST_P(DrmHalTest, OfflineLicenseStateTest) { 228 auto sessionId = openSession(); 229 DrmHalVTSVendorModule_V1::ContentConfiguration content = getContent(KeyType::OFFLINE); 230 hidl_vec<uint8_t> keySetId = loadKeys(sessionId, content, KeyType::OFFLINE); 231 drmPlugin->getOfflineLicenseState(keySetId, checkKeySetIdState<Status::OK, OfflineLicenseState::USABLE>); 232 233 hidl_vec<uint8_t> keyRequest = getKeyRequest(keySetId, content, KeyType::RELEASE); 234 drmPlugin->getOfflineLicenseState(keySetId, checkKeySetIdState<Status::OK, OfflineLicenseState::INACTIVE>); 235 236 /** 237 * Get key response from vendor module 238 */ 239 hidl_vec<uint8_t> keyResponse = 240 vendorModule->handleKeyRequest(keyRequest, content.serverUrl); 241 EXPECT_GT(keyResponse.size(), 0u); 242 243 provideKeyResponse(keySetId, keyResponse); 244 drmPlugin->getOfflineLicenseState(keySetId, checkKeySetIdState<Status::BAD_VALUE, OfflineLicenseState::UNKNOWN>); 245 closeSession(sessionId); 246 } 247 248 /** 249 * Negative offline license test. Remove empty keySetId 250 */ 251 TEST_P(DrmHalTest, RemoveEmptyKeySetId) { 252 KeySetId emptyKeySetId; 253 Status err = drmPlugin->removeOfflineLicense(emptyKeySetId); 254 EXPECT_EQ(Status::BAD_VALUE, err); 255 } 256 257 /** 258 * Negative offline license test. Get empty keySetId state 259 */ 260 TEST_P(DrmHalTest, GetEmptyKeySetIdState) { 261 KeySetId emptyKeySetId; 262 auto res = drmPlugin->getOfflineLicenseState(emptyKeySetId, checkKeySetIdState<Status::BAD_VALUE, OfflineLicenseState::UNKNOWN>); 263 EXPECT_OK(res); 264 } 265 266 /** 267 * Test that the plugin returns valid connected and max HDCP levels 268 */ 269 TEST_P(DrmHalTest, GetHdcpLevels) { 270 auto res = drmPlugin->getHdcpLevels_1_2( 271 [&](StatusV1_2 status, const HdcpLevel &connectedLevel, 272 const HdcpLevel &maxLevel) { 273 EXPECT_EQ(StatusV1_2::OK, status); 274 EXPECT_GE(connectedLevel, HdcpLevel::HDCP_NONE); 275 EXPECT_LE(maxLevel, HdcpLevel::HDCP_V2_3); 276 }); 277 EXPECT_OK(res); 278 } 279 280 /** 281 * Simulate the plugin sending keys change and make sure 282 * the listener gets them. 283 */ 284 TEST_P(DrmHalTest, ListenerKeysChange) { 285 RETURN_IF_SKIPPED; 286 sp<DrmHalPluginListener> listener = new DrmHalPluginListener(); 287 auto res = drmPlugin->setListener(listener); 288 EXPECT_OK(res); 289 290 auto sessionId = openSession(); 291 const hidl_vec<KeyStatus> keyStatusList = { 292 {{1}, KeyStatusType::USABLE}, 293 {{2}, KeyStatusType::EXPIRED}, 294 {{3}, KeyStatusType::OUTPUTNOTALLOWED}, 295 {{4}, KeyStatusType::STATUSPENDING}, 296 {{5}, KeyStatusType::INTERNALERROR}, 297 {{6}, KeyStatusType::USABLEINFUTURE}, 298 }; 299 300 drmPlugin->sendKeysChange_1_2(sessionId, keyStatusList, true); 301 auto result = listener->WaitForCallback(kCallbackKeysChange); 302 EXPECT_TRUE(result.no_timeout); 303 EXPECT_TRUE(result.args); 304 EXPECT_EQ(sessionId, result.args->sessionId); 305 EXPECT_EQ(keyStatusList, result.args->keyStatusList); 306 closeSession(sessionId); 307 } 308 309 /** 310 * CryptoPlugin Decrypt tests 311 */ 312 313 /** 314 * Positive decrypt test. "Decrypt" a single clear segment 315 */ 316 TEST_P(DrmHalTest, ClearSegmentTest) { 317 RETURN_IF_SKIPPED; 318 for (const auto& config : contentConfigurations) { 319 for (const auto& key : config.keys) { 320 const size_t kSegmentSize = 1024; 321 vector<uint8_t> iv(AES_BLOCK_SIZE, 0); 322 const Pattern noPattern = {0, 0}; 323 const vector<SubSample> subSamples = {{.numBytesOfClearData = kSegmentSize, 324 .numBytesOfEncryptedData = 0}}; 325 auto sessionId = openSession(); 326 loadKeys(sessionId, config); 327 328 Status status = cryptoPlugin->setMediaDrmSession(sessionId); 329 EXPECT_EQ(Status::OK, status); 330 331 uint32_t byteCount = decrypt(Mode::UNENCRYPTED, key.isSecure, toHidlArray(key.keyId), 332 &iv[0], subSamples, noPattern, key.clearContentKey, StatusV1_2::OK); 333 EXPECT_EQ(kSegmentSize, byteCount); 334 335 closeSession(sessionId); 336 } 337 } 338 } 339 340 /** 341 * Positive decrypt test. Decrypt a single segment using aes_ctr. 342 * Verify data matches. 343 */ 344 TEST_P(DrmHalTest, EncryptedAesCtrSegmentTest) { 345 RETURN_IF_SKIPPED; 346 for (const auto& config : contentConfigurations) { 347 for (const auto& key : config.keys) { 348 const size_t kSegmentSize = 1024; 349 vector<uint8_t> iv(AES_BLOCK_SIZE, 0); 350 const Pattern noPattern = {0, 0}; 351 const vector<SubSample> subSamples = {{.numBytesOfClearData = kSegmentSize, 352 .numBytesOfEncryptedData = 0}}; 353 auto sessionId = openSession(); 354 loadKeys(sessionId, config); 355 356 Status status = cryptoPlugin->setMediaDrmSession(sessionId); 357 EXPECT_EQ(Status::OK, status); 358 359 uint32_t byteCount = decrypt(Mode::AES_CTR, key.isSecure, toHidlArray(key.keyId), 360 &iv[0], subSamples, noPattern, key.clearContentKey, StatusV1_2::OK); 361 EXPECT_EQ(kSegmentSize, byteCount); 362 363 closeSession(sessionId); 364 } 365 } 366 } 367 368 /** 369 * Negative decrypt test. Decrypted frame too large to fit in output buffer 370 */ 371 TEST_P(DrmHalTest, ErrorFrameTooLarge) { 372 RETURN_IF_SKIPPED; 373 for (const auto& config : contentConfigurations) { 374 for (const auto& key : config.keys) { 375 const size_t kSegmentSize = 1024; 376 vector<uint8_t> iv(AES_BLOCK_SIZE, 0); 377 const Pattern noPattern = {0, 0}; 378 const vector<SubSample> subSamples = {{.numBytesOfClearData = kSegmentSize, 379 .numBytesOfEncryptedData = 0}}; 380 auto sessionId = openSession(); 381 loadKeys(sessionId, config); 382 383 Status status = cryptoPlugin->setMediaDrmSession(sessionId); 384 EXPECT_EQ(Status::OK, status); 385 386 decrypt(Mode::UNENCRYPTED, key.isSecure, toHidlArray(key.keyId), 387 &iv[0], subSamples, noPattern, key.clearContentKey, StatusV1_2::ERROR_DRM_FRAME_TOO_LARGE); 388 389 closeSession(sessionId); 390 } 391 } 392 } 393 394 /** 395 * Negative decrypt test. Decrypt without loading keys. 396 */ 397 TEST_P(DrmHalTest, EncryptedAesCtrSegmentTestNoKeys) { 398 RETURN_IF_SKIPPED; 399 for (const auto& config : contentConfigurations) { 400 for (const auto& key : config.keys) { 401 vector<uint8_t> iv(AES_BLOCK_SIZE, 0); 402 const Pattern noPattern = {0, 0}; 403 const vector<SubSample> subSamples = {{.numBytesOfClearData = 256, 404 .numBytesOfEncryptedData = 256}}; 405 auto sessionId = openSession(); 406 407 Status status = cryptoPlugin->setMediaDrmSession(sessionId); 408 EXPECT_EQ(Status::OK, status); 409 410 uint32_t byteCount = decrypt(Mode::AES_CTR, key.isSecure, 411 toHidlArray(key.keyId), &iv[0], subSamples, noPattern, 412 key.clearContentKey, StatusV1_2::ERROR_DRM_NO_LICENSE); 413 EXPECT_EQ(0u, byteCount); 414 415 closeSession(sessionId); 416 } 417 } 418 } 419 420 /** 421 * Ensure clearkey drm factory doesn't support security level higher than supported 422 */ 423 TEST_P(DrmHalClearkeyTest, BadLevelNotSupported) { 424 const SecurityLevel kHwSecureAll = SecurityLevel::HW_SECURE_ALL; 425 EXPECT_FALSE(drmFactory->isCryptoSchemeSupported_1_2(getVendorUUID(), kVideoMp4, kHwSecureAll)); 426 } 427 428 /** 429 * Test resource contention during attempt to generate key request 430 */ 431 TEST_P(DrmHalClearkeyTest, GetKeyRequestResourceContention) { 432 Status status = drmPlugin->setPropertyString(kDrmErrorTestKey, kDrmErrorResourceContention); 433 EXPECT_EQ(Status::OK, status); 434 auto sessionId = openSession(); 435 hidl_vec<uint8_t> initData; 436 KeyedVector optionalParameters; 437 auto res = drmPlugin->getKeyRequest_1_2( 438 sessionId, initData, kVideoMp4, KeyType::STREAMING, 439 optionalParameters, [&](StatusV1_2 status, const hidl_vec<uint8_t>&, 440 KeyRequestType, const hidl_string&) { 441 EXPECT_EQ(StatusV1_2::ERROR_DRM_RESOURCE_CONTENTION, status); 442 }); 443 EXPECT_OK(res); 444 445 status = drmPlugin->closeSession(sessionId); 446 EXPECT_NE(Status::OK, status); 447 } 448 449 /** 450 * Test clearkey plugin offline key with mock error 451 */ 452 TEST_P(DrmHalClearkeyTest, OfflineLicenseInvalidState) { 453 auto sessionId = openSession(); 454 hidl_vec<uint8_t> keySetId = loadKeys(sessionId, KeyType::OFFLINE); 455 Status status = drmPlugin->setPropertyString(kDrmErrorTestKey, kDrmErrorInvalidState); 456 EXPECT_EQ(Status::OK, status); 457 458 // everything should start failing 459 const Status kInvalidState = Status::ERROR_DRM_INVALID_STATE; 460 const OfflineLicenseState kUnknownState = OfflineLicenseState::UNKNOWN; 461 auto res = drmPlugin->getOfflineLicenseKeySetIds(checkKeySetIds<kInvalidState, 0u>); 462 EXPECT_OK(res); 463 res = drmPlugin->getOfflineLicenseState(keySetId, checkKeySetIdState<kInvalidState, kUnknownState>); 464 EXPECT_OK(res); 465 Status err = drmPlugin->removeOfflineLicense(keySetId); 466 EXPECT_EQ(kInvalidState, err); 467 closeSession(sessionId); 468 } 469 470 /** 471 * Test SessionLostState is triggered on error 472 */ 473 TEST_P(DrmHalClearkeyTest, SessionLostState) { 474 sp<DrmHalPluginListener> listener = new DrmHalPluginListener(); 475 auto res = drmPlugin->setListener(listener); 476 EXPECT_OK(res); 477 478 Status status = drmPlugin->setPropertyString(kDrmErrorTestKey, kDrmErrorInvalidState); 479 EXPECT_EQ(Status::OK, status); 480 481 auto sessionId = openSession(); 482 drmPlugin->closeSession(sessionId); 483 484 auto result = listener->WaitForCallback(kCallbackLostState); 485 EXPECT_TRUE(result.no_timeout); 486 EXPECT_TRUE(result.args); 487 EXPECT_EQ(sessionId, result.args->sessionId); 488 } 489 490 /** 491 * Negative decrypt test. Decrypt with invalid key. 492 */ 493 TEST_P(DrmHalClearkeyTest, DecryptWithEmptyKey) { 494 vector<uint8_t> iv(AES_BLOCK_SIZE, 0); 495 const Pattern noPattern = {0, 0}; 496 const uint32_t kClearBytes = 512; 497 const uint32_t kEncryptedBytes = 512; 498 const vector<SubSample> subSamples = { 499 {.numBytesOfClearData = kClearBytes, 500 .numBytesOfEncryptedData = kEncryptedBytes}}; 501 502 // base 64 encoded JSON response string, must not contain padding character '=' 503 const hidl_string emptyKeyResponse = 504 "{\"keys\":[" \ 505 "{" \ 506 "\"kty\":\"oct\"" \ 507 "\"alg\":\"A128KW2\"" \ 508 "\"k\":\"SGVsbG8gRnJpZW5kIQ\"" \ 509 "\"kid\":\"Y2xlYXJrZXlrZXlpZDAyAy\"" \ 510 "}" \ 511 "{" \ 512 "\"kty\":\"oct\"," \ 513 "\"alg\":\"A128KW2\"" \ 514 "\"kid\":\"Y2xlYXJrZXlrZXlpZDAzAy\"," \ 515 // empty key follows 516 "\"k\":\"R\"" \ 517 "}]" \ 518 "}"; 519 const size_t kEmptyKeyResponseSize = emptyKeyResponse.size(); 520 521 hidl_vec<uint8_t> invalidResponse; 522 invalidResponse.resize(kEmptyKeyResponseSize); 523 memcpy(invalidResponse.data(), emptyKeyResponse.c_str(), kEmptyKeyResponseSize); 524 decryptWithInvalidKeys(invalidResponse, iv, noPattern, subSamples); 525 } 526 527 /** 528 * Negative decrypt test. Decrypt with a key exceeds AES_BLOCK_SIZE. 529 */ 530 TEST_P(DrmHalClearkeyTest, DecryptWithKeyTooLong) { 531 vector<uint8_t> iv(AES_BLOCK_SIZE, 0); 532 const Pattern noPattern = {0, 0}; 533 const uint32_t kClearBytes = 512; 534 const uint32_t kEncryptedBytes = 512; 535 const vector<SubSample> subSamples = { 536 {.numBytesOfClearData = kClearBytes, 537 .numBytesOfEncryptedData = kEncryptedBytes}}; 538 539 // base 64 encoded JSON response string, must not contain padding character '=' 540 const hidl_string keyTooLongResponse = 541 "{\"keys\":[" \ 542 "{" \ 543 "\"kty\":\"oct\"," \ 544 "\"alg\":\"A128KW2\"" \ 545 "\"kid\":\"Y2xlYXJrZXlrZXlpZDAzAy\"," \ 546 // key too long 547 "\"k\":\"V2lubmllIHRoZSBwb29oIVdpbm5pZSB0aGUgcG9vaCE=\"" \ 548 "}]" \ 549 "}"; 550 const size_t kKeyTooLongResponseSize = keyTooLongResponse.size(); 551 552 hidl_vec<uint8_t> invalidResponse; 553 invalidResponse.resize(kKeyTooLongResponseSize); 554 memcpy(invalidResponse.data(), keyTooLongResponse.c_str(), kKeyTooLongResponseSize); 555 decryptWithInvalidKeys(invalidResponse, iv, noPattern, subSamples); 556 } 557 558 /** 559 * Instantiate the set of test cases for each vendor module 560 */ 561 562 INSTANTIATE_TEST_CASE_P( 563 DrmHalTestClearkey, DrmHalTest, 564 testing::Values("clearkey")); 565 566 INSTANTIATE_TEST_CASE_P( 567 DrmHalTestClearkeyExtended, DrmHalClearkeyTest, 568 testing::Values("clearkey")); 569 570 INSTANTIATE_TEST_CASE_P( 571 DrmHalTestVendor, DrmHalTest, 572 testing::ValuesIn(DrmHalTest::gVendorModules->getPathList())); 573 574 int main(int argc, char** argv) { 575 #if defined(__LP64__) 576 const char* kModulePath = "/data/local/tmp/64/lib"; 577 #else 578 const char* kModulePath = "/data/local/tmp/32/lib"; 579 #endif 580 DrmHalTest::gVendorModules = new drm_vts::VendorModules(kModulePath); 581 if (DrmHalTest::gVendorModules->getPathList().size() == 0) { 582 std::cerr << "WARNING: No vendor modules found in " << kModulePath << 583 ", all vendor tests will be skipped" << std::endl; 584 } 585 ::testing::AddGlobalTestEnvironment(DrmHidlEnvironment::Instance()); 586 ::testing::InitGoogleTest(&argc, argv); 587 DrmHidlEnvironment::Instance()->init(&argc, argv); 588 int status = RUN_ALL_TESTS(); 589 ALOGI("Test result = %d", status); 590 return status; 591 } 592