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

Add backwards compatibility for OEMCrypto version 9

Browse Source 
This is a merge of http://go/wvgerrit/13710

The oemcrypto adapter loads a version 8, 9 or 10 library and adds
backwards compatibility for version 8 or 9.

The only function whose signature has changed from v9 to v10 is
OEMCrypto_GetHDCPCability. This CL adds backwards compatibility for
that function.

Level 3 libraries are now:
level3/arm/libwvlevel3.a  Level3 Library Mar 17 2015 14:33:34
level3/x86/libwvlevel3.a  Level3 Library Mar 17 2015 14:30:23

b/19785099 L1 Widevine missing/broken on master (Fugu)
b/19789909 L1 Widevine missing on master (AAY75B)

Change-Id: I9bd716f5cdffaf1bfbdfcd8ed067af3f5d0ac9ba
This commit is contained in:
Fred Gylys-Colwell
2015-03-17 13:52:59 -07:00
parent 12a986f808
commit bd2ac27684
5 changed files with 77 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
libwvdrmengine/cdm/core/include/oemcrypto_adapter.h
View File

@@ -23,7 +23,11 @@ OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData, size_t* keyDataLength,
SecurityLevel level);
uint32_t OEMCrypto_APIVersion(SecurityLevel level);
const char* OEMCrypto_SecurityLevel(SecurityLevel level);
OEMCryptoResult OEMCrypto_GetHDCPCapability(SecurityLevel level,
OEMCrypto_HDCP_Capability* current,
OEMCrypto_HDCP_Capability* maximum);
bool OEMCrypto_SupportsUsageTable(SecurityLevel level);
bool OEMCrypto_IsAntiRollbackHwPresent(SecurityLevel level);
} // namespace wvcdm
#endif // WVCDM_CORE_OEMCRYPTO_ADAPTER_H_

90
libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp
View File

@@ -112,6 +112,8 @@ typedef OEMCryptoResult (*L1_DeriveKeysFromSessionKey_t)(
size_t enc_key_context_length);
typedef uint32_t (*L1_APIVersion_t)();
typedef const char* (*L1_SecurityLevel_t)();
typedef OEMCryptoResult (*L1_GetHDCPCapability_V9_t)(uint8_t* current,
uint8_t* maximum);
typedef OEMCryptoResult (*L1_GetHDCPCapability_t)(
OEMCrypto_HDCP_Capability* current, OEMCrypto_HDCP_Capability* maximum);
typedef bool (*L1_SupportsUsageTable_t)();
@@ -198,6 +200,7 @@ struct FunctionPointers {
L1_LoadKeys_V8_t LoadKeys_V8;
L1_GenerateRSASignature_V8_t GenerateRSASignature_V8;
L1_GetHDCPCapability_V9_t GetHDCPCapability_V9;
};
struct LevelSession {
@@ -216,6 +219,13 @@ struct LevelSession {
return false; \
}
// An Adapter keeps a block of FunctionPointers for the built-in level 3 and
// the dynamically loaded level 1 oemcrypto. When initialized, it tries to
// load the level 1 library and verifies that all needed functions are present.
// If they are not, then it flags the level 1 as invalid. Later, when the
// function get(kLevel3) is called, if returns the level 3 function pointers.
// When get(kLevelDefault) is called, it returns level 1 function pointers if
// level 1 is valid and otherwise returns the level 3 function pointers.
class Adapter {
public:
typedef std::map<OEMCrypto_SESSION, LevelSession>::iterator map_iterator;
@@ -289,10 +299,10 @@ class Adapter {
return false;
}
level1_.version = level1_.APIVersion();
uint32_t minimum_version = 8;
if (level1_.version < minimum_version) {
const uint32_t kMinimumVersion = 8;
if (level1_.version < kMinimumVersion) {
LOGW("liboemcrypto.so is version %d, not %d. Falling Back to L3.",
level1_.version, minimum_version);
level1_.version, kMinimumVersion);
level1_.Terminate();
return false;
}
@@ -302,16 +312,20 @@ class Adapter {
} else {
LOOKUP(LoadKeys, OEMCrypto_LoadKeys);
LOOKUP(GenerateRSASignature, OEMCrypto_GenerateRSASignature);
LOOKUP(GetHDCPCapability, OEMCrypto_GetHDCPCapability);
LOOKUP(SupportsUsageTable, OEMCrypto_SupportsUsageTable);
LOOKUP(UpdateUsageTable, OEMCrypto_UpdateUsageTable);
LOOKUP(DeactivateUsageEntry, OEMCrypto_DeactivateUsageEntry);
LOOKUP(ReportUsage, OEMCrypto_ReportUsage);
LOOKUP(DeleteUsageEntry, OEMCrypto_DeleteUsageEntry);
LOOKUP(DeleteUsageTable, OEMCrypto_DeleteUsageTable);
}
if (level1_.version >= 10) {
LOOKUP(GetMaxNumberOfSessions, OEMCrypto_GetMaxNumberOfSessions);
if (level1_.version == 9) {
LOOKUP(GetHDCPCapability_V9, OEMCrypto_GetHDCPCapability_V9);
} else {
LOOKUP(GetHDCPCapability, OEMCrypto_GetHDCPCapability);
LOOKUP(IsAntiRollbackHwPresent, OEMCrypto_IsAntiRollbackHwPresent);
LOOKUP(GetNumberOfOpenSessions, OEMCrypto_GetNumberOfOpenSessions);
LOOKUP(GetMaxNumberOfSessions, OEMCrypto_GetMaxNumberOfSessions);
}
}
if (OEMCrypto_SUCCESS == level1_.IsKeyboxValid()) {
return true;
@@ -351,13 +365,13 @@ class Adapter {
level3_.GenerateSignature = Level3_GenerateSignature;
level3_.LoadKeys = Level3_LoadKeys;
level3_.RefreshKeys = Level3_RefreshKeys;
// level3_.QueryKeyControl = Level3_QueryKeyControl;
level3_.QueryKeyControl = Level3_QueryKeyControl;
level3_.SelectKey = Level3_SelectKey;
level3_.DecryptCTR = Level3_DecryptCTR;
// level3_.CopyBuffer = Level3_CopyBuffer;
level3_.CopyBuffer = Level3_CopyBuffer;
level3_.WrapKeybox = Level3_WrapKeybox;
level3_.InstallKeybox = Level3_InstallKeybox;
// level3_.LoadTestKeybox = Level3_LoadTestKeybox;
level3_.LoadTestKeybox = Level3_LoadTestKeybox;
level3_.IsKeyboxValid = Level3_IsKeyboxValid;
level3_.GetDeviceID = Level3_GetDeviceID;
level3_.GetKeyData = Level3_GetKeyData;
@@ -370,8 +384,8 @@ class Adapter {
level3_.SecurityLevel = Level3_SecurityLevel;
level3_.GetHDCPCapability = Level3_GetHDCPCapability;
level3_.SupportsUsageTable = Level3_SupportsUsageTable;
// level3_.IsAntiRollbackHwPresent = Level3_IsAntiRollbackHwPresent;
// level3_.GetNumberOfOpenSessions = Level3_GetNumberOfOpenSessions;
level3_.IsAntiRollbackHwPresent = Level3_IsAntiRollbackHwPresent;
level3_.GetNumberOfOpenSessions = Level3_GetNumberOfOpenSessions;
level3_.GetMaxNumberOfSessions = Level3_GetMaxNumberOfSessions;
level3_.Generic_Decrypt = Level3_Generic_Decrypt;
level3_.Generic_Encrypt = Level3_Generic_Encrypt;
@@ -381,7 +395,7 @@ class Adapter {
level3_.DeactivateUsageEntry = Level3_DeactivateUsageEntry;
level3_.ReportUsage = Level3_ReportUsage;
level3_.DeleteUsageEntry = Level3_DeleteUsageEntry;
// level3_.ForceDeleteUsageEntry = Level3_ForceDeleteUsageEntry;
level3_.ForceDeleteUsageEntry = Level3_ForceDeleteUsageEntry;
level3_.DeleteUsageTable = Level3_DeleteUsageTable;
level3_.version = Level3_APIVersion();
@@ -518,6 +532,26 @@ const char* OEMCrypto_SecurityLevel(SecurityLevel level) {
return fcn->SecurityLevel();
}
OEMCryptoResult OEMCrypto_GetHDCPCapability(
SecurityLevel level, OEMCrypto_HDCP_Capability* current,
OEMCrypto_HDCP_Capability* maximum) {
if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = kAdapter->get(level);
if (!fcn) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
if (fcn->version == 8) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
if (fcn->version == 9) {
if (current == NULL) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
if (maximum == NULL) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
uint8_t current_byte, maximum_byte;
OEMCryptoResult sts = fcn->GetHDCPCapability_V9(&current_byte, &maximum_byte);
*current = static_cast<OEMCrypto_HDCP_Capability>(current_byte);
*maximum = static_cast<OEMCrypto_HDCP_Capability>(maximum_byte);
return sts;
} else {
return fcn->GetHDCPCapability(current, maximum);
}
}
bool OEMCrypto_SupportsUsageTable(SecurityLevel level) {
if (!kAdapter) return false;
const FunctionPointers* fcn = kAdapter->get(level);
@@ -526,6 +560,14 @@ bool OEMCrypto_SupportsUsageTable(SecurityLevel level) {
return fcn->SupportsUsageTable();
}
bool OEMCrypto_IsAntiRollbackHwPresent(SecurityLevel level) {
if (!kAdapter) return false;
const FunctionPointers* fcn = kAdapter->get(level);
if (!fcn) return false;
if (fcn->version < 10) return false;
return fcn->IsAntiRollbackHwPresent();
}
} // namespace wvcdm
extern "C" OEMCryptoResult OEMCrypto_Initialize(void) {
@@ -742,18 +784,28 @@ extern "C" const char* OEMCrypto_SecurityLevel() {
extern "C" OEMCryptoResult OEMCrypto_GetHDCPCapability(
OEMCrypto_HDCP_Capability* current, OEMCrypto_HDCP_Capability* maximum) {
if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
if (fcn->version == 8) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
return fcn->GetHDCPCapability(current, maximum);
return OEMCrypto_GetHDCPCapability(kLevelDefault, current, maximum);
}
extern "C" bool OEMCrypto_SupportsUsageTable() {
return OEMCrypto_SupportsUsageTable(kLevelDefault);
}
extern "C" OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(size_t* maximum) {
extern "C" bool OEMCrypto_IsAntiRollbackHwPresent() {
return OEMCrypto_IsAntiRollbackHwPresent(kLevelDefault);
}
extern "C" OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(size_t* maximum) {
if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
if (!fcn) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
if (fcn->version < 10) {
return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}
return fcn->GetNumberOfOpenSessions(maximum);
}
extern "C" OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(size_t *maximum) {
if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
if (!fcn) return OEMCrypto_ERROR_UNKNOWN_FAILURE;