hitls_cert.h

浏览该文件的文档.

/*---------------------------------------------------------------------------------------------
 *  This file is part of the openHiTLS project.
 *  Copyright © 2023 Huawei Technologies Co.,Ltd. All rights reserved.
 *  Licensed under the openHiTLS Software license agreement 1.0. See LICENSE in the project root
 *  for license information.
 *---------------------------------------------------------------------------------------------
 */
 
#ifndef HITLS_CERT_H
#define HITLS_CERT_H
 
#include <stdbool.h>
#include <stdint.h>
#include "hitls_type.h"
#include "hitls_cert_type.h"
#include "hitls_cert_reg.h"
#include "hitls_error.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
int32_t HITLS_CFG_SetVerifyStore(HITLS_Config *config, HITLS_CERT_Store *store, bool isClone);
 
HITLS_CERT_Store *HITLS_CFG_GetVerifyStore(const HITLS_Config *config);
 
int32_t HITLS_SetVerifyStore(HITLS_Ctx *ctx, HITLS_CERT_Store *store, bool isClone);
 
HITLS_CERT_Store *HITLS_GetVerifyStore(const HITLS_Ctx *ctx);
 
int32_t HITLS_CFG_SetChainStore(HITLS_Config *config, HITLS_CERT_Store *store, bool isClone);
 
HITLS_CERT_Store *HITLS_CFG_GetChainStore(const HITLS_Config *config);
 
int32_t HITLS_SetChainStore(HITLS_Ctx *ctx, HITLS_CERT_Store *store, bool isClone);
 
HITLS_CERT_Store *HITLS_GetChainStore(const HITLS_Ctx *ctx);
 
int32_t HITLS_CFG_SetCertStore(HITLS_Config *config, HITLS_CERT_Store *store, bool isClone);
 
HITLS_CERT_Store *HITLS_CFG_GetCertStore(const HITLS_Config *config);
 
int32_t HITLS_SetCertStore(HITLS_Ctx *ctx, HITLS_CERT_Store *store, bool isClone);
 
HITLS_CERT_Store *HITLS_GetCertStore(const HITLS_Ctx *ctx);
 
int32_t HITLS_CFG_SetVerifyDepth(HITLS_Config *config, uint32_t depth);
 
int32_t HITLS_CFG_GetVerifyDepth(const HITLS_Config *config, uint32_t *depth);
 
int32_t HITLS_SetVerifyDepth(HITLS_Ctx *ctx, uint32_t depth);
 
int32_t HITLS_GetVerifyDepth(const HITLS_Ctx *ctx, uint32_t *depth);
 
typedef int32_t (*HITLS_PasswordCb)(char *buf, int32_t bufLen, int32_t flag, void *userdata);
 
int32_t HITLS_CFG_SetDefaultPasswordCb(HITLS_Config *config, HITLS_PasswordCb cb);
 
HITLS_PasswordCb HITLS_CFG_GetDefaultPasswordCb(HITLS_Config *config);
 
int32_t HITLS_CFG_SetDefaultPasswordCbUserdata(HITLS_Config *config, void *userdata);
 
void *HITLS_CFG_GetDefaultPasswordCbUserdata(HITLS_Config *config);
 
int32_t HITLS_SetDefaultPasswordCb(HITLS_Ctx *ctx, HITLS_PasswordCb cb);
 
HITLS_PasswordCb HITLS_GetDefaultPasswordCb(HITLS_Ctx *ctx);
 
int32_t HITLS_SetDefaultPasswordCbUserdata(HITLS_Ctx *ctx, void *userdata);
 
void *HITLS_GetDefaultPasswordCbUserdata(HITLS_Ctx *ctx);
 
#ifndef HITLS_NO_TLCP11
int32_t HITLS_CFG_SetTlcpCertificate(HITLS_Config *config, HITLS_CERT_X509 *cert, bool isClone, bool isTlcpEncCert);
 
int32_t HITLS_CFG_SetTlcpPrivateKey(HITLS_Config *config, HITLS_CERT_Key *privateKey,
    bool isClone, bool isTlcpEncCertPriKey);
#endif
 
int32_t HITLS_CFG_SetCertificate(HITLS_Config *config, HITLS_CERT_X509 *cert, bool isClone);
 
int32_t HITLS_CFG_LoadCertFile(HITLS_Config *config, const char *file, HITLS_ParseFormat format);
 
int32_t HITLS_CFG_LoadCertBuffer(HITLS_Config *config, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format);
 
HITLS_CERT_X509 *HITLS_CFG_GetCertificate(const HITLS_Config *config);
 
int32_t HITLS_SetCertificate(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert, bool isClone);
 
int32_t HITLS_LoadCertFile(HITLS_Ctx *ctx, const char *file, HITLS_ParseFormat format);
 
int32_t HITLS_LoadCertBuffer(HITLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format);
 
HITLS_CERT_X509 *HITLS_GetCertificate(const HITLS_Ctx *ctx);
 
HITLS_CERT_X509 *HITLS_GetPeerCertificate(const HITLS_Ctx *ctx);
 
int32_t HITLS_CFG_SetPrivateKey(HITLS_Config *config, HITLS_CERT_Key *privateKey, bool isClone);
 
int32_t HITLS_CFG_LoadKeyFile(HITLS_Config *config, const char *file, HITLS_ParseFormat format);
 
int32_t HITLS_CFG_LoadKeyBuffer(HITLS_Config *config, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format);
 
HITLS_CERT_Key *HITLS_CFG_GetPrivateKey(const HITLS_Config *config);
 
int32_t HITLS_CFG_CheckPrivateKey(const HITLS_Config *config);
 
int32_t HITLS_SetPrivateKey(HITLS_Ctx *ctx, HITLS_CERT_Key *key, bool isClone);
 
int32_t HITLS_LoadKeyFile(HITLS_Ctx *ctx, const char *file, HITLS_ParseFormat format);
 
int32_t HITLS_LoadKeyBuffer(HITLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format);
 
HITLS_CERT_Key *HITLS_GetPrivateKey(HITLS_Ctx *ctx);
 
int32_t HITLS_CheckPrivateKey(const HITLS_Ctx *ctx);
 
int32_t HITLS_CFG_AddChainCert(HITLS_Config *config, HITLS_CERT_X509 *cert, bool isClone);
 
int32_t HITLS_CFG_AddCertToStore(HITLS_Config *config, char *certPath, HITLS_CERT_StoreType storeType);
 
HITLS_CERT_Chain *HITLS_CFG_GetChainCerts(HITLS_Config *config);
 
int32_t HITLS_CFG_ClearChainCerts(HITLS_Config *config);
 
int32_t HITLS_ClearChainCerts(HITLS_Ctx *ctx);
 
int32_t HITLS_CFG_RemoveCertAndKey(HITLS_Config *config);
 
int32_t HITLS_RemoveCertAndKey(HITLS_Ctx *ctx);
 
typedef int (*HITLS_VerifyCb)(int32_t isPreverifyOk, HITLS_CERT_StoreCtx *storeCtx);
 
int32_t HITLS_CFG_SetVerifyCb(HITLS_Config *config, HITLS_VerifyCb callback);
 
HITLS_VerifyCb HITLS_CFG_GetVerifyCb(const HITLS_Config *config);
 
int32_t HITLS_SetVerifyCb(HITLS_Ctx *ctx, HITLS_VerifyCb callback);
 
HITLS_VerifyCb HITLS_GetVerifyCb(const HITLS_Ctx *ctx);
 
int32_t HITLS_SetVerifyResult(HITLS_Ctx *ctx, HITLS_ERROR verifyResult);
 
int32_t HITLS_GetVerifyResult(const HITLS_Ctx *ctx, HITLS_ERROR *verifyResult);
 
HITLS_CERT_Chain *HITLS_GetPeerCertChain(const HITLS_Ctx *ctx);
 
HITLS_TrustedCAList *HITLS_GetClientCAList(const HITLS_Ctx *ctx);
 
int32_t HITLS_CFG_AddExtraChainCert(HITLS_Config *config, HITLS_CERT_X509 *cert);
 
HITLS_CERT_Chain *HITLS_CFG_GetExtraChainCerts(HITLS_Config *config);
 
#ifdef __cplusplus
}
#endif
 
#endif /* HITLS_CERT_H */