widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Allow queries without opening a session

Browse Source 
[ Merge of http://go/wvgerrit/69724 ]

Some queries no longer require a session to be opened before they
can be answered - security level, current HDCP level, max HDCP level,
usage support, number of open sessions, max sessions,
OEMCrypto API version, current SRM version, SRM update support,
resource rating tier and OEMCrypto build information.

b/117104043
Test: WV unit/integration tests

Change-Id: I92f8249e5599860da8cbf42d3b16f25515a46c55
This commit is contained in:
Rahul Frias
2019-01-08 09:52:40 -08:00
parent 38c45a66a3
commit 22e991343b
5 changed files with 253 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
libwvdrmengine/cdm/core/src/crypto_session.cpp
View File

@@ -341,12 +341,22 @@ bool CryptoSession::GetProvisioningToken(std::string* token) {
CdmSecurityLevel CryptoSession::GetSecurityLevel() {
LOGV("CryptoSession::GetSecurityLevel");
if (!open_) {
LOGW("CryptoSession::GetSecurityLevel: session not open");
return kSecurityLevelUninitialized;
}
return GetSecurityLevel(requested_security_level_);
}
CdmSecurityLevel CryptoSession::GetSecurityLevel(
SecurityLevel requested_level) {
LOGV("CryptoSession::GetSecurityLevel");
if (!initialized_) {
LOGW("CryptoSession::GetSecurityLevel: not initialized");
return kSecurityLevelUninitialized;
}
std::string security_level =
OEMCrypto_SecurityLevel(requested_security_level_);
std::string security_level = OEMCrypto_SecurityLevel(requested_level);
if ((security_level.size() != 2) || (security_level.at(0) != 'L')) {
return kSecurityLevelUnknown;
@@ -450,16 +460,28 @@ bool CryptoSession::GetExternalDeviceUniqueId(std::string* device_id) {
}
bool CryptoSession::GetApiVersion(uint32_t* version) {
LOGV("CryptoSession::GetApiVersion");
if (!open_) {
LOGW("CryptoSession::GetApiVersion: session not open");
return false;
}
return GetApiVersion(requested_security_level_, version);
}
bool CryptoSession::GetApiVersion(SecurityLevel security_level,
uint32_t* version) {
LOGV("CryptoSession::GetApiVersion");
if (!version) {
LOGE("CryptoSession::GetApiVersion: No buffer passed to method.");
return false;
}
if (!initialized_) {
LOGW("CryptoSession::GetApiVersion: not initialized");
return false;
}
*version = OEMCrypto_APIVersion(requested_security_level_);
*version = OEMCrypto_APIVersion(security_level);
// Record the version into the metrics.
metrics_->oemcrypto_api_version_.Record(*version);
@@ -1206,10 +1228,23 @@ CdmResponseType CryptoSession::Decrypt(const CdmDecryptionParameters& params) {
}
bool CryptoSession::UsageInformationSupport(bool* has_support) {
LOGV("UsageInformationSupport: id=%lu", oec_session_id_);
if (!initialized_) return false;
LOGV("CryptoSession::UsageInformationSupport");
if (!open_) {
LOGW("CryptoSession::UsageInformationSupport: session not open");
return false;
}
return UsageInformationSupport(requested_security_level_, has_support);
}
*has_support = OEMCrypto_SupportsUsageTable(requested_security_level_);
bool CryptoSession::UsageInformationSupport(SecurityLevel security_level,
bool* has_support) {
LOGV("CryptoSession::UsageInformationSupport");
if (!initialized_) {
LOGW("CryptoSession::UsageInformationSupport: not initialized");
return false;
}
*has_support = OEMCrypto_SupportsUsageTable(security_level);
return true;
}
@@ -1628,8 +1663,22 @@ bool CryptoSession::RewrapDeviceRSAKey30(const std::string& message,
bool CryptoSession::GetHdcpCapabilities(HdcpCapability* current,
HdcpCapability* max) {
LOGV("GetHdcpCapabilities: id=%lu", oec_session_id_);
if (!initialized_) return false;
LOGV("CryptoSession::GetHdcpCapabilities: id=%lu", oec_session_id_);
if (!open_) {
LOGW("CryptoSession::GetHdcpCapabilities: session not open");
return false;
}
return GetHdcpCapabilities(requested_security_level_, current, max);
}
bool CryptoSession::GetHdcpCapabilities(SecurityLevel security_level,
HdcpCapability* current,
HdcpCapability* max) {
LOGV("CryptoSession::GetHdcpCapabilities");
if (!initialized_) {
LOGW("CryptoSession::GetHdcpCapabilities: not initialized");
return false;
}
if (current == NULL || max == NULL) {
LOGE(
"CryptoSession::GetHdcpCapabilities: |current|, |max| cannot be "
@@ -1637,7 +1686,7 @@ bool CryptoSession::GetHdcpCapabilities(HdcpCapability* current,
return false;
}
OEMCryptoResult status =
OEMCrypto_GetHDCPCapability(requested_security_level_, current, max);
OEMCrypto_GetHDCPCapability(security_level, current, max);
if (OEMCrypto_SUCCESS != status) {
metrics_->oemcrypto_current_hdcp_capability_.SetError(status);
@@ -1685,9 +1734,13 @@ bool CryptoSession::GetRandom(size_t data_length, uint8_t* random_data) {
return true;
}
bool CryptoSession::GetNumberOfOpenSessions(size_t* count) {
bool CryptoSession::GetNumberOfOpenSessions(SecurityLevel security_level,
size_t* count) {
LOGV("GetNumberOfOpenSessions");
if (!initialized_) return false;
if (!initialized_) {
LOGW("CryptoSession::GetNumberOfOpenSessions: not initialized");
return false;
}
if (count == NULL) {
LOGE("CryptoSession::GetNumberOfOpenSessions: |count| cannot be NULL");
return false;
@@ -1695,7 +1748,7 @@ bool CryptoSession::GetNumberOfOpenSessions(size_t* count) {
size_t sessions_count;
OEMCryptoResult status = OEMCrypto_GetNumberOfOpenSessions(
requested_security_level_, &sessions_count);
security_level, &sessions_count);
if (OEMCrypto_SUCCESS != status) {
LOGW("OEMCrypto_GetNumberOfOpenSessions fails with %d", status);
@@ -1708,9 +1761,14 @@ bool CryptoSession::GetNumberOfOpenSessions(size_t* count) {
return true;
}
bool CryptoSession::GetMaxNumberOfSessions(size_t* max) {
bool CryptoSession::GetMaxNumberOfSessions(SecurityLevel security_level,
size_t* max) {
LOGV("GetMaxNumberOfSessions");
if (!initialized_) return false;
if (!initialized_) {
LOGW("CryptoSession::GetMaxNumberOfSessions: not initialized");
return false;
}
if (max == NULL) {
LOGE("CryptoSession::GetMaxNumberOfSessions: |max| cannot be NULL");
return false;
@@ -1718,7 +1776,7 @@ bool CryptoSession::GetMaxNumberOfSessions(size_t* max) {
size_t max_sessions = 0;
OEMCryptoResult status = OEMCrypto_GetMaxNumberOfSessions(
requested_security_level_, &max_sessions);
security_level, &max_sessions);
if (OEMCrypto_SUCCESS != status) {
LOGW("OEMCrypto_GetMaxNumberOfSessions fails with %d", status);
metrics_->oemcrypto_max_number_of_sessions_.SetError(status);
@@ -1774,16 +1832,29 @@ bool CryptoSession::LoadSrm(const std::string& srm) {
}
bool CryptoSession::GetResourceRatingTier(uint32_t* tier) {
LOGV("CryptoSession::GetResourceRatingTier");
if (!open_) {
LOGW("CryptoSession::GetResourceRatingTier: session not open");
return false;
}
return GetResourceRatingTier(requested_security_level_, tier);
}
bool CryptoSession::GetResourceRatingTier(SecurityLevel security_level,
uint32_t* tier) {
LOGV("GetResourceRatingTier");
if (!initialized_) return false;
if (!initialized_) {
LOGW("CryptoSession::GetResourceRatingTier: not initialized");
return false;
}
if (tier == nullptr) {
LOGE("tier destination not provided");
return false;
}
*tier = OEMCrypto_ResourceRatingTier(requested_security_level_);
*tier = OEMCrypto_ResourceRatingTier(security_level);
if (*tier < RESOURCE_RATING_TIER_LOW || *tier > RESOURCE_RATING_TIER_HIGH) {
uint32_t api_version;
if (GetApiVersion(&api_version)) {
if (GetApiVersion(security_level, &api_version)) {
if (api_version >= OEM_CRYPTO_API_VERSION_SUPPORTS_RESOURCE_RATING_TIER) {
LOGW("GetResourceRatingTier: invalid resource rating tier: %d", *tier);
}
@@ -1792,15 +1863,19 @@ bool CryptoSession::GetResourceRatingTier(uint32_t* tier) {
return true;
}
bool CryptoSession::GetBuildInformation(std::string* info) {
bool CryptoSession::GetBuildInformation(SecurityLevel security_level,
std::string* info) {
LOGV("GetBuildInformation");
if (!initialized_) return false;
if (!initialized_) {
LOGW("CryptoSession::GetBuildInformation: not initialized");
return false;
}
if (info == nullptr) {
LOGE("CryptoSession::GetBuildInformation: |info| cannot be empty");
return false;
}
const char* build_information =
OEMCrypto_BuildInformation(requested_security_level_);
OEMCrypto_BuildInformation(security_level);
if (build_information == nullptr) {
LOGE("CryptoSession::GetBuildInformation: returned null");
return false;
@@ -1810,12 +1885,15 @@ bool CryptoSession::GetBuildInformation(std::string* info) {
return true;
}
uint32_t CryptoSession::IsDecryptHashSupported() {
uint32_t CryptoSession::IsDecryptHashSupported(SecurityLevel security_level) {
LOGV("IsDecryptHashSupported");
if (!initialized_) return false;
if (!initialized_) {
LOGW("CryptoSession::IsDecryptHashSupported: not initialized");
return false;
}
uint32_t secure_decrypt_support =
OEMCrypto_SupportsDecryptHash(requested_security_level_);
OEMCrypto_SupportsDecryptHash(security_level);
switch (secure_decrypt_support) {
case OEMCrypto_Hash_Not_Supported:
case OEMCrypto_CRC_Clear_Buffer: