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

Allow Apps to Voluntarily Downgrade to L3 Crypto

Browse Source 
This merges the following changes from the Widevine CDM repository:

564f4cc  Add CdmClientPropertySet to CDM
  Adds an interface to the CDM that allows it to query its client for
  certain properties.  In this case, this includes the ability to
  specify what security level is desired, as well as support for
  service ceritifcate privacy mode.

9cfbd3e  Force Level 3 fallback
  Adds support for voluntarily invoking L3 crypto to the OEMCrypto
  wrapper.

95d12c1  Add pointer to CdmClientPropertySet class to OpenSession.
  Adds support for storing the property set on a session-by-session
  basis and choosing the appropriate crypto level.

17de442  Add Settable Properties for Clank to Android
  Adds support for setting the aforementioned properties to the
  DrmEngine

bbe704d  Fixes to force fallback to level three security
  Corrections to invoke provisioning, OEMCrypto API with configured
  security level rather than the default. Unit tests were also revised.

Note that some parts of this are also support for the ability to use
a service certificate-based privacy mode. The remaining code for
supporting this mode is still forthcoming.

Bug: 10109249
Change-Id: I2755e4dea1de3e8a56cff237360298f7b7f1bddc
This commit is contained in:
Rahul Frias
2013-08-15 10:59:42 -07:00
parent 0fa3e16999
commit f6c2a60485
45 changed files with 2359 additions and 906 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
libwvdrmengine/oemcrypto/Android.mk
View File

@@ -1,34 +0,0 @@
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_C_INCLUDES := \
vendor/widevine/libwvdrmengine/cdm/core/include \
bionic \
external/openssh \
external/openssl/include \
external/openssl/include/openssl \
external/stlport/stlport \
vendor/widevine/libwvdrmengine/oemcrypto/include \
LOCAL_SHARED_LIBRARIES := \
libcrypto \
libcutils \
libdl \
liblog \
libstlport \
libutils \
libz \
LOCAL_STATIC_LIBRARIES := \
libwvlevel3 \
LOCAL_MODULE := libwvwrapper
# TODO(fredgc): remove mock reference when library is complete.
REL_MOCK_SOURCE := ../oemcrypto/mock/src
LOCAL_SRC_FILES := \
src/wrapper.cpp \
include $(BUILD_STATIC_LIBRARY)

2
libwvdrmengine/oemcrypto/include/level3.h
View File

@@ -130,6 +130,8 @@ OEMCryptoResult Level3_DeriveKeysFromSessionKey(OEMCrypto_SESSION session,
size_t mac_key_context_length,
const uint8_t *enc_key_context,
size_t enc_key_context_length);
uint32_t Level3_APIVersion();
const char* Level3_SecurityLevel();
OEMCryptoResult Level3_Generic_Encrypt(OEMCrypto_SESSION session,
const uint8_t* in_buffer,
size_t buffer_length,

647
libwvdrmengine/oemcrypto/src/wrapper.cpp
View File

@@ -1,647 +0,0 @@
/*******************************************************************************
*
* Copyright 2013 Google Inc. All Rights Reserved.
*
* mock implementation of OEMCrypto APIs
*
******************************************************************************/
#include "OEMCryptoCENC.h"
#include <dlfcn.h>
#include <stdio.h>
#include <iostream>
#include <cstring>
#include <string>
#include "level3.h"
#include "log.h"
#include "file_store.h"
#include "properties.h"
using namespace wvoec_level3;
namespace {
typedef OEMCryptoResult (*L1_Initialize_t)(void);
typedef OEMCryptoResult (*L1_Terminate_t)(void);
typedef OEMCryptoResult (*L1_OpenSession_t)(OEMCrypto_SESSION *session);
typedef OEMCryptoResult (*L1_CloseSession_t)(OEMCrypto_SESSION session);
typedef OEMCryptoResult (*L1_GenerateDerivedKeys_t)(OEMCrypto_SESSION session,
const uint8_t *mac_key_context,
uint32_t mac_key_context_length,
const uint8_t *enc_key_context,
uint32_t enc_key_context_length);
typedef OEMCryptoResult (*L1_GenerateNonce_t)(OEMCrypto_SESSION session,
uint32_t* nonce);
typedef OEMCryptoResult (*L1_GenerateSignature_t)(OEMCrypto_SESSION session,
const uint8_t* message,
size_t message_length,
uint8_t* signature,
size_t* signature_length);
typedef OEMCryptoResult (*L1_LoadKeys_t)(OEMCrypto_SESSION session,
const uint8_t* message,
size_t message_length,
const uint8_t* signature,
size_t signature_length,
const uint8_t* enc_mac_key_iv,
const uint8_t* enc_mac_key,
size_t num_keys,
const OEMCrypto_KeyObject* key_array);
typedef OEMCryptoResult (*L1_RefreshKeys_t)(OEMCrypto_SESSION session,
const uint8_t* message,
size_t message_length,
const uint8_t* signature,
size_t signature_length,
size_t num_keys,
const OEMCrypto_KeyRefreshObject* key_array);
typedef OEMCryptoResult (*L1_SelectKey_t)(const OEMCrypto_SESSION session,
const uint8_t* key_id,
size_t key_id_length);
typedef OEMCryptoResult (*L1_DecryptCTR_t)(OEMCrypto_SESSION session,
const uint8_t *data_addr,
size_t data_length,
bool is_encrypted,
const uint8_t *iv,
size_t offset,
const OEMCrypto_DestBufferDesc* out_buffer,
uint8_t subsample_flags);
typedef OEMCryptoResult (*L1_InstallKeybox_t)(const uint8_t *keybox,
size_t keyBoxLength);
typedef OEMCryptoResult (*L1_IsKeyboxValid_t)(void);
typedef OEMCryptoResult (*L1_GetDeviceID_t)(uint8_t* deviceID,
size_t *idLength);
typedef OEMCryptoResult (*L1_GetKeyData_t)(uint8_t* keyData,
size_t *keyDataLength);
typedef OEMCryptoResult (*L1_GetRandom_t)(uint8_t* randomData,
size_t dataLength);
typedef OEMCryptoResult (*L1_WrapKeybox_t)(const uint8_t *keybox,
size_t keyBoxLength,
uint8_t *wrappedKeybox,
size_t *wrappedKeyBoxLength,
const uint8_t *transportKey,
size_t transportKeyLength);
typedef OEMCryptoResult (*L1_RewrapDeviceRSAKey_t)(OEMCrypto_SESSION session,
const uint8_t* message,
size_t message_length,
const uint8_t* signature,
size_t signature_length,
const uint32_t *nonce,
const uint8_t* enc_rsa_key,
size_t enc_rsa_key_length,
const uint8_t* enc_rsa_key_iv,
uint8_t* wrapped_rsa_key,
size_t *wrapped_rsa_key_length);
typedef OEMCryptoResult (*L1_LoadDeviceRSAKey_t)(OEMCrypto_SESSION session,
const uint8_t* wrapped_rsa_key,
size_t wrapped_rsa_key_length);
typedef OEMCryptoResult (*L1_GenerateRSASignature_t)(OEMCrypto_SESSION session,
const uint8_t* message,
size_t message_length,
uint8_t* signature,
size_t *signature_length);
typedef OEMCryptoResult (*L1_DeriveKeysFromSessionKey_t)(OEMCrypto_SESSION session,
const uint8_t* enc_session_key,
size_t enc_session_key_length,
const uint8_t *mac_key_context,
size_t mac_key_context_length,
const uint8_t *enc_key_context,
size_t enc_key_context_length);
typedef OEMCryptoResult (*L1_Generic_Encrypt_t)(OEMCrypto_SESSION session,
const uint8_t* in_buffer,
size_t buffer_length,
const uint8_t* iv,
OEMCrypto_Algorithm algorithm,
uint8_t* out_buffer);
typedef OEMCryptoResult (*L1_Generic_Decrypt_t)(OEMCrypto_SESSION session,
const uint8_t* in_buffer,
size_t buffer_length,
const uint8_t* iv,
OEMCrypto_Algorithm algorithm,
uint8_t* out_buffer);
typedef OEMCryptoResult (*L1_Generic_Sign_t)(OEMCrypto_SESSION session,
const uint8_t* in_buffer,
size_t buffer_length,
OEMCrypto_Algorithm algorithm,
uint8_t* signature,
size_t* signature_length);
typedef OEMCryptoResult (*L1_Generic_Verify_t)(OEMCrypto_SESSION session,
const uint8_t* in_buffer,
size_t buffer_length,
OEMCrypto_Algorithm algorithm,
const uint8_t* signature,
size_t signature_length);
typedef uint8_t (*L1_APIVersion_t)();
typedef const char* (*L1_SecurityLevel_t)();
struct FunctionPointers {
void* library;
L1_Initialize_t OEMCrypto_Initialize;
L1_Terminate_t OEMCrypto_Terminate;
L1_OpenSession_t OEMCrypto_OpenSession;
L1_CloseSession_t OEMCrypto_CloseSession;
L1_GenerateDerivedKeys_t OEMCrypto_GenerateDerivedKeys;
L1_GenerateNonce_t OEMCrypto_GenerateNonce;
L1_GenerateSignature_t OEMCrypto_GenerateSignature;
L1_LoadKeys_t OEMCrypto_LoadKeys;
L1_RefreshKeys_t OEMCrypto_RefreshKeys;
L1_SelectKey_t OEMCrypto_SelectKey;
L1_DecryptCTR_t OEMCrypto_DecryptCTR;
L1_InstallKeybox_t OEMCrypto_InstallKeybox;
L1_IsKeyboxValid_t OEMCrypto_IsKeyboxValid;
L1_GetDeviceID_t OEMCrypto_GetDeviceID;
L1_GetKeyData_t OEMCrypto_GetKeyData;
L1_GetRandom_t OEMCrypto_GetRandom;
L1_WrapKeybox_t OEMCrypto_WrapKeybox;
L1_RewrapDeviceRSAKey_t OEMCrypto_RewrapDeviceRSAKey;
L1_LoadDeviceRSAKey_t OEMCrypto_LoadDeviceRSAKey;
L1_GenerateRSASignature_t OEMCrypto_GenerateRSASignature;
L1_DeriveKeysFromSessionKey_t OEMCrypto_DeriveKeysFromSessionKey;
L1_APIVersion_t OEMCrypto_APIVersion;
L1_SecurityLevel_t OEMCrypto_SecurityLevel;
L1_Generic_Encrypt_t OEMCrypto_Generic_Encrypt;
L1_Generic_Decrypt_t OEMCrypto_Generic_Decrypt;
L1_Generic_Sign_t OEMCrypto_Generic_Sign;
L1_Generic_Verify_t OEMCrypto_Generic_Verify;
};
static struct FunctionPointers level1;
#define QUOTE_DEFINE(A) #A
#define QUOTE(A) QUOTE_DEFINE(A)
#define LOOKUP(Type, Name) \
level1.Name = (Type)dlsym(level1.library, QUOTE(Name)); \
if (!level1.Name) { \
dll_valid = false; \
}
extern "C"
OEMCryptoResult OEMCrypto_Initialize(void) {
// LOGD("First, I will try to load Level 1");
level1.library = dlopen("liboemcrypto.so", RTLD_NOW);
if (level1.library == NULL) {
LOGW("Could not load liboemcrypto.so. Falling Back to L3. %s", dlerror());
return Level3_Initialize();
}
bool dll_valid = true;
LOOKUP(L1_Initialize_t, OEMCrypto_Initialize);
LOOKUP(L1_Terminate_t, OEMCrypto_Terminate);
LOOKUP(L1_OpenSession_t, OEMCrypto_OpenSession);
LOOKUP(L1_CloseSession_t, OEMCrypto_CloseSession);
LOOKUP(L1_GenerateDerivedKeys_t, OEMCrypto_GenerateDerivedKeys);
LOOKUP(L1_GenerateNonce_t, OEMCrypto_GenerateNonce);
LOOKUP(L1_GenerateSignature_t, OEMCrypto_GenerateSignature);
LOOKUP(L1_LoadKeys_t, OEMCrypto_LoadKeys);
LOOKUP(L1_RefreshKeys_t, OEMCrypto_RefreshKeys);
LOOKUP(L1_SelectKey_t, OEMCrypto_SelectKey);
LOOKUP(L1_DecryptCTR_t, OEMCrypto_DecryptCTR);
LOOKUP(L1_InstallKeybox_t, OEMCrypto_InstallKeybox);
LOOKUP(L1_IsKeyboxValid_t, OEMCrypto_IsKeyboxValid);
LOOKUP(L1_GetDeviceID_t, OEMCrypto_GetDeviceID);
LOOKUP(L1_GetKeyData_t, OEMCrypto_GetKeyData);
LOOKUP(L1_GetRandom_t, OEMCrypto_GetRandom);
LOOKUP(L1_WrapKeybox_t, OEMCrypto_WrapKeybox);
LOOKUP(L1_RewrapDeviceRSAKey_t, OEMCrypto_RewrapDeviceRSAKey);
LOOKUP(L1_LoadDeviceRSAKey_t, OEMCrypto_LoadDeviceRSAKey);
LOOKUP(L1_GenerateRSASignature_t, OEMCrypto_GenerateRSASignature);
LOOKUP(L1_DeriveKeysFromSessionKey_t, OEMCrypto_DeriveKeysFromSessionKey);
LOOKUP(L1_APIVersion_t, OEMCrypto_APIVersion);
LOOKUP(L1_SecurityLevel_t, OEMCrypto_SecurityLevel);
LOOKUP(L1_Generic_Decrypt_t, OEMCrypto_Generic_Decrypt);
LOOKUP(L1_Generic_Encrypt_t, OEMCrypto_Generic_Encrypt);
LOOKUP(L1_Generic_Sign_t, OEMCrypto_Generic_Sign);
LOOKUP(L1_Generic_Verify_t, OEMCrypto_Generic_Verify);
if (!dll_valid) {
dlclose(level1.library);
level1.library = NULL;
LOGW("Could not load functions from liboemcrypto.so. Falling Back to L3.");
return Level3_Initialize();
}
OEMCryptoResult st = level1.OEMCrypto_Initialize();
if (st != OEMCrypto_SUCCESS) {
LOGW("Could not initialize liboemcrypto.so. Falling Back to L3.");
dlclose(level1.library);
level1.library = NULL;
return Level3_Initialize();
}
if (level1.OEMCrypto_APIVersion) {
uint32_t level1_version = level1.OEMCrypto_APIVersion();
if (level1_version != oec_latest_version) {
LOGW("liboemcrypto.so is version %d, not %d. Falling Back to L3.",
level1_version, oec_latest_version);
dlclose(level1.library);
level1.library = NULL;
return Level3_Initialize();
}
}
if (OEMCrypto_SUCCESS != OEMCrypto_IsKeyboxValid()) {
wvcdm::File file;
std::string filename;
if (!wvcdm::Properties::GetFactoryKeyboxPath(&filename)) {
LOGW("Bad Level 1 Keybox. Falling Back to L3.");
dlclose(level1.library);
level1.library = NULL;
return Level3_Initialize();
}
ssize_t size = file.FileSize(filename);
if( size <= 0 || !file.Open(filename, file.kBinary | file.kReadOnly) ) {
LOGW("Could not open %s. Falling Back to L3.", filename.c_str());
dlclose(level1.library);
level1.library = NULL;
return Level3_Initialize();
}
uint8_t keybox[size];
ssize_t size_read = file.Read(reinterpret_cast<char *>(keybox), size);
if (level1.OEMCrypto_InstallKeybox(keybox, size) != OEMCrypto_SUCCESS) {
LOGE("Could NOT install keybox in /factory/wv.keys. Falling Back to L3.");
dlclose(level1.library);
level1.library = NULL;
return Level3_Initialize();
}
LOGI("Installed keybox from %s", filename.c_str());
}
LOGD("OEMCrypto_Initialize Level 1 success. I will use level 1.");
return OEMCrypto_SUCCESS;
}
extern "C"
OEMCryptoResult OEMCrypto_Terminate(void) {
if (level1.library) {
OEMCryptoResult st = level1.OEMCrypto_Terminate();
dlclose(level1.library);
level1.library = NULL;
return st;
}
return Level3_Terminate();
}
extern "C"
OEMCryptoResult OEMCrypto_OpenSession(OEMCrypto_SESSION* session) {
if (level1.library) {
return level1.OEMCrypto_OpenSession(session);
}
return Level3_OpenSession(session);
}
extern "C"
OEMCryptoResult OEMCrypto_CloseSession(OEMCrypto_SESSION session) {
if (level1.library) {
return level1.OEMCrypto_CloseSession(session);
}
return Level3_CloseSession(session);
}
extern "C"
OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session,
uint32_t* nonce) {
if (level1.library) {
return level1.OEMCrypto_GenerateNonce(session, nonce);
}
return Level3_GenerateNonce(session, nonce);
}
extern "C"
OEMCryptoResult OEMCrypto_GenerateDerivedKeys(OEMCrypto_SESSION session,
const uint8_t* mac_key_context,
uint32_t mac_key_context_length,
const uint8_t* enc_key_context,
uint32_t enc_key_context_length) {
if (level1.library) {
return level1.OEMCrypto_GenerateDerivedKeys(session, mac_key_context,
mac_key_context_length,
enc_key_context,
enc_key_context_length);
}
return Level3_GenerateDerivedKeys(session, mac_key_context,
mac_key_context_length,
enc_key_context,
enc_key_context_length);
}
extern "C"
OEMCryptoResult OEMCrypto_GenerateSignature(OEMCrypto_SESSION session,
const uint8_t* message,
size_t message_length,
uint8_t* signature,
size_t* signature_length) {
if (level1.library) {
return level1.OEMCrypto_GenerateSignature(session, message, message_length,
signature, signature_length);
}
return Level3_GenerateSignature(session, message, message_length,
signature, signature_length);
}
extern "C"
OEMCryptoResult OEMCrypto_LoadKeys(OEMCrypto_SESSION session,
const uint8_t* message,
size_t message_length,
const uint8_t* signature,
size_t signature_length,
const uint8_t* enc_mac_key_iv,
const uint8_t* enc_mac_key,
size_t num_keys,
const OEMCrypto_KeyObject* key_array) {
if (level1.library) {
return level1.OEMCrypto_LoadKeys(session, message, message_length, signature,
signature_length, enc_mac_key_iv, enc_mac_key,
num_keys, key_array);
}
return Level3_LoadKeys(session, message, message_length, signature,
signature_length, enc_mac_key_iv, enc_mac_key,
num_keys, key_array);
}
extern "C"
OEMCryptoResult OEMCrypto_RefreshKeys(OEMCrypto_SESSION session,
const uint8_t* message,
size_t message_length,
const uint8_t* signature,
size_t signature_length,
size_t num_keys,
const OEMCrypto_KeyRefreshObject* key_array) {
if (level1.library) {
return level1.OEMCrypto_RefreshKeys(session, message, message_length, signature,
signature_length, num_keys, key_array);
}
return Level3_RefreshKeys(session, message, message_length, signature,
signature_length, num_keys, key_array);
}
extern "C"
OEMCryptoResult OEMCrypto_SelectKey(const OEMCrypto_SESSION session,
const uint8_t* key_id,
size_t key_id_length) {
if (level1.library) {
return level1.OEMCrypto_SelectKey(session, key_id, key_id_length);
}
return Level3_SelectKey(session, key_id, key_id_length);
}
extern "C"
OEMCryptoResult OEMCrypto_DecryptCTR(OEMCrypto_SESSION session,
const uint8_t* data_addr,
size_t data_length,
bool is_encrypted,
const uint8_t* iv,
size_t offset,
const OEMCrypto_DestBufferDesc* out_buffer,
uint8_t subsample_flags) {
if (level1.library) {
return level1.OEMCrypto_DecryptCTR(session, data_addr, data_length,
is_encrypted, iv, offset, out_buffer,
subsample_flags);
}
return Level3_DecryptCTR(session, data_addr, data_length,
is_encrypted, iv, offset, out_buffer, subsample_flags);
}
extern "C"
OEMCryptoResult OEMCrypto_InstallKeybox(const uint8_t* keybox,
size_t keyBoxLength) {
if (level1.library) {
return level1.OEMCrypto_InstallKeybox(keybox, keyBoxLength);
}
return Level3_InstallKeybox(keybox, keyBoxLength);
}
extern "C"
OEMCryptoResult OEMCrypto_IsKeyboxValid(void) {
if (level1.library) {
return level1.OEMCrypto_IsKeyboxValid();
}
return Level3_IsKeyboxValid();
}
extern "C"
OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID,
size_t* idLength) {
if (level1.library) {
return level1.OEMCrypto_GetDeviceID(deviceID, idLength);
}
return Level3_GetDeviceID(deviceID, idLength);
}
extern "C"
OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData,
size_t* keyDataLength) {
if (level1.library) {
return level1.OEMCrypto_GetKeyData(keyData, keyDataLength);
}
return Level3_GetKeyData(keyData, keyDataLength);
}
extern "C"
OEMCryptoResult OEMCrypto_GetRandom(uint8_t* randomData, size_t dataLength) {
if (level1.library) {
return level1.OEMCrypto_GetRandom(randomData, dataLength);
}
return Level3_GetRandom(randomData, dataLength);
}
extern "C"
OEMCryptoResult OEMCrypto_WrapKeybox(const uint8_t* keybox,
size_t keyBoxLength,
uint8_t* wrappedKeybox,
size_t* wrappedKeyBoxLength,
const uint8_t* transportKey,
size_t transportKeyLength) {
if (level1.library) {
return level1.OEMCrypto_WrapKeybox(keybox, keyBoxLength, wrappedKeybox,
wrappedKeyBoxLength, transportKey,
transportKeyLength);
}
return Level3_WrapKeybox(keybox, keyBoxLength, wrappedKeybox,
wrappedKeyBoxLength, transportKey,
transportKeyLength);
}
extern "C"
OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey(OEMCrypto_SESSION session,
const uint8_t* message,
size_t message_length,
const uint8_t* signature,
size_t signature_length,
const uint32_t* nonce,
const uint8_t* enc_rsa_key,
size_t enc_rsa_key_length,
const uint8_t* enc_rsa_key_iv,
uint8_t* wrapped_rsa_key,
size_t* wrapped_rsa_key_length) {
if (level1.library) {
if (!level1.OEMCrypto_RewrapDeviceRSAKey) {
return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}
return level1.OEMCrypto_RewrapDeviceRSAKey(session, message, message_length,
signature, signature_length, nonce,
enc_rsa_key, enc_rsa_key_length,
enc_rsa_key_iv, wrapped_rsa_key,
wrapped_rsa_key_length);
}
return Level3_RewrapDeviceRSAKey(session, message, message_length,
signature, signature_length, nonce,
enc_rsa_key, enc_rsa_key_length,
enc_rsa_key_iv, wrapped_rsa_key,
wrapped_rsa_key_length);
}
extern "C"
OEMCryptoResult OEMCrypto_LoadDeviceRSAKey(OEMCrypto_SESSION session,
const uint8_t* wrapped_rsa_key,
size_t wrapped_rsa_key_length) {
if (level1.library) {
if (!level1.OEMCrypto_LoadDeviceRSAKey) {
return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}
return level1.OEMCrypto_LoadDeviceRSAKey(session, wrapped_rsa_key,
wrapped_rsa_key_length);
}
return Level3_LoadDeviceRSAKey(session, wrapped_rsa_key,
wrapped_rsa_key_length);
}
extern "C"
OEMCryptoResult OEMCrypto_GenerateRSASignature(OEMCrypto_SESSION session,
const uint8_t* message,
size_t message_length,
uint8_t* signature,
size_t* signature_length) {
if (level1.library) {
if (!level1.OEMCrypto_GenerateRSASignature) {
return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}
return level1.OEMCrypto_GenerateRSASignature(session, message, message_length,
signature, signature_length);
}
return Level3_GenerateRSASignature(session, message, message_length,
signature, signature_length);
}
extern "C"
OEMCryptoResult OEMCrypto_DeriveKeysFromSessionKey(OEMCrypto_SESSION session,
const uint8_t* enc_session_key,
size_t enc_session_key_length,
const uint8_t* mac_key_context,
size_t mac_key_context_length,
const uint8_t* enc_key_context,
size_t enc_key_context_length) {
if (level1.library) {
if (!level1.OEMCrypto_DeriveKeysFromSessionKey) {
return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}
return level1.OEMCrypto_DeriveKeysFromSessionKey(session, enc_session_key,
enc_session_key_length,
mac_key_context,
mac_key_context_length,
enc_key_context,
enc_key_context_length);
}
return Level3_DeriveKeysFromSessionKey(session, enc_session_key,
enc_session_key_length,
mac_key_context,
mac_key_context_length,
enc_key_context,
enc_key_context_length);
}
extern "C"
uint32_t OEMCrypto_APIVersion() {
if (level1.library) {
if (!level1.OEMCrypto_APIVersion) {
return 5;
}
return level1.OEMCrypto_APIVersion();
}
return oec_latest_version;
}
extern "C"
const char* OEMCrypto_SecurityLevel() {
if (level1.library) {
if (!level1.OEMCrypto_SecurityLevel) {
return "Unknown";
}
return level1.OEMCrypto_SecurityLevel();
}
return "L3";
}
extern "C"
OEMCryptoResult OEMCrypto_Generic_Encrypt(OEMCrypto_SESSION session,
const uint8_t* in_buffer,
size_t buffer_length,
const uint8_t* iv,
OEMCrypto_Algorithm algorithm,
uint8_t* out_buffer) {
if (level1.library) {
if (!level1.OEMCrypto_Generic_Encrypt) {
return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}
return level1.OEMCrypto_Generic_Encrypt(session, in_buffer, buffer_length,
iv, algorithm, out_buffer);
}
return Level3_Generic_Encrypt(session, in_buffer, buffer_length,
iv, algorithm, out_buffer);
}
extern "C"
OEMCryptoResult OEMCrypto_Generic_Decrypt(OEMCrypto_SESSION session,
const uint8_t* in_buffer,
size_t buffer_length,
const uint8_t* iv,
OEMCrypto_Algorithm algorithm,
uint8_t* out_buffer) {
if (level1.library) {
if (!level1.OEMCrypto_Generic_Decrypt) {
return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}
return level1.OEMCrypto_Generic_Decrypt(session, in_buffer, buffer_length,
iv, algorithm, out_buffer);
}
return Level3_Generic_Decrypt(session, in_buffer, buffer_length,
iv, algorithm, out_buffer);
}
extern "C"
OEMCryptoResult OEMCrypto_Generic_Sign(OEMCrypto_SESSION session,
const uint8_t* in_buffer,
size_t buffer_length,
OEMCrypto_Algorithm algorithm,
uint8_t* signature,
size_t* signature_length) {
if (level1.library) {
if (!level1.OEMCrypto_Generic_Sign) {
return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}
return level1.OEMCrypto_Generic_Sign(session, in_buffer, buffer_length,
algorithm, signature,
signature_length);
}
return Level3_Generic_Sign(session, in_buffer, buffer_length,
algorithm, signature,
signature_length);
}
extern "C"
OEMCryptoResult OEMCrypto_Generic_Verify(OEMCrypto_SESSION session,
const uint8_t* in_buffer,
size_t buffer_length,
OEMCrypto_Algorithm algorithm,
const uint8_t* signature,
size_t signature_length) {
if (level1.library) {
if (!level1.OEMCrypto_Generic_Verify) {
return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}
return level1.OEMCrypto_Generic_Verify(session, in_buffer, buffer_length,
algorithm, signature,
signature_length);
}
return Level3_Generic_Verify(session, in_buffer, buffer_length,
algorithm, signature,
signature_length);
}
}; // namespace wvoec_mock

2
libwvdrmengine/oemcrypto/test/Android.mk
View File

@@ -22,9 +22,9 @@ LOCAL_C_INCLUDES += \
vendor/widevine/libwvdrmengine/third_party/stringencoders/src \
LOCAL_STATIC_LIBRARIES := \
libcdm \
libgtest \
libgtest_main \
libwvwrapper \
libwvlevel3 \
libcdm_utils \