hitls_config.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_CONFIG_H
#define HITLS_CONFIG_H
 
#include <stdbool.h>
#include <stdint.h>
#include "hitls_type.h"
#include "hitls_crypt_type.h"
#include "hitls_cert_type.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define HITLS_VERSION_TLCP_DTLCP11 0x0101u

#define HITLS_TLS_ANY_VERSION 0x03ffu

#define HITLS_VERSION_SSL30 0x0300u

#define HITLS_VERSION_TLS10 0x0301u

#define HITLS_VERSION_TLS11 0x0302u

#define HITLS_VERSION_TLS12 0x0303u

#define HITLS_VERSION_TLS13 0x0304u

#define HITLS_VERSION_TLS_MAJOR 0x03u

#define HITLS_DTLS_ANY_VERSION 0xfe00u

#define HITLS_VERSION_DTLS12 0xfefdu

#define HITLS_CFG_MAX_SIZE 1024

#define TLS13_CIPHERSUITES_MAX_LEN 80

typedef enum {
    HITLS_RSA_WITH_AES_128_CBC_SHA = 0x002F,
    HITLS_DHE_DSS_WITH_AES_128_CBC_SHA = 0x0032,
    HITLS_DHE_RSA_WITH_AES_128_CBC_SHA = 0x0033,
    HITLS_DH_ANON_WITH_AES_128_CBC_SHA = 0x0034,
    HITLS_RSA_WITH_AES_256_CBC_SHA = 0x0035,
    HITLS_DHE_DSS_WITH_AES_256_CBC_SHA = 0x0038,
    HITLS_DHE_RSA_WITH_AES_256_CBC_SHA = 0x0039,
    HITLS_DH_ANON_WITH_AES_256_CBC_SHA = 0x003A,
    HITLS_RSA_WITH_AES_128_CBC_SHA256 = 0x003C,
    HITLS_RSA_WITH_AES_256_CBC_SHA256 = 0x003D,
    HITLS_DHE_DSS_WITH_AES_128_CBC_SHA256 = 0x0040,
    HITLS_DHE_RSA_WITH_AES_128_CBC_SHA256 = 0x0067,
    HITLS_DHE_DSS_WITH_AES_256_CBC_SHA256 = 0x006A,
    HITLS_DHE_RSA_WITH_AES_256_CBC_SHA256 = 0x006B,
    HITLS_DH_ANON_WITH_AES_128_CBC_SHA256 = 0x006C,
    HITLS_DH_ANON_WITH_AES_256_CBC_SHA256 = 0x006D,
    HITLS_PSK_WITH_AES_128_CBC_SHA = 0x008C,
    HITLS_PSK_WITH_AES_256_CBC_SHA = 0x008D,
    HITLS_DHE_PSK_WITH_AES_128_CBC_SHA = 0x0090,
    HITLS_DHE_PSK_WITH_AES_256_CBC_SHA = 0x0091,
    HITLS_RSA_PSK_WITH_AES_128_CBC_SHA = 0x0094,
    HITLS_RSA_PSK_WITH_AES_256_CBC_SHA = 0x0095,
    HITLS_RSA_WITH_AES_128_GCM_SHA256 = 0x009C,
    HITLS_RSA_WITH_AES_256_GCM_SHA384 = 0x009D,
    HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256 = 0x009E,
    HITLS_DHE_RSA_WITH_AES_256_GCM_SHA384 = 0x009F,
    HITLS_DHE_DSS_WITH_AES_128_GCM_SHA256 = 0x00A2,
    HITLS_DHE_DSS_WITH_AES_256_GCM_SHA384 = 0x00A3,
    HITLS_DH_ANON_WITH_AES_128_GCM_SHA256 = 0x00A6,
    HITLS_DH_ANON_WITH_AES_256_GCM_SHA384 = 0x00A7,
    HITLS_PSK_WITH_AES_128_GCM_SHA256 = 0x00A8,
    HITLS_PSK_WITH_AES_256_GCM_SHA384 = 0x00A9,
    HITLS_DHE_PSK_WITH_AES_128_GCM_SHA256 = 0x00AA,
    HITLS_DHE_PSK_WITH_AES_256_GCM_SHA384 = 0x00AB,
    HITLS_RSA_PSK_WITH_AES_128_GCM_SHA256 = 0x00AC,
    HITLS_RSA_PSK_WITH_AES_256_GCM_SHA384 = 0x00AD,
    HITLS_PSK_WITH_AES_128_CBC_SHA256 = 0x00AE,
    HITLS_PSK_WITH_AES_256_CBC_SHA384 = 0x00AF,
    HITLS_DHE_PSK_WITH_AES_128_CBC_SHA256 = 0x00B2,
    HITLS_DHE_PSK_WITH_AES_256_CBC_SHA384 = 0x00B3,
    HITLS_RSA_PSK_WITH_AES_128_CBC_SHA256 = 0x00B6,
    HITLS_RSA_PSK_WITH_AES_256_CBC_SHA384 = 0x00B7,
    HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = 0xC009,
    HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = 0xC00A,
    HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA = 0xC013,
    HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014,
    HITLS_ECDH_ANON_WITH_AES_128_CBC_SHA = 0xC018,
    HITLS_ECDH_ANON_WITH_AES_256_CBC_SHA = 0xC019,
    HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 0xC023,
    HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = 0xC024,
    HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 0xC027,
    HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = 0xC028,
    HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = 0xC02B,
    HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = 0xC02C,
    HITLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = 0xC02F,
    HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = 0xC030,
    HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA = 0xC035,
    HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA = 0xC036,
    HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 = 0xC037,
    HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 = 0xC038,
    HITLS_RSA_WITH_AES_128_CCM = 0xC09C,
    HITLS_RSA_WITH_AES_256_CCM = 0xC09D,
    HITLS_DHE_RSA_WITH_AES_128_CCM = 0xC09E,
    HITLS_DHE_RSA_WITH_AES_256_CCM = 0xC09F,
    HITLS_RSA_WITH_AES_128_CCM_8 = 0xC0A0,
    HITLS_RSA_WITH_AES_256_CCM_8 = 0xC0A1,
    HITLS_PSK_WITH_AES_256_CCM = 0xC0A5,
    HITLS_DHE_PSK_WITH_AES_128_CCM = 0xC0A6,
    HITLS_DHE_PSK_WITH_AES_256_CCM = 0xC0A7,
    HITLS_ECDHE_ECDSA_WITH_AES_128_CCM = 0xC0AC,
    HITLS_ECDHE_ECDSA_WITH_AES_256_CCM = 0xC0AD,
    HITLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA8,
    HITLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA9,
    HITLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCAA,
    HITLS_PSK_WITH_CHACHA20_POLY1305_SHA256 = 0xCCAB,
    HITLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 = 0xCCAC,
    HITLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256 = 0xCCAD,
    HITLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256 = 0xCCAE,
    HITLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256 = 0xD001,
    HITLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384 = 0xD002,
    HITLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256 = 0xD005,
 
    /* TLS1.3 cipher suite */
    HITLS_AES_128_GCM_SHA256 = 0x1301,
    HITLS_AES_256_GCM_SHA384 = 0x1302,
    HITLS_CHACHA20_POLY1305_SHA256 = 0x1303,
    HITLS_AES_128_CCM_SHA256 = 0x1304,
    HITLS_AES_128_CCM_8_SHA256 = 0x1305,
    /* RFC 8998 */
    HITLS_SM4_GCM_SM3 = 0x00C6,
    HITLS_SM4_CCM_SM3 = 0x00C7,
    /* TLCP 1.1 cipher suite */
    HITLS_ECDHE_SM4_CBC_SM3 = 0xE011,
    HITLS_ECC_SM4_CBC_SM3 = 0xE013,
    HITLS_ECDHE_SM4_GCM_SM3 = 0xE051,
    HITLS_ECC_SM4_GCM_SM3 = 0xE053,
} HITLS_CipherSuite;

HITLS_Config *HITLS_CFG_NewDTLS12Config(void);

HITLS_Config *HITLS_CFG_ProviderNewDTLS12Config(HITLS_Lib_Ctx *libCtx, const char *attrName);

HITLS_Config *HITLS_CFG_NewTLCPConfig(void);

HITLS_Config *HITLS_CFG_ProviderNewTLCPConfig(HITLS_Lib_Ctx *libCtx, const char *attrName);

HITLS_Config *HITLS_CFG_NewDTLCPConfig(void);

HITLS_Config *HITLS_CFG_ProviderNewDTLCPConfig(HITLS_Lib_Ctx *libCtx, const char *attrName);

HITLS_Config *HITLS_CFG_NewTLS12Config(void);

HITLS_Config *HITLS_CFG_ProviderNewTLS12Config(HITLS_Lib_Ctx *libCtx, const char *attrName);

HITLS_Config *HITLS_CFG_NewTLS13Config(void);

HITLS_Config *HITLS_CFG_ProviderNewTLS13Config(HITLS_Lib_Ctx *libCtx, const char *attrName);

HITLS_Config *HITLS_CFG_NewTLSConfig(void);

HITLS_Config *HITLS_CFG_ProviderNewTLSConfig(HITLS_Lib_Ctx *libCtx, const char *attrName);

HITLS_Config *HITLS_CFG_NewDTLSConfig(void);

HITLS_Config *HITLS_CFG_ProviderNewDTLSConfig(HITLS_Lib_Ctx *libCtx, const char *attrName);

void HITLS_CFG_FreeConfig(HITLS_Config *config);

int32_t HITLS_CFG_UpRef(HITLS_Config *config);

int32_t HITLS_CFG_SetVersion(HITLS_Config *config, uint16_t minVersion, uint16_t maxVersion);

int32_t HITLS_CFG_SetVersionForbid(HITLS_Config *config, uint32_t noVersion);

int32_t HITLS_CFG_SetRenegotiationSupport(HITLS_Config *config, bool support);

int32_t HITLS_CFG_SetClientRenegotiateSupport(HITLS_Config *config, bool support);

int32_t HITLS_CFG_SetLegacyRenegotiateSupport(HITLS_Config *config, bool support);

int32_t HITLS_CFG_SetResumptionOnRenegoSupport(HITLS_Config *config, bool support);

int32_t HITLS_CFG_SetClientVerifySupport(HITLS_Config *config, bool support);

int32_t HITLS_CFG_SetNoClientCertSupport(HITLS_Config *config, bool support);

int32_t HITLS_CFG_SetExtendedMasterSecretSupport(HITLS_Config *config, bool support);

int32_t HITLS_CFG_SetDhAutoSupport(HITLS_Config *config, bool support);

int32_t HITLS_CFG_SetTmpDh(HITLS_Config *config, HITLS_CRYPT_Key *dhPkey);

int32_t HITLS_CFG_GetRenegotiationSupport(const HITLS_Config *config, bool *isSupport);
 

int32_t HITLS_CFG_GetClientVerifySupport(HITLS_Config *config, bool *isSupport);

int32_t HITLS_CFG_GetNoClientCertSupport(HITLS_Config *config, bool *isSupport);

int32_t HITLS_CFG_GetExtendedMasterSecretSupport(HITLS_Config *config, bool *isSupport);

int32_t HITLS_CFG_SetExtendedMasterSecretMode(HITLS_Config *config, int32_t mode);

int32_t HITLS_CFG_GetExtendedMasterSecretMode(HITLS_Config *config, int32_t *mode);

int32_t HITLS_CFG_GetDhAutoSupport(HITLS_Config *config, bool *isSupport);

int32_t HITLS_CFG_SetPostHandshakeAuthSupport(HITLS_Config *config, bool support);

int32_t HITLS_CFG_GetPostHandshakeAuthSupport(HITLS_Config *config, bool *isSupport);

int32_t HITLS_CFG_SetVerifyNoneSupport(HITLS_Config *config, bool support);

int32_t HITLS_CFG_GetVerifyNoneSupport(HITLS_Config *config, bool *isSupport);

int32_t HITLS_CFG_SetClientOnceVerifySupport(HITLS_Config *config, bool support);

int32_t HITLS_CFG_GetClientOnceVerifySupport(HITLS_Config *config, bool *isSupport);

int32_t HITLS_CFG_SetCipherSuites(HITLS_Config *config, const uint16_t *cipherSuites, uint32_t cipherSuitesSize);

int32_t HITLS_CFG_GetCipherSuites(HITLS_Config *config, uint16_t *data, uint32_t dataLen, uint32_t *cipherSuitesSize);

int32_t HITLS_CFG_ClearTLS13CipherSuites(HITLS_Config *config);

int32_t HITLS_CFG_SetEcPointFormats(HITLS_Config *config, const uint8_t *pointFormats, uint32_t pointFormatsSize);

int32_t HITLS_CFG_SetGroups(HITLS_Config *config, const uint16_t *groups, uint32_t groupsSize);

int32_t HITLS_CFG_SetGroupList(HITLS_Config *config, const char *groupNames, uint32_t groupNamesLen);

int32_t HITLS_CFG_SetSignature(HITLS_Config *config, const uint16_t *signAlgs, uint16_t signAlgsSize);

int32_t HITLS_CFG_AddCAIndication(HITLS_Config *config, HITLS_TrustedCAType caType, const uint8_t *data, uint32_t len);

HITLS_TrustedCAList *HITLS_CFG_GetCAList(const HITLS_Config *config);

int32_t HITLS_CFG_SetCAList(HITLS_Config *config, HITLS_TrustedCAList *list);

void HITLS_CFG_ClearCAList(HITLS_Config *config);

int32_t HITLS_CFG_SetKeyExchMode(HITLS_Config *config, uint32_t mode);

uint32_t HITLS_CFG_GetKeyExchMode(HITLS_Config *config);
 
/* If the ClientHello callback is successfully executed, the handshake continues */
#define HITLS_CLIENT_HELLO_SUCCESS 1
/* The  ClientHello callback fails. Send an alert message and terminate the handshake */
#define HITLS_CLIENT_HELLO_FAILED 0
/* The ClientHello callback is suspended. The handshake process is suspended and the callback is called again */
#define HITLS_CLIENT_HELLO_RETRY (-1)

typedef int32_t (*HITLS_ClientHelloCb)(HITLS_Ctx *ctx, int32_t *alert, void *arg);

int32_t HITLS_CFG_SetClientHelloCb(HITLS_Config *config, HITLS_ClientHelloCb callback, void *arg);

typedef uint32_t (*HITLS_DtlsTimerCb)(HITLS_Ctx *ctx, uint32_t us);

int32_t HITLS_CFG_SetDtlsTimerCb(HITLS_Config *config, HITLS_DtlsTimerCb callback);

int32_t HITLS_CFG_GetMinVersion(const HITLS_Config *config, uint16_t *minVersion);

int32_t HITLS_CFG_GetMaxVersion(const HITLS_Config *config, uint16_t *maxVersion);

int32_t HITLS_CFG_GetCipherId(const HITLS_Cipher *cipher, HITLS_CipherAlgo *cipherAlg);

int32_t HITLS_CFG_GetHashId(const HITLS_Cipher *cipher, HITLS_HashAlgo *hashAlg);

int32_t HITLS_CFG_GetMacId(const HITLS_Cipher *cipher, HITLS_MacAlgo *macAlg);

int32_t HITLS_CFG_GetAuthId(const HITLS_Cipher *cipher, HITLS_AuthAlgo *authAlg);

int32_t HITLS_CFG_GetKeyExchId(const HITLS_Cipher *cipher, HITLS_KeyExchAlgo *kxAlg);

const uint8_t* HITLS_CFG_GetCipherSuiteName(const HITLS_Cipher *cipher);

const uint8_t* HITLS_CFG_GetCipherSuiteStdName(const HITLS_Cipher *cipher);

const HITLS_Cipher* HITLS_CFG_GetCipherSuiteByStdName(const uint8_t* stdName);

int32_t HITLS_CFG_GetDescription(const HITLS_Cipher *cipher, uint8_t *buf, int32_t len);

int32_t HITLS_CIPHER_IsAead(const HITLS_Cipher *cipher, bool *isAead);

int32_t HITLS_CFG_GetCipherVersion(const HITLS_Cipher *cipher, int32_t *version);

const HITLS_Cipher *HITLS_CFG_GetCipherByID(uint16_t cipherSuite);

int32_t HITLS_CFG_GetCipherSuite(const HITLS_Cipher *cipher, uint16_t *cipherSuite);

int32_t HITLS_CFG_GetVersionSupport(const HITLS_Config *config, uint32_t *version);

int32_t HITLS_CFG_SetVersionSupport(HITLS_Config *config, uint32_t version);

int32_t HITLS_CFG_SetNeedCheckPmsVersion(HITLS_Config *config, bool needCheck);

int32_t HITLS_CFG_SetModeSupport(HITLS_Config *config, uint32_t mode);

int32_t HITLS_CFG_ClearModeSupport(HITLS_Config *config, uint32_t mode);

int32_t HITLS_CFG_GetModeSupport(const HITLS_Config *config, uint32_t *mode);

int32_t HITLS_CFG_SetQuietShutdown(HITLS_Config *config, int32_t mode);

int32_t HITLS_CFG_GetQuietShutdown(const HITLS_Config *config, int32_t *mode);

int32_t HITLS_CFG_SetDtlsPostHsTimeoutVal(HITLS_Config *config, uint32_t timeoutVal);

int32_t HITLS_CFG_SetEncryptThenMac(HITLS_Config *config, bool encryptThenMacType);

int32_t HITLS_CFG_GetEncryptThenMac(const HITLS_Config *config, bool *encryptThenMacType);

void *HITLS_CFG_GetConfigUserData(const HITLS_Config *config);

int32_t HITLS_CFG_SetConfigUserData(HITLS_Config *config, void *userData);

typedef void (*HITLS_ConfigUserDataFreeCb)(void *);

int32_t HITLS_CFG_SetConfigUserDataFreeCb(HITLS_Config *config, HITLS_ConfigUserDataFreeCb callback);

int32_t HITLS_CFG_IsDtls(const HITLS_Config *config, bool *isDtls);

int32_t HITLS_CFG_SetCipherServerPreference(HITLS_Config *config, bool isSupport);

int32_t HITLS_CFG_GetCipherServerPreference(const HITLS_Config *config, bool *isSupport);

int32_t HITLS_CFG_SetFlightTransmitSwitch(HITLS_Config *config, bool isEnable);

int32_t HITLS_CFG_GetFlightTransmitSwitch(const HITLS_Config *config, bool *isEnable);

int32_t HITLS_CFG_SetDtlsCookieExchangeSupport(HITLS_Config *config, bool isSupport);

int32_t HITLS_CFG_GetDtlsCookieExchangeSupport(const HITLS_Config *config, bool *isSupport);

int32_t HITLS_CFG_SetEmptyRecordsNum(HITLS_Config *config, uint32_t emptyNum);

int32_t HITLS_CFG_GetEmptyRecordsNum(const HITLS_Config *config, uint32_t *emptyNum);

int32_t HITLS_CFG_SetMaxSendFragment(HITLS_Config *config, uint16_t maxSendFragment);

int32_t HITLS_CFG_GetMaxSendFragment(const HITLS_Config *config, uint16_t *maxSendFragment);

int32_t HITLS_CFG_SetRecInbufferSize(HITLS_Config *config, uint32_t recInbufferSize);

int32_t HITLS_CFG_GetRecInbufferSize(const HITLS_Config *config, uint32_t *recInbufferSize);

int32_t HITLS_CFG_SetMaxCertList(HITLS_Config *config, uint32_t maxSize);

int32_t HITLS_CFG_GetMaxCertList(const HITLS_Config *config, uint32_t *maxSize);

typedef HITLS_CRYPT_Key *(*HITLS_DhTmpCb)(HITLS_Ctx *ctx, int32_t isExport, uint32_t keyLen);

int32_t HITLS_CFG_SetTmpDhCb(HITLS_Config *config, HITLS_DhTmpCb callback);

typedef uint64_t (*HITLS_RecordPaddingCb)(HITLS_Ctx *ctx, int32_t type, uint64_t length, void *arg);

int32_t HITLS_CFG_SetRecordPaddingCb(HITLS_Config *config, HITLS_RecordPaddingCb callback);

HITLS_RecordPaddingCb HITLS_CFG_GetRecordPaddingCb(HITLS_Config *config);

int32_t HITLS_CFG_SetRecordPaddingCbArg(HITLS_Config *config, void *arg);

void *HITLS_CFG_GetRecordPaddingCbArg(HITLS_Config *config);

int32_t HITLS_CFG_SetCheckKeyUsage(HITLS_Config *config, bool isCheck);

int32_t HITLS_CFG_SetReadAhead(HITLS_Config *config, int32_t onOff);

int32_t HITLS_CFG_GetReadAhead(HITLS_Config *config, int32_t *onOff);

int32_t HITLS_CFG_SetKeepPeerCertificate(HITLS_Config *config, bool isKeepPeerCert);

int32_t HITLS_CFG_SetRecordSizeLimit(HITLS_Config *config, uint16_t recordSize);

int32_t HITLS_CFG_GetRecordSizeLimit(HITLS_Config *config, uint16_t *recordSize);

int32_t HITLS_CFG_SetMiddleBoxCompat(HITLS_Config *config, bool isMiddleBox);

int32_t HITLS_CFG_GetMiddleBoxCompat(HITLS_Config *config, bool *isMiddleBox);

int32_t HITLS_CFG_SetEndPoint(HITLS_Config *config, bool isClient);

int32_t HITLS_CFG_GetResumptionOnRenegoSupport(HITLS_Config *config, bool *isSupport);

int32_t HITLS_CFG_GetClientRenegotiateSupport(HITLS_Config *config, bool *isSupport);

int32_t HITLS_CFG_EnableTls13SM(HITLS_Config *config, bool isOnlySupportSM);
#ifdef __cplusplus
}
#endif
 
#endif /* HITLS_CONFIG_H */