// Copyright 2022 Google LLC. All Rights Reserved. This file and proprietary
// source code may only be used and distributed under the Widevine License
// Agreement.

#include "OEMCryptoCENC.h"
#include "wv_attributes.h"

#pragma message( \
    "Warning: The Widevine CE CDM does not include an implementation of \
OEMCrypto. You must provide your own implementation. If you have access to the \
OEMCrypto repository, you can use an implementation from there. Otherwise, you \
will need to acquire an implementation from your SoC vendor. This build should \
successfully compile and link, but the resulting binary will fail the unit \
tests.")

OEMCryptoResult OEMCrypto_SetSandbox(const uint8_t* sandbox_id UNUSED,
                                     size_t sandbox_id_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_Initialize(void) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_Terminate(void) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_Idle(OEMCrypto_IdleState state UNUSED,
                               uint32_t os_specific_code UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_Wake(void) { return OEMCrypto_ERROR_NOT_IMPLEMENTED; }

OEMCryptoResult OEMCrypto_OpenSession(OEMCrypto_SESSION* session UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_CloseSession(OEMCrypto_SESSION session UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_CreateEntitledKeySession(
    OEMCrypto_SESSION oec_session UNUSED,
    OEMCrypto_SESSION* key_session UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_RemoveEntitledKeySession(
    OEMCrypto_SESSION key_session UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GenerateDerivedKeys(
    OEMCrypto_SESSION session UNUSED,
    const OEMCrypto_SharedMemory* mac_key_context UNUSED,
    size_t mac_key_context_length UNUSED,
    const OEMCrypto_SharedMemory* enc_key_context UNUSED,
    size_t enc_key_context_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_DeriveKeysFromSessionKey(
    OEMCrypto_SESSION session UNUSED, const uint8_t* derivation_key UNUSED,
    size_t derivation_key_length UNUSED,
    const OEMCrypto_SharedMemory* mac_key_context UNUSED,
    size_t mac_key_context_length UNUSED,
    const OEMCrypto_SharedMemory* enc_key_context UNUSED,
    size_t enc_key_context_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session UNUSED,
                                        uint32_t* nonce UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_PrepAndSignLicenseRequest(
    OEMCrypto_SESSION session UNUSED, uint8_t* message UNUSED,
    size_t message_length UNUSED, size_t* core_message_size UNUSED,
    uint8_t* signature UNUSED, size_t* signature_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_PrepAndSignRenewalRequest(
    OEMCrypto_SESSION session UNUSED, uint8_t* message UNUSED,
    size_t message_length UNUSED, size_t* core_message_size UNUSED,
    uint8_t* signature UNUSED, size_t* signature_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadKeys(
    OEMCrypto_SESSION session UNUSED, const uint8_t* message UNUSED,
    size_t message_length UNUSED, const uint8_t* signature UNUSED,
    size_t signature_length UNUSED, OEMCrypto_Substring enc_mac_keys_iv UNUSED,
    OEMCrypto_Substring enc_mac_keys UNUSED, size_t key_array_length UNUSED,
    const OEMCrypto_KeyObject* key_array UNUSED, OEMCrypto_Substring pst UNUSED,
    OEMCrypto_Substring srm_restriction_data UNUSED,
    OEMCrypto_LicenseType license_type UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadLicense_V18(OEMCrypto_SESSION session UNUSED,
                                          const uint8_t* message UNUSED,
                                          size_t message_length UNUSED,
                                          size_t core_message_length UNUSED,
                                          const uint8_t* signature UNUSED,
                                          size_t signature_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadEntitledContentKeys(
    OEMCrypto_SESSION session UNUSED, const uint8_t* message UNUSED,
    size_t message_length UNUSED, size_t key_array_length UNUSED,
    const OEMCrypto_EntitledContentKeyObject* key_array UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_RefreshKeys(
    OEMCrypto_SESSION session UNUSED, const uint8_t* message UNUSED,
    size_t message_length UNUSED, const uint8_t* signature UNUSED,
    size_t signature_length UNUSED, size_t num_keys UNUSED,
    const OEMCrypto_KeyRefreshObject* key_array UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadRenewal(OEMCrypto_SESSION session UNUSED,
                                      const uint8_t* message UNUSED,
                                      size_t message_length UNUSED,
                                      size_t core_message_length UNUSED,
                                      const uint8_t* signature UNUSED,
                                      size_t signature_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_QueryKeyControl(
    OEMCrypto_SESSION session UNUSED, const uint8_t* content_key_id UNUSED,
    size_t content_key_id_length UNUSED, uint8_t* key_control_block UNUSED,
    size_t* key_control_block_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetKeyHandle(OEMCrypto_SESSION session UNUSED,
                                       const uint8_t* content_key_id UNUSED,
                                       size_t content_key_id_length UNUSED,
                                       OEMCryptoCipherMode cipher_mode UNUSED,
                                       uint8_t* key_handle UNUSED,
                                       size_t* key_handle_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_DecryptCENC(
    const uint8_t* key_handle UNUSED, size_t key_handle_length UNUSED,
    const OEMCrypto_SampleDescription* samples UNUSED,
    size_t samples_length UNUSED,
    const OEMCrypto_CENCEncryptPatternDesc* pattern UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_CopyBuffer(
    OEMCrypto_SESSION session UNUSED,
    const OEMCrypto_SharedMemory* data_addr UNUSED,
    size_t data_addr_length UNUSED,
    const OEMCrypto_DestBufferDesc* out_buffer_descriptor UNUSED,
    uint8_t subsample_flags UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_Generic_Encrypt(
    const uint8_t* key_handle UNUSED, size_t key_handle_length UNUSED,
    const OEMCrypto_SharedMemory* in_buffer UNUSED,
    size_t in_buffer_length UNUSED, const uint8_t* iv UNUSED,
    OEMCrypto_Algorithm algorithm UNUSED,
    OEMCrypto_SharedMemory* out_buffer UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_Generic_Decrypt(
    const uint8_t* key_handle UNUSED, size_t key_handle_length UNUSED,
    const OEMCrypto_SharedMemory* in_buffer UNUSED,
    size_t in_buffer_length UNUSED, const uint8_t* iv UNUSED,
    OEMCrypto_Algorithm algorithm UNUSED,
    OEMCrypto_SharedMemory* out_buffer UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_Generic_Sign(
    const uint8_t* key_handle UNUSED, size_t key_handle_length UNUSED,
    const OEMCrypto_SharedMemory* buffer UNUSED, size_t buffer_length UNUSED,
    OEMCrypto_Algorithm algorithm UNUSED,
    OEMCrypto_SharedMemory* signature UNUSED, size_t* signature_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_Generic_Verify(
    const uint8_t* key_handle UNUSED, size_t key_handle_length UNUSED,
    const OEMCrypto_SharedMemory* buffer UNUSED, size_t buffer_length UNUSED,
    OEMCrypto_Algorithm algorithm UNUSED,
    const OEMCrypto_SharedMemory* signature UNUSED,
    size_t signature_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_WrapKeyboxOrOEMCert(
    const uint8_t* keybox_or_cert UNUSED, size_t keybox_or_cert_length UNUSED,
    uint8_t* wrapped_keybox_or_cert UNUSED,
    size_t* wrapped_keybox_or_cert_length UNUSED,
    const uint8_t* transport_key UNUSED, size_t transport_key_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_InstallKeyboxOrOEMCert(
    const uint8_t* keybox_or_cert UNUSED, size_t keybox_or_cert_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod(void) {
  return OEMCrypto_ProvisioningError;
}

OEMCryptoResult OEMCrypto_IsKeyboxOrOEMCertValid(void) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* device_id UNUSED,
                                      size_t* device_id_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* key_data UNUSED,
                                     size_t* key_data_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadTestKeybox(const uint8_t* buffer UNUSED,
                                         size_t buffer_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadOEMPrivateKey(OEMCrypto_SESSION session UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetOEMPublicCertificate(
    uint8_t* public_cert UNUSED, size_t* public_cert_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetRandom(uint8_t* random_data UNUSED,
                                    size_t random_data_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

uint32_t OEMCrypto_APIVersion(void) { return 0; }

uint32_t OEMCrypto_MinorAPIVersion(void) { return 0; }

OEMCryptoResult OEMCrypto_BuildInformation(char* buffer UNUSED,
                                           size_t* buffer_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

uint8_t OEMCrypto_Security_Patch_Level(void) { return 0; }

OEMCrypto_Security_Level OEMCrypto_SecurityLevel(void) {
  return OEMCrypto_Level_Unknown;
}

OEMCryptoResult OEMCrypto_GetHDCPCapability(
    OEMCrypto_HDCP_Capability* current UNUSED,
    OEMCrypto_HDCP_Capability* maximum UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetDTCP2Capability(
    OEMCrypto_DTCP2_Capability* capability UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

bool OEMCrypto_SupportsUsageTable(void) { return false; }

size_t OEMCrypto_MaximumUsageTableHeaderSize(void) { return 0; }

bool OEMCrypto_IsAntiRollbackHwPresent(void) { return false; }

OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(size_t* count UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(size_t* max UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

uint32_t OEMCrypto_SupportedCertificates(void) { return 0; }

OEMCryptoResult OEMCrypto_GetCurrentSRMVersion(uint16_t* version UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

uint32_t OEMCrypto_GetAnalogOutputFlags(void) { return 0; }

uint32_t OEMCrypto_ResourceRatingTier(void) { return 0; }

OEMCryptoResult OEMCrypto_ProductionReady(void) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCrypto_WatermarkingSupport OEMCrypto_GetWatermarkingSupport(void) {
  return OEMCrypto_WatermarkingError;
}

OEMCryptoResult OEMCrypto_GetSignatureHashAlgorithm(
    OEMCrypto_SESSION session UNUSED,
    OEMCrypto_SignatureHashAlgorithm* algorithm UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadProvisioning_V18(
    OEMCrypto_SESSION session UNUSED, const uint8_t* message UNUSED,
    size_t message_length UNUSED, size_t core_message_length UNUSED,
    const uint8_t* signature UNUSED, size_t signature_length UNUSED,
    uint8_t* wrapped_private_key UNUSED,
    size_t* wrapped_private_key_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadDRMPrivateKey(
    OEMCrypto_SESSION session UNUSED, OEMCrypto_PrivateKeyType key_type UNUSED,
    const uint8_t* wrapped_private_key UNUSED,
    size_t wrapped_private_key_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadTestRSAKey(void) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GenerateRSASignature(
    OEMCrypto_SESSION session UNUSED, const uint8_t* message UNUSED,
    size_t message_length UNUSED, uint8_t* signature UNUSED,
    size_t* signature_length UNUSED, RSA_Padding_Scheme padding_scheme UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_PrepAndSignProvisioningRequest(
    OEMCrypto_SESSION session UNUSED, uint8_t* message UNUSED,
    size_t message_length UNUSED, size_t* core_message_size UNUSED,
    uint8_t* signature UNUSED, size_t* signature_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_CreateUsageTableHeader(
    uint8_t* header_buffer UNUSED, size_t* header_buffer_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadUsageTableHeader(const uint8_t* buffer UNUSED,
                                               size_t buffer_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_CreateNewUsageEntry(
    OEMCrypto_SESSION session UNUSED, uint32_t* usage_entry_number UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_ReuseUsageEntry(OEMCrypto_SESSION session UNUSED,
                                          uint32_t usage_entry_number UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadUsageEntry(OEMCrypto_SESSION session UNUSED,
                                         uint32_t usage_entry_number UNUSED,
                                         const uint8_t* buffer UNUSED,
                                         size_t buffer_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_UpdateUsageEntry(
    OEMCrypto_SESSION session UNUSED,
    OEMCrypto_SharedMemory* header_buffer UNUSED,
    size_t* header_buffer_length UNUSED,
    OEMCrypto_SharedMemory* entry_buffer UNUSED,
    size_t* entry_buffer_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_DeactivateUsageEntry(OEMCrypto_SESSION session UNUSED,
                                               const uint8_t* pst UNUSED,
                                               size_t pst_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_ReportUsage(OEMCrypto_SESSION session UNUSED,
                                      const uint8_t* pst UNUSED,
                                      size_t pst_length UNUSED,
                                      uint8_t* buffer UNUSED,
                                      size_t* buffer_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_MoveEntry(OEMCrypto_SESSION session UNUSED,
                                    uint32_t new_index UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(
    uint32_t new_entry_count UNUSED, uint8_t* header_buffer UNUSED,
    size_t* header_buffer_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetBootCertificateChain(
    uint8_t* bcc UNUSED, size_t* bcc_length UNUSED,
    uint8_t* additional_signature UNUSED,
    size_t* additional_signature_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GenerateCertificateKeyPair(
    OEMCrypto_SESSION session UNUSED, uint8_t* public_key UNUSED,
    size_t* public_key_length UNUSED, uint8_t* public_key_signature UNUSED,
    size_t* public_key_signature_length UNUSED,
    uint8_t* wrapped_private_key UNUSED,
    size_t* wrapped_private_key_length UNUSED,
    OEMCrypto_PrivateKeyType* key_type UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

uint32_t OEMCrypto_SupportsDecryptHash(void) { return 0; }

OEMCryptoResult OEMCrypto_SetDecryptHash(OEMCrypto_SESSION session UNUSED,
                                         uint32_t frame_number UNUSED,
                                         const uint8_t* hash UNUSED,
                                         size_t hash_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetHashErrorCode(
    OEMCrypto_SESSION session UNUSED, uint32_t* failed_frame_number UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_AllocateSecureBuffer(
    OEMCrypto_SESSION session UNUSED, size_t buffer_size UNUSED,
    OEMCrypto_DestBufferDesc* output_descriptor UNUSED, int* secure_fd UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_FreeSecureBuffer(
    OEMCrypto_SESSION session UNUSED,
    OEMCrypto_DestBufferDesc* output_descriptor UNUSED, int secure_fd UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_InstallOemPrivateKey(
    OEMCrypto_SESSION session UNUSED, OEMCrypto_PrivateKeyType key_type UNUSED,
    const uint8_t* wrapped_private_key UNUSED,
    size_t wrapped_private_key_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_ReassociateEntitledKeySession(
    OEMCrypto_SESSION key_session UNUSED,
    OEMCrypto_SESSION oec_session UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadCasECMKeys(
    OEMCrypto_SESSION session UNUSED, const uint8_t* message UNUSED,
    size_t message_length UNUSED,
    const OEMCrypto_EntitledContentKeyObject* even_key UNUSED,
    const OEMCrypto_EntitledContentKeyObject* odd_key UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_OPK_SerializationVersion(uint32_t* ree_major UNUSED,
                                                   uint32_t* ree_minor UNUSED,
                                                   uint32_t* tee_major UNUSED,
                                                   uint32_t* tee_minor UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GenerateOTARequest(OEMCrypto_SESSION session UNUSED,
                                             uint8_t* buffer UNUSED,
                                             size_t* buffer_length UNUSED,
                                             uint32_t use_test_key UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_ProcessOTAKeybox(OEMCrypto_SESSION session UNUSED,
                                           const uint8_t* buffer UNUSED,
                                           size_t buffer_length UNUSED,
                                           uint32_t use_test_key UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetOEMKeyToken(OEMCrypto_SESSION key_session UNUSED,
                                         uint8_t* key_token UNUSED,
                                         size_t* key_token_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_SetSessionUsage(OEMCrypto_SESSION session UNUSED,
                                          uint32_t intent UNUSED,
                                          uint32_t mode UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetPVRKey(OEMCrypto_SESSION session UNUSED,
                                    uint8_t* wrapped_pvr_key UNUSED,
                                    size_t* wrapped_pvr_key_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadPVRKey(OEMCrypto_SESSION session UNUSED,
                                     const uint8_t* wrapped_pvr_key UNUSED,
                                     size_t wrapped_pvr_key_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetDeviceInformation(
    uint8_t* device_info UNUSED, size_t* device_info_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetDeviceSignedCsrPayload(
    const uint8_t* challenge UNUSED, size_t challenge_length UNUSED,
    const uint8_t* encoded_device_info UNUSED,
    size_t encoded_device_info_length UNUSED,
    uint8_t* signed_csr_payload UNUSED,
    size_t* signed_csr_payload_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_SetMaxAPIVersion(uint32_t max_version UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_EnterTestMode(void) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_SetDecryptHash(OEMCrypto_SESSION session UNUSED,
                                         uint32_t frame_number UNUSED,
                                         uint32_t crc32 UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadLicense(
    OEMCrypto_SESSION session UNUSED, const uint8_t* context UNUSED,
    size_t context_length UNUSED, const uint8_t* derivation_key UNUSED,
    size_t derivation_key_length UNUSED, const uint8_t* message UNUSED,
    size_t message_length UNUSED, size_t core_message_length UNUSED,
    const uint8_t* signature UNUSED, size_t signature_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadProvisioning(
    OEMCrypto_SESSION session UNUSED, const uint8_t* provision_request UNUSED,
    size_t provision_request_length UNUSED, const uint8_t* message UNUSED,
    size_t message_length UNUSED, size_t core_message_length UNUSED,
    const uint8_t* signature UNUSED, size_t signature_length UNUSED,
    uint8_t* wrapped_private_key UNUSED,
    size_t* wrapped_private_key_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadProvisioningCast(
    OEMCrypto_SESSION session UNUSED, const uint8_t* derivation_key UNUSED,
    size_t derivation_key_length UNUSED,
    const uint8_t* provision_request UNUSED,
    size_t provision_request_length UNUSED, const uint8_t* message UNUSED,
    size_t message_length UNUSED, size_t core_message_length UNUSED,
    const uint8_t* signature UNUSED, size_t signature_length UNUSED,
    uint8_t* wrapped_private_key UNUSED,
    size_t* wrapped_private_key_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_PrepAndSignReleaseRequest(
    OEMCrypto_SESSION session UNUSED, uint8_t* message UNUSED,
    size_t message_length UNUSED, size_t* core_message_size UNUSED,
    uint8_t* signature UNUSED, size_t* signature_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetUsageEntryInfo(
    OEMCrypto_SESSION session UNUSED,
    OEMCrypto_Usage_Entry_Status* status UNUSED,
    int64_t* seconds_since_license_received UNUSED,
    int64_t* seconds_since_first_decrypt UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetBCCType(OEMCrypto_BCCType* bcc_type UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetBCCSignatureType(
    OEMCrypto_BCCSignatureType* bcc_signature_type UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadRelease(OEMCrypto_SESSION session UNUSED,
                                      const uint8_t* message UNUSED,
                                      size_t message_length UNUSED,
                                      size_t core_message_length UNUSED,
                                      const uint8_t* signature UNUSED,
                                      size_t signature_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetEmbeddedDrmCertificate(
    uint8_t* public_cert UNUSED, size_t* public_cert_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_UseSecondaryKey(OEMCrypto_SESSION session_id UNUSED,
                                          bool dual_key UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_WrapClearPrivateKey(
    const uint8_t* clear_private_key_bytes UNUSED,
    size_t clear_private_key_length UNUSED, uint8_t* wrapped_private_key UNUSED,
    size_t* wrapped_private_key_length UNUSED) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}