hitls_config.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_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_TLCP11 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,
    /* TLCP 1.1 cipher suite */
    HITLS_ECDHE_SM4_CBC_SM3 = 0xE011,
    HITLS_ECC_SM4_CBC_SM3 = 0xE013,
} HITLS_CipherSuite;
 
HITLS_Config *HITLS_CFG_NewDTLS12Config(void);
 
#ifndef HITLS_NO_TLCP11
HITLS_Config *HITLS_CFG_NewTLCPConfig(void);
#endif
 
HITLS_Config *HITLS_CFG_NewTLS12Config(void);
 
HITLS_Config *HITLS_CFG_NewTLS13Config(void);
 
HITLS_Config *HITLS_CFG_NewTLSConfig(void);
 
HITLS_Config *HITLS_CFG_NewDTLSConfig(void);
 
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_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_SetExtenedMasterSecretSupport(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, uint8_t *isSupport);
 
int32_t HITLS_CFG_GetClientVerifySupport(HITLS_Config *config, uint8_t *isSupport);
 
int32_t HITLS_CFG_GetNoClientCertSupport(HITLS_Config *config, uint8_t *isSupport);
 
int32_t HITLS_CFG_GetExtenedMasterSecretSupport(HITLS_Config *config, uint8_t *isSupport);
 
int32_t HITLS_CFG_GetDhAutoSupport(HITLS_Config *config, uint8_t *isSupport);
 
int32_t HITLS_CFG_SetPostHandshakeAuthSupport(HITLS_Config *config, bool support);
 
int32_t HITLS_CFG_GetPostHandshakeAuthSupport(HITLS_Config *config, uint8_t *isSupport);
 
int32_t HITLS_CFG_SetVerifyNoneSupport(HITLS_Config *config, bool support);
 
int32_t HITLS_CFG_GetVerifyNoneSupport(HITLS_Config *config, uint8_t *isSupport);
 
int32_t HITLS_CFG_SetClientOnceVerifySupport(HITLS_Config *config, bool support);
 
int32_t HITLS_CFG_GetClientOnceVerifySupport(HITLS_Config *config, uint8_t *isSupport);
 
int32_t HITLS_CFG_SetCipherSuites(HITLS_Config *config, const uint16_t *cipherSuites, 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_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_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_CONTINUE_HANDHSAKE 1
/* The  ClientHello callback fails. Send an alert message and terminate the handshake */
#define HITLS_ALERT_HANDSHAKE 0
 
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 int32_t (*HITLS_NoSecRenegotiationCb)(HITLS_Ctx *ctx);
 
int32_t HITLS_CFG_SetNoSecRenegotiationCb(HITLS_Config *config, HITLS_NoSecRenegotiationCb 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);
 
int32_t HITLS_CFG_GetDescription(const HITLS_Cipher *cipher, uint8_t *buf, int32_t len);
 
int32_t HITLS_CIPHER_IsAead(const HITLS_Cipher *cipher, uint8_t *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_SetQuietShutdown(HITLS_Config *config, int32_t mode);
 
int32_t HITLS_CFG_GetQuietShutdown(const HITLS_Config *config, int32_t *mode);
 
int32_t HITLS_CFG_SetEncryptThenMac(HITLS_Config *config, uint32_t encryptThenMacType);
 
int32_t HITLS_CFG_GetEncryptThenMac(const HITLS_Config *config, uint32_t *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, uint8_t *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, uint8_t isEnable);
 
int32_t HITLS_CFG_GetFlightTransmitSwitch(const HITLS_Config *config, uint8_t *isEnable);
 
int32_t HITLS_CFG_GetMiniaturizationSwitch(const HITLS_Config *config, uint8_t *isEnable);
 
int32_t HITLS_CFG_SetMaxCertList(HITLS_Config *config, uint32_t maxSize);
 
int32_t HITLS_CFG_GetMaxCertList(const HITLS_Config *config, uint32_t *maxSize);
 
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_SetCloseCheckKeyUsage(HITLS_Config *config, bool isClose);
 
#ifdef __cplusplus
}
#endif
 
#endif /* HITLS_CONFIG_H */