hitls_cert.h

/*
 * This file is part of the openHiTLS project.
 *
 * openHiTLS is licensed under the Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
 * You may obtain a copy of Mulan PSL v2 at:
 *
 *     http://license.coscl.org.cn/MulanPSL2
 *
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PSL v2 for more details.
 */

 
#ifndef HITLS_CERT_H
#define HITLS_CERT_H
 
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
#include "hitls_type.h"
#include "hitls_cert_type.h"
#include "hitls_error.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define HITLS_CERT_SET_FIRST    1
#define HITLS_CERT_SET_NEXT     2

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);

#define HITLS_CFG_SetVerifyDepth(config, depth) \
    HITLS_CFG_CtrlSetVerifyParams(config, NULL, CERT_STORE_CTRL_SET_VERIFY_DEPTH, depth, NULL)

#define HITLS_CFG_GetVerifyDepth(config, depth) \
    HITLS_CFG_CtrlGetVerifyParams((HITLS_Config *)(uintptr_t)(config), NULL, CERT_STORE_CTRL_GET_VERIFY_DEPTH, depth)

#define HITLS_SetVerifyDepth(ctx, depth) \
    HITLS_CtrlSetVerifyParams(ctx, NULL, CERT_STORE_CTRL_SET_VERIFY_DEPTH, depth, NULL)

#define HITLS_GetVerifyDepth(ctx, depth) \
    HITLS_CtrlGetVerifyParams(ctx, NULL, CERT_STORE_CTRL_GET_VERIFY_DEPTH, 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);

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);

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_ProviderLoadKeyFile(HITLS_Config *config, const char *file, const char *format, const char *type);

int32_t HITLS_CFG_LoadKeyBuffer(HITLS_Config *config, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format);

int32_t HITLS_CFG_ProviderLoadKeyBuffer(HITLS_Config *config, const uint8_t *buf, uint32_t bufLen, const char *format,
    const char *type);

HITLS_CERT_Key *HITLS_CFG_GetPrivateKey(HITLS_Config *config);

int32_t HITLS_CFG_CheckPrivateKey(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_ProviderLoadKeyFile(HITLS_Ctx *ctx, const char *file, const char *format, const char *type);

int32_t HITLS_LoadKeyBuffer(HITLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format);

int32_t HITLS_ProviderLoadKeyBuffer(HITLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, const char *format,
    const char *type);
HITLS_CERT_Key *HITLS_GetPrivateKey(HITLS_Ctx *ctx);

int32_t HITLS_CheckPrivateKey(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, HITLS_CERT_X509 *cert,
    HITLS_CERT_StoreType storeType, bool isClone);

HITLS_CERT_X509 *HITLS_CFG_ParseCert(HITLS_Config *config, const uint8_t *buf, uint32_t len,
    HITLS_ParseType type, HITLS_ParseFormat format);

HITLS_CERT_Key *HITLS_CFG_ParseKey(HITLS_Config *config, const uint8_t *buf, uint32_t len,
    HITLS_ParseType type, HITLS_ParseFormat format);

HITLS_CERT_Key *HITLS_CFG_ProviderParseKey(HITLS_Config *config, const uint8_t *buf, uint32_t len,
    HITLS_ParseType type, const char *format, const char *encodeType);

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(HITLS_Config *config);

int32_t HITLS_SetVerifyCb(HITLS_Ctx *ctx, HITLS_VerifyCb callback);

HITLS_VerifyCb HITLS_GetVerifyCb(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_GetPeerCAList(const HITLS_Ctx *ctx);

HITLS_TrustedCAList *HITLS_GetCAList(const HITLS_Ctx *ctx);

int32_t HITLS_SetCAList(HITLS_Ctx *ctx, HITLS_TrustedCAList *list);

int32_t HITLS_CFG_AddExtraChainCert(HITLS_Config *config, HITLS_CERT_X509 *cert);

HITLS_CERT_Chain *HITLS_CFG_GetExtraChainCerts(HITLS_Config *config);

int32_t HITLS_CFG_ClearExtraChainCerts(HITLS_Config *config);

int32_t HITLS_CFG_SetCurrentCert(HITLS_Config *config, long option);

int32_t HITLS_SetCurrentCert(HITLS_Ctx *ctx, long option);
 
/* If the ClientHello callback is successfully executed, the handshake continues */
#define HITLS_CERT_CALLBACK_SUCCESS 1
/* The  ClientHello callback fails. Send an alert message and terminate the handshake */
#define HITLS_CERT_CALLBACK_FAILED 0
/* The ClientHello callback is suspended. The handshake process is suspended and the callback is called again */
#define HITLS_CERT_CALLBACK_RETRY (-1)

typedef int32_t (*HITLS_CertCb)(HITLS_Ctx *ctx, void *arg);

int32_t HITLS_CFG_SetCertCb(HITLS_Config *config, HITLS_CertCb certCb, void *arg);

int32_t HITLS_SetCertCb(HITLS_Ctx *ctx, HITLS_CertCb certCb, void *arg);

typedef void (*HITLS_KeyLogCb)(HITLS_Ctx *ctx, const char *line);

int32_t HITLS_CFG_SetKeyLogCb(HITLS_Config *config, HITLS_KeyLogCb callback);

HITLS_KeyLogCb HITLS_CFG_GetKeyLogCb(HITLS_Config *config);

int32_t HITLS_LogSecret(HITLS_Ctx *ctx, const char *label, const uint8_t *secret, size_t secretLen);

int32_t HITLS_CFG_ParseCAList(HITLS_Config *config, const char *input, uint32_t inputLen, HITLS_ParseType inputType,
                              HITLS_ParseFormat format, HITLS_TrustedCAList **caList);

int32_t HITLS_CFG_BuildCertChain(HITLS_Config *config, HITLS_BUILD_CHAIN_FLAG flag);

int32_t HITLS_BuildCertChain(HITLS_Ctx *ctx, HITLS_BUILD_CHAIN_FLAG flag);

int32_t HITLS_CFG_CtrlSetVerifyParams(
    HITLS_Config *config, HITLS_CERT_Store *store, uint32_t cmd, int64_t in, void *inArg);

int32_t HITLS_CFG_CtrlGetVerifyParams(HITLS_Config *config, HITLS_CERT_Store *store, uint32_t cmd, void *out);

int32_t HITLS_CtrlSetVerifyParams(HITLS_Ctx *ctx, HITLS_CERT_Store *store, uint32_t cmd, int64_t in, void *inArg);

int32_t HITLS_CtrlGetVerifyParams(HITLS_Ctx *ctx, HITLS_CERT_Store *store, uint32_t cmd, void *out);

int32_t HITLS_CFG_LoadCrlFile(HITLS_Config *config, const char *file, HITLS_ParseFormat format);

int32_t HITLS_CFG_LoadCrlBuffer(HITLS_Config *config, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format);

int32_t HITLS_CFG_ClearVerifyCrls(HITLS_Config *config);

int32_t HITLS_LoadCrlFile(HITLS_Ctx *ctx, const char *file, HITLS_ParseFormat format);

int32_t HITLS_LoadCrlBuffer(HITLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format);

int32_t HITLS_ClearVerifyCrls(HITLS_Ctx *ctx);

#define HITLS_CFG_SetVerifyFlags(config, verifyFlags) HITLS_CFG_CtrlSetVerifyParams(config, \
    NULL, CERT_STORE_CTRL_SET_VERIFY_FLAGS, verifyFlags, NULL)

#define HITLS_CFG_GetVerifyFlags(config, verifyFlags) HITLS_CFG_CtrlGetVerifyParams(config, \
    NULL, CERT_STORE_CTRL_GET_VERIFY_FLAGS, verifyFlags)

#define HITLS_SetVerifyFlags(ctx, verifyFlags) HITLS_CtrlSetVerifyParams(ctx, \
    NULL, CERT_STORE_CTRL_SET_VERIFY_FLAGS, verifyFlags, NULL)

#define HITLS_GetVerifyFlags(ctx, verifyFlags) HITLS_CtrlGetVerifyParams(ctx, \
    NULL, CERT_STORE_CTRL_GET_VERIFY_FLAGS, verifyFlags)

int32_t HITLS_CFG_FreeCert(HITLS_Config *config, HITLS_CERT_X509 *cert);

int32_t HITLS_CFG_FreeKey(HITLS_Config *config, HITLS_CERT_Key *key);
int32_t HITLS_UseCertificateChainFile(HITLS_Ctx *ctx, const char *file);

int32_t HITLS_CFG_UseCertificateChainFile(HITLS_Config *config, const char *file);

int32_t HITLS_CFG_UseCertificateChainBuffer(HITLS_Config *config, const uint8_t *buf,
    uint32_t bufLen, HITLS_ParseFormat format);
int32_t HITLS_UseCertificateChainBuffer(HITLS_Ctx *ctx, const uint8_t *buf,
    uint32_t bufLen, HITLS_ParseFormat format);

int32_t HITLS_CFG_LoadVerifyFile(HITLS_Config *config, const char *file);

int32_t HITLS_CFG_LoadVerifyBuffer(HITLS_Config *config, const uint8_t *buf,
    uint32_t bufLen, HITLS_ParseFormat format);
int32_t HITLS_LoadVerifyBuffer(HITLS_Ctx *ctx, const uint8_t *buf,
    uint32_t bufLen, HITLS_ParseFormat format);

int32_t HITLS_CFG_LoadVerifyDir(HITLS_Config *config, const char *path);

int32_t HITLS_CFG_LoadDefaultCAPath(HITLS_Config *config);
#ifdef __cplusplus
}
#endif
 
#endif /* HITLS_CERT_H */