/* Copyright 2015 The Chromium OS Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "Global.h"
#include "_TPM_Init_fp.h"
#include   "CryptoEngine.h"


CRYPT_RESULT _cpri__AESDecryptCBC(
  BYTE * dOut,                  // OUT: the decrypted data
  UINT32 keySizeInBits,         // IN: key size in bit
  BYTE * key,                   // IN: key buffer. The size of this buffer in
  //     bytes is (keySizeInBits + 7) / 8
  BYTE * iv,                    // IN/OUT: IV for decryption. The size of this
  //     buffer is 16 byte
  UINT32 dInSize,               // IN: data size
  BYTE * dIn)                   // IN: data buffer
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__AESDecryptCFB(
  BYTE * dOut,                  // OUT: the decrypted data
  UINT32 keySizeInBits,         // IN: key size in bit
  BYTE * key,                   // IN: key buffer. The size of this buffer in
  // bytes is (keySizeInBits + 7) / 8
  BYTE * iv,                    // IN/OUT: IV for decryption.
  UINT32 dInSize,               // IN: data size
  BYTE * dIn)                   // IN: data buffer
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__AESDecryptECB(
  BYTE * dOut,                  // OUT: the clear text data
  UINT32 keySizeInBits,         // IN: key size in bit
  BYTE * key,                   // IN: key buffer. The size of this buffer in
  // bytes is (keySizeInBits + 7) / 8
  UINT32 dInSize,               // IN: data size
  BYTE * dIn                    // IN: cipher text buffer
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__AESEncryptCBC(
  BYTE * dOut,                  // OUT:
  UINT32 keySizeInBits,         // IN: key size in bit
  BYTE * key,                   // IN: key buffer. The size of this buffer in
  // bytes is (keySizeInBits + 7) / 8
  BYTE * iv,                    // IN/OUT: IV for decryption.
  UINT32 dInSize,               // IN: data size (is required to be a multiple
  // of 16 bytes)
  BYTE * dIn                    // IN: data buffer
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__AESEncryptCFB(
  BYTE * dOut,                  // OUT: the encrypted
  UINT32 keySizeInBits,         // IN: key size in bit
  BYTE * key,                   // IN: key buffer. The size of this buffer in
  // bytes is (keySizeInBits + 7) / 8
  BYTE * iv,                    // IN/OUT: IV for decryption.
  UINT32 dInSize,               // IN: data size
  BYTE * dIn                    // IN: data buffer
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__AESEncryptCTR(
  BYTE * dOut,                  // OUT: the encrypted data
  UINT32 keySizeInBits,         // IN: key size in bit
  BYTE * key,                   // IN: key buffer. The size of this buffer in
  // bytes is (keySizeInBits + 7) / 8
  BYTE * iv,                    // IN/OUT: IV for decryption.
  UINT32 dInSize,               // IN: data size
  BYTE * dIn                    // IN: data buffer
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__AESEncryptECB(
  BYTE * dOut,                  // OUT: encrypted data
  UINT32 keySizeInBits,         // IN: key size in bit
  BYTE * key,                   // IN: key buffer. The size of this buffer in
  // bytes is (keySizeInBits + 7) / 8
  UINT32 dInSize,               // IN: data size
  BYTE * dIn                    // IN: clear text buffer
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__AESEncryptOFB(
  BYTE * dOut,                  // OUT: the encrypted/decrypted data
  UINT32 keySizeInBits,         // IN: key size in bit
  BYTE * key,                   // IN: key buffer. The size of this buffer in
  // bytes is (keySizeInBits + 7) / 8
  BYTE * iv,                    // IN/OUT: IV for decryption. The size of this
  // buffer is 16 byte
  UINT32 dInSize,               // IN: data size
  BYTE * dIn                    // IN: data buffer
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__C_2_2_KeyExchange(
  TPMS_ECC_POINT * outZ1,       //   OUT: a computed point
  TPMS_ECC_POINT * outZ2,       //   OUT: and optional second point
  TPM_ECC_CURVE curveId,        //   IN: the curve for the computations
  TPM_ALG_ID scheme,            //   IN: the key exchange scheme
  TPM2B_ECC_PARAMETER * dsA,    //   IN: static private TPM key
  TPM2B_ECC_PARAMETER * deA,    //   IN: ephemeral private TPM key
  TPMS_ECC_POINT * QsB,         //   IN: static public party B key
  TPMS_ECC_POINT * QeB          //   IN: ephemeral public party B key
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

UINT16 _cpri__CompleteHMAC(
  CPRI_HASH_STATE * hashState,  //   IN: the state of hash stack
  TPM2B * oPadKey,              //   IN: the HMAC key in oPad format
  UINT32 dOutSize,              //   IN: size of digest buffer
  BYTE * dOut                   //   OUT: hash digest
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

UINT16 _cpri__CompleteHash(
  CPRI_HASH_STATE * hashState,  // IN: the state of hash stack
  UINT32 dOutSize,              // IN: size of digest buffer
  BYTE * dOut                   // OUT: hash digest
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

CRYPT_RESULT _cpri__DecryptRSA(
  UINT32 * dOutSize,            //   OUT: the size of the decrypted data
  BYTE * dOut,                  //   OUT: the decrypted data
  RSA_KEY * key,                //   IN: the key to use for decryption
  TPM_ALG_ID padType,           //   IN: the type of padding
  UINT32 cInSize,               //   IN: the amount of data to decrypt
  BYTE * cIn,                   //   IN: the data to decrypt
  TPM_ALG_ID hashAlg,           //   IN: in case this is needed for the scheme
  const char *label             //   IN: in case it is needed for the scheme
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__DrbgGetPutState(
  GET_PUT direction,
  int bufferSize,
  BYTE * buffer)
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__EccCommitCompute(
  TPMS_ECC_POINT * K,           //   OUT: [d]B or [r]Q
  TPMS_ECC_POINT * L,           //   OUT: [r]B
  TPMS_ECC_POINT * E,           //   OUT: [r]M
  TPM_ECC_CURVE curveId,        //   IN: the curve for the computations
  TPMS_ECC_POINT * M,           //   IN: M (optional)
  TPMS_ECC_POINT * B,           //   IN: B (optional)
  TPM2B_ECC_PARAMETER * d,      //   IN: d (required)
  TPM2B_ECC_PARAMETER * r       //   IN: the computed r value (required)
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

UINT32 _cpri__EccGetCurveCount(
  void)
{
  ecprintf("%s called\n", __func__);
  return -1;
}

const ECC_CURVE *_cpri__EccGetParametersByCurveId(
  TPM_ECC_CURVE curveId         // IN: the curveID
  )
{
  ecprintf("%s called\n", __func__);
  return NULL;
}

BOOL _cpri__EccIsPointOnCurve(
  TPM_ECC_CURVE curveId,        // IN: the curve selector
  TPMS_ECC_POINT * Q            // IN: the point.
  )
{
  ecprintf("%s called\n", __func__);
  return 0;
}

CRYPT_RESULT _cpri__EccPointMultiply(
  TPMS_ECC_POINT * Rout,        //   OUT: the product point R
  TPM_ECC_CURVE curveId,        //   IN: the curve to use
  TPM2B_ECC_PARAMETER * dIn,    //   IN: value to multiply against the
  // curve generator
  TPMS_ECC_POINT * Qin,         //   IN: point Q
  TPM2B_ECC_PARAMETER * uIn     //   IN: scalar value for the multiplier of Q
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__EncryptRSA(
  UINT32 * cOutSize,            //   OUT: the size of the encrypted data
  BYTE * cOut,                  //   OUT: the encrypted data
  RSA_KEY * key,                //   IN: the key to use for encryption
  TPM_ALG_ID padType,           //   IN: the type of padding
  UINT32 dInSize,               //   IN: the amount of data to encrypt
  BYTE * dIn,                   //   IN: the data to encrypt
  TPM_ALG_ID hashAlg,           //   IN: in case this is needed
  const char *label             //   IN: in case it is needed
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__GenerateKeyEcc(
  TPMS_ECC_POINT * Qout,        //   OUT: the public point
  TPM2B_ECC_PARAMETER * dOut,   //   OUT: the private scalar
  TPM_ECC_CURVE curveId,        //   IN: the curve identifier
  TPM_ALG_ID hashAlg,           //   IN: hash algorithm to use in the key
  // generation process
  TPM2B * seed,                 //   IN: the seed to use
  const char *label,            //   IN: A label for the generation process.
  TPM2B * extra,                //   IN: Party 1 data for the KDF
  UINT32 * counter              //   IN/OUT: Counter value to allow KDF
  // iteration to be propagated across multiple functions
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__GenerateKeyRSA(
  TPM2B * n,                    //   OUT: The public modulu
  TPM2B * p,                    //   OUT: One of the prime factors of n
  UINT16 keySizeInBits,         //   IN: Size of the public modulus in bit
  UINT32 e,                     //   IN: The public exponent
  TPM_ALG_ID hashAlg,           //   IN: hash algorithm to use in the key generation proce
  TPM2B * seed,                 //   IN: the seed to use
  const char *label,            //   IN: A label for the generation process.
  TPM2B * extra,                //   IN: Party 1 data for the KDF
  UINT32 * counter              //   IN/OUT: Counter value to allow KFD iteration to be
  //   propagated across multiple routine
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

UINT16 _cpri__GenerateRandom(
  INT32 randomSize,
  BYTE * buffer)
{
  ecprintf("%s called\n", __func__);
  return randomSize;
}

UINT16 _cpri__GenerateSeededRandom(
  INT32 randomSize,             //   IN: the size of the request
  BYTE * random,                //   OUT: receives the data
  TPM_ALG_ID hashAlg,           //   IN: used by KDF version but not here
  TPM2B * seed,                 //   IN: the seed value
  const char *label,            //   IN: a label string (optional)
  TPM2B * partyU,               //   IN: other data (oprtional)
  TPM2B * partyV                //   IN: still more (optional)
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

TPM_ALG_ID _cpri__GetContextAlg(
  CPRI_HASH_STATE * hashState)
{
  ecprintf("%s called\n", __func__);
  return TPM_ALG_ERROR;
}

TPM_ECC_CURVE _cpri__GetCurveIdByIndex(
  UINT16 i)
{
  ecprintf("%s called\n", __func__);
  return TPM_ECC_NONE;
}

UINT16 _cpri__GetDigestSize(
  TPM_ALG_ID hashAlg            // IN: hash algorithm to look up
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

CRYPT_RESULT _cpri__GetEphemeralEcc(
  TPMS_ECC_POINT * Qout,        // OUT: the public point
  TPM2B_ECC_PARAMETER * dOut,   // OUT: the private scalar
  TPM_ECC_CURVE curveId         // IN: the curve for the key
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

LIB_EXPORT TPM_ALG_ID _cpri__GetHashAlgByIndex(
  UINT32 index)                 // IN: the index
{
  ecprintf("%s called\n", __func__);
  return TPM_ALG_ERROR;
}

UINT16 _cpri__GetHashBlockSize(
  TPM_ALG_ID hashAlg            // IN: hash algorithm to look up
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

INT16 _cpri__GetSymmetricBlockSize(
  TPM_ALG_ID symmetricAlg,      // IN: the symmetric algorithm
  UINT16 keySizeInBits          // IN: the key size
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

UINT16 _cpri__HashBlock(
  TPM_ALG_ID hashAlg,           //   IN: The hash algorithm
  UINT32 dataSize,              //   IN: size of buffer to hash
  BYTE * data,                  //   IN: the buffer to hash
  UINT32 digestSize,            //   IN: size of the digest buffer
  BYTE * digest                 //   OUT: hash digest
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

void _cpri__ImportExportHashState(
  CPRI_HASH_STATE * osslFmt,    // IN/OUT: the hash state formated for use
  // by openSSL
  EXPORT_HASH_STATE * externalFmt,      // IN/OUT: the exported hash state
  IMPORT_EXPORT direction       //
  )
{
  ecprintf("%s called\n", __func__);
}

UINT16 _cpri__KDFa(
  TPM_ALG_ID hashAlg,           //   IN: hash algorithm used in HMAC
  TPM2B * key,                  //   IN: HMAC key
  const char *label,            //   IN: a 0-byte terminated label used in KDF
  TPM2B * contextU,             //   IN: context U
  TPM2B * contextV,             //   IN: context V
  UINT32 sizeInBits,            //   IN: size of generated key in bit
  BYTE * keyStream,             //   OUT: key buffer
  UINT32 * counterInOut,        //   IN/OUT: caller may provide the iteration
  //   counter for incremental operations to
  //   avoid large intermediate buffers.
  BOOL once                     //   IN: TRUE if only one iteration is
  // performed FALSE if iteration count determined by "sizeInBits"
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

UINT16 _cpri__KDFe(
  TPM_ALG_ID hashAlg,           //   IN: hash algorithm used in HMAC
  TPM2B * Z,                    //   IN: Z
  const char *label,            //   IN: a 0 terminated label using in KDF
  TPM2B * partyUInfo,           //   IN: PartyUInfo
  TPM2B * partyVInfo,           //   IN: PartyVInfo
  UINT32 sizeInBits,            //   IN: size of generated key in bit
  BYTE * keyStream              //   OUT: key buffer
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

CRYPT_RESULT _cpri__SignEcc(
  TPM2B_ECC_PARAMETER * rOut,   //   OUT: r component of the signature
  TPM2B_ECC_PARAMETER * sOut,   //   OUT: s component of the signature
  TPM_ALG_ID scheme,            //   IN: the scheme selector
  TPM_ALG_ID hashAlg,           //   IN: the hash algorithm if need
  TPM_ECC_CURVE curveId,        //   IN: the curve used in the signature process
  TPM2B_ECC_PARAMETER * dIn,    //   IN: the private key
  TPM2B * digest,               //   IN: the digest to sign
  TPM2B_ECC_PARAMETER * kIn     //   IN: k for input
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__SignRSA(
  UINT32 * sigOutSize,          //   OUT: size of signature
  BYTE * sigOut,                //   OUT: signature
  RSA_KEY * key,                //   IN: key to use
  TPM_ALG_ID scheme,            //   IN: the scheme to use
  TPM_ALG_ID hashAlg,           //   IN: hash algorithm for PKSC1v1_5
  UINT32 hInSize,               //   IN: size of digest to be signed
  BYTE * hIn                    //   IN: digest buffer
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

UINT16 _cpri__StartHMAC(
  TPM_ALG_ID hashAlg,           //   IN: the algorithm to use
  BOOL sequence,                //   IN: indicates if the state should be saved
  CPRI_HASH_STATE * state,      //   IN/OUT: the state buffer
  UINT16 keySize,               //   IN: the size of the HMAC key
  BYTE * key,                   //   IN: the HMAC key
  TPM2B * oPadKey               //   OUT: the key prepared for the oPad round
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

UINT16 _cpri__StartHash(
  TPM_ALG_ID hashAlg,           // IN: hash algorithm
  BOOL sequence,                // IN: TRUE if the state should be saved
  CPRI_HASH_STATE * hashState   // OUT: the state of hash stack.
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

BOOL _cpri__Startup(
  void)
{
  ecprintf("%s called\n", __func__);
  return 0;
}

CRYPT_RESULT _cpri__StirRandom(
  INT32 entropySize,
  BYTE * entropy)
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__TestKeyRSA(
  TPM2B * d,                    //   OUT: the address to receive the
  // private exponent
  UINT32 exponent,              //   IN: the public modulu
  TPM2B * publicKey,            //   IN/OUT: an input if only one prime is
  // provided. an output if both primes are provided
  TPM2B * prime1,               //   IN: a first prime
  TPM2B * prime2                //   IN: an optional second prime
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

void _cpri__UpdateHash(
  CPRI_HASH_STATE * hashState,  // IN: the hash context information
  UINT32 dataSize,              // IN: the size of data to be added
  // to the digest
  BYTE * data                   // IN: data to be hashed
  )
{
  ecprintf("%s called\n", __func__);
}

CRYPT_RESULT _cpri__ValidateSignatureEcc(
  TPM2B_ECC_PARAMETER * rIn,    //   IN: r component of the signature
  TPM2B_ECC_PARAMETER * sIn,    //   IN: s component of the signature
  TPM_ALG_ID scheme,            //   IN: the scheme selector
  TPM_ALG_ID hashAlg,           //   IN: the hash algorithm used (not used
  // in all schemes)
  TPM_ECC_CURVE curveId,        //   IN: the curve used in the
  // signature process
  TPMS_ECC_POINT * Qin,         //   IN: the public point of the key
  TPM2B * digest                //   IN: the digest that was signed
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

CRYPT_RESULT _cpri__ValidateSignatureRSA(
  RSA_KEY * key,                //   IN:   key to use
  TPM_ALG_ID scheme,            //   IN:   the scheme to use
  TPM_ALG_ID hashAlg,           //   IN:   hash algorithm
  UINT32 hInSize,               //   IN:   size of digest to be checked
  BYTE * hIn,                   //   IN:   digest buffer
  UINT32 sigInSize,             //   IN:   size of signature
  BYTE * sigIn,                 //   IN:   signature
  UINT16 saltSize               //   IN:   salt size for PSS
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

int _math__Comp(
  const UINT32 aSize,           //   IN:   size of a
  const BYTE * a,               //   IN:   a buffer
  const UINT32 bSize,           //   IN:   size of b
  const BYTE * b                //   IN:   b buffer
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

CRYPT_RESULT _math__Div(
  const TPM2B * n,              //   IN: numerator
  const TPM2B * d,              //   IN: denominator
  TPM2B * q,                    //   OUT: quotient
  TPM2B * r                     //   OUT: remainder
  )
{
  ecprintf("%s called\n", __func__);
  return CRYPT_FAIL;
}

int _math__uComp(
  const UINT32 aSize,           // IN: size of a
  const BYTE * a,               // IN: a
  const UINT32 bSize,           // IN: size of b
  const BYTE * b                // IN: b
  )
{
  ecprintf("%s called\n", __func__);
  return -1;
}

void __assert_func(
  const char *file,
  int line,
  const char *func)
{
  ecprintf("Failure in %s, line %d, code %d\n",
           s_failFunction, s_failLine, s_failCode);
  while (1)
    ;                           /* Let the watchdog doo the rest. */
}

CRYPT_RESULT _cpri__InitCryptoUnits(
  FAIL_FUNCTION failFunction)
{
  return CRYPT_SUCCESS;
}