2117 lines
80 KiB
C
2117 lines
80 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 "deserializer.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include "marshaller_base.h"
|
|
#include "serialization_base.h"
|
|
#include "serializer.h"
|
|
#include "shared_memory_allocator.h"
|
|
#include "special_cases.h"
|
|
|
|
bool Is_Valid_OEMCryptoResult(uint32_t value) {
|
|
switch (value) {
|
|
case 0: /* OEMCrypto_SUCCESS */
|
|
case 1: /* OEMCrypto_ERROR_INIT_FAILED */
|
|
case 2: /* OEMCrypto_ERROR_TERMINATE_FAILED */
|
|
case 3: /* OEMCrypto_ERROR_OPEN_FAILURE */
|
|
case 4: /* OEMCrypto_ERROR_CLOSE_FAILURE */
|
|
case 5: /* OEMCrypto_ERROR_ENTER_SECURE_PLAYBACK_FAILED */
|
|
case 6: /* OEMCrypto_ERROR_EXIT_SECURE_PLAYBACK_FAILED */
|
|
case 7: /* OEMCrypto_ERROR_SHORT_BUFFER */
|
|
case 8: /* OEMCrypto_ERROR_NO_DEVICE_KEY */
|
|
case 9: /* OEMCrypto_ERROR_NO_ASSET_KEY */
|
|
case 10: /* OEMCrypto_ERROR_KEYBOX_INVALID */
|
|
case 11: /* OEMCrypto_ERROR_NO_KEYDATA */
|
|
case 12: /* OEMCrypto_ERROR_NO_CW */
|
|
case 13: /* OEMCrypto_ERROR_DECRYPT_FAILED */
|
|
case 14: /* OEMCrypto_ERROR_WRITE_KEYBOX */
|
|
case 15: /* OEMCrypto_ERROR_WRAP_KEYBOX */
|
|
case 16: /* OEMCrypto_ERROR_BAD_MAGIC */
|
|
case 17: /* OEMCrypto_ERROR_BAD_CRC */
|
|
case 18: /* OEMCrypto_ERROR_NO_DEVICEID */
|
|
case 19: /* OEMCrypto_ERROR_RNG_FAILED */
|
|
case 20: /* OEMCrypto_ERROR_RNG_NOT_SUPPORTED */
|
|
case 21: /* OEMCrypto_ERROR_SETUP */
|
|
case 22: /* OEMCrypto_ERROR_OPEN_SESSION_FAILED */
|
|
case 23: /* OEMCrypto_ERROR_CLOSE_SESSION_FAILED */
|
|
case 24: /* OEMCrypto_ERROR_INVALID_SESSION */
|
|
case 25: /* OEMCrypto_ERROR_NOT_IMPLEMENTED */
|
|
case 26: /* OEMCrypto_ERROR_NO_CONTENT_KEY */
|
|
case 27: /* OEMCrypto_ERROR_CONTROL_INVALID */
|
|
case 28: /* OEMCrypto_ERROR_UNKNOWN_FAILURE */
|
|
case 29: /* OEMCrypto_ERROR_INVALID_CONTEXT */
|
|
case 30: /* OEMCrypto_ERROR_SIGNATURE_FAILURE */
|
|
case 31: /* OEMCrypto_ERROR_TOO_MANY_SESSIONS */
|
|
case 32: /* OEMCrypto_ERROR_INVALID_NONCE */
|
|
case 33: /* OEMCrypto_ERROR_TOO_MANY_KEYS */
|
|
case 34: /* OEMCrypto_ERROR_DEVICE_NOT_RSA_PROVISIONED */
|
|
case 35: /* OEMCrypto_ERROR_INVALID_RSA_KEY */
|
|
case 36: /* OEMCrypto_ERROR_KEY_EXPIRED */
|
|
case 37: /* OEMCrypto_ERROR_INSUFFICIENT_RESOURCES */
|
|
case 38: /* OEMCrypto_ERROR_INSUFFICIENT_HDCP */
|
|
case 39: /* OEMCrypto_ERROR_BUFFER_TOO_LARGE */
|
|
case 40: /* OEMCrypto_WARNING_GENERATION_SKEW */
|
|
case 41: /* OEMCrypto_ERROR_GENERATION_SKEW */
|
|
case 42: /* OEMCrypto_LOCAL_DISPLAY_ONLY */
|
|
case 43: /* OEMCrypto_ERROR_ANALOG_OUTPUT */
|
|
case 44: /* OEMCrypto_ERROR_WRONG_PST */
|
|
case 45: /* OEMCrypto_ERROR_WRONG_KEYS */
|
|
case 46: /* OEMCrypto_ERROR_MISSING_MASTER */
|
|
case 47: /* OEMCrypto_ERROR_LICENSE_INACTIVE */
|
|
case 48: /* OEMCrypto_ERROR_ENTRY_NEEDS_UPDATE */
|
|
case 49: /* OEMCrypto_ERROR_ENTRY_IN_USE */
|
|
case 50: /* OEMCrypto_ERROR_USAGE_TABLE_UNRECOVERABLE */
|
|
case 51: /* OEMCrypto_KEY_NOT_LOADED */
|
|
case 52: /* OEMCrypto_KEY_NOT_ENTITLED */
|
|
case 53: /* OEMCrypto_ERROR_BAD_HASH */
|
|
case 54: /* OEMCrypto_ERROR_OUTPUT_TOO_LARGE */
|
|
case 55: /* OEMCrypto_ERROR_SESSION_LOST_STATE */
|
|
case 56: /* OEMCrypto_ERROR_SYSTEM_INVALIDATED */
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool Is_Valid_OEMCryptoBufferType(uint32_t value) {
|
|
switch (value) {
|
|
case 0: /* OEMCrypto_BufferType_Clear */
|
|
case 1: /* OEMCrypto_BufferType_Secure */
|
|
case 2: /* OEMCrypto_BufferType_Direct */
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool Is_Valid_OEMCryptoCipherMode(uint32_t value) {
|
|
switch (value) {
|
|
case 0: /* OEMCrypto_CipherMode_CTR */
|
|
case 1: /* OEMCrypto_CipherMode_CBC */
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool Is_Valid_OEMCrypto_LicenseType(uint32_t value) {
|
|
switch (value) {
|
|
case 0: /* OEMCrypto_ContentLicense */
|
|
case 1: /* OEMCrypto_EntitlementLicense */
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool Is_Valid_OEMCrypto_Algorithm(uint32_t value) {
|
|
switch (value) {
|
|
case 0: /* OEMCrypto_AES_CBC_128_NO_PADDING */
|
|
case 1: /* OEMCrypto_HMAC_SHA256 */
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool Is_Valid_OEMCrypto_Usage_Entry_Status(uint32_t value) {
|
|
switch (value) {
|
|
case 0: /* kUnused */
|
|
case 1: /* kActive */
|
|
case 2: /* kInactive */
|
|
case 3: /* kInactiveUsed */
|
|
case 4: /* kInactiveUnused */
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool Is_Valid_OEMCrypto_Clock_Security_Level(uint32_t value) {
|
|
switch (value) {
|
|
case 0: /* kInsecureClock */
|
|
case 1: /* kSecureTimer */
|
|
case 2: /* kSecureClock */
|
|
case 3: /* kHardwareSecureClock */
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool Is_Valid_OEMCrypto_HDCP_Capability(uint32_t value) {
|
|
switch (value) {
|
|
case 0: /* HDCP_NONE */
|
|
case 1: /* HDCP_V1 */
|
|
case 2: /* HDCP_V2 */
|
|
case 3: /* HDCP_V2_1 */
|
|
case 4: /* HDCP_V2_2 */
|
|
case 5: /* HDCP_V2_3 */
|
|
case 255: /* HDCP_NO_DIGITAL_OUTPUT */
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool Is_Valid_OEMCrypto_ProvisioningMethod(uint32_t value) {
|
|
switch (value) {
|
|
case 0: /* OEMCrypto_ProvisioningError */
|
|
case 1: /* OEMCrypto_DrmCertificate */
|
|
case 2: /* OEMCrypto_Keybox */
|
|
case 3: /* OEMCrypto_OEMCertificate */
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void ODK_Unpack_OEMCrypto_Substring(Message* msg, OEMCrypto_Substring* obj) {
|
|
ODK_Unpack_size_t(msg, (size_t*)&obj->offset);
|
|
ODK_Unpack_size_t(msg, (size_t*)&obj->length);
|
|
}
|
|
|
|
void ODK_Unpack_OEMCrypto_KeyObject(Message* msg, OEMCrypto_KeyObject* obj) {
|
|
ODK_Unpack_OEMCrypto_Substring(msg, (OEMCrypto_Substring*)&obj->key_id);
|
|
ODK_Unpack_OEMCrypto_Substring(msg, (OEMCrypto_Substring*)&obj->key_data_iv);
|
|
ODK_Unpack_OEMCrypto_Substring(msg, (OEMCrypto_Substring*)&obj->key_data);
|
|
ODK_Unpack_OEMCrypto_Substring(msg,
|
|
(OEMCrypto_Substring*)&obj->key_control_iv);
|
|
ODK_Unpack_OEMCrypto_Substring(msg, (OEMCrypto_Substring*)&obj->key_control);
|
|
}
|
|
|
|
void ODK_Unpack_OEMCrypto_EntitledContentKeyObject(
|
|
Message* msg, OEMCrypto_EntitledContentKeyObject* obj) {
|
|
ODK_Unpack_OEMCrypto_Substring(
|
|
msg, (OEMCrypto_Substring*)&obj->entitlement_key_id);
|
|
ODK_Unpack_OEMCrypto_Substring(msg,
|
|
(OEMCrypto_Substring*)&obj->content_key_id);
|
|
ODK_Unpack_OEMCrypto_Substring(
|
|
msg, (OEMCrypto_Substring*)&obj->content_key_data_iv);
|
|
ODK_Unpack_OEMCrypto_Substring(msg,
|
|
(OEMCrypto_Substring*)&obj->content_key_data);
|
|
}
|
|
|
|
void ODK_Unpack_OEMCrypto_KeyRefreshObject(Message* msg,
|
|
OEMCrypto_KeyRefreshObject* obj) {
|
|
ODK_Unpack_OEMCrypto_Substring(msg, (OEMCrypto_Substring*)&obj->key_id);
|
|
ODK_Unpack_OEMCrypto_Substring(msg,
|
|
(OEMCrypto_Substring*)&obj->key_control_iv);
|
|
ODK_Unpack_OEMCrypto_Substring(msg, (OEMCrypto_Substring*)&obj->key_control);
|
|
}
|
|
|
|
void ODK_Unpack_OEMCrypto_CENCEncryptPatternDesc(
|
|
Message* msg, OEMCrypto_CENCEncryptPatternDesc* obj) {
|
|
ODK_Unpack_size_t(msg, (size_t*)&obj->encrypt);
|
|
ODK_Unpack_size_t(msg, (size_t*)&obj->skip);
|
|
ODK_Unpack_size_t(msg, (size_t*)&obj->offset);
|
|
}
|
|
|
|
void ODK_Unpack_SecurityLevel_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 23) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SecurityLevel_Response(Message* msg, char** result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 23) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_c_str(msg, result);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_BuildInformation_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 90) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_BuildInformation_Response(Message* msg, char** result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 90) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_c_str(msg, result);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SetSandbox_Request(Message* msg, uint8_t** sandbox_id,
|
|
size_t* sandbox_id_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 84) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, sandbox_id_length);
|
|
ODK_UnpackPointerToMemory(msg, sandbox_id);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SetSandbox_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 84) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Initialize_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 1) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Initialize_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 1) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Terminate_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 2) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Terminate_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 2) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_OpenSession_Request(Message* msg, OEMCrypto_SESSION** session) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 9) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
*session = (uint32_t*)ODK_UnpackAlloc(msg, sizeof(OEMCrypto_SESSION));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_OpenSession_Response(Message* msg, OEMCryptoResult* result,
|
|
OEMCrypto_SESSION** session) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 9) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackNullable_uint32_t(msg, session);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_CloseSession_Request(Message* msg, OEMCrypto_SESSION* session) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 10) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_CloseSession_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 10) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GenerateDerivedKeys_Request(Message* msg,
|
|
OEMCrypto_SESSION* session,
|
|
SharedMemory** mac_key_context,
|
|
uint32_t* mac_key_context_length,
|
|
SharedMemory** enc_key_context,
|
|
uint32_t* enc_key_context_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 12) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, mac_key_context_length);
|
|
ODK_Unpack_uint32_t(msg, enc_key_context_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*mac_key_context = ODK_UnpackSharedBuffer(
|
|
msg, 0, LengthFromUint32TPointer(mac_key_context_length));
|
|
*enc_key_context = ODK_UnpackSharedBuffer(
|
|
msg, 1, LengthFromUint32TPointer(enc_key_context_length));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GenerateDerivedKeys_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 12) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_DeriveKeysFromSessionKey_Request(
|
|
Message* msg, OEMCrypto_SESSION* session, uint8_t** enc_session_key,
|
|
size_t* enc_session_key_length, SharedMemory** mac_key_context,
|
|
size_t* mac_key_context_length, SharedMemory** enc_key_context,
|
|
size_t* enc_key_context_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 21) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, enc_session_key_length);
|
|
ODK_Unpack_size_t(msg, mac_key_context_length);
|
|
ODK_Unpack_size_t(msg, enc_key_context_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
ODK_UnpackPointerToMemory(msg, enc_session_key);
|
|
*mac_key_context = ODK_UnpackSharedBuffer(
|
|
msg, 0, LengthFromSizeTPointer(mac_key_context_length));
|
|
*enc_key_context = ODK_UnpackSharedBuffer(
|
|
msg, 1, LengthFromSizeTPointer(enc_key_context_length));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_DeriveKeysFromSessionKey_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 21) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GenerateNonce_Request(Message* msg, OEMCrypto_SESSION* session,
|
|
uint32_t** nonce) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 14) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*nonce = (uint32_t*)ODK_UnpackAlloc(msg, sizeof(uint32_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GenerateNonce_Response(Message* msg, OEMCryptoResult* result,
|
|
uint32_t** nonce) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 14) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackNullable_uint32_t(msg, nonce);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GenerateSignature_Request(
|
|
Message* msg, OEMCrypto_SESSION* session, SharedMemory** message,
|
|
size_t* message_length, uint8_t** signature, size_t** signature_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 13) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, message_length);
|
|
ODK_UnpackNullable_size_t(msg, signature_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*message =
|
|
ODK_UnpackSharedBuffer(msg, 0, LengthFromSizeTPointer(message_length));
|
|
*signature = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTDoublePointer(signature_length), sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GenerateSignature_Response(Message* msg,
|
|
OEMCryptoResult* result,
|
|
uint8_t** signature,
|
|
size_t** signature_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 13) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, signature_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *signature) {
|
|
memcpy(*signature, p,
|
|
LengthAsSizeT(LengthFromSizeTDoublePointer(signature_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadSRM_Request(Message* msg, uint8_t** buffer,
|
|
size_t* buffer_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 55) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, buffer_length);
|
|
ODK_UnpackPointerToMemory(msg, buffer);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadSRM_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 55) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadKeys_Request(
|
|
Message* msg, OEMCrypto_SESSION* session, SharedMemory** message,
|
|
size_t* message_length, SharedMemory** signature, size_t* signature_length,
|
|
OEMCrypto_Substring* enc_mac_keys_iv, OEMCrypto_Substring* enc_mac_keys,
|
|
size_t* key_array_length, OEMCrypto_KeyObject** key_array,
|
|
OEMCrypto_Substring* pst, OEMCrypto_Substring* srm_restriction_data,
|
|
OEMCrypto_LicenseType* license_type) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 83) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, message_length);
|
|
ODK_Unpack_size_t(msg, signature_length);
|
|
ODK_Unpack_size_t(msg, key_array_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*message =
|
|
ODK_UnpackSharedBuffer(msg, 0, LengthFromSizeTPointer(message_length));
|
|
*signature =
|
|
ODK_UnpackSharedBuffer(msg, 1, LengthFromSizeTPointer(signature_length));
|
|
ODK_Unpack_OEMCrypto_Substring(msg, enc_mac_keys_iv);
|
|
ODK_Unpack_OEMCrypto_Substring(msg, enc_mac_keys);
|
|
ODK_UnpackObjArray(msg, (uint8_t**)key_array,
|
|
LengthFromSizeTPointer(key_array_length),
|
|
sizeof(OEMCrypto_KeyObject),
|
|
(ObjUnpacker)&ODK_Unpack_OEMCrypto_KeyObject);
|
|
ODK_Unpack_OEMCrypto_Substring(msg, pst);
|
|
ODK_Unpack_OEMCrypto_Substring(msg, srm_restriction_data);
|
|
ODK_Unpack_uint32_t(msg, license_type);
|
|
if (!Is_Valid_OEMCrypto_LicenseType(*license_type)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadKeys_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 83) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadEntitledContentKeys_Request(
|
|
Message* msg, OEMCrypto_SESSION* session, SharedMemory** message,
|
|
size_t* message_length, size_t* key_array_length,
|
|
OEMCrypto_EntitledContentKeyObject** key_array) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 92) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, message_length);
|
|
ODK_Unpack_size_t(msg, key_array_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*message =
|
|
ODK_UnpackSharedBuffer(msg, 0, LengthFromSizeTPointer(message_length));
|
|
ODK_UnpackObjArray(
|
|
msg, (uint8_t**)key_array, LengthFromSizeTPointer(key_array_length),
|
|
sizeof(OEMCrypto_EntitledContentKeyObject),
|
|
(ObjUnpacker)&ODK_Unpack_OEMCrypto_EntitledContentKeyObject);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadEntitledContentKeys_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 92) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_RefreshKeys_Request(
|
|
Message* msg, OEMCrypto_SESSION* session, SharedMemory** message,
|
|
size_t* message_length, SharedMemory** signature, size_t* signature_length,
|
|
size_t* key_array_length, OEMCrypto_KeyRefreshObject** key_array) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 91) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, message_length);
|
|
ODK_Unpack_size_t(msg, signature_length);
|
|
ODK_Unpack_size_t(msg, key_array_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*message =
|
|
ODK_UnpackSharedBuffer(msg, 0, LengthFromSizeTPointer(message_length));
|
|
*signature =
|
|
ODK_UnpackSharedBuffer(msg, 1, LengthFromSizeTPointer(signature_length));
|
|
ODK_UnpackObjArray(msg, (uint8_t**)key_array,
|
|
LengthFromSizeTPointer(key_array_length),
|
|
sizeof(OEMCrypto_KeyRefreshObject),
|
|
(ObjUnpacker)&ODK_Unpack_OEMCrypto_KeyRefreshObject);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_RefreshKeys_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 91) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_QueryKeyControl_Request(Message* msg,
|
|
OEMCrypto_SESSION* session,
|
|
uint8_t** content_key_id,
|
|
size_t* content_key_id_length,
|
|
uint8_t** key_control_block,
|
|
size_t** key_control_block_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 41) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, content_key_id_length);
|
|
ODK_UnpackNullable_size_t(msg, key_control_block_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
ODK_UnpackPointerToMemory(msg, content_key_id);
|
|
*key_control_block = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTDoublePointer(key_control_block_length),
|
|
sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_QueryKeyControl_Response(Message* msg, OEMCryptoResult* result,
|
|
uint8_t** key_control_block,
|
|
size_t** key_control_block_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 41) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, key_control_block_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *key_control_block) {
|
|
memcpy(*key_control_block, p,
|
|
LengthAsSizeT(
|
|
LengthFromSizeTDoublePointer(key_control_block_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SelectKey_Request(Message* msg, OEMCrypto_SESSION* session,
|
|
uint8_t** content_key_id,
|
|
size_t* content_key_id_length,
|
|
OEMCryptoCipherMode* cipher_mode) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 81) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, content_key_id_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
ODK_UnpackPointerToMemory(msg, content_key_id);
|
|
ODK_Unpack_uint32_t(msg, cipher_mode);
|
|
if (!Is_Valid_OEMCryptoCipherMode(*cipher_mode)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SelectKey_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 81) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_DecryptCENC_Request(
|
|
Message* msg, OEMCrypto_SESSION* session, SharedMemory** data_addr,
|
|
size_t* data_addr_length, bool* is_encrypted, uint8_t* iv,
|
|
size_t* block_offset, OEMCrypto_DestBufferDesc** out_buffer,
|
|
OEMCrypto_CENCEncryptPatternDesc** pattern, uint8_t* subsample_flags) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 48) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, data_addr_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*data_addr =
|
|
ODK_UnpackSharedBuffer(msg, 0, LengthFromSizeTPointer(data_addr_length));
|
|
ODK_Unpack_bool(msg, is_encrypted);
|
|
ODK_UnpackArray(msg, &iv[0], 16);
|
|
ODK_Unpack_size_t(msg, block_offset);
|
|
ODK_UnpackNullable_OEMCrypto_DestBufferDesc(msg, out_buffer);
|
|
ODK_UnpackNullable_OEMCrypto_CENCEncryptPatternDesc(msg, pattern);
|
|
ODK_Unpack_uint8_t(msg, subsample_flags);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_DecryptCENC_Response(Message* msg, OEMCryptoResult* result,
|
|
OEMCrypto_DestBufferDesc** out_buffer) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 48) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackNullable_OEMCrypto_DestBufferDesc(msg, out_buffer);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_CopyBuffer_Request(Message* msg, OEMCrypto_SESSION* session,
|
|
SharedMemory** data_addr,
|
|
size_t* data_addr_length,
|
|
OEMCrypto_DestBufferDesc** out_buffer,
|
|
uint8_t* subsample_flags) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 93) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, data_addr_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*data_addr =
|
|
ODK_UnpackSharedBuffer(msg, 0, LengthFromSizeTPointer(data_addr_length));
|
|
ODK_UnpackNullable_OEMCrypto_DestBufferDesc(msg, out_buffer);
|
|
ODK_Unpack_uint8_t(msg, subsample_flags);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_CopyBuffer_Response(Message* msg, OEMCryptoResult* result,
|
|
OEMCrypto_DestBufferDesc** out_buffer) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 93) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackNullable_OEMCrypto_DestBufferDesc(msg, out_buffer);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Generic_Encrypt_Request(Message* msg,
|
|
OEMCrypto_SESSION* session,
|
|
SharedMemory** in_buffer,
|
|
size_t* in_buffer_length, uint8_t* iv,
|
|
OEMCrypto_Algorithm* algorithm,
|
|
uint8_t** out_buffer) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 24) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, in_buffer_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*in_buffer =
|
|
ODK_UnpackSharedBuffer(msg, 0, LengthFromSizeTPointer(in_buffer_length));
|
|
ODK_UnpackArray(msg, &iv[0], 16);
|
|
ODK_Unpack_uint32_t(msg, algorithm);
|
|
if (!Is_Valid_OEMCrypto_Algorithm(*algorithm)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
*out_buffer = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTPointer(in_buffer_length), sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Generic_Encrypt_Response(Message* msg, OEMCryptoResult* result,
|
|
size_t* in_buffer_length,
|
|
uint8_t** out_buffer) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 24) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, in_buffer_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *out_buffer) {
|
|
memcpy(*out_buffer, p,
|
|
LengthAsSizeT(LengthFromSizeTPointer(in_buffer_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Generic_Decrypt_Request(Message* msg,
|
|
OEMCrypto_SESSION* session,
|
|
SharedMemory** in_buffer,
|
|
size_t* in_buffer_length, uint8_t* iv,
|
|
OEMCrypto_Algorithm* algorithm,
|
|
uint8_t** out_buffer) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 25) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, in_buffer_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*in_buffer =
|
|
ODK_UnpackSharedBuffer(msg, 0, LengthFromSizeTPointer(in_buffer_length));
|
|
ODK_UnpackArray(msg, &iv[0], 16);
|
|
ODK_Unpack_uint32_t(msg, algorithm);
|
|
if (!Is_Valid_OEMCrypto_Algorithm(*algorithm)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
*out_buffer = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTPointer(in_buffer_length), sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Generic_Decrypt_Response(Message* msg, OEMCryptoResult* result,
|
|
size_t* in_buffer_length,
|
|
uint8_t** out_buffer) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 25) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, in_buffer_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *out_buffer) {
|
|
memcpy(*out_buffer, p,
|
|
LengthAsSizeT(LengthFromSizeTPointer(in_buffer_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Generic_Sign_Request(Message* msg, OEMCrypto_SESSION* session,
|
|
SharedMemory** buffer,
|
|
size_t* buffer_length,
|
|
OEMCrypto_Algorithm* algorithm,
|
|
uint8_t** signature,
|
|
size_t** signature_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 26) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, buffer_length);
|
|
ODK_UnpackNullable_size_t(msg, signature_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*buffer =
|
|
ODK_UnpackSharedBuffer(msg, 0, LengthFromSizeTPointer(buffer_length));
|
|
ODK_Unpack_uint32_t(msg, algorithm);
|
|
if (!Is_Valid_OEMCrypto_Algorithm(*algorithm)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
*signature = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTDoublePointer(signature_length), sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Generic_Sign_Response(Message* msg, OEMCryptoResult* result,
|
|
uint8_t** signature,
|
|
size_t** signature_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 26) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, signature_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *signature) {
|
|
memcpy(*signature, p,
|
|
LengthAsSizeT(LengthFromSizeTDoublePointer(signature_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Generic_Verify_Request(Message* msg, OEMCrypto_SESSION* session,
|
|
SharedMemory** buffer,
|
|
size_t* buffer_length,
|
|
OEMCrypto_Algorithm* algorithm,
|
|
SharedMemory** signature,
|
|
size_t* signature_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 27) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, buffer_length);
|
|
ODK_Unpack_size_t(msg, signature_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*buffer =
|
|
ODK_UnpackSharedBuffer(msg, 0, LengthFromSizeTPointer(buffer_length));
|
|
ODK_Unpack_uint32_t(msg, algorithm);
|
|
if (!Is_Valid_OEMCrypto_Algorithm(*algorithm)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
*signature =
|
|
ODK_UnpackSharedBuffer(msg, 1, LengthFromSizeTPointer(signature_length));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Generic_Verify_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 27) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_UpdateUsageTable_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 30) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_UpdateUsageTable_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 30) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_WrapKeyboxOrOEMCert_Request(Message* msg, uint8_t** rot,
|
|
size_t* rotLength,
|
|
uint8_t** wrappedRot,
|
|
size_t** wrappedRotLength,
|
|
uint8_t** transportKey,
|
|
size_t* transportKeyLength) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 8) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, rotLength);
|
|
*wrappedRotLength = (size_t*)ODK_UnpackAlloc(msg, sizeof(size_t));
|
|
ODK_Unpack_size_t(msg, transportKeyLength);
|
|
ODK_UnpackPointerToMemory(msg, rot);
|
|
*wrappedRot = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTDoublePointer(wrappedRotLength), sizeof(uint8_t));
|
|
ODK_UnpackPointerToMemory(msg, transportKey);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_WrapKeyboxOrOEMCert_Response(Message* msg,
|
|
OEMCryptoResult* result,
|
|
uint8_t** wrappedRot,
|
|
size_t** wrappedRotLength) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 8) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, wrappedRotLength);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *wrappedRot) {
|
|
memcpy(*wrappedRot, p,
|
|
LengthAsSizeT(LengthFromSizeTDoublePointer(wrappedRotLength)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_InstallKeyboxOrOEMCert_Request(Message* msg, uint8_t** rot,
|
|
size_t* rotLength) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 3) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, rotLength);
|
|
ODK_UnpackPointerToMemory(msg, rot);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_InstallKeyboxOrOEMCert_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 3) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetProvisioningMethod_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 49) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetProvisioningMethod_Response(
|
|
Message* msg, OEMCrypto_ProvisioningMethod* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 49) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCrypto_ProvisioningMethod(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_IsKeyboxOrOEMCertValid_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 5) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_IsKeyboxOrOEMCertValid_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 5) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetDeviceID_Request(Message* msg, uint8_t** device_id,
|
|
size_t** device_id_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 7) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, device_id_length);
|
|
*device_id = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTDoublePointer(device_id_length), sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetDeviceID_Response(Message* msg, OEMCryptoResult* result,
|
|
uint8_t** device_id,
|
|
size_t** device_id_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 7) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, device_id_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *device_id) {
|
|
memcpy(*device_id, p,
|
|
LengthAsSizeT(LengthFromSizeTDoublePointer(device_id_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetKeyData_Request(Message* msg, uint8_t** keyData,
|
|
size_t** keyDataLength) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 4) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, keyDataLength);
|
|
*keyData = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTDoublePointer(keyDataLength), sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetKeyData_Response(Message* msg, OEMCryptoResult* result,
|
|
uint8_t** keyData, size_t** keyDataLength) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 4) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, keyDataLength);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *keyData) {
|
|
memcpy(*keyData, p,
|
|
LengthAsSizeT(LengthFromSizeTDoublePointer(keyDataLength)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadTestKeybox_Request(Message* msg, uint8_t** buffer,
|
|
size_t* buffer_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 78) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, buffer_length);
|
|
ODK_UnpackPointerToMemory(msg, buffer);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadTestKeybox_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 78) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetOEMPublicCertificate_Request(Message* msg,
|
|
OEMCrypto_SESSION* session,
|
|
uint8_t** public_cert,
|
|
size_t** public_cert_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 50) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, public_cert_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*public_cert = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTDoublePointer(public_cert_length), sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetOEMPublicCertificate_Response(Message* msg,
|
|
OEMCryptoResult* result,
|
|
uint8_t** public_cert,
|
|
size_t** public_cert_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 50) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, public_cert_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *public_cert) {
|
|
memcpy(*public_cert, p,
|
|
LengthAsSizeT(LengthFromSizeTDoublePointer(public_cert_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetRandom_Request(Message* msg, uint8_t** random_data,
|
|
size_t* random_data_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 6) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, random_data_length);
|
|
*random_data = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTPointer(random_data_length), sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetRandom_Response(Message* msg, OEMCryptoResult* result,
|
|
uint8_t** random_data,
|
|
size_t* random_data_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 6) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, random_data_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *random_data) {
|
|
memcpy(*random_data, p,
|
|
LengthAsSizeT(LengthFromSizeTPointer(random_data_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_APIVersion_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 22) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_APIVersion_Response(Message* msg, uint32_t* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 22) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Security_Patch_Level_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 46) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_Security_Patch_Level_Response(Message* msg, uint8_t* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 46) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint8_t(msg, result);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetHDCPCapability_Request(Message* msg,
|
|
OEMCrypto_HDCP_Capability** current,
|
|
OEMCrypto_HDCP_Capability** maximum) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 44) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
*current = (uint32_t*)ODK_UnpackAlloc(msg, sizeof(OEMCrypto_HDCP_Capability));
|
|
*maximum = (uint32_t*)ODK_UnpackAlloc(msg, sizeof(OEMCrypto_HDCP_Capability));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetHDCPCapability_Response(
|
|
Message* msg, OEMCryptoResult* result, OEMCrypto_HDCP_Capability** current,
|
|
OEMCrypto_HDCP_Capability** maximum) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 44) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackNullable_uint32_t(msg, current);
|
|
if (*current) {
|
|
if (!Is_Valid_OEMCrypto_HDCP_Capability(**current)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
}
|
|
ODK_UnpackNullable_uint32_t(msg, maximum);
|
|
if (*maximum) {
|
|
if (!Is_Valid_OEMCrypto_HDCP_Capability(**maximum)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SupportsUsageTable_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 29) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SupportsUsageTable_Response(Message* msg, bool* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 29) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_bool(msg, result);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_IsAntiRollbackHwPresent_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 39) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_IsAntiRollbackHwPresent_Response(Message* msg, bool* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 39) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_bool(msg, result);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetNumberOfOpenSessions_Request(Message* msg, size_t** count) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 38) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
*count = (size_t*)ODK_UnpackAlloc(msg, sizeof(size_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetNumberOfOpenSessions_Response(Message* msg,
|
|
OEMCryptoResult* result,
|
|
size_t** count) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 38) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackNullable_size_t(msg, count);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetMaxNumberOfSessions_Request(Message* msg, size_t** max) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 37) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
*max = (size_t*)ODK_UnpackAlloc(msg, sizeof(size_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetMaxNumberOfSessions_Response(Message* msg,
|
|
OEMCryptoResult* result,
|
|
size_t** max) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 37) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackNullable_size_t(msg, max);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SupportedCertificates_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 52) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SupportedCertificates_Response(Message* msg, uint32_t* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 52) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_IsSRMUpdateSupported_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 53) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_IsSRMUpdateSupported_Response(Message* msg, bool* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 53) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_bool(msg, result);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetCurrentSRMVersion_Request(Message* msg, uint16_t** version) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 54) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
*version = (uint16_t*)ODK_UnpackAlloc(msg, sizeof(uint16_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetCurrentSRMVersion_Response(Message* msg,
|
|
OEMCryptoResult* result,
|
|
uint16_t** version) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 54) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackNullable_uint16_t(msg, version);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetAnalogOutputFlags_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 71) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetAnalogOutputFlags_Response(Message* msg, uint32_t* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 71) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_ResourceRatingTier_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 85) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_ResourceRatingTier_Response(Message* msg, uint32_t* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 85) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_RewrapDeviceRSAKey30_Request(
|
|
Message* msg, OEMCrypto_SESSION* session, uint32_t** unaligned_nonce,
|
|
SharedMemory** encrypted_message_key, size_t* encrypted_message_key_length,
|
|
SharedMemory** enc_rsa_key, size_t* enc_rsa_key_length,
|
|
uint8_t** enc_rsa_key_iv, uint8_t** wrapped_rsa_key,
|
|
size_t** wrapped_rsa_key_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 51) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, encrypted_message_key_length);
|
|
ODK_Unpack_size_t(msg, enc_rsa_key_length);
|
|
ODK_UnpackNullable_size_t(msg, wrapped_rsa_key_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
ODK_UnpackNullable_uint32_t(msg, unaligned_nonce);
|
|
*encrypted_message_key = ODK_UnpackSharedBuffer(
|
|
msg, 0, LengthFromSizeTPointer(encrypted_message_key_length));
|
|
*enc_rsa_key = ODK_UnpackSharedBuffer(
|
|
msg, 1, LengthFromSizeTPointer(enc_rsa_key_length));
|
|
ODK_UnpackNullable_uint8_t(msg, enc_rsa_key_iv);
|
|
*wrapped_rsa_key = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTDoublePointer(wrapped_rsa_key_length),
|
|
sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_RewrapDeviceRSAKey30_Response(Message* msg,
|
|
OEMCryptoResult* result,
|
|
uint8_t** wrapped_rsa_key,
|
|
size_t** wrapped_rsa_key_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 51) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, wrapped_rsa_key_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *wrapped_rsa_key) {
|
|
memcpy(
|
|
*wrapped_rsa_key, p,
|
|
LengthAsSizeT(LengthFromSizeTDoublePointer(wrapped_rsa_key_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_RewrapDeviceRSAKey_Response(Message* msg,
|
|
OEMCryptoResult* result,
|
|
uint8_t** wrapped_rsa_key,
|
|
size_t** wrapped_rsa_key_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 18) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, wrapped_rsa_key_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *wrapped_rsa_key) {
|
|
memcpy(
|
|
*wrapped_rsa_key, p,
|
|
LengthAsSizeT(LengthFromSizeTDoublePointer(wrapped_rsa_key_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadDeviceRSAKey_Request(Message* msg,
|
|
OEMCrypto_SESSION* session,
|
|
SharedMemory** wrapped_rsa_key,
|
|
size_t* wrapped_rsa_key_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 19) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, wrapped_rsa_key_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*wrapped_rsa_key = ODK_UnpackSharedBuffer(
|
|
msg, 0, LengthFromSizeTPointer(wrapped_rsa_key_length));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadDeviceRSAKey_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 19) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadTestRSAKey_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 45) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadTestRSAKey_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 45) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GenerateRSASignature_Request(
|
|
Message* msg, OEMCrypto_SESSION* session, SharedMemory** message,
|
|
size_t* message_length, uint8_t** signature, size_t** signature_length,
|
|
RSA_Padding_Scheme* padding_scheme) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 36) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, message_length);
|
|
ODK_UnpackNullable_size_t(msg, signature_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*message =
|
|
ODK_UnpackSharedBuffer(msg, 0, LengthFromSizeTPointer(message_length));
|
|
*signature = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTDoublePointer(signature_length), sizeof(uint8_t));
|
|
ODK_Unpack_uint8_t(msg, padding_scheme);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GenerateRSASignature_Response(Message* msg,
|
|
OEMCryptoResult* result,
|
|
uint8_t** signature,
|
|
size_t** signature_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 36) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, signature_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *signature) {
|
|
memcpy(*signature, p,
|
|
LengthAsSizeT(LengthFromSizeTDoublePointer(signature_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_CreateUsageTableHeader_Request(Message* msg,
|
|
uint8_t** header_buffer,
|
|
size_t** header_buffer_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 61) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, header_buffer_length);
|
|
*header_buffer = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTDoublePointer(header_buffer_length), sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_CreateUsageTableHeader_Response(Message* msg,
|
|
OEMCryptoResult* result,
|
|
uint8_t** header_buffer,
|
|
size_t** header_buffer_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 61) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, header_buffer_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *header_buffer) {
|
|
memcpy(*header_buffer, p,
|
|
LengthAsSizeT(LengthFromSizeTDoublePointer(header_buffer_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadUsageTableHeader_Request(Message* msg, uint8_t** buffer,
|
|
size_t* buffer_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 62) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, buffer_length);
|
|
ODK_UnpackPointerToMemory(msg, buffer);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadUsageTableHeader_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 62) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_CreateNewUsageEntry_Request(Message* msg,
|
|
OEMCrypto_SESSION* session,
|
|
uint32_t** usage_entry_number) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 63) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*usage_entry_number = (uint32_t*)ODK_UnpackAlloc(msg, sizeof(uint32_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_CreateNewUsageEntry_Response(Message* msg,
|
|
OEMCryptoResult* result,
|
|
uint32_t** usage_entry_number) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 63) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackNullable_uint32_t(msg, usage_entry_number);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadUsageEntry_Request(Message* msg, OEMCrypto_SESSION* session,
|
|
uint32_t* usage_entry_number,
|
|
uint8_t** buffer,
|
|
size_t* buffer_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 64) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, buffer_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
ODK_Unpack_uint32_t(msg, usage_entry_number);
|
|
ODK_UnpackPointerToMemory(msg, buffer);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_LoadUsageEntry_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 64) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_UpdateUsageEntry_Request(Message* msg,
|
|
OEMCrypto_SESSION* session,
|
|
SharedMemory** header_buffer,
|
|
size_t** header_buffer_length,
|
|
SharedMemory** entry_buffer,
|
|
size_t** entry_buffer_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 65) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, header_buffer_length);
|
|
ODK_UnpackNullable_size_t(msg, entry_buffer_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*header_buffer = ODK_UnpackSharedBuffer(
|
|
msg, 0, LengthFromSizeTDoublePointer(header_buffer_length));
|
|
*entry_buffer = ODK_UnpackSharedBuffer(
|
|
msg, 1, LengthFromSizeTDoublePointer(entry_buffer_length));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_UpdateUsageEntry_Response(Message* msg, OEMCryptoResult* result,
|
|
SharedMemory** header_buffer,
|
|
size_t** header_buffer_length,
|
|
SharedMemory** entry_buffer,
|
|
size_t** entry_buffer_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 65) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, header_buffer_length);
|
|
ODK_UnpackNullable_size_t(msg, entry_buffer_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
ODK_UnpackSharedOutputBuffer(
|
|
msg, 0, header_buffer,
|
|
LengthFromSizeTDoublePointer(header_buffer_length));
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
ODK_UnpackSharedOutputBuffer(
|
|
msg, 1, entry_buffer,
|
|
LengthFromSizeTDoublePointer(entry_buffer_length));
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_DeactivateUsageEntry_Request(Message* msg,
|
|
OEMCrypto_SESSION* session,
|
|
uint8_t** pst,
|
|
size_t* pst_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 66) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, pst_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
ODK_UnpackPointerToMemory(msg, pst);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_DeactivateUsageEntry_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 66) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_ReportUsage_Request(Message* msg, OEMCrypto_SESSION* session,
|
|
uint8_t** pst, size_t* pst_length,
|
|
uint8_t** buffer, size_t** buffer_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 32) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, pst_length);
|
|
ODK_UnpackNullable_size_t(msg, buffer_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
ODK_UnpackPointerToMemory(msg, pst);
|
|
*buffer = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTDoublePointer(buffer_length), sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_ReportUsage_Response(Message* msg, OEMCryptoResult* result,
|
|
uint8_t** buffer, size_t** buffer_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 32) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, buffer_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *buffer) {
|
|
memcpy(*buffer, p,
|
|
LengthAsSizeT(LengthFromSizeTDoublePointer(buffer_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_DeleteUsageEntry_Request(
|
|
Message* msg, OEMCrypto_SESSION* session, uint8_t** pst, size_t* pst_length,
|
|
uint8_t** message, size_t* message_length, uint8_t** signature,
|
|
size_t* signature_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 33) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, pst_length);
|
|
ODK_Unpack_size_t(msg, message_length);
|
|
ODK_Unpack_size_t(msg, signature_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
ODK_UnpackPointerToMemory(msg, pst);
|
|
ODK_UnpackPointerToMemory(msg, message);
|
|
ODK_UnpackPointerToMemory(msg, signature);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_DeleteUsageEntry_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 33) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_ForceDeleteUsageEntry_Request(Message* msg, uint8_t** pst,
|
|
size_t* pst_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 43) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, pst_length);
|
|
ODK_UnpackPointerToMemory(msg, pst);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_ForceDeleteUsageEntry_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 43) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_MoveEntry_Request(Message* msg, OEMCrypto_SESSION* session,
|
|
uint32_t* new_index) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 68) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
ODK_Unpack_uint32_t(msg, new_index);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_MoveEntry_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 68) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_ShrinkUsageTableHeader_Request(Message* msg,
|
|
uint32_t* new_entry_count,
|
|
uint8_t** header_buffer,
|
|
size_t** header_buffer_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 67) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, header_buffer_length);
|
|
ODK_Unpack_uint32_t(msg, new_entry_count);
|
|
*header_buffer = (uint8_t*)ODK_UnpackAllocBuffer(
|
|
msg, LengthFromSizeTDoublePointer(header_buffer_length), sizeof(uint8_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_ShrinkUsageTableHeader_Response(Message* msg,
|
|
OEMCryptoResult* result,
|
|
uint8_t** header_buffer,
|
|
size_t** header_buffer_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 67) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackNullable_size_t(msg, header_buffer_length);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
if (SuccessResult(*result)) {
|
|
uint8_t* p;
|
|
ODK_UnpackPointerToMemory(msg, &p);
|
|
if (p && *header_buffer) {
|
|
memcpy(*header_buffer, p,
|
|
LengthAsSizeT(LengthFromSizeTDoublePointer(header_buffer_length)));
|
|
}
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_CopyOldUsageEntry_Request(Message* msg,
|
|
OEMCrypto_SESSION* session,
|
|
uint8_t** pst, size_t* pst_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 69) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, pst_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
ODK_UnpackPointerToMemory(msg, pst);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_CopyOldUsageEntry_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 69) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_DeleteOldUsageTable_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 34) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_DeleteOldUsageTable_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 34) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_RemoveSRM_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 57) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_RemoveSRM_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 57) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_CreateOldUsageEntry_Request(
|
|
Message* msg, uint64_t* time_since_license_received,
|
|
uint64_t* time_since_first_decrypt, uint64_t* time_since_last_decrypt,
|
|
OEMCrypto_Usage_Entry_Status* status, uint8_t* server_mac_key,
|
|
uint8_t* client_mac_key, uint8_t** pst, size_t* pst_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 70) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, pst_length);
|
|
ODK_Unpack_uint64_t(msg, time_since_license_received);
|
|
ODK_Unpack_uint64_t(msg, time_since_first_decrypt);
|
|
ODK_Unpack_uint64_t(msg, time_since_last_decrypt);
|
|
ODK_Unpack_uint32_t(msg, status);
|
|
if (!Is_Valid_OEMCrypto_Usage_Entry_Status(*status)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackArray(msg, &server_mac_key[0], 32);
|
|
ODK_UnpackArray(msg, &client_mac_key[0], 32);
|
|
ODK_UnpackPointerToMemory(msg, pst);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_CreateOldUsageEntry_Response(Message* msg,
|
|
OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 70) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SupportsDecryptHash_Request(Message* msg) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 86) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SupportsDecryptHash_Response(Message* msg, uint32_t* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 86) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SetDecryptHash_Request(Message* msg, OEMCrypto_SESSION* session,
|
|
uint32_t* frame_number, uint8_t** hash,
|
|
size_t* hash_length) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 88) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_size_t(msg, hash_length);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
ODK_Unpack_uint32_t(msg, frame_number);
|
|
ODK_UnpackPointerToMemory(msg, hash);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_SetDecryptHash_Response(Message* msg, OEMCryptoResult* result) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 88) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetHashErrorCode_Request(Message* msg,
|
|
OEMCrypto_SESSION* session,
|
|
uint32_t** failed_frame_number) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 89) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, session);
|
|
*failed_frame_number = (uint32_t*)ODK_UnpackAlloc(msg, sizeof(uint32_t));
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_Unpack_GetHashErrorCode_Response(Message* msg, OEMCryptoResult* result,
|
|
uint32_t** failed_frame_number) {
|
|
uint32_t api_value = UINT32_MAX;
|
|
ODK_Unpack_uint32_t(msg, &api_value);
|
|
if (api_value != 89) SetStatus(msg, MESSAGE_STATUS_API_VALUE_ERROR);
|
|
ODK_Unpack_uint32_t(msg, result);
|
|
if (!Is_Valid_OEMCryptoResult(*result)) {
|
|
SetStatus(msg, MESSAGE_STATUS_INVALID_ENUM_VALUE);
|
|
}
|
|
ODK_UnpackNullable_uint32_t(msg, failed_frame_number);
|
|
ODK_UnpackEOM(msg);
|
|
}
|
|
|
|
void ODK_UnpackNullable_c_str(Message* msg, char** value) {
|
|
if (ODK_UnpackIsNull(msg)) {
|
|
*value = NULL;
|
|
} else {
|
|
ODK_Unpack_c_str(msg, value);
|
|
}
|
|
}
|
|
void ODK_UnpackAlloc_c_str(Message* msg, char** value) {
|
|
*value = (char*)ODK_UnpackAlloc(msg, sizeof(char));
|
|
if (*value) {
|
|
ODK_Unpack_c_str(msg, value);
|
|
}
|
|
}
|
|
void ODK_UnpackNullable_uint32_t(Message* msg, OEMCrypto_SESSION** value) {
|
|
if (ODK_UnpackIsNull(msg)) {
|
|
*value = NULL;
|
|
} else {
|
|
ODK_Unpack_uint32_t(msg, *value);
|
|
}
|
|
}
|
|
void ODK_UnpackAlloc_uint32_t(Message* msg, OEMCrypto_SESSION** value) {
|
|
*value = (OEMCrypto_SESSION*)ODK_UnpackAlloc(msg, sizeof(OEMCrypto_SESSION));
|
|
if (*value) {
|
|
ODK_Unpack_uint32_t(msg, *value);
|
|
}
|
|
}
|
|
void ODK_UnpackNullable_size_t(Message* msg, size_t** value) {
|
|
if (ODK_UnpackIsNull(msg)) {
|
|
*value = NULL;
|
|
} else {
|
|
ODK_Unpack_size_t(msg, *value);
|
|
}
|
|
}
|
|
void ODK_UnpackNullable_OEMCrypto_DestBufferDesc(
|
|
Message* msg, OEMCrypto_DestBufferDesc** value) {
|
|
if (ODK_UnpackIsNull(msg)) {
|
|
*value = NULL;
|
|
} else {
|
|
ODK_Unpack_OEMCrypto_DestBufferDesc(msg, *value);
|
|
}
|
|
}
|
|
void ODK_UnpackNullable_OEMCrypto_CENCEncryptPatternDesc(
|
|
Message* msg, OEMCrypto_CENCEncryptPatternDesc** value) {
|
|
if (ODK_UnpackIsNull(msg)) {
|
|
*value = NULL;
|
|
} else {
|
|
ODK_Unpack_OEMCrypto_CENCEncryptPatternDesc(msg, *value);
|
|
}
|
|
}
|
|
void ODK_UnpackAlloc_size_t(Message* msg, size_t** value) {
|
|
*value = (size_t*)ODK_UnpackAlloc(msg, sizeof(size_t));
|
|
if (*value) {
|
|
ODK_Unpack_size_t(msg, *value);
|
|
}
|
|
}
|
|
void ODK_UnpackNullable_uint16_t(Message* msg, uint16_t** value) {
|
|
if (ODK_UnpackIsNull(msg)) {
|
|
*value = NULL;
|
|
} else {
|
|
ODK_Unpack_uint16_t(msg, *value);
|
|
}
|
|
}
|
|
void ODK_UnpackAlloc_uint16_t(Message* msg, uint16_t** value) {
|
|
*value = (uint16_t*)ODK_UnpackAlloc(msg, sizeof(uint16_t));
|
|
if (*value) {
|
|
ODK_Unpack_uint16_t(msg, *value);
|
|
}
|
|
}
|
|
void ODK_UnpackNullable_uint8_t(Message* msg, uint8_t** value) {
|
|
if (ODK_UnpackIsNull(msg)) {
|
|
*value = NULL;
|
|
} else {
|
|
ODK_Unpack_uint8_t(msg, *value);
|
|
}
|
|
}
|