From c9e4dd249562c977733c37a7c473de9cbb04fe69 Mon Sep 17 00:00:00 2001 From: Alex Dale Date: Thu, 5 Mar 2020 23:06:56 -0800 Subject: [PATCH 1/3] New CDM error codes for usage table errors. [ Merge of http://go/wvgerrit/95404 ] There are three situtations where error codes from a usage table operations were not being mapped to unique CDM response types. These particular errors provide useful information for the CDM during table defragging. Also fixed misspelled error code. Bug: 150890014 Bug: 150891685 Test: Linux unit tests and Android build Change-Id: I683abdd5fc0871317eede960ea36cfafac7e7f49 --- .../cdm/core/include/wv_cdm_types.h | 5 ++- .../cdm/core/src/crypto_session.cpp | 40 ++++++++++++------- .../cdm/core/test/test_printers.cpp | 13 +++++- .../core/test/usage_table_header_unittest.cpp | 9 ++--- libwvdrmengine/include/WVErrors.h | 7 +++- libwvdrmengine/include/mapErrors-inl.h | 10 ++++- libwvdrmengine/include_hidl/mapErrors-inl.h | 5 ++- 7 files changed, 62 insertions(+), 27 deletions(-) diff --git a/libwvdrmengine/cdm/core/include/wv_cdm_types.h b/libwvdrmengine/cdm/core/include/wv_cdm_types.h index a6ce404e..f19248e0 100644 --- a/libwvdrmengine/cdm/core/include/wv_cdm_types.h +++ b/libwvdrmengine/cdm/core/include/wv_cdm_types.h @@ -281,7 +281,7 @@ enum CdmResponseType { /* previsouly INVALID_PARAMETERS_ENG_20 = 227, */ UPDATE_USAGE_ENTRY_UNKNOWN_ERROR = 228, /* previously INVALID_PARAMETERS_ENG_21 = 229, */ - SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR = 230, + SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR = 230, MOVE_USAGE_ENTRY_UNKNOWN_ERROR = 231, COPY_OLD_USAGE_ENTRY_UNKNOWN_ERROR = 232, INVALID_PARAMETERS_ENG_22 = 233, @@ -408,6 +408,9 @@ enum CdmResponseType { CANNOT_DECRYPT_ZERO_SUBSAMPLES = 354, SAMPLE_AND_SUBSAMPLE_SIZE_MISMATCH = 355, INVALID_IV_SIZE = 356, + LOAD_USAGE_ENTRY_INVALID_SESSION = 357, + MOVE_USAGE_ENTRY_DESTINATION_IN_USE = 358, + SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE = 359, // Don't forget to add new values to // * core/test/test_printers.cpp. // * android/include/mapErrors-inl.h diff --git a/libwvdrmengine/cdm/core/src/crypto_session.cpp b/libwvdrmengine/cdm/core/src/crypto_session.cpp index 3d8fe846..bef1d361 100644 --- a/libwvdrmengine/cdm/core/src/crypto_session.cpp +++ b/libwvdrmengine/cdm/core/src/crypto_session.cpp @@ -2476,18 +2476,19 @@ CdmResponseType CryptoSession::LoadUsageEntry( case OEMCrypto_SUCCESS: case OEMCrypto_WARNING_GENERATION_SKEW: return NO_ERROR; + case OEMCrypto_ERROR_INVALID_SESSION: + // This case is special, as it could imply that the provided + // session ID is invalid (CDM internal bug), or that the entry + // being loaded is already in use in a different session. + // It is up to the caller to handle this. + return LOAD_USAGE_ENTRY_INVALID_SESSION; case OEMCrypto_ERROR_GENERATION_SKEW: return LOAD_USAGE_ENTRY_GENERATION_SKEW; case OEMCrypto_ERROR_SIGNATURE_FAILURE: return LOAD_USAGE_ENTRY_SIGNATURE_FAILURE; - case OEMCrypto_ERROR_INSUFFICIENT_RESOURCES: - return INSUFFICIENT_CRYPTO_RESOURCES_3; - case OEMCrypto_ERROR_SESSION_LOST_STATE: - return SESSION_LOST_STATE_ERROR; - case OEMCrypto_ERROR_SYSTEM_INVALIDATED: - return SYSTEM_INVALIDATED_ERROR; default: - return LOAD_USAGE_ENTRY_UNKNOWN_ERROR; + return MapOEMCryptoResult(result, LOAD_USAGE_ENTRY_UNKNOWN_ERROR, + "LoadUsageEntry"); } } @@ -2561,12 +2562,16 @@ CdmResponseType CryptoSession::ShrinkUsageTableHeader( }); } - if (result == OEMCrypto_SUCCESS) { - usage_table_header->resize(usage_table_header_len); + switch (result) { + case OEMCrypto_SUCCESS: + usage_table_header->resize(usage_table_header_len); + return NO_ERROR; + case OEMCrypto_ERROR_ENTRY_IN_USE: + return SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE; + default: + return MapOEMCryptoResult(result, SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR, + "ShrinkUsageTableHeader"); } - - return MapOEMCryptoResult(result, SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR, - "ShrinkUsageTableHeader"); } CdmResponseType CryptoSession::MoveUsageEntry(uint32_t new_entry_number) { @@ -2578,8 +2583,15 @@ CdmResponseType CryptoSession::MoveUsageEntry(uint32_t new_entry_number) { metrics_->oemcrypto_move_entry_.Increment(result); }); - return MapOEMCryptoResult(result, MOVE_USAGE_ENTRY_UNKNOWN_ERROR, - "MoveUsageEntry"); + switch (result) { + case OEMCrypto_ERROR_ENTRY_IN_USE: + LOGW("OEMCrypto_MoveEntry failed: Destination index in use: index = %u", + new_entry_number); + return MOVE_USAGE_ENTRY_DESTINATION_IN_USE; + default: + return MapOEMCryptoResult(result, MOVE_USAGE_ENTRY_UNKNOWN_ERROR, + "MoveUsageEntry"); + } } bool CryptoSession::GetAnalogOutputCapabilities(bool* can_support_output, diff --git a/libwvdrmengine/cdm/core/test/test_printers.cpp b/libwvdrmengine/cdm/core/test/test_printers.cpp index fb6b7fb0..392b9d59 100644 --- a/libwvdrmengine/cdm/core/test/test_printers.cpp +++ b/libwvdrmengine/cdm/core/test/test_printers.cpp @@ -560,6 +560,9 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) { case LOAD_USAGE_ENTRY_GENERATION_SKEW: *os << "LOAD_USAGE_ENTRY_GENERATION_SKEW"; break; + case LOAD_USAGE_ENTRY_INVALID_SESSION: + *os << "LOAD_USAGE_ENTRY_INVALID_SESSION"; + break; case LOAD_USAGE_ENTRY_SIGNATURE_FAILURE: *os << "LOAD_USAGE_ENTRY_SIGNATURE_FAILURE"; break; @@ -578,6 +581,9 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) { case LOAD_USAGE_HEADER_UNKNOWN_ERROR: *os << "LOAD_USAGE_HEADER_UNKNOWN_ERROR"; break; + case MOVE_USAGE_ENTRY_DESTINATION_IN_USE: + *os << "MOVE_USAGE_ENTRY_DESTINATION_IN_USE"; + break; case MOVE_USAGE_ENTRY_UNKNOWN_ERROR: *os << "MOVE_USAGE_ENTRY_UNKNOWN_ERROR"; break; @@ -818,8 +824,11 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) { case SET_DECRYPT_HASH_ERROR: *os << "SET_DECRYPT_HASH_ERROR"; break; - case SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR: - *os << "SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR"; + case SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE: + *os << "SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE"; + break; + case SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR: + *os << "SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR"; break; case SIGNATURE_NOT_FOUND: *os << "SIGNATURE_NOT_FOUND"; diff --git a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp index 8a5c6f32..b5578901 100644 --- a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp @@ -740,10 +740,9 @@ TEST_P(UsageTableHeaderInitializationTest, Open(security_level)) .Times(2) .WillRepeatedly(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull())) - .WillOnce(Return(SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR)); + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull())) + .WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR)); EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_)); } @@ -1306,7 +1305,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_CryptoSessionError) { EXPECT_CALL( *crypto_session_, ShrinkUsageTableHeader(usage_entry_info_vector.size() - 1, NotNull())) - .WillOnce(Return(SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR)); + .WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR)); EXPECT_NE(NO_ERROR, usage_table_header_->DeleteEntry(usage_entry_number_to_be_deleted, diff --git a/libwvdrmengine/include/WVErrors.h b/libwvdrmengine/include/WVErrors.h index 096ab9f6..38ef22c8 100644 --- a/libwvdrmengine/include/WVErrors.h +++ b/libwvdrmengine/include/WVErrors.h @@ -206,7 +206,7 @@ enum { kLoadUsageEntrySignatureFailure = ERROR_DRM_VENDOR_MIN + 218, kLoadUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 219, kUpdateUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 222, - kShrinkUsageTablerHeaderUnknownError = ERROR_DRM_VENDOR_MIN + 224, + kShrinkUsageTableHeaderUnknownError = ERROR_DRM_VENDOR_MIN + 224, kMoveUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 225, kCopyOldUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 226, kInvalidParametersEng22 = ERROR_DRM_VENDOR_MIN + 227, @@ -289,10 +289,13 @@ enum { kCannotDecryptZeroSubsamples = ERROR_DRM_VENDOR_MIN + 306, kSampleAndSubsampleSizeMismatch = ERROR_DRM_VENDOR_MIN + 307, kInvalidIvSize = ERROR_DRM_VENDOR_MIN + 308, + kLoadUsageEntryInvalidSession = ERROR_DRM_VENDOR_MIN + 309, + kMoveUsageEntryDestinationInUse = ERROR_DRM_VENDOR_MIN + 310, + kShrinkUsageTableHeaderEntryInUse = ERROR_DRM_VENDOR_MIN + 311, // This should always follow the last error code. // The offset value should be updated each time a new error code is added. - kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 308, + kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 311, // Used by crypto test mode kErrorTestMode = ERROR_DRM_VENDOR_MAX, diff --git a/libwvdrmengine/include/mapErrors-inl.h b/libwvdrmengine/include/mapErrors-inl.h index 090a21f9..bc98d9e5 100644 --- a/libwvdrmengine/include/mapErrors-inl.h +++ b/libwvdrmengine/include/mapErrors-inl.h @@ -378,6 +378,8 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) { return kLoadSystemIdError; case wvcdm::LOAD_USAGE_ENTRY_GENERATION_SKEW: return kLoadUsageEntryGenerationSkew; + case wvcdm::LOAD_USAGE_ENTRY_INVALID_SESSION: + return kLoadUsageEntryInvalidSession; case wvcdm::LOAD_USAGE_ENTRY_SIGNATURE_FAILURE: return kLoadUsageEntrySignatureFailure; case wvcdm::LOAD_USAGE_ENTRY_UNKNOWN_ERROR: @@ -394,6 +396,8 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) { return kLoadUsageInfoFileError; case wvcdm::LOAD_USAGE_INFO_MISSING: return kLoadUsageInfoMissing; + case wvcdm::MOVE_USAGE_ENTRY_DESTINATION_IN_USE: + return kMoveUsageEntryDestinationInUse; case wvcdm::MOVE_USAGE_ENTRY_UNKNOWN_ERROR: return kMoveUsageEntryUnknownError; case wvcdm::NOT_AN_ENTITLEMENT_SESSION: @@ -492,8 +496,10 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) { return kSessionNotFound16; case wvcdm::SET_DECRYPT_HASH_ERROR: return kSetDecryptHashError; - case wvcdm::SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR: - return kShrinkUsageTablerHeaderUnknownError; + case wvcdm::SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE: + return kShrinkUsageTableHeaderEntryInUse; + case wvcdm::SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR: + return kShrinkUsageTableHeaderUnknownError; case wvcdm::SIGNATURE_NOT_FOUND: return kSignatureNotFound; case wvcdm::SIGNATURE_NOT_FOUND_2: diff --git a/libwvdrmengine/include_hidl/mapErrors-inl.h b/libwvdrmengine/include_hidl/mapErrors-inl.h index a89dfd92..1f861c0d 100644 --- a/libwvdrmengine/include_hidl/mapErrors-inl.h +++ b/libwvdrmengine/include_hidl/mapErrors-inl.h @@ -246,7 +246,7 @@ static Status mapCdmResponseType(wvcdm::CdmResponseType res) { case wvcdm::LOAD_USAGE_ENTRY_SIGNATURE_FAILURE: case wvcdm::LOAD_USAGE_ENTRY_UNKNOWN_ERROR: case wvcdm::UPDATE_USAGE_ENTRY_UNKNOWN_ERROR: - case wvcdm::SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR: + case wvcdm::SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR: case wvcdm::MOVE_USAGE_ENTRY_UNKNOWN_ERROR: case wvcdm::COPY_OLD_USAGE_ENTRY_UNKNOWN_ERROR: case wvcdm::INVALID_PARAMETERS_ENG_22: @@ -355,6 +355,9 @@ static Status mapCdmResponseType(wvcdm::CdmResponseType res) { case wvcdm::CANNOT_DECRYPT_ZERO_SUBSAMPLES: case wvcdm::SAMPLE_AND_SUBSAMPLE_SIZE_MISMATCH: case wvcdm::INVALID_IV_SIZE: + case wvcdm::LOAD_USAGE_ENTRY_INVALID_SESSION: + case wvcdm::MOVE_USAGE_ENTRY_DESTINATION_IN_USE: + case wvcdm::SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE: ALOGW("Returns UNKNOWN error for legacy status: %d", res); return Status::ERROR_DRM_UNKNOWN; From 193d5c384d3e8c15f562ba9345ec88344fe56607 Mon Sep 17 00:00:00 2001 From: Alex Dale Date: Fri, 6 Mar 2020 17:46:50 -0800 Subject: [PATCH 2/3] Usage table header operations no longer need an open session. [ Merge of http://go/wvgerrit/95405 ] There are several OEMCrypto functions that do not require an open session to be called. This change updates the OEMCrypto functions related to the Usage Table Header. Bug: 150888316 Test: Linux unit tests and Android build Change-Id: Ic879876dd190fb3e058bbe8e0cce37273030b105 --- .../cdm/core/include/crypto_session.h | 10 +- .../cdm/core/src/crypto_session.cpp | 174 +++++------ .../cdm/core/src/usage_table_header.cpp | 27 +- .../certificate_provisioning_unittest.cpp | 13 +- .../core/test/usage_table_header_unittest.cpp | 281 +++++++++--------- 5 files changed, 267 insertions(+), 238 deletions(-) diff --git a/libwvdrmengine/cdm/core/include/crypto_session.h b/libwvdrmengine/cdm/core/include/crypto_session.h index 80566042..c26810fb 100644 --- a/libwvdrmengine/cdm/core/include/crypto_session.h +++ b/libwvdrmengine/cdm/core/include/crypto_session.h @@ -254,11 +254,17 @@ class CryptoSession { virtual UsageTableHeader* GetUsageTableHeader() { return usage_table_header_; } - + // The following crypto methods do not require an open session to + // complete the operations. virtual CdmResponseType CreateUsageTableHeader( + SecurityLevel requested_security_level, CdmUsageTableHeader* usage_table_header); virtual CdmResponseType LoadUsageTableHeader( + SecurityLevel requested_security_level, const CdmUsageTableHeader& usage_table_header); + virtual CdmResponseType ShrinkUsageTableHeader( + SecurityLevel requested_security_level, uint32_t new_entry_count, + CdmUsageTableHeader* usage_table_header); // Usage entry. virtual CdmResponseType CreateUsageEntry(uint32_t* entry_number); @@ -268,8 +274,6 @@ class CryptoSession { CdmUsageTableHeader* usage_table_header, CdmUsageEntry* usage_entry); // Adjust usage entries in usage table header. - virtual CdmResponseType ShrinkUsageTableHeader( - uint32_t new_entry_count, CdmUsageTableHeader* usage_table_header); virtual CdmResponseType MoveUsageEntry(uint32_t new_entry_number); virtual bool GetAnalogOutputCapabilities(bool* can_support_output, diff --git a/libwvdrmengine/cdm/core/src/crypto_session.cpp b/libwvdrmengine/cdm/core/src/crypto_session.cpp index bef1d361..0563e4e9 100644 --- a/libwvdrmengine/cdm/core/src/crypto_session.cpp +++ b/libwvdrmengine/cdm/core/src/crypto_session.cpp @@ -708,12 +708,10 @@ uint8_t CryptoSession::GetSecurityPatchLevel() { } CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) { - LOGD( - "Opening crypto session: requested_security_level: " - "requested_security_level = %s", - requested_security_level == kLevel3 - ? QUERY_VALUE_SECURITY_LEVEL_L3.c_str() - : QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str()); + LOGD("Opening crypto session: requested_security_level = %s", + requested_security_level == kLevel3 + ? QUERY_VALUE_SECURITY_LEVEL_L3.c_str() + : QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str()); RETURN_IF_UNINITIALIZED(UNKNOWN_ERROR); if (open_) return NO_ERROR; @@ -802,35 +800,33 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) { CdmSecurityLevel security_level = GetSecurityLevel(); if (security_level == kSecurityLevelL1 || security_level == kSecurityLevelL3) { - { - // This block cannot use |WithStaticFieldWriteLock| because it needs - // to unlock the lock partway through. - LOGV("Static field write lock: Open() initializing usage table"); - std::unique_lock auto_lock(static_field_mutex_); + // This block cannot use |WithStaticFieldWriteLock| because it needs + // to unlock the lock partway through. + LOGV("Static field write lock: Open() initializing usage table"); + std::unique_lock auto_lock(static_field_mutex_); - UsageTableHeader** header = security_level == kSecurityLevelL1 - ? &usage_table_header_l1_ - : &usage_table_header_l3_; - if (*header == nullptr) { - *header = new UsageTableHeader(); - // Ignore errors since we do not know when a session is opened, - // if it is intended to be used for offline/usage session related - // or otherwise. - auto_lock.unlock(); - bool is_usage_table_header_inited = - (*header)->Init(security_level, this); - auto_lock.lock(); - if (!is_usage_table_header_inited) { - delete *header; - *header = nullptr; - usage_table_header_ = nullptr; - return NO_ERROR; - } + UsageTableHeader** header = security_level == kSecurityLevelL1 + ? &usage_table_header_l1_ + : &usage_table_header_l3_; + if (*header == nullptr) { + *header = new UsageTableHeader(); + // Ignore errors since we do not know when a session is opened, + // if it is intended to be used for offline/usage session related + // or otherwise. + auto_lock.unlock(); + bool is_usage_table_header_inited = + (*header)->Init(security_level, this); + auto_lock.lock(); + if (!is_usage_table_header_inited) { + delete *header; + *header = nullptr; + usage_table_header_ = nullptr; + return NO_ERROR; } - usage_table_header_ = *header; - metrics_->usage_table_header_initial_size_.Record((*header)->size()); } - } + usage_table_header_ = *header; + metrics_->usage_table_header_initial_size_.Record((*header)->size()); + } // End |static_field_mutex_| block. } } else { metrics_->oemcrypto_usage_table_support_.SetError(result); @@ -2342,18 +2338,20 @@ CdmResponseType CryptoSession::GetUsageSupportType( } CdmResponseType CryptoSession::CreateUsageTableHeader( + SecurityLevel requested_security_level, CdmUsageTableHeader* usage_table_header) { - LOGV("Creating usage table header: id = %u", oec_session_id_); - + LOGV("Creating usage table header: requested_security_level = %s", + requested_security_level == kLevel3 + ? QUERY_VALUE_SECURITY_LEVEL_L3.c_str() + : QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str()); RETURN_IF_NULL(usage_table_header, PARAMETER_NULL); usage_table_header->resize(kEstimatedInitialUsageTableHeader); - size_t usage_table_header_size = usage_table_header->size(); OEMCryptoResult result; WithOecWriteLock("CreateUsageTableHeader Attempt 1", [&] { result = OEMCrypto_CreateUsageTableHeader( - requested_security_level_, + requested_security_level, reinterpret_cast( const_cast(usage_table_header->data())), &usage_table_header_size); @@ -2364,7 +2362,7 @@ CdmResponseType CryptoSession::CreateUsageTableHeader( usage_table_header->resize(usage_table_header_size); WithOecWriteLock("CreateUsageTableHeader Attempt 2", [&] { result = OEMCrypto_CreateUsageTableHeader( - requested_security_level_, + requested_security_level, reinterpret_cast( const_cast(usage_table_header->data())), &usage_table_header_size); @@ -2372,22 +2370,28 @@ CdmResponseType CryptoSession::CreateUsageTableHeader( }); } - if (result == OEMCrypto_SUCCESS) { - usage_table_header->resize(usage_table_header_size); + switch (result) { + case OEMCrypto_SUCCESS: + usage_table_header->resize(usage_table_header_size); + return NO_ERROR; + default: + return MapOEMCryptoResult(result, CREATE_USAGE_TABLE_ERROR, + "CreateUsageTableHeader"); } - - return MapOEMCryptoResult(result, CREATE_USAGE_TABLE_ERROR, - "CreateUsageTableHeader"); } CdmResponseType CryptoSession::LoadUsageTableHeader( + SecurityLevel requested_security_level, const CdmUsageTableHeader& usage_table_header) { - LOGV("Loading usage table header: id = %u", oec_session_id_); + LOGV("Loading usage table header: requested_security_level = %s", + requested_security_level == kLevel3 + ? QUERY_VALUE_SECURITY_LEVEL_L3.c_str() + : QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str()); OEMCryptoResult result; WithOecWriteLock("LoadUsageTableHeader", [&] { result = OEMCrypto_LoadUsageTableHeader( - requested_security_level_, + requested_security_level, reinterpret_cast(usage_table_header.data()), usage_table_header.size()); metrics_->oemcrypto_load_usage_table_header_.Increment(result); @@ -2420,6 +2424,48 @@ CdmResponseType CryptoSession::LoadUsageTableHeader( } } +CdmResponseType CryptoSession::ShrinkUsageTableHeader( + SecurityLevel requested_security_level, uint32_t new_entry_count, + CdmUsageTableHeader* usage_table_header) { + LOGV("Shrinking usage table header: requested_security_level = %s", + requested_security_level == kLevel3 + ? QUERY_VALUE_SECURITY_LEVEL_L3.c_str() + : QUERY_VALUE_SECURITY_LEVEL_DEFAULT.c_str()); + RETURN_IF_NULL(usage_table_header, PARAMETER_NULL); + + size_t usage_table_header_len = 0; + OEMCryptoResult result; + WithOecWriteLock("ShrinkUsageTableHeader Attempt 1", [&] { + result = OEMCrypto_ShrinkUsageTableHeader(requested_security_level, + new_entry_count, nullptr, + &usage_table_header_len); + metrics_->oemcrypto_shrink_usage_table_header_.Increment(result); + }); + + if (result == OEMCrypto_ERROR_SHORT_BUFFER) { + usage_table_header->resize(usage_table_header_len); + WithOecWriteLock("ShrinkUsageTableHeader Attempt 2", [&] { + result = OEMCrypto_ShrinkUsageTableHeader( + requested_security_level, new_entry_count, + reinterpret_cast( + const_cast(usage_table_header->data())), + &usage_table_header_len); + metrics_->oemcrypto_shrink_usage_table_header_.Increment(result); + }); + } + + switch (result) { + case OEMCrypto_SUCCESS: + usage_table_header->resize(usage_table_header_len); + return NO_ERROR; + case OEMCrypto_ERROR_ENTRY_IN_USE: + return SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE; + default: + return MapOEMCryptoResult(result, SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR, + "ShrinkUsageTableHeader"); + } +} + CdmResponseType CryptoSession::CreateUsageEntry(uint32_t* entry_number) { LOGV("Creating usage entry: id = %u", oec_session_id_); @@ -2534,46 +2580,6 @@ CdmResponseType CryptoSession::UpdateUsageEntry( "UpdateUsageEntry"); } -CdmResponseType CryptoSession::ShrinkUsageTableHeader( - uint32_t new_entry_count, CdmUsageTableHeader* usage_table_header) { - LOGV("Shrinking usage table header: id = %u", oec_session_id_); - - RETURN_IF_NULL(usage_table_header, PARAMETER_NULL); - - size_t usage_table_header_len = 0; - OEMCryptoResult result; - WithOecWriteLock("ShrinkUsageTableHeader Attempt 1", [&] { - result = OEMCrypto_ShrinkUsageTableHeader(requested_security_level_, - new_entry_count, nullptr, - &usage_table_header_len); - metrics_->oemcrypto_shrink_usage_table_header_.Increment(result); - }); - - if (result == OEMCrypto_ERROR_SHORT_BUFFER) { - usage_table_header->resize(usage_table_header_len); - - WithOecWriteLock("ShrinkUsageTableHeader Attempt 2", [&] { - result = OEMCrypto_ShrinkUsageTableHeader( - requested_security_level_, new_entry_count, - reinterpret_cast( - const_cast(usage_table_header->data())), - &usage_table_header_len); - metrics_->oemcrypto_shrink_usage_table_header_.Increment(result); - }); - } - - switch (result) { - case OEMCrypto_SUCCESS: - usage_table_header->resize(usage_table_header_len); - return NO_ERROR; - case OEMCrypto_ERROR_ENTRY_IN_USE: - return SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE; - default: - return MapOEMCryptoResult(result, SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR, - "ShrinkUsageTableHeader"); - } -} - CdmResponseType CryptoSession::MoveUsageEntry(uint32_t new_entry_number) { LOGV("Moving usage entry: id = %u", oec_session_id_); diff --git a/libwvdrmengine/cdm/core/src/usage_table_header.cpp b/libwvdrmengine/cdm/core/src/usage_table_header.cpp index 74b5d08e..ac45ea77 100644 --- a/libwvdrmengine/cdm/core/src/usage_table_header.cpp +++ b/libwvdrmengine/cdm/core/src/usage_table_header.cpp @@ -186,7 +186,8 @@ bool UsageTableHeader::Init(CdmSecurityLevel security_level, if (file_handle_->RetrieveUsageTableInfo( &usage_table_header_, &usage_entry_info_, &run_lru_upgrade)) { LOGI("Number of usage entries: %zu", usage_entry_info_.size()); - status = crypto_session->LoadUsageTableHeader(usage_table_header_); + status = crypto_session->LoadUsageTableHeader(requested_security_level_, + usage_table_header_); bool lru_success = true; if (status == NO_ERROR && run_lru_upgrade) { @@ -250,12 +251,14 @@ bool UsageTableHeader::Init(CdmSecurityLevel security_level, file_handle_->DeleteUsageTableInfo(); usage_entry_info_.clear(); usage_table_header_.clear(); - status = crypto_session->CreateUsageTableHeader(&usage_table_header_); + status = crypto_session->CreateUsageTableHeader(requested_security_level_, + &usage_table_header_); if (status != NO_ERROR) return false; file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_); } } else { - status = crypto_session->CreateUsageTableHeader(&usage_table_header_); + status = crypto_session->CreateUsageTableHeader(requested_security_level_, + &usage_table_header_); if (status != NO_ERROR) return false; file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_); } @@ -537,7 +540,7 @@ CdmResponseType UsageTableHeader::MoveEntry( std::unique_ptr scoped_crypto_session; CryptoSession* crypto_session = test_crypto_session_.get(); if (crypto_session == nullptr) { - scoped_crypto_session.reset((CryptoSession::MakeCryptoSession(metrics))); + scoped_crypto_session.reset(CryptoSession::MakeCryptoSession(metrics)); crypto_session = scoped_crypto_session.get(); } @@ -731,6 +734,7 @@ CdmResponseType UsageTableHeader::Shrink( if (number_of_usage_entries_to_delete == 0) return NO_ERROR; + // TODO(b/150887808): Only resize if the shrink operation is successful. usage_entry_info_.resize(usage_entry_info_.size() - number_of_usage_entries_to_delete); @@ -743,15 +747,14 @@ CdmResponseType UsageTableHeader::Shrink( crypto_session = scoped_crypto_session.get(); } - CdmResponseType status = crypto_session->Open(requested_security_level_); - if (status != NO_ERROR) return status; + const CdmResponseType status = crypto_session->ShrinkUsageTableHeader( + requested_security_level_, usage_entry_info_.size(), + &usage_table_header_); - status = crypto_session->ShrinkUsageTableHeader(usage_entry_info_.size(), - &usage_table_header_); - if (status != NO_ERROR) return status; - - file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_); - return NO_ERROR; + if (status == NO_ERROR) { + file_handle_->StoreUsageTableInfo(usage_table_header_, usage_entry_info_); + } + return status; } // Test only method. diff --git a/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp b/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp index 13ff2464..5a0a01b2 100644 --- a/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp @@ -40,16 +40,19 @@ class MockCryptoSession : public TestCryptoSession { MockCryptoSession(metrics::CryptoMetrics* metrics) : TestCryptoSession(metrics) {} MOCK_METHOD1(Open, CdmResponseType(SecurityLevel)); - MOCK_METHOD1(LoadUsageTableHeader, - CdmResponseType(const CdmUsageTableHeader&)); - MOCK_METHOD1(CreateUsageTableHeader, CdmResponseType(CdmUsageTableHeader*)); + // Usage Table Header. + MOCK_METHOD2(CreateUsageTableHeader, + CdmResponseType(SecurityLevel, CdmUsageTableHeader*)); + MOCK_METHOD2(LoadUsageTableHeader, + CdmResponseType(SecurityLevel, const CdmUsageTableHeader&)); + MOCK_METHOD3(ShrinkUsageTableHeader, + CdmResponseType(SecurityLevel, uint32_t, CdmUsageTableHeader*)); + // Usage Entry. MOCK_METHOD1(CreateUsageEntry, CdmResponseType(uint32_t*)); MOCK_METHOD2(LoadUsageEntry, CdmResponseType(uint32_t, const CdmUsageEntry&)); MOCK_METHOD2(UpdateUsageEntry, CdmResponseType(CdmUsageTableHeader*, CdmUsageEntry*)); MOCK_METHOD1(MoveUsageEntry, CdmResponseType(uint32_t)); - MOCK_METHOD2(ShrinkUsageTableHeader, - CdmResponseType(uint32_t, CdmUsageTableHeader*)); }; class TestStubCryptoSessionFactory : public CryptoSessionFactory { diff --git a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp index b5578901..e4a633ab 100644 --- a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp @@ -424,16 +424,19 @@ class MockCryptoSession : public TestCryptoSession { MockCryptoSession(metrics::CryptoMetrics* metrics) : TestCryptoSession(metrics) {} MOCK_METHOD1(Open, CdmResponseType(SecurityLevel)); - MOCK_METHOD1(LoadUsageTableHeader, - CdmResponseType(const CdmUsageTableHeader&)); - MOCK_METHOD1(CreateUsageTableHeader, CdmResponseType(CdmUsageTableHeader*)); + // Usage Table Header. + MOCK_METHOD2(CreateUsageTableHeader, + CdmResponseType(SecurityLevel, CdmUsageTableHeader*)); + MOCK_METHOD2(LoadUsageTableHeader, + CdmResponseType(SecurityLevel, const CdmUsageTableHeader&)); + MOCK_METHOD3(ShrinkUsageTableHeader, + CdmResponseType(SecurityLevel, uint32_t, CdmUsageTableHeader*)); + // Usage Entry. MOCK_METHOD1(CreateUsageEntry, CdmResponseType(uint32_t*)); MOCK_METHOD2(LoadUsageEntry, CdmResponseType(uint32_t, const CdmUsageEntry&)); MOCK_METHOD2(UpdateUsageEntry, CdmResponseType(CdmUsageTableHeader*, CdmUsageEntry*)); MOCK_METHOD1(MoveUsageEntry, CdmResponseType(uint32_t)); - MOCK_METHOD2(ShrinkUsageTableHeader, - CdmResponseType(uint32_t, CdmUsageTableHeader*)); // Fake method for testing. Having an EXPECT_CALL causes complexities // for getting table capacity during initialization. @@ -561,7 +564,7 @@ class UsageTableHeaderTest : public WvCdmTestBase { .WillOnce(DoAll(SetArgPointee<0>(usage_table_header), SetArgPointee<1>(usage_entry_info_vector), SetArgPointee<2>(false), Return(true))); - EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(usage_table_header)) + EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(_, usage_table_header)) .WillOnce(Return(NO_ERROR)); EXPECT_TRUE(usage_table_header_->Init(security_level, crypto_session_)); } @@ -594,14 +597,17 @@ class UsageTableHeaderInitializationTest }; TEST_P(UsageTableHeaderInitializationTest, CreateUsageTableHeader) { + const SecurityLevel security_level = + (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), SetArgPointee<1>(kEmptyUsageEntryInfoVector), SetArgPointee<2>(false), Return(false))); - EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull())) + EXPECT_CALL(*crypto_session_, + CreateUsageTableHeader(security_level, NotNull())) .WillOnce( - DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, StoreUsageTableInfo(kEmptyUsageTableHeader, kEmptyUsageEntryInfoVector)) .WillOnce(Return(true)); @@ -610,14 +616,17 @@ TEST_P(UsageTableHeaderInitializationTest, CreateUsageTableHeader) { } TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveLicenses) { + const SecurityLevel security_level = + (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), SetArgPointee<1>(kEmptyUsageEntryInfoVector), SetArgPointee<2>(false), Return(false))); - EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull())) + EXPECT_CALL(*crypto_session_, + CreateUsageTableHeader(security_level, NotNull())) .WillOnce( - DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR))); // TODO: Why not being called? //EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true)); EXPECT_CALL(*device_files_, StoreUsageTableInfo(kEmptyUsageTableHeader, @@ -628,14 +637,17 @@ TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveLicenses) { } TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveUsageInfo) { + const SecurityLevel security_level = + (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), SetArgPointee<1>(kEmptyUsageEntryInfoVector), SetArgPointee<2>(false), Return(false))); - EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull())) + EXPECT_CALL(*crypto_session_, + CreateUsageTableHeader(security_level, NotNull())) .WillOnce( - DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, StoreUsageTableInfo(kEmptyUsageTableHeader, kEmptyUsageEntryInfoVector)) .WillOnce(Return(true)); @@ -644,12 +656,15 @@ TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveUsageInfo) { } TEST_P(UsageTableHeaderInitializationTest, UsageTableHeaderExists) { + const SecurityLevel security_level = + (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader), SetArgPointee<1>(kUsageEntryInfoVector), SetArgPointee<2>(false), Return(true))); - EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader)) + EXPECT_CALL(*crypto_session_, + LoadUsageTableHeader(security_level, kUsageTableHeader)) .WillOnce(Return(NO_ERROR)); EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_)); @@ -658,12 +673,15 @@ TEST_P(UsageTableHeaderInitializationTest, UsageTableHeaderExists) { TEST_P(UsageTableHeaderInitializationTest, 200UsageEntries) { std::vector usage_entries_200 = k201UsageEntryInfoVector; usage_entries_200.resize(200); + const SecurityLevel security_level = + (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader), SetArgPointee<1>(usage_entries_200), SetArgPointee<2>(false), Return(true))); - EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader)) + EXPECT_CALL(*crypto_session_, + LoadUsageTableHeader(security_level, kUsageTableHeader)) .WillOnce(Return(NO_ERROR)); EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_)); @@ -681,11 +699,13 @@ TEST_P(UsageTableHeaderInitializationTest, (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; EXPECT_CALL(*crypto_session_, Open(security_level)).WillOnce(Return(NO_ERROR)); - EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader)) + EXPECT_CALL(*crypto_session_, + LoadUsageTableHeader(security_level, kUsageTableHeader)) .WillOnce(Return(NO_ERROR)); - EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull())) + EXPECT_CALL(*crypto_session_, + CreateUsageTableHeader(security_level, NotNull())) .WillOnce( - DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true)); EXPECT_CALL(*device_files_, DeleteAllUsageInfo()).WillOnce(Return(true)); EXPECT_CALL(*device_files_, DeleteUsageTableInfo()).WillOnce(Return(true)); @@ -706,17 +726,21 @@ TEST_P(UsageTableHeaderInitializationTest, 201UsageEntries_DeleteEntryFails_UsageTableHeaderRecreated) { std::vector usage_entries_202 = k201UsageEntryInfoVector; usage_entries_202.push_back(kDummyUsageEntryInfo); + const SecurityLevel security_level = + (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader), SetArgPointee<1>(k201UsageEntryInfoVector), SetArgPointee<2>(false), Return(true))); - EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader)) + EXPECT_CALL(*crypto_session_, + LoadUsageTableHeader(security_level, kUsageTableHeader)) .WillOnce(Return(NO_ERROR)); - EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull())) + EXPECT_CALL(*crypto_session_, + CreateUsageTableHeader(security_level, NotNull())) .WillOnce( - DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true)); EXPECT_CALL(*device_files_, DeleteAllUsageInfo()).WillOnce(Return(true)); EXPECT_CALL(*device_files_, DeleteUsageTableInfo()).WillOnce(Return(true)); @@ -734,14 +758,11 @@ TEST_P(UsageTableHeaderInitializationTest, .WillOnce(Return(true)); // Expectations for DeleteEntry - const SecurityLevel security_level = - (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; + EXPECT_CALL(*crypto_session_, Open(security_level)) + .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*crypto_session_, - Open(security_level)) - .Times(2) - .WillRepeatedly(Return(NO_ERROR)); - EXPECT_CALL(*crypto_session_, - ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull())) + ShrinkUsageTableHeader(security_level, + usage_entries_202.size() - 1, NotNull())) .WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR)); EXPECT_TRUE(usage_table_header_->Init(GetParam(), crypto_session_)); @@ -752,12 +773,16 @@ TEST_P(UsageTableHeaderInitializationTest, std::vector usage_entries_202 = k201UsageEntryInfoVector; usage_entries_202.push_back(kDummyUsageEntryInfo); + const SecurityLevel security_level = + (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; + EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader), SetArgPointee<1>(k201UsageEntryInfoVector), SetArgPointee<2>(false), Return(true))); - EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader)) + EXPECT_CALL(*crypto_session_, + LoadUsageTableHeader(security_level, kUsageTableHeader)) .WillOnce(Return(NO_ERROR)); // Expectations for AddEntry @@ -770,18 +795,13 @@ TEST_P(UsageTableHeaderInitializationTest, .WillOnce(Return(true)); // Expectations for DeleteEntry - const SecurityLevel security_level = - (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault; - + EXPECT_CALL(*crypto_session_, Open(security_level)) + .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*crypto_session_, - Open(security_level)) - .Times(2) - .WillRepeatedly(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull())) + ShrinkUsageTableHeader(security_level, + usage_entries_202.size() - 1, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, StoreUsageTableInfo( kAnotherUsageTableHeader, @@ -1301,10 +1321,9 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_CryptoSessionError) { usage_entry_info_vector.size() - 1; // kUsageEntryInfoOfflineLicense2 metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(usage_entry_info_vector.size() - 1, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, usage_entry_info_vector.size() - 1, NotNull())) .WillOnce(Return(SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR)); EXPECT_NE(NO_ERROR, @@ -1340,12 +1359,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastOfflineEntry) { usage_entry_info_vector.size() - 1; // kUsageEntryInfoOfflineLicense2 metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(usage_entry_info_vector.size() - 1, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, usage_entry_info_vector.size() - 1, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, StoreUsageTableInfo( @@ -1388,12 +1406,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastSecureStopEntry) { usage_entry_info_vector.size() - 1; // kUsageEntryInfoSecureStop2 metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(usage_entry_info_vector.size() - 1, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, usage_entry_info_vector.size() - 1, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, StoreUsageTableInfo( @@ -1439,12 +1456,11 @@ TEST_F(UsageTableHeaderTest, usage_entry_info_vector.size() - 3; // kUsageEntryInfoOfflineLicense1 metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, usage_entry_number_to_be_deleted, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, StoreUsageTableInfo( @@ -1497,12 +1513,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastSecureStopEntriesAreMissing) { usage_entry_info_vector.size() - 3; // kUsageEntryInfoSecureStop1 metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, usage_entry_number_to_be_deleted, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, RetrieveUsageInfoByKeySetId( @@ -1598,12 +1613,11 @@ TEST_F(UsageTableHeaderTest, device_files_->StoreLicense(offline_license_2_data, &sub_error_code)); EXPECT_EQ(DeviceFiles::kNoError, sub_error_code); - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, usage_entry_number_to_be_deleted, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, StoreUsageTableInfo( kAnotherUsageTableHeader, @@ -1656,12 +1670,11 @@ TEST_F(UsageTableHeaderTest, usage_entry_number_to_be_deleted + 1; metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, usage_entry_number_to_be_deleted, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, RetrieveUsageInfoByKeySetId( @@ -1732,12 +1745,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreStorageTypeUnknown) { usage_entry_info_vector.size() - 3; // kUsageEntryInfoOfflineLicense3 metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(usage_entry_number_to_be_deleted, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, usage_entry_number_to_be_deleted, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL( *device_files_, @@ -1968,20 +1980,18 @@ TEST_F(UsageTableHeaderTest, EXPECT_TRUE(device_files_->StoreLicense(license_data, &sub_error_code)); EXPECT_EQ(DeviceFiles::kNoError, sub_error_code); - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)) - .Times(2) - .WillRepeatedly(Return(NO_ERROR)); + EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); EXPECT_CALL(*crypto_session_, LoadUsageEntry(last_valid_usage_entry_number, kUsageEntry)) .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*crypto_session_, MoveUsageEntry(usage_entry_number_to_be_deleted)) .WillOnce(Return(MOVE_USAGE_ENTRY_UNKNOWN_ERROR)); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(last_valid_usage_entry_number + 1, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, last_valid_usage_entry_number + 1, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL( *device_files_, @@ -2043,9 +2053,7 @@ TEST_F(UsageTableHeaderTest, usage_entry_info_vector.size() - 3; // kUsageEntryInfoOfflineLicense3 metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)) - .Times(2) - .WillRepeatedly(Return(NO_ERROR)); + EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); EXPECT_CALL(*crypto_session_, LoadUsageEntry(last_valid_usage_entry_number, kUsageEntry)) .WillOnce(Return(NO_ERROR)); @@ -2063,11 +2071,11 @@ TEST_F(UsageTableHeaderTest, SetArgPointee<3>(kKeyRequest), SetArgPointee<4>(kKeyResponse), SetArgPointee<5>(kUsageEntry), SetArgPointee<6>(last_valid_usage_entry_number), Return(true))); - EXPECT_CALL( - *crypto_session_, - ShrinkUsageTableHeader(last_valid_usage_entry_number + 1, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader( + kLevelDefault, last_valid_usage_entry_number + 1, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL( *device_files_, @@ -2138,9 +2146,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) { device_files_->StoreLicense(stored_license_data, &sub_error_code)); EXPECT_EQ(DeviceFiles::kNoError, sub_error_code); - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)) - .Times(2) - .WillRepeatedly(Return(NO_ERROR)); + EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); EXPECT_CALL(*crypto_session_, LoadUsageEntry(last_usage_entry_number, kUsageEntry)) .WillOnce(Return(NO_ERROR)); @@ -2150,10 +2156,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsOffline) { EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader), SetArgPointee<1>(kAnotherUsageEntry), Return(NO_ERROR))); - EXPECT_CALL(*crypto_session_, - ShrinkUsageTableHeader(last_usage_entry_number, NotNull())) + EXPECT_CALL( + *crypto_session_, + ShrinkUsageTableHeader(kLevelDefault, last_usage_entry_number, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL( *device_files_, @@ -2243,9 +2250,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsSecureStop) { usage_entry_info_vector.size() - 1; // kUsageEntryInfoSecureStop3 metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)) - .Times(2) - .WillRepeatedly(Return(NO_ERROR)); + EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); EXPECT_CALL(*crypto_session_, LoadUsageEntry(last_usage_entry_number, kUsageEntry)) .WillOnce(Return(NO_ERROR)); @@ -2255,10 +2260,11 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntryIsSecureStop) { EXPECT_CALL(*crypto_session_, UpdateUsageEntry(NotNull(), NotNull())) .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader), SetArgPointee<1>(kAnotherUsageEntry), Return(NO_ERROR))); - EXPECT_CALL(*crypto_session_, - ShrinkUsageTableHeader(last_usage_entry_number, NotNull())) + EXPECT_CALL( + *crypto_session_, + ShrinkUsageTableHeader(kLevelDefault, last_usage_entry_number, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, RetrieveUsageInfoByKeySetId( @@ -2366,9 +2372,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) { device_files_->StoreLicense(stored_license_data, &sub_error_code)); EXPECT_EQ(DeviceFiles::kNoError, sub_error_code); - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)) - .Times(2) - .WillRepeatedly(Return(NO_ERROR)); + EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); EXPECT_CALL(*crypto_session_, LoadUsageEntry(last_valid_usage_entry_number, kUsageEntry)) .WillOnce(Return(NO_ERROR)); @@ -2379,9 +2383,10 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreOfflineAndUnknknown) { .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader), SetArgPointee<1>(kAnotherUsageEntry), Return(NO_ERROR))); EXPECT_CALL(*crypto_session_, - ShrinkUsageTableHeader(last_valid_usage_entry_number, NotNull())) + ShrinkUsageTableHeader(kLevelDefault, + last_valid_usage_entry_number, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL( *device_files_, @@ -2476,9 +2481,7 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreSecureStopAndUnknknown) { usage_entry_info_vector.size() - 3; // kUsageEntryInfoSecureStop3 metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)) - .Times(2) - .WillRepeatedly(Return(NO_ERROR)); + EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); EXPECT_CALL(*crypto_session_, LoadUsageEntry(last_valid_usage_entry_number, kUsageEntry)) .WillOnce(Return(NO_ERROR)); @@ -2489,9 +2492,10 @@ TEST_F(UsageTableHeaderTest, DeleteEntry_LastEntriesAreSecureStopAndUnknknown) { .WillOnce(DoAll(SetArgPointee<0>(kAnotherUsageTableHeader), SetArgPointee<1>(kAnotherUsageEntry), Return(NO_ERROR))); EXPECT_CALL(*crypto_session_, - ShrinkUsageTableHeader(last_valid_usage_entry_number, NotNull())) + ShrinkUsageTableHeader(kLevelDefault, + last_valid_usage_entry_number, NotNull())) .WillOnce( - DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<2>(kAnotherUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, RetrieveUsageInfoByKeySetId( @@ -2556,11 +2560,13 @@ TEST_F(UsageTableHeaderTest, StaleHeader) { .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader), SetArgPointee<1>(usage_entry_info_vector), SetArgPointee<2>(false), Return(true))); - EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader)) + EXPECT_CALL(*crypto_session_, + LoadUsageTableHeader(kLevelDefault, kUsageTableHeader)) .WillOnce(Return(LOAD_USAGE_HEADER_GENERATION_SKEW)); - EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull())) + EXPECT_CALL(*crypto_session_, + CreateUsageTableHeader(kLevelDefault, NotNull())) .WillOnce( - DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR))); + DoAll(SetArgPointee<1>(kEmptyUsageTableHeader), Return(NO_ERROR))); EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true)); EXPECT_CALL(*device_files_, DeleteAllUsageInfo()).WillOnce(Return(true)); EXPECT_CALL(*device_files_, DeleteUsageTableInfo()).WillOnce(Return(true)); @@ -2579,7 +2585,9 @@ TEST_F(UsageTableHeaderTest, Shrink_NoneOfTable) { // These calls are "expensive" and should be avoided if possible. EXPECT_CALL(*crypto_session_, Open(_)).Times(0); - EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader(_, NotNull())).Times(0); + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader(kLevelDefault, _, NotNull())) + .Times(0); EXPECT_CALL(*device_files_, StoreUsageTableInfo(_, _)).Times(0); EXPECT_EQ(usage_table_header_->Shrink(&metrics, 0), NO_ERROR); @@ -2594,9 +2602,9 @@ TEST_F(UsageTableHeaderTest, Shrink_PartOfTable) { k10UsageEntryInfoVector.cend() - to_shink); metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); - EXPECT_CALL(*crypto_session_, - ShrinkUsageTableHeader(shunken_entries.size(), NotNull())) + EXPECT_CALL( + *crypto_session_, + ShrinkUsageTableHeader(kLevelDefault, shunken_entries.size(), NotNull())) .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader, shunken_entries)) @@ -2610,8 +2618,8 @@ TEST_F(UsageTableHeaderTest, Shrink_AllOfTable) { Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector); metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); - EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader(0, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader(kLevelDefault, 0, NotNull())) .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader, kEmptyUsageEntryInfoVector)) @@ -2627,8 +2635,8 @@ TEST_F(UsageTableHeaderTest, Shrink_AllOfTable) { TEST_F(UsageTableHeaderTest, Shrink_MoreThanTable) { Init(kSecurityLevelL1, kUsageTableHeader, k10UsageEntryInfoVector); metrics::CryptoMetrics metrics; - EXPECT_CALL(*crypto_session_, Open(kLevelDefault)).WillOnce(Return(NO_ERROR)); - EXPECT_CALL(*crypto_session_, ShrinkUsageTableHeader(0, NotNull())) + EXPECT_CALL(*crypto_session_, + ShrinkUsageTableHeader(kLevelDefault, 0, NotNull())) .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader, kEmptyUsageEntryInfoVector)) @@ -2653,7 +2661,7 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_NoAction) { SetArgPointee<2>(/* lru_upgrade = */ false), Return(true))); EXPECT_CALL(*crypto_session_, - LoadUsageTableHeader(kUpgradableUsageTableHeader)) + LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader)) .WillOnce(Return(NO_ERROR)); // These function are called specifically by the LRU upgrading system. @@ -2679,7 +2687,7 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_Succeed) { SetArgPointee<2>(/* lru_upgrade = */ true), Return(true))); EXPECT_CALL(*crypto_session_, - LoadUsageTableHeader(kUpgradableUsageTableHeader)) + LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader)) .WillOnce(Return(NO_ERROR)); for (size_t i = 0; i < kUpgradableUsageEntryInfoList.size(); ++i) { @@ -2743,7 +2751,7 @@ TEST_F(UsageTableHeaderTest, SetArgPointee<2>(/* lru_upgrade = */ true), Return(true))); EXPECT_CALL(*crypto_session_, - LoadUsageTableHeader(kUpgradableUsageTableHeader)) + LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader)) .WillOnce(Return(NO_ERROR)); // Expectations of the one successful license. @@ -2803,7 +2811,7 @@ TEST_F(UsageTableHeaderTest, SetArgPointee<2>(/* lru_upgrade = */ true), Return(true))); EXPECT_CALL(*crypto_session_, - LoadUsageTableHeader(kUpgradableUsageTableHeader)) + LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader)) .WillOnce(Return(NO_ERROR)); for (size_t i = 0; i < kUpgradableUsageEntryInfoList.size(); ++i) { @@ -2856,7 +2864,7 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_AllFailure) { SetArgPointee<2>(/* lru_upgrade = */ true), Return(true))); EXPECT_CALL(*crypto_session_, - LoadUsageTableHeader(kUpgradableUsageTableHeader)) + LoadUsageTableHeader(kLevelDefault, kUpgradableUsageTableHeader)) .WillOnce(Return(NO_ERROR)); for (size_t i = 0; i < kUpgradableUsageEntryInfoList.size(); ++i) { @@ -2880,7 +2888,8 @@ TEST_F(UsageTableHeaderTest, LruUsageTableUpgrade_AllFailure) { EXPECT_CALL(*device_files_, DeleteAllLicenses()); EXPECT_CALL(*device_files_, DeleteAllUsageInfo()); EXPECT_CALL(*device_files_, DeleteUsageTableInfo()); - EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull())) + EXPECT_CALL(*crypto_session_, + CreateUsageTableHeader(kLevelDefault, NotNull())) .WillOnce(Return(NO_ERROR)); EXPECT_CALL(*device_files_, StoreUsageTableInfo(_, _)); @@ -2895,7 +2904,8 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateLicenseEntry) { SetArgPointee<1>(kUpgradedUsageEntryInfoList), SetArgPointee<2>(/* lru_upgrade = */ false), Return(true))); - EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUpgradedUsageTableHeader)) + EXPECT_CALL(*crypto_session_, + LoadUsageTableHeader(kLevelDefault, kUpgradedUsageTableHeader)) .WillOnce(Return(NO_ERROR)); EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_)); @@ -2939,7 +2949,8 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_CreateUsageInfoEntry) { SetArgPointee<1>(kUpgradedUsageEntryInfoList), SetArgPointee<2>(/* lru_upgrade = */ false), Return(true))); - EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUpgradedUsageTableHeader)) + EXPECT_CALL(*crypto_session_, + LoadUsageTableHeader(kLevelDefault, kUpgradedUsageTableHeader)) .WillOnce(Return(NO_ERROR)); EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_)); @@ -2984,7 +2995,8 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_UpdateEntry) { SetArgPointee<1>(kUpgradedUsageEntryInfoList), SetArgPointee<2>(/* lru_upgrade = */ false), Return(true))); - EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUpgradedUsageTableHeader)) + EXPECT_CALL(*crypto_session_, + LoadUsageTableHeader(kLevelDefault, kUpgradedUsageTableHeader)) .WillOnce(Return(NO_ERROR)); EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_)); @@ -3026,7 +3038,8 @@ TEST_F(UsageTableHeaderTest, LruLastUsedTime_LoadEntry) { SetArgPointee<1>(kUpgradedUsageEntryInfoList), SetArgPointee<2>(/* lru_upgrade = */ false), Return(true))); - EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUpgradedUsageTableHeader)) + EXPECT_CALL(*crypto_session_, + LoadUsageTableHeader(kLevelDefault, kUpgradedUsageTableHeader)) .WillOnce(Return(NO_ERROR)); EXPECT_TRUE(usage_table_header_->Init(kSecurityLevelL1, crypto_session_)); From a53a6bf35577dd41402dcf60ca45a63c54f85838 Mon Sep 17 00:00:00 2001 From: Cong Lin Date: Wed, 25 Mar 2020 17:26:32 -0700 Subject: [PATCH 3/3] Use unique_ptr in oemcrypto ref Merge from Widevine repo of http://go/wvgerrit/95945 The reference oemcrypto and testbed still use old style pointers, even though we now require a more modern C++ compiler. Updated a few places where smart pointer would be appropriate. Bug: 141393616 Test: Ran unit tests Change-Id: I8b1e155bce241075928e373478d6f8e1001233f9 --- .../oemcrypto/ref/src/oemcrypto_session.cpp | 21 ++++++----------- .../oemcrypto/ref/src/oemcrypto_session.h | 4 ++-- .../ref/src/oemcrypto_usage_table_ref.cpp | 23 ++++++++----------- .../ref/src/oemcrypto_usage_table_ref.h | 5 ++-- 4 files changed, 22 insertions(+), 31 deletions(-) diff --git a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.cpp b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.cpp index 5b7ee644..a3ea95ef 100644 --- a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.cpp +++ b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.cpp @@ -210,14 +210,6 @@ SessionContext::SessionContext(CryptoEngine* ce, SessionId sid, } SessionContext::~SessionContext() { - if (usage_entry_) { - delete usage_entry_; - usage_entry_ = nullptr; - } - if (session_keys_) { - delete session_keys_; - session_keys_ = nullptr; - } } // Internal utility function to derive key using CMAC-128 @@ -777,11 +769,11 @@ OEMCryptoResult SessionContext::LoadKeysNoSignature( if (session_keys_ == nullptr) { switch (license_type) { case OEMCrypto_ContentLicense: - session_keys_ = new ContentKeysContext(); + session_keys_.reset(new ContentKeysContext()); break; case OEMCrypto_EntitlementLicense: - session_keys_ = new EntitlementKeysContext(); + session_keys_.reset(new EntitlementKeysContext()); break; default: @@ -915,7 +907,8 @@ OEMCryptoResult SessionContext::LoadEntitledContentKeys( if (!key_array) { return OEMCrypto_ERROR_UNKNOWN_FAILURE; } - if (!session_keys_ || session_keys_->type() != OEMCrypto_EntitlementLicense) { + if (session_keys_ == nullptr || + session_keys_->type() != OEMCrypto_EntitlementLicense) { return OEMCrypto_ERROR_INVALID_CONTEXT; } for (size_t i = 0; i < key_array_length; ++i) { @@ -1494,8 +1487,8 @@ OEMCryptoResult SessionContext::UpdateUsageEntry(uint8_t* header_buffer, return OEMCrypto_ERROR_INVALID_CONTEXT; } return ce_->usage_table().UpdateUsageEntry( - this, usage_entry_, header_buffer, header_buffer_length, entry_buffer, - entry_buffer_length, &clock_values_); + this, usage_entry_.get(), header_buffer, header_buffer_length, + entry_buffer, entry_buffer_length, &clock_values_); } OEMCryptoResult SessionContext::DeactivateUsageEntry( @@ -1514,7 +1507,7 @@ OEMCryptoResult SessionContext::ReportUsage(const std::vector& pst, OEMCryptoResult SessionContext::MoveEntry(uint32_t new_index) { if (!usage_entry_) return OEMCrypto_ERROR_INVALID_CONTEXT; - return ce_->usage_table().MoveEntry(usage_entry_, new_index); + return ce_->usage_table().MoveEntry(usage_entry_.get(), new_index); } // Internal utility function to decrypt the message diff --git a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.h b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.h index f092d639..e6a1d787 100644 --- a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.h +++ b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.h @@ -267,7 +267,7 @@ class SessionContext { std::vector encryption_key_; std::vector session_key_; const Key* current_content_key_; - SessionContextKeys* session_keys_; + std::unique_ptr session_keys_; ODK_NonceValues nonce_values_; uint8_t license_request_hash_[ODK_SHA256_HASH_SIZE]; RSA_shared_ptr rsa_key_; @@ -275,7 +275,7 @@ class SessionContext { bool decrypt_started_; // If the license has been used in this session. ODK_TimerLimits timer_limits_; ODK_ClockValues clock_values_; - UsageTableEntry* usage_entry_; + std::unique_ptr usage_entry_; SRMVersionStatus srm_requirements_status_; enum UsageEntryStatus { kNoUsageEntry, // No entry loaded for this session. diff --git a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.cpp b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.cpp index abe6167a..db04ae78 100644 --- a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.cpp +++ b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.cpp @@ -348,9 +348,9 @@ UsageTableEntry* UsageTable::MakeEntry(uint32_t index) { return new UsageTableEntry(this, index, master_generation_number_); } -OEMCryptoResult UsageTable::CreateNewUsageEntry(SessionContext* session, - UsageTableEntry** entry, - uint32_t* usage_entry_number) { +OEMCryptoResult UsageTable::CreateNewUsageEntry( + SessionContext* session, std::unique_ptr* entry, + uint32_t* usage_entry_number) { if (!header_loaded_) { LOGE("CreateNewUsageEntry: Header not loaded."); return OEMCrypto_ERROR_UNKNOWN_FAILURE; @@ -367,16 +367,15 @@ OEMCryptoResult UsageTable::CreateNewUsageEntry(SessionContext* session, generation_numbers_.push_back(master_generation_number_); sessions_.push_back(session); master_generation_number_++; - *entry = new_entry; + entry->reset(new_entry); *usage_entry_number = index; return OEMCrypto_SUCCESS; } -OEMCryptoResult UsageTable::LoadUsageEntry(SessionContext* session, - UsageTableEntry** entry, - uint32_t index, - const std::vector& buffer, - ODK_ClockValues* clock_values) { +OEMCryptoResult UsageTable::LoadUsageEntry( + SessionContext* session, std::unique_ptr* entry, + uint32_t index, const std::vector& buffer, + ODK_ClockValues* clock_values) { if (!header_loaded_) { LOGE("CreateNewUsageEntry: Header not loaded."); return OEMCrypto_ERROR_UNKNOWN_FAILURE; @@ -393,12 +392,11 @@ OEMCryptoResult UsageTable::LoadUsageEntry(SessionContext* session, LOGE("Too many usage entries: %d/%d", index, max); return OEMCrypto_ERROR_INSUFFICIENT_RESOURCES; } - UsageTableEntry* new_entry = MakeEntry(index); + std::unique_ptr new_entry(MakeEntry(index)); OEMCryptoResult status = new_entry->LoadData(ce_, index, buffer, clock_values); if (status != OEMCrypto_SUCCESS) { - delete new_entry; return status; } if (new_entry->generation_number() != generation_numbers_[index]) { @@ -406,13 +404,12 @@ OEMCryptoResult UsageTable::LoadUsageEntry(SessionContext* session, generation_numbers_[index]); if ((new_entry->generation_number() + 1 < generation_numbers_[index]) || (new_entry->generation_number() - 1 > generation_numbers_[index])) { - delete new_entry; return OEMCrypto_ERROR_GENERATION_SKEW; } status = OEMCrypto_WARNING_GENERATION_SKEW; } sessions_[index] = session; - *entry = new_entry; + *entry = std::move(new_entry); return status; } diff --git a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.h b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.h index e8d4360b..a2d87d01 100644 --- a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.h +++ b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.h @@ -88,10 +88,11 @@ class UsageTable { virtual ~UsageTable(); OEMCryptoResult CreateNewUsageEntry(SessionContext* session, - UsageTableEntry** entry, + std::unique_ptr* entry, uint32_t* usage_entry_number); OEMCryptoResult LoadUsageEntry(SessionContext* session, - UsageTableEntry** entry, uint32_t index, + std::unique_ptr* entry, + uint32_t index, const std::vector& buffer, ODK_ClockValues* clock_values); OEMCryptoResult UpdateUsageEntry(