oemcrypto_v13/oemcrypto/stubs/v11/stubs.cc

// Copyright 2016 Google Inc. All Rights Reserved.

#include "OEMCryptoCENC.h"

OEMCryptoResult OEMCrypto_Initialize(void) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_Terminate(void) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

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

OEMCryptoResult OEMCrypto_CloseSession(OEMCrypto_SESSION session) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GenerateDerivedKeys(
                            OEMCrypto_SESSION session,
                            const uint8_t *mac_key_context,
                            uint32_t mac_key_context_length,
                            const uint8_t *enc_key_context,
                            uint32_t enc_key_context_length) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

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

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

OEMCryptoResult OEMCrypto_LoadKeys(OEMCrypto_SESSION session,
                                   const uint8_t* message,
                                   size_t message_length,
                                   const uint8_t* signature,
                                   size_t signature_length,
                                   const uint8_t* enc_mac_keys_iv,
                                   const uint8_t* enc_mac_keys,
                                   size_t num_keys,
                                   const OEMCrypto_KeyObject* key_array,
                                   const uint8_t* pst,
                                   size_t pst_length) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

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

OEMCryptoResult
OEMCrypto_QueryKeyControl(OEMCrypto_SESSION session,
                          const uint8_t* key_id,
                          size_t key_id_length,
                          uint8_t* key_control_block,
                          size_t* key_control_block_length) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_SelectKey(OEMCrypto_SESSION session,
                                    const uint8_t* key_id,
                                    size_t key_id_length) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_DecryptCENC(OEMCrypto_SESSION session,
                                      const uint8_t *data_addr,
                                      size_t data_length,
                                      bool is_encrypted,
                                      const uint8_t *iv,
                                      size_t block_offset,
                                      OEMCrypto_DestBufferDesc* out_buffer,
                                      const OEMCrypto_CENCEncryptPatternDesc* pattern,
                                      uint8_t subsample_flags) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_CopyBuffer(const uint8_t *data_addr,
                                     size_t data_length,
                                     OEMCrypto_DestBufferDesc* out_buffer,
                                     uint8_t subsample_flags) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_WrapKeybox(const uint8_t *keybox,
                                     size_t keyBoxLength,
                                     uint8_t *wrappedKeybox,
                                     size_t *wrappedKeyBoxLength,
                                     const uint8_t *transportKey,
                                     size_t transportKeyLength) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_InstallKeybox(const uint8_t *keybox,
                                        size_t keyBoxLength) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadTestKeybox() {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_IsKeyboxValid(void) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID,
                                      size_t *idLength) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData,
                                     size_t *keyDataLength) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_GetRandom(uint8_t* randomData,
                                    size_t dataLength) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey(OEMCrypto_SESSION session,
                                             const uint8_t* message,
                                             size_t message_length,
                                             const uint8_t* signature,
                                             size_t signature_length,
                                             const uint32_t *nonce,
                                             const uint8_t* enc_rsa_key,
                                             size_t enc_rsa_key_length,
                                             const uint8_t* enc_rsa_key_iv,
                                             uint8_t* wrapped_rsa_key,
                                             size_t *wrapped_rsa_key_length) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadDeviceRSAKey(OEMCrypto_SESSION session,
                                           const uint8_t* wrapped_rsa_key,
                                           size_t wrapped_rsa_key_length) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_LoadTestRSAKey() {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

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

OEMCryptoResult OEMCrypto_DeriveKeysFromSessionKey(OEMCrypto_SESSION session,
                                                   const uint8_t* enc_session_key,
                                                   size_t enc_session_key_length,
                                                   const uint8_t *mac_key_context,
                                                   size_t mac_key_context_length,
                                                   const uint8_t *enc_key_context,
                                                   size_t enc_key_context_length) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

uint32_t OEMCrypto_APIVersion() {
  return 0;
}

uint8_t OEMCrypto_Security_Patch_Level() {
  return 0;
}

const char* OEMCrypto_SecurityLevel() {
  return NULL;
}

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

bool OEMCrypto_SupportsUsageTable() {
  return false;
}

bool OEMCrypto_IsAntiRollbackHwPresent() {
  return false;
}

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

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

OEMCryptoResult OEMCrypto_Generic_Encrypt(OEMCrypto_SESSION session,
                                          const uint8_t* in_buffer,
                                          size_t buffer_length,
                                          const uint8_t* iv,
                                          OEMCrypto_Algorithm algorithm,
                                          uint8_t* out_buffer) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_Generic_Decrypt(OEMCrypto_SESSION session,
                                          const uint8_t* in_buffer,
                                          size_t buffer_length,
                                          const uint8_t* iv,
                                          OEMCrypto_Algorithm algorithm,
                                          uint8_t* out_buffer) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_Generic_Sign(OEMCrypto_SESSION session,
                                       const uint8_t* in_buffer,
                                       size_t buffer_length,
                                       OEMCrypto_Algorithm algorithm,
                                       uint8_t* signature,
                                       size_t* signature_length) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_Generic_Verify(OEMCrypto_SESSION session,
                                         const uint8_t* in_buffer,
                                         size_t buffer_length,
                                         OEMCrypto_Algorithm algorithm,
                                         const uint8_t* signature,
                                         size_t signature_length) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_UpdateUsageTable() {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

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

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

OEMCryptoResult OEMCrypto_DeleteUsageEntry(OEMCrypto_SESSION session,
                                           const uint8_t* pst,
                                           size_t pst_length,
                                           const uint8_t *message,
                                           size_t message_length,
                                           const uint8_t *signature,
                                           size_t signature_length) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_ForceDeleteUsageEntry(const uint8_t* pst,
                                                size_t pst_length) {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}

OEMCryptoResult OEMCrypto_DeleteUsageTable() {
  return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}