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

Add DecryptCTR to OEMCrypto Mock

Browse Source 
This is a software only implementation of the OEMCrypto library for
testing the rest of the DRM code.  It currently implements the
OEMCrypto_DecrtyptCTR function using a clear key.

I've included the license request code so the rest of the group can
play with it, but I have only tested part of it.

This patch also has some makefiles and an integration testing.  You
should be able to generate the shared library libclearkeydrmengine.so with
cd vendor/widevine/libclearkeydrmengine; mm
You can create some unit test and integration test programs from the
directories:
vendor/widevine/libwvdrmengine/oemcrypto/test
vendor/widevine/libclearkeydrmengine/test
vendor/widevine/libclearkeydrmengine/inttest
vendor/widevine/libclearkeydrmengine/crypto/test

This change also addresses some comments about comments in OEMCryptoDASH.h
which were made in https://googleplex-android-review.googlesource.com/257323

Change-Id: Id6899b9f8d2f09e09be2ea493baa83a6b929073b
This commit is contained in:
Fred Gylys-Colwell
2012-12-14 19:03:25 -08:00
committed by Jeff Tinker
parent 04bfbb0198
commit fede3bffdd
26 changed files with 1561 additions and 1492 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
libwvdrmengine/oemcrypto/Android.mk
View File

@@ -1 +0,0 @@
include $(call all-subdir-makefiles)

2
libwvdrmengine/oemcrypto/TODO
View File

@@ -1,2 +0,0 @@
Fred and Ed fill this out
Fred and Ed write tests.

73
libwvdrmengine/oemcrypto/include/OEMCryptoDASH.h
View File

@@ -9,18 +9,39 @@
#ifndef OEMCRYPTO_DASH_H_
#define OEMCRYPTO_DASH_H_
#include<stdint.h>
// 12/20/2012 - changes from 4.3 to 4.4:
// 1. Added key id length.
// 2. Renamed fields in DestBufferDesc.
// 12/11/2012 - changes from 4.2 to 4.3:
// 1. Include stdint.h. Change base types.
// 2. Allow NULL for mac_key in OEMCrypto_LoadKeys() (doc-only change).
// 3. Allow NULL for key_control_block in OEMCrypto_RefreshKeys() (doc-only
// change).
// 12/05/2012 - changes from 4.1 to 4.2:
// 1. Change OEMCrypto_GenerateDerivedkeys() to pass in two context strings
// for the derived key computation - one for the mac key and one for the
// encryption key.
// 12/04/2012 - changes from 4.0 to 4.1:
// 1. Change 'unsigned long' back to 'unsigned int'.
// 2. Add struct OEMCrypto_DestBufferDesc for OEMCrypto_DecryptCTR()
// output param.
// 3. Change OEMCrypto_KeyObject to use 'const OEMCrypto_UINT8*'
// 4. Change OEMCrypto_KeyRefreshObject to use 'const OEMCrypto_UINT8*'
// 5. Change enc_mac params of OEMCrypto_LoadKeys() to
// to use const OEMCrypto_UINT8*'.
// 6. Add OEMCrypto_SelectKey().
// 7. Add OEMCrypto_DestBufferDesc param to OEMCrypto_DecryptCTR().
#ifdef __cplusplus
extern "C" {
#endif
#define OEMCRYPTO_VERSION "4.0"
#define OEMCRYPTO_VERSION "4.4"
static const char oec_version[] = OEMCRYPTO_VERSION;
#include<stdint.h>
typedef uint32_t OEMCrypto_SESSION;
typedef uint8_t OEMCrypto_KeyID[16];
typedef enum OEMCryptoResult {
OEMCrypto_SUCCESS = 0,
@@ -138,7 +159,8 @@ typedef struct {
* by the caller of OEMCrypto_LoadKeys().
*/
typedef struct {
const OEMCrypto_KeyID* key_id;
const uint8_t* key_id;
size_t key_id_length;
const uint8_t* key_data_iv;
const uint8_t* key_data;
const uint8_t* key_control_iv;
@@ -165,7 +187,8 @@ typedef struct {
* by the caller of OEMCrypto_RefreshKeys().
*/
typedef struct {
const OEMCrypto_KeyID* key_id;
const uint8_t* key_id;
size_t key_id_length;
const uint8_t* key_control_iv;
const uint8_t* key_control;
} OEMCrypto_KeyRefreshObject;
@@ -287,10 +310,10 @@ OEMCryptoResult OEMCrypto_CloseSession(OEMCrypto_SESSION session);
*
* Refer to document "OEMCrypto Changes for V2 License Protocol" for details.
* This function computes the AES-128-CMAC of the enc_key_context and stores
* it in secure memory as the encrypt_key, and the first half of the mac_key.
* It then computes the AES-128-CMAC of the mac_key_context and stores it in
* the second half of the mac_key. These two keys will be stored until the
* next call to LoadKeys.
* it in secure memory as the encrypt_key.
* It then computes two cycles of AES-128-CMAC of the mac_key_context and
* stores it in the mac_key. These two keys will be stored until the next
* call to LoadKeys.
*
* Parameters:
* session (in) - crypto session identifier.
@@ -301,6 +324,10 @@ OEMCryptoResult OEMCrypto_CloseSession(OEMCrypto_SESSION session);
* computing the encryption key.
* enc_key_context_length (in) - length of the encryption key context data.
*
* Results:
* mac_key: the 256 bit mac key is generated and stored in secure memory.
* enc_key: the 128 bit encryption key is generated and stored in secure memory.
*
* Threading:
* This function may be called simultaneously with functions on other sessions,
* but not with other functions on this session.
@@ -324,23 +351,18 @@ OEMCryptoResult OEMCrypto_GenerateDerivedKeys(
*
* Description:
* Generates a 32-bit nonce to detect possible replay attack on the key
* control block.
* control block. The nonce is stored in secure memory and will be used
* for the next call to LoadKeys.
*
* Refer to documents "OEMCrypto Changes for V2 License Protocol" and "Key
* Control Block Definition" for details.
*
* XXX TODO: Verify design needs more than one nonce per session. If not,
* I will add a comment saying only once nonce is stored. If so, I will add
* a comment saying how many nonces needed. Nancy needs nine nonces, and Ned
* never needs any.
*
* Parameters:
* session (in) - crypto session identifier.
* message (in) - pointer to memory containing message to be signed.
* message_length (in) - length of the message.
* signature (out) - pointer to memory to received the computed signature.
* signature_length (in/out) - (in) length of the signature buffer.
* (out) actual length of the signature
* nonce (out) - pointer to memory to received the computed nonce.
*
* Results:
* nonce: the nonce is also stored in secure memory.
*
* Threading:
* This function may be called simultaneously with functions on other sessions,
@@ -413,7 +435,7 @@ OEMCryptoResult OEMCrypto_GenerateSignature(
* using the corresponding content key (AES-128-CBC) and the IV given in the
* KeyObject.
*
* If any key's control block does have valid verification fields, return
* If any key's control block does not have valid verification fields, return
* OEMCrypto_ERROR_INVALID_CONTEXT and do not install any keys.
*
* If any key's control block requires a nonce, and the nonce in the control
@@ -440,7 +462,7 @@ OEMCryptoResult OEMCrypto_GenerateSignature(
* signature_length (in) - length of the signature.
* enc_mac_key_iv (in) - IV for decrypting new mac_key. Size is 128 bits.
* enc_mac_key (in) - encrypted mac_key for generating new mac_key. Size is
* 128 bits.
* 256 bits.
* num_keys (in) - number of keys present.
* key_array (in) - set of keys to be installed.
*
@@ -560,7 +582,8 @@ OEMCrypto_RefreshKeys(OEMCrypto_SESSION session,
* OEMCrypto_ERROR_KEYBOX_INVALID cannot decrypt and read from Keybox
*/
OEMCryptoResult OEMCrypto_SelectKey(const OEMCrypto_SESSION session,
const OEMCrypto_KeyID* key_id);
const uint8_t* key_id,
size_t key_id_length);
/*
* OEMCrypto_DecryptCTR

24
libwvdrmengine/oemcrypto/mock/Android.mk
View File

@@ -3,18 +3,26 @@ LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := MockOEMCrypto.cpp
LOCAL_C_INCLUDES += vendor/widevine/libwvdrmengine/oemcrypto/include
LOCAL_SRC_FILES := MockOEMCrypto.cpp \
OEMCryptoWrapper.cpp \
wvcrc.cpp \
LOCAL_MODULE := libMockOEMCrypto
LOCAL_C_INCLUDES += vendor/widevine/libwvdrmengine/oemcrypto/include \
external/openssl/include \
external/openssh
LOCAL_MODULE_CLASS := SHARED_LIBRARIES
LOCAL_MODULE_SUFFIX := .so
LOCAL_MODULE := libmockoemcrypto
LOCAL_MODULE_TAGS := tests
LOCAL_SHARED_LIBRARIES := \
liblog \
libutils \
libstlport \
liblog \
libcorkscrew \
libutils \
libz \
libcutils \
libcrypto \
libdl
include $(BUILD_SHARED_LIBRARY)
include $(BUILD_STATIC_LIBRARY)

1067
libwvdrmengine/oemcrypto/mock/MockOEMCrypto.cpp
View File

File diff suppressed because it is too large Load Diff

136
libwvdrmengine/oemcrypto/mock/MockOEMCrypto.h
View File

@@ -9,14 +9,138 @@
#ifndef WV_MOCK_OEMCRYPTO_H_
#define WV_MOCK_OEMCRYPTO_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "OEMCryptoDASH.h"
#include <openssl/aes.h>
#include <stdint.h>
#include <utils/KeyedVector.h>
#include <utils/Mutex.h>
#include <utils/RefBase.h>
#include <utils/SortedVector.h>
#include <utils/String8.h>
#include <utils/Vector.h>
#include <media/stagefright/foundation/ABase.h>
extern void initializeMockOEMCrypto();
namespace wvdrm {
// Widevine keybox.
struct BinaryKeybox { // 128 bytes total.
uint8_t mDeviceId[32]; // C character string identifying the device. Null terminated.
uint8_t mKey[16]; // 128 bit AES key assigned to device. Generated by Widevine.
uint8_t mData[72]; // Key Data. Encrypted data.
uint8_t mMagic[4]; // Constant code used to recognize a valid keybox "kbox" = 0x6b626f78.
uint8_t mCrc[4]; // The CRC checksum of the first 124 bytes of the keybox.
};
struct OEMCrypto_KeyControl {
uint8_t mVerification[4]; // Known pattern to verify decryption is
// successful = ‘kctl’
uint32_t mDuration; // Maximum number of seconds during which the key
// can be used after being set. Interpret 0 as
// unlimited. (Network Byte Order)
uint32_t mNonce;
uint32_t mControl; // Bit field. (Network Byte Order)
// bit 4: data path type: 0 normal, 1 = secure only.
// bit 3: nonce enabled. 0 = ignore, 1 = requre nonce.
// bit 2: HDCP: 0 = not required, 1 = required.
// bit 1:0 CGMS control: 0 = copy freely, 2= copy once. 3= copy never.
};
enum KeyType {
SIGNING = 1,
CONTENT_ANY = 2,
CONTENT_AUDIO = 3,
CONTENT_VIDEO = 4
};
struct ControlledKey {
android::Vector<uint8_t> mKeyId;
OEMCrypto_KeyControl mControl;
uint8_t mKeyData[16];
AES_KEY mKey;
};
class MockSession : public android::RefBase {
public:
OEMCrypto_SESSION mId;
android::Vector<ControlledKey> mKeys;
ControlledKey *mCurrentKey;
bool mNoKeyLoaded;
ControlledKey mClearKey; // Stores a single key, for clear key demo.
uint8_t mMacKey[32];
uint8_t mEncryptKey[16];
uint32_t mNonce;
MockSession(OEMCrypto_SESSION id);
~MockSession();
OEMCryptoResult generateDerivedKeys(const uint8_t *mac_key_context,
uint32_t mac_key_context_length,
const uint8_t *enc_key_context,
uint32_t enc_key_context_length);
OEMCryptoResult generateNonce(uint32_t* nonce);
OEMCryptoResult generateSignature(const uint8_t* message,
size_t message_length,
uint8_t* signature,
size_t* signature_length);
OEMCryptoResult loadKeys(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);
OEMCryptoResult refreshKeys(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);
OEMCryptoResult selectKey(const uint8_t* key_id,
size_t key_id_length);
OEMCryptoResult decryptCTR(const uint8_t *data_addr,
size_t data_length,
bool is_encrypted,
const uint8_t *iv,
size_t offset,
const OEMCrypto_DestBufferDesc* out_buffer);
DISALLOW_EVIL_CONSTRUCTORS(MockSession);
};
class MockOEMCrypto : public android::RefBase {
public:
static MockOEMCrypto *sSingleton;
bool mInitialized;
BinaryKeybox mKeybox;
OEMCrypto_SESSION mMaxId;
android::KeyedVector<OEMCrypto_SESSION, android::sp<MockSession> > mSessions;
android::Mutex mSessionListMutex; // This locks list access only, not the items in the list.
// TODO: max sessions.
// TODO max keys.
bool mClearKeys;
MockOEMCrypto(BinaryKeybox *keybox = NULL);
virtual OEMCryptoResult initialize(void);
virtual OEMCryptoResult terminate(void);
virtual OEMCryptoResult openSession(OEMCrypto_SESSION *session);
virtual OEMCryptoResult closeSession(OEMCrypto_SESSION session);
virtual MockSession *findSession(OEMCrypto_SESSION id);
virtual OEMCryptoResult installKeybox(uint8_t *keybox,
size_t keyBoxLength);
virtual OEMCryptoResult isKeyboxValid(void);
virtual OEMCryptoResult getDeviceID(uint8_t* deviceID,
size_t* idLength);
virtual OEMCryptoResult getKeyData(uint8_t* keyData,
size_t* keyDataLength);
virtual ~MockOEMCrypto();
DISALLOW_EVIL_CONSTRUCTORS(MockOEMCrypto);
};
#ifdef __cplusplus
}
#endif
#endif // _WV_MOCK_OEMCRYPTO_H_

239
libwvdrmengine/oemcrypto/mock/OEMCryptoWrapper.cpp Normal file
View File

@@ -0,0 +1,239 @@
/*********************************************************************
* OEMCryptoWrapper.cpp
*
* (c) Copyright 2011-2012 Google, Inc.
*
* OEMCryptoDASH fuctions wrapped around a Mock OEMCrypto object.
*********************************************************************/
#define LOG_TAG "WV.MockOEMCrypto"
#include <utils/Log.h>
#include <utils/String8.h>
#include "OEMCryptoDASH.h"
#include "MockOEMCrypto.h"
#include "openssl/rand.h"
using namespace android;
using namespace wvdrm;
extern "C"
OEMCryptoResult OEMCrypto_Initialize(void) {
if (MockOEMCrypto::sSingleton == NULL) MockOEMCrypto::sSingleton = new MockOEMCrypto();
return MockOEMCrypto::sSingleton->initialize();
}
extern "C"
OEMCryptoResult OEMCrypto_Terminate(void) {
if (!MockOEMCrypto::sSingleton) {
ALOGE( "[OEMCrypto_Terminate(): failed - not initialized, no engine]\n" );
return OEMCrypto_ERROR_TERMINATE_FAILED;
}
return MockOEMCrypto::sSingleton->terminate();
}
extern "C"
OEMCryptoResult OEMCrypto_OpenSession(OEMCrypto_SESSION *session) {
if (! MockOEMCrypto::sSingleton) {
ALOGE("OEMCrypto not initialized");
return OEMCrypto_ERROR_OPEN_SESSION_FAILED;
}
return MockOEMCrypto::sSingleton->openSession(session);
}
extern "C"
OEMCryptoResult OEMCrypto_CloseSession(OEMCrypto_SESSION session) {
if (! MockOEMCrypto::sSingleton) {
ALOGE("OEMCrypto not initialized");
return OEMCrypto_ERROR_TERMINATE_FAILED;
}
return MockOEMCrypto::sSingleton->closeSession(session);
}
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 (! MockOEMCrypto::sSingleton) {
ALOGE("OEMCrypto not initialized");
return OEMCrypto_ERROR_INVALID_SESSION;
}
MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
if (!s) {
ALOGE("OEMCrypto no session for id %d", session);
return OEMCrypto_ERROR_INVALID_SESSION;
}
return s->generateDerivedKeys(mac_key_context,mac_key_context_length,
enc_key_context, enc_key_context_length);
}
extern "C"
OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session,
uint32_t* nonce) {
if (! MockOEMCrypto::sSingleton) {
ALOGE("OEMCrypto not initialized");
return OEMCrypto_ERROR_INVALID_SESSION;
}
MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
if (!s) {
ALOGE("OEMCrypto no session for id %d", session);
return OEMCrypto_ERROR_INVALID_SESSION;
}
return s->generateNonce(nonce);
}
extern "C"
OEMCryptoResult OEMCrypto_GenerateSignature(OEMCrypto_SESSION session,
const uint8_t* message,
size_t message_length,
uint8_t* signature,
size_t* signature_length) {
if (! MockOEMCrypto::sSingleton) {
ALOGE("OEMCrypto not initialized");
return OEMCrypto_ERROR_INVALID_SESSION;
}
MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
if (!s) {
ALOGE("OEMCrypto no session for id %d", session);
return OEMCrypto_ERROR_INVALID_SESSION;
}
return s->generateSignature(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 (! MockOEMCrypto::sSingleton) {
ALOGE("OEMCrypto not initialized");
return OEMCrypto_ERROR_INVALID_SESSION;
}
MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
if (!s) {
ALOGE("OEMCrypto no session for id %d", session);
return OEMCrypto_ERROR_INVALID_SESSION;
}
return s->loadKeys(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 (! MockOEMCrypto::sSingleton) {
ALOGE("OEMCrypto not initialized");
return OEMCrypto_ERROR_INVALID_SESSION;
}
MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
if (!s) {
ALOGE("OEMCrypto no session for id %d", session);
return OEMCrypto_ERROR_INVALID_SESSION;
}
return s->refreshKeys(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 (! MockOEMCrypto::sSingleton) {
ALOGE("OEMCrypto not initialized");
return OEMCrypto_ERROR_INVALID_SESSION;
}
MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
if (!s) {
ALOGE("OEMCrypto no session for id %d", session);
return OEMCrypto_ERROR_INVALID_SESSION;
}
return s->selectKey(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) {
if (! MockOEMCrypto::sSingleton) {
ALOGE("OEMCrypto not initialized");
return OEMCrypto_ERROR_INVALID_SESSION;
}
MockSession *s = MockOEMCrypto::sSingleton->findSession(session);
if (!s) {
ALOGE("OEMCrypto no session for id %d", session);
return OEMCrypto_ERROR_INVALID_SESSION;
}
return s->decryptCTR(data_addr, data_length, is_encrypted,
iv, offset, out_buffer);
}
extern "C"
OEMCryptoResult OEMCrypto_InstallKeybox(uint8_t *keybox,
size_t keyBoxLength) {
if (!MockOEMCrypto::sSingleton) {
MockOEMCrypto::sSingleton = new MockOEMCrypto(NULL);
}
return MockOEMCrypto::sSingleton->installKeybox(keybox, keyBoxLength);
}
extern "C"
OEMCryptoResult OEMCrypto_IsKeyboxValid(void) {
if (!MockOEMCrypto::sSingleton) {
MockOEMCrypto::sSingleton = new MockOEMCrypto(NULL);
}
return MockOEMCrypto::sSingleton->isKeyboxValid();
}
extern "C"
OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID,
size_t *idLength) {
if (MockOEMCrypto::sSingleton == NULL) MockOEMCrypto::sSingleton = new MockOEMCrypto();
return MockOEMCrypto::sSingleton->getDeviceID(deviceID, idLength);
}
extern "C"
OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData,
size_t *keyDataLength) {
if (MockOEMCrypto::sSingleton == NULL) MockOEMCrypto::sSingleton = new MockOEMCrypto();
return MockOEMCrypto::sSingleton->getKeyData(keyData, keyDataLength);
}
extern "C"
OEMCryptoResult OEMCrypto_GetRandom(uint8_t* randomData,
size_t dataLength) {
ALOGV("OEMCryptoResult OEMCrypto_GetRandom\n");
if (RAND_bytes(randomData, dataLength)) {
return OEMCrypto_SUCCESS;
} else {
return OEMCrypto_ERROR_RNG_FAILED;
}
}
extern "C"
OEMCryptoResult OEMCrypto_WrapKeybox(uint8_t *keybox,
size_t keyBoxLength,
uint8_t *wrappedKeybox,
size_t *wrappedKeyBoxLength,
uint8_t *transportKey,
size_t transportKeyLength) {
return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

2
libwvdrmengine/oemcrypto/mock/TODO
View File

@@ -1,2 +0,0 @@
Fred and Ed fill this out
Fred and Ed write tests.

93
libwvdrmengine/oemcrypto/mock/wvcrc.cpp Normal file
View File

@@ -0,0 +1,93 @@
/*********************************************************************
* wvcrc32.cpp
*
* (c) Copyright 2011-2012 Google, Inc.
*
* Compte CRC32 Checksum. Needed for verification of WV Keybox.
*********************************************************************/
#include "wvcrc32.h"
#define INIT_CRC32 0xffffffff
uint32_t wvrunningcrc32(uint8_t* p_begin, int i_count, uint32_t i_crc) {
static uint32_t CRC32[256] = {
0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,
0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,
0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011,
0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81,
0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,
0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae,
0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066,
0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,
0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686,
0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f,
0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47,
0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7,
0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f,
0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f,
0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30,
0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088,
0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0,
0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
};
/* Calculate the CRC */
while (i_count > 0) {
i_crc = (i_crc << 8) ^ CRC32[(i_crc >> 24) ^ ((uint32_t) * p_begin) ];
p_begin++;
i_count--;
}
return(i_crc);
}
uint32_t wvcrc32(uint8_t* p_begin, int i_count) {
return(wvrunningcrc32(p_begin, i_count, INIT_CRC32));
}

16
libwvdrmengine/oemcrypto/mock/wvcrc32.h Normal file
View File

@@ -0,0 +1,16 @@
/*********************************************************************
* wvcrc32.h
*
* (c) Copyright 2011-2012 Google, Inc.
*
* Compte CRC32 Checksum. Needed for verification of WV Keybox.
*********************************************************************/
#ifndef WV_CRC_32_H_
#define WV_CRC_32_H_
#include <stdint.h>
uint32_t wvcrc32(uint8_t* p_begin, int i_count);
#endif // WV_MOCK_OEMCRYPTO_H_

2
libwvdrmengine/oemcrypto/src/TODO
View File

@@ -1,2 +0,0 @@
Fred and Ed fill this out
Fred and Ed write tests.

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

@@ -10,18 +10,28 @@ LOCAL_MODULE_TAGS := tests
LOCAL_C_INCLUDES += \
bionic \
vendor/widevine/libwvdrmengine/oemcrypto/include \
vendor/widevine/libwvdrmengine/oemcrypto/mock
vendor/widevine/libwvdrmengine/oemcrypto/mock \
external/gtest/include \
external/openssl/include \
external/stlport/stlport \
LOCAL_STATIC_LIBRARIES := \
libgtest \
libgtest_main \
libmockoemcrypto # This is used before a real OEMCrypto library exists.
LOCAL_SHARED_LIBRARIES := \
libdrmframework \
libstlport \
liblog \
libutils \
libz \
libcutils \
libdl \
libMockOEMCrypto # This is used before a real OEMCrypto library exists.
libcrypto \
LOCAL_MODULE:=test-oemcrypto
include $(BUILD_EXECUTABLE)
# Sublibraries Needed:
include vendor/widevine/libwvdrmengine/oemcrypto/mock/Android.mk

2
libwvdrmengine/oemcrypto/test/TODO
View File

@@ -1,2 +0,0 @@
Fred and Ed fill this out
Fred and Ed write tests.

514
libwvdrmengine/oemcrypto/test/TestOEMCrypto.cpp
View File

@@ -1,6 +1,7 @@
/*
* Copyright (C) 2011 Google, Inc. All Rights Reserved
*/
* Requires gtest "mm $ANDROID/external/gtest" before mm in this directory.
*/
#include <stdlib.h>
#include <unistd.h>
@@ -14,15 +15,514 @@
#include <dlfcn.h>
#define LOG_TAG "WV.TestOEMCrypto"
#include <utils/Log.h>
#include <openssl/aes.h>
#include "OEMCryptoDASH.h" // Unit Test 1: The header file must compile.
#include "MockOEMCrypto.h"
int main( int argc, char *argv[] )
{
ALOGD("--- Running Test OEMCrypto.\n"); // Unit Test 2: The code links.
initializeMockOEMCrypto();
#include "gtest/gtest.h"
ALOGD("--- Finished Running OEMCrypto.\n"); // Unit Test 2: The code links.
return(0);
using namespace wvdrm;
// Make an array of bytes from the string in Hexidecimal.
uint8_t * makeArray(const char *hex, size_t *length=NULL) {
size_t hex_length = strlen(hex);
uint8_t* array = new uint8_t[hex_length/2];
size_t hex_index = 0;
size_t array_index = 0;
while( hex_index < hex_length) {
// skip spaces and dashes.
if ((hex[hex_index] == '-') || (hex[hex_index] == ' ')) {
hex_index++;
} else {
unsigned int value;
sscanf(hex +hex_index, "%02x", &value);
array[array_index] = value;
hex_index += 2;
array_index += 1;
}
}
if (length != NULL) *length = array_index;
return array;
}
class OEMCryptoTest : public testing::Test {
protected:
virtual void SetUp() {
ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_Initialize())
<< "OEMCrypto_Initialize failed.";
}
virtual void TearDown() {
ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_Terminate())
<< "OEMCrypto_Terminate failed.";
}
public:
};
TEST_F(OEMCryptoTest, MockOEMCrypto_isKeyboxValid) {
ASSERT_EQ(OEMCrypto_IsKeyboxValid(), OEMCrypto_SUCCESS);
}
TEST_F(OEMCryptoTest, MockOEMCrypto_GenerateDerivedKeys) {
OEMCrypto_SESSION session;
// This is the Eureka test key.
static const uint8_t device_key[16] = {
0x89, 0xc0, 0x85, 0x0c, 0xbd, 0xcd, 0xa9, 0x62,
0xdc, 0x33, 0x2f, 0x96, 0x0e, 0x11, 0xcc, 0x67,
};
memcpy(MockOEMCrypto::sSingleton->mKeybox.mKey, device_key, 16);
// This data was captured from a successful licence request using the Eureka
// test data. I'm just going to borrow it.
uint32_t mac_length = 0;
const uint8_t *mac_context = makeArray("41555448454e5449434154494f4e00" // AUTHENTICATION
"0a4c0800124800000002000001241f34"
"4db9dff087f01d917910f39b60dc7797"
"cd97789ee82516dc07a478cb70b8c08c"
"299293150aa8e01d2dc9808c98daa16e"
"40a0e55dfe3618c7584dd3c7be42122c"
"122a0a10303132333435363738394142"
"4344454610011a146d79436f6f6c5265"
"71756573742c20447564652118012000"
"00000100", &mac_length);
uint32_t enc_length = 0;
const uint8_t *enc_context = makeArray("454e4352595054494f4e00" // ENCRYPTION
"0a4c0800124800000002000001241f34"
"4db9dff087f01d917910f39b60dc7797"
"cd97789ee82516dc07a478cb70b8c08c"
"299293150aa8e01d2dc9808c98daa16e"
"40a0e55dfe3618c7584dd3c7be42122c"
"122a0a10303132333435363738394142"
"4344454610011a146d79436f6f6c5265"
"71756573742c20447564652118012000"
"00000080",
&enc_length);
uint32_t key_length = 0;
const uint8_t* mac_key = makeArray("d53c018d4a4d2cdb19685d1764845a87"
"7474dc020a2d19225d385ce2176bd61c",
&key_length);
EXPECT_EQ(32, (int)key_length) << "The mac key has the wrong length.";
const uint8_t* enc_key = makeArray("9713d57529b9f0a84fa06371af92b791",
&key_length);
EXPECT_EQ(16, (int)key_length) << "The encrypt key has the wrong length";
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_OpenSession(&session))
<< "OpenSession not successful.";
MockSession* ms = MockOEMCrypto::sSingleton->findSession(session);
EXPECT_EQ(OEMCrypto_SUCCESS,
OEMCrypto_GenerateDerivedKeys(session, mac_context, mac_length,
enc_context, enc_length))
<< "GenerateDerivedKeys failed.";
EXPECT_EQ(0, memcmp(ms->mEncryptKey, enc_key, 16));
EXPECT_EQ(0, memcmp(ms->mMacKey, mac_key, 32));
// printf("\n--------------------------\n");
// printf("enc is: ");
// for(int i=0; i < 16; i++) printf(" %02x", ms->encrypt_key[i]);
// printf("\n");
// printf("should: ");
// for(int i=0; i < 16; i++) printf(" %02x", enc_key[i]);
// printf("\n");
// printf("\n--------------------------\n");
// printf("mac is: ");
// for(int i=0; i < 32; i++) printf(" %02x", ms->mac_key[i]);
// printf("\n");
// printf("should: ");
// for(int i=0; i < 32; i++) printf(" %02x", mac_key[i]);
// printf("\n");
// printf("\n--------------------------\n");
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_CloseSession(session))
<< "OEMCrypto_CloseSesion failed.";
EXPECT_EQ(OEMCrypto_ERROR_INVALID_SESSION, OEMCrypto_CloseSession(session))
<< "Can only close session once. ";
}
TEST_F(OEMCryptoTest, MockOEMCrypto_GenerateSignature) {
OEMCrypto_SESSION session;
// session = 0xdeadbeef;
size_t message_length = 0;
const uint8_t* message = makeArray("0a300a146d79436f6f6c526571756573"
"742c2044756465211208ec2316261123"
"b47c1a0a507572636861736573212001"
"28001204080118011a3612103cb829f7"
"c0241dc1434982d9e059ae0d1a20015f"
"6157446481b9a32823c2657c9c464fe2"
"e6115e96963f1d3c484ce95bff1e2001"
"1a2e0a066b657920696412104e793f3b"
"ef67bc83f7deacfbf1e9d3851a101308"
"fb0835bda16782f902f5c49644d52002"
"209580ff8505", &message_length);
uint8_t signature[32];
uint32_t signature_length = 32;
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_OpenSession(&session));
// MockSession *ms = MockOEMCrypto::sSingleton->findSession(session);
// TODO: enter some test vectors.
EXPECT_EQ(OEMCrypto_SUCCESS,
OEMCrypto_GenerateSignature(session, message, message_length,
signature, &signature_length))
<< "Generate signature failed.";
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_CloseSession(session))
<< "OEMCrypto_CloseSesion failed.";
delete [] message;
}
/* Test a single call to decryptCTR. */
TEST_F(OEMCryptoTest, MockOEMCrypto_DecryptContent) {
OEMCrypto_SESSION session;
// session = 0xdeadbeef;
// This is the test content from iStreamPlanet.
size_t keyid_length = 0;
const uint8_t* keyid = makeArray("60061e01-7e57-5e57-ce57-d00d1ed00d1e",
&keyid_length);
EXPECT_EQ(16, (int)keyid_length) << "Key ID setup incorrectly.";
size_t key_length = 0;
const uint8_t* key = makeArray("1a 8a 20 95 e4 de b2 d2 9e c8 16 ac 7b ae 20 82",
&keyid_length);
EXPECT_EQ(16, (int)keyid_length) << "Key setup incorrectly.";
uint8_t * iv = makeArray("000102030405060708090a0b0c0d0e0f");
uint8_t ecount[16];
uint8_t ivec[16];
unsigned int num = 0;
memset(ecount, 0, 16);
memcpy(ivec, iv, 16);
AES_KEY aes_key;
AES_set_encrypt_key(key, 128, &aes_key);
int bytes_read, bytes_written;
const size_t count = 751; // a nice big number, but not too round.
unsigned char indata[count];
unsigned char outdata[count];
memset(indata, 0xAA, count);
AES_ctr128_encrypt(indata, outdata, count, &aes_key, ivec, ecount, &num);
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_OpenSession(&session))
<< "OEMCrypto_OpenSession failed.";
// TODO: turn on clear keys. Or rather, allow clear keys to be turned off.
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_SelectKey(session, key, keyid_length))
<< "OEMCrypto_SelectKey failed.";
OEMCrypto_DestBufferDesc out_buffer;
out_buffer.type = OEMCrypto_BufferType_Clear;
out_buffer.buffer.clear.address = new uint8_t[count];
out_buffer.buffer.clear.max_length = count;
memset(out_buffer.buffer.clear.address, 0, count);
EXPECT_EQ(OEMCrypto_SUCCESS,
OEMCrypto_DecryptCTR(session, outdata, count, true, iv,
0, // offset=0
&out_buffer)) << "OEMCrypto_DecryptCTR";
EXPECT_EQ(0, memcmp(indata,out_buffer.buffer.clear.address, count))
<< "Final result was wrong.";
// printf("\n--------------------------\n");
// printf("ivec : ");
// for(int i=0; i < 16; i++) printf(" %02x", ivec[i]);
// printf("\n");
// printf("count: ");
// for(int i=0; i < 16; i++) printf(" %02x", ecount[i]);
// printf(" num=%d\n", num);
// printf("Input: ");
// for(int i=0; i < 16; i++) printf(" %02x", indata[i]);
// printf("\n");
// printf("Outpt: ");
// for(int i=0; i < 16; i++) printf(" %02x", out_buffer.buffer.clear.address[i]);
// printf("\n");
// printf("Encry: ");
// for(int i=0; i < 16; i++) printf(" %02x", outdata[i]);
// printf("\n");
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_CloseSession(session))
<< "OEMCrypto_CloseSesion failed.";
delete [] out_buffer.buffer.clear.address;
delete [] keyid;
delete [] key;
}
TEST_F(OEMCryptoTest, MockOEMCrypto_LoadKeys) {
OEMCrypto_SESSION session;
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_OpenSession(&session));
MockSession* ms = MockOEMCrypto::sSingleton->findSession(session);
uint32_t key_length = 0;
const uint8_t* mac_key = makeArray("d53c018d4a4d2cdb19685d1764845a87"
"7474dc020a2d19225d385ce2176bd61c",
&key_length);
EXPECT_EQ(32, (int)key_length);
const uint8_t* enc_key = makeArray("9713d57529b9f0a84fa06371af92b791",
&key_length);
EXPECT_EQ(16, (int)key_length);
memcpy(ms->mEncryptKey, enc_key, 16);
memcpy(ms->mMacKey, mac_key, 32);
uint32_t message_length = 0;
const uint8_t* message = makeArray("0a300a146d79436f6f6c526571756573"
"742c2044756465211208ec2316261123"
"b47c1a0a507572636861736573212001"
"28001204080118011a3612103cb829f7"
"c0241dc1434982d9e059ae0d1a20015f"
"6157446481b9a32823c2657c9c464fe2"
"e6115e96963f1d3c484ce95bff1e2001"
"1a2e0a066b657920696412104e793f3b"
"ef67bc83f7deacfbf1e9d3851a101308"
"fb0835bda16782f902f5c49644d52002"
"209580ff8505",
&message_length);
uint32_t signature_length = 0;
const uint8_t* signature = makeArray("7941857a3a42dd46992dc585e8e3ac01"
"5ff491bd190921e5f4212074795575fd",
&signature_length);
uint8_t* enc_mac_key_iv = makeArray("3cb829f7c0241dc1434982d9e059ae0d",
&key_length);
EXPECT_EQ(16, (int)key_length);
uint8_t* enc_mac_key = makeArray("015f6157446481b9a32823c2657c9c46"
"4fe2e6115e96963f1d3c484ce95bff1e",
&key_length);
EXPECT_EQ(32, (int)key_length);
uint8_t* content_key = makeArray("30313233343536373839616263646566",
&key_length);
uint32_t num_keys = 1;
OEMCrypto_KeyObject key_array[1];
OEMCrypto_KeyControl control;
memcpy( control.mVerification, "kctl", 4);
control.mDuration = htonl(60*60*24); // 1 day.
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_GenerateNonce(session, &control.mNonce))
<< "OEMCrypto_GenerateNonce";
control.mControl = htonl(0);
EXPECT_EQ(16, (int)sizeof(control));
AES_KEY aes_key;
AES_set_encrypt_key( content_key, 128, &aes_key);
uint8_t iv[16];
uint8_t enc_key_control[16];
memset( iv, 0, 16);
AES_cbc_encrypt((uint8_t *) &control, enc_key_control, 16, &aes_key,
iv, AES_ENCRYPT);
memset( iv, 0, 16);
key_array[0].key_id = makeArray("00000000000000000000000000000000",
&(key_array[0].key_id_length));
key_array[0].key_data_iv = makeArray("4e793f3bef67bc83f7deacfbf1e9d385"); // given.
key_array[0].key_data = makeArray("1308fb0835bda16782f902f5c49644d5"); // given.
key_array[0].key_control_iv = iv;
key_array[0].key_control = enc_key_control;
// printf("\n--------------------------\n");
// printf(" iv: ");
// for(int i=0; i < 16; i++) printf(" %02x", key_array[0].key_control_iv[i]);
// printf("\n");
// printf(" con: ");
// uint8_t *buffer = (uint8_t *) &control;
// for(int i=0; i < 16; i++) printf(" %02x", buffer[i]);
// printf("\n");
// printf("e con: ");
// for(int i=0; i < 16; i++) printf(" %02x", key_array[0].key_control[i]);
// printf("\n");
// printf("u key: ");
// for(int i=0; i < 16; i++) printf(" %02x", content_key[i]);
// printf("\n");
EXPECT_EQ(OEMCrypto_SUCCESS,
OEMCrypto_LoadKeys(session, message, message_length,
signature, signature_length,
enc_mac_key_iv, enc_mac_key, num_keys, key_array))
<< "OEMCrypto_LoadKeys";
uint8_t* new_mac_key = makeArray("faa85bcdd67395e65566c4b891f8a2f0"
"2ff983dbad9a4cb44518e8235a4dbb5f",
&key_length);
EXPECT_EQ(0, memcmp(ms->mMacKey, new_mac_key, 32))
<< "New Mac key was not decrypted.";
// printf("\n--------------------------\n");
// printf(" mac: ");
// for(int i=0; i < 32; i++) printf(" %02x", ms->mac_key[i]);
// printf("\n");
// printf("new mac: ");
// for(int i=0; i < 32; i++) printf(" %02x", new_mac_key[i]);
// printf("\n");
EXPECT_EQ(1, (int)ms->mKeys.size());
if (ms->mKeys.size() > 0) {
EXPECT_EQ(0, memcmp( ms->mKeys[0].mKeyData, content_key, 16))
<< "Key data was not loaded correctly";
}
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_CloseSession(session))
<< "OEMCrypto_CloseSesion failed.";
}
TEST_F(OEMCryptoTest, MockOEMCrypto_RefreshKeys) {
OEMCrypto_SESSION session;
// session = 0xdeadbeef;
const uint8_t* message = NULL;
uint32_t message_length = 0;
const uint8_t* signature = NULL;
uint32_t signature_length = 0;
uint32_t num_keys = 0;
const OEMCrypto_KeyRefreshObject* key_array = NULL;
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_OpenSession(&session));
EXPECT_EQ(OEMCrypto_SUCCESS,
OEMCrypto_RefreshKeys(session, message, message_length,
signature, signature_length,
num_keys, key_array))
<< "OEMCrypto_RefreshKeys";
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_CloseSession(session))
<< "OEMCrypto_CloseSesion failed.";
}
/***********************************************************************/
/***********************************************************************/
// TODO: This test is just a stub. We will fix it in a future CL.
/***********************************************************************/
/***********************************************************************/
TEST_F(OEMCryptoTest, MockOEMCrypto_FullVideoTest) {
uint8_t *keybox = (uint8_t*)"pointer to some valid keybox data";
uint32_t keyBoxLength = strlen((char*)keybox);
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_InstallKeybox(keybox, keyBoxLength));
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_IsKeyboxValid());
uint8_t deviceID[32] = "0123456789012345";
uint32_t idLength = 16;
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_GetDeviceID(deviceID, &idLength));
for (uint32_t i = 0; i < idLength; i++)
printf("%c", deviceID[i]);
printf("\n");
uint8_t* keyData;
uint32_t keyDataLength = 72;
keyData = (uint8_t*)malloc(keyDataLength); //not really but we will malloc it for the stub work
memset(keyData, 0, keyDataLength);
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_GetKeyData(keyData, &keyDataLength));
for (uint32_t i = 0; i < keyDataLength; i++) {
if ((i % 15) == 0)
printf("\n");
printf("0x%02x ", keyData[i]);
}
printf("\n");
printf("request an EMM\n");
delete keyData;
OEMCrypto_SESSION session;
// session = 0xdeadbeef;
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_OpenSession(&session));
// EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_EnterSecurePlayback());
const uint8_t* emmKey = (const uint8_t*)"0123456789012345";
const uint32_t emmKeyLength = 16;
// EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_SetEntitlementKey(emmKey, emmKeyLength));
const uint8_t* ecm = (const uint8_t*)"01234567890123450123456789012345";
const uint32_t length = 32;
uint32_t flags;
// EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_DeriveControlWord(ecm, length, &flags));
const uint8_t* contentKey = (const uint8_t*)"0123456789012345";
const uint32_t contentKeyLength = 16;
const uint8_t* control = (const uint8_t*)"abcd";
const uint32_t controlLength = 4;
// EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_SetContentKey(session, contentKey, contentKeyLength, control, controlLength));
{
const uint8_t* iv = (const uint8_t*)"0123456789012345";
const uint8_t* input = (const uint8_t*)"some nicely encrypted video data";
const uint32_t inputLength = strlen((char*)input);
uint32_t output_handle = 0xdeadbeef;
uint32_t output_offset = 0;
uint32_t outputLength;
// EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_DecryptVideo(iv, input, inputLength, output_handle, output_offset, &outputLength));
}
{
const uint8_t* iv = (const uint8_t*)"0123456789012345";
const uint8_t* input = (const uint8_t*)"some nicely encrypted audio data";
const uint32_t inputLength = strlen((char*)input);
uint8_t *output;
uint32_t outputLength;
// EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_DecryptAudio(iv, input, inputLength, output, &outputLength));
}
// EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_ExitSecurePlayback());
EXPECT_EQ(OEMCrypto_SUCCESS, OEMCrypto_CloseSession(session))
<< "OEMCrypto_CloseSesion failed.";
}