/**
 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
 * All Rights Reserved.
 * Confidential and Proprietary - Qualcomm Technologies, Inc.
 */

#ifndef   __TEE_INTERNAL_API_H__
#define   __TEE_INTERNAL_API_H__

#ifndef TA_EXPORT
#define TA_EXPORT
#endif

//#define TEE_NO_TRACE
//#define TEE_INCLUDE_DEPRECATED_ECC_IDENTIFIERS

/*----------------------------------------------------------------------------
 * Include Files
 * -------------------------------------------------------------------------*/
#include <stdint.h>
#include <string.h>
#include <stdbool.h>

#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"

/*----------------------------------------------------------------------------
 * Table of Contents
 * -------------------------------------------------------------------------*/
/*
 * 1. API Version information
 * 2. Basic type definitions
 *    a) Basic types
 * 3. TEE type definitions
 *    a) TEE Data types
 *        -TEE Core Framework data types (UUID, params, sessions, etc..)
 *        -TEE Trusted Storage types
 *        -TEE Crypto types
 *        -TEE Time types
 *        -TEE Arithmetical types
 * 4. TEE Constants
 *    a) TEE Core Framework constants
 *        -TEE Error codes
 *        -TEE Param types
 *        -TEE Login types
 *        -TEE Origin codes
 *        -TEE Property Set pseudo-handles
 *        -TEE Memory Access rights
 *        -TEE Handle values
 *    b) TEE Trusted Storage constants
 *        -TEE Object Storage constants
 *        -TEE Data Flag constants
 *        -TEE Usage constants
 *        -TEE Handle Flag constants
 *        -TEE Operation constants
 *        -TEE Miscellaneous constants
 *    c) TEE Crypto constants
 *        -TEE Crypto algorithms
 *        -TEE Transient Object types
 *        -TEE Object/Operation attributes
 *        -TEE attribute ID flags
 *
 */

/*----------------------------------------------------------------------------
 * API Version information
 * -------------------------------------------------------------------------*/
#define TEE_CORE_API_MAJOR_VERSION        (1)
#define TEE_CORE_API_MINOR_VERSION        (2)
#define TEE_CORE_API_MAINTENANCE_VERSION  (1)
#define TEE_CORE_API_VERSION              (TEE_CORE_API_MAJOR_VERSION << 24) + \
                                          (TEE_CORE_API_MINOR_VERSION << 16) + \
                                          (TEE_CORE_API_MAINTENANCE_VERSION << 8)
#define TEE_CORE_API_1_2_1

/* GP Spec allows TAs to mention specific version compatible with */ 
/* the TA source code ensuring compilation if and only if the */ 
/* mentioned version is available. */

/* Presence of a required maintainence version requires minor and */
/* major versions to mentioned as well. */
/* Similarly presence of a required minor version requires major */
/* version to be set. */
#if defined(TEE_CORE_API_REQUIRED_MAINTENANCE_VERSION) && \
	!defined(TEE_CORE_API_REQUIRED_MINOR_VERSION)
#error "Required TEE_CORE_API_REQUIRED_MINOR_VERSION not defined"
#endif

#if defined(TEE_CORE_API_REQUIRED_MINOR_VERSION) && \
	!defined(TEE_CORE_API_REQUIRED_MAJOR_VERSION)
#error "Required TEE_CORE_API_REQUIRED_MAJOR_VERSION not defined"
#endif

/* Check if the required major, minor and maintenance versions are */
/* supported in the current spec version. */
#if defined(TEE_CORE_API_REQUIRED_MAJOR_VERSION)
#if TEE_CORE_API_REQUIRED_MAJOR_VERSION != 1 && \
	TEE_CORE_API_REQUIRED_MAJOR_VERSION != 0
#error "Required TEE_CORE_API_REQUIRED_MAJOR_VERSION not supported"
#endif
#endif

#if defined(TEE_CORE_API_REQUIRED_MINOR_VERSION)
#if TEE_CORE_API_REQUIRED_MINOR_VERSION != 2 && \
  TEE_CORE_API_REQUIRED_MINOR_VERSION != 0
#error "Required TEE_CORE_API_REQUIRED_MINOR_VERSION not supported"
#endif
#endif

#if defined(TEE_CORE_API_REQUIRED_MAINTENANCE_VERSION)
#if TEE_CORE_API_REQUIRED_MAINTENANCE_VERSION != 1 && \
  TEE_CORE_API_REQUIRED_MAINTENANCE_VERSION != 0
#error "Required TEE_CORE_API_REQUIRED_MAINTENANCE_VERSION not supported"
#endif
#endif
/*----------------------------------------------------------------------------
 * Type definitions
 * -------------------------------------------------------------------------*/

/* Return type */
typedef uint32_t TEE_Result;
typedef TEE_Result TEEC_Result;

/* TEE Arithmetical types */
typedef uint32_t TEE_BigInt; /* placeholder for large multi-precision int */
typedef uint32_t TEE_BigIntFMMContext; /* placeholder for context */
typedef uint32_t TEE_BigIntFMM; /* placeholder for mem structure of Fast modular mult */

#ifndef NULL
#define NULL 0
#endif

typedef struct TEE_Buffer
{
  void*     buffer;
  size_t    size;
} TEE_Buffer;

typedef struct TEE_Value
{
  uint32_t a;
  uint32_t b;
} TEE_Value;

typedef union TEE_Param
{
  TEE_Buffer  memref;
  TEE_Value   value;
} TEE_Param;

/*----------------------------------------------------------------------------
 * Generic GP Constants
 * -------------------------------------------------------------------------*/
#define MAX_GP_PARAMS                               4

/*---------------------------------------------------------
    Common type definition
---------------------------------------------------------*/
typedef struct
{
   uint32_t timeLow;
   uint16_t timeMid;
   uint16_t timeHiAndVersion;
   uint8_t  clockSeqAndNode[8];
} TEE_UUID;

/*---------------------------------------------------------
    Type definition for Trusted Core Framework API
    ---------------------------------------------------------*/
typedef struct TEE_Identity
{
  uint32_t login;
  TEE_UUID uuid;
} TEE_Identity;

// Sessions
typedef struct __TEE_TASessionHandle* TEE_TASessionHandle; /* Opaque handle */

#define TA_EXPORT //__declspec(dllexport)

// Property Set
struct __TEE_PropSetHandle;
typedef struct __TEE_PropSetHandle* TEE_PropSetHandle; /* Opaque handle */

/*---------------------------------------------------------
    Type definition for Time API
    ---------------------------------------------------------*/
typedef struct
{
  uint32_t seconds;
  uint32_t millis;
} TEE_Time;

/*---------------------------------------------------------
    Type definition for Data Storage
    ---------------------------------------------------------*/
typedef struct
{
  uint32_t attributeID;
  union
  {
    struct
    {
      void* buffer; /* [inbuf] */
      size_t length;
    } ref;
    struct
    {
      uint32_t a, b;
    } value;
  } content;
} TEE_Attribute;

typedef struct
{
  uint32_t objectType;
  uint32_t objectSize;
  uint32_t maxObjectSize;
  uint32_t objectUsage;
  size_t dataSize;
  size_t dataPosition;
  uint32_t handleFlags;
} TEE_ObjectInfo;

//Refer TEE_Whence constants for allowed values.
typedef uint32_t TEE_Whence;

// Obj
struct __TEE_ObjectHandle;
typedef struct __TEE_ObjectHandle* TEE_ObjectHandle; /* Opaque handle */

// Obj enum
struct __TEE_ObjectEnumHandle;
typedef struct __TEE_ObjectEnumHandle* TEE_ObjectEnumHandle; /* Opaque handle */

//Cryptographic Operations API
typedef uint32_t TEE_OperationMode;

// Operation info
typedef struct
{
  uint32_t algorithm;
  uint32_t operationClass;
  uint32_t mode;
  uint32_t digestLength;
  uint32_t maxKeySize;
  uint32_t keySize;
  uint32_t requiredKeyUsage;
  uint32_t handleState;
} TEE_OperationInfo;

typedef struct
{
  uint32_t keySize;
  uint32_t requiredKeyUsage;
} TEE_OperationInfoKey;

typedef struct
{
  uint32_t             algorithm;
  uint32_t             operationClass;
  uint32_t             mode;
  uint32_t             digestLength;
  uint32_t             maxKeySize;
  uint32_t             handleState;
  uint32_t             operationState;
  uint32_t             numberOfKeys;
  TEE_OperationInfoKey keyInformation[];
} TEE_OperationInfoMultiple; // +

// Operation Handle
struct __TEE_OperationHandle;
typedef struct __TEE_OperationHandle* TEE_OperationHandle; /* Opaque handle */

/*----------------------------------------------------------------------------
 * TEE Core framework constants
 * -------------------------------------------------------------------------*/

/* TEE Error codes */

#define TEE_SUCCESS                           0x00000000    /* Operation success */
#define TEE_ERROR_CORRUPT_OBJECT              0xF0100001
#define TEE_ERROR_CORRUPT_OBJECT_2            0xF0100002
#define TEE_ERROR_STORAGE_NOT_AVAILABLE       0xF0100003
#define TEE_ERROR_STORAGE_NOT_AVAILABLE_2     0xF0100004
#define TEE_ERROR_GENERIC                     0xFFFF0000    /* Non-specific error */
#define TEE_ERROR_ACCESS_DENIED               0xFFFF0001    /* Access privileges are not sufficient */
#define TEE_ERROR_CANCEL                      0xFFFF0002    /* Operation was cancelled */
#define TEE_ERROR_ACCESS_CONFLICT             0xFFFF0003    /* Concurrent accesses caused conflict */
#define TEE_ERROR_EXCESS_DATA                 0xFFFF0004    /* Too much data for the requested operation was provided */
#define TEE_ERROR_BAD_FORMAT                  0xFFFF0005    /* The input data was of invalid format */
#define TEE_ERROR_BAD_PARAMETERS              0xFFFF0006    /* The input parameters were invalid */
#define TEE_ERROR_BAD_STATE                   0xFFFF0007    /* The operation is not valid in current state */
#define TEE_ERROR_ITEM_NOT_FOUND              0xFFFF0008    /* The requested data could not be found */
#define TEE_ERROR_NOT_IMPLEMENTED             0xFFFF0009    /* The operation should be implemented, but does not currently exist */
#define TEE_ERROR_NOT_SUPPORTED               0xFFFF000A    /* The operation is valid, but not supported */
#define TEE_ERROR_NO_DATA                     0xFFFF000B    /* Expected data was missing */
#define TEE_ERROR_OUT_OF_MEMORY               0xFFFF000C    /* System ran out of resources */
#define TEE_ERROR_BUSY                        0xFFFF000D    /* System is busy with something else */
#define TEE_ERROR_COMMUNICATION               0xFFFF000E    /* Communication with a remote party failed */
#define TEE_ERROR_SECURITY                    0xFFFF000F    /* A security fault was detected */
#define TEE_ERROR_SHORT_BUFFER                0xFFFF0010    /* The buffer is NULL or is too small */
#define TEE_ERROR_EXTERNAL_CANCEL             0xFFFF0011    /* An external event has caused a User Interface operation to be aborted*/
#define TEE_PENDING                           0xFFFF2000    /* The operation is pending action */
#define TEE_ERROR_TIMEOUT                     0xFFFF3001    /* The operation has timed out and could not complete */
#define TEE_ERROR_OVERFLOW                    0xFFFF300F    /* An integer overflow has occurred */
#define TEE_ERROR_TARGET_DEAD                 0xFFFF3024    /* TA has shut down */
#define TEE_ERROR_STORAGE_NO_SPACE            0xFFFF3041    /* Insufficient space available to create persistent object */
#define TEE_ERROR_MAC_INVALID                 0xFFFF3071    /* The computed MAC does not correspond with passed-in param */
#define TEE_ERROR_SIGNATURE_INVALID           0xFFFF3072    /* The signature is invalid */
#define TEE_ERROR_TIME_NOT_SET                0xFFFF5000    /* Persistent object is not currently set */
#define TEE_ERROR_TIME_NEEDS_RESET            0xFFFF5001    /* Persistent object is set, but may be corrupted and can no longer be trusted */
#define TEEC_SUCCESS                          TEE_SUCCESS
#define TEEC_ERROR_GENERIC                    TEE_ERROR_GENERIC
#define TEEC_ERROR_ACCESS_DENIED              TEE_ERROR_ACCESS_DENIED
#define TEEC_ERROR_CANCEL                     TEE_ERROR_CANCEL
#define TEEC_ERROR_ACCESS_CONFLICT            TEE_ERROR_ACCESS_CONFLICT
#define TEEC_ERROR_EXCESS_DATA                TEE_ERROR_EXCESS_DATA
#define TEEC_ERROR_BAD_FORMAT                 TEE_ERROR_BAD_FORMAT
#define TEEC_ERROR_BAD_PARAMETERS             TEE_ERROR_BAD_PARAMETERS
#define TEEC_ERROR_BAD_STATE                  TEE_ERROR_BAD_STATE
#define TEEC_ERROR_ITEM_NOT_FOUND             TEE_ERROR_ITEM_NOT_FOUND
#define TEEC_ERROR_NOT_IMPLEMENTED            TEE_ERROR_NOT_IMPLEMENTED
#define TEEC_ERROR_NOT_SUPPORTED              TEE_ERROR_NOT_SUPPORTED
#define TEEC_ERROR_NO_DATA                    TEE_ERROR_NO_DATA
#define TEEC_ERROR_OUT_OF_MEMORY              TEE_ERROR_OUT_OF_MEMORY
#define TEEC_ERROR_BUSY                       TEE_ERROR_BUSY
#define TEEC_ERROR_COMMUNICATION              TEE_ERROR_COMMUNICATION
#define TEEC_ERROR_SECURITY                   TEE_ERROR_SECURITY
#define TEEC_ERROR_SHORT_BUFFER               TEE_ERROR_SHORT_BUFFER
#define TEEC_ERROR_TARGET_DEAD                TEE_ERROR_TARGET_DEAD

/* TEE Login types */
#define TEE_LOGIN_PUBLIC                      0x00000000
#define TEE_LOGIN_USER                        0x00000001
#define TEE_LOGIN_GROUP                       0x00000002
#define TEE_LOGIN_APPLICATION                 0x00000004
#define TEE_LOGIN_APPLICATION_USER            0x00000005
#define TEE_LOGIN_APPLICATION_GROUP           0x00000006
#define TEE_LOGIN_TRUSTED_APP                 0xF0000000

/* TEE Param types */
#define TEE_PARAM_TYPE_NONE                   0x0
#define TEE_PARAM_TYPE_VALUE_INPUT            0x1
#define TEE_PARAM_TYPE_VALUE_OUTPUT           0x2
#define TEE_PARAM_TYPE_VALUE_INOUT            0x3
#define TEE_PARAM_TYPE_MEMREF_INPUT           0x5
#define TEE_PARAM_TYPE_MEMREF_OUTPUT          0x6
#define TEE_PARAM_TYPE_MEMREF_INOUT           0x7

/* TEE Memory Access rights */
#define TEE_MEMORY_ACCESS_READ                0x1
#define TEE_MEMORY_ACCESS_WRITE               0x2
#define TEE_MEMORY_ACCESS_ANY_OWNER           0x4

//Macros to retrieve Param Types
#define TEE_PARAM_TYPES(t0,t1,t2,t3)          ((t0) | ((t1) << 4) | ((t2) << 8) | ((t3) << 12))
#define TEE_PARAM_TYPE_GET(t, i)              (((t) >> (i*4)) & 0xF)
#define TEE_BigIntSizeInU32(n) ((((n)+31)/32)+2)

/* TEE Origin codes */
#define TEE_ORIGIN_API                        0x1
#define TEE_ORIGIN_COMMS                      0x2
#define TEE_ORIGIN_TEE                        0x3
#define TEE_ORIGIN_TRUSTED_APP                0x4

#define TEE_TIMEOUT_INFINITE                  0xFFFFFFFF

/* TEE Property Set pseudo-handles */
#define TEE_PROPSET_CURRENT_TA                (TEE_PropSetHandle)0xFFFFFFFF
#define TEE_PROPSET_CURRENT_CLIENT            (TEE_PropSetHandle)0xFFFFFFFE
#define TEE_PROPSET_TEE_IMPLEMENTATION        (TEE_PropSetHandle)0xFFFFFFFD

/*----------------------------------------------------------------------------
 * TEE Trusted storage constants
 * -------------------------------------------------------------------------*/
/* Object storage constants */
#define TEE_HANDLE_NULL                       (NULL)
#define TEE_OBJECT_STORAGE_PRIVATE            0x00000001

/* Data Flag constants */
#define TEE_DATA_FLAG_ACCESS_READ             0x00000001
#define TEE_DATA_FLAG_ACCESS_WRITE            0x00000002
#define TEE_DATA_FLAG_ACCESS_WRITE_META       0x00000004
#define TEE_DATA_FLAG_SHARE_READ              0x00000010
#define TEE_DATA_FLAG_SHARE_WRITE             0x00000020
#define TEE_DATA_FLAG_CREATE                  0x00000200
#define TEE_DATA_FLAG_OVERWRITE               0x00000400
#define TEE_DATA_FLAG_EXCLUSIVE               0x00000400

/* Usage constants */
#define TEE_USAGE_EXTRACTABLE                 0x00000001
#define TEE_USAGE_ENCRYPT                     0x00000002
#define TEE_USAGE_DECRYPT                     0x00000004
#define TEE_USAGE_MAC                         0x00000008
#define TEE_USAGE_SIGN                        0x00000010
#define TEE_USAGE_VERIFY                      0x00000020
#define TEE_USAGE_DERIVE                      0x00000040

/* Handle Flag constants */
#define TEE_HANDLE_FLAG_UNINITIALIZED         0x00000000
#define TEE_HANDLE_FLAG_PERSISTENT            0x00010000
#define TEE_HANDLE_FLAG_INITIALIZED           0x00020000
#define TEE_HANDLE_FLAG_KEY_SET               0x00040000
#define TEE_HANDLE_FLAG_EXPECT_TWO_KEYS       0x00080000

/* Operation constants */
#define TEE_OPERATION_CIPHER                  1
#define TEE_OPERATION_MAC                     3
#define TEE_OPERATION_AE                      4
#define TEE_OPERATION_DIGEST                  5
#define TEE_OPERATION_ASYMMETRIC_CIPHER       6
#define TEE_OPERATION_ASYMMETRIC_SIGNATURE    7
#define TEE_OPERATION_KEY_DERIVATION          8

/* TEE_Malloc Allocation hints */
#define TEE_MALLOC_FILL_ZERO               0x00000000
#define TEE_MALLOC_NO_FILL                 0x00000001
#define TEE_MALLOC_NO_SHARE                0x00000002

/* Operation States */
#define TEE_OPERATION_STATE_INITIAL           0x00000000
#define TEE_OPERATION_STATE_ACTIVE            0x00000001
/* Reserved for future use                    0x00000002-0x7FFFFFFF */
/* Implementation defined                     0x80000000-0xFFFFFFFF */

/* TEE_Whence Constants */
#define TEE_DATA_SEEK_SET                  0x00000000
#define TEE_DATA_SEEK_CUR                  0x00000001
#define TEE_DATA_SEEK_END                  0x00000002
#define TEE_WHENCE_ILLEGAL_VALUE           0x7FFFFFFF

/* TEE_OperationMode Values */
#define TEE_MODE_ENCRYPT                   0x00000000
#define TEE_MODE_DECRYPT                   0x00000001
#define TEE_MODE_SIGN                      0x00000002
#define TEE_MODE_VERIFY                    0x00000003
#define TEE_MODE_MAC                       0x00000004
#define TEE_MODE_DIGEST                    0x00000005
#define TEE_MODE_DERIVE                    0x00000006
#define TEE_MODE_ILLEGAL_VALUE             0x7FFFFFFF

/* Miscellaneous constants */
#define TEE_DATA_MAX_POSITION                 0xFFFFFFFF
#define TEE_OBJECT_ID_MAX_LEN                 64
#define TEE_STORAGE_PRIVATE                   1

/*----------------------------------------------------------------------------
 * TEE Crypto constants
 * -------------------------------------------------------------------------*/

 /* TEE Transient Object types */
#define TEE_TYPE_AES                          0xA0000010  /* 128, 192, or 256 bits */
#define TEE_TYPE_DES                          0xA0000011  /* Always 64 bits */
#define TEE_TYPE_DES3                         0xA0000013  /* 128 or 192 bits */
#define TEE_TYPE_HMAC_MD5                     0xA0000001  /* Between 64 and 512 bits, multiple of 8 bits */
#define TEE_TYPE_HMAC_SHA1                    0xA0000002  /* Between 80 and 512 bits, multiple of 8 bits */
#define TEE_TYPE_HMAC_SHA224                  0xA0000003  /* Between 112 and 512 bits, multiple of 8 bits */
#define TEE_TYPE_HMAC_SHA256                  0xA0000004  /* Between 192 and 1024 bits, multiple of 8 bits */
#define TEE_TYPE_HMAC_SHA384                  0xA0000005  /* Between 256 and 1024 bits, multiple of 8 bits */
#define TEE_TYPE_HMAC_SHA512                  0xA0000006  /* Between 256 and 1024 bits, multiple of 8 bits */
#define TEE_TYPE_RSA_PUBLIC_KEY               0xA0000030  /* Object size is the number of bits in the modulus. Min key size 256 bits, must support up to 2048 bit key sizes */
#define TEE_TYPE_RSA_KEYPAIR                  0xA1000030  /* Same as RSA public key size */
#define TEE_TYPE_DSA_PUBLIC_KEY               0xA0000031  /* Between 512 and 1024 bits, multiple of 64 bits */
#define TEE_TYPE_DSA_KEYPAIR                  0xA1000031  /* Same as DSA public key size */
#define TEE_TYPE_DH_KEYPAIR                   0xA1000032  /* From 256 to 2048 bits */
#define TEE_TYPE_ECDSA_PUBLIC_KEY             0xA0000041  /* TODO: New value - implement */
#define TEE_TYPE_ECDSA_KEYPAIR                0xA1000041  /* TODO: New value - implement */
#define TEE_TYPE_ECDH_PUBLIC_KEY              0xA0000042  /* TODO: New value - implement */
#define TEE_TYPE_ECDH_KEYPAIR                 0xA1000042  /* TODO: New value - implement */
#define TEE_TYPE_GENERIC_SECRET               0xA0000000  /* Multiple of 8 bits, up to 4096 bits */
#define TEE_TYPE_CORRUPTED_OBJECT             0xA00000BE  /* TODO: New value - implement */
#define TEE_TYPE_DATA                         0xA00000BF  /* TODO: New value - implement */
#define TEE_TYPE_HKDF                         0xA000004A

/* TEE Crypto algorithms */
#define TEE_ALG_AES_ECB_NOPAD                     0x10000010
#define TEE_ALG_AES_CBC_NOPAD                     0x10000110
#define TEE_ALG_AES_CTR                           0x10000210
#define TEE_ALG_AES_CTS                           0x10000310
#define TEE_ALG_AES_XTS                           0x10000410
#define TEE_ALG_AES_CBC_MAC_NOPAD                 0x30000110
#define TEE_ALG_AES_CBC_MAC_PKCS5                 0x30000510
#define TEE_ALG_AES_CMAC                          0x30000610
#define TEE_ALG_AES_CCM                           0x40000710
#define TEE_ALG_AES_GCM                           0x40000810
#define TEE_ALG_DES_ECB_NOPAD                     0x10000011
#define TEE_ALG_DES_CBC_NOPAD                     0x10000111
#define TEE_ALG_DES_CBC_MAC_NOPAD                 0x30000111
#define TEE_ALG_DES_CBC_MAC_PKCS5                 0x30000511
#define TEE_ALG_DES3_ECB_NOPAD                    0x10000013
#define TEE_ALG_DES3_CBC_NOPAD                    0x10000113
#define TEE_ALG_DES3_CBC_MAC_NOPAD                0x30000113
#define TEE_ALG_DES3_CBC_MAC_PKCS5                0x30000513
#define TEE_ALG_RSASSA_PKCS1_V1_5_MD5             0x70001830
#define TEE_ALG_RSASSA_PKCS1_V1_5_SHA1            0x70002830
#define TEE_ALG_RSASSA_PKCS1_V1_5_SHA224          0x70003830
#define TEE_ALG_RSASSA_PKCS1_V1_5_SHA256          0x70004830
#define TEE_ALG_RSASSA_PKCS1_V1_5_SHA384          0x70005830
#define TEE_ALG_RSASSA_PKCS1_V1_5_SHA512          0x70006830
#define TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA1        0x70212930
#define TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA224      0x70313930
#define TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA256      0x70414930
#define TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA384      0x70515930
#define TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA512      0x70616930
#define TEE_ALG_RSAES_PKCS1_V1_5                  0x60000130
#define TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA1        0x60210230
#define TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA224      0x60310230
#define TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA256      0x60410230
#define TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA384      0x60510230
#define TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA512      0x60610230
#define TEE_ALG_RSA_NOPAD                         0x60000030
#define TEE_ALG_DSA_SHA1                          0x70002131
#define TEE_ALG_DSA_SHA224                        0x70003131
#define TEE_ALG_DSA_SHA256                        0x70004131
#define TEE_ALG_DH_DERIVE_SHARED_SECRET           0x80000032
#define TEE_ALG_MD5                               0x50000001
#define TEE_ALG_SHA1                              0x50000002
#define TEE_ALG_SHA224                            0x50000003
#define TEE_ALG_SHA256                            0x50000004
#define TEE_ALG_SHA384                            0x50000005
#define TEE_ALG_SHA512                            0x50000006
#define TEE_ALG_HMAC_MD5                          0x30000001
#define TEE_ALG_HMAC_SHA1                         0x30000002
#define TEE_ALG_HMAC_SHA224                       0x30000003
#define TEE_ALG_HMAC_SHA256                       0x30000004
#define TEE_ALG_HMAC_SHA384                       0x30000005
#define TEE_ALG_HMAC_SHA512                       0x30000006
#define TEE_ALG_ECDSA_SHA1                        0x70001042
#define TEE_ALG_ECDSA_SHA224                      0x70002042
#define TEE_ALG_ECDSA_SHA256                      0x70003042
#define TEE_ALG_ECDSA_SHA384                      0x70004042
#define TEE_ALG_ECDSA_SHA512                      0x70005042
#define TEE_ALG_ECDH_DERIVE_SHARED_SECRET         0x80000042
#define TEE_ALG_HKDF                              0x80000047

#ifdef TEE_INCLUDE_DEPRECATED_ECC_IDENTIFIERS
/* These Elliptic Curve ID values appeared in the GP Specification version 1.1, */
/* but were removed in 1.1.1 because they were deemed to be inconsistent, or in */
/* some other way incorrect.                                                    */
/*                                                                              */
/* Some ID values were removed completely; others were kept but assigned new    */
/* semantics. The latter would cause us a problem but for the fact that there   */
/* is no implementation that uses them. The only place we see them at all is in */
/* some of the GP tests, but the testing is so limited that simply aliasing the */
/* proper values should be sufficient to get through.                           */
/*                                                                              */
/* In the fullness of time the tests will switch over to the 1.1.1 values and   */
/* identifiers and then these can all be removed completely.                    */
#define TEE_ALG_ECDSA_P192                          TEE_ALG_ECDSA_SHA1    /* 0x70001042 */
#define TEE_ALG_ECDSA_P224                          TEE_ALG_ECDSA_SHA224  /* 0x70002042 */
#define TEE_ALG_ECDSA_P256                          TEE_ALG_ECDSA_SHA256  /* 0x70003042 */
#define TEE_ALG_ECDSA_P384                          TEE_ALG_ECDSA_SHA384  /* 0x70004042 */
#define TEE_ALG_ECDSA_P521                          TEE_ALG_ECDSA_SHA512  /* 0x70005042 */
#define TEE_ALG_ECDH_P192                           0x80001042            /* Same purpose as TEE_ALG_ECDH_DERIVE_SHARED_SECRET */
#define TEE_ALG_ECDH_P224                           0x80002042            /* Same purpose as TEE_ALG_ECDH_DERIVE_SHARED_SECRET */
#define TEE_ALG_ECDH_P256                           0x80003042            /* Same purpose as TEE_ALG_ECDH_DERIVE_SHARED_SECRET */
#define TEE_ALG_ECDH_P384                           0x80004042            /* Same purpose as TEE_ALG_ECDH_DERIVE_SHARED_SECRET */
#define TEE_ALG_ECDH_P521                           0x80005042            /* Same purpose as TEE_ALG_ECDH_DERIVE_SHARED_SECRET */
#define TEE_ALG_ECDH_NIST_P192_DERIVE_SHARED_SECRET TEE_ALG_ECDH_P192
#define TEE_ALG_ECDH_NIST_P224_DERIVE_SHARED_SECRET TEE_ALG_ECDH_P224
#define TEE_ALG_ECDH_NIST_P256_DERIVE_SHARED_SECRET TEE_ALG_ECDH_P256
#define TEE_ALG_ECDH_NIST_P384_DERIVE_SHARED_SECRET TEE_ALG_ECDH_P384
#define TEE_ALG_ECDH_NIST_P521_DERIVE_SHARED_SECRET TEE_ALG_ECDH_P521
#endif

/* TEE Object/Operation attributes */

#define TEE_ATTR_SECRET_VALUE                 0xC0000000
#define TEE_ATTR_LABEL                        0xC0000100  /* Proprietary - info for KDF */
#define TEE_ATTR_CONTEXT                      0xC0000200  /* Proprietary - info for KDF */
#define TEE_ATTR_INPUT_KEY                    0xC0000300  /* Proprietary - info for KDF */
#define TEE_ATTR_RSA_MODULUS                  0xD0000130
#define TEE_ATTR_RSA_PUBLIC_EXPONENT          0xD0000230
#define TEE_ATTR_RSA_PRIVATE_EXPONENT         0xC0000330
#define TEE_ATTR_RSA_PRIME1                   0xC0000430
#define TEE_ATTR_RSA_PRIME2                   0xC0000530
#define TEE_ATTR_RSA_EXPONENT1                0xC0000630
#define TEE_ATTR_RSA_EXPONENT2                0xC0000730
#define TEE_ATTR_RSA_COEFFICIENT              0xC0000830
#define TEE_ATTR_DSA_PRIME                    0xD0001031
#define TEE_ATTR_DSA_SUBPRIME                 0xD0001131
#define TEE_ATTR_DSA_BASE                     0xD0001231
#define TEE_ATTR_DSA_PUBLIC_VALUE             0xD0000131
#define TEE_ATTR_DSA_PRIVATE_VALUE            0xC0000231
#define TEE_ATTR_DH_PRIME                     0xD0001032
#define TEE_ATTR_DH_SUBPRIME                  0xD0001132
#define TEE_ATTR_DH_BASE                      0xD0001232
#define TEE_ATTR_DH_X_BITS                    0xF0001332
#define TEE_ATTR_DH_PUBLIC_VALUE              0xD0000132
#define TEE_ATTR_DH_PRIVATE_VALUE             0xC0000232
#define TEE_ATTR_RSA_OAEP_LABEL               0xD0000930
#define TEE_ATTR_RSA_OAEP_MGF_HASH            0xD0000931
#define TEE_ATTR_RSA_PSS_SALT_LENGTH          0xF0000A30
#define TEE_ATTR_ECC_PUBLIC_VALUE_X           0xD0000141
#define TEE_ATTR_ECC_PUBLIC_VALUE_Y           0xD0000241
#define TEE_ATTR_ECC_PRIVATE_VALUE            0xC0000341
#define TEE_ATTR_ECC_CURVE                    0xF0000441
#define TEE_ATTR_HKDF_SALT                    0xD0000946
#define TEE_ATTR_HKDF_INFO                    0xD0000A46
#define TEE_ATTR_HKDF_HASH_ALGORITHM          0xF0000B46
#define TEE_ATTR_KDF_KEY_SIZE                 0xF0000C46
#define TEE_ATTR_HKDF_IKM                     0xC00001C0 /* OPTEE defined attribute for HKDF input key param. Not defined in 1.3.1 */

/* TEE attribute ID flags */

#define TEE_ATTR_FLAG_VALUE                   0x20000000
#define TEE_ATTR_FLAG_PUBLIC                  0x10000000

/* TEE Elliptic Curve types */

#define TEE_CRYPTO_ELEMENT_NONE               0x00000000
#define TEE_ECC_CURVE_NIST_P192               0x00000001
#define TEE_ECC_CURVE_NIST_P224               0x00000002
#define TEE_ECC_CURVE_NIST_P256               0x00000003
#define TEE_ECC_CURVE_NIST_P384               0x00000004
#define TEE_ECC_CURVE_NIST_P521               0x00000005
#define TEE_ECC_CURVE_RFU_START               0x00000006
#define TEE_ECC_CURVE_RFU_END                 0x7FFFFFFF
#define TEE_ECC_CURVE_PROPRIETARY_START       0x80000000
#define TEE_ECC_CURVE_PROP_BP_P160r1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 0)
#define TEE_ECC_CURVE_PROP_BP_P160t1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 1)
#define TEE_ECC_CURVE_PROP_BP_P192r1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 2)
#define TEE_ECC_CURVE_PROP_BP_P192t1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 3)
#define TEE_ECC_CURVE_PROP_BP_P224r1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 4)
#define TEE_ECC_CURVE_PROP_BP_P224t1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 5)
#define TEE_ECC_CURVE_PROP_BP_P256r1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 6)
#define TEE_ECC_CURVE_PROP_BP_P256t1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 7)
#define TEE_ECC_CURVE_PROP_BP_P320r1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 8)
#define TEE_ECC_CURVE_PROP_BP_P320t1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 9)
#define TEE_ECC_CURVE_PROP_BP_P384r1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 10)
#define TEE_ECC_CURVE_PROP_BP_P384t1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 11)
#define TEE_ECC_CURVE_PROP_BP_P512r1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 12)
#define TEE_ECC_CURVE_PROP_BP_P512t1          ((TEE_ECC_CURVE_PROPRIETARY_START) + 13)
#define TEE_ECC_CURVE_PROPRIETARY_END         0xFFFFFFFF

/*------------------------------------------------------------------------------
      Panic Function
------------------------------------------------------------------------------*/

extern void TEE_Panic(TEE_Result nPanicCode);

/*------------------------------------------------------------------------------
      Trusted Application Entry Points
------------------------------------------------------------------------------*/

extern TEE_Result TA_EXPORT TA_CreateEntryPoint(void);
extern void TA_EXPORT TA_DestroyEntryPoint(void);
extern TEE_Result TA_EXPORT TA_OpenSessionEntryPoint(
   uint32_t    nParamTypes,
   TEE_Param   pParams[4],
   void**      ppSessionContext);
extern void TA_EXPORT TA_CloseSessionEntryPoint(
   void*       pSessionContext);
extern TEE_Result TA_EXPORT TA_InvokeCommandEntryPoint(
   void*       pSessionContext,
   uint32_t    nCommandID,
   uint32_t    nParamTypes,
   TEE_Param   pParams[4]);

/*------------------------------------------------------------------------------
      Trusted Core Framework (27) functions
------------------------------------------------------------------------------*/
/**
 * @brief Get property as string.
 *
 *    The TEE_GetPropertyAsString function performs a lookup in a property set to retrieve an individual property
 * and convert its value into a printable string. When the lookup succeeds, the implementation MUST convert
 * the property into a printable string and copy the result into the buffer described by valueBuffer and valueBufferLen.
 *
 * @param[in]     propsetOrEnumerator     One of the TEE_PROPSET_XXX pseudo-handles or a handle on a property enumerator
 * @param[in]     name                    A pointer to the zero-terminated string containing the name of the property to
 *                                        retrieve. Its content is case-sensitive and it must be encoded in UTF-8.
 *                                          o If hPropSet is a property enumerator handle, name is ignored and can be NULL.
 *                                          o Otherwise, name cannot be NULL
 * @param[out]    valueBuffer             Output buffer for the property value.
 * @param[inout]  valueBufferLen          Length of the output buffer.
 *
 * @return        TEE_SUCCESS: In case of success
 *                TEE_ERROR_ITEM_NOT_FOUND: If the property is not found or if name is not a valid UTF-8 encoding
 *                TEE_ERROR_SHORT_BUFFER: If the value buffer is not large enough to hold the whole property value
 */
extern TEE_Result TEE_GetPropertyAsString(
    TEE_PropSetHandle  propsetOrEnumerator,
    char*              name,        /* [instringopt] */
    char*              valueBuffer, /* [outstring] */
    size_t*            valueBufferLen
);
/**
 * @brief Get property as bool.
 *
 *    The TEE_GetPropertyAsBool function retrieves a single property in a property set and converts its value to a Boolean.
 * If a property cannot be viewed as a Boolean, this function MUST return TEE_ERROR_BAD_FORMAT. Otherwise, if this
 * function succeeds, then calling the function TEE_GetPropertyAsString on the same name and with a sufficiently large
 * output buffer MUST also succeed and return a string equal to true or false case-insensitive, depending on the value
 * of the Boolean.
 *
 * @param[in]     propsetOrEnumerator     One of the TEE_PROPSET_XXX pseudo-handles or a handle on a property enumerator
 * @param[in]     name                    A pointer to the zero-terminated string containing the name of the property to
 *                                        retrieve. Its content is case-sensitive and it must be encoded in UTF-8.
 *                                          o If hPropSet is a property enumerator handle, name is ignored and can be NULL.
 *                                          o Otherwise, name cannot be NULL
 * @param[out]    value                   A pointer to the variable that will contain the value of the property on success or
 *                                        false on error.
 *
 * @return        TEE_SUCCESS: In case of success
 *                TEE_ERROR_ITEM_NOT_FOUND: If the property is not found or if name is not a valid UTF-8 encoding
 *                TEE_ERROR_BAD_FORMAT: If the property value cannot be converted to a Boolean
 */
extern TEE_Result TEE_GetPropertyAsBool(
    TEE_PropSetHandle  propsetOrEnumerator,
    char*              name, /* [instringopt] */
    bool*              value /* [out] */
);
/**
 * @brief Get property as uint32_t.
 *
 *    The TEE_GetPropertyAsU32 function retrieves a single property in a property set and converts its value to a 32-bit
 * unsigned integer. If a property cannot be viewed as a 32-bit unsigned integer, this function MUST return
 * TEE_ERROR_BAD_FORMAT.
 *
 * @param[in]     propsetOrEnumerator     One of the TEE_PROPSET_XXX pseudo-handles or a handle on a property enumerator
 * @param[in]     name                    A pointer to the zero-terminated string containing the name of the property to
 *                                        retrieve. Its content is case-sensitive and it must be encoded in UTF-8.
 *                                          o If hPropSet is a property enumerator handle, name is ignored and can be NULL.
 *                                          o Otherwise, name cannot be NULL
 * @param[out]    value                   A pointer to the variable that will contain the value of the property on success or
 *                                        zero on error.
 *
 * @return        TEE_SUCCESS: In case of success
 *                TEE_ERROR_ITEM_NOT_FOUND: If the property is not found or if name is not a valid UTF-8 encoding
 *                TEE_ERROR_BAD_FORMAT: If the property value cannot be converted to a 32-bit integer.
 */
extern TEE_Result TEE_GetPropertyAsU32 (
    TEE_PropSetHandle propsetOrEnumerator,
    char*             name, /* [intstringopt] */
    uint32_t*         value /* [out] */
);
/**
 * @brief Get property as base64 encoded binary block.
 *
 *    The function TEE_GetPropertyAsBinaryBlock retrieves an individual property and converts its value into a binary block.
 * If a property cannot be viewed as a binary block, this function MUST return TEE_ERROR_BAD_FORMAT. Otherwise, if this function
 * succeeds, then calling the function TEE_GetPropertyAsString on the same name and with a sufficiently large output buffer
 * MUST also succeed and return a string that is consistent with a Base64 encoding of the binary block as defined in RFC 2045 [6],
 * section 6.8 but with the following tolerance:
 *   An Implementation is allowed not to encode the final padding = characters.
 *   An Implementation is allowed to insert characters that are not in the Base64 character set.
 *
 * @param[in]     propsetOrEnumerator     One of the TEE_PROPSET_XXX pseudo-handles or a handle on a property enumerator
 * @param[in]     name                    A pointer to the zero-terminated string containing the name of the property to
 *                                        retrieve. Its content is case-sensitive and it must be encoded in UTF-8.
 *                                          o If hPropSet is a property enumerator handle, name is ignored and can be NULL.
 *                                          o Otherwise, name cannot be NULL
 * @param[out]    valueBuffer             Output buffer for the property value.
 * @param[inout]  valueBufferLen          Length of the output buffer.
 *
 * @return        TEE_SUCCESS: In case of success
 *                TEE_ERROR_ITEM_NOT_FOUND: If the property is not found or if name is not a valid UTF-8 encoding
 *                TEE_ERROR_BAD_FORMAT: If the property cannot be retrieved as a binary block
 *                TEE_ERROR_SHORT_BUFFER: If the value buffer is not large enough to hold the whole property value
 */
extern TEE_Result TEE_GetPropertyAsBinaryBlock(
    TEE_PropSetHandle  propsetOrEnumerator,
    char*              name,        /* [instringopt] */
    void*              valueBuffer, /* [outstring] */
    size_t*            valueBufferLen
);
/**
 * @brief Get property as TEE_UUID.
 *
 *    The function TEE_GetPropertyAsUUID retrieves an individual property and converts its value into a UUID.
 * If a property cannot be viewed as a UUID, this function MUST return TEE_ERROR_BAD_FORMAT. Otherwise,
 * if this function succeeds, then calling the function TEE_GetPropertyAsString on the same name and with
 * a sufficiently large output buffer MUST also succeed and return a string that is consistent with the
 * concrete syntax of UUIDs defined in RFC 4122. Note that this string may mix character cases.
 *
 * @param[in]     propsetOrEnumerator     One of the TEE_PROPSET_XXX pseudo-handles or a handle on a property enumerator
 * @param[in]     name                    A pointer to the zero-terminated string containing the name of the property to
 *                                        retrieve. Its content is case-sensitive and it must be encoded in UTF-8.
 *                                          o If hPropSet is a property enumerator handle, name is ignored and can be NULL.
 *                                          o Otherwise, name cannot be NULL
 * @param[out]    value                   A pointer filled with the UUID. Must not be NULL.
 *
 * @return        TEE_SUCCESS: In case of success
 *                TEE_ERROR_ITEM_NOT_FOUND: If the property is not found or if name is not a valid UTF-8 encoding
 *                TEE_ERROR_BAD_FORMAT: If the property cannot be converted into a UUID
 */
extern TEE_Result TEE_GetPropertyAsUUID(
    TEE_PropSetHandle  propsetOrEnumerator,
    char*              name, /* [instringopt] */
    TEE_UUID*          value /* [out] */
);
/**
 * @brief Get property as TEE_Identity.
 *
 * The function TEE_GetPropertyAsIdentity retrieves an individual property and converts its value into a TEE_Identity.
 *
 * @param[in]     propsetOrEnumerator     One of the TEE_PROPSET_XXX pseudo-handles or a handle on a property enumerator
 * @param[in]     name                    A pointer to the zero-terminated string containing the name of the property to
 *                                        retrieve. Its content is case-sensitive and it must be encoded in UTF-8.
 *                                          o If hPropSet is a property enumerator handle, name is ignored and can be NULL.
 *                                          o Otherwise, name cannot be NULL
 * @param[out]    value                   A pointer filled with the identity. Must not be NULL.
 *
 * @return        TEE_SUCCESS: In case of success
 *                TEE_ERROR_ITEM_NOT_FOUND: If the property is not found or if name is not a valid UTF-8 encoding
 *                TEE_ERROR_BAD_FORMAT: If the property cannot be converted into an Identity
 */
extern TEE_Result TEE_GetPropertyAsIdentity(
    TEE_PropSetHandle  propsetOrEnumerator,
    char*              name, /* [instringopt] */
    TEE_Identity*      value /* [out] */
);
/**
 * @brief Allocate a Property Set enumerator.
 *
 *    The function TEE_AllocatePropertyEnumerator allocates a property enumerator object. Once a handle on a property enumerator
 * has been allocated, it can be used to enumerate properties in a property set using the function TEE_StartPropertyEnumerator.
 *
 * @param[in]     enumerator    A pointer filled with an opaque handle on the property enumerator on success and with TEE_HANDLE_NULL on error
 *
 * @return        TEE_SUCCESS: In case of success
 *                TEE_ERROR_OUT_OF_MEMORY: If there are not enough resources to allocate the property enumerator
 */
extern TEE_Result TEE_AllocatePropertyEnumerator(
    TEE_PropSetHandle* enumerator
);
/**
 * @brief Free a Property Set enumerator.
 *
 * The function TEE_FreePropertyEnumerator deallocates a property enumerator object.
 *
 * @param[in]       enumerator    A handle on the enumerator to free
 */
extern void TEE_FreePropertyEnumerator(
    TEE_PropSetHandle enumerator
);
/**
 * @brief Assign a Property Set to the Enumerator.
 *
 *    The function TEE_StartPropertyEnumerator starts to enumerate the properties in an enumerator.
 * Once an enumerator is attached to a property set:
 *   Properties can be retrieved using one of the TEE_GetPropertyAsXXX functions, passing the enumerator handle as the property set and NULL as the name.
 *   The function TEE_GetPropertyName can be used to retrieve the name of the current property in the enumerator.
 *   The function TEE_GetNextProperty can be used to advance the enumeration to the next property in the property set.
 *
 *  @param[in]      enumerator    A handle on the enumerator
 *  @param[in]      propSet       A pseudo-handle on the property set to enumerate. Must be one of the TEE_PROPSET_XXX pseudo-handles.
 */
extern void TEE_StartPropertyEnumerator(
    TEE_PropSetHandle enumerator,
    TEE_PropSetHandle propSet
);
/**
 * @brief Reset Property Set enumerator to the un-assigned state.
 *
 * The function TEE_ResetPropertyEnumerator resets a property enumerate to its state immediately after allocation.
 * If an enumeration is currently started, it is abandoned.
 *
 * @param[in]       enumerator    A handle on the enumerator to reset
 */
extern void TEE_ResetPropertyEnumerator(
    TEE_PropSetHandle enumerator
);
/**
 * @brief Get the name of the current property from the enumerator as a (char *).
 *
 * The function TEE_GetPropertyName gets the name of the current property in an enumerator.
 * The property name MUST be the valid UTF-8 encoding of a Unicode string containing no U+0000 code points.
 *
 * @param[in]       enumerator    A handle on the enumerator
 * @param[out]      nameBuffer    The buffer filled with the name
 * @param[inout]    nameBufferLen The buffer length that is updated to reflect the size property name.
 *
 * @return          TEE_SUCCESS: In case of success
 *                  TEE_ERROR_ITEM_NOT_FOUND: If there is no current property either because the enumerator
 *                  has not started or because it has reached the end of the property set
 *                  TEE_ERROR_SHORT_BUFFER: If the name buffer is not large enough to contain the property name
 */
extern TEE_Result TEE_GetPropertyName(
    TEE_PropSetHandle enumerator,
    void*             nameBuffer,   /* [outstring] */
    size_t*           nameBufferLen
);
/**
 * @brief Iterate to the next property in the enumerator.
 *
 * The function TEE_GetNextProperty advances the enumerator to the next property.
 *
 * @param[in]       enumerator      A handle on the enumerator
 *
 * @return          TEE_SUCCESS: In case of success
 *                  TEE_ERROR_ITEM_NOT_FOUND: If the enumerator has reached the end of the property set or if it has not started
 */
extern TEE_Result TEE_GetNextProperty(
    TEE_PropSetHandle enumerator);

/*------------------------------------------------------------------------------
      GP Internal Internal Client APIs
------------------------------------------------------------------------------*/

extern TEE_Result TEE_OpenTASession(
  TEE_UUID* destination,
  uint32_t cancellationRequestTimeout,
  uint32_t paramTypes,
  TEE_Param params[MAX_GP_PARAMS],
  TEE_TASessionHandle* session,
  uint32_t* returnOrigin);

extern void TEE_CloseTASession( TEE_TASessionHandle session);

extern TEE_Result TEE_InvokeTACommand(
  TEE_TASessionHandle session,
  uint32_t cancellationRequestTimeout,
  uint32_t commandID,
  uint32_t paramTypes,
  TEE_Param params[MAX_GP_PARAMS],
  uint32_t* returnOrigin);

/*------------------------------------------------------------------------------
      GP Cancellations
------------------------------------------------------------------------------*/
extern bool TEE_GetCancellationFlag( void);

extern bool TEE_UnmaskCancellation( void );

extern bool TEE_MaskCancellation( void );

/*------------------------------------------------------------------------------
      GP Memory Management
------------------------------------------------------------------------------*/
/**
 * @brief Checks memory access rights on buffer address.
 *
 * The TEE_CheckMemoryAccessRights function causes the Implementation to examine a buffer of memory
 * specified in the parameters buffer and size and to determine whether the current Trusted Application
 * instance has the access rights requested in the parameter accessFlags. If the characteristics of the buffer
 * are compatible with accessFlags, then the function returns TEE_SUCCESS. Otherwise, it returns
 * TEE_ERROR_ACCESS_DENIED. Note that the buffer SHOULD NOT be accessed by the function, but the
 * Implementation SHOULD check the access rights based on the address of the buffer and internal memory
 * management information.
 *
 * @return  Upon successful completion, TEE_SUCCESS, otherwise TEE_ERROR_ACCESS_DENIED
 *
*/

extern TEE_Result TEE_CheckMemoryAccessRights(
  uint32_t accessFlags,
  void* buffer,
  size_t size );

/**
 * @brief Set an application global variable.
 *
 * The TEE_SetInstanceData and TEE_GetInstanceData functions provide an alternative to writable global data
 * (writable variables with global scope and writable static variables with global or function scope). While
 * an Implementation MUST support C global variables, using these functions may be sometimes more efficient,
 * especially if only a single instance data variable is required.
 * These two functions can be used to register and access an instance variable. Typically this instance
 * variable can be used to hold a pointer to a Trusted Application-defined memory block containing any
 * writable data that needs instance global scope, or writable static data that needs instance function scope.
 * An equivalent session context variable for managing session global and static data exists for sessions
 * (see TA_OpenSessionEntryPoint, TA_InvokeCommandEntryPoint, and TA_CloseSessionEntryPoint in section 4.3).
 * This function sets the Trusted Application instance data pointer. The data pointer can then be retrieved
 * by the Trusted Application instance by calling the TEE_GetInstanceData function.
 *
 * @param[in] instanceData    A pointer to the global Trusted Application instance data. This pointer may be NULL.
 */
extern void TEE_SetInstanceData( void* instanceData ); // [ctx]

/**
 * @brief Get the application global variable.
 *
 * The TEE_GetInstanceData function retrieves the instance data pointer set by the Trusted Application
 * using the TEE_GetInstanceData function.
 *
 * @return The value returned is the previously set pointer to the Trusted Application instance data, or NULL if
 * no instance data pointer has yet been set.
 */
extern void* TEE_GetInstanceData( void ); // [ctx]

/**
 * @brief Allocate dynamic memory.
 *
 * The parameter hint is a hint to the allocator. In this version of the specification, only one hint
 * is defined. This parameter is nonetheless included so that the Trusted Applications may refer to
 * various pools of memory or request special characteristics for the allocated memory by using an
 * implementation-defined hint. Future versions of this specification may introduce additional standard hints.
 * If the space cannot be allocated, a NULL pointer is returned.
 *
 * Calls qsee_malloc().
 *
 * @param[in] size    The size of the buffer to be allocated.
 * @param[in] hint    A hint to the allocator. Currently defined values are as follows:
 *                      o The default value, 0, guarantees that the returned block of memory is filled with zeros.
 *                      o Values in the range [0x00000001, 0x7FFFFFFF] are reserved for future version of this specification.
 *                      o Values in the range [0x80000000, 0xFFFFFFFF] can be used for implementation-defined hints.
 *
 * @return  Upon successful completion, with size not equal to zero, the function returns a pointer to the allocated space.
 *          If the space cannot be allocated, a NULL pointer is returned.
 */
extern void* TEE_Malloc(
  size_t size,
  uint32_t hint
);

extern void* TEE_Realloc(
  void* buffer,
  size_t newSize );

/**
 * @brief Free dynamically allocated memory.
 *
 * The TEE_Free function causes the space pointed to by buffer to be deallocated; that is, made available for further allocation.
 * If buffer is a NULL pointer, TEE_Free does nothing.
 *
 * @param[in] buffer    Upon successful completion, with size not equal to zero, the function returns a pointer
 *                      to the allocated space. If the space cannot be allocated, a NULL pointer is returned.
 */
extern void TEE_Free(  void* buffer ); // [in]

/**
 * @brief Copy bytes from source to destination.
 *
 * The TEE_MemMove function copies size bytes from the object pointed to by src into the object pointed to by dest.
 * Copying takes place as if the size bytes from the object pointed to by src are first copied into a temporary
 * array of size bytes that does not overlap the objects pointed to by dest and src, and then the size bytes
 * from the temporary array are copied into the object pointed to by dest.
 *
 * @param[in] dest    A pointer to the destination buffer
 * @param[in] src     A pointer to the source buffer
 * @param[in] size    The number of bytes to be copied
 */
extern void TEE_MemMove(
    void* dest,
    void* src,
    size_t size );

/**
 * @brief Compare two blocks of memory.
 *
 * The TEE_MemCompare function compares the first size bytes of the object pointed to by buffer1 to the first size
 * bytes of the object pointed to by buffer2.
 *
 * @param[in] buffer1     A pointer to the first buffer
 * @param[in] buffer2     A pointer to the second buffer
 * @param[in] size        The number of bytes to be compared
 *
 * @return The sign of a non-zero return value is determined by the sign of the difference between the values of
 *         the first pair of bytes (both interpreted as type uint8_t) that differ in the objects being compared.
 *           If the first byte that differs is higher in buffer1, then return an integer greater than zero.
 *           If the first size bytes of the two buffers are identical, then return zero.
 *           If the first byte that differs is higher in buffer2, then return an integer lower than zero.
 */
extern int32_t TEE_MemCompare(
    void* buffer1,
    void* buffer2,
    size_t size );

/**
 * @brief Fill memory with byte x.
 *
 * The TEE_MemFill function writes the byte x (converted to a uint8_t) into the first size bytes of the
 * object pointed to by buffer.
 *
 * @param[in] buffer    A pointer to the destination buffer
 * @param[in] x         The value to be set
 * @param[in] size      The number of bytes to be set
 */
extern void TEE_MemFill(
    void* buffer,
    uint8_t x,
    size_t size );

/*------------------------------------------------------------------------------
      GP Time functions  (5)
------------------------------------------------------------------------------*/
extern void TEE_GetSystemTime(
   TEE_Time* time);     //[out]

extern TEE_Result TEE_Wait(
   uint32_t timeout);

extern TEE_Result TEE_GetTAPersistentTime(
   TEE_Time* time);     // [out]

extern TEE_Result TEE_SetTAPersistentTime(
   TEE_Time* time);     //[in]

extern void TEE_GetREETime(
   TEE_Time* time);     //[out]


/*------------------------------------------------------------------------------
      GP Arithmetic functions (32)
------------------------------------------------------------------------------*/
extern size_t TEE_BigIntFMMContextSizeInU32(
   size_t modulusSizeInBits);

extern size_t TEE_BigIntFMMSizeInU32(
   size_t modulusSizeInBits);

/**
 * Initialization Functions
 */

/**
 * @brief The TEE_BigIntInit function initializes bigInt
 *        and sets its represented value to zero. This function
 *        assumes that bigInt points to a memory area of len uint32_t
 *        This can be done for example with the following memory allocation
 *        TEE_BigInt *a;
 *        size_t len;
 *        len = TEE_BigIntSizeInU32(bitSize);
 *        a =(TEE_BigInt *)TEE_Malloc(len * sizeof(TEE_BigInt));
 *        ret = TEE_BigIntInit(a,len);
 *
 * @param[out]  bigInt   A pointer to TEE_BigInt to be initialized,
 *                       memory has to be allocated by caller
 * @param[in]   len      The size in uint32_t of the memory pointed to by
 *                       bigInt
 *
 * @return
 *
 */
extern void TEE_BigIntInit(
  TEE_BigInt *bigInt,
    size_t len);

/**
 * @brief The TEE_BigIntInitFMMContext1 function calculates the
 *        necessary prerequisites for the fast modular
 *        multiplication and stores them in a context. This
 *        function assumes that context points to a memory area
 *        of len uint32_t This can be done for example with the
 *        following memory allocation:
 *
 *       TEE_BigIntFMMContext* ctx;
 *       size_t len = TEE_BigIntFMMContextSizeInU32(bitsize);
 *       ctx=(TEE_BigIntFMMContext)TEE_Malloc
 *       (len * sizeof(TEE_BigIntFFMContext));
 *       //Code for initializing modulus
 *       TEE_BigIntInitFMMContext (ctx, len, modulus);
 *
 *       Eventhough a fast multiplication might be
 *       mathematically defined for any modulus,
 *       normally there are restrictions in order
 *       for it to be fast on a computer. This specification
 *       mandates that all implementations
 *       MUST work for all odd moduli larger than 2 and less
 *       than 2 to the power of the implementation defined
 *       property gpd.tee.arith.maxBigIntSize.
 *
 * @param[out]  context  A pointer to the TEE_BigIntFMMContext
 *                       to be initialized, memory has to be
 *                       allocated by caller
 * @param[in]   len      The size in uint32_t of the memory pointed to by
 *                       context
 * @param[in]   modulus  The modulus, an odd integer larger than
 *                       2 and less than 2 to the power of
 *                       gpd.tee.arith.maxBigIntSize
 *
 * @return
 * TEE_SUCCESS: In case of success.
 * TEE_ERROR_NOT_SUPPORTED: The underlying implementation is unable to perform
                            the operation on a particular modulus value.
                            This may only be returned for even moduli inside the valid range,
                            outside that range the described PANIC will occur.
 */
extern TEE_Result TEE_BigIntInitFMMContext1(
  TEE_BigIntFMMContext *context, // [out]
  size_t len,
  TEE_BigInt *modulus);          // [in]

/**
 * Use of this function is DEPRECATED  new code SHOULD use the
 * TEE_BigIntInitFMMContext1 function instead.
 *
 * @brief The TEE_BigIntInitFMMContext function calculates the
 *        necessary prerequisites for the fast modular
 *        multiplication and stores them in a context. This
 *        function assumes that context points to a memory area
 *        of len uint32_t This can be done for example with the
 *        following memory allocation:
 *
 *       TEE_BigIntFMMContext* ctx;
 *       size_t len = TEE_BigIntFMMContextSizeInU32(bitsize);
 *       ctx=(TEE_BigIntFMMContext)TEE_Malloc
 *       (len * sizeof(TEE_BigIntFFMContext));
 *       //Code for initializing modulus
 *       TEE_BigIntInitFMMContext (ctx, len, modulus);
 *
 *       Eventhough a fast multiplication might be
 *       mathematically defined for any modulus,
 *       normally there are restrictions in order
 *       for it to be fast on a computer. This specification
 *       mandates that all implementations
 *       MUST work for all odd moduli larger than 2 and less
 *       than 2 to the power of the implementation defined
 *       property gpd.tee.arith.maxBigIntSize.
 *
 * @param[out]  context  A pointer to the TEE_BigIntFMMContext
 *                       to be initialized, memory has to be
 *                       allocated by caller
 * @param[in]   len      The size in uint32_t of the memory pointed to by
 *                       context
 * @param[in]   modulus  The modulus, an odd integer larger than
 *                       2 and less than 2 to the power of
 *                       gpd.tee.arith.maxBigIntSize
 *
 * @return
 */
extern void TEE_BigIntInitFMMContext(
  TEE_BigIntFMMContext *context, // [out]
  size_t len,
  TEE_BigInt *modulus);          // [in]

/**
 * @brief The TEE_BigIntInitFMM function initializes bigIntFMM
 * and sets its represented value to zero. This function assumes
 * that bigIntFMM points to a memory area of len uint32_t This
 * can be done for example with the following memory allocation:
 *
 * TEE_BigIntFMM *a;
 * size_t len;
 * len = TEE_BigIntFMMSizeInU32(modulusSizeinBits);
 * a = * (TEE_BigIntFMM *)TEE_Malloc
 * (len * sizeof(TEE_BigIntFMM));
 * TEE_InitFMMInt(a, len);
 *
 * @param[out]  bigIntFMM A pointer to the TEE_BigIntFMM
 *                        to be initialized, memory has to be
 *                        allocated by caller
 * @param[in]   len       The size in uint32_t of the memory
 *                        pointed to by bigIntFMM
 *
 * @return
 *
 */
extern void TEE_BigIntInitFMM(
  TEE_BigIntFMM *bigIntFMM, //[in]
  size_t len);

/**
 * Converter Functions
 */

/**
 * @brief The TEE_BigIntConvertFromOctetString function converts
 * a bufferLen byte octet string buffer into a TEE_BigInt
 * format. The octet string is in most significant byte first
 * representation. The input parameter sign will set the sign of
 * dest. It will be set to negative if sign <0 and to positive
 * if sign >=0
 *
 * @param[out]  dest      Pointer to a TEE_BigInt to hold the
 *                        result, memory has to be allocated by
 *                        caller
 * @param[in]   buffer    Pointerto the buffer containing the
 *                        octet string representation of the
 *                        integer
 * @param[in]   bufferLen The length of buffer in bytes
 * @param[in]   sign      The sign of dest is set to the sign of
 *                        sign
 *
 * @return
 * TEE_SUCCESS        : In case of success
 * TEE_ERROR_OVERFLOW : If memory allocation for the  dest is
 *                      too small
 *
 */
extern TEE_Result TEE_BigIntConvertFromOctetString(
  TEE_BigInt *dest,
  uint8_t *buffer, size_t bufferLen,
  int32_t sign);

/**
 * @brief The TEE_BigIntConvertToOctetString function converts
 *        the absolute value of an integer in TEE_BigInt format
 *        into an octet string. The octet string is written in a
 *        most significant byte first representation.
 *
 * @param[out]  buffer    Output buffer where converted octet
 *                        string representation of the integer
 *                        is written
 * @param[in]   bufferLen The length of buffer in bytes
 * @param[in]   bigInt    Pointer to the integer that will be
 *                        converted to an octet string
 *
 * @return
 * TEE_SUCCESS            : In case of success
 * TEE_ERROR_SHORT_BUFFER : If the output buffer is too small to
 *                          contain the octet string
 *
 */
extern TEE_Result TEE_BigIntConvertToOctetString(
  void *buffer, size_t *bufferLen,
  TEE_BigInt *bigInt);

/**
 * @brief The TEE_BigIntConvertFromS32 function sets *dest to
 *        the value shortVal
 *
 * @param[out]  dest      Pointer to a TEE_BigInt to store the
 *                        result, The result must have memory allocation
 *                        for holding a 32 bit signed value
 * @param[in]   shortVal  Input Value
 *
 * @return
 *
 */
extern void TEE_BigIntConvertFromS32(
  TEE_BigInt *dest,
  int32_t shortVal);

/**
 * @brief The TEE_BigIntConvertToS32 function sets *dest to the
 * value of src ,including the sign of src. If src does not fit
 * within an int32_t, the value of *dest is undefined
 *
 * @param[out]  dest      Pointer to an int32_t to store the
 *                        result
 * @param[in]   src       Pointer to an input value
 *
 * @return
 * TEE_SUCCESS            : In case of success
 * TEE_ERROR_OVERFLOW     : If the source does not fit within an
 *                          int32_t
 *
 */
extern TEE_Result TEE_BigIntConvertToS32(
  int32_t *dest,
  TEE_BigInt *src);

/**
 * Logical Operations
 */

/**
 * @brief The TEE_BigIntCmp function checks whether op1 > op2 ,
 * op1 == op2 , or op1 < op2
 *
 * @param[in]  op1      Pointer to first operand
 * @param[in]  op2      Pointer to second operand
 *
 * @return
 *     This function returns a negative number if op1 < op2,
 *                             0 if op1 == op2,
 *                             positive number if op1 > op2
 *
 */
extern int32_t TEE_BigIntCmp(
  TEE_BigInt *op1,
  TEE_BigInt *op2);

/**
 * @brief The TEE_BigIntCmpS32 function checks whether
 * op > shortVal , op == shortVal , or op < shortVal
 *
 * @param[in]  op       Pointer to first operand
 * @param[in]  shortVal Pointer to second operand
 *
 * @return
 *     This function returns a negative number if op < shortVal,
 *                             0 if op == shortVal,
 *                             positive number if op > shortVal
 *
 */
extern int32_t TEE_BigIntCmpS32(
  TEE_BigInt *op,
  int32_t shortVal);

/**
 * @brief The TEE_BigIntShiftRight function computes
 * |dest| = | op | >> bits and dest will have the same sign as
 * op. If bits is greater than the bit length of op then the
 * result is zero. It is allowed that dest and op point to the
 * same memory region.
 *
 * @param[out] dest     Pointer to TEE_BigInt to hold the
 *                      shifted result, memory allocated by
 *                      caller
 * @param[in]  op       Pointer to operand to be shifted
 * @param[in]  bits     Number of bits to shift
 *
 * @return
 *
 */
extern void TEE_BigIntShiftRight(
  TEE_BigInt *dest,
  TEE_BigInt *op,
    size_t bits);


/**
 *  @brief The TEE_BigIntGetBit function returns the bitIndexth
 *   bit of thenatural binary representation of |src|. A true
 *   return value indicates a 1 and a false return value
 *   indicates a 0 in the bitIndexth position. If bitIndex is
 *   larger than the number of bits in op , the return value is
 *   false, thus indicating a 0
 *
 * @param[in]  src      Pointer to the integer
 * @param[in]  bitIndex The offset of the bit to be read,
 *                      starting at offset 0 for the least
 *                      significant bit
 *
 * @return
 * The Boolean value of the bitIndexth bit in | src |
 * True represents a 1 and false represents a 0.
 *
 */
extern bool TEE_BigIntGetBit(
  TEE_BigInt *src,
  uint32_t bitIndex);


/**
 *  @brief The TEE_BigIntGetBitCount function returns the number
 *  of bits in the natural binary representation of |src|; that
 *  is, the magnitude of src
 *
 * @param[in]  src      Pointer to the integer
 *
 * @return
 * The number of bits in the natural binary representation of
 * |src |. If src equals zero, it will return 0
 *
 */
extern uint32_t TEE_BigIntGetBitCount(
  TEE_BigInt *src);


/**
 * Basic Arithmetic Operations
 */

/**
 *  @brief The TEE_BigIntAdd function computes dest = op1 + op2
 *  It is allowed that all or some of dest, op1, and op2 point
 *  to the same memory region.
 *  Result Size, Depending on the sign of op1 and op2, the
 *  result may be larger or smaller than op1 and op2. For the
 *  worst case, dest must have memory allocation for holding
 *  max(magnitude( op1), magnitude( op2 ))+ 1 bits
 *
 * @param[out]  dest      Pointer to TEE_BigInt to store the
 *                        result op1 + op2, pointer allocated by
 *                        caller
 * @param[in]   op1       Pointer to the first operand
 * @param[in]   op2       Pointer to the second operand
 *
 * @return
 *
 */
extern void TEE_BigIntAdd(
  TEE_BigInt *dest,
  TEE_BigInt *op1,
  TEE_BigInt *op2);

/**
 *  @brief The TEE_BigIntSub function computes dest = op1  op2.
 *  It is allowed that all or some of dest, op1, and op2 point
 *  to the same memory region.
 *  Result Size, Depending on the sign of op1 and op2, the
 *  result may be larger or smaller than op1 and op2. For the
 *  worst case, dest must have memory allocation for holding
 *  max(magnitude( op1), magnitude( op2 ))+ 1 bits
 *
 * @param[out]  dest      Pointer to TEE_BigInt to store the
 *                        result op1 - op2
 * @param[in]   op1       Pointer to the first operand
 * @param[in]   op2       Pointer to the second operand
 *
 * @return
 *
 */
extern void TEE_BigIntSub(
  TEE_BigInt *dest,
  TEE_BigInt *op1,
  TEE_BigInt *op2);

/**
 *  @brief The TEE_BigIntNeg function negates an operand:
 *  dest = -op. It is allowed that dest and op point to the
 *  same memory region
 *  ResultSize, The result must have memory allocation for
 *  magnitude(op) bits.
 *
 * @param[out]  dest      Pointer to TEE_BigInt to store the
 *                        result -op
 * @param[in]   op        Pointer to the operand to be negated
 *
 * @return
 *
 */
extern void TEE_BigIntNeg(
  TEE_BigInt *dest,
  TEE_BigInt *op);

/**
 *  @brief The TEE_BigIntMul function computes
 *  dest= op1 * op2. It is allowed that all or some of dest,
 *  op1 , and op2 point to the same memory region
 *  ResultSize, The result must have memory allocation for
 *  (magnitude(op1)+magnitude(op2)) bits.
 *
 * @param[out]  dest      Pointer to TEE_BigInt to store the
 *                        result op1 * op2
 * @param[in]   op1       Pointer to the first operand
 * @param[in]   op2       Pointer to the second operand
 *
 * @return
 *
 */
extern void TEE_BigIntMul(
  TEE_BigInt *dest,
  TEE_BigInt *op1,
  TEE_BigInt *op2);

/**
 *  @brief The TEE_BigIntSquare function computes
 *  dest = op * op. . It is allowed that dest and op point to
 *  the same memory region
 *  ResultSize, The result must have memory allocation for
 *  2*magnitude(op) bits
 *
 * @param[out]  dest      Pointer to TEE_BigInt to store the
 *                        result op * op
 * @param[in]   op        Pointer to the operand to be squared
 *
 * @return
 *
 */
extern void TEE_BigIntSquare(
  TEE_BigInt *dest,
  TEE_BigInt *op);


/**
 *  @brief The TEE_BigIntDiv function computes dest_r and dest_q
 *  such that op1 = dest_q * op2 + dest_r. It will round dest_q
 *  towards zero and dest_r will have the same sign as op1
 *
 *  If op2 equals zero this function will execute a divide by
 *  zero operation using the normal / operator for integers.
 *  This function has the limitation that the memory pointed to
 *  by dest_q and dest_r MUST NOT overlap. However it is
 *  possible that dest_q==op1 , dest_q==op2, dest_r==op1,
 *  dest_r==op2, when dest_q and dest_r do not overlap. It is
 *  allowed to pass a NULL pointer for either dest_q or dest_r
 *  in which case the implementation MAY take advantage of the
 *  fact that it is only required to calculate either dest_q or
 *  dest_r
 *  Result Sizes, The quotient, dest_q , must have memory
 *  allocation for
 *  0 bytes if |op1 | <= |op2| and
 *  magnitude(op1) magnitude(op2) if|op1| >| op2 |
 *  The remainder dest_r must have memory allocation to hold
 *  magnitude(op2) bits.
 *
 * @param[out]  dest_q      Pointer to a  TEE_BigInt  to store
 *                          the quotient. dest_q can be NULL
 * @param[out]  dest_r      Pointer to a  TEE_BigInt  to store
 *                          the remainder. dest_r can be NULL
 * @param[in]   op1         Pointer to the first operand, the
 *                          dividend
 * @param[in]   op2         Pointer to the second operand, the
 *                          divisor
 *
 * @return
 *
 */
extern void TEE_BigIntDiv(
  TEE_BigInt *dest_q,
  TEE_BigInt *dest_r,
  TEE_BigInt *op1,
  TEE_BigInt *op2);

/**
 * Modular Arithmetic Operations
 */

/**
 *  @brief The TEE_BigIntMod function computes dest = op(modn)
 *  such that 0 <= dest < n.
 *  It is allowed that dest and op point to the same memory
 *  region but n MUST point to a unique memory region. For
 *  negative op it follows the normal convention that
 *  -1 = (n-1)mod n
 *  Result Sizes, The result dest must have memory allocation
 *  for magnitude(n) bits
 *  Panic Reasons, n<2
 *
 * @param[out]  dest        Pointer to TEE_BigInt to hold the
 *                          result op * (modn). The result dest
 *                          will be in the interval [0, n - 1]
 * @param[in]   op          Pointer to the operand, to be
 *                          reduced mod n
 * @param[in]   n           Pointer to the modulus. Modulus must be larger than 1
 *
 * @return
 *
 */
extern void TEE_BigIntMod(
  TEE_BigInt *dest,
  TEE_BigInt *op,
  TEE_BigInt *n);

/**
 *  @brief The TEE_BigIntAddMod function computes
 *  dest=op1+op2(modn). It is allowed that all or some of dest,
 *  op1 , and op2 point to the same memory region but n MUST
 *  point to a unique memory region.
 *  Result Sizes, The result dest must have memory allocation
 *  for magnitude(n) bits
 *  Panic Reasons, n<2
 *
 * @param[out]  dest        Pointer to TEE_BigInt to hold the
 *                          result op1 + op2 (modn).
 * @param[in]   op1         Pointer to the first operand, must
 *                          be in the interval [0, n - 1]
 * @param[in]   op2         Pointer to the second operand, must
 *                          be in the interval [0, n - 1]
 * @param[in]   n           Pointer to the modulus. Modulus must be larger than 1
 *
 * @return
 *
 */
extern void TEE_BigIntAddMod(
  TEE_BigInt *dest,
  TEE_BigInt *op1,
  TEE_BigInt *op2,
  TEE_BigInt *n);

/**
 *  @brief The TEE_BigIntSubMod function computes
 *  dest = op1 - op2 (modn)
 *  It is allowed that all or some of dest , op1, and op2
 *  points to the same memory region but n MUST point to a
 *  unique memory region.
 *  Result Sizes, The result dest must have memory allocation
 *  for magnitude(n) bits
 *  Panic Reasons, n<2
 *
 * @param[out]  dest        Pointer to TEE_BigInt to hold the
 *                          result op1 - op2 (modn).
 * @param[in]   op1         Pointer to the first operand, must
 *                          be in the interval [0, n - 1]
 * @param[in]   op2         Pointer to the second operand, must
 *                          be in the interval [0, n - 1]
 * @param[in]   n           Pointer to the modulus. Modulus must be larger than 1
 *
 * @return
 *
 */
extern void TEE_BigIntSubMod(
  TEE_BigInt *dest,
  TEE_BigInt *op1,
  TEE_BigInt *op2,
  TEE_BigInt *n);

/**
 *  @brief The TEE_BigIntMulMod function computes
 *  dest=op1*op2(modn). It is allowed that all or some of dest,
 *  op1 , and op2 point to the same memory region but n  MUST
 *  point to a unique memory region
 *  Result Sizes, The result dest must have memory allocation
 *  for magnitude(n) bits
 *  Panic Reasons, n<2
 *
 * @param[out]  dest        Pointer to TEE_BigInt to hold the
 *                          result op1 * op2 (modn).
 * @param[in]   op1         Pointer to the first operand, must
 *                          be in the interval [0, n - 1]
 * @param[in]   op2         Pointer to the second operand, must
 *                          be in the interval [0, n - 1]
 * @param[in]   n           Pointer to the modulus. Modulus must be larger than 1
 *
 * @return
 *
 */
extern void TEE_BigIntMulMod(
  TEE_BigInt *dest,
  TEE_BigInt *op1,
  TEE_BigInt *op2,
  TEE_BigInt *n);

/**
 *  @brief The TEE_BigIntSquareMod function computes
 *  dest = op * op (modn). It is allowed that dest and op1 point
 *  to the same memory region but n MUST point to a unique
 *  memory region
 *  Result Sizes, The result dest must have memory allocation
 *  for magnitude(n) bits
 *  Panic Reasons, n<2
 *
 * @param[out]  dest        Pointer to TEE_BigInt to hold the
 *                          result op * op (modn).
 * @param[in]   op          Pointer to the operand, must
 *                          be in the interval [0, n - 1]
 * @param[in]   n           Pointer to the modulus. Modulus must be larger than 1
 *
 * @return
 *
 */
extern void TEE_BigIntSquareMod(
  TEE_BigInt *dest,
  TEE_BigInt *op,
  TEE_BigInt *n);

/**
 *  @brief The TEE_BigIntInvMod function computes dest such that
 *         dest * op = 1 (modn). It is allowed that dest and op
 *  point to the same memory region. This function assumes that
 *  gcd(op,n) is equal to 1, which can be checked by using the
 *  function in section 8.10.1. If gcd(op,n) is greater than 1
 *  then the result is unreliable
 *  Result Sizes, The result dest must have memory allocation
 *  for magnitude(n) bits
 *  Panic Reasons, n<2, op = 0
 *
 * @param[out]  dest        Pointer to TEE_BigInt to hold the
 *                          result op^-1 (modn).
 * @param[in]   op          Pointer to the operand, must
 *                          be in the interval [1, n - 1]
 * @param[in]   n           Pointer to the modulus. Modulus must be larger than 1
 *
 * @return
 *
 */
extern void TEE_BigIntInvMod(
  TEE_BigInt *dest,
    TEE_BigInt *op,
    TEE_BigInt *n);

/**
 * Other Arithmetic Operations
 */

/**
 *  @brief The TEE_BigIntRelativePrime function
 *  determines whether gcd(op1, op2)==1.
 *  It is allowed that op1 and op2 point to the same memory
 *  region
 *
 * @param[in]   op1          Pointer to the first operand
 * @param[in]   op2          Pointer to the second operand
 *
 * @return
 * true if gcd(op1,op2) == 1
 * false otherwise
 *
 */
extern bool TEE_BigIntRelativePrime(
  TEE_BigInt *op1,
  TEE_BigInt *op2);

/**
 *  @brief The TEE_BigIntComputeExtendedGcd function computes
 *  the greatest common divisor of the input parameters op1 and
 *  op2. Furthermore it computes the coefficients u and v such
 *  that u*op1+v*op2 == gcd It is allowed that op1 and op2 point
 *  to the same memory region. It is allowed that u , v , or
 *  both can be NULL. If both of them are NULL then the function
 *  only computes the gcd of op1 and op2.
 *  ResultSizes, The gcd result must be able to hold
 *  max(magnitude(op1),magnitude( op2 )) bits
 *  The absolute value of u is in the range [0, |op2/gcd|-1]
 *  The absolute value of v is in the range [0, |op2/gcd|-1]
 *
 * @param[out]   gcd          Pointer to TEE_BigInt to hold the
 *                            greatest common divisor of op1 and
 *                            op2
 * @param[out]   u            Pointer to TEE_BigInt to hold the
 *                            first coefficient
 * @param[out]   v            Pointer to TEE_BigInt to hold the
 *                            second coefficient
 * @param[in]    op1          Pointer to the first operand
 * @param[in]    op2          Pointer to the second operand
 *
 * @return
 *
 */
extern void TEE_BigIntComputeExtendedGcd(
  TEE_BigInt *gcd,
  TEE_BigInt *u,
  TEE_BigInt *v,
  TEE_BigInt *op1,
  TEE_BigInt *op2);

/**
 *  @brief The TEE_BigIntComputeExtendedGcd function computes
 *  the greatest common divisor of the input parameters op1 and
 *  op2. Furthermore it computes the coefficients u and v such
 *  that u*op1+v*op2 == gcd It is allowed that op1 and op2 point
 *  to the same memory region. It is allowed that u , v , or
 *  both can be NULL. If both of them are NULL then the function
 *  only computes the gcd of op1 and op2.
 *  ResultSizes, The gcd result must be able to hold
 *  max(magnitude(op1),magnitude( op2 )) bits
 *  The absolute value of u is in the range [0, |op2/gcd|-1]
 *  The absolute value of v is in the range [0, |op2/gcd|-1]
 *
 * @param[in] op              Candidate number that is tested
 *                            for primality
 * @param[in] confidenceLevel The desired confidence level for a
 *                            non conclusive test. This
 *                            parameter (usually) maps to the
 *                            number of iterations and thus to
 *                            the running time of the test.
 *                            Values smaller than 80 will be
 *                            treated as 80
 *
 * @return
 *  0 : If op is a composite number
 *  1 : If op is a prime number
 *  -1: If the test is nonconclusive but the probability that op
 *  is composite is less than 2^(-confidenceLevel)
 *
 */
extern int32_t TEE_BigIntIsProbablePrime(
  TEE_BigInt *op,
  uint32_t confidenceLevel);

/**
 * Fast Modular Multiplication Operations
 */

/**
 *  @brief The TEE_BigIntConvertToFMM function converts src in
 *  to a representation suitable for doing fast modular
 *  multiplication. If the operation is successful , the result
 *  will be written in implementation specific format into
 *  the buffer dest , which must have been allocated by the TA
 *  and initialized using TEE_BigIntInitFMM
 *
 * @param[out]   dest         Pointer to an initialized
 *                            TEE_BigIntFMM memory area
 * @param[in]    src          Pointer to TEE_BigInt to convert
 * @param[in]    n            Pointer to modulus
 * @param[in]    context      Pointer to the context previously
 *                            initialized using
 *                            TEE_BigIntInitFMMContext
 *
 * @return
 *
 */
extern void TEE_BigIntConvertToFMM(
  TEE_BigIntFMM *dest,
  TEE_BigInt *src,
  TEE_BigInt *n,
  TEE_BigIntFMMContext *context);

/**
 *  @brief The TEE_BigIntConvertFromFMM function converts src in
 *  the fast modular multiplication representation back to a
 *  TEE_BigIntrepresentation.
 *
 * @param[out]   dest         Pointer to an initialized
 *                            TEE_BigInt memory area to hold the
 *                            converted result
 * @param[in]    src          Pointer to a TEE_BigIntFMM holding
 *                            the value in the fast modular
 *                            multiplication representation
 * @param[in]    n            Pointer to modulus
 * @param[in]    context      Pointer to the context previously
 *                            initialized using
 *                            TEE_BigIntInitFMMContext
 *
 * @return
 *
 */
extern void TEE_BigIntConvertFromFMM(
  TEE_BigInt *dest,
  TEE_BigIntFMM *src,
  TEE_BigInt *n,
  TEE_BigIntFMMContext *context);

/**
 *  @brief The TEE_BigIntComputeFMM function calculates
 *  dest = op 1 * op2 in the fast modular multiplication
 *  representation. The pointers dest, op1 and op2 MUST all
 *  point to a TEE_BigIntFMM which has been previously
 *  initialized with the same modulus and context as used in
 *  this function call; otherwise the result is undefined. It is
 *  allowed that all or some of dest, op1, and op2 point to the
 *  same memory region.
 *
 * @param[out]   dest         Pointer to TEE_BigIntFMM to hold
 *                            the result op1 * op2 in the fast
 *                            modular multiplication
 *                            representation
 * @param[in]    op1          Pointer to the first operand
 * @param[in]    op2          Pointer to the second operand
 * @param[in]    n            Pointer to modulus
 * @param[in]    context      Pointer to the context previously
 *                            initialized using
 *                            TEE_BigIntInitFMMContext
 *
 * @return
 *
 */
extern void TEE_BigIntComputeFMM(
  TEE_BigIntFMM *dest,
  TEE_BigIntFMM *op1,
  TEE_BigIntFMM *op2,
  TEE_BigInt *n,
  TEE_BigIntFMMContext *context);

/**
 *  @brief The TEE_BigIntAbs function assigns the value of |src| to dest. 
 *  The parameters src and dest MAY point within the same memory region 
 *  but SHALL point to the start address of a TEE_BigInt.
 *
 * @param[out]   dest         Pointer to TEE_BigInt to be assigned.
 *
 * @param[in]    src          Pointer to the source operand.
 *
 * @return   
 *  TEE_SUCCESS            : In case of success
 *  TEE_ERROR_OVERFLOW     : In case the dest operand cannot hold the value of |src|.
 *
 */
extern TEE_Result TEE_BigIntAbs(
  TEE_BigInt *dest,
  TEE_BigInt *src);

/**
 *  @brief The TEE_BigIntSetBit function sets the bitIndexth bit of the natural 
 *  binary representation of |op| to 1 or 0, depending on the parameter value. 
 *  If value is true the bit will be set, and if value is false the bit will be cleared. 
 *  If bitIndex is larger than the number of bits in op, the function will return an 
 *  overflow error.
 *
 * @param[inout]   op        Pointer to the integer
 *
 * @param[in]      bitIndex  The offset of the bit to be set, starting at 
                             offset 0 for the least significant bit.
 * @param[in]      value     The bit value to set where true represents a “1” 
                             and false represents a "0".
 *
 * @return
 *  TEE_SUCCESS            : In case of success
 *  TEE_ERROR_OVERFLOW     : If the bitIndexth bit is larger than allocated bit length 
                             of op.
 */
extern TEE_Result TEE_BigIntSetBit(
  TEE_BigInt *op,
  uint32_t bitIndex,
  bool value);

/**
 *  @brief The TEE_BigIntAssign function assigns the value of src to dest. 
 *  The parameters src and dest MAY point within the same memory region 
 *  but SHALL point to the start address of a TEE_BigInt.
 *
 * @param[out]     dest      Pointer to TEE_BigInt to be assigned.
 *
 * @param[in]      src       Pointer to the source operand.
 *
 * @return
 *  TEE_SUCCESS            : In case of success
 *  TEE_ERROR_OVERFLOW     : In case the dest operand cannot hold the value of src.
 */
extern TEE_Result TEE_BigIntAssign(
  TEE_BigInt *dest,
  TEE_BigInt *src);

/**
 *  @brief The TEE_BigIntExpMod function computes dest = (op1 ^ op2) (mod n). 
 *  All or some of dest, op1, and op2 MAY point to the same memory region but 
 *  SHALL point to the start address of a TEE_BigInt. The value n SHALL point to 
 *  a unique memory region. In order to utilize the FMM capabilities, a pre-computed
 *  TEE_BigIntFMMContext1 MAY be supplied. The context parameter MAY be NULL. 
 *  If it is not NULL, the context SHALL be initialized using the same modulus n as 
 *  provided as parameter.
 *
 * @param[out]     dest      Pointer to TEE_BigInt to hold the result (op1 ^ op2) (mod n)
 *
 * @param[in]      op1       Pointer to the first operand. Operand SHALL be in the interval [0,n-1].
 * @param[in]      op2       Pointer to the second operand. Operand SHALL be non-negative.
 * @param[in]      n         Pointer to the modulus. Modulus SHALL be an odd integer larger than 2 
                             and less than 2 to the power of gpd.tee.arith.maxBigIntSize .
 * @param[in]      context   Pointer to a context previously initialized using 
                             TEE_BigIntInitFMMContext1, or NULL.
 *
 */
extern TEE_Result TEE_BigIntExpMod(
  TEE_BigInt *dest,
  TEE_BigInt *op1,
  TEE_BigInt *op2,
  TEE_BigInt *n,
  TEE_BigIntFMMContext *context );

/******************************************************************************
Data Storage functions (31)
******************************************************************************/
/**
 * Generic Objects
 */

/**
 * This function replaces the TEE_GetObjectInfo function, whose use is deprecated.
 *
 * @brief Gets info about transient or persistent object.
 *
 * The TEE_GetObjectInfo1 function returns the characteristics of an object.
 * It fills in the following fields in the structure TEE_ObjectInfo (section 5.3.2):
 *    objectType: The parameter objectType passed when the object was created
 *    keySize: The current size in bits of the object as determined by its attributes.
 *     This will always be less than or equal to maxKeySize. Set to 0 for uninitialized
 *     and data only objects.
 *    maxKeySize: The maximum keySize which this object can represent.
 *     o For a persistent object, set to keySize
 *     o For a transient object, set to the parameter maxKeySize passed to
 *       TEE_AllocateTransientObject
 *    objectUsage: A bit vector of the TEE_USAGE_XXX bits defined in Table 5-4.
 *    dataSize
 *     o For a persistent object, set to the current size of the data associated with the object
 *     o For a transient object, always set to 0
 *    dataPosition
 *     o For a persistent object, set to the current position in the data for this handle.
 *       Data positions for different handles on the same object may differ.
 *     o For a transient object, set to 0
 *    handleFlags: A bit vector containing one or more of the following flags:
 *     o TEE_HANDLE_FLAG_PERSISTENT: Set for a persistent object
 *     o TEE_HANDLE_FLAG_INITIALIZED
 *    For a persistent object, always set
 *    For a transient object, initially cleared, then set when the object becomes initialized
 *     o TEE_DATA_FLAG_XXX: Only for persistent objects, the flags used to open or create the object
 *
 * @param[in]   object      Handle on an object
 * @param[out]  objectInfo  A pointer to a TEE_ObjectInfo struct who's data members we'll be populated by the function
 *
 * @return   TEE_SUCCESS                Object info was copied form object.
 *           TEE_ERROR_BAD_PARAMETERS   Parameters were invalid to complete the operation
 *           TEE_ERROR_CORRUPT_OBJECT   If the persistent object is corrupt. The object handle is closed.
 *           TEE_ERROR_STORAGE_NOT_AVAILABLE   If the persistent object is stored in a storage area which is
 *                                             currently inaccessible.
 */
extern TEE_Result TEE_GetObjectInfo1(
    TEE_ObjectHandle object,
  TEE_ObjectInfo* objectInfo /*[out]*/);

/**
 * Use of this function is DEPRECATED - new code SHOULD use the TEE_GetObjectInfo1 function instead.
 *
 * @brief Gets info about transient or persistent object.
 *
 * The TEE_GetObjectInfo function returns the characteristics of an object.
 * It fills in the following fields in the structure TEE_ObjectInfo:
 *   objectType: The parameter objectType passed when the object was created
 *   objectSize: Set to 0 for an uninitialized object
 *   maxObjectSize
 *    o For a persistent object, set to objectSize
 *    o For a transient object, set to the parameter maxObjectSize passed to TEE_AllocateTransientObject
 *   objectUsage: A bit vector of the TEE_USAGE_XXX bits defined in Table 5-3. Initially set to 0xFFFFFFFF.
 *    Can be narrowed by calling TEE_SetRestrictUsage.
 *   dataSize
 *    o For a persistent object, set to the current size of the data associated with the object
 *    o For a transient object, always set to 0
 *   dataPosition
 *    o For a persistent object, set to the current position in the data for this handle.
 *      Data positions for different handles on the same object may differ.
 *    o For a transient object, set to 0
 *   handleFlags: A bit vector containing one or more of the following flags:
 *    o TEE_HANDLE_FLAG_PERSISTENT: Set for a persistent object
 *    o TEE_HANDLE_FLAG_INITIALIZED
 *   For a persistent object, always set
 *   For a transient object, initially cleared, then set when the object becomes initialized
 *    o TEE_DATA_FLAG_XXX: Only for persistent objects, the flags used to open or create the object
 *
 * @param[in]   object      Handle on an object
 * @param[out]  objectInfo  A pointer to a TEE_ObjectInfo struct who's data members we'll be populated by the function
 *
 * @return   TEE_SUCCESS                Object info was copied form object.
 *           TEE_ERROR_BAD_PARAMETERS   Parameters were invalid to complete the operation
 */
extern void TEE_GetObjectInfo(
    TEE_ObjectHandle object,
  TEE_ObjectInfo* objectInfo /*[out]*/);

/**
 * @brief This function replaces the TEE_RestrictObjectUsage function, whose use is deprecated.
 *
 * The TEE_RestrictObjectUsage1 function restricts the object usage flags of an object handle
 * to contain at most the flags passed in the objectUsage parameter.
 * For each bit in the parameter objectUsage:
 *   If the bit is set to 1, the corresponding usage flag in the object is left unchanged.
 *   If the bit is set to 0, the corresponding usage flag in the object is cleared.
 * For example, if the usage flags of the object are set to TEE_USAGE_ENCRYPT | TEE_USAGE_DECRYPT and
 * if objectUsage is set to TEE_USAGE_ENCRYPT | TEE_USAGE_EXTRACTABLE, then the only remaining usage
 * flag in the object after calling the function TEE_RestrictObjectUsage is TEE_USAGE_ENCRYPT.
 * Note that an object usage flag can only be cleared. Once it is cleared, it cannot be set to 1 again
 * until the whole object is reset using the function TEE_ResetObject. A transient objects object usage
 * flags are reset to 1 using the TEE_ResetTransientObject function. For a persistent object,
 * setting the object usage MUST be an atomic operation.
 *
 * @param[in] object        Handle on an object
 * @param[in] objectUsage   New object usage, an OR combination of one or more of the TEE_USAGE_XXX
 *                          constants defined in Table 5-3 in GP spec
 *
 * @return   TEE_SUCCESS                      Object info was copied form object.
 *           TEE_ERROR_CORRUPT_OBJECT         If the persistent object is corrupt. The object handle is
 *                                            closed.
 *           TEE_ERROR_STORAGE_NOT_AVAILABLE  If the persistent object is stored in a storage area which
 *                                            is currently inaccessible
 */
extern TEE_Result TEE_RestrictObjectUsage1(
    TEE_ObjectHandle object,
    uint32_t objectUsage);

/**
 * Use of this function is DEPRECATED - new code SHOULD use the TEE_RestrictObjectUsage1 function instead.
 *
 * @brief Restricts the usage permissions of a transient or persistent object.
 *
 * The TEE_RestrictObjectUsage function restricts the object usage flags of an object handle
 * to contain at most the flags passed in the objectUsage parameter.
 * For each bit in the parameter objectUsage:
 *   If the bit is set to 1, the corresponding usage flag in the object is left unchanged.
 *   If the bit is set to 0, the corresponding usage flag in the object is cleared.
 * For example, if the usage flags of the object are set to TEE_USAGE_ENCRYPT | TEE_USAGE_DECRYPT and
 * if objectUsage is set to TEE_USAGE_ENCRYPT | TEE_USAGE_EXTRACTABLE, then the only remaining usage
 * flag in the object after calling the function TEE_RestrictObjectUsage is TEE_USAGE_ENCRYPT.
 * Note that an object usage flag can only be cleared. Once it is cleared, it cannot be set to 1 again
 * until the whole object is reset using the function TEE_ResetObject. For a transient object, resetting
 * the object also clears all the key material stored in the container. For a persistent object,
 * setting the object usage MUST be an atomic operation.
 *
 * @param[in] object        Handle on an object
 * @param[in] objectUsage   New object usage, an OR combination of one or more of the TEE_USAGE_XXX
 *                          constants defined in Table 5-3 in GP spec
 *
 * @return   TEE_SUCCESS                Object info was copied form object.
 *           TEE_ERROR_BAD_PARAMETERS   Parameters were invalid to complete the operation
 */
extern void TEE_RestrictObjectUsage(
    TEE_ObjectHandle object,
    uint32_t objectUsage);

/**
 * @brief Extracts an attribute containing a buffer from a transient or persistent object.
 *
 * The TEE_GetObjectBufferAttribute function extracts one buffer attribute from an object.
 * The attribute is identified by the argument attributeID. The precise meaning of this parameter
 * depends on the container type and size and is defined in section 6.11.
 * Bit [29] of the attribute identifier must be set to 0, i.e., it must denote a buffer attribute.
 * They are two kinds of object attributes:
 *   Public object attributes can always be extracted whatever the status of the container.
 *   Secret attributes can be extracted only if the objects key usage contains the TEE_USAGE_EXTRACTABLE flag.
 * See section 6.11 for a definition of all available object attributes and their level of protection.
 *
 * @param[in]   object        Handle on an object
 * @param[in]   attributeID   Identifier of the attribute to retrieve
 * @param[out]  buffer        Output buffer to get the content of the attribute
 * @param[out]  size          Size of the output buffer
 *
 * @return
 * TEE_SUCCESS: In case of success
 * TEE_ERROR_ITEM_NOT_FOUND: If the attribute is not found on this object or if the object is a transient uninitialized object
 * TEE_ERROR_SHORT_BUFFER: If buffer is NULL or too small to contain the key part
 */

extern TEE_Result TEE_GetObjectBufferAttribute(
    TEE_ObjectHandle object,
    uint32_t attributeID,
  void* buffer, /*[outbuf]*/
  size_t* size);

/**
 * @brief Extracts an attribute containing two values from a transient or persistent object.
 *
 * The TEE_GetObjectValueAttribute function extracts a value attribute from an object.
 * The attribute is identified by the argument attributeID. The precise meaning of this parameter depends
 * on the container type and size and is defined in section 6.11.
 * Bit [29] of the attribute identifier must be set to 1, i.e., it must denote a value attribute.
 * They are two kinds of object attributes:
 *   Public object attributes can always be extracted whatever the status of the container.
 *   Secret attributes can be extracted only if the objects key usage contains the TEE_USAGE_EXTRACTABLE flag.
 * See section 6.11 for a definition of all available object attributes and their level of protection.
 *
 * @param[in]   object        Handle on an object
 * @param[in]   attributeID   Identifier of the attribute to retrieve
 * @param[out]  a             Pointer on the placeholder filled with the attribute field a. Can be NULL
 *                            if the corresponding field is not of interest to the caller.
 * @param[out]  b             Pointer on the placeholder filled with the attribute field b. Can be NULL
 *                            if the corresponding field is not of interest to the caller.
 *
 * @return
 * TEE_SUCCESS: In case of success
 * TEE_ERROR_ITEM_NOT_FOUND: If the attribute is not found on this object or if the object is a transient uninitialized object
 * TEE_ERROR_ACCESS_DENIED: For an attempt to extract a secret part of a non-extractable container
 */

extern TEE_Result TEE_GetObjectValueAttribute(
    TEE_ObjectHandle object,
    uint32_t attributeID,
  uint32_t* a, /*[outopt]*/
  uint32_t* b  /*[outopt]*/);

/**
 * @brief Closes an opened object handle.
 *
 * The TEE_CloseObject function closes an opened object handle. The object can be persistent or transient.
 *
 * @param[in]  object    Handle on an object
 */

extern void TEE_CloseObject(TEE_ObjectHandle object);

/**
 * Transient Objects
 */

/**
 * @brief allocates an uninitialized transient object, i.e., a
 *        container for attributes
 *
 * Transient objects are used to hold a cryptographic object
 * (key or key-pair). The object type and the maximum object
 * characteristic size must be specified so that all the
 * container resources can be pre-allocated
 *
 *  The returned handle is used to refer to the newly-created
 *  container in all subsequent functions that require an object
 *  container: key management and operation functions. The
 *  handle remains valid until the container is deallocated
 *  using the function TEE_FreeTransientObject.
 *
 *  the object type determines the possible object size:
 *
 *  Object Type                   Possible Object Sizes
 *  TEE_TYPE_AES                   128 or 256 bits
 *  TEE_TYPE_HMAC_SHA1             multiple of 8 bits
 *  TEE_TYPE_HMAC_SHA256           multiple of 8 bits
 *  TEE_TYPE_RSA_PUBLIC_KEY        Object size is the number of
 *                                 bits in the modulus. Upto
 *                                 4096 bits
 *  TEE_TYPE_RSA_KEYPAIR           Same as for RSA public key
 *  size.
 *
 * @param[in]  objectType     Type of uninitialized object container to be created
 * @param[in]  maxObjectSize  Size of the object as described
 *                            above
 * @param[out]  object        Filled with a handle on the newly created key container
 *
 * @return   TEE_SUCCESS                handle created
 *           TEE_ERROR_OUT_OF_MEMORY   not enough resources
 *                                     are available to allocate
 *                                     the object handle
 *           TEE_ERROR_NOT_SUPPORTED   Not supported Object type
 */
extern TEE_Result TEE_AllocateTransientObject(
    uint32_t objectType,
    uint32_t maxObjectSize,
    TEE_ObjectHandle* object /*[out]*/);

/**
 * @brief deallocates a transient object previously allocated with TEE_AllocateTransientObject
 *
 * After this function has been called, the object handle is no
 *  longer valid and all resources associated with the transient
 *  object must have been reclaimed
 *
 *
 * @param[in]  object        Handle on the object to free
 *
 * @return
 *
 */
extern void TEE_FreeTransientObject(
    TEE_ObjectHandle object);

/**
 * @brief resets a transient object to its initial state after allocation
 *
 * If the object is currently initialized, the function clears
 *  the object of all its material. The object is then
 *  uninitialized again.
 *
 * @param[out]  object        handle on transient object to
 *                            reset
 *
 * @return
 *
 */
extern void TEE_ResetTransientObject(
    TEE_ObjectHandle object);

/**
 * @brief populates an uninitialized object container with object attributes passed by the TA in the attrs parameter.
 *
 *
 *  the object type determines the possible attributes:
 *
 *  Object Type                   Possible attrs
 *  TEE_TYPE_AES                   For all secret key objects, the TEE_ATTR_SECRET_VALUE must be provided.
 *  TEE_TYPE_DES                   same as TEE_TYPE_AES, buffer associated must include parity bits
 *  TEE_TYPE_DES3                  same as TEE_TYPE_AES, buffer associated must include parity bits
 *  TEE_TYPE_HMAC_MD5              same as TEE_TYPE_AES
 *  TEE_TYPE_HMAC_SHA1             same as TEE_TYPE_AES
 *  TEE_TYPE_HMAC_SHA224           same as TEE_TYPE_AES
 *  TEE_TYPE_HMAC_SHA256           same as TEE_TYPE_AES
 *  TEE_TYPE_HMAC_SHA384           same as TEE_TYPE_AES
 *  TEE_TYPE_HMAC_SHA512           same as TEE_TYPE_AES
 *  TEE_TYPE_GENERIC_KEY           same as TEE_TYPE_AES
 *  TEE_TYPE_RSA_PUBLIC_KEY        TEE_ATTR_RSA_MODULUS
 *                                 TEE_ATTR_RSA_PUBLIC_EXPONENT
 *  TEE_TYPE_RSA_KEYPAIR           TEE_ATTR_RSA_MODULUS
 *                                 TEE_ATTR_RSA_PUBLIC_EXPONENT
 *                                 TEE_ATTR_RSA_PRIVATE_EXPONENT
 *                                 The CRT parameters are optional. If any of these parts is provided,
 *                                 then all of them must be provided:
 *                                 TEE_ATTR_RSA_PRIME1 (p)
 *                                 TEE_ATTR_RSA_PRIME2 (q)
 *                                 TEE_ATTR_RSA_EXPONENT1 (dP)
 *                                 TEE_ATTR_RSA_EXPONENT2 (dQ)
 *                                 TEE_ATTR_RSA_COEFFICIENT (pQ)
 *  TEE_TYPE_ECDSA_PUBLIC_KEY      Conditional: If ECC is supported, then the following parts MUST
 *                                 be provided.
 *                                 TEE_ATTR_ECC_PUBLIC_VALUE_X
 *                                 TEE_ATTR_ECC_PUBLIC_VALUE_Y
 *                                 TEE_ATTR_ECC_CURVE
 *  TEE_TYPE_ECDSA_KEYPAIR         Conditional: If ECC is supported, then the following parts MUST
 *                                 be provided.
 *                                 TEE_ATTR_ECC_PRIVATE_VALUE
 *                                 TEE_ATTR_ECC_PUBLIC_VALUE_X
 *                                 TEE_ATTR_ECC_PUBLIC_VALUE_Y
 *                                 TEE_ATTR_ECC_CURVE
 *  TEE_TYPE_ECDH_PUBLIC_KEY       Conditional: If ECC is supported, then the following parts MUST
 *                                 be provided.
 *                                 TEE_ATTR_ECC_PUBLIC_VALUE_X
 *                                 TEE_ATTR_ECC_PUBLIC_VALUE_Y
 *                                 TEE_ATTR_ECC_CURVE
 *  TEE_TYPE_ECDH_KEYPAIR          Conditional: If ECC is supported, then the following parts MUST
 *                                 be provided.
 *                                 TEE_ATTR_ECC_PRIVATE_VALUE
 *                                 TEE_ATTR_ECC_PUBLIC_VALUE_X
 *                                 TEE_ATTR_ECC_PUBLIC_VALUE_Y
 *                                 TEE_ATTR_ECC_CURVE
 *  TEE_TYPE_DSA_PUBLIC_KEY        TEE_ATTR_DSA_PRIME
 *                                 TEE_ATTR_DSA_SUBPRIME
 *                                 TEE_ATTR_DSA_BASE
 *                                 TEE_DSA_PUBLIC_VALUE
 *  TEE_TYPE_DSA_KEYPAIR           TEE_ATTR_DSA_PRIME
 *                                 TEE_ATTR_DSA_SUBPRIME
 *                                 TEE_ATTR_DSA_BASE
 *                                 TEE_ATTR_DSA_PRIVATE_VALUE
 *                                 TEE_ATTR_DSA_PUBLIC_VALUE
 *  TEE_TYPE_DH_KEYPAIR            TEE_ATTR_DH_PRIME
 *                                 TEE_ATTR_DH_BASE
 *                                 TEE_ATTR_DH_PUBLIC_VALUE
 *                                 TEE_ATTR_DH_PRIVATE_VALUE
 *                                 Optionally, TEE_ATTR_DH_SUBPRIME may be provided
 *
 * @param[in]  object        Handle on an already created
 *                           transient and uninitialized object
 * @param[in]  attrs         Array of object attributes
 * @param[in]  attrCount     number of elements in attrs array
 *
 * @return   TEE_SUCCESS               object populated
 *           TEE_ERROR_OUT_OF_MEMORY   not enough resources
 *                                     are available to allocate
 *                                     the object handle
 *           TEE_ERROR_BAD_PARAMETERS  Incorrect input
 *                                     parameters
 */
extern TEE_Result TEE_PopulateTransientObject(
    TEE_ObjectHandle object,
  TEE_Attribute* attrs, /*[in]*/
  uint32_t attrCount);

  /**
 * @brief populate a single attribute with a reference to
 *        a buffer
 *
 * @param[out]  attr          handle on transient object to
 *                            reset
 * @param[in]   attributeID   attribute Type
 * @param[in]   buffer        buffer holding data
 * @param[in]   length        size of buffer in bytes
 *
 * @return
 *
 */
extern void TEE_InitRefAttribute(
    TEE_Attribute* attr, /*[out]*/
    uint32_t attributeID,
  void* buffer, /*[inbuf]*/
  size_t length);

/**
 * @brief populate a single attribute with integer values
 *
 * @param[out]  attr          handle on transient object to
 *                            reset
 * @param[in]   attributeID   attribute Type
 * @param[in]   a             data
 * @param[in]   b             data
 *
 * @return
 *
 */
extern void TEE_InitValueAttribute(
    TEE_Attribute* attr, /*[out]*/
    uint32_t attributeID,
  uint32_t a,
  uint32_t b);

/**
 * This function replaces the TEE_CopyObjectAttributes function, whose use is deprecated
 *
 * @brief populates an uninitialized object handle with the
 *        attributes of another object handle
 *
 * populates the attributes of destObject with the attributes of
 * srcObject. It is most useful in the following situations
 *  To extract the public key attributes from a key-pair object
 *  To copy the attributes from a persistent object into a
 * transient object
 * destObject MUST refer to an uninitialized object handle and MUST therefore
 * be a transient object
 * The source and destination objects must have compatible types
 * and sizes in the following sense:
 *   The type of destObject must be a subtype of srcObject,
 *  i.e., one of the following must be true:
 *        o The type of destObject is equal to the type of
 *        srcObject.
 *        o The type of destObject is TEE_TYPE_RSA_PUBLIC_KEY
 *        and the type of srcObject is TEE_TYPE_RSA_KEYPAIR.
 *        o The type of destObject is TEE_TYPE_DSA_PUBLIC_KEY
 *        and the type of srcObject is TEE_TYPE_DSA_KEYPAIR.
 *        o The type of destObject is TEE_TYPE_ECDSA_PUBLIC_KEY
 *        and the type of srcObject is TEE_TYPE_ECDSA_KEYPAIR.
 *        o The type of destObject is TEE_TYPE_ECDH_PUBLIC_KEY
 *        and the type of srcObject is TEE_TYPE_ECDH_KEYPAIR.
 *    The size of srcObject must be less than or equal to the
 *   maximum size of destObject.
 *
 * @param[in]  destObject    Handle on an uninitialized
 *                           transient object
 * @param[in]  srcObject     Handle on an initialized object
 *
 * @return   TEE_SUCCESS                      destObject populated
 *           TEE_ERROR_CORRUPT_OBJECT         If the persistent object is corrupt
 *                                            the object handle is closed.
 *           TEE_ERROR_STORAGE_NOT_AVAILABLE  If the persistent object is stored
 *                                            in a storage area which is currently
 *                                            inaccessible
 */
extern TEE_Result TEE_CopyObjectAttributes1(
    TEE_ObjectHandle destObject,
    TEE_ObjectHandle srcObject);

/**
 * @brief populates an uninitialized object handle with the
 *        attributes of another object handle
 *
 * populates the attributes of destObject with the attributes of
 * srcObject. It is most useful in the following situations
 *  To extract the public key attributes from a key-pair object
 *  To copy the attributes from a persistent object into a
 * transient object
 * The source and destination objects must have compatible types
 * and sizes in the following sense:
 *   The type of destObject must be a subtype of srcObject,
 *  i.e., one of the following must be true:
 *        o The type of destObject is equal to the type of
 *        srcObject.
 *        o The type of destObject is TEE_TYPE_RSA_PUBLIC_KEY
 *        and the type of srcObject is TEE_TYPE_RSA_KEYPAIR.
 *    The size of srcObject must be less than or equal to the
 *   maximum size of destObject.
 *
 * @param[in]  destObject    Handle on an uninitialized
 *                           transient object
 * @param[in]  srcObject     Handle on an initialized object
 *
 * @return   TEE_SUCCESS               destObject populated
 *           TEE_ERROR_OUT_OF_MEMORY   not enough resources
 *                                     are available to allocate
 *                                     the object handle
 *           TEE_ERROR_BAD_PARAMETERS  Incorrect input
 *                                     parameters
 */

extern void TEE_CopyObjectAttributes(
    TEE_ObjectHandle destObject,
    TEE_ObjectHandle srcObject);

/**
 * @brief generates a random key or a key-pair and
 *        populates a transient key object with the
 *        generated key material.
 *
 * The size of the desired key is passed in the keySize
 * parameter and must be less than the maximum size
 * of the transient object.
 *
 * Object Type              Details
 * TEE_TYPE_AES              No Parameters necessary. The function generates the
 *                           attribute TEE_ATTR_SECRET_VALUE. The generated value
 *                           SHALL be the full key size.
 * TEE_TYPE_DES              As TEE_TYPE_AES
 * TEE_TYPE_DES3             As TEE_TYPE_AES
 * TEE_TYPE_HMAC_MD5         As TEE_TYPE_AES
 * TEE_TYPE_HMAC_SHA1        As TEE_TYPE_AES
 * TEE_TYPE_HMAC_SHA224      As TEE_TYPE_AES
 * TEE_TYPE_HMAC_SHA256      As TEE_TYPE_AES
 * TEE_TYPE_HMAC_SHA384      As TEE_TYPE_AES
 * TEE_TYPE_HMAC_SHA512      As TEE_TYPE_AES
 * TEE_TYPE_GENERIC_SECRET   As TEE_TYPE_AES
 *
 * TEE_TYPE_RSA_KEYPAIR      No parameter required
 *                           TEE_ATTR_RSA_PUBLIC_EXPONENT maybe be specifed;
 *                           if omitted the default is 65537
 *
 * TEE_TYPE_DSA_KEYPAIR      The following domain parameters MUST be passed:
 *                           TEE_ATTR_DSA_PRIME
 *                           TEE_ATTR_DSA_SUBPRIME
 *                           TEE_ATTR_DSA_BASE
 *
 * TEE_TYPE_DH_KEYPAIR       The following domain parameters MUST be passed:
 *                           TEE_ATTR_DH_PRIME
 *                           TEE_ATTR_DH_BASE
 *                           Optionally passed:
 *                           TEE_ATTR_DH_SUBPRIME
 *                           TEE_ATTR_DH_X_BITS
 * TEE_TYPE_ECDSA_KEYPAIR    The following domain parameters MUST be passed:
 *                           TEE_ATTR_ECC_CURVE
 *
 * TEE_TYPE_ECDH_KEYPAIR     The following domain parameters MUST be passed:
 *                           TEE_ATTR_ECC_CURVE
 *
 * @param[in]  object        Handle on an uninitialized transient key to
 *                           populate with the generated key
 * @param[in]  keySize       Requested key size in bits. Must be less than or equal
 *                           to the maximum size of the object container
 * @param[in]  params        Array of attribute parameters for key generation
 * @param[in]  paramCount    Number of params
 *
 * @return   TEE_SUCCESS                Key generated
 *           TEE_ERROR_GENERIC          Hardware/Software
 *                                      failure
 *           TEE_ERROR_BAD_PARAMETERS   Incorrect input
 *                                      parameters
 */

extern TEE_Result TEE_GenerateKey(
  TEE_ObjectHandle object,
    uint32_t keySize,
    TEE_Attribute* params,
  uint32_t paramCount);

/**
 * Persistent Objects
 */

/**
 * @brief Opens a handle on an existing persistent object
 *
 * Returns a handle that can be used to access the objects attributes and data stream.
 * The storageID parameter indicates which Trusted Storage Space to access.
 * The flags parameter is a set of flags that controls the access rights and sharing
 * permissions with which the object handle is opened. The value of the flags parameter
 * is constructed by a bitwise-inclusive OR of flags from the following list:
 *
 * Access control flags:
 *   - TEE_DATA_FLAG_ACCESS_READ:
 *     The object is opened with the read access right. This allows the Trusted Application
 *     to call the function TEE_ReadObjectData.
 *   - TEE_DATA_FLAG_ACCESS_WRITE:
 *     The object is opened with the write access right. This allows the Trusted Application
 *     to call the functions TEE_WriteObjectData and TEE_TruncateObjectData.
 *   - TEE_DATA_FLAG_ACCESS_WRITE_META:
 *     The object is opened with the write-meta access right. This allows the Trusted
 *     Application to call the functions TEE_CloseAndDeletePersistentObject and
 *     TEE_RenamePersistentObject.
 *
 * Sharing permission control flags:
 *   - TEE_DATA_FLAG_SHARE_READ:
 *     The caller allows another handle on the object to be created with read access.
 *   - TEE_DATA_FLAG_SHARE_WRITE:
 *    The caller allows another handle on the object to be created with write access.
 *   - TEE_DATA_FLAG_OVERWRITE:
 *     If this flag is present and the object exists, then the object is deleted and
 *     re-created as an atomic operation: that is the TA sees either the old object or
 *     the new one. If the flag is absent and the object exists, then the function SHALL
 *     return TEE_ERROR_ACCESS_CONFLICT.
 *
 * Other flags are reserved for future use and SHALL be set to 0.
 *
 * Multiple handles may be opened on the same object simultaneously, but sharing MUST be
 * explicitly allowed.
 * The initial data position in the data stream is set to 0.
 * Every Trusted Storage implementation is expected to return TEE_ERROR_CORRUPT_OBJECT if
 * a Trusted Application attempts to open an object and the TEE determines that its contents
 * (or those of the storage itself) have been tampered with or rolled back.
 *
 * @param[in]  storageID    The storage to use. It must be TEE_STORAGE_PRIVATE.
 * @param[in]  objectID     The object identifier. Note that this cannot reside in shared
 *                          memory.
 * @param[in]  objectIDLen  Length of objectID
 * @param[in]  flags        The flags which determine the settings under which the object
 *                          is opened.
 * @param[out] object       A pointer to the handle, which contains the opened handle upon
 *                          successful completion. If this function fails for any reason,
 *                          the value pointed to by object is set to TEE_HANDLE_NULL. When
 *                          the object handle is no longer required, it MUST be closed using
 *                          a call to the TEE_CloseObject function.
 *
 * @return
 * TEE_SUCCESS:                     In case of success
 * TEE_ERROR_ITEM_NOT_FOUND:        If the storage denoted by storageID does not exist or if
 *                                 the object identifier cannot be found in the storage
 * TEE_ERROR_ACCESS_CONFLICT:       If an access right conflict was detected while opening the
 *                                object
 * TEE_ERROR_OUT_OF_MEMORY:         If there is not enough memory to complete the operation
 * TEE_ERROR_CORRUPT_OBJECT:        If the storage is corrupt
 * TEE_ERROR_STORAGE_NOT_AVAILABLE: If the persistent object is stored in a storage area which
 *                                is currently inaccessible.
 *
 */
extern TEE_Result TEE_OpenPersistentObject(
  uint32_t storageID,
  void* objectID,
  size_t objectIDLen,
  uint32_t flags,
  TEE_ObjectHandle* object);

/**
 * The TEE_CreatePersistentObject function creates a persistent object with initial attributes
 * and an initial data stream content, and optionally returns either a handle on the created
 * object, or TEE_HANDLE_NULL upon failure.
 * The storageID parameter indicates which Trusted Storage Space to access
 * The flags parameter is a set of flags that controls the access rights, sharing permissions,
 * and object creation mechanism with which the object handle is opened. The value of the flags
 * parameter is constructed by a bitwise-inclusive OR of flags from the following list:
 *
 *  Access control flags:
 *    - TEE_DATA_FLAG_ACCESS_READ:
 *      The object is opened with the read access right. This allows the Trusted Application
 *      to call the function TEE_ReadObjectData.
 *    - TEE_DATA_FLAG_ACCESS_WRITE:
 *      The object is opened with the write access right. This allows the Trusted Application
 *      to call the functions TEE_WriteObjectData and TEE_TruncateObjectData.
 *    - TEE_DATA_FLAG_ACCESS_WRITE_META:
 *      The object is opened with the write-meta access right. This allows the Trusted
 *      Application to call the functions TEE_CloseAndDeletePersistentObject and
 *      TEE_RenamePersistentObject.
 *
 *  Sharing permission control flags:
 *    - TEE_DATA_FLAG_SHARE_READ:
 *      The caller allows another handle on the object to be created with read access.
 *    - TEE_DATA_FLAG_SHARE_WRITE:
 *      The caller allows another handle on the object to be created with write access.
 *    - TEE_DATA_FLAG_OVERWRITE:
 *      If this flag is present and the object exists, then the object is deleted and
 *      re-created as an atomic operation: that is the TA sees either the old object or
 *      the new one. If the flag is absent and the object exists, then the function SHALL
 *      return TEE_ERROR_ACCESS_CONFLICT.
 *
 * Other flags are reserved for future use and SHALL be set to 0.
 *
 * The attributes of the newly created persistent object are taken from attributes, which can
 * be another persistent object or an initialized transient object. The attributes argument
 * can also be NULL for a pure data object. The object type, size, and usage are copied from
 * attributes. If attributes is NULL, the object type SHALL be set to TEE_TYPE_DATA to create
 * a pure data object.
 * Multiple handles may be opened on the same object simultaneously, but sharing MUST be
 * explicitly allowed.
 * The initial data position in the data stream is set to 0.
 *
 * @param[in] storageID      The storage to use. It must be TEE_STORAGE_PRIVATE.
 * @param[in] objectID       The object identifier. Note that this cannot reside in shared
 *                           memory.
 * @param[in] objectIDLen    Length of objectID
 * @param[in] flags          The flags which determine the settings under which the object
 *                           is opened
 * @param[in] attributes     A handle on a persistent object or an initialized transient
 *                           object from which to take the persistent object attributes.
 *                           Can be TEE_HANDLE_NULL if the persistent object contains no
 *                           attribute; for example, if it is a pure data object.
 * @param[in] initialData    The initial data content of the persistent object
 * @param[in] initialDataLen Length of initialData
 * @param[out] object        A pointer to the handle, which contains the opened handle upon
 *                           successful completion. If this function fails for any reason,
 *                           the value pointed to by object is set to TEE_HANDLE_NULL. When
 *                           the object handle is no longer required, it MUST be closed using
 *                           a call to the TEE_CloseObject function.
 *
 * @return
 * TEE_SUCCESS:                      In case of success
 * TEE_ERROR_ITEM_NOT_FOUND:         If the storage denoted by storageID does not exist or if
 *                                   the object identifier cannot be found in the storage
 * TEE_ERROR_ACCESS_CONFLICT:        If an access right conflict was detected while opening the
 *                                   object
 * TEE_ERROR_OUT_OF_MEMORY:          If there is not enough memory to complete the operation
 * TEE_ERROR_STORAGE_NO_SPACE:       If insufficient space is available to create the persistent
 *                                   object
 * TEE_ERROR_CORRUPT_OBJECT:         If the storage is corrupt
 * TEE_ERROR_STORAGE_NOT_AVAILABLE:  If the persistent object is stored in a storage area which
 *                                   is currently inaccessible.
 *
 **/
extern TEE_Result TEE_CreatePersistentObject(
  uint32_t storageID,
  void* objectID, size_t objectIDLen,
  uint32_t flags,
  TEE_ObjectHandle attributes,
  void* initialData, size_t initialDataLen,
  TEE_ObjectHandle* object);

/**
 * The TEE_CloseAndDeletePersistentObject1 function marks an object for deletion and closes
 * the object handle.
 * The object handle MUST have been opened with the write-meta access right, which means
 * access to the object is exclusive.
 * Deleting an object is atomic; once this function returns, the object is definitely deleted
 * and no more open handles for the object exist. This SHALL be the case even if the object or
 * the storage containing it have become corrupted.
 * The only reason this routine can fail is if the storage area containing the object becomes
 * inaccessible (e.g. the user removes the media holding the object). In this case
 * TEE_ERROR_STORAGE_NOT_AVAILABLE SHALL be returned.
 * If object is TEE_HANDLE_NULL, the function does nothing.
 *
 * @param[in] object   The object handle
 *
 * @return
 *
 **/
extern TEE_Result TEE_CloseAndDeletePersistentObject1( TEE_ObjectHandle object );

/**
 * Use of this function is DEPRECATED  new code SHOULD use the
 * TEE_CloseAndDeletePersistentObject1 function instead.
 *
 * The TEE_CloseAndDeletePersistentObject function marks an object for deletion and closes
 * the object handle.
 * The object handle MUST have been opened with the write-meta access right, which means
 * access to the object is exclusive.
 * Deleting an object is atomic; once this function returns, the object is definitely deleted
 * and no more open handles for the object exist. This SHALL be the case even if the object or
 * the storage containing it have become corrupted.
 * If the storage containing the object is unavailable then this routine SHALL panic.
 * If object is TEE_HANDLE_NULL, the function does nothing.
 *
 * @param[in] object   The object handle
 *
 * @return
 *
 **/
extern void TEE_CloseAndDeletePersistentObject(TEE_ObjectHandle object);

/**
 * The function TEE_RenamePersistentObject changes the identifier of an object. The object
 * handle MUST have been opened with the write-meta access right, which means access to the
 * object is exclusive.
 * Renaming an object is an atomic operation; either the object is renamed or nothing happens.
 *
 * @param[in] object         The object handle
 * @param[in] newObjectID    A buffer containing the new object identifier. The identifier
 *                           contains arbitrary bytes, including the zero byte. The buffer
 *                           containing the new object identifier cannot reside in shared
 *                           memory.
 * @param[in] newObjectIDLen The identifier length MUST be less than or equal to
 *                           TEE_OBJECT_ID_MAX_LEN and can be zero.
 *
 * @return
 * TEE_SUCCESS:                      In case of success
 * TEE_ERROR_ACCESS_CONFLICT:        If an object with the same identifier already exists
 * TEE_ERROR_CORRUPT_OBJECT:         If the storage is corrupt
 * TEE_ERROR_STORAGE_NOT_AVAILABLE:  If the persistent object is stored in a storage area which
 *                                   is currently inaccessible.
 *
 **/
extern TEE_Result TEE_RenamePersistentObject(
  TEE_ObjectHandle object,
    void* newObjectID,
  size_t newObjectIDLen);

/**
 * The TEE_AllocatePersistentObjectEnumerator function allocates a handle on an object
 * enumerator. Once an object enumerator handle has been allocated, it can be reused for
 * multiple enumerations.
 *
 * @param[out] objectEnumerator   A pointer filled with the newly-allocated object
 *                               enumerator handle on success. Set to TEE_HANDLE_NULL
 *                               in case of error.
 *
 * @return
 * TEE_SUCCESS:              In case of success
 * TEE_ERROR_OUT_OF_MEMORY:  If there is not enough memory to allocate the enumerator
 *                           handle
 *
 **/
extern TEE_Result TEE_AllocatePersistentObjectEnumerator(
  TEE_ObjectEnumHandle* objectEnumerator);

/**
 * The TEE_FreePersistentObjectEnumerator function deallocates all resources associated
 * with an object enumerator handle. After this function is called, the handle is no longer
 * valid.
 *
 * @param[in] objectEnumerator  The handle to close. If objectEnumerator is TEE_HANDLE_NULL,
 *                             then this function does nothing.
 *
 **/
extern void TEE_FreePersistentObjectEnumerator(
  TEE_ObjectEnumHandle objectEnumerator);

/**
 * The TEE_ResetPersistentObjectEnumerator function resets an object enumerator handle to
 * its initial state after allocation. If an enumeration has been started, it is stopped.
 * This function does nothing if objectEnumerator is TEE_HANDLE_NULL.
 *
 * @param[in] objectEnumerator  The handle to reset.
 *
 **/
extern void TEE_ResetPersistentObjectEnumerator(
  TEE_ObjectEnumHandle objectEnumerator);

/**
The TEE_StartPersistentObjectEnumerator function starts the enumeration of all the
persistent objects in a given Trusted Storage. The object information can be retrieved
by calling the function TEE_GetNextPersistentObject repeatedly.
The enumeration does not necessarily reflect a given consistent state of the storage:
During the enumeration, other TAs or other instances of the TA may create, delete, or
rename objects. It is not guaranteed that all objects will be returned if objects are
created or destroyed while the enumeration is in progress.
To stop an enumeration, the TA can call the function TEE_ResetPersistentObjectEnumerator,
which detaches the enumerator from the Trusted Storage. The TA can call the function
TEE_FreePersistentObjectEnumerator to completely deallocate the object enumerator.
If this function is called on an enumerator that has already been started, the enumeration
is first reset then started.

@param[in] objectEnumerator   A valid handle on an object enumerator
@param[in] storageID          The identifier of the storage in which the objects MUST be
                              enumerated.

@return
TEE_SUCCESS:                     In case of success
TEE_ERROR_ITEM_NOT_FOUND:        If the storage does not exist or if there is no object
                                 in the specified storage
TEE_ERROR_CORRUPT_OBJECT:        If the storage is corrupt
TEE_ERROR_STORAGE_NOT_AVAILABLE: If the persistent object is stored in a storage area
                                 which is currently inaccessible.
*/
extern TEE_Result TEE_StartPersistentObjectEnumerator(
  TEE_ObjectEnumHandle objectEnumerator,
  uint32_t storageID);

/**
 * The TEE_GetNextPersistentObject function gets the next object in an enumeration and
 * returns information about the object: type, size, identifier, etc.
 * If there are no more objects in the enumeration or if there is no enumeration started,
 * then the function returns TEE_ERROR_ITEM_NOT_FOUND.
 * If while enumerating objects a corrupt object is detected, then its object ID SHALL
 * be returned in objectID, objectInfo shall be zeroed, and the function SHALL return
 * TEE_ERROR_CORRUPT_OBJECT.
 *
 * @param[in]  objectEnumerator  A handle on the object enumeration
 * @param[out] objectInfo        A pointer to a TEE_ObjectInfo filled with the object
 *                               information as specified in the function TEE_GetObjectInfo1
 *                               in section 5.5.1. It may be NULL.
 * @param[out] objectID          Pointer to an array able to hold at least TEE_OBJECT_ID_MAX_LEN
 *                               bytes. On exit the object identifier is written to this location.
 * @param[out] objectIDLen       Filled with the size of the object identifier (from 0 to
 *                               TEE_OBJECT_ID_MAX_LEN)
 *
 * @return
 * TEE_SUCCESS:                     In case of success
 * TEE_ERROR_ITEM_NOT_FOUND:        If there are no more elements in the object enumeration
 *                                  or if no enumeration is started on this handle
 * TEE_ERROR_CORRUPT_OBJECT:        If the storage or returned object is corrupt
 * TEE_ERROR_STORAGE_NOT_AVAILABLE: If the persistent object is stored in a storage area
 *                                  which is currently inaccessible.
 **/
extern TEE_Result TEE_GetNextPersistentObject(
  TEE_ObjectEnumHandle objectEnumerator,
  TEE_ObjectInfo* objectInfo,
  void* objectID,
  size_t* objectIDLen);

/**
 * The TEE_ReadObjectData function attempts to read size bytes from the data stream associated
 * with the object object into the buffer pointed to by buffer.
 * The object handle MUST have been opened with the read access right.
 * The bytes are read starting at the position in the data stream currently stored in the
 * object handle. The handles position is incremented by the number of bytes actually read.
 * On completion TEE_ReadObjectData sets the number of bytes actually read in the uint32_t
 * pointed to by count. The value written to *count may be less than size if the number of
 * bytes until the end-ofstream is less than size. It is set to 0 if the position at the start
 * of the read operation is at or beyond the end-of-stream. These are the only cases where
 * *count may be less than size.
 * No data transfer can occur past the current end of stream. If an attempt is made to read
 * past the end-ofstream, the TEE_ReadObjectData function stops reading data at the
 * end-of-stream and returns the data read up to that point. This is still a success. The
 * position indicator is then set at the end-of-stream. If the position is at, or past, the end
 * of the data when this function is called, then no bytes are copied to *buffer and *count is
 * set to 0.
 *
 * @param[in]  object   The object handle
 * @param[out] buffer   A pointer to the memory which, upon successful completion, contains
 *                      the bytes read
 * @param[in]  size     The number of bytes to read
 * @param[out] count    A pointer to the variable which upon successful completion contains
 *                      the number of bytes read
 *
 * @return
 * TEE_SUCCESS                       In case of success
 * TEE_ERROR_CORRUPT_OBJECT:         If the storage is corrupt
 * TEE_ERROR_STORAGE_NOT_AVAILABLE:  If the persistent object is stored in a storage area which
 *                                   is currently inaccessible.
 **/
extern TEE_Result TEE_ReadObjectData(
  TEE_ObjectHandle object,
  void* buffer,
  size_t size,
  uint32_t* count);

/**
 * The TEE_WriteObjectData function writes size bytes from the buffer pointed to by buffer to
 * the data stream associated with the open object handle object.
 * The object handle MUST have been opened with the write access permission.
 * If the current data position points before the end-of-stream, then size bytes are written
 * to the data stream, overwriting bytes starting at the current data position. If the current
 * data position points beyond the streams end, then the data stream is first extended with
 * zero bytes until the length indicated by the data position indicator is reached, and then
 * size bytes are written to the stream. Thus, the size of the data stream can be increased as
 * a result of this operation.
 * If the operation would move the data position indicator to beyond its maximum possible value,
 * then TEE_ERROR_OVERFLOW is returned and the operation fails.
 * The data position indicator is advanced by size. The data position indicators of other
 * object handles opened on the same object are not changed.
 * Writing in a data stream is atomic; either the entire operation completes successfully or
 * no write is done.
 *
 * @param[in] object   The object handle
 * @param[in] buffer   The buffer containing the data to be written
 * @param[in] size     The number of bytes to write
 *
 * @return
 * TEE_SUCCESS:                      In case of success
 * TEE_ERROR_STORAGE_NO_SPACE:       If insufficient storage space is available
 * TEE_ERROR_OVERFLOW:               If the value of the data position indicator resulting
 *                                   from this operation would be greater than
 *                                   TEE_DATA_MAX_POSITION
 * TEE_ERROR_CORRUPT_OBJECT:         If the storage is corrupt
 * TEE_ERROR_STORAGE_NOT_AVAILABLE:  If the persistent object is stored in a storage area which
 *                                   is currently inaccessible.
 *
 **/
extern TEE_Result TEE_WriteObjectData(
  TEE_ObjectHandle object,
  void* buffer,
  size_t size);

/**
The function TEE_TruncateObjectData changes the size of a data stream. If size is less
than the current size of the data stream then all bytes beyond size are removed. If size
is greater than the current size of the data stream then the data stream is extended by
adding zero bytes at the end of the stream.
The object handle MUST have been opened with the write access permission.
This operation does not change the data position of any handle opened on the object.
Note that if the current data position of such a handle is beyond size, the data position
will point beyond the object datas end after truncation.
Truncating a data stream is atomic: Either the data stream is successfully truncated or
nothing happens.

@param[in] object   The object handle
@param[in] size     The new size of the data stream

@return
TEE_SUCCESS:                      In case of success
TEE_ERROR_STORAGE_NO_SPACE:       If insufficient storage space is available
TEE_ERROR_CORRUPT_OBJECT:         If the storage is corrupt
TEE_ERROR_STORAGE_NOT_AVAILABLE:  If the persistent object is stored in a storage area which
                                  is currently inaccessible.

*/
extern TEE_Result TEE_TruncateObjectData(
  TEE_ObjectHandle object,
  uint32_t size);

/**
 * The TEE_SeekObjectData function sets the data position indicator associated with the
 * object handle.
 * The parameter whence controls the meaning of offset:
 *     - If whence is TEE_DATA_SEEK_SET,
 *       the data position is set to offset bytes from the beginning of the data stream.
 *     - If whence is TEE_DATA_SEEK_CUR, the data position is set to its current position
 *       plus offset.
 *     - If whence is TEE_DATA_SEEK_END, the data position is set to the size of the object
 *       data plus offset.
 *
 * The TEE_SeekObjectData function may be used to set the data position beyond the end of
 * stream; this does not constitute an error. However, the data position indicator does have
 * a maximum value which is TEE_DATA_MAX_POSITION. If the value of the data position indicator
 * resulting from this operation would be greater than TEE_DATA_MAX_POSITION, the error
 * TEE_ERROR_OVERFLOW is returned.
 * If an attempt is made to move the data position before the beginning of the data stream,
 * the data position is set at the beginning of the stream. This does not constitute an error.
 *
 * @param[in] object   The object handle
 * @param[in] offset   The number of bytes to move the data position.
 *                     A positive value moves the data position forward; a negative value
 *                     moves the data position backward.
 * @param[in] whence   The position in the data stream from which to calculate the new
 *                     position
 *
 * @return
 * TEE_SUCCESS:                      In case of success
 * TEE_ERROR_OVERFLOW:               If the value of the data position indicator resulting
 *                                   from this operation would be greater than
 *                                   TEE_DATA_MAX_POSITION
 * TEE_ERROR_CORRUPT_OBJECT:         If the storage is corrupt
 * TEE_ERROR_STORAGE_NOT_AVAILABLE:  If the persistent object is stored in a storage area
 *                                   which is currently inaccessible.
 **/
extern TEE_Result TEE_SeekObjectData(
  TEE_ObjectHandle object,
  intmax_t offset,
  TEE_Whence whence);

/******************************************************************************
Cryptographic Operations Functions (28)
******************************************************************************/
/**
 * @brief allocates a handle for a new cryptographic operation and sets the mode and algorithm type
 *
 * The TEE_AllocateOperation function allocates a handle for a new cryptographic operation and sets the mode and algorithm type.
 * If this function does not return with TEE_SUCCESS then there is no valid handle value.
 *     Supported algorithm                   Supported mode                         Supported maxKeySize
 *     TEE_ALG_AES_ECB_NOPAD                 TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     128, 256bits
 *     TEE_ALG_AES_CBC_NOPAD                 TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     128, 256bits
 *     TEE_ALG_AES_CTR                       TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     128, 256bits
 *     TEE_ALG_AES_CTS                       TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     128, 256bits
 *     TEE_ALG_AES_XTS                       TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     128, 256bits
 *     TEE_ALG_AES_CCM                       TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     128, 256bits
 *     TEE_ALG_AES_GCM                       TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     128, 256bits
 *     TEE_ALG_DES_ECB_NOPAD                 TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     128, 256bits
 *     TEE_ALG_DES_CBC_NOPAD                 TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     128, 256bits
 *     TEE_ALG_DES3_ECB_NOPAD                TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     128, 256bits
 *     TEE_ALG_DES3_CBC_NOPAD                TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     128, 256bits
 *     TEE_ALG_DES_CBC_MAC_NOPAD             TEE_MODE_MAC
 *     TEE_ALG_AES_CBC_MAC_NOPAD             TEE_MODE_MAC
 *     TEE_ALG_AES_CBC_MAC_PCKS5             TEE_MODE_MAC
 *     TEE_ALG_AES_CMAC                      TEE_MODE_MAC
 *     TEE_ALG_DES_CBC_MAC_PKCS5             TEE_MODE_MAC
 *     TEE_ALG_DES3_CBC_MAC_NOPAD            TEE_MODE_MAC
 *     TEE_ALG_DES3_CBC_MAC_PKCS5            TEE_MODE_MAC
 *     TEE_ALG_RSASSA_PKCS1_V1_5_MD5         TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_RSASSA_PKCS1_V1_5_SHA1        TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_RSASSA_PKCS1_V1_5_SHA224      TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_RSASSA_PKCS1_V1_5_SHA256      TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_RSASSA_PKCS1_V1_5_SHA384      TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_RSASSA_PKCS1_V1_5_SHA8512     TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA1    TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA224  TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA256  TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA384  TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA512  TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_DSA_SHA1                      TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_DSA_SHA224                    TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_DSA_SHA256                    TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_ECDSA                         TEE_MODE_SIGN, TEE_MODE_VERIFY         upto 4096bits
 *     TEE_ALG_RSAES_PKCS1_V1_5              TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     upto 4096bits
 *     TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA1    TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     upto 4096bits
 *     TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA224  TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     upto 4096bits
 *     TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA256  TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     upto 4096bits
 *     TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA384  TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     upto 4096bits
 *     TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA512  TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     upto 4096bits
 *     TEE_ALG_RSA_NOPAD                     TEE_MODE_ENCRYPT, TEE_MODE_DECRYPT     upto 4096bits
 *     TEE_ALG_DH_DERIVE_SHARED_SECRET       TEE_MODE_DERIVE
 *     TEE_ALG_ECDH_DERIVE_SHARED_SECRET     TEE_MODE_DERIVE
 *     TEE_ALG_MD5                           TEE_MODE_DIGEST
 *     TEE_ALG_SHA1                          TEE_MODE_DIGEST
 *     TEE_ALG_SHA224                        TEE_MODE_DIGEST
 *     TEE_ALG_SHA256                        TEE_MODE_DIGEST
 *     TEE_ALG_SHA384                        TEE_MODE_DIGEST
 *     TEE_ALG_SHA512                        TEE_MODE_DIGEST
 *     TEE_ALG_HMAC_MD5                      TEE_MODE_MAC
 *     TEE_ALG_HMAC_SHA1                     TEE_MODE_MAC
 *     TEE_ALG_HMAC_SHA224                   TEE_MODE_MAC
 *     TEE_ALG_HMAC_SHA256                   TEE_MODE_MAC
 *     TEE_ALG_HMAC_SHA384                   TEE_MODE_MAC
 *     TEE_ALG_HMAC_SHA512                   TEE_MODE_MAC
 *
 *
 * @param[out]  operation   A pointer to a TEE_OperationHandle
 * @param[in]   algorithm   One of the cipher algorithms enumerated above
 * @param[in]   mode        The operation mode
 * @param[in]   maxKeySize  Maximum key size in bits for the operation
 *
 * @return   TEE_SUCCESS                Handle is allocated
 *           TEE_ERROR_OUT_OF_MEMORY    No free memory
 *           TEE_ERROR_NOT_SUPPORTED    Incompatible mode for alg or key size, not a listed alg
 *                                      or maxKeySize not appropriate for alg
 */
extern TEE_Result TEE_AllocateOperation(
  TEE_OperationHandle *operation,
  uint32_t algorithm,
  uint32_t mode,
  uint32_t maxKeySize
);

/**
 * @brief The TEE_Free Operation function deallocates all
 *        resources associated with an operation handle. After
 *        this function is called, the operation handle is no
 *        longer valid.
 *
 * @param[in]   operation   handle allocated during
 *       TEE_AllocateOperation
 *
 * @return      none
 *
 */
extern void TEE_FreeOperation( TEE_OperationHandle operation);

/**
 * @brief returns information about an operation handle
 *
 * It fills the following fields in the structure
 * operationInfoMultiple
 *
 *   algorithm, mode, maxKeySize: The parameters passed to the
 *                        function TEE_AllocateOperation
 *   algorithmClass: One of the following constants, describing
 *                   the kind of operation:
 *              o TEE_OPERATION_CIPHER
 *              o TEE_OPERATION_MAC
 *              o TEE_OPERATION_AE
 *              o TEE_OPERATION_DIGEST
 *              o TEE_OPERATION_ASYMMETRIC_CIPHER
 *              o TEE_OPERATION_ASYMMETRIC_SIGNATURE
 *              o TEE_OPERATION_KEY_DERIVATION
 *   digestLength: For a MAC, AE, or Digest , describes
 *                 the number of bytes in the digest or tag
 *   handleState: A bit vector describing the current state of
 *                 the operation. Contains one or more of the
 *                 following flags:
 *            o TEE_HANDLE_FLAG_EXPECT_TWO_KEYS: Set if the
 *            algorithm expects two keys to be set, using
 *            TEE_SetOperationKey2. This happens only if
 *            algorithm is set to TEE_ALG_AES_XTS.
 *            o TEE_HANDLE_FLAG_KEY_SET: Set if the operation
 *            key has been set. Always set for digest operations
 *            o TEE_HANDLE_FLAG_INITIALIZED: For multi-stage
 *   operationState: One of the following constants, describing
 *                     the state of operation:
 *            o TEE_OPERATION_STATE_INITIAL
 *            o TEE_OPERATION_STATE_ACTIVE
 *   numberOfKeys: Number of TEE_OperationInfoKey contained in
 *                  keyInformation structure. Maybe 0 if
 *                  operation does not require any keys
 *   keyInformation: Array containing numberOfKeys entries
 *                  defining details of one key used by the
 *                  operation in the order they are defined.
 *                  Each element:
 *            o keySize: If a key is programmed in the
 *               operation, the actual size of this key
 *            o requiredKeyUsage: A bit vector that describes
 *                  the necessary bits in the object usage for
 *                  TEE_SetOperationKey or TEE_SetOperationKey2
 *                  to succeed without panicking.
 *
 *
 * @param[in]  operation     A pointer to a TEE_OperationHandle
 *                            allocated by TEE_AllocateOperation
 * @param[out] operationInfoMultiple Fills above operation info
 *                            at this pointer location
 * @param[in,out] operationSize
 *
 * @return   TEE_SUCCESS            OperationInfoMultiple filled
 *           TEE_ERROR_SHORT_BUFFER Buffer not large enough to
 *                                  hold OperationInfoMultiple
 */
extern TEE_Result TEE_GetOperationInfoMultiple(
  TEE_OperationHandle operation,
  TEE_OperationInfoMultiple* operationInfoMultiple,
  size_t* operationSize
);

/**
 * @brief returns information about an operation handle
 *
 * It fills the following fields in the structure operationInfo
 *
 *   algorithm, mode, maxKeySize: The parameters passed to the
 *                        function TEE_AllocateOperation
 *   algorithmClass: One of the following constants, describing
 *                   the kind of operation:
 *              o TEE_OPERATION_CIPHER
 *              o TEE_OPERATION_MAC
 *              o TEE_OPERATION_AE
 *              o TEE_OPERATION_DIGEST
 *              o TEE_OPERATION_ASYMMETRIC_CIPHER
 *              o TEE_OPERATION_ASYMMETRIC_SIGNATURE
 *  keySize: If a key is programmed in the operation, the
 *            actual size of this key
 *  requiredKeyUsage: A bit vector that describes the necessary
 *                  bits in the object usage for
 *                  TEE_SetOperationKey or TEE_SetOperationKey2
 *                  to succeed without panicking. Set to 0 for a
 *                  digest operation.
 *  digestLength: For a MAC, AE, or Digest , describes
 *                 the number of bytes in the digest or tag
 *   handleState: A bit vector describing the current state of
 *                 the operation. Contains one or more of the
 *                 following flags:
 *            o TEE_HANDLE_FLAG_EXPECT_TWO_KEYS: Set if the
 *            algorithm expects two keys to be set, using
 *            TEE_SetOperationKey2. This happens only if
 *            algorithm is set to TEE_ALG_AES_XTS.
 *            o TEE_HANDLE_FLAG_KEY_SET: Set if the operation
 *            key has been set. Always set for digest operations
 *            o TEE_HANDLE_FLAG_INITIALIZED: For multi-stage
 *            operations
 *
 * @param[in]  operation     A pointer to a TEE_OperationHandle
 *                            allocated by TEE_AllocateOperation
 * @param[out] operationInfo Fills above operation info at
 *                            this pointer location
 *
 */
extern void TEE_GetOperationInfo(
  TEE_OperationHandle operation,
  TEE_OperationInfo* operationInfo
);

/**
 * @brief Resets the operation
 *
 * For a multi-stage operation, the TEE_ResetOperation function
 * resets the operation state before initialization, but after
 * the key has been set.
 * Only for the multi-stage operations, i.e., symmetric ciphers,
 * MACs, AEs, and digests. When such a multi-stage operation is
 * active, i.e., when it has been initialized but not yet
 * successfully finalized, then the operation is reset to its
 * pre-initialization state. The operation key(s) are not
 * cleared.
 *
 *  Valid only for
 *      TEE_OPERATION_CIPHER
 *      TEE_OPERATION_DIGEST
 *      TEE_OPERATION_MAC
 *      TEE_OPERATION_AE
 *
 * @param[in]  operation     A pointer to a TEE_OperationHandle
 *                            allocated by TEE_AllocateOperation
 *
 */
extern void TEE_ResetOperation( TEE_OperationHandle operation);

/**
 * @brief returns whether the combination of input algorithm and element
 * is supported
 *
 * The TEE_IsAlgorithmSupported function can be used to determine whether 
 * a combination of algId and element is supported. Implementations SHALL 
 * return TEE_ERROR_NOT_SUPPORTED for any value of algId or element which 
 * is reserved for future use.
 *
 * @param[in]  algId         The algorithm identifier
 *
 * @param[in]  element       The supporting cryptographic element.
 *                           Where algId fully defines the required
 *                           support, the special value TEE_CRYPTO_ELEMENT_NONE 
 *                           SHOULD be used.
 *
 * @return     TEE_SUCCESS               The combination of algId and element is supported.
 *
 *             TEE_ERROR_NOT_SUPPORTED   The combination of algId and element is not supported.
 *
 */

extern TEE_Result TEE_IsAlgorithmSupported(uint32_t algId, uint32_t element);

/**
 * @brief associates an operation with a key
 *
 * The key material is copied from the key object handle into
 * the operation. After the key has been set, there is no longer
 * any link between the operation and the key object. The object
 * handle can be closed or reset and this will not affect the
 * operation.
 *
 * The key object type and size must be compatible with the type
 * and size of the operation. The operation mode must be
 * compatible with key usage:
 *  In general, the operation mode must be allowed in the
 * object usage.
 *  For the TEE_ALG_RSA_NOPAD algorithm:
 *        o The only supported modes are TEE_MODE_ENCRYPT and
 *        TEE_MODE_DECRYPT.
 *        o For TEE_MODE_ENCRYPT, the object usage must contain
 *        both the TEE_USAGE_ENCRYPT and TEE_USAGE_VERIFY flags.
 *        o For TEE_MODE_DECRYPT, the object usage must contain
 *        both the TEE_USAGE_DECRYPT and TEE_USAGE_SIGN flags.
 *  For a public key object, the operation mode can only be
 * TEE_MODE_ENCRYPT or TEE_MODE_VERIFY but cannot be
 * TEE_MODE_DECRYPT or TEE_MODE_SIGN as these kinds of
 * operations require the private parts of a key-pair.
 *  If the object is a key-pair then the key parts used in the
 * operation depend on the mode:
 *        o For a TEE_MODE_ENCRYPT or TEE_MODE_VERIFY operation,
 *        the public parts of the key-pair are used.
 *        o For a TEE_MODE_DECRYPT or TEE_MODE_SIGN, the private
 *        parts of the key-pair are used.
 *
 * @param[in]  operation     A pointer to a TEE_OperationHandle
 *                            allocated by TEE_AllocateOperation
 * @param[in]  key           Initialized key
 *
 * @return   TEE_SUCCESS                      Key associated with
 *                                            operation
 *           TEE_ERROR_CORRUPT_OBJECT         If object is corrupt.
 *                                            Object handle is closed.
 *           TEE_ERROR_STORAGE_NOT_AVAILABLE  Persistent object is stored
 *                                            in inaccessible storage area
 */
extern TEE_Result TEE_SetOperationKey(
  TEE_OperationHandle operation,
  TEE_ObjectHandle key
);

/**
 * @brief initializes an existing operation with two keys
 *
 * This is used only for the algorithm TEE_ALG_AES_XTS.
 * The key material is copied from the key object handle into
 * the operation.
 * This function works like TEE_SetOperationKey except that two
 * keys are set instead of a single key.
 *
 * @param[in]  operation     A pointer to a TEE_OperationHandle
 *                            allocated by TEE_AllocateOperation
 * @param[in]  key1           Initialized key 1
 * @param[in]  key2           Initialized key 2
 *
 * @return  TEE_SUCCESS                        Key associated to
 *                                             operation
 *          TEE_ERROR_CORRUPT_OBJECT           If key1 object is corrupt.
 *                                             Object handle is closed.
 *          TEE_ERROR_CORRUPT_OBJECT_2         If key2 object is corrupt.
 *                                             Object handle is closed.
 *          TEE_ERROR_STORAGE_NOT_AVAILABLE    Key1 object is stored
 *                                             in inaccessible storage area
 *          TEE_ERROR_STORAGE_NOT_AVAILABLE_2  Key2 object is stored
 *                                             in inaccessible storage area
 */
extern TEE_Result TEE_SetOperationKey2(
  TEE_OperationHandle operation,
  TEE_ObjectHandle key1,
  TEE_ObjectHandle key2
);

extern void TEE_CopyOperation(
  TEE_OperationHandle dstOperation,
  TEE_OperationHandle srcOperation
);

/**
 * @brief accumulates message data for hashing
 *
 * The message does not have to be block aligned.
 * Subsequent calls to this function are possible.
 *
 * @param[in]  operation     Handle of a running Message Digest operation
 * @param[in]  chunk         Chunk of data to be hashed
 * @param[in]  chunkSize     size of chunk in bytes
 *
 */

extern void TEE_DigestUpdate(
  TEE_OperationHandle operation,
  void* chunk,
  size_t chunkSize
);

/**
 * @brief finalizes the message digest operation
 *
 * produces the message hash. the Message Digest
 * operation can be reset and reused.
 *
 * @param[in]  operation     Handle of a running Message Digest operation
 * @param[in]  chunk         Chunk of data to be hashed
 * @param[in]  chunkSize     size of chunk in bytes
 * @param[out] hash          Output buffer filled with the
 *                           message hash
 * @param[in,out] hashLen    Length of hash buffer passed in
 *                           bytes, updated with length of hash
 *                           result.
 *
 * @return   TEE_SUCCESS                Hash final op done
 *           TEE_ERROR_SHORT_BUFFER     Output buffer too small
 */

TEE_Result TEE_DigestDoFinal(
  TEE_OperationHandle operation,
  void* chunk, size_t chunkLen,
  void* hash, size_t *hashLen
);

/**
 * @brief starts the symmetric cipher operation
 *
 * The operation must have been associated with a key.
 *
 * @param[in]  operation     A handle on an opened cipher
 *                           operation setup with a key
 * @param[in]  IV            Buffer containing the operation
 *                           Initialization Vector
 * @param[in]  IVLen         Size of IV in bytes
 *
 */
extern void TEE_CipherInit(
  TEE_OperationHandle operation,
  void* IV,
  size_t IVLen
);

/**
 * @brief function encrypts or decrypts input data
 *
 * Subsequent calls to this function are possible. The cipher
 * operation is finalized with a call to TEE_CipherDoFinal.
 *
 * @param[in]  operation     Handle of a running Cipher operation
 * @param[in]  srcData       Input data buffer to be encrypted
 *                           or decrypted operation
 * @param[in]  srcLen        length of srcData in bytes
 * @param[out] destData      Output buffer
 * @param[in,out]  destLen   length of destData in bytes
 *
 * @return   TEE_SUCCESS                Cipher update done
 *           TEE_ERROR_SHORT_BUFFER     Output buffer not large enough to
 *                                      contain output.
 *                                      Input not fed into algorithm.
 */

extern TEE_Result TEE_CipherUpdate(
  TEE_OperationHandle operation,
  void* srcData,
  size_t srcLen,
  void* destData,
  size_t *destLen
);

/**
 * @brief finalizes the cipher operation
 *
 * Input data does not have to be a multiple of block size for
 * TEE_ALG_AES_CTS and TEE_ALG_AES_CTR. The cipher operation is
 * finalized with this call.
 *
 * @param[in]  operation     Handle of a running Cipher operation
 * @param[in]  srcData       Input data buffer to be encrypted
 *                           or decrypted operation
 * @param[in]  srcLen        length of srcData in bytes
 * @param[out] destData      Output buffer
 * @param[in,out]  destLen   length of destData in bytes
 *
 * @return   TEE_SUCCESS                Cipher final done
 *           TEE_ERROR_SHORT_BUFFER     Output buffer not large enough to
 *                                      contain output.
 *
 */

extern TEE_Result TEE_CipherDoFinal(
  TEE_OperationHandle operation,
  void* srcData,
  size_t srcLen,
  void* destData,
  size_t *destLen
);

/**
 * MAC Functions
 **/

/**
 * @brief initializes a MAC operation
 *
 * The operation is started and associated with a key. If this
 * function does not return with TEE_SUCCESS, the operation is
 * not initialized.
 * If the MAC algorithm does not require an IV, the parameters
 * IV, IVLen are ignored. IV must still be a valid input buffer,
 * so, for example, if IV is NULL, then IVLen must be set to 0.
 *
 * @param[in]  operation     Operation handle
 * @param[in]  IV            Input buffer containing the
 *                           operation IV, if applicable
 * @param[in]  IVLen         Length of IV in bytes
 *
 */

extern void TEE_MACInit(
  TEE_OperationHandle operation,
  void* IV,
  size_t IVLen
);

/**
 * @brief accumulates data for a MAC calculation
 *
 * Input data does not have to be a multiple of the block size.
 * Subsequent calls to this function are possible.
 * TEE_MACComputeFinal or TEE_MACCompareFinal are called to
 * complete the MAC operation.
 *
 * @param[in]  operation     Handle of a MAC operation
 * @param[in]  chunk         Chunk of the message to be MACed
 * @param[in]  chunkSize     Size of chunk in bytes
 *
 * @note This operation not supported for :
 *          TEE_ALG_AES_CMAC
 *
 */

extern void TEE_MACUpdate(
  TEE_OperationHandle operation,
  void* chunk,
  size_t chunkSize
);

/**
 * @brief finalizes the MAC operation with a last chunk of
 *        message, and computes the MAC
 *
 * finalizes the MAC operation with a last chunk of message, and
 * computes the MAC.
 *
 * @param[in]  operation     Handle of a MAC operation
 * @param[in]  message       Chunk of the message to be MACed
 * @param[in]  messageLen    Size of chunk in bytes
 * @param[out] mac           Output buffer filled with the
 *                           computed MAC
 * @param[in,out]  macLen    Length of buffer passed, updated
 *                           with correct length after function
 *                           returns, size in bytes
 *
 *
 * @return   TEE_SUCCESS                Mac final done
 *           TEE_ERROR_SHORT_BUFFER     Output buffer not large enough to
 *                                      contain output.
 */

extern TEE_Result TEE_MACComputeFinal(
  TEE_OperationHandle operation,
  void* message,
  size_t messageLen,
  void* mac,
  size_t *macLen
);

/**
 * @brief finalizes the MAC operation and compares the MAC with
 *        the buffer passed to the function
 *
 * finalizes the MAC operation and compares the MAC with the
 * buffer passed to the function.
 *
 * @param[in]  operation     Handle of a MAC operation
 * @param[in]  message       Input buffer containing the last
 *                           message chunk to MAC
 * @param[in]  messageLen    Size of message in bytes
 * @param[in]  mac           Input buffer containing the MAC to check
 * @param[in]  macLen        Length of buffer passed, size in
 *                           bytes
 *
 * @return   TEE_SUCCESS                Mac initialized
 *           TEE_ERROR_GENERIC          Hardware/Software
 *                                      failure
 *           TEE_ERROR_MAC_INVALID      computed MAC does not
 *                                      correspond to the value
 *                                      passed in the parameter
 *                                      mac
 */

extern TEE_Result TEE_MACCompareFinal(
  TEE_OperationHandle operation,
  void* message,
  size_t messageLen,
  void* mac,
  size_t macLen
);

/**
 * AUTHENTICATED ENCRYPTION API's
 **/

/**
 * @brief initializes an Authentication Encryption operation
 *
 * @param[in]  operation     A handle on the operation
 * @param[in]  nonce         The operation nonce or IV
 * @param[in]  nonceLen      operation nonce or IV in bytes
 * @param[in]  tagLen        Size in bits of the tag length
 * @param[in]  AADLen        Length in bytes of the AAD
 *                             o Used only for AES-CCM. Ignored for AES-GCM
 * @param[in]  payloadLen    Used only for AES-CCM. Ignored for AES-GCM.bits
 *
 * @return   TEE_SUCCESS                AE intialize done
 *           TEE_ERROR_NOT_SUPPORTED    Tag length no supported
 *
 */

extern TEE_Result TEE_AEInit(
  TEE_OperationHandle operation,
  void* nonce,
  size_t nonceLen,
  uint32_t tagLen,
  size_t AADLen,
  size_t payloadLen
);

/**
 * @brief Feeds AAD chunk to the AE operation
 *
 * @param[in]  operation     Handle on the AE operation
 * @param[in]  AADdata       Input buffer containing the chunk
 *                           of AAD
 * @param[in]  AADdataLen    Length in bytes of the AAD
 *
 */

extern void TEE_AEUpdateAAD(
  TEE_OperationHandle operation,
  void* AADdata,
  size_t AADdataLen
);

/**
 * @brief accumulates data for an Authentication Encryption
 *        operation
 *
 * Subsequent calls to this function are possible.
 *
 * @param[in]  operation     Handle of a running AE operation
 * @param[in]  srcData       Input data buffer to be encrypted
 *                           or decrypted
 * @param[in]  srcLen        length of srcData in bytes
 * @param[out] destData      Output buffer
 * @param[in,out]  destLen   length of destData in bytes
 *
 * @return   TEE_SUCCESS              AE Updated
 *           TEE_ERROR_SHORT_BUFFER   Output buffer not large enough
 *
 */

extern TEE_Result TEE_AEUpdate(
  TEE_OperationHandle operation,
  void* srcData,
  size_t srcLen,
  void* destData,
  size_t *destLen
);

/**
 * @brief completes the AE operation and computes the tag
 *
 * @param[in]  operation     Handle of a running AE operation
 * @param[in]  srcData       Reference to final chunk of input
 *                           data to be encrypted
 * @param[in]  srcLen        Length in bytes of the srcData
 * @param[out] destData      Output buffer. Can be omitted if
 *                           the output is to be discarded,
 *                           e.g., because it is known to be
 *                           empty.
 * @param[in]  destLen       Length in bytes of the destData
 * @param[out] tag           Output buffer filled with the computed tag
 * @param[in]  tagLen        Length in bytes of the tag
 *
 * @return   TEE_SUCCESS              AE final done
 *           TEE_ERROR_SHORT_BUFFER   Output buffer not large enough
 *
 */

extern TEE_Result TEE_AEEncryptFinal(
  TEE_OperationHandle operation,
  void* srcData,
  size_t srcLen,
  void* destData,
  size_t* destLen,
  void* tag,
  size_t* tagLen
);

/**
 * @brief completes the AE operation and verifies the tag
 *
 * @param[in]  operation     Handle of a running AE operation
 * @param[in]  srcData       Reference to final chunk of input
 *                           data to be encrypted
 * @param[in]  srcLen        Length in bytes of the srcData
 * @param[out]  destData      Output buffer. Can be omitted if
 *                           the output is to be discarded,
 *                           e.g., because it is known to be
 *                           empty.
 * @param[in]  destLen       Length in bytes of the destData
 * @param[out]  tag          Input buffer filled with the
 *                           computed tag
 * @param[in]  tagLen        Length in bytes of the tag
 *
 * @return   TEE_SUCCESS              AE final done
 *           TEE_ERROR_SHORT_BUFFER   Output buffer not large enough
 *           TEE_ERROR_MAC_INVALID    Computed tag does not match input tag
 *
 */

extern TEE_Result TEE_AEDecryptFinal(
  TEE_OperationHandle operation,
  void* srcData,
  size_t srcLen,
  void* destData,
  size_t *destLen,
  void* tag,
  size_t tagLen
);

/**
 * Aysmmetric Cipher APIs
 **/

/**
 * @brief encrypts a message within an asymmetric operation
 *
 * These functions can be called only with an operation of the following algorithms:
 *  TEE_ALG_RSAES_PKCS1_V1_5
 *  TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA1
 *  TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA224
 *  TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA256
 *  TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA384
 *  TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA512
 *  TEE_ALG_RSA_NOPAD (expects input buffer and output buffer of same size)
 *
 * The parameters params, paramCount contain the operation parameters
 *
 * Algorithm                               Possible operation parameters
 * TEE_ALG_RSAES_PKCS1_OAEP_MGF1_XXX       TEE_ATTR_RSA_OAEP_LABEL: This parameter is optional.
 *                                         If not present, an empty label is assumed.
 *
 *
 * @param[in]  operation     Handle on the operation, which must have been suitably
 *                           set up with an operation key
 * @param[in]  params        Optional operation parameters
 * @param[in]  paramCount    Optional operation parameters count
 * @param[in]  srcData       Reference to final chunk of input
 *                           data to be encrypted
 * @param[in]  srcLen        Length in bytes of the srcData
 * @param[out]  destData     Output buffer.
 * @param[in]  destLen       Length in bytes of the destData
 *
 * @return   TEE_SUCCESS                Asym  encryption done
 *           TEE_ERROR_BAD_PARAMETERS   Incorrect input
 *                                      parameters
 *           TEE_ERROR_SHORT_BUFFER     If the output buffer is
 *                                      not large enough to hold the result
 *
 */

extern TEE_Result TEE_AsymmetricEncrypt(
  TEE_OperationHandle operation,
  TEE_Attribute* params,
  uint32_t paramCount,
  void* srcData,
  size_t srcLen,
  void* destData,
  size_t *destLen
);

/**
 * @brief decrypts a message within an asymmetric operation
 *
 * These functions can be called only with an operation of the following algorithms:
 *  TEE_ALG_RSAES_PKCS1_V1_5
 *  TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA1
 *  TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA224
 *  TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA256
 *  TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA384
 *  TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA512
 *  TEE_ALG_RSA_NOPAD (expects input buffer and output buffer of same size)
 *
 * The parameters params, paramCount contain the operation parameters
 *
 * Algorithm                               Possible operation parameters
 * TEE_ALG_RSAES_PKCS1_OAEP_MGF1_XXX       TEE_ATTR_RSA_OAEP_LABEL: This parameter is optional.
 *                                         If not present, an empty label is assumed.
 *
 *  All supported algo by this api         TEE_ATTR_RSA_KEY_CRT_DECRYPT:This parameter is optional.
 *                                         If not present, a
 *                                         regular asymmetric
 *                                         decryption is done
 *                                         else CRT decryption
 *                                         is done.
 *
 * @param[in]  operation     Handle on the operation, which must have been suitably
 *                           set up with an operation key
 *
 * @param[in]  params        Optional operation parameters
 * @param[in]  paramCount    Optional operation parameters count
 * @param[in]  srcData       Reference to final chunk of input
 *                           data to be encrypted
 * @param[in]  srcLen        Length in bytes of the srcData
 * @param[out] destData      Output buffer. Can be omitted if
 *                           the output is to be discarded,
 *                           e.g., because it is known to be
 *                           empty.
 * @param[in]  destLen       Length in bytes of the destData
 *
 * @return   TEE_SUCCESS                Asym  decryption done
 *           TEE_ERROR_BAD_PARAMETERS   Incorrect input
 *                                      parameters
 *           TEE_ERROR_SHORT_BUFFER     If the output buffer is
 *                                      not large enough to hold the result
 *
 */

extern TEE_Result TEE_AsymmetricDecrypt(
  TEE_OperationHandle operation,
  TEE_Attribute* params,
  uint32_t paramCount,
  void* srcData,
  size_t srcLen,
  void* destData,
  size_t *destLen
);

/**
 * @brief signs a message digest within an asymmetric operation
 *
 * Note that only an already hashed message can be signed.
 * This function can be called only with an operation of the
 * following algorithms:
 *  TEE_ALG_RSASSA_PKCS1_V1_5_MD5
 *  TEE_ALG_RSASSA_PKCS1_V1_5_SHA1
 *  TEE_ALG_RSASSA_PKCS1_V1_5_SHA224
 *  TEE_ALG_RSASSA_PKCS1_V1_5_SHA256
 *  TEE_ALG_RSASSA_PKCS1_V1_5_SHA384
 *  TEE_ALG_RSASSA_PKCS1_V1_5_SHA512
 *  TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA1
 *  TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA224
 *  TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA256
 *  TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA384
 *  TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA512
 *  TEE_ALG_DSA_SHA1
 *  TEE_ALG_DSA_SHA224
 *  TEE_ALG_DSA_SHA256
 *  TEE_ALG_ECDSA_P192
 *  TEE_ALG_ECDSA_P224
 *  TEE_ALG_ECDSA_P256
 *  TEE_ALG_ECDSA_P384
 *  TEE_ALG_ECDSA_P512
 *
 * The parameters params, paramCount contain the operation
 * parameters
 *
 * Algorithm                      Possible operation parameters
 * TEE_ALG_RSASSA_PKCS1_PSS_MGF1_XX
 *                                      TEE_ATTR_RSA_PSS_SALT_LENGTH: Number of bytes in the salt.
 *                                      This parameter is
 *                                      optional. If not
 *                                      present, the salt length
 *                                      is equal to the hash
 *                                      length.
 *
 * @param[in]  operation     Handle on the operation, which must have been suitably
 *                           set up with an operation key
 * @param[in]  params        Optional operation parameters
 * @param[in]  paramCount    Optional operation parameters count
 * @param[in]  digest        Input buffer containing the input message digest
 * @param[in]  digestLen     length of message digest in bytes
 * @param[out] signature     Output buffer written with the signature of the digest
 * @param[in]  signatureLen  Length in bytes of the signature
 *                           buffer
 *
 * @return   TEE_SUCCESS                Signing done
 *           TEE_ERROR_SHORT_BUFFER     If the output buffer is
 *                                      not large enough to hold the result
 *
 */

extern TEE_Result TEE_AsymmetricSignDigest(
  TEE_OperationHandle operation,
  TEE_Attribute* params,
  uint32_t paramCount,
  void* digest,
  size_t digestLen,
  void* signature,
  size_t *signatureLen
);

/**
 * @brief verifies a message digest signature within an
 *        asymmetric operation
 *
 * Note that only an already hashed message can be signed.
 * This function can be called only with an operation of the
 * following algorithms:
 *  TEE_ALG_RSASSA_PKCS1_V1_5_MD5
 *  TEE_ALG_RSASSA_PKCS1_V1_5_SHA1
 *  TEE_ALG_RSASSA_PKCS1_V1_5_SHA224
 *  TEE_ALG_RSASSA_PKCS1_V1_5_SHA256
 *  TEE_ALG_RSASSA_PKCS1_V1_5_SHA384
 *  TEE_ALG_RSASSA_PKCS1_V1_5_SHA512
 *  TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA1
 *  TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA224
 *  TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA256
 *  TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA384
 *  TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA512
 *  TEE_ALG_DSA_SHA1
 *  TEE_ALG_DSA_SHA224
 *  TEE_ALG_DSA_SHA256
 *  TEE_ALG_ECDSA_P192
 *  TEE_ALG_ECDSA_P224
 *  TEE_ALG_ECDSA_P256
 *  TEE_ALG_ECDSA_P384
 *  TEE_ALG_ECDSA_P512
 *
 * The parameters params, paramCount contain the operation
 * parameters
 *
 * Algorithm                      Possible operation parameters
 * TEE_ALG_RSASSA_PKCS1_PSS_MGF1_XXX
 *                                      TEE_ATTR_RSA_OAEP_LABEL:
 *                                         TEE_ATTR_RSA_PSS_SALT_LENGTH: Number of bytes in the salt.
 *                                         This parameter is
 *                                         optional. If not
 *                                         present, the salt
 *                                         length is equal to
 *                                         the hash length.
 *
 * @param[in]  operation     Handle on the operation, which must have been suitably
 *                           set up with an operation key
 * @param[in]  params        Optional operation parameters
 * @param[in]  paramCount    Optional operation parameters count
 * @param[in]  digest        Input buffer containing the input message digest
 * @param[in]  digestLen     length of message digest in bytes
 * @param[in]  signature     signature of the digest to be
 *                           verified
 * @param[in]  signatureLen  Length in bytes of the signature
 *                           buffer
 *
 * @return   TEE_SUCCESS                  Signature verified
 *           TEE_ERROR_SIGNATURE_INVALID  Singature is invalid
 *
 */

extern TEE_Result TEE_AsymmetricVerifyDigest(
  TEE_OperationHandle operation,
  TEE_Attribute* params,
  uint32_t paramCount,
  void* digest,
  size_t digestLen,
  void* signature,
  size_t signatureLen
);

extern void TEE_DeriveKey(
  TEE_OperationHandle operation,
  TEE_Attribute* params,
  uint32_t paramCount,
  TEE_ObjectHandle derivedKey
);

/**
 * @brief generates random data
 *
 * @param[out] randomBuffer     Reference to generated random data
 * @param[in]  randomBufferLen  Byte length of requested random data
 */

extern void TEE_GenerateRandom(
  void* randomBuffer,
  size_t randomBufferLen
);

/*------------------------------------------------------------------------------
               --- WARNING --- WARNING --- WARNING ---
               The following definitions are not part of the TEE Internal API
  ------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------
      Internal Core API Extension Functions
  ------------------------------------------------------------------------------*/
/**
 * @brief Copy bytes from source to destination, with bounds checking.
 *
 * The TEE_MemSMove_ext function copies bytes from the object pointed to by src into the object pointed to by dest.
 * The number of bytes copied is the minimum of srcSize and destSize if both buffer pointers are non-NULL,
 * or zero otherwise
 *
 * Copying takes place as if the bytes from the object pointed to by src are first copied into a temporary
 * array that does not overlap the objects pointed to by dest and src, and then the size bytes
 * from the temporary array are copied into the object pointed to by dest.
 *
 * @param[out]  dest      A pointer to the destination buffer
 * @param[in]   destSize  The destination buffer size
 * @param[in]   src       A pointer to the source buffer
 * @param[in]   srcSize   The source buffer size
 *
 * @return The number of bytes copied
 */
extern size_t TEE_MemSMove_ext(
    void       *dest,
    size_t      destSize,
    const void *src,
    size_t      srcSize);

/**
 * @brief Compare two blocks of memory, with bounds checking.
 *
 * The TEE_MemSCompare function compares the bytes of the object pointed to by buffer1 to the bytes of the
 * object pointed to by buffer2. The number of bytes compared
 *
 * @param[in] buffer1     A pointer to the first buffer
 * @param[in] buffer1Size The size of the first buffer
 * @param[in] buffer2     A pointer to the second buffer
 * @param[in] buffer2Size The size of the second buffer
 *
 * @return The sign of a non-zero return value is determined by the sign of the difference between the values of
 *         the first pair of bytes (both interpreted as type uint8_t) that differ in the objects being compared.
 *           If the first byte that differs is higher in buffer1, then return a small positive value.
 *           If the contents of the two buffers are identical, then return zero.
 *           If the first byte that differs is higher in buffer2, then return a small negative value.
 *           If either buffer pointer is NULL, or the two sizes differ, then return INT32_MIN.
 */
extern int32_t TEE_MemSCompare_ext(
    const void *buffer1,
    size_t      buffer1Size,
    const void *buffer2,
    size_t      buffer2Size);

/*------------------------------------------------------------------------------
      Trace Functions
  ------------------------------------------------------------------------------*/
//void _SLogTrace(
//               const char *message,
//               ... /* arguments */);
//void _SLogWarning(
//               const char *message,
//               ... /* arguments */);
//void _SLogError(
//               const char *message,
//               ... /* arguments */);

#ifdef TEE_TRACE_ALLOW_OVERLOAD

#define SLogTrace(xx_fmt, ...)    LOG_FUNC("[%s] " xx_fmt, __FUNCTION__, ##__VA_ARGS__)
#define SLogError(xx_fmt, ...)    LOG_FUNC("[%s] " xx_fmt, __FUNCTION__, ##__VA_ARGS__)

#else /* !defined(TEE_TRACE_ALLOW_OVERLOAD) */

#include "qsee_log.h"

#ifndef TEE_NO_TRACE

#define SLogTrace(xx_fmt, ...)    qsee_log(QSEE_LOG_MSG_DEBUG, "[%s] " xx_fmt, __FUNCTION__, ##__VA_ARGS__)
#define SLogError(xx_fmt, ...)    qsee_log(QSEE_LOG_MSG_FATAL, "[%s] " xx_fmt, __FUNCTION__, ##__VA_ARGS__)

#else /* defined(TEE_NO_TRACE) */

/* Note that the following code depends on the compiler's supporting variadic macros */
#define SLogTrace(...)   do {} while(0)
#define SLogError(...)   do {} while(0)

#endif /* !defined(TEE_NO_TRACE) */

#define GPLOG_DEBUG(xx_fmt, ...) \
  qsee_log(QSEE_LOG_MSG_DEBUG, "%s:%d " xx_fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__)

#define GPLOG_ERROR(x) \
  qsee_log(QSEE_LOG_MSG_ERROR, "%s:%d retvalue=[0x%x]", __FUNCTION__, __LINE__, x)

#define GPLOG_ERROR2(s, x) \
  qsee_log(QSEE_LOG_MSG_ERROR, "%s:%d %s retvalue=[0x%x]", __FUNCTION__, __LINE__, s, x)

#define GPLOG_ERROR3(xx_fmt, ...) \
  qsee_log(QSEE_LOG_MSG_ERROR, "%s:%d " xx_fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__)

#define GPLOG_FATAL(x) \
  qsee_log(QSEE_LOG_MSG_FATAL, "%s:%d retvalue=[0x%x]", __FUNCTION__, __LINE__, x)

#define GPLOG_FATAL2(s, x) \
  qsee_log(QSEE_LOG_MSG_FATAL, "%s:%d %s retvalue=[0x%x]", __FUNCTION__, __LINE__, s, x)

#endif /* defined(TEE_TRACE_ALLOW_OVERLOAD) */

#ifndef S_VAR_NOT_USED
#define S_VAR_NOT_USED(variable) do{(void)(variable);}while(0);
#endif // S_VAR_NOT_USED

#endif /* __TEE_INTERNAL_API_H__ */
