cssmapi.h

来自「Next BIOS Source code : Extensible Firmw」· C头文件 代码 · 共 660 行 · 第 1/3 页

                                       uint32 *bytesEncrypted,
                                       CSSM_DATA_PTR RemData);

/* Returns the decrypted data */
CSSM_RETURN CSSMAPI CSSM_DecryptData  (const CSSM_CC_HANDLE CCHandle,
                                       const CSSM_DATA_PTR CipherBufs,
                                       uint32 CipherBufCount,
                                       CSSM_DATA_PTR ClearBufs,
                                       uint32 ClearBufCount,
                                       uint32 *bytesDecrypted,
                                       CSSM_DATA_PTR RemData);

/* Query to get the key size */
CSSM_RETURN CSSMAPI CSSM_QueryKeySizeInBits (
                                       CSSM_CSP_HANDLE CSPHandle,
                                       CSSM_CC_HANDLE CCHandle,
                                       const CSSM_KEY_PTR Key,
                                       CSSM_KEY_SIZE_PTR KeySize);

/* Returns the symmetric key */
CSSM_RETURN CSSMAPI CSSM_GenerateKey  (CSSM_CC_HANDLE CCHandle,
                                       uint32 KeyUsage,
                                       uint32 KeyAttr,
                                       const CSSM_DATA_PTR KeyLabel,
                                       CSSM_KEY_PTR Key);

/* Returns the asymmetric key pair */
CSSM_RETURN CSSMAPI CSSM_GenerateKeyPair (
                                       CSSM_CC_HANDLE CCHandle,
                                       uint32 PublicKeyUsage,
                                       uint32 PublicKeyAttr,
                                       const CSSM_DATA_PTR PublicKeyLabel,
                                       CSSM_KEY_PTR PublicKey,
                                       uint32 PrivateKeyUsage,
                                       uint32 PrivateKeyAttr,
                                       const CSSM_DATA_PTR PrivateKeyLabel,
                                       CSSM_KEY_PTR PrivateKey);

/* Returns the random data */
CSSM_RETURN CSSMAPI CSSM_GenerateRandom(CSSM_CC_HANDLE CCHandle,
                                       CSSM_DATA_PTR RandomNumber);

CSSM_RETURN CSSMAPI CSSM_CSP_ObtainPrivateKeyFromPublicKey (
                                       CSSM_CSP_HANDLE CSPHandle,
                                       const CSSM_KEY_PTR PublicKey,
                                       CSSM_KEY_PTR PrivateKey);

CSSM_RETURN CSSMAPI CSSM_WrapKey      (CSSM_CC_HANDLE CCHandle,
                                       const CSSM_CRYPTO_DATA_PTR PassPhrase, 
                                       const CSSM_KEY_PTR Key,
                                       const CSSM_DATA_PTR DescriptiveData,
                                       CSSM_WRAP_KEY_PTR WrappedKey);

CSSM_RETURN CSSMAPI CSSM_UnwrapKey    (CSSM_CC_HANDLE CCHandle,
                                       const CSSM_CRYPTO_DATA_PTR NewPassPhrase,
                                       const CSSM_KEY_PTR PublicKey,
                                       const CSSM_WRAP_KEY_PTR WrappedKey,
                                       uint32 KeyUsage,
                                       uint32 KeyAttr,
                                       const CSSM_DATA_PTR KeyLabel,
                                       CSSM_KEY_PTR UnwrappedKey,
                                       CSSM_DATA_PTR DescriptiveData);

CSSM_RETURN CSSMAPI CSSM_FreeKey      (CSSM_CSP_HANDLE CSPHandle,
                                       CSSM_KEY_PTR KeyPtr);

CSSM_RETURN CSSMAPI CSSM_GenerateAlgorithmParams 
                                      (CSSM_CC_HANDLE CCHandle,
                                       uint32 ParamBits,
                                       CSSM_DATA_PTR Param);

/*
 * Miscellaneous Functions 
 */
CSSM_RETURN CSSMAPI CSSM_RetrieveUniqueId (CSSM_CSP_HANDLE CSPHandle,
                                           CSSM_DATA_PTR UniqueID);

CSSM_RETURN CSSMAPI CSSM_RetrieveCounter (CSSM_CSP_HANDLE CSPHandle,
                                          CSSM_DATA_PTR Counter);

CSSM_RETURN CSSMAPI CSSM_VerifyDevice (CSSM_CSP_HANDLE CSPHandle,
                                       CSSM_DATA_PTR DeviceCert);
/*
 * Extensibility Functions
 */
void * CSSMAPI CSSM_CSP_PassThrough (CSSM_CC_HANDLE CCHandle, 
                                     uint32 PassThroughId,
                                     const void *InData);

/* Trust Policy API */
/* Trust Policy Operations */
CSSM_BOOL CSSMAPI CSSM_TP_CertGroupVerify (
                                      CSSM_TP_HANDLE TPHandle,
                                      CSSM_CL_HANDLE CLHandle,
                                      CSSM_CSP_HANDLE CSPHandle,
                                      const CSSM_DL_DB_LIST_PTR DBList,
                                      const CSSM_CERTGROUP_PTR CertGroupToBeVerified,
                                      const CSSM_VERIFYCONTEXT_PTR VerifyContext); 
                                  
CSSM_BOOL CSSMAPI CSSM_TP_CrlVerify (CSSM_TP_HANDLE TPHandle,
                                CSSM_CL_HANDLE CLHandle,
                                CSSM_CSP_HANDLE CSPHandle,
                                const CSSM_DL_DB_LIST_PTR DBList,
                                const CSSM_DATA_PTR CrlToBeVerified,
                                CSSM_CRL_TYPE CrlType, 
                                CSSM_CRL_ENCODING CrlEncoding,
                                const CSSM_CERTGROUP_PTR SignerCertGroup,
                                const CSSM_VERIFYCONTEXT_PTR VerifyContext);

CSSM_RETURN CSSMAPI CSSM_TP_ApplyCrlToDb (CSSM_TP_HANDLE TPHandle,
                                CSSM_CL_HANDLE CLHandle,
                                CSSM_CSP_HANDLE CSPHandle,
                                const CSSM_DL_DB_LIST_PTR DBList,
                                const CSSM_DATA_PTR CrlToBeApplied,
                                CSSM_CRL_TYPE CrlType,
                                CSSM_CRL_ENCODING CrlEncoding,
                                const CSSM_CERTGROUP_PTR SignerCert,
                                const CSSM_VERIFYCONTEXT_PTR SignerVerifyContext);

/*
 * Extensibility Functions
 */

void * CSSMAPI CSSM_TP_PassThrough (CSSM_TP_HANDLE TPHandle, 
                                    CSSM_CL_HANDLE CLHandle, 
                                    CSSM_CSP_HANDLE CSPHandle, 
                                    const CSSM_DL_DB_LIST_PTR DBList,
                                    uint32 PassThroughId,
                                    const void *InputParams);


/* Certificate Library API */
/* Certificate Operations */
CSSM_BOOL CSSMAPI CSSM_CL_CertVerify (CSSM_CL_HANDLE CLHandle, 
                                      CSSM_CC_HANDLE CCHandle, 
                                      const CSSM_DATA_PTR CertToBeVerified, 
                                      const CSSM_DATA_PTR SignerCert, 
                                      const CSSM_FIELD_PTR VerifyScope,
                                      uint32 ScopeSize);
/* Returns the field value */
CSSM_DATA_PTR CSSMAPI CSSM_CL_CertGetFirstFieldValue (
                                                 CSSM_CL_HANDLE CLHandle, 
                                                 const CSSM_DATA_PTR Cert, 
                                                 const CSSM_OID_PTR CertField,
                                                 CSSM_HANDLE_PTR ResultsHandle,
                                                 uint32 *NumberOfMatchedFields);
/* Returns the field value */
CSSM_DATA_PTR CSSMAPI CSSM_CL_CertGetNextFieldValue (CSSM_CL_HANDLE CLHandle, 
                                                     CSSM_HANDLE ResultsHandle);

CSSM_RETURN CSSMAPI CSSM_CL_CertAbortQuery (CSSM_CL_HANDLE CLHandle, 
                                            CSSM_HANDLE ResultsHandle);

CSSM_KEY_PTR CSSMAPI CSSM_CL_CertGetKeyInfo (CSSM_CL_HANDLE CLHandle, 
                                             const CSSM_DATA_PTR Cert);

/*
 * Certificate Revocation List Operations
 */
CSSM_BOOL CSSMAPI CSSM_CL_CrlVerify (CSSM_CL_HANDLE CLHandle, 
                                     CSSM_CC_HANDLE CCHandle, 
                                     const CSSM_DATA_PTR CrlToBeVerified, 
                                     const CSSM_DATA_PTR SignerCert,
                                     const CSSM_FIELD_PTR VerifyScope,
                                     uint32 ScopeSize);

CSSM_BOOL CSSMAPI CSSM_CL_IsCertInCrl (CSSM_CL_HANDLE CLHandle, 
                                       const CSSM_DATA_PTR Cert, 
                                       const CSSM_DATA_PTR Crl);

/* Returns the first item in the CRL */
CSSM_DATA_PTR CSSMAPI CSSM_CL_CrlGetFirstFieldValue (
                                               CSSM_CL_HANDLE CLHandle, 
                                               const CSSM_DATA_PTR Crl,
                                               const CSSM_OID_PTR CrlField,
                                               CSSM_HANDLE_PTR ResultsHandle,
                                               uint32 *NumberOfMatchedFields);

/* Returns the next item in the CRL */
CSSM_DATA_PTR CSSMAPI CSSM_CL_CrlGetNextFieldValue (CSSM_CL_HANDLE CLHandle, 
                                                    CSSM_HANDLE ResultsHandle);

CSSM_RETURN CSSMAPI CSSM_CL_CrlAbortQuery (CSSM_CL_HANDLE CLHandle, 
                                           CSSM_HANDLE ResultsHandle);

/*
 * Extensibility Functions 
 */

void * CSSMAPI CSSM_CL_PassThrough (CSSM_CL_HANDLE CLHandle, 
                                    CSSM_CC_HANDLE CCHandle, 
                                    uint32 PassThroughId, 
                                    const void * InputParams);


/*
 * Data Storage API
 */

CSSM_DB_HANDLE CSSMAPI CSSM_DL_DbOpen (CSSM_DL_HANDLE DLHandle,
                            const char *DbName,
                            const CSSM_NET_ADDRESS_PTR DbLocation,   
                            const CSSM_DB_ACCESS_TYPE_PTR AccessRequest,
                            const CSSM_USER_AUTHENTICATION_PTR UserAuthentication,
                            const void *OpenParameters);

CSSM_RETURN CSSMAPI CSSM_DL_DbClose (CSSM_DL_DB_HANDLE DLDBHandle);

CSSM_DB_HANDLE CSSMAPI CSSM_DL_DbCreate (CSSM_DL_HANDLE DLHandle,
                            const char *DbName,
                            const CSSM_NET_ADDRESS_PTR DbLocation,   
                            const CSSM_DBINFO_PTR DBInfo,
                            const CSSM_DB_ACCESS_TYPE_PTR AccessRequest,
                            const CSSM_USER_AUTHENTICATION_PTR UserAuthentication,
                            const void *OpenParameters); 

CSSM_RETURN CSSMAPI CSSM_DL_DbDelete (
                     CSSM_DL_HANDLE DLHandle,
                     const char *DbName,
                     const CSSM_NET_ADDRESS_PTR DbLocation,