/*-----------------------------------------------------------------------
 * File: CSM_CSPI.H
 *
 * Copyright (c) 1995-2000 Intel Corporation. All rights reserved.
 *-----------------------------------------------------------------------
 */

/*
 * OpenVMS History
 *
 * 13-Sep-2002 Carol Kelly
 *        o Merge in V3_14 changes
 *
 */

#ifndef __CSM_CSPI_H__
#define __CSM_CSPI_H__    

#ifdef __cplusplus
extern "C" {
#endif


/************************************************************************/
/*** Cryptographic Service Provider SPIs ********************************/
/************************************************************************/

CSSM_RETURN CSSMAPI CSM_EventNotify(
                        CSSM_MODULE_HANDLE CSPHandle,
                        CSSM_CONTEXT_EVENT Event,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT* Context );

CSSM_RETURN CSSMAPI CSM_QuerySize(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        CSSM_BOOL Encrypt,
                        uint32 QuerySizeCount,
                        CSSM_QUERY_SIZE_DATA_PTR DataBlock );

CSSM_RETURN CSSMAPI CSM_SignData(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount,
                        CSSM_ALGORITHMS DigestAlgorithm,
                        CSSM_DATA_PTR Signature );

CSSM_RETURN CSSMAPI CSM_SignDataInit(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context );

CSSM_RETURN CSSMAPI CSM_SignDataUpdate(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount );

CSSM_RETURN CSSMAPI CSM_SignDataFinal(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        CSSM_DATA_PTR Signature );

CSSM_RETURN CSSMAPI CSM_VerifyData(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount,
                        CSSM_ALGORITHMS DigestAlgorithm,
                        const CSSM_DATA *Signature );

CSSM_RETURN CSSMAPI CSM_VerifyDataInit(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context );

CSSM_RETURN CSSMAPI CSM_VerifyDataUpdate(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount );

CSSM_RETURN CSSMAPI CSM_VerifyDataFinal(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_DATA *Signature );

CSSM_RETURN CSSMAPI CSM_DigestData(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount,
                        CSSM_DATA_PTR Digest );

CSSM_RETURN CSSMAPI CSM_DigestDataInit(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context );

CSSM_RETURN CSSMAPI CSM_DigestDataUpdate(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount );

CSSM_RETURN CSSMAPI CSM_DigestDataClone(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        CSSM_CC_HANDLE ClonednewCCHandle );

CSSM_RETURN CSSMAPI CSM_DigestDataFinal(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        CSSM_DATA_PTR Digest );

CSSM_RETURN CSSMAPI CSM_GenerateMac(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount,
                        CSSM_DATA_PTR Mac );

CSSM_RETURN CSSMAPI CSM_GenerateMacInit(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context );

CSSM_RETURN CSSMAPI CSM_GenerateMacUpdate(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount );

CSSM_RETURN CSSMAPI CSM_GenerateMacFinal(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        CSSM_DATA_PTR Mac );

CSSM_RETURN CSSMAPI CSM_VerifyMac(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount,
                        const CSSM_DATA *Mac );

CSSM_RETURN CSSMAPI CSM_VerifyMacInit(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context );

CSSM_RETURN CSSMAPI CSM_VerifyMacUpdate(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount );

CSSM_RETURN CSSMAPI CSM_VerifyMacFinal(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_DATA *Mac );

CSSM_RETURN CSSMAPI CSM_EncryptData(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        const CSSM_DATA *ClearBufs,
                        uint32 ClearBufCount,
                        CSSM_DATA_PTR CipherBufs,
                        uint32 CipherBufCount,
                        uint32 *bytesEncrypted,
                        CSSM_DATA_PTR RemData,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI CSM_EncryptDataInit(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI CSM_EncryptDataUpdate(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_DATA *ClearBufs,
                        uint32 ClearBufCount,
                        CSSM_DATA_PTR CipherBufs,
                        uint32 CipherBufCount,
                        uint32 *bytesEncrypted );

CSSM_RETURN CSSMAPI CSM_EncryptDataFinal(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        CSSM_DATA_PTR RemData );

CSSM_RETURN CSSMAPI CSM_DecryptData(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        const CSSM_DATA *CipherBufs,
                        uint32 CipherBufCount,
                        CSSM_DATA_PTR ClearBufs,
                        uint32 ClearBufCount,
                        uint32 *bytesDecrypted,
                        CSSM_DATA_PTR RemData,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI CSM_DecryptDataInit(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI CSM_DecryptDataUpdate(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_DATA *CipherBufs,
                        uint32 CipherBufCount,
                        CSSM_DATA_PTR ClearBufs,
                        uint32 ClearBufCount,
                        uint32 *bytesDecrypted );

CSSM_RETURN CSSMAPI CSM_DecryptDataFinal(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        CSSM_DATA_PTR RemData );

CSSM_RETURN CSSMAPI CSM_QueryKeySizeInBits(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT * Context,
                        const CSSM_KEY *Key,
                        CSSM_KEY_SIZE_PTR KeySize );

CSSM_RETURN CSSMAPI CSM_GenerateKey(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        uint32 KeyUsage,
                        uint32 KeyAttr,
                        const CSSM_DATA *KeyLabel,
                        const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                        CSSM_KEY_PTR Key,
						CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI CSM_GenerateKeyPair(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        uint32 PublicKeyUsage,
                        uint32 PublicKeyAttr,
                        const CSSM_DATA *PublicKeyLabel,
                        CSSM_KEY_PTR PublicKey,
                        uint32 PrivateKeyUsage,
                        uint32 PrivateKeyAttr,
                        const CSSM_DATA *PrivateKeyLabel,
                        const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                        CSSM_KEY_PTR PrivateKey,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI CSM_GenerateRandom(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        CSSM_DATA_PTR RandomNumber );

CSSM_RETURN CSSMAPI CSM_GenerateAlgorithmParams(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        uint32 ParamBits,
                        CSSM_DATA_PTR Param,
                        uint32* NumberOfUpdatedAttributes,
                        CSSM_CONTEXT_ATTRIBUTE_PTR* UpdatedAttributes );

CSSM_RETURN CSSMAPI CSM_WrapKey(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        const CSSM_ACCESS_CREDENTIALS *Credentials,
                        const CSSM_KEY *Key,
                        const CSSM_DATA *DescriptiveData,
                        CSSM_WRAP_KEY_PTR WrappedKey,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI CSM_UnwrapKey(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        const CSSM_KEY *PublicKey,
                        const CSSM_WRAP_KEY *WrappedKey,
                        uint32 KeyUsage,
                        uint32 KeyAttr,
                        const CSSM_DATA *KeyLabel,
                        const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                        CSSM_KEY_PTR UnwrappedKey,
                        CSSM_DATA_PTR DescriptiveData,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI CSM_DeriveKey(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        CSSM_DATA_PTR Param,
                        uint32 KeyUsage,
                        uint32 KeyAttr,
                        const CSSM_DATA *KeyLabel,
                        const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                        CSSM_KEY_PTR DerivedKey );

CSSM_RETURN CSSMAPI CSM_FreeKey(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
                        CSSM_KEY_PTR KeyPtr,
                        CSSM_BOOL Delete );

CSSM_RETURN CSSMAPI CSM_PassThrough(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT *Context,
                        uint32 PassThroughId,
                        const void *InData,
                        void **OutData );

CSSM_RETURN CSSMAPI CSM_Login(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
                        const CSSM_DATA *LoginName,
                        const void *Reserved );

CSSM_RETURN CSSMAPI CSM_Logout(
                        CSSM_CSP_HANDLE CSPHandle );

CSSM_RETURN CSSMAPI CSM_ChangeLoginAcl(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
                        const CSSM_ACL_EDIT *AclEdit );

CSSM_RETURN CSSMAPI CSM_ObtainPrivateKeyFromPublicKey(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_KEY *PublicKey,
                        CSSM_KEY_PTR PrivateKey );

CSSM_RETURN CSSMAPI CSM_RetrieveUniqueId(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_DATA_PTR UniqueID );

CSSM_RETURN CSSMAPI CSM_RetrieveCounter(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_DATA_PTR Counter );

CSSM_RETURN CSSMAPI CSM_VerifyDevice(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_DATA *DeviceCert );

CSSM_RETURN CSSMAPI CSM_GetTimeValue(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_ALGORITHMS TimeAlgorithm,
                        CSSM_DATA *TimeData );

CSSM_RETURN CSSMAPI CSM_GetOperationalStatistics(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CSP_OPERATIONAL_STATISTICS *Statistics );

CSSM_RETURN CSSMAPI CSM_GetLoginAcl(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_STRING *SelectionTag,
                        uint32 *NumberOfAclInfos,
                        CSSM_ACL_ENTRY_INFO_PTR *AclInfos );

CSSM_RETURN CSSMAPI CSM_GetKeyAcl(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_KEY *Key,
                        const CSSM_STRING *SelectionTag,
                        uint32 *NumberOfAclInfos,
                        CSSM_ACL_ENTRY_INFO_PTR *AclInfos );

CSSM_RETURN CSSMAPI CSM_ChangeKeyAcl(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
                        const CSSM_ACL_EDIT *AclEdit,
                        const CSSM_KEY *Key );

CSSM_RETURN CSSMAPI CSM_GetKeyOwner(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_KEY *Key,
                        CSSM_ACL_OWNER_PROTOTYPE_PTR Owner );

CSSM_RETURN CSSMAPI CSM_ChangeKeyOwner(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
                        const CSSM_KEY *Key,
                        const CSSM_ACL_OWNER_PROTOTYPE *NewOwner );

CSSM_RETURN CSSMAPI CSM_GetLoginOwner(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_ACL_OWNER_PROTOTYPE_PTR Owner );

CSSM_RETURN CSSMAPI CSM_ChangeLoginOwner(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
                        const CSSM_ACL_OWNER_PROTOTYPE *NewOwner );


/************************************************************************/
/*** Cryptographic Service Provider SPI Handlers ************************/
/************************************************************************/

CSSM_RETURN CSSMAPI ADDIN_CSM_EventNotify(
                        CSSM_MODULE_HANDLE CSPHandle,
                        CSSM_CONTEXT_EVENT Event,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT* Context );

CSSM_RETURN CSSMAPI ADDIN_CSM_QuerySize(
                        CSM_SESSION *pSession,
                        CSSM_BOOL Encrypt,
                        uint32 QuerySizeCount,
                        CSSM_QUERY_SIZE_DATA_PTR DataBlock );

CSSM_RETURN CSSMAPI ADDIN_CSM_SignData(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount,
                        CSSM_ALGORITHMS DigestAlgorithm,
                        CSSM_DATA_PTR Signature );

CSSM_RETURN CSSMAPI ADDIN_CSM_SignDataInit(
                        CSM_SESSION *pSession );

CSSM_RETURN CSSMAPI ADDIN_CSM_SignDataUpdate(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount );

CSSM_RETURN CSSMAPI ADDIN_CSM_SignDataFinal(
                        CSM_SESSION *pSession,
                        CSSM_DATA_PTR Signature );

CSSM_RETURN CSSMAPI ADDIN_CSM_VerifyData(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount,
                        CSSM_ALGORITHMS DigestAlgorithm,
                        const CSSM_DATA *Signature );

CSSM_RETURN CSSMAPI ADDIN_CSM_VerifyDataInit(
                        CSM_SESSION *pSession );

CSSM_RETURN CSSMAPI ADDIN_CSM_VerifyDataUpdate(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount );

CSSM_RETURN CSSMAPI ADDIN_CSM_VerifyDataFinal(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *Signature );

CSSM_RETURN CSSMAPI ADDIN_CSM_DigestData(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount,
                        CSSM_DATA_PTR Digest );

CSSM_RETURN CSSMAPI ADDIN_CSM_DigestDataInit(
                        CSM_SESSION *pSession );

CSSM_RETURN CSSMAPI ADDIN_CSM_DigestDataUpdate(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount );

#ifdef CSM_TRUSTWAY
CSSM_RETURN CSSMAPI ADDIN_CSM_DigestDataClone(
                        const CSM_SESSION *pSrcSession,
			CSM_SESSION *pDestSession);
#else
CSSM_RETURN CSSMAPI ADDIN_CSM_DigestDataClone(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        CSSM_CC_HANDLE ClonednewCCHandle );
#endif

CSSM_RETURN CSSMAPI ADDIN_CSM_DigestDataFinal(
                        CSM_SESSION *pSession,
                        CSSM_DATA_PTR Digest );

CSSM_RETURN CSSMAPI ADDIN_CSM_GenerateMac(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount,
                        CSSM_DATA_PTR Mac );

CSSM_RETURN CSSMAPI ADDIN_CSM_GenerateMacInit(
                        CSM_SESSION *pSession );

CSSM_RETURN CSSMAPI ADDIN_CSM_GenerateMacUpdate(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount );

CSSM_RETURN CSSMAPI ADDIN_CSM_GenerateMacFinal(
                        CSM_SESSION *pSession,
                        CSSM_DATA_PTR Mac );

CSSM_RETURN CSSMAPI ADDIN_CSM_VerifyMac(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount,
                        const CSSM_DATA *Mac );

CSSM_RETURN CSSMAPI ADDIN_CSM_VerifyMacInit(
                        CSM_SESSION *pSession );

CSSM_RETURN CSSMAPI ADDIN_CSM_VerifyMacUpdate(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *DataBufs,
                        uint32 DataBufCount );

CSSM_RETURN CSSMAPI ADDIN_CSM_VerifyMacFinal(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *Mac );

CSSM_RETURN CSSMAPI ADDIN_CSM_EncryptData(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *ClearBufs,
                        uint32 ClearBufCount,
                        CSSM_DATA_PTR CipherBufs,
                        uint32 CipherBufCount,
                        uint32 *bytesEncrypted,
                        CSSM_DATA_PTR RemData,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI ADDIN_CSM_EncryptDataInit(
                        CSM_SESSION *pSession,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI ADDIN_CSM_EncryptDataUpdate(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *ClearBufs,
                        uint32 ClearBufCount,
                        CSSM_DATA_PTR CipherBufs,
                        uint32 CipherBufCount,
                        uint32 *bytesEncrypted );

CSSM_RETURN CSSMAPI ADDIN_CSM_EncryptDataFinal(
                        CSM_SESSION *pSession,
                        CSSM_DATA_PTR RemData );

CSSM_RETURN CSSMAPI ADDIN_CSM_DecryptData(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *CipherBufs,
                        uint32 CipherBufCount,
                        CSSM_DATA_PTR ClearBufs,
                        uint32 ClearBufCount,
                        uint32 *bytesDecrypted,
                        CSSM_DATA_PTR RemData,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI ADDIN_CSM_DecryptDataInit(
                        CSM_SESSION *pSession,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI ADDIN_CSM_DecryptDataUpdate(
                        CSM_SESSION *pSession,
                        const CSSM_DATA *CipherBufs,
                        uint32 CipherBufCount,
                        CSSM_DATA_PTR ClearBufs,
                        uint32 ClearBufCount,
                        uint32 *bytesDecrypted );

CSSM_RETURN CSSMAPI ADDIN_CSM_DecryptDataFinal(
                        CSM_SESSION *pSession,
                        CSSM_DATA_PTR RemData );

CSSM_RETURN CSSMAPI ADDIN_CSM_QueryKeySizeInBits(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CC_HANDLE CCHandle,
                        const CSSM_CONTEXT * Context,
                        const CSSM_KEY *Key,
                        CSSM_KEY_SIZE_PTR KeySize );

CSSM_RETURN CSSMAPI ADDIN_CSM_GenerateKey(
                        CSM_SESSION *pSession,
                        uint32 KeyUsage,
                        uint32 KeyAttr,
                        const CSSM_DATA *KeyLabel,
                        const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                        CSSM_KEY_PTR Key,
						CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI ADDIN_CSM_GenerateKeyPair(
                        CSM_SESSION *pSession,
                        uint32 PublicKeyUsage,
                        uint32 PublicKeyAttr,
                        const CSSM_DATA *PublicKeyLabel,
                        CSSM_KEY_PTR PublicKey,
                        uint32 PrivateKeyUsage,
                        uint32 PrivateKeyAttr,
                        const CSSM_DATA *PrivateKeyLabel,
                        const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                        CSSM_KEY_PTR PrivateKey,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI ADDIN_CSM_GenerateRandom(
                        CSM_SESSION *pSession,
                        CSSM_DATA_PTR RandomNumber );

CSSM_RETURN CSSMAPI ADDIN_CSM_GenerateAlgorithmParams(
                        CSM_SESSION *pSession,
                        uint32 ParamBits,
                        CSSM_DATA_PTR Param,
                        uint32* NumberOfUpdatedAttributes,
                        CSSM_CONTEXT_ATTRIBUTE_PTR* UpdatedAttributes );

CSSM_RETURN CSSMAPI ADDIN_CSM_WrapKey(
                        CSM_SESSION *pSession,
                        const CSSM_ACCESS_CREDENTIALS *Credentials,
                        const CSSM_KEY *Key,
                        const CSSM_DATA *DescriptiveData,
                        CSSM_WRAP_KEY_PTR WrappedKey,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI ADDIN_CSM_UnwrapKey(
                        CSM_SESSION *pSession,
                        const CSSM_KEY *PublicKey,
                        const CSSM_WRAP_KEY *WrappedKey,
                        uint32 KeyUsage,
                        uint32 KeyAttr,
                        const CSSM_DATA *KeyLabel,
                        const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                        CSSM_KEY_PTR UnwrappedKey,
                        CSSM_DATA_PTR DescriptiveData,
                        CSSM_PRIVILEGE Privilege );

CSSM_RETURN CSSMAPI ADDIN_CSM_DeriveKey(
                        CSM_SESSION *pSession,
                        CSSM_DATA_PTR Param,
                        uint32 KeyUsage,
                        uint32 KeyAttr,
                        const CSSM_DATA *KeyLabel,
                        const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
                        CSSM_KEY_PTR DerivedKey );

CSSM_RETURN CSSMAPI ADDIN_CSM_FreeKey(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
                        CSSM_KEY_PTR KeyPtr,
                        CSSM_BOOL Delete );

CSSM_RETURN CSSMAPI ADDIN_CSM_PassThrough(
                        CSM_SESSION *pSession,
                        uint32 PassThroughId,
                        const void *InData,
                        void **OutData );

CSSM_RETURN CSSMAPI ADDIN_CSM_Login(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
                        const CSSM_DATA *LoginName,
                        const void *Reserved );

CSSM_RETURN CSSMAPI ADDIN_CSM_Logout(
                        CSSM_CSP_HANDLE CSPHandle );

CSSM_RETURN CSSMAPI ADDIN_CSM_ChangeLoginAcl(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
                        const CSSM_ACL_EDIT *AclEdit );

CSSM_RETURN CSSMAPI ADDIN_CSM_ObtainPrivateKeyFromPublicKey(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_KEY *PublicKey,
                        CSSM_KEY_PTR PrivateKey );

CSSM_RETURN CSSMAPI ADDIN_CSM_RetrieveUniqueId(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_DATA_PTR UniqueID );

CSSM_RETURN CSSMAPI ADDIN_CSM_RetrieveCounter(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_DATA_PTR Counter );

CSSM_RETURN CSSMAPI ADDIN_CSM_VerifyDevice(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_DATA *DeviceCert );

CSSM_RETURN CSSMAPI ADDIN_CSM_GetTimeValue(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_ALGORITHMS TimeAlgorithm,
                        CSSM_DATA *TimeData );

CSSM_RETURN CSSMAPI ADDIN_CSM_GetOperationalStatistics(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_CSP_OPERATIONAL_STATISTICS *Statistics );

CSSM_RETURN CSSMAPI ADDIN_CSM_GetLoginAcl(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_STRING *SelectionTag,
                        uint32 *NumberOfAclInfos,
                        CSSM_ACL_ENTRY_INFO_PTR *AclInfos );

CSSM_RETURN CSSMAPI ADDIN_CSM_GetKeyAcl(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_KEY *Key,
                        const CSSM_STRING *SelectionTag,
                        uint32 *NumberOfAclInfos,
                        CSSM_ACL_ENTRY_INFO_PTR *AclInfos );

CSSM_RETURN CSSMAPI ADDIN_CSM_ChangeKeyAcl(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
                        const CSSM_ACL_EDIT *AclEdit,
                        const CSSM_KEY *Key );

CSSM_RETURN CSSMAPI ADDIN_CSM_GetKeyOwner(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_KEY *Key,
                        CSSM_ACL_OWNER_PROTOTYPE_PTR Owner );

CSSM_RETURN CSSMAPI ADDIN_CSM_ChangeKeyOwner(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
                        const CSSM_KEY *Key,
                        const CSSM_ACL_OWNER_PROTOTYPE *NewOwner );

CSSM_RETURN CSSMAPI ADDIN_CSM_GetLoginOwner(
                        CSSM_CSP_HANDLE CSPHandle,
                        CSSM_ACL_OWNER_PROTOTYPE_PTR Owner );

CSSM_RETURN CSSMAPI ADDIN_CSM_ChangeLoginOwner(
                        CSSM_CSP_HANDLE CSPHandle,
                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
                        const CSSM_ACL_OWNER_PROTOTYPE *NewOwner );


/************************************************************************/
/*** Function declarations that do not have two separate declarations ***/
/************************************************************************/

/* Function declarations that do not have two separate declarations */
void ADDIN_CSM_DigestDataError( CSM_SESSION *pSession );
void ADDIN_CSM_EncryptDataError( CSM_SESSION *pSession );
void ADDIN_CSM_DecryptDataError( CSM_SESSION *pSession );
void ADDIN_CSM_GenerateMacError( CSM_SESSION *pSession );
void ADDIN_CSM_VerifyMacError( CSM_SESSION *pSession );
void ADDIN_CSM_SignDataError( CSM_SESSION *pSession );
void ADDIN_CSM_VerifyDataError( CSM_SESSION *pSession );

CSSM_RETURN ADDIN_CSM_DuplicateDigestState( 
                        const CSSM_CONTEXT *pContext,
                        const void *pSrcState,
                        uint32 uSrcStateSize,
                        void *pDestState );

#ifdef __cplusplus
}
#endif

#endif /* ifndef __CSM_CSPI_H__ */