hitls.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_H
#define HITLS_H
 
#include <stdint.h>
#include <stddef.h>
#include "hitls_type.h"
#include "hitls_config.h"
#include "hitls_cert_type.h"
#include "bsl_uio.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
HITLS_Ctx *HITLS_New(HITLS_Config *config);
 
void HITLS_Free(HITLS_Ctx *ctx);
 
int32_t HITLS_SetUio(HITLS_Ctx *ctx, BSL_UIO *uio);
 
int32_t HITLS_SetReadUio(HITLS_Ctx *ctx, BSL_UIO *uio);
 
BSL_UIO *HITLS_GetUio(const HITLS_Ctx *ctx);
 
BSL_UIO *HITLS_GetReadUio(const HITLS_Ctx *ctx);
 
int32_t HITLS_Connect(HITLS_Ctx *ctx);
 
int32_t HITLS_SetEndPoint(HITLS_Ctx *ctx, bool isClient);
 
int32_t HITLS_Accept(HITLS_Ctx *ctx);
 
int32_t HITLS_Read(HITLS_Ctx *ctx, uint8_t *data, uint32_t bufSize, uint32_t *readLen);
 
int32_t HITLS_Write(HITLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen);
 
int32_t HITLS_GetMaxWriteSize(const HITLS_Ctx *ctx, uint32_t *len);
 
void *HITLS_GetUserData(const HITLS_Ctx *ctx);
 
int32_t HITLS_SetUserData(HITLS_Ctx *ctx, void *userData);
 
int32_t HITLS_Close(HITLS_Ctx *ctx);
 
int32_t HITLS_SetShutdownState(HITLS_Ctx *ctx, uint32_t mode);
 
int32_t HITLS_GetShutdownState(const HITLS_Ctx *ctx, uint32_t *mode);
 
int32_t HITLS_GetNegotiatedVersion(const HITLS_Ctx *ctx, uint16_t *version);
 
int32_t HITLS_GetMaxProtoVersion(const HITLS_Ctx *ctx, uint16_t *maxVersion);
 
int32_t HITLS_GetMinProtoVersion(const HITLS_Ctx *ctx, uint16_t *minVersion);
 
int32_t HITLS_SetMinProtoVersion(HITLS_Ctx *ctx, uint16_t version);
 
int32_t HITLS_SetMaxProtoVersion(HITLS_Ctx *ctx, uint16_t version);
 
int32_t HITLS_IsAead(const HITLS_Ctx *ctx, uint8_t *isAead);
 
int32_t HITLS_IsDtls(const HITLS_Ctx *ctx, uint8_t *isDtls);
 
int32_t HITLS_SetErrorCode(HITLS_Ctx *ctx, int32_t errorCode);
 
int32_t HITLS_GetErrorCode(const HITLS_Ctx *ctx);
 
int32_t HITLS_IsHandShakeDone(const HITLS_Ctx *ctx, uint8_t *isDone);
 
int32_t HITLS_IsServer(const HITLS_Ctx *ctx, uint8_t *isServer);
 
int32_t HITLS_ReadHasPending(const HITLS_Ctx *ctx, uint8_t *isPending);
 
uint32_t HITLS_GetReadPendingBytes(const HITLS_Ctx *ctx);
 
int32_t HITLS_GetPeerSignScheme(const HITLS_Ctx *ctx, HITLS_SignHashAlgo *peerSignScheme);
 
int32_t HITLS_GetLocalSignScheme(const HITLS_Ctx *ctx, HITLS_SignHashAlgo *localSignScheme);
 
int32_t HITLS_SetEcGroups(HITLS_Ctx *ctx, uint16_t *lst, uint32_t groupSize);
 
int32_t HITLS_SetSigalgsList(HITLS_Ctx *ctx, const uint16_t *signAlgs, uint16_t signAlgsSize);
 
int32_t HITLS_SetEcPointFormats(HITLS_Ctx *ctx, const uint8_t *pointFormats, uint32_t pointFormatsSize);
 
int32_t HITLS_SetClientVerifySupport(HITLS_Ctx *ctx, bool support);
 
int32_t HITLS_SetNoClientCertSupport(HITLS_Ctx *ctx, bool support);
 
int32_t HITLS_SetPostHandshakeAuthSupport(HITLS_Ctx *ctx, bool support);
 
int32_t HITLS_SetVerifyNoneSupport(HITLS_Ctx *ctx, bool support);
 
int32_t HITLS_SetClientOnceVerifySupport(HITLS_Ctx *ctx, bool support);
 
const HITLS_Config *HITLS_GetConfig(const HITLS_Ctx *ctx);
 
int32_t HITLS_ClearTLS13CipherSuites(HITLS_Ctx *ctx);
 
int32_t HITLS_SetCipherSuites(HITLS_Ctx *ctx, const uint16_t *cipherSuites, uint32_t cipherSuitesSize);
 
const HITLS_Cipher *HITLS_GetCurrentCipher(const HITLS_Ctx *ctx);
 
int32_t HITLS_GetRandom(const HITLS_Ctx *ctx, uint8_t *out, uint32_t *outlen, bool isClient);
 
int32_t HITLS_GetHandShakeState(const HITLS_Ctx *ctx, uint32_t *state);
 
const char *HITLS_GetStateString(uint32_t state);
 
int32_t HITLS_IsHandShaking(const HITLS_Ctx *ctx, uint8_t *isHandShaking);
 
int32_t HITLS_GetRenegotiationSupport(const HITLS_Ctx *ctx, uint8_t *isSupportRenegotiation);
 
int32_t HITLS_IsBeforeHandShake(const HITLS_Ctx *ctx, uint8_t *isBefore);
 
int32_t HITLS_SetMtu(HITLS_Ctx *ctx, long mtu);
 
int32_t HITLS_GetClientVersion(const HITLS_Ctx *ctx, uint16_t *clientVersion);
 
int32_t HITLS_DoHandShake(HITLS_Ctx *ctx);
 
int32_t HITLS_IsClient(const HITLS_Ctx *ctx, bool *isClient);
 
int32_t HITLS_KeyUpdate(HITLS_Ctx *ctx, uint32_t updateType);
 
int32_t HITLS_GetKeyUpdateType(HITLS_Ctx *ctx);
 
int32_t HITLS_GetSharedGroup(const HITLS_Ctx *ctx, int32_t nmatch, uint16_t *groupId);
 
int32_t HITLS_GetVersionSupport(const HITLS_Ctx *ctx, uint32_t *version);
 
int32_t HITLS_SetVersionSupport(HITLS_Ctx *ctx, uint32_t version);
 
int32_t HITLS_SetVersion(HITLS_Ctx *ctx, uint32_t minVersion, uint32_t maxVersion);
 
int32_t HITLS_SetVersionForbid(HITLS_Ctx *ctx, uint32_t noVersion);
 
int32_t HITLS_SetNeedCheckPmsVersion(HITLS_Ctx *ctx, bool needCheck);
 
int32_t HITLS_SetQuietShutdown(HITLS_Ctx *ctx, int32_t mode);
 
int32_t HITLS_GetQuietShutdown(const HITLS_Ctx *ctx, int32_t *mode);
 
int32_t HITLS_SetDhAutoSupport(HITLS_Ctx *ctx, bool support);
 
int32_t HITLS_SetTmpDh(HITLS_Ctx *ctx, HITLS_CRYPT_Key *dhPkey);
 
int32_t HITLS_SetRecordPaddingCb(HITLS_Ctx *ctx, HITLS_RecordPaddingCb callback);
 
HITLS_RecordPaddingCb HITLS_GetRecordPaddingCb(HITLS_Ctx *ctx);
 
int32_t HITLS_SetRecordPaddingCbArg(HITLS_Ctx *ctx, void *arg);
 
void *HITLS_GetRecordPaddingCbArg(HITLS_Ctx *ctx);
 
int32_t HITLS_GetPeerFinishVerifyData(const HITLS_Ctx *ctx, void *buf, uint32_t bufLen, uint32_t *dataLen);
 
int32_t HITLS_SetCloseCheckKeyUsage(HITLS_Ctx *ctx, bool isClose);
 
int32_t HITLS_GetFinishVerifyData(const HITLS_Ctx *ctx, void *buf, uint32_t bufLen, uint32_t *dataLen);
 
int32_t HITLS_GetSecureRenegotiationSupport(const HITLS_Ctx *ctx, uint8_t *isSecureRenegotiation);
 
int32_t HITLS_Renegotiate(HITLS_Ctx *ctx);
 
int32_t HITLS_GetRenegotiationState(const HITLS_Ctx *ctx, uint8_t *isRenegotiationState);
 
 
int32_t HITLS_GetRwstate(const HITLS_Ctx *ctx, uint8_t *rwstate);
 
int32_t HITLS_GetClientVerifySupport(HITLS_Ctx *ctx, uint8_t *isSupport);
 
int32_t HITLS_GetNoClientCertSupport(HITLS_Ctx *ctx, uint8_t *isSupport);
 
int32_t HITLS_GetPostHandshakeAuthSupport(HITLS_Ctx *ctx, uint8_t *isSupport);
 
int32_t HITLS_GetVerifyNoneSupport(HITLS_Ctx *ctx, uint8_t *isSupport);
 
int32_t HITLS_GetClientOnceVerifySupport(HITLS_Ctx *ctx, uint8_t *isSupport);
 
 
int32_t HITLS_ClearRenegotiationNum(HITLS_Ctx *ctx, uint32_t *renegotiationNum);
 
int32_t HITLS_GetNegotiateGroup(const HITLS_Ctx *ctx, uint16_t *group);
 
int32_t HITLS_SetEncryptThenMac(HITLS_Ctx *ctx, uint32_t encryptThenMacType);
 
int32_t HITLS_GetEncryptThenMac(const HITLS_Ctx *ctx, uint32_t *encryptThenMacType);
 
int32_t HITLS_SetServerName(HITLS_Ctx *ctx, uint8_t *serverName, uint32_t serverNameStrlen);
 
int32_t HITLS_SetCipherServerPreference(HITLS_Ctx *ctx, bool isSupport);
 
int32_t HITLS_GetCipherServerPreference(const HITLS_Ctx *ctx, bool *isSupport);
 
int32_t HITLS_SetRenegotiationSupport(HITLS_Ctx *ctx, bool isSupport);
 
int32_t HITLS_SetSessionTicketSupport(HITLS_Ctx *ctx, bool isSupport);
 
int32_t HITLS_GetSessionTicketSupport(const HITLS_Ctx *ctx, uint8_t *isSupport);
 
int32_t HITLS_SetFlightTransmitSwitch(HITLS_Ctx *ctx, uint8_t isEnable);
 
int32_t HITLS_GetFlightTransmitSwitch(const HITLS_Ctx *ctx, uint8_t *isEnable);
 
int32_t HITLS_GetAllAsyncFds(HITLS_Ctx *ctx, int *fd, int *fdNums);
 
int32_t HITLS_get_ex_data_X509_STORE_CTX_idx(void);
 
int32_t HITLS_SetMaxCertList(HITLS_Ctx *ctx, uint32_t maxSize);
 
int32_t HITLS_GetMaxCertList(const HITLS_Ctx *ctx, uint32_t *maxSize);
 
int32_t HITLS_VerifyClientPostHandshake(HITLS_Ctx *ctx);
#ifdef __cplusplus
}
#endif
 
#endif /* HITLS_H */