hitls.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_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"
#include "bsl_sal.h"
 
#ifdef __cplusplus
extern "C" {
#endif

HITLS_Ctx *HITLS_New(HITLS_Config *config);

void HITLS_Free(HITLS_Ctx *ctx);

int32_t HITLS_Clear(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_Listen(HITLS_Ctx *ctx, BSL_SAL_SockAddr clientAddr);

int32_t HITLS_Read(HITLS_Ctx *ctx, uint8_t *data, uint32_t bufSize, uint32_t *readLen);

int32_t HITLS_Peek(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, uint32_t *writeLen);

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, bool *isAead);

int32_t HITLS_IsDtls(const HITLS_Ctx *ctx, bool *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, bool *isServer);

int32_t HITLS_ReadHasPending(const HITLS_Ctx *ctx, bool *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_GetSharedSigAlgs(const HITLS_Ctx *ctx, int32_t idx, uint16_t *signatureScheme, int32_t *keyType,
    int32_t *paraId);

int32_t HITLS_SetEcGroups(HITLS_Ctx *ctx, uint16_t *lst, uint32_t groupSize);

int32_t HITLS_SetGroupList(HITLS_Ctx *ctx, const char *groups, uint32_t groupNamesLen);

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

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

int32_t HITLS_GetCipherSuites(HITLS_Ctx *ctx, uint16_t *data, uint32_t dataLen, uint32_t *cipherSuitesSize);

int32_t HITLS_GetClientCipherSuites(HITLS_Ctx *ctx, uint16_t *data, uint32_t dataLen, uint32_t *cipherSuitesSize);

const HITLS_Cipher *HITLS_GetCurrentCipher(const HITLS_Ctx *ctx);

HITLS_CIPHER_List *HITLS_GetSupportedCiphers(const HITLS_Ctx *ctx);

int32_t HITLS_GetHsRandom(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, bool *isHandShaking);

int32_t HITLS_GetRenegotiationSupport(const HITLS_Ctx *ctx, bool *isSupportRenegotiation);

int32_t HITLS_IsBeforeHandShake(const HITLS_Ctx *ctx, bool *isBefore);

int32_t HITLS_SetLinkMtu(HITLS_Ctx *ctx, uint16_t linkMtu);

int32_t HITLS_SetMtu(HITLS_Ctx *ctx, uint16_t mtu);

int32_t HITLS_SetNoQueryMtu(HITLS_Ctx *ctx, bool noQueryMtu);

int32_t HITLS_GetNeedQueryMtu(HITLS_Ctx *ctx, bool *needQueryMtu);

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_SetDtlsTimerCb(HITLS_Ctx *ctx, HITLS_DtlsTimerCb cb);

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_SetTmpDhCb(HITLS_Ctx *ctx, HITLS_DhTmpCb callback);

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_SetCheckKeyUsage(HITLS_Ctx *ctx, bool isCheck);

int32_t HITLS_GetFinishVerifyData(const HITLS_Ctx *ctx, void *buf, uint32_t bufLen, uint32_t *dataLen);

int32_t HITLS_GetSecureRenegotiationSupport(const HITLS_Ctx *ctx, bool *isSecureRenegotiation);

int32_t HITLS_Renegotiate(HITLS_Ctx *ctx);

int32_t HITLS_GetRenegotiationState(const HITLS_Ctx *ctx, bool *isRenegotiationState);
 

int32_t HITLS_GetRwstate(const HITLS_Ctx *ctx, uint8_t *rwstate);

int32_t HITLS_GetClientVerifySupport(HITLS_Ctx *ctx, bool *isSupport);

int32_t HITLS_GetNoClientCertSupport(HITLS_Ctx *ctx, bool *isSupport);

int32_t HITLS_GetPostHandshakeAuthSupport(HITLS_Ctx *ctx, bool *isSupport);

int32_t HITLS_GetVerifyNoneSupport(HITLS_Ctx *ctx, bool *isSupport);

int32_t HITLS_GetClientOnceVerifySupport(HITLS_Ctx *ctx, bool *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_SetModeSupport(HITLS_Ctx *ctx, uint32_t mode);

int32_t HITLS_ClearModeSupport(HITLS_Ctx *ctx, uint32_t mode);

int32_t HITLS_GetModeSupport(const HITLS_Ctx *ctx, uint32_t *mode);

int32_t HITLS_SetEncryptThenMac(HITLS_Ctx *ctx, bool encryptThenMacType);

int32_t HITLS_GetEncryptThenMac(const HITLS_Ctx *ctx, bool *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_SetClientRenegotiateSupport(HITLS_Ctx *ctx, bool isSupport);

int32_t HITLS_SetLegacyRenegotiateSupport(HITLS_Ctx *ctx, bool isSupport);

int32_t HITLS_SetSessionTicketSupport(HITLS_Ctx *ctx, bool isSupport);

int32_t HITLS_GetSessionTicketSupport(const HITLS_Ctx *ctx, bool *isSupport);

int32_t HITLS_SetDtlsCookieExangeSupport(HITLS_Ctx *ctx, bool isSupport);

int32_t HITLS_GetDtlsCookieExangeSupport(const HITLS_Ctx *ctx, bool *isSupport);

int32_t HITLS_SetFlightTransmitSwitch(HITLS_Ctx *ctx, bool isEnable);

int32_t HITLS_GetFlightTransmitSwitch(const HITLS_Ctx *ctx, bool *isEnable);

int32_t HITLS_SetEmptyRecordsNum(HITLS_Ctx *ctx, uint32_t emptyNum);

int32_t HITLS_SetMaxSendFragment(HITLS_Ctx *ctx, uint16_t maxSendFragment);

int32_t HITLS_GetMaxSendFragment(const HITLS_Ctx *ctx, uint16_t *maxSendFragment);

int32_t HITLS_SetRecInbufferSize(HITLS_Ctx *ctx, uint32_t recInbufferSize);

int32_t HITLS_GetRecInbufferSize(const HITLS_Ctx *ctx, uint32_t *recInbufferSize);

int32_t HITLS_GetEmptyRecordsNum(const HITLS_Ctx *ctx, uint32_t *emptyNum);

int32_t HITLS_SetMaxCertList(HITLS_Ctx *ctx, uint32_t maxSize);

int32_t HITLS_GetMaxCertList(const HITLS_Ctx *ctx, uint32_t *maxSize);

int32_t HITLS_ExportKeyingMaterial(HITLS_Ctx *ctx, uint8_t *out, size_t outLen, const char *label, size_t labelLen,
    const uint8_t *context, size_t contextLen, int32_t useContext);

int32_t HITLS_VerifyClientPostHandshake(HITLS_Ctx *ctx);

int32_t HITLS_SetKeepPeerCertificate(HITLS_Ctx *ctx, bool isKeepPeerCert);

int32_t HITLS_SetRecordSizeLimit(HITLS_Ctx *ctx, uint16_t recordSize);

int32_t HITLS_GetRecordSizeLimit(HITLS_Ctx *ctx, uint16_t *recordSize);

int32_t HITLS_ClientHelloGetLegacyVersion(HITLS_Ctx *ctx, uint16_t *version);

int32_t HITLS_ClientHelloGetRandom(HITLS_Ctx *ctx, uint8_t **out, uint8_t *outlen);

int32_t HITLS_ClientHelloGetSessionID(HITLS_Ctx *ctx, uint8_t **out, uint8_t *outlen);

int32_t HITLS_ClientHelloGetCiphers(HITLS_Ctx *ctx, uint16_t **out, uint16_t *outlen);

int32_t HITLS_ClientHelloGetExtensionsPresent(HITLS_Ctx *ctx, uint16_t **out, uint8_t *outlen);

int32_t HITLS_ClientHelloGetExtension(HITLS_Ctx *ctx, uint16_t type, uint8_t **out, uint32_t *outlen);

int32_t HITLS_DtlsProcessTimeout(HITLS_Ctx *ctx);

int32_t HITLS_DtlsGetTimeout(HITLS_Ctx *ctx, uint64_t *remainTimeOut);

int32_t HITLS_SetMiddleBoxCompat(HITLS_Ctx *ctx, bool isMiddleBox);

int32_t HITLS_GetMiddleBoxCompat(HITLS_Ctx *ctx, bool *isMiddleBox);

int32_t HITLS_GetOutPendingSize(const HITLS_Ctx *ctx, uint32_t *size);

int32_t HITLS_Flush(HITLS_Ctx *ctx);

int32_t HITLS_SetExtendedMasterSecretSupport(HITLS_Ctx *ctx, bool support);

int32_t HITLS_GetExtendedMasterSecretSupport(HITLS_Ctx *ctx, bool *isSupport);

int32_t HITLS_SetExtendedMasterSecretMode(HITLS_Ctx *ctx, int32_t mode);

int32_t HITLS_GetExtendedMasterSecretMode(HITLS_Ctx *ctx, int32_t *mode);

int32_t HITLS_SetResumptionOnRenegoSupport(HITLS_Ctx *ctx, bool support);

int32_t HITLS_GetResumptionOnRenegoSupport(HITLS_Ctx *ctx, bool *isSupport);

int32_t HITLS_GetClientRenegotiateSupport(HITLS_Ctx *ctx, bool *isSupport);
 
#ifdef __cplusplus
}
#endif
 
#endif /* HITLS_H */