1500 lines
57 KiB
C
1500 lines
57 KiB
C
/*
|
|
* Copyright 2019 Google LLC. All Rights Reserved. This file and proprietary
|
|
* source code may only be used and distributed under the Widevine Master
|
|
* License Agreement.
|
|
*/
|
|
|
|
/*
|
|
* This code is auto-generated, do not edit
|
|
*/
|
|
#include "dispatcher.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "OEMCryptoCENC.h"
|
|
#include "bump_allocator.h"
|
|
#include "deserializer.h"
|
|
#include "marshaller_base.h"
|
|
#include "serializer.h"
|
|
#include "shared_memory_allocator.h"
|
|
#include "shared_memory_interface.h"
|
|
#include "special_cases.h"
|
|
|
|
void ODK_InitializeDispatcher() {
|
|
SharedMemory_Initialize(1024 * 1024 /* 1MB */);
|
|
}
|
|
|
|
void Init_OEMCrypto_Substring(OEMCrypto_Substring* obj) {
|
|
Init_size_t((size_t*)&obj->offset);
|
|
Init_size_t((size_t*)&obj->length);
|
|
}
|
|
|
|
void Init_OEMCrypto_KeyObject(OEMCrypto_KeyObject* obj) {
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&obj->key_id);
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&obj->key_data_iv);
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&obj->key_data);
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&obj->key_control_iv);
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&obj->key_control);
|
|
}
|
|
|
|
void Init_OEMCrypto_EntitledContentKeyObject(
|
|
OEMCrypto_EntitledContentKeyObject* obj) {
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&obj->entitlement_key_id);
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&obj->content_key_id);
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&obj->content_key_data_iv);
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&obj->content_key_data);
|
|
}
|
|
|
|
void Init_OEMCrypto_KeyRefreshObject(OEMCrypto_KeyRefreshObject* obj) {
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&obj->key_id);
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&obj->key_control_iv);
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&obj->key_control);
|
|
}
|
|
|
|
void Init_OEMCrypto_CENCEncryptPatternDesc(
|
|
OEMCrypto_CENCEncryptPatternDesc* obj) {
|
|
Init_size_t((size_t*)&obj->encrypt);
|
|
Init_size_t((size_t*)&obj->skip);
|
|
Init_size_t((size_t*)&obj->offset);
|
|
}
|
|
|
|
MessageStatus ODK_DispatchMessage(Message* request, Message* response) {
|
|
if (request == NULL || response == NULL) {
|
|
return MESSAGE_STATUS_NULL_POINTER_ERROR;
|
|
}
|
|
MessageStatus message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
message_status = GetStatus(response);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
ClearMessage(response);
|
|
uint32_t api_value;
|
|
ODK_Unpack_uint32_t(request, &api_value);
|
|
BumpAllocator_Reset();
|
|
SharedMemory_Reset();
|
|
ResetMessage(request);
|
|
switch (api_value) {
|
|
case 23: /* OEMCrypto_SecurityLevel */
|
|
{
|
|
ODK_Unpack_SecurityLevel_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
const char* result;
|
|
Init_c_str((char**)&result);
|
|
result = OEMCrypto_SecurityLevel();
|
|
ODK_Pack_SecurityLevel_Response(response, result);
|
|
break;
|
|
}
|
|
case 90: /* OEMCrypto_BuildInformation */
|
|
{
|
|
ODK_Unpack_BuildInformation_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
const char* result;
|
|
Init_c_str((char**)&result);
|
|
result = OEMCrypto_BuildInformation();
|
|
ODK_Pack_BuildInformation_Response(response, result);
|
|
break;
|
|
}
|
|
case 84: /* OEMCrypto_SetSandbox */
|
|
{
|
|
size_t sandbox_id_length;
|
|
Init_size_t((size_t*)&sandbox_id_length);
|
|
uint8_t* sandbox_id;
|
|
InitPointer((uint8_t**)&sandbox_id);
|
|
ODK_Unpack_SetSandbox_Request(request, &sandbox_id, &sandbox_id_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_SetSandbox(sandbox_id, sandbox_id_length);
|
|
ODK_Pack_SetSandbox_Response(response, result);
|
|
break;
|
|
}
|
|
case 1: /* OEMCrypto_Initialize */
|
|
{
|
|
ODK_Unpack_Initialize_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_Initialize();
|
|
ODK_Pack_Initialize_Response(response, result);
|
|
break;
|
|
}
|
|
case 2: /* OEMCrypto_Terminate */
|
|
{
|
|
ODK_Unpack_Terminate_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_Terminate();
|
|
ODK_Pack_Terminate_Response(response, result);
|
|
break;
|
|
}
|
|
case 9: /* OEMCrypto_OpenSession */
|
|
{
|
|
OEMCrypto_SESSION* session;
|
|
InitPointer((uint8_t**)&session);
|
|
ODK_Unpack_OpenSession_Request(request, &session);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_OpenSession(session);
|
|
ODK_Pack_OpenSession_Response(response, result, session);
|
|
break;
|
|
}
|
|
case 10: /* OEMCrypto_CloseSession */
|
|
{
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
ODK_Unpack_CloseSession_Request(request, &session);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_CloseSession(session);
|
|
ODK_Pack_CloseSession_Response(response, result);
|
|
break;
|
|
}
|
|
case 12: /* OEMCrypto_GenerateDerivedKeys */
|
|
{
|
|
uint32_t mac_key_context_length;
|
|
Init_uint32_t((uint32_t*)&mac_key_context_length);
|
|
uint32_t enc_key_context_length;
|
|
Init_uint32_t((uint32_t*)&enc_key_context_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* mac_key_context;
|
|
InitPointer((uint8_t**)&mac_key_context);
|
|
SharedMemory* enc_key_context;
|
|
InitPointer((uint8_t**)&enc_key_context);
|
|
ODK_Unpack_GenerateDerivedKeys_Request(
|
|
request, &session, &mac_key_context, &mac_key_context_length,
|
|
&enc_key_context, &enc_key_context_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GenerateDerivedKeys(
|
|
session, mac_key_context, mac_key_context_length, enc_key_context,
|
|
enc_key_context_length);
|
|
ODK_Pack_GenerateDerivedKeys_Response(response, result);
|
|
break;
|
|
}
|
|
case 21: /* OEMCrypto_DeriveKeysFromSessionKey */
|
|
{
|
|
size_t enc_session_key_length;
|
|
Init_size_t((size_t*)&enc_session_key_length);
|
|
size_t mac_key_context_length;
|
|
Init_size_t((size_t*)&mac_key_context_length);
|
|
size_t enc_key_context_length;
|
|
Init_size_t((size_t*)&enc_key_context_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint8_t* enc_session_key;
|
|
InitPointer((uint8_t**)&enc_session_key);
|
|
SharedMemory* mac_key_context;
|
|
InitPointer((uint8_t**)&mac_key_context);
|
|
SharedMemory* enc_key_context;
|
|
InitPointer((uint8_t**)&enc_key_context);
|
|
ODK_Unpack_DeriveKeysFromSessionKey_Request(
|
|
request, &session, &enc_session_key, &enc_session_key_length,
|
|
&mac_key_context, &mac_key_context_length, &enc_key_context,
|
|
&enc_key_context_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_DeriveKeysFromSessionKey(
|
|
session, enc_session_key, enc_session_key_length, mac_key_context,
|
|
mac_key_context_length, enc_key_context, enc_key_context_length);
|
|
ODK_Pack_DeriveKeysFromSessionKey_Response(response, result);
|
|
break;
|
|
}
|
|
case 14: /* OEMCrypto_GenerateNonce */
|
|
{
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint32_t* nonce;
|
|
InitPointer((uint8_t**)&nonce);
|
|
ODK_Unpack_GenerateNonce_Request(request, &session, &nonce);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GenerateNonce(session, nonce);
|
|
ODK_Pack_GenerateNonce_Response(response, result, nonce);
|
|
break;
|
|
}
|
|
case 13: /* OEMCrypto_GenerateSignature */
|
|
{
|
|
size_t message_length;
|
|
Init_size_t((size_t*)&message_length);
|
|
size_t* signature_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(signature_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* message;
|
|
InitPointer((uint8_t**)&message);
|
|
uint8_t* signature;
|
|
InitPointer((uint8_t**)&signature);
|
|
ODK_Unpack_GenerateSignature_Request(request, &session, &message,
|
|
&message_length, &signature,
|
|
&signature_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GenerateSignature(session, message, message_length,
|
|
signature, signature_length);
|
|
ODK_Pack_GenerateSignature_Response(response, result, signature,
|
|
signature_length);
|
|
break;
|
|
}
|
|
case 55: /* OEMCrypto_LoadSRM */
|
|
{
|
|
size_t buffer_length;
|
|
Init_size_t((size_t*)&buffer_length);
|
|
uint8_t* buffer;
|
|
InitPointer((uint8_t**)&buffer);
|
|
ODK_Unpack_LoadSRM_Request(request, &buffer, &buffer_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_LoadSRM(buffer, buffer_length);
|
|
ODK_Pack_LoadSRM_Response(response, result);
|
|
break;
|
|
}
|
|
case 83: /* OEMCrypto_LoadKeys */
|
|
{
|
|
size_t message_length;
|
|
Init_size_t((size_t*)&message_length);
|
|
size_t signature_length;
|
|
Init_size_t((size_t*)&signature_length);
|
|
size_t key_array_length;
|
|
Init_size_t((size_t*)&key_array_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* message;
|
|
InitPointer((uint8_t**)&message);
|
|
SharedMemory* signature;
|
|
InitPointer((uint8_t**)&signature);
|
|
OEMCrypto_Substring enc_mac_keys_iv;
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&enc_mac_keys_iv);
|
|
OEMCrypto_Substring enc_mac_keys;
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&enc_mac_keys);
|
|
OEMCrypto_KeyObject* key_array;
|
|
InitPointer((uint8_t**)&key_array);
|
|
OEMCrypto_Substring pst;
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&pst);
|
|
OEMCrypto_Substring srm_restriction_data;
|
|
Init_OEMCrypto_Substring((OEMCrypto_Substring*)&srm_restriction_data);
|
|
OEMCrypto_LicenseType license_type;
|
|
Init_uint32_t((uint32_t*)&license_type);
|
|
ODK_Unpack_LoadKeys_Request(
|
|
request, &session, &message, &message_length, &signature,
|
|
&signature_length, &enc_mac_keys_iv, &enc_mac_keys, &key_array_length,
|
|
&key_array, &pst, &srm_restriction_data, &license_type);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_LoadKeys(session, message, message_length, signature,
|
|
signature_length, enc_mac_keys_iv,
|
|
enc_mac_keys, key_array_length, key_array,
|
|
pst, srm_restriction_data, license_type);
|
|
ODK_Pack_LoadKeys_Response(response, result);
|
|
break;
|
|
}
|
|
case 92: /* OEMCrypto_LoadEntitledContentKeys */
|
|
{
|
|
size_t message_length;
|
|
Init_size_t((size_t*)&message_length);
|
|
size_t key_array_length;
|
|
Init_size_t((size_t*)&key_array_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* message;
|
|
InitPointer((uint8_t**)&message);
|
|
OEMCrypto_EntitledContentKeyObject* key_array;
|
|
InitPointer((uint8_t**)&key_array);
|
|
ODK_Unpack_LoadEntitledContentKeys_Request(request, &session, &message,
|
|
&message_length,
|
|
&key_array_length, &key_array);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_LoadEntitledContentKeys(
|
|
session, message, message_length, key_array_length, key_array);
|
|
ODK_Pack_LoadEntitledContentKeys_Response(response, result);
|
|
break;
|
|
}
|
|
case 91: /* OEMCrypto_RefreshKeys */
|
|
{
|
|
size_t message_length;
|
|
Init_size_t((size_t*)&message_length);
|
|
size_t signature_length;
|
|
Init_size_t((size_t*)&signature_length);
|
|
size_t key_array_length;
|
|
Init_size_t((size_t*)&key_array_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* message;
|
|
InitPointer((uint8_t**)&message);
|
|
SharedMemory* signature;
|
|
InitPointer((uint8_t**)&signature);
|
|
OEMCrypto_KeyRefreshObject* key_array;
|
|
InitPointer((uint8_t**)&key_array);
|
|
ODK_Unpack_RefreshKeys_Request(
|
|
request, &session, &message, &message_length, &signature,
|
|
&signature_length, &key_array_length, &key_array);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result =
|
|
OEMCrypto_RefreshKeys(session, message, message_length, signature,
|
|
signature_length, key_array_length, key_array);
|
|
ODK_Pack_RefreshKeys_Response(response, result);
|
|
break;
|
|
}
|
|
case 41: /* OEMCrypto_QueryKeyControl */
|
|
{
|
|
size_t content_key_id_length;
|
|
Init_size_t((size_t*)&content_key_id_length);
|
|
size_t* key_control_block_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(key_control_block_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint8_t* content_key_id;
|
|
InitPointer((uint8_t**)&content_key_id);
|
|
uint8_t* key_control_block;
|
|
InitPointer((uint8_t**)&key_control_block);
|
|
ODK_Unpack_QueryKeyControl_Request(
|
|
request, &session, &content_key_id, &content_key_id_length,
|
|
&key_control_block, &key_control_block_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_QueryKeyControl(
|
|
session, content_key_id, content_key_id_length, key_control_block,
|
|
key_control_block_length);
|
|
ODK_Pack_QueryKeyControl_Response(response, result, key_control_block,
|
|
key_control_block_length);
|
|
break;
|
|
}
|
|
case 81: /* OEMCrypto_SelectKey */
|
|
{
|
|
size_t content_key_id_length;
|
|
Init_size_t((size_t*)&content_key_id_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint8_t* content_key_id;
|
|
InitPointer((uint8_t**)&content_key_id);
|
|
OEMCryptoCipherMode cipher_mode;
|
|
Init_uint32_t((uint32_t*)&cipher_mode);
|
|
ODK_Unpack_SelectKey_Request(request, &session, &content_key_id,
|
|
&content_key_id_length, &cipher_mode);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_SelectKey(session, content_key_id,
|
|
content_key_id_length, cipher_mode);
|
|
ODK_Pack_SelectKey_Response(response, result);
|
|
break;
|
|
}
|
|
case 48: /* OEMCrypto_DecryptCENC */
|
|
{
|
|
size_t data_addr_length;
|
|
Init_size_t((size_t*)&data_addr_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* data_addr;
|
|
InitPointer((uint8_t**)&data_addr);
|
|
bool is_encrypted;
|
|
Init_bool((bool*)&is_encrypted);
|
|
uint8_t iv[16];
|
|
InitMemory(&iv[0], 16);
|
|
size_t block_offset;
|
|
Init_size_t((size_t*)&block_offset);
|
|
OEMCrypto_DestBufferDesc* out_buffer =
|
|
(OEMCrypto_DestBufferDesc*)VarAlloc(sizeof(OEMCrypto_DestBufferDesc));
|
|
Init_OEMCrypto_DestBufferDesc(out_buffer);
|
|
OEMCrypto_CENCEncryptPatternDesc* pattern =
|
|
(OEMCrypto_CENCEncryptPatternDesc*)VarAlloc(
|
|
sizeof(OEMCrypto_CENCEncryptPatternDesc));
|
|
Init_OEMCrypto_CENCEncryptPatternDesc(
|
|
(OEMCrypto_CENCEncryptPatternDesc*)pattern);
|
|
uint8_t subsample_flags;
|
|
Init_uint8_t((uint8_t*)&subsample_flags);
|
|
ODK_Unpack_DecryptCENC_Request(
|
|
request, &session, &data_addr, &data_addr_length, &is_encrypted,
|
|
&iv[0], &block_offset, &out_buffer, &pattern, &subsample_flags);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_DecryptCENC(session, data_addr, data_addr_length,
|
|
is_encrypted, iv, block_offset, out_buffer,
|
|
pattern, subsample_flags);
|
|
ODK_Pack_DecryptCENC_Response(response, result, out_buffer);
|
|
break;
|
|
}
|
|
case 93: /* OEMCrypto_CopyBuffer */
|
|
{
|
|
size_t data_addr_length;
|
|
Init_size_t((size_t*)&data_addr_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* data_addr;
|
|
InitPointer((uint8_t**)&data_addr);
|
|
OEMCrypto_DestBufferDesc* out_buffer =
|
|
(OEMCrypto_DestBufferDesc*)VarAlloc(sizeof(OEMCrypto_DestBufferDesc));
|
|
Init_OEMCrypto_DestBufferDesc(out_buffer);
|
|
uint8_t subsample_flags;
|
|
Init_uint8_t((uint8_t*)&subsample_flags);
|
|
ODK_Unpack_CopyBuffer_Request(request, &session, &data_addr,
|
|
&data_addr_length, &out_buffer,
|
|
&subsample_flags);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_CopyBuffer(session, data_addr, data_addr_length,
|
|
out_buffer, subsample_flags);
|
|
ODK_Pack_CopyBuffer_Response(response, result, out_buffer);
|
|
break;
|
|
}
|
|
case 24: /* OEMCrypto_Generic_Encrypt */
|
|
{
|
|
size_t in_buffer_length;
|
|
Init_size_t((size_t*)&in_buffer_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* in_buffer;
|
|
InitPointer((uint8_t**)&in_buffer);
|
|
uint8_t iv[16];
|
|
InitMemory(&iv[0], 16);
|
|
OEMCrypto_Algorithm algorithm;
|
|
Init_uint32_t((uint32_t*)&algorithm);
|
|
uint8_t* out_buffer;
|
|
InitPointer((uint8_t**)&out_buffer);
|
|
ODK_Unpack_Generic_Encrypt_Request(request, &session, &in_buffer,
|
|
&in_buffer_length, &iv[0], &algorithm,
|
|
&out_buffer);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_Generic_Encrypt(session, in_buffer, in_buffer_length,
|
|
iv, algorithm, out_buffer);
|
|
ODK_Pack_Generic_Encrypt_Response(response, result, in_buffer_length,
|
|
out_buffer);
|
|
break;
|
|
}
|
|
case 25: /* OEMCrypto_Generic_Decrypt */
|
|
{
|
|
size_t in_buffer_length;
|
|
Init_size_t((size_t*)&in_buffer_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* in_buffer;
|
|
InitPointer((uint8_t**)&in_buffer);
|
|
uint8_t iv[16];
|
|
InitMemory(&iv[0], 16);
|
|
OEMCrypto_Algorithm algorithm;
|
|
Init_uint32_t((uint32_t*)&algorithm);
|
|
uint8_t* out_buffer;
|
|
InitPointer((uint8_t**)&out_buffer);
|
|
ODK_Unpack_Generic_Decrypt_Request(request, &session, &in_buffer,
|
|
&in_buffer_length, &iv[0], &algorithm,
|
|
&out_buffer);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_Generic_Decrypt(session, in_buffer, in_buffer_length,
|
|
iv, algorithm, out_buffer);
|
|
ODK_Pack_Generic_Decrypt_Response(response, result, in_buffer_length,
|
|
out_buffer);
|
|
break;
|
|
}
|
|
case 26: /* OEMCrypto_Generic_Sign */
|
|
{
|
|
size_t buffer_length;
|
|
Init_size_t((size_t*)&buffer_length);
|
|
size_t* signature_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(signature_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* buffer;
|
|
InitPointer((uint8_t**)&buffer);
|
|
OEMCrypto_Algorithm algorithm;
|
|
Init_uint32_t((uint32_t*)&algorithm);
|
|
uint8_t* signature;
|
|
InitPointer((uint8_t**)&signature);
|
|
ODK_Unpack_Generic_Sign_Request(request, &session, &buffer,
|
|
&buffer_length, &algorithm, &signature,
|
|
&signature_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_Generic_Sign(session, buffer, buffer_length, algorithm,
|
|
signature, signature_length);
|
|
ODK_Pack_Generic_Sign_Response(response, result, signature,
|
|
signature_length);
|
|
break;
|
|
}
|
|
case 27: /* OEMCrypto_Generic_Verify */
|
|
{
|
|
size_t buffer_length;
|
|
Init_size_t((size_t*)&buffer_length);
|
|
size_t signature_length;
|
|
Init_size_t((size_t*)&signature_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* buffer;
|
|
InitPointer((uint8_t**)&buffer);
|
|
OEMCrypto_Algorithm algorithm;
|
|
Init_uint32_t((uint32_t*)&algorithm);
|
|
SharedMemory* signature;
|
|
InitPointer((uint8_t**)&signature);
|
|
ODK_Unpack_Generic_Verify_Request(request, &session, &buffer,
|
|
&buffer_length, &algorithm, &signature,
|
|
&signature_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_Generic_Verify(session, buffer, buffer_length,
|
|
algorithm, signature, signature_length);
|
|
ODK_Pack_Generic_Verify_Response(response, result);
|
|
break;
|
|
}
|
|
case 30: /* OEMCrypto_UpdateUsageTable */
|
|
{
|
|
ODK_Unpack_UpdateUsageTable_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_UpdateUsageTable();
|
|
ODK_Pack_UpdateUsageTable_Response(response, result);
|
|
break;
|
|
}
|
|
case 8: /* OEMCrypto_WrapKeyboxOrOEMCert */
|
|
{
|
|
size_t rotLength;
|
|
Init_size_t((size_t*)&rotLength);
|
|
size_t* wrappedRotLength;
|
|
InitPointer((uint8_t**)&wrappedRotLength);
|
|
size_t transportKeyLength;
|
|
Init_size_t((size_t*)&transportKeyLength);
|
|
uint8_t* rot;
|
|
InitPointer((uint8_t**)&rot);
|
|
uint8_t* wrappedRot;
|
|
InitPointer((uint8_t**)&wrappedRot);
|
|
uint8_t* transportKey;
|
|
InitPointer((uint8_t**)&transportKey);
|
|
ODK_Unpack_WrapKeyboxOrOEMCert_Request(
|
|
request, &rot, &rotLength, &wrappedRot, &wrappedRotLength,
|
|
&transportKey, &transportKeyLength);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_WrapKeyboxOrOEMCert(rot, rotLength, wrappedRot,
|
|
wrappedRotLength, transportKey,
|
|
transportKeyLength);
|
|
ODK_Pack_WrapKeyboxOrOEMCert_Response(response, result, wrappedRot,
|
|
wrappedRotLength);
|
|
break;
|
|
}
|
|
case 3: /* OEMCrypto_InstallKeyboxOrOEMCert */
|
|
{
|
|
size_t rotLength;
|
|
Init_size_t((size_t*)&rotLength);
|
|
uint8_t* rot;
|
|
InitPointer((uint8_t**)&rot);
|
|
ODK_Unpack_InstallKeyboxOrOEMCert_Request(request, &rot, &rotLength);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_InstallKeyboxOrOEMCert(rot, rotLength);
|
|
ODK_Pack_InstallKeyboxOrOEMCert_Response(response, result);
|
|
break;
|
|
}
|
|
case 49: /* OEMCrypto_GetProvisioningMethod */
|
|
{
|
|
ODK_Unpack_GetProvisioningMethod_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCrypto_ProvisioningMethod result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GetProvisioningMethod();
|
|
ODK_Pack_GetProvisioningMethod_Response(response, result);
|
|
break;
|
|
}
|
|
case 5: /* OEMCrypto_IsKeyboxOrOEMCertValid */
|
|
{
|
|
ODK_Unpack_IsKeyboxOrOEMCertValid_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_IsKeyboxOrOEMCertValid();
|
|
ODK_Pack_IsKeyboxOrOEMCertValid_Response(response, result);
|
|
break;
|
|
}
|
|
case 7: /* OEMCrypto_GetDeviceID */
|
|
{
|
|
size_t* device_id_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(device_id_length);
|
|
uint8_t* device_id;
|
|
InitPointer((uint8_t**)&device_id);
|
|
ODK_Unpack_GetDeviceID_Request(request, &device_id, &device_id_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GetDeviceID(device_id, device_id_length);
|
|
ODK_Pack_GetDeviceID_Response(response, result, device_id,
|
|
device_id_length);
|
|
break;
|
|
}
|
|
case 4: /* OEMCrypto_GetKeyData */
|
|
{
|
|
size_t* keyDataLength = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(keyDataLength);
|
|
uint8_t* keyData;
|
|
InitPointer((uint8_t**)&keyData);
|
|
ODK_Unpack_GetKeyData_Request(request, &keyData, &keyDataLength);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GetKeyData(keyData, keyDataLength);
|
|
ODK_Pack_GetKeyData_Response(response, result, keyData, keyDataLength);
|
|
break;
|
|
}
|
|
case 78: /* OEMCrypto_LoadTestKeybox */
|
|
{
|
|
size_t buffer_length;
|
|
Init_size_t((size_t*)&buffer_length);
|
|
uint8_t* buffer;
|
|
InitPointer((uint8_t**)&buffer);
|
|
ODK_Unpack_LoadTestKeybox_Request(request, &buffer, &buffer_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_LoadTestKeybox(buffer, buffer_length);
|
|
ODK_Pack_LoadTestKeybox_Response(response, result);
|
|
break;
|
|
}
|
|
case 50: /* OEMCrypto_GetOEMPublicCertificate */
|
|
{
|
|
size_t* public_cert_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(public_cert_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint8_t* public_cert;
|
|
InitPointer((uint8_t**)&public_cert);
|
|
ODK_Unpack_GetOEMPublicCertificate_Request(
|
|
request, &session, &public_cert, &public_cert_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GetOEMPublicCertificate(session, public_cert,
|
|
public_cert_length);
|
|
ODK_Pack_GetOEMPublicCertificate_Response(response, result, public_cert,
|
|
public_cert_length);
|
|
break;
|
|
}
|
|
case 6: /* OEMCrypto_GetRandom */
|
|
{
|
|
size_t random_data_length;
|
|
Init_size_t((size_t*)&random_data_length);
|
|
uint8_t* random_data;
|
|
InitPointer((uint8_t**)&random_data);
|
|
ODK_Unpack_GetRandom_Request(request, &random_data, &random_data_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GetRandom(random_data, random_data_length);
|
|
ODK_Pack_GetRandom_Response(response, result, random_data,
|
|
random_data_length);
|
|
break;
|
|
}
|
|
case 22: /* OEMCrypto_APIVersion */
|
|
{
|
|
ODK_Unpack_APIVersion_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
uint32_t result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_APIVersion();
|
|
ODK_Pack_APIVersion_Response(response, result);
|
|
break;
|
|
}
|
|
case 46: /* OEMCrypto_Security_Patch_Level */
|
|
{
|
|
ODK_Unpack_Security_Patch_Level_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
uint8_t result;
|
|
Init_uint8_t((uint8_t*)&result);
|
|
result = OEMCrypto_Security_Patch_Level();
|
|
ODK_Pack_Security_Patch_Level_Response(response, result);
|
|
break;
|
|
}
|
|
case 44: /* OEMCrypto_GetHDCPCapability */
|
|
{
|
|
OEMCrypto_HDCP_Capability* current;
|
|
InitPointer((uint8_t**)¤t);
|
|
OEMCrypto_HDCP_Capability* maximum;
|
|
InitPointer((uint8_t**)&maximum);
|
|
ODK_Unpack_GetHDCPCapability_Request(request, ¤t, &maximum);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GetHDCPCapability(current, maximum);
|
|
ODK_Pack_GetHDCPCapability_Response(response, result, current, maximum);
|
|
break;
|
|
}
|
|
case 29: /* OEMCrypto_SupportsUsageTable */
|
|
{
|
|
ODK_Unpack_SupportsUsageTable_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
bool result;
|
|
Init_bool((bool*)&result);
|
|
result = OEMCrypto_SupportsUsageTable();
|
|
ODK_Pack_SupportsUsageTable_Response(response, result);
|
|
break;
|
|
}
|
|
case 39: /* OEMCrypto_IsAntiRollbackHwPresent */
|
|
{
|
|
ODK_Unpack_IsAntiRollbackHwPresent_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
bool result;
|
|
Init_bool((bool*)&result);
|
|
result = OEMCrypto_IsAntiRollbackHwPresent();
|
|
ODK_Pack_IsAntiRollbackHwPresent_Response(response, result);
|
|
break;
|
|
}
|
|
case 38: /* OEMCrypto_GetNumberOfOpenSessions */
|
|
{
|
|
size_t* count;
|
|
InitPointer((uint8_t**)&count);
|
|
ODK_Unpack_GetNumberOfOpenSessions_Request(request, &count);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GetNumberOfOpenSessions(count);
|
|
ODK_Pack_GetNumberOfOpenSessions_Response(response, result, count);
|
|
break;
|
|
}
|
|
case 37: /* OEMCrypto_GetMaxNumberOfSessions */
|
|
{
|
|
size_t* max;
|
|
InitPointer((uint8_t**)&max);
|
|
ODK_Unpack_GetMaxNumberOfSessions_Request(request, &max);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GetMaxNumberOfSessions(max);
|
|
ODK_Pack_GetMaxNumberOfSessions_Response(response, result, max);
|
|
break;
|
|
}
|
|
case 52: /* OEMCrypto_SupportedCertificates */
|
|
{
|
|
ODK_Unpack_SupportedCertificates_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
uint32_t result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_SupportedCertificates();
|
|
ODK_Pack_SupportedCertificates_Response(response, result);
|
|
break;
|
|
}
|
|
case 53: /* OEMCrypto_IsSRMUpdateSupported */
|
|
{
|
|
ODK_Unpack_IsSRMUpdateSupported_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
bool result;
|
|
Init_bool((bool*)&result);
|
|
result = OEMCrypto_IsSRMUpdateSupported();
|
|
ODK_Pack_IsSRMUpdateSupported_Response(response, result);
|
|
break;
|
|
}
|
|
case 54: /* OEMCrypto_GetCurrentSRMVersion */
|
|
{
|
|
uint16_t* version;
|
|
InitPointer((uint8_t**)&version);
|
|
ODK_Unpack_GetCurrentSRMVersion_Request(request, &version);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GetCurrentSRMVersion(version);
|
|
ODK_Pack_GetCurrentSRMVersion_Response(response, result, version);
|
|
break;
|
|
}
|
|
case 71: /* OEMCrypto_GetAnalogOutputFlags */
|
|
{
|
|
ODK_Unpack_GetAnalogOutputFlags_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
uint32_t result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GetAnalogOutputFlags();
|
|
ODK_Pack_GetAnalogOutputFlags_Response(response, result);
|
|
break;
|
|
}
|
|
case 85: /* OEMCrypto_ResourceRatingTier */
|
|
{
|
|
ODK_Unpack_ResourceRatingTier_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
uint32_t result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_ResourceRatingTier();
|
|
ODK_Pack_ResourceRatingTier_Response(response, result);
|
|
break;
|
|
}
|
|
case 51: /* OEMCrypto_RewrapDeviceRSAKey30 */
|
|
{
|
|
size_t encrypted_message_key_length;
|
|
Init_size_t((size_t*)&encrypted_message_key_length);
|
|
size_t enc_rsa_key_length;
|
|
Init_size_t((size_t*)&enc_rsa_key_length);
|
|
size_t* wrapped_rsa_key_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(wrapped_rsa_key_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint32_t* unaligned_nonce = (uint32_t*)VarAlloc(sizeof(uint32_t));
|
|
Init_uint32_t((uint32_t*)unaligned_nonce);
|
|
SharedMemory* encrypted_message_key;
|
|
InitPointer((uint8_t**)&encrypted_message_key);
|
|
SharedMemory* enc_rsa_key;
|
|
InitPointer((uint8_t**)&enc_rsa_key);
|
|
uint8_t* enc_rsa_key_iv = (uint8_t*)VarAlloc(sizeof(uint8_t));
|
|
Init_uint8_t((uint8_t*)enc_rsa_key_iv);
|
|
uint8_t* wrapped_rsa_key;
|
|
InitPointer((uint8_t**)&wrapped_rsa_key);
|
|
ODK_Unpack_RewrapDeviceRSAKey30_Request(
|
|
request, &session, &unaligned_nonce, &encrypted_message_key,
|
|
&encrypted_message_key_length, &enc_rsa_key, &enc_rsa_key_length,
|
|
&enc_rsa_key_iv, &wrapped_rsa_key, &wrapped_rsa_key_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_RewrapDeviceRSAKey30(
|
|
session, unaligned_nonce, encrypted_message_key,
|
|
encrypted_message_key_length, enc_rsa_key, enc_rsa_key_length,
|
|
enc_rsa_key_iv, wrapped_rsa_key, wrapped_rsa_key_length);
|
|
ODK_Pack_RewrapDeviceRSAKey30_Response(response, result, wrapped_rsa_key,
|
|
wrapped_rsa_key_length);
|
|
break;
|
|
}
|
|
case 18: /* OEMCrypto_RewrapDeviceRSAKey */
|
|
{
|
|
size_t message_length;
|
|
Init_size_t((size_t*)&message_length);
|
|
size_t signature_length;
|
|
Init_size_t((size_t*)&signature_length);
|
|
size_t enc_rsa_key_length;
|
|
Init_size_t((size_t*)&enc_rsa_key_length);
|
|
size_t* wrapped_rsa_key_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(wrapped_rsa_key_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* message;
|
|
InitPointer((uint8_t**)&message);
|
|
SharedMemory* signature;
|
|
InitPointer((uint8_t**)&signature);
|
|
uint32_t* unaligned_nonce = (uint32_t*)VarAlloc(sizeof(uint32_t));
|
|
Init_uint32_t((uint32_t*)unaligned_nonce);
|
|
uint8_t* enc_rsa_key;
|
|
InitPointer((uint8_t**)&enc_rsa_key);
|
|
uint8_t* enc_rsa_key_iv = (uint8_t*)VarAlloc(sizeof(uint8_t));
|
|
Init_uint8_t((uint8_t*)enc_rsa_key_iv);
|
|
uint8_t* wrapped_rsa_key;
|
|
InitPointer((uint8_t**)&wrapped_rsa_key);
|
|
ODK_Unpack_RewrapDeviceRSAKey_Request(
|
|
request, &session, &message, &message_length, &signature,
|
|
&signature_length, &unaligned_nonce, &enc_rsa_key,
|
|
&enc_rsa_key_length, &enc_rsa_key_iv, &wrapped_rsa_key,
|
|
&wrapped_rsa_key_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_RewrapDeviceRSAKey(
|
|
session, message, message_length, signature, signature_length,
|
|
unaligned_nonce, enc_rsa_key, enc_rsa_key_length, enc_rsa_key_iv,
|
|
wrapped_rsa_key, wrapped_rsa_key_length);
|
|
ODK_Pack_RewrapDeviceRSAKey_Response(response, result, wrapped_rsa_key,
|
|
wrapped_rsa_key_length);
|
|
break;
|
|
}
|
|
case 19: /* OEMCrypto_LoadDeviceRSAKey */
|
|
{
|
|
size_t wrapped_rsa_key_length;
|
|
Init_size_t((size_t*)&wrapped_rsa_key_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* wrapped_rsa_key;
|
|
InitPointer((uint8_t**)&wrapped_rsa_key);
|
|
ODK_Unpack_LoadDeviceRSAKey_Request(request, &session, &wrapped_rsa_key,
|
|
&wrapped_rsa_key_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_LoadDeviceRSAKey(session, wrapped_rsa_key,
|
|
wrapped_rsa_key_length);
|
|
ODK_Pack_LoadDeviceRSAKey_Response(response, result);
|
|
break;
|
|
}
|
|
case 45: /* OEMCrypto_LoadTestRSAKey */
|
|
{
|
|
ODK_Unpack_LoadTestRSAKey_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_LoadTestRSAKey();
|
|
ODK_Pack_LoadTestRSAKey_Response(response, result);
|
|
break;
|
|
}
|
|
case 36: /* OEMCrypto_GenerateRSASignature */
|
|
{
|
|
size_t message_length;
|
|
Init_size_t((size_t*)&message_length);
|
|
size_t* signature_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(signature_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* message;
|
|
InitPointer((uint8_t**)&message);
|
|
uint8_t* signature;
|
|
InitPointer((uint8_t**)&signature);
|
|
RSA_Padding_Scheme padding_scheme;
|
|
Init_uint8_t((uint8_t*)&padding_scheme);
|
|
ODK_Unpack_GenerateRSASignature_Request(
|
|
request, &session, &message, &message_length, &signature,
|
|
&signature_length, &padding_scheme);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GenerateRSASignature(session, message, message_length,
|
|
signature, signature_length,
|
|
padding_scheme);
|
|
ODK_Pack_GenerateRSASignature_Response(response, result, signature,
|
|
signature_length);
|
|
break;
|
|
}
|
|
case 61: /* OEMCrypto_CreateUsageTableHeader */
|
|
{
|
|
size_t* header_buffer_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(header_buffer_length);
|
|
uint8_t* header_buffer;
|
|
InitPointer((uint8_t**)&header_buffer);
|
|
ODK_Unpack_CreateUsageTableHeader_Request(request, &header_buffer,
|
|
&header_buffer_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result =
|
|
OEMCrypto_CreateUsageTableHeader(header_buffer, header_buffer_length);
|
|
ODK_Pack_CreateUsageTableHeader_Response(response, result, header_buffer,
|
|
header_buffer_length);
|
|
break;
|
|
}
|
|
case 62: /* OEMCrypto_LoadUsageTableHeader */
|
|
{
|
|
size_t buffer_length;
|
|
Init_size_t((size_t*)&buffer_length);
|
|
uint8_t* buffer;
|
|
InitPointer((uint8_t**)&buffer);
|
|
ODK_Unpack_LoadUsageTableHeader_Request(request, &buffer, &buffer_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_LoadUsageTableHeader(buffer, buffer_length);
|
|
ODK_Pack_LoadUsageTableHeader_Response(response, result);
|
|
break;
|
|
}
|
|
case 63: /* OEMCrypto_CreateNewUsageEntry */
|
|
{
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint32_t* usage_entry_number;
|
|
InitPointer((uint8_t**)&usage_entry_number);
|
|
ODK_Unpack_CreateNewUsageEntry_Request(request, &session,
|
|
&usage_entry_number);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_CreateNewUsageEntry(session, usage_entry_number);
|
|
ODK_Pack_CreateNewUsageEntry_Response(response, result,
|
|
usage_entry_number);
|
|
break;
|
|
}
|
|
case 64: /* OEMCrypto_LoadUsageEntry */
|
|
{
|
|
size_t buffer_length;
|
|
Init_size_t((size_t*)&buffer_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint32_t usage_entry_number;
|
|
Init_uint32_t((uint32_t*)&usage_entry_number);
|
|
uint8_t* buffer;
|
|
InitPointer((uint8_t**)&buffer);
|
|
ODK_Unpack_LoadUsageEntry_Request(request, &session, &usage_entry_number,
|
|
&buffer, &buffer_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_LoadUsageEntry(session, usage_entry_number, buffer,
|
|
buffer_length);
|
|
ODK_Pack_LoadUsageEntry_Response(response, result);
|
|
break;
|
|
}
|
|
case 65: /* OEMCrypto_UpdateUsageEntry */
|
|
{
|
|
size_t* header_buffer_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(header_buffer_length);
|
|
size_t* entry_buffer_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(entry_buffer_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
SharedMemory* header_buffer;
|
|
InitPointer((uint8_t**)&header_buffer);
|
|
SharedMemory* entry_buffer;
|
|
InitPointer((uint8_t**)&entry_buffer);
|
|
ODK_Unpack_UpdateUsageEntry_Request(request, &session, &header_buffer,
|
|
&header_buffer_length, &entry_buffer,
|
|
&entry_buffer_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_UpdateUsageEntry(session, header_buffer,
|
|
header_buffer_length, entry_buffer,
|
|
entry_buffer_length);
|
|
ODK_Pack_UpdateUsageEntry_Response(
|
|
response, result, SharedMemory_GetAddress(0), header_buffer_length,
|
|
SharedMemory_GetAddress(1), entry_buffer_length);
|
|
break;
|
|
}
|
|
case 66: /* OEMCrypto_DeactivateUsageEntry */
|
|
{
|
|
size_t pst_length;
|
|
Init_size_t((size_t*)&pst_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint8_t* pst;
|
|
InitPointer((uint8_t**)&pst);
|
|
ODK_Unpack_DeactivateUsageEntry_Request(request, &session, &pst,
|
|
&pst_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_DeactivateUsageEntry(session, pst, pst_length);
|
|
ODK_Pack_DeactivateUsageEntry_Response(response, result);
|
|
break;
|
|
}
|
|
case 32: /* OEMCrypto_ReportUsage */
|
|
{
|
|
size_t pst_length;
|
|
Init_size_t((size_t*)&pst_length);
|
|
size_t* buffer_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(buffer_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint8_t* pst;
|
|
InitPointer((uint8_t**)&pst);
|
|
uint8_t* buffer;
|
|
InitPointer((uint8_t**)&buffer);
|
|
ODK_Unpack_ReportUsage_Request(request, &session, &pst, &pst_length,
|
|
&buffer, &buffer_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_ReportUsage(session, pst, pst_length, buffer,
|
|
buffer_length);
|
|
ODK_Pack_ReportUsage_Response(response, result, buffer, buffer_length);
|
|
break;
|
|
}
|
|
case 33: /* OEMCrypto_DeleteUsageEntry */
|
|
{
|
|
size_t pst_length;
|
|
Init_size_t((size_t*)&pst_length);
|
|
size_t message_length;
|
|
Init_size_t((size_t*)&message_length);
|
|
size_t signature_length;
|
|
Init_size_t((size_t*)&signature_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint8_t* pst;
|
|
InitPointer((uint8_t**)&pst);
|
|
uint8_t* message;
|
|
InitPointer((uint8_t**)&message);
|
|
uint8_t* signature;
|
|
InitPointer((uint8_t**)&signature);
|
|
ODK_Unpack_DeleteUsageEntry_Request(request, &session, &pst, &pst_length,
|
|
&message, &message_length, &signature,
|
|
&signature_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_DeleteUsageEntry(session, pst, pst_length, message,
|
|
message_length, signature,
|
|
signature_length);
|
|
ODK_Pack_DeleteUsageEntry_Response(response, result);
|
|
break;
|
|
}
|
|
case 43: /* OEMCrypto_ForceDeleteUsageEntry */
|
|
{
|
|
size_t pst_length;
|
|
Init_size_t((size_t*)&pst_length);
|
|
uint8_t* pst;
|
|
InitPointer((uint8_t**)&pst);
|
|
ODK_Unpack_ForceDeleteUsageEntry_Request(request, &pst, &pst_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_ForceDeleteUsageEntry(pst, pst_length);
|
|
ODK_Pack_ForceDeleteUsageEntry_Response(response, result);
|
|
break;
|
|
}
|
|
case 68: /* OEMCrypto_MoveEntry */
|
|
{
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint32_t new_index;
|
|
Init_uint32_t((uint32_t*)&new_index);
|
|
ODK_Unpack_MoveEntry_Request(request, &session, &new_index);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_MoveEntry(session, new_index);
|
|
ODK_Pack_MoveEntry_Response(response, result);
|
|
break;
|
|
}
|
|
case 67: /* OEMCrypto_ShrinkUsageTableHeader */
|
|
{
|
|
size_t* header_buffer_length = (size_t*)VarAlloc(sizeof(size_t));
|
|
Init_size_t(header_buffer_length);
|
|
uint32_t new_entry_count;
|
|
Init_uint32_t((uint32_t*)&new_entry_count);
|
|
uint8_t* header_buffer;
|
|
InitPointer((uint8_t**)&header_buffer);
|
|
ODK_Unpack_ShrinkUsageTableHeader_Request(
|
|
request, &new_entry_count, &header_buffer, &header_buffer_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_ShrinkUsageTableHeader(new_entry_count, header_buffer,
|
|
header_buffer_length);
|
|
ODK_Pack_ShrinkUsageTableHeader_Response(response, result, header_buffer,
|
|
header_buffer_length);
|
|
break;
|
|
}
|
|
case 69: /* OEMCrypto_CopyOldUsageEntry */
|
|
{
|
|
size_t pst_length;
|
|
Init_size_t((size_t*)&pst_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint8_t* pst;
|
|
InitPointer((uint8_t**)&pst);
|
|
ODK_Unpack_CopyOldUsageEntry_Request(request, &session, &pst,
|
|
&pst_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_CopyOldUsageEntry(session, pst, pst_length);
|
|
ODK_Pack_CopyOldUsageEntry_Response(response, result);
|
|
break;
|
|
}
|
|
case 34: /* OEMCrypto_DeleteOldUsageTable */
|
|
{
|
|
ODK_Unpack_DeleteOldUsageTable_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_DeleteOldUsageTable();
|
|
ODK_Pack_DeleteOldUsageTable_Response(response, result);
|
|
break;
|
|
}
|
|
case 57: /* OEMCrypto_RemoveSRM */
|
|
{
|
|
ODK_Unpack_RemoveSRM_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_RemoveSRM();
|
|
ODK_Pack_RemoveSRM_Response(response, result);
|
|
break;
|
|
}
|
|
case 70: /* OEMCrypto_CreateOldUsageEntry */
|
|
{
|
|
size_t pst_length;
|
|
Init_size_t((size_t*)&pst_length);
|
|
uint64_t time_since_license_received;
|
|
Init_uint64_t((uint64_t*)&time_since_license_received);
|
|
uint64_t time_since_first_decrypt;
|
|
Init_uint64_t((uint64_t*)&time_since_first_decrypt);
|
|
uint64_t time_since_last_decrypt;
|
|
Init_uint64_t((uint64_t*)&time_since_last_decrypt);
|
|
OEMCrypto_Usage_Entry_Status status;
|
|
Init_uint32_t((uint32_t*)&status);
|
|
uint8_t server_mac_key[32];
|
|
InitMemory(&server_mac_key[0], 32);
|
|
uint8_t client_mac_key[32];
|
|
InitMemory(&client_mac_key[0], 32);
|
|
uint8_t* pst;
|
|
InitPointer((uint8_t**)&pst);
|
|
ODK_Unpack_CreateOldUsageEntry_Request(
|
|
request, &time_since_license_received, &time_since_first_decrypt,
|
|
&time_since_last_decrypt, &status, &server_mac_key[0],
|
|
&client_mac_key[0], &pst, &pst_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_CreateOldUsageEntry(
|
|
time_since_license_received, time_since_first_decrypt,
|
|
time_since_last_decrypt, status, server_mac_key, client_mac_key, pst,
|
|
pst_length);
|
|
ODK_Pack_CreateOldUsageEntry_Response(response, result);
|
|
break;
|
|
}
|
|
case 86: /* OEMCrypto_SupportsDecryptHash */
|
|
{
|
|
ODK_Unpack_SupportsDecryptHash_Request(request);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
uint32_t result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_SupportsDecryptHash();
|
|
ODK_Pack_SupportsDecryptHash_Response(response, result);
|
|
break;
|
|
}
|
|
case 88: /* OEMCrypto_SetDecryptHash */
|
|
{
|
|
size_t hash_length;
|
|
Init_size_t((size_t*)&hash_length);
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint32_t frame_number;
|
|
Init_uint32_t((uint32_t*)&frame_number);
|
|
uint8_t* hash;
|
|
InitPointer((uint8_t**)&hash);
|
|
ODK_Unpack_SetDecryptHash_Request(request, &session, &frame_number, &hash,
|
|
&hash_length);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result =
|
|
OEMCrypto_SetDecryptHash(session, frame_number, hash, hash_length);
|
|
ODK_Pack_SetDecryptHash_Response(response, result);
|
|
break;
|
|
}
|
|
case 89: /* OEMCrypto_GetHashErrorCode */
|
|
{
|
|
OEMCrypto_SESSION session;
|
|
Init_uint32_t((uint32_t*)&session);
|
|
uint32_t* failed_frame_number;
|
|
InitPointer((uint8_t**)&failed_frame_number);
|
|
ODK_Unpack_GetHashErrorCode_Request(request, &session,
|
|
&failed_frame_number);
|
|
message_status = GetStatus(request);
|
|
if (message_status != MESSAGE_STATUS_OK) {
|
|
return message_status;
|
|
}
|
|
OEMCryptoResult result;
|
|
Init_uint32_t((uint32_t*)&result);
|
|
result = OEMCrypto_GetHashErrorCode(session, failed_frame_number);
|
|
ODK_Pack_GetHashErrorCode_Response(response, result, failed_frame_number);
|
|
break;
|
|
}
|
|
default:
|
|
return MESSAGE_STATUS_API_VALUE_ERROR;
|
|
}
|
|
return GetStatus(response);
|
|
}
|