code stringlengths 1 1.05M | repo_name stringlengths 6 83 | path stringlengths 3 242 | language stringclasses 222 values | license stringclasses 20 values | size int64 1 1.05M |
|---|---|---|---|---|---|
/*
* 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.
*/
#include "hitls_build.h"
#if defined(HITLS_TLS_CALLBACK_CERT) || defined(HITLS_TLS_FEATURE_PROVIDER)
#include <stdint.h>
#include <string.h>
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "hitls_cert_type.h"
#include "hitls_type.h"
#include "hitls_pki_x509.h"
#include "hitls_pki_crl.h"
#include "hitls_cert_local.h"
#include "hitls_error.h"
#include "hitls_x509_adapt.h"
HITLS_CERT_Store *HITLS_X509_Adapt_StoreNew(void)
{
return (HITLS_CERT_Store *)HITLS_X509_StoreCtxNew();
}
HITLS_CERT_Store *HITLS_X509_Adapt_StoreDup(HITLS_CERT_Store *store)
{
int references = 0;
int32_t ret = HITLS_X509_StoreCtxCtrl((HITLS_X509_StoreCtx *)store, HITLS_X509_STORECTX_REF_UP, &references,
sizeof(int));
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return NULL;
}
return store;
}
void HITLS_X509_Adapt_StoreFree(HITLS_CERT_Store *store)
{
HITLS_X509_StoreCtxFree(store);
}
int32_t HITLS_X509_Adapt_StoreCtrl(HITLS_Config *config, HITLS_CERT_Store *store, HITLS_CERT_CtrlCmd cmd,
void *input, void *output)
{
(void)config;
(void)output;
int32_t value1 = 0;
uint64_t value2 = 0;
int32_t ret = 0;
switch (cmd) {
case CERT_STORE_CTRL_SET_VERIFY_DEPTH:
if (*(int64_t *)input > INT32_MAX) {
return HITLS_CERT_SELF_ADAPT_ERR;
}
value1 = *(int64_t *)input;
return HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_PARAM_DEPTH, &value1, sizeof(int32_t));
case CERT_STORE_CTRL_GET_VERIFY_DEPTH:
return HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_GET_PARAM_DEPTH, output, sizeof(int32_t));
case CERT_STORE_CTRL_SET_VERIFY_FLAGS:
if (*(int64_t *)input > UINT32_MAX || *(int64_t *)input < 0) {
return HITLS_CERT_SELF_ADAPT_ERR;
}
return HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_PARAM_FLAGS, (int64_t *)input,
sizeof(uint64_t));
case CERT_STORE_CTRL_GET_VERIFY_FLAGS:
ret = HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_GET_PARAM_FLAGS, &value2, sizeof(uint64_t));
*(uint32_t *)output = (uint32_t)value2;
return ret;
case CERT_STORE_CTRL_ADD_CERT_LIST:
return HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SHALLOW_COPY_SET_CA, input,
sizeof(HITLS_X509_Cert));
case CERT_STORE_CTRL_ADD_CRL_LIST: {
/* Input is a HITLS_CERT_CRLList (BSL_LIST), need to iterate and add each CRL */
HITLS_CERT_CRLList *crlList = (HITLS_CERT_CRLList *)input;
if (crlList == NULL) {
return HITLS_CERT_SELF_ADAPT_ERR;
}
HITLS_X509_Crl *tempCrl = (HITLS_X509_Crl *)BSL_LIST_GET_FIRST(crlList);
while (tempCrl != NULL) {
ret = HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_CRL, tempCrl, 0);
if (ret != CRYPT_SUCCESS) {
return ret;
}
tempCrl = (HITLS_X509_Crl *)BSL_LIST_GET_NEXT(crlList);
}
int64_t setFlag = HITLS_X509_VFY_FLAG_CRL_ALL;
return HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_SET_PARAM_FLAGS, &setFlag, sizeof(int64_t));
}
case CERT_STORE_CTRL_CLEAR_CRL_LIST:
return HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_CLEAR_CRL, NULL, 0);
case CERT_STORE_CTRL_ADD_CA_PATH:
return HITLS_X509_StoreCtxCtrl(store, HITLS_X509_STORECTX_ADD_CA_PATH, input, strlen(input));
default:
return HITLS_CERT_SELF_ADAPT_ERR;
}
}
#endif /* defined(HITLS_TLS_CALLBACK_CERT) || defined(HITLS_TLS_FEATURE_PROVIDER) */
| 2302_82127028/openHiTLS-examples_1508 | tls/cert/hitls_x509_adapt/hitls_x509_cert_store.c | C | unknown | 4,302 |
/*
* 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.
*/
#include <stdint.h>
#include <string.h>
#include "hitls_build.h"
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "hitls_error.h"
#include "hitls_cert_type.h"
#include "bsl_uio.h"
#include "bsl_sal.h"
#include "hitls_pki_crl.h"
#include "hitls_pki_errno.h"
#include "hitls_x509_adapt.h"
static int32_t LoadCrlFromFile(const char *path, HITLS_ParseFormat format, HITLS_X509_List **crlList)
{
return HITLS_X509_CrlParseBundleFile(format, path, crlList);
}
static int32_t LoadCrlFromBuffer(const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format, HITLS_X509_List **crlList)
{
BSL_Buffer buffer = {(uint8_t *)(uintptr_t)buf, bufLen};
return HITLS_X509_CrlParseBundleBuff(format, &buffer, crlList);
}
HITLS_CERT_CRLList *HITLS_X509_Adapt_CrlParse(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, HITLS_ParseFormat format)
{
(void)config; /* config parameter not used for CRL parsing */
if (buf == NULL || len == 0) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return NULL;
}
HITLS_X509_List *crlList = NULL;
int32_t ret;
if (type == TLS_PARSE_TYPE_FILE) {
ret = LoadCrlFromFile((const char *)buf, format, &crlList);
} else if (type == TLS_PARSE_TYPE_BUFF) {
ret = LoadCrlFromBuffer(buf, len, format, &crlList);
} else {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
return NULL;
}
if (ret != HITLS_PKI_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16572, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CRL parse failed, ret = %d", ret, 0, 0, 0);
return NULL;
}
return (HITLS_CERT_CRLList *)crlList;
}
void HITLS_X509_Adapt_CrlFree(HITLS_CERT_CRLList *crlList)
{
if (crlList != NULL) {
HITLS_X509_List *list = (HITLS_X509_List *)crlList;
BSL_LIST_FREE(list, (BSL_LIST_PFUNC_FREE)HITLS_X509_CrlFree);
}
} | 2302_82127028/openHiTLS-examples_1508 | tls/cert/hitls_x509_adapt/hitls_x509_crl_magr.c | C | unknown | 2,532 |
/*
* 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.
*/
#include "hitls_build.h"
#if defined(HITLS_TLS_CALLBACK_CERT) || defined(HITLS_TLS_FEATURE_PROVIDER)
#include <stdio.h>
#include <string.h>
#include "crypt_types.h"
#include "bsl_err_internal.h"
#include "crypt_errno.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "hitls_cert_type.h"
#include "hitls_crypt_type.h"
#include "crypt_algid.h"
#include "crypt_eal_pkey.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
#include "eal_md_local.h"
#include "hitls_pki_cert.h"
#include "tls.h"
#ifdef HITLS_TLS_FEATURE_PROVIDER
static int32_t SetMdAttr(CRYPT_EAL_PkeyCtx *ctx, const char *attrName)
{
CRYPT_PKEY_AlgId id = CRYPT_EAL_PkeyGetId(ctx);
bool supportUnloadMd = id == CRYPT_PKEY_RSA || id == CRYPT_PKEY_ECDSA || id == CRYPT_PKEY_DSA;
if (attrName == NULL || strlen(attrName) == 0 || supportUnloadMd == false) {
return CRYPT_SUCCESS;
}
BSL_Param param[] = {
{.key = CRYPT_PARAM_MD_ATTR, .valueType = BSL_PARAM_TYPE_UTF8_STR,
.value = (void *)(uintptr_t)attrName, .valueLen = strlen(attrName), .useLen = 0},
BSL_PARAM_END
};
return CRYPT_EAL_PkeySetParaEx(ctx, param);
}
#endif
static int32_t SetPkeySignParam(CRYPT_EAL_PkeyCtx *ctx, HITLS_SignAlgo signAlgo, int32_t mdAlgId, const char *attrName)
{
(void)attrName;
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = SetMdAttr(ctx, attrName);
if (ret != CRYPT_SUCCESS) {
return ret;
}
#endif
if (signAlgo == HITLS_SIGN_RSA_PKCS1_V15) {
int32_t pad = mdAlgId;
return CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_RSA_EMSA_PKCSV15, &pad, sizeof(pad));
} else if (signAlgo == HITLS_SIGN_RSA_PSS) {
int32_t saltLen = CRYPT_RSA_SALTLEN_TYPE_HASHLEN;
BSL_Param pssParam[4] = {
{CRYPT_PARAM_RSA_MD_ID, BSL_PARAM_TYPE_INT32, &mdAlgId, sizeof(mdAlgId), 0},
{CRYPT_PARAM_RSA_MGF1_ID, BSL_PARAM_TYPE_INT32, &mdAlgId, sizeof(mdAlgId), 0},
{CRYPT_PARAM_RSA_SALTLEN, BSL_PARAM_TYPE_INT32, &saltLen, sizeof(saltLen), 0},
BSL_PARAM_END};
return CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_RSA_EMSA_PSS, pssParam, 0);
} else if (signAlgo == HITLS_SIGN_SM2) {
/* The default user id as specified in GM/T 0009-2012 */
char sm2DefaultUserid[] = "1234567812345678";
return CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_SM2_USER_ID, sm2DefaultUserid, strlen(sm2DefaultUserid));
}
return HITLS_SUCCESS;
}
int32_t HITLS_X509_Adapt_CreateSign(HITLS_Ctx *ctx, HITLS_CERT_Key *key, HITLS_SignAlgo signAlgo,
HITLS_HashAlgo hashAlgo, const uint8_t *data, uint32_t dataLen, uint8_t *sign, uint32_t *signLen)
{
(void)ctx;
if (SetPkeySignParam(key, signAlgo, hashAlgo, ATTRIBUTE_FROM_CTX(ctx)) != HITLS_SUCCESS) {
return HITLS_CERT_SELF_ADAPT_ERR;
}
return CRYPT_EAL_PkeySign(key, (CRYPT_MD_AlgId)hashAlgo, data, dataLen, sign, signLen);
}
int32_t HITLS_X509_Adapt_VerifySign(HITLS_Ctx *ctx, HITLS_CERT_Key *key, HITLS_SignAlgo signAlgo,
HITLS_HashAlgo hashAlgo, const uint8_t *data, uint32_t dataLen, const uint8_t *sign, uint32_t signLen)
{
(void)ctx;
if (SetPkeySignParam(key, signAlgo, hashAlgo, ATTRIBUTE_FROM_CTX(ctx)) != HITLS_SUCCESS) {
return HITLS_CERT_SELF_ADAPT_ERR;
}
return CRYPT_EAL_PkeyVerify(key, (CRYPT_MD_AlgId)hashAlgo, data, dataLen, sign, signLen);
}
#if defined(HITLS_TLS_SUITE_KX_RSA) || defined(HITLS_TLS_PROTO_TLCP11)
static int32_t CertSetRsaEncryptionScheme(CRYPT_EAL_PkeyCtx *ctx)
{
int32_t pad = CRYPT_MD_SHA256;
return CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_RSA_RSAES_PKCSV15, &pad, sizeof(pad));
}
/* only support rsa pkcs1.5 */
int32_t HITLS_X509_Adapt_Encrypt(HITLS_Ctx *ctx, HITLS_CERT_Key *key, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
(void)ctx;
#ifdef HITLS_TLS_FEATURE_PROVIDER
if (SetMdAttr(key, ATTRIBUTE_FROM_CTX(ctx)) != HITLS_SUCCESS) {
return HITLS_CERT_SELF_ADAPT_ERR;
}
#endif
if (CRYPT_EAL_PkeyGetId(key) == CRYPT_PKEY_RSA && CertSetRsaEncryptionScheme(key) != HITLS_SUCCESS) {
return HITLS_CERT_SELF_ADAPT_ERR;
}
return CRYPT_EAL_PkeyEncrypt(key, in, inLen, out, outLen);
}
int32_t HITLS_X509_Adapt_Decrypt(HITLS_Ctx *ctx, HITLS_CERT_Key *key, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
(void)ctx;
#ifdef HITLS_TLS_FEATURE_PROVIDER
if (SetMdAttr(key, ATTRIBUTE_FROM_CTX(ctx)) != HITLS_SUCCESS) {
return HITLS_CERT_SELF_ADAPT_ERR;
}
#endif
if (CRYPT_EAL_PkeyGetId(key) == CRYPT_PKEY_RSA && CertSetRsaEncryptionScheme(key) != HITLS_SUCCESS) {
return HITLS_CERT_SELF_ADAPT_ERR;
}
return CRYPT_EAL_PkeyDecrypt(key, in, inLen, out, outLen);
}
#endif
int32_t HITLS_X509_Adapt_CheckPrivateKey(const HITLS_Config *config, HITLS_CERT_X509 *cert, HITLS_CERT_Key *key)
{
(void)config;
CRYPT_EAL_PkeyCtx *ealPubKey = NULL;
CRYPT_EAL_PkeyCtx *ealPrivKey = (CRYPT_EAL_PkeyCtx *)key;
int32_t ret = HITLS_X509_CertCtrl(cert, HITLS_X509_GET_PUBKEY, &ealPubKey, 0);
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = CRYPT_EAL_PkeyPairCheck(ealPubKey, ealPrivKey);
CRYPT_EAL_PkeyFreeCtx(ealPubKey);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
#endif /* defined(HITLS_TLS_CALLBACK_CERT) || defined(HITLS_TLS_FEATURE_PROVIDER) */
| 2302_82127028/openHiTLS-examples_1508 | tls/cert/hitls_x509_adapt/hitls_x509_crypto.c | C | unknown | 5,969 |
/*
* 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.
*/
#include "hitls_build.h"
#include <stdint.h>
#include <stddef.h>
#include "hitls_error.h"
#include "hitls_cert_reg.h"
#include "hitls_x509_adapt.h"
int32_t HITLS_CertMethodInit(void)
{
#ifdef HITLS_TLS_CALLBACK_CERT
HITLS_CERT_MgrMethod mgr = {
.certStoreNew = HITLS_X509_Adapt_StoreNew,
.certStoreDup = HITLS_X509_Adapt_StoreDup,
.certStoreFree = HITLS_X509_Adapt_StoreFree,
.certStoreCtrl = HITLS_X509_Adapt_StoreCtrl,
.buildCertChain = HITLS_X509_Adapt_BuildCertChain,
.verifyCertChain = HITLS_X509_Adapt_VerifyCertChain,
.certEncode = HITLS_X509_Adapt_CertEncode,
.certParse = HITLS_X509_Adapt_CertParse,
.certDup = HITLS_X509_Adapt_CertDup,
.certRef = HITLS_X509_Adapt_CertRef,
.certFree = HITLS_X509_Adapt_CertFree,
.certCtrl = HITLS_X509_Adapt_CertCtrl,
.keyParse = HITLS_X509_Adapt_KeyParse,
.keyDup = HITLS_X509_Adapt_KeyDup,
.keyFree = HITLS_X509_Adapt_KeyFree,
.keyCtrl = HITLS_X509_Adapt_KeyCtrl,
.createSign = HITLS_X509_Adapt_CreateSign,
.verifySign = HITLS_X509_Adapt_VerifySign,
#if defined(HITLS_TLS_SUITE_KX_RSA) || defined(HITLS_TLS_PROTO_TLCP11)
.encrypt = HITLS_X509_Adapt_Encrypt,
.decrypt = HITLS_X509_Adapt_Decrypt,
#endif
.checkPrivateKey = HITLS_X509_Adapt_CheckPrivateKey,
};
return HITLS_CERT_RegisterMgrMethod(&mgr);
#else
return HITLS_SUCCESS;
#endif
}
void HITLS_CertMethodDeinit(void)
{
#ifdef HITLS_TLS_CALLBACK_CERT
HITLS_CERT_DeinitMgrMethod();
#endif
}
| 2302_82127028/openHiTLS-examples_1508 | tls/cert/hitls_x509_adapt/hitls_x509_init.c | C | unknown | 2,146 |
/*
* 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.
*/
#include "hitls_build.h"
#if defined(HITLS_TLS_CALLBACK_CERT) || defined(HITLS_TLS_FEATURE_PROVIDER)
#include <stdint.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_types.h"
#include "bsl_err_internal.h"
#include "hitls_x509_adapt.h"
#include "crypt_eal_codecs.h"
#include "crypt_errno.h"
#include "hitls_cert.h"
#include "hitls_cert_type.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "crypt_eal_pkey.h"
#include "hitls_crypt_type.h"
#include "config_type.h"
#include "tls_config.h"
#include "cert_mgr_ctx.h"
static int32_t GetPassByCb(HITLS_PasswordCb passWordCb, void *passWordCbUserData, char *pass, int32_t *passLen)
{
if (pass == NULL || passLen == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
int32_t len = 0;
if (passWordCb != NULL) {
len = passWordCb(pass, *passLen, 0, passWordCbUserData);
if (len < 0) {
BSL_ERR_PUSH_ERROR(HITLS_CERT_SELF_ADAPT_ERR);
return HITLS_CERT_SELF_ADAPT_ERR;
}
} else {
if (passWordCbUserData != NULL) {
uint32_t userDataLen = BSL_SAL_Strnlen((const char *)passWordCbUserData, *passLen);
if (userDataLen == 0 || userDataLen == (uint32_t)*passLen) {
BSL_ERR_PUSH_ERROR(HITLS_CERT_SELF_ADAPT_ERR);
return HITLS_CERT_SELF_ADAPT_ERR;
}
(void)memcpy_s(pass, *passLen, (char *)passWordCbUserData, userDataLen + 1);
len = userDataLen;
}
}
*passLen = len;
return HITLS_SUCCESS;
}
static int32_t GetPrivKeyPassword(HITLS_Config *config, uint8_t *pwd, int32_t *pwdLen)
{
HITLS_PasswordCb pwCb = HITLS_CFG_GetDefaultPasswordCb(config);
void *userData = HITLS_CFG_GetDefaultPasswordCbUserdata(config);
int32_t len = *pwdLen;
int32_t ret = GetPassByCb(pwCb, userData, (char *)pwd, pwdLen);
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
(void)memset_s(pwd, len, 0, len);
}
return ret;
}
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_CERT_Key *HITLS_X509_Adapt_ProviderKeyParse(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, const char *format, const char *encodeType)
{
HITLS_Lib_Ctx *libCtx = LIBCTX_FROM_CONFIG(config);
const char *attrName = ATTRIBUTE_FROM_CONFIG(config);
int32_t ret;
BSL_Buffer encode = {0};
HITLS_CERT_Key *ealPriKey = NULL;
uint8_t pwd[MAX_PASS_LEN] = { 0 };
BSL_Buffer pwdBuff = {pwd, sizeof(pwd)};
(void)GetPrivKeyPassword(config, pwdBuff.data, (int32_t *)&pwdBuff.dataLen);
switch (type) {
case TLS_PARSE_TYPE_FILE:
ret = CRYPT_EAL_ProviderDecodeFileKey(libCtx, attrName, BSL_CID_UNKNOWN, format, encodeType,
(const char *)buf, &pwdBuff, (CRYPT_EAL_PkeyCtx **)&ealPriKey);
break;
case TLS_PARSE_TYPE_BUFF:
encode.data = (uint8_t *)(uintptr_t)buf;
encode.dataLen = len;
ret = CRYPT_EAL_ProviderDecodeBuffKey(libCtx, attrName, BSL_CID_UNKNOWN, format, encodeType,
&encode, &pwdBuff, (CRYPT_EAL_PkeyCtx **)&ealPriKey);
break;
default:
BSL_ERR_PUSH_ERROR(HITLS_CERT_SELF_ADAPT_UNSUPPORT_FORMAT);
(void)memset_s(pwd, MAX_PASS_LEN, 0, MAX_PASS_LEN);
return NULL;
}
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
(void)memset_s(pwd, MAX_PASS_LEN, 0, MAX_PASS_LEN);
return ealPriKey;
}
#else
HITLS_CERT_Key *HITLS_X509_Adapt_KeyParse(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, HITLS_ParseFormat format)
{
(void)config;
int32_t ret;
BSL_Buffer encode = {0};
HITLS_CERT_Key *ealPriKey = NULL;
uint8_t pwd[MAX_PASS_LEN] = { 0 };
int32_t pwdLen = (int32_t)sizeof(pwd);
(void)GetPrivKeyPassword(config, pwd, &pwdLen);
switch (type) {
case TLS_PARSE_TYPE_FILE:
ret = CRYPT_EAL_DecodeFileKey(format, CRYPT_ENCDEC_UNKNOW, (const char *)buf, pwd, pwdLen,
(CRYPT_EAL_PkeyCtx **)&ealPriKey);
break;
case TLS_PARSE_TYPE_BUFF:
encode.data = (uint8_t *)(uintptr_t)buf;
encode.dataLen = len;
ret = CRYPT_EAL_DecodeBuffKey(format, CRYPT_ENCDEC_UNKNOW, &encode, pwd, pwdLen,
(CRYPT_EAL_PkeyCtx **)&ealPriKey);
break;
default:
BSL_ERR_PUSH_ERROR(HITLS_CERT_SELF_ADAPT_UNSUPPORT_FORMAT);
(void)memset_s(pwd, MAX_PASS_LEN, 0, MAX_PASS_LEN);
return NULL;
}
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
(void)memset_s(pwd, MAX_PASS_LEN, 0, MAX_PASS_LEN);
return ealPriKey;
}
#endif
HITLS_CERT_Key *HITLS_X509_Adapt_KeyDup(HITLS_CERT_Key *key)
{
return (HITLS_CERT_Key *)CRYPT_EAL_PkeyDupCtx(key);
}
void HITLS_X509_Adapt_KeyFree(HITLS_CERT_Key *key)
{
CRYPT_EAL_PkeyFreeCtx(key);
}
static HITLS_NamedGroup GetCurveNameByKey(HITLS_Config *config, const CRYPT_EAL_PkeyCtx *key)
{
CRYPT_PKEY_ParaId paraId = CRYPT_EAL_PkeyGetParaId(key);
if (paraId == CRYPT_PKEY_PARAID_MAX) {
return HITLS_NAMED_GROUP_BUTT;
}
uint32_t size = 0;
const TLS_GroupInfo *groupInfoList = ConfigGetGroupInfoList(config, &size);
for (size_t i = 0; i < size; i++) {
if (groupInfoList[i].paraId == (int32_t)paraId) {
return groupInfoList[i].groupId;
}
}
return HITLS_NAMED_GROUP_BUTT;
}
static HITLS_CERT_KeyType CertKeyAlgId2KeyType(CRYPT_EAL_PkeyCtx *pkey)
{
CRYPT_PKEY_AlgId cid = CRYPT_EAL_PkeyGetId(pkey);
if (cid == CRYPT_PKEY_RSA) {
CRYPT_RsaPadType padType = 0;
if (CRYPT_EAL_PkeyCtrl(pkey, CRYPT_CTRL_GET_RSA_PADDING, &padType, sizeof(CRYPT_RsaPadType)) != CRYPT_SUCCESS) {
return TLS_CERT_KEY_TYPE_UNKNOWN;
}
if (padType == CRYPT_EMSA_PSS) {
return TLS_CERT_KEY_TYPE_RSA_PSS;
}
}
return (HITLS_CERT_KeyType)cid;
}
int32_t HITLS_X509_Adapt_KeyCtrl(HITLS_Config *config, HITLS_CERT_Key *key, HITLS_CERT_CtrlCmd cmd,
void *input, void *output)
{
(void)input;
int32_t ret = HITLS_SUCCESS;
switch (cmd) {
case CERT_KEY_CTRL_GET_SIGN_LEN:
*(uint32_t *)output = CRYPT_EAL_PkeyGetSignLen((const CRYPT_EAL_PkeyCtx *)key);
break;
case CERT_KEY_CTRL_GET_TYPE:
*(HITLS_CERT_KeyType *)output = CertKeyAlgId2KeyType(key);
break;
case CERT_KEY_CTRL_GET_CURVE_NAME:
*(HITLS_NamedGroup *)output = GetCurveNameByKey(config, key);
break;
case CERT_KEY_CTRL_GET_POINT_FORMAT:
/* Currently only uncompressed is used */
*(HITLS_ECPointFormat *)output = HITLS_POINT_FORMAT_UNCOMPRESSED;
break;
case CERT_KEY_CTRL_GET_SECBITS:
*(int32_t *)output = CRYPT_EAL_PkeyGetSecurityBits(key);
break;
case CERT_KEY_CTRL_GET_PARAM_ID:
*(int32_t *)output = CRYPT_EAL_PkeyGetParaId(key);
break;
default:
BSL_ERR_PUSH_ERROR(HITLS_CERT_SELF_ADAPT_ERR);
ret = HITLS_CERT_SELF_ADAPT_ERR;
break;
}
return ret;
}
#endif /* defined(HITLS_TLS_CALLBACK_CERT) || defined(HITLS_TLS_FEATURE_PROVIDER) */
| 2302_82127028/openHiTLS-examples_1508 | tls/cert/hitls_x509_adapt/hitls_x509_pkey_magr.c | C | unknown | 7,886 |
/*
* 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 CERT_H
#define CERT_H
#include <stdint.h>
#include "hitls_type.h"
#include "hitls_cert_type.h"
#include "cipher_suite.h"
#include "cert_mgr.h"
#include "tls.h"
#ifdef __cplusplus
extern "C" {
#endif
#define TLS_DEFAULT_VERIFY_DEPTH 20u
#define MAX_PASS_LEN 256
/* tls.handshake.certificate_length Length of a label */
#define CERT_LEN_TAG_SIZE 3u
/* Used to transfer certificate data in ASN.1 DER format. */
typedef struct CertItem {
uint32_t dataSize; /* Data length */
uint8_t *data; /* Data content */
struct CertItem *next;
} CERT_Item;
/* Information used to describe the expected certificate */
typedef struct {
/* The server must select the certificate matching the cipher suite. The client has no such restriction. */
CERT_Type certType;
uint16_t *signSchemeList; /* certificate signature algorithm list */
uint32_t signSchemeNum; /* number of certificate signature algorithms */
uint16_t *ellipticCurveList; /* EC curve ID list */
uint32_t ellipticCurveNum; /* number of EC curve IDs */
uint8_t *ecPointFormatList; /* EC point format list */
uint32_t ecPointFormatNum; /* number of EC point formats */
HITLS_TrustedCAList *caList; /* trusted CA list */
} CERT_ExpectInfo;
/**
* @ingroup hitls_cert_type
* @brief used to transfer the signature parameter
*/
typedef struct {
HITLS_SignAlgo signAlgo; /* signature algorithm */
HITLS_HashAlgo hashAlgo; /* hash algorithm */
const uint8_t *data; /* signed data */
uint32_t dataLen; /* length of the signed data */
uint8_t *sign; /* sign */
uint32_t signLen; /* signature length */
} CERT_SignParam;
/**
* @brief Check the certificate information.
*
* @param ctx [IN] TLS context
* @param expectCertInfo [IN] Expected certificate information
* @param cert [IN] Certificate
* @param isNegotiateSignAlgo [IN] Indicates whether to select the signature algorithm used in handshake messages.
* @param signCheck [IN] Indicates whether to check the certificate signature information.
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK No callback is set.
* @retval HITLS_CERT_CTRL_ERR_GET_PUB_KEY Failed to obtain the public key.
* @retval HITLS_CERT_KEY_CTRL_ERR_GET_TYPE Failed to obtain the public key type.
* @retval HITLS_CERT_ERR_UNSUPPORT_CERT_TYPE The certificate type does not match.
* @retval HITLS_CERT_ERR_NO_SIGN_SCHEME_MATCH signature algorithm mismatch
* @retval HITLS_CERT_ERR_NO_CURVE_MATCH elliptic curve mismatch
* @retval HITLS_CERT_ERR_NO_POINT_FORMAT_MATCH Point format mismatch
*/
int32_t SAL_CERT_CheckCertInfo(HITLS_Ctx *ctx, const CERT_ExpectInfo *expectCertInfo, HITLS_CERT_X509 *cert,
bool isNegotiateSignAlgo, bool signCheck);
/**
* @brief Select the certificate chain to be sent to the peer end.
*
* @param ctx [IN] tls Context
* @param info [IN] Expected certificate information
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK No callback is set.
* @retval HITLS_CERT_ERR_SELECT_CERTIFICATE Failed to select the certificate.
*/
int32_t SAL_CERT_SelectCertByInfo(HITLS_Ctx *ctx, CERT_ExpectInfo *info);
/**
* @brief Encode the certificate chain in ASN.1 DER format.
*
* @param ctx [IN] tls Context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK No callback is set.
* @retval HITLS_CERT_ERR_BUILD_CHAIN Failed to assemble the certificate chain.
* @retval HITLS_CERT_CTRL_ERR_GET_ENCODE_LEN Failed to obtain the encoding length.
* @retval HITLS_CERT_ERR_ENCODE_CERT Certificate encoding failed.
*/
int32_t SAL_CERT_EncodeCertChain(HITLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Decode the certificate in ASN.1 DER format.
*
* @param ctx [IN] tls Context
* @param item [IN] Original certificate data, which is a linked list. Each node indicates a certificate.
* @param certPair [OUT] Certificate chain
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK No callback is set.
* @retval HITLS_MEMALLOC_FAIL Insufficient Memory
* @retval HITLS_CERT_ERR_PARSE_MSG Failed to parse the certificate data.
*/
int32_t SAL_CERT_ParseCertChain(HITLS_Ctx *ctx, CERT_Item *item, CERT_Pair **certPair);
/**
* @brief Verify the certificate chain.
*
* @param ctx [IN] tls Context
* @param certPair [IN] Certificate chain
* @param isGmEncCert [IN] Indicates whether to verify the certificate chain of the encrypted certificate
* of the TLCP. The value is always false
* when the TLCP protocol is not used.
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK No callback is set.
* @retval HITLS_MEMALLOC_FAIL Insufficient Memory
* @retval HITLS_CERT_ERR_VERIFY_CERT_CHAIN Failed to verify the certificate chain.
*/
int32_t SAL_CERT_VerifyCertChain(HITLS_Ctx *ctx, CERT_Pair *certPair, bool isTlcpEncCert);
/**
* @brief Obtain the maximum signature length.
*
* @param config [IN] TLS link configuration
* @param key [IN] Certificate private key
*
* @return Signature length
*/
uint32_t SAL_CERT_GetSignMaxLen(HITLS_Config *config, HITLS_CERT_Key *key);
/**
* @brief Sign with the certificate private key.
*
* @param ctx [IN] tls Context
* @param key [IN] Certificate private key
* @param signParam [IN/OUT] Signature information
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK No callback is set.
* @retval HITLS_CERT_ERR_CREATE_SIGN Signing failed.
*/
int32_t SAL_CERT_CreateSign(HITLS_Ctx *ctx, HITLS_CERT_Key *key, CERT_SignParam *signParam);
/**
* @brief Use the certificate public key to verify the signature.
*
* @param ctx [IN] tls Context
* @param key [IN] Certificate public key
* @param signParam [IN] Signature information
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK No callback is set.
* @retval HITLS_CERT_ERR_VERIFY_SIGN Failed to verify the signature.
*/
int32_t SAL_CERT_VerifySign(HITLS_Ctx *ctx, HITLS_CERT_Key *key, CERT_SignParam *signParam);
/**
* @ingroup hitls_cert_reg
* @brief Encrypted by the certificate public key, which is used for the RSA cipher suite.
*
* @param ctx [IN] tls Context
* @param key [IN] Certificate public key
* @param in [IN] Plaintext
* @param inLen [IN] length of plaintext
* @param out [IN] Ciphertext
* @param outLen [IN/OUT] IN: Maximum length of the ciphertext padding. OUT: Length of the ciphertext
*
* @retval HITLS_SUCCESS succeeded
*/
int32_t SAL_CERT_KeyEncrypt(HITLS_Ctx *ctx, HITLS_CERT_Key *key, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
/**
* @ingroup hitls_cert_reg
* @brief Use the certificate private key to decrypt, which is used for the RSA cipher suite.
*
* @param ctx [IN] tls Context
* @param key [IN] Certificate private key
* @param in [IN] Ciphertext
* @param inLen [IN] length of ciphertext
* @param out [IN] Plaintext
* @param outLen [IN/OUT] IN: Maximum length of plaintext padding. OUT: Plaintext length
*
* @retval HITLS_SUCCESS succeeded
*/
int32_t SAL_CERT_KeyDecrypt(HITLS_Ctx *ctx, HITLS_CERT_Key *key, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
/**
* @brief Obtain the default signature hash algorithm based on the certificate public key type.
*
* @param keyType [IN] Certificate public key type
*
* @retval Default signature hash algorithm
*/
HITLS_SignHashAlgo SAL_CERT_GetDefaultSignHashAlgo(HITLS_CERT_KeyType keyType);
/**
* @ingroup hitls_cert_reg
* @brief Encoded content of the TLCP encryption certificate obtained by the server.
*
* @param ctx [IN] tls Context
* @param outLen [OUT] OUT: length after encoding
*
* @retval Encoded content
*/
uint8_t *SAL_CERT_SrvrGmEncodeEncCert(HITLS_Ctx *ctx, uint32_t *useLen);
/**
* @ingroup hitls_cert_reg
* @brief The client obtains the encoded content of the TLCP encryption certificate.
*
* @param ctx [IN] tls Context
* @param peerCert [IN] Peer certificate information
* @param outLen [OUT] OUT: length after encoding
*
* @retval Encoded content
*/
uint8_t *SAL_CERT_ClntGmEncodeEncCert(HITLS_Ctx *ctx, CERT_Pair *peerCert, uint32_t *useLen);
/**
* @ingroup hitls_cert_reg
* @brief Check whether the certificate is an encrypted certificate, a digital signature,
* or a permission to issue the certificate.
*
* @param ctx [IN] tls Context
* @param cert [IN] Certificate to be verified
*
* @retval true indicates that is the encryption certificate.
*/
bool SAL_CERT_CheckCertKeyUsage(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert, HITLS_CERT_CtrlCmd keyusage);
/**
* @brief get cert key type based on signScheme
*
* @param signScheme [IN] signature algorithm
*
* @retval cert key type
*/
HITLS_CERT_KeyType SAL_CERT_SignScheme2CertKeyType(const HITLS_Ctx *ctx, HITLS_SignHashAlgo signScheme);
#ifdef __cplusplus
}
#endif
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/cert/include/cert.h | C | unknown | 10,096 |
/*
* 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 CERT_METHOD_H
#define CERT_METHOD_H
#include <stdint.h>
#include "hitls_cert_type.h"
#include "tls_config.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Create a certificate store.
*
* @param mgrCtx [IN] Certificate management struct
*
* @return Certificate store
*/
HITLS_CERT_Store *SAL_CERT_StoreNew(const CERT_MgrCtx *mgrCtx);
/**
* @brief Copy the certificate store.
*
* @param mgrCtx [IN] Certificate management struct
* @param store [IN] Certificate store
*
* @return Certificate store
*/
HITLS_CERT_Store *SAL_CERT_StoreDup(const CERT_MgrCtx *mgrCtx, HITLS_CERT_Store *store);
/**
* @brief Release the certificate store.
*
* @param mgrCtx [IN] Certificate management struct
* @param store [IN] Certificate store
*
* @return void
*/
void SAL_CERT_StoreFree(const CERT_MgrCtx *mgrCtx, HITLS_CERT_Store *store);
/**
* @brief Construct the certificate chain.
*
* @param config [IN] TLS link configuration
* @param store [IN] Certificate store
* @param cert [IN] Device certificate
* @param certList [OUT] Certificate chain
* @param num [IN/OUT] IN: length of array OUT: length of certificate chain
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_BuildChain(HITLS_Config *config, HITLS_CERT_Store *store, HITLS_CERT_X509 *cert,
HITLS_CERT_X509 **certList, uint32_t *num);
/**
* @brief Verify the certificate chain.
*
* @param config [IN] TLS link configuration
* @param store [IN] Certificate store
* @param certList [IN] Certificate chain
* @param num [IN] length of certificate chain
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_VerifyChain(HITLS_Ctx *ctx, HITLS_CERT_Store *store, HITLS_CERT_X509 **certList, uint32_t num);
/**
* @brief Encode the certificate in ASN.1 DER format.
*
* @param ctx [IN] TLS link object
* @param cert [IN] Certificate
* @param buf [OUT] Certificate encoding data
* @param len [IN] buffer length
* @param usedLen [OUT] Data length
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_X509Encode(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert, uint8_t *buf, uint32_t len, uint32_t *usedLen);
/**
* @brief Parse the bundle certificate to list.
*
* @param libCtx [IN] library context for provider
* @param attrName [IN] attribute name of the provider, maybe NULL
* @param config [IN] TLS link configuration
* @param buf [IN] Certificate encoding data
* @param len [IN] Data length
* @param type [IN] Data type
* @param format [IN] Data format
*
* @return certificate list
*/
HITLS_CERT_Chain *SAL_CERT_X509ParseBundleFile(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, HITLS_ParseFormat format);
/**
* @brief Parse the certificate.
*
* @param libCtx [IN] library context for provider
* @param attrName [IN] attribute name of the provider, maybe NULL
* @param config [IN] TLS link configuration
* @param buf [IN] Certificate encoding data
* @param len [IN] Data length
* @param type [IN] Data type
* @param format [IN] Data format
*
* @return Certificate
*/
HITLS_CERT_X509 *SAL_CERT_X509Parse(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, HITLS_ParseFormat format);
/**
* @brief Copy the certificate.
*
* @param mgrCtx [IN] Certificate management struct
* @param cert [IN] Certificate
*
* @return Certificate
*/
HITLS_CERT_X509 *SAL_CERT_X509Dup(const CERT_MgrCtx *mgrCtx, HITLS_CERT_X509 *cert);
/**
* @brief Certificate reference increments by one.
*
* @param mgrCtx [IN] Certificate management struct
* @param cert [IN] Certificate
*
* @return Certificate
*/
HITLS_CERT_X509 *SAL_CERT_X509Ref(const CERT_MgrCtx *mgrCtx, HITLS_CERT_X509 *cert);
/**
* @brief Release the certificate.
*
* @param cert [IN] Certificate
*
* @return void
*/
void SAL_CERT_X509Free(HITLS_CERT_X509 *cert);
/**
* @brief Parse the key.
*
* @param config [IN] TLS link configuration
* @param buf [IN] Key coded data
* @param len [IN] Data length
* @param type [IN] Data type
* @param format [IN] Data format
* @param encodeType [IN] Data encode type
*
* @return Key
*/
HITLS_CERT_Key *SAL_CERT_KeyParse(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, const char *format, const char *encodeType);
/**
* @brief Get the parse format string.
*
* @param format [IN] Data format
*
* @return Parse format string
*/
const char *SAL_CERT_GetParseFormatStr(HITLS_ParseFormat format);
/**
* @brief Copy the key.
*
* @param mgrCtx [IN] Certificate management struct
* @param key [IN] Key
*
* @return Key
*/
HITLS_CERT_Key *SAL_CERT_KeyDup(const CERT_MgrCtx *mgrCtx, HITLS_CERT_Key *key);
/**
* @brief Release the key.
*
* @param mgrCtx [IN] Certificate management struct
* @param cert [IN] Key
*
* @return void
*/
void SAL_CERT_KeyFree(const CERT_MgrCtx *mgrCtx, HITLS_CERT_Key *key);
/**
* @brief Certificate store operation function
*
* @param config [IN] TLS link configuration
* @param store [IN] Certificate store
* @param cmd [IN] Operation command
* @param in [IN] Input parameter
* @param out [OUT] Output parameter
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_StoreCtrl(HITLS_Config *config, HITLS_CERT_Store *store, HITLS_CERT_CtrlCmd cmd, void *in, void *out);
/**
* @brief Certificate operation function
*
* @param config [IN] TLS link configuration
* @param cert [IN] Certificate
* @param cmd [IN] Operation command
* @param in [IN] Input parameter
* @param out [OUT] Output parameter
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_X509Ctrl(HITLS_Config *config, HITLS_CERT_X509 *cert, HITLS_CERT_CtrlCmd cmd, void *in, void *out);
/**
* @brief Key operation function
*
* @param config [IN] TLS link configuration
* @param key [IN] Key
* @param cmd [IN] Operation command
* @param in [IN] Input parameter
* @param out [OUT] Output parameter
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_KeyCtrl(HITLS_Config *config, HITLS_CERT_Key *key, HITLS_CERT_CtrlCmd cmd, void *in, void *out);
/**
* @brief Verify the certificate private key pair.
*
* @param config [IN] TLS link configuration
* @param cert [IN] Certificate
* @param key [IN] Key
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_CheckPrivateKey(HITLS_Config *config, HITLS_CERT_X509 *cert, HITLS_CERT_Key *key);
/**
* @brief Parse CRL from data.
*
* @param config [IN] TLS link configuration
* @param buf [IN] CRL data buffer
* @param len [IN] Data length
* @param type [IN] Parse type (file or buffer)
* @param format [IN] Data format
*
* @retval HITLS_CERT_CRLList * CRL list, NULL on failure
*/
HITLS_CERT_CRLList *SAL_CERT_CrlParse(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, HITLS_ParseFormat format);
/**
* @brief Free CRL list.
*
* @param crlList [IN] CRL list to be freed
*/
void SAL_CERT_CrlFree(HITLS_CERT_CRLList *crlList);
#ifdef __cplusplus
}
#endif
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/cert/include/cert_method.h | C | unknown | 7,840 |
/*
* 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 CERT_MGR_H
#define CERT_MGR_H
#include <stdint.h>
#include "hitls_type.h"
#include "hitls_cert_type.h"
#include "hitls_cert_reg.h"
#include "hitls_cert.h"
#include "tls_config.h"
#include "bsl_hash.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Used to transfer certificates, private keys, and certificate chains. */
typedef struct CertPairInner CERT_Pair;
/**
* @brief Obtain the certificate
*
* @param certPair [IN] Certificate resource struct
*
* @return Certificate
*/
HITLS_CERT_X509 *SAL_CERT_PairGetX509(CERT_Pair *certPair);
/**
* @ingroup hitls_cert_reg
* @brief Obtain the encryption certificate
*
* @param certPair [IN] Certificate resource struct
*
* @return Encryption certificate
*/
HITLS_CERT_X509 *SAL_CERT_GetTlcpEncCert(CERT_Pair *certPair);
HITLS_CERT_Chain *SAL_CERT_PairGetChain(CERT_Pair *certPair);
CERT_Pair *SAL_CERT_PairDup(CERT_MgrCtx *mgrCtx, CERT_Pair *srcCertPair);
/**
* @brief Uninstall the certificate resource but not release the struct
*
* @param mgrCtx [IN] Certificate management struct
* @param certPair [IN] Certificate resource struct
*
* @return void
*/
void SAL_CERT_PairClear(CERT_MgrCtx *mgrCtx, CERT_Pair *certPair);
/**
* @brief Release the certificate resource struct
*
* @param mgrCtx [IN] Certificate management struct
* @param certPair [IN] Certificate resource struct. The certPair is set NULL by the invoker.
*
* @return void
*/
void SAL_CERT_PairFree(CERT_MgrCtx *mgrCtx, CERT_Pair *certPair);
/**
* @brief Copy certificate hash table
*
* @param destMgrCtx [OUT] Certificate management struct
* @param srcMgrCtx [IN] Certificate management struct
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_HashDup(CERT_MgrCtx *destMgrCtx, CERT_MgrCtx *srcMgrCtx);
/**
* @brief Indicates whether to enable the certificate management module.
*
* @param void
*
* @retval true yes
* @retval false no
*/
bool SAL_CERT_MgrIsEnable(void);
/**
* @brief Callback for obtaining a certificate
*
* @param NA
*
* @return Certificate callback
*/
HITLS_CERT_MgrMethod *SAL_CERT_GetMgrMethod(void);
/**
* @brief Create a certificate management struct
*
* @param void
*
* @return Certificate management struct
*/
CERT_MgrCtx *SAL_CERT_MgrCtxNew(void);
/**
* @brief Create a certificate management struct with provider
*
* @param libCtx [IN] Provider library context
* @param attrName [IN] Provider attrName
*
* @return Certificate management struct
*/
CERT_MgrCtx *SAL_CERT_MgrCtxProviderNew(HITLS_Lib_Ctx *libCtx, const char *attrName);
/**
* @brief Copy the certificate management struct
*
* @param mgrCtx [IN] Certificate management struct
*
* @return Certificate management struct
*/
CERT_MgrCtx *SAL_CERT_MgrCtxDup(CERT_MgrCtx *mgrCtx);
/**
* @brief Release the certificate management struct
*
* @param mgrCtx [IN] Certificate management struct. mgrCtx is set NULL by the invoker.
*
* @return void
*/
void SAL_CERT_MgrCtxFree(CERT_MgrCtx *mgrCtx);
/**
* @brief Set the cert store
*
* @param mgrCtx [IN] Certificate management struct
* @param store [IN] cert store
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_SetCertStore(CERT_MgrCtx *mgrCtx, HITLS_CERT_Store *store);
/**
* @brief Obtain the cert store
*
* @param mgrCtx [IN] Certificate management struct
*
* @return cert store
*/
HITLS_CERT_Store *SAL_CERT_GetCertStore(CERT_MgrCtx *mgrCtx);
/**
* @brief Set the chain store
*
* @param mgrCtx [IN] Certificate management struct
* @param store [IN] chain store
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_SetChainStore(CERT_MgrCtx *mgrCtx, HITLS_CERT_Store *store);
/**
* @brief Obtain the chain store
*
* @param mgrCtx [IN] Certificate management struct
*
* @return chain store
*/
HITLS_CERT_Store *SAL_CERT_GetChainStore(CERT_MgrCtx *mgrCtx);
/**
* @brief Set the verify store
*
* @param mgrCtx [IN] Certificate management struct
* @param store [IN] verify store
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_SetVerifyStore(CERT_MgrCtx *mgrCtx, HITLS_CERT_Store *store);
/**
* @brief Obtain the verify store
*
* @param mgrCtx [IN] Certificate management struct
*
* @return verify store
*/
HITLS_CERT_Store *SAL_CERT_GetVerifyStore(CERT_MgrCtx *mgrCtx);
/**
* @brief Add a device certificate and set it to the current. Only one certificate of each type can be added.
* If the certificate is added repeatedly, the certificate will be overwritten.
*
* @param config [IN] Certificate management struct
* @param cert [IN] Device certificate
* @param isGmEncCert [IN] Indicates whether the certificate is encrypted using the TLCP.
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_SetCurrentCert(HITLS_Config *config, HITLS_CERT_X509 *cert, bool isTlcpEncCert);
/**
* @brief Obtain the current device certificate
*
* @param mgrCtx [IN] Certificate management struct
*
* @return Device certificate
*/
HITLS_CERT_X509 *SAL_CERT_GetCurrentCert(CERT_MgrCtx *mgrCtx);
/**
* @brief Obtain the certificate of the specified type.
*
* @param mgrCtx [IN] Certificate management struct
* @param keyType [IN] Certificate public key type
*
* @return Device certificate
*/
HITLS_CERT_X509 *SAL_CERT_GetCert(CERT_MgrCtx *mgrCtx, HITLS_CERT_KeyType keyType);
/**
* @brief Add a private key and set it to the current key.
* Only one private key can be added for each type of certificate.
* If a private key is added repeatedly, it will be overwritten.
*
* @param config [IN] Certificate management struct
* @param key [IN] Private key
* @param isGmEncCertPriKey [IN] Indicates whether the private key of the certificate encrypted
* using the TLCP.
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_SetCurrentPrivateKey(HITLS_Config *config, HITLS_CERT_Key *key, bool isTlcpEncCertPriKey);
/**
* @brief Obtain the current private key
*
* @param mgrCtx [IN] Certificate management struct
* @param isGmEncCertPriKey [IN] Indicates whether the private key of the certificate encrypted
* using the TLCP.
*
* @return Private key
*/
HITLS_CERT_Key *SAL_CERT_GetCurrentPrivateKey(CERT_MgrCtx *mgrCtx, bool isTlcpEncCert);
/**
* @brief Obtain the private key of a specified type.
*
* @param mgrCtx [IN] Certificate management struct
* @param keyType [IN] Private key type
*
* @return Private key
*/
HITLS_CERT_Key *SAL_CERT_GetPrivateKey(CERT_MgrCtx *mgrCtx, HITLS_CERT_KeyType keyType);
int32_t SAL_CERT_AddChainCert(CERT_MgrCtx *mgrCtx, HITLS_CERT_X509 *cert);
HITLS_CERT_Chain *SAL_CERT_GetCurrentChainCerts(CERT_MgrCtx *mgrCtx);
void SAL_CERT_ClearCurrentChainCerts(CERT_MgrCtx *mgrCtx);
/**
* @brief Delete all certificate resources, including the device certificate, private key, and certificate chain.
*
* @param mgrCtx [IN] Certificate management struct
*
* @return void
*/
void SAL_CERT_ClearCertAndKey(CERT_MgrCtx *mgrCtx);
int32_t SAL_CERT_AddExtraChainCert(CERT_MgrCtx *mgrCtx, HITLS_CERT_X509 *cert);
HITLS_CERT_Chain *SAL_CERT_GetExtraChainCerts(CERT_MgrCtx *mgrCtx, bool isExtraChainCertsOnly);
void SAL_CERT_ClearExtraChainCerts(CERT_MgrCtx *mgrCtx);
/**
* @brief Set or get certificate verification parameters.
*
* @param config [IN] TLS link configuration
* @param store [IN] Certificate store
* @param cmd [IN] Operation command, HITLS_CERT_CtrlCmd enum
* @param in [IN] Input parameter
* @param out [OUT] Output parameter
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_CtrlVerifyParams(HITLS_Config *config, HITLS_CERT_Store *store, uint32_t cmd, void *in, void *out);
/**
* @brief Set the default passwd callback.
*
* @param mgrCtx [IN] Certificate management struct
* @param cb [IN] Callback function
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_SetDefaultPasswordCb(CERT_MgrCtx *mgrCtx, HITLS_PasswordCb cb);
/**
* @brief Obtain the default passwd callback.
*
* @param mgrCtx [IN] Certificate management struct
*
* @return Callback function
*/
HITLS_PasswordCb SAL_CERT_GetDefaultPasswordCb(CERT_MgrCtx *mgrCtx);
/**
* @brief Set the user data used in the default passwd callback.
*
* @param mgrCtx [IN] Certificate management struct
* @param userdata [IN] User data
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_SetDefaultPasswordCbUserdata(CERT_MgrCtx *mgrCtx, void *userdata);
/**
* @brief Obtain the user data used in the default passwd callback.
*
* @param mgrCtx [IN] Certificate management struct
*
* @return User data
*/
void *SAL_CERT_GetDefaultPasswordCbUserdata(CERT_MgrCtx *mgrCtx);
/**
* @brief Set the verify callback function, which is used during certificate verification.
*
* @param mgrCtx [IN] Certificate management struct
* @param cb [IN] User data
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_SetVerifyCb(CERT_MgrCtx *mgrCtx, HITLS_VerifyCb cb);
/**
* @brief Obtain the verify callback function.
*
* @param mgrCtx [IN] Certificate management struct
*
* @return Callback function
*/
HITLS_VerifyCb SAL_CERT_GetVerifyCb(CERT_MgrCtx *mgrCtx);
/**
* @brief Set the certificate callback function.
*
* @param mgrCtx [IN] Certificate management struct
* @param certCb [IN] Certificate callback function
* @param arg [IN] Parameter for the certificate callback function
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CERT_SetCertCb(CERT_MgrCtx *mgrCtx, HITLS_CertCb certCb, void *arg);
/**
* @brief Free the certificate chain.
*
* @param chain [IN] Certificate chain
*/
void SAL_CERT_ChainFree(HITLS_CERT_Chain *chain);
#ifdef __cplusplus
}
#endif
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/cert/include/cert_mgr.h | C | unknown | 10,579 |
/*
* 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_X509_ADAPT_LOCAL_H
#define HITLS_X509_ADAPT_LOCAL_H
#include <stdint.h>
#include "hitls_type.h"
#include "hitls_cert.h"
#include "hitls_crypt_type.h"
#include "hitls_cert_type.h"
#ifdef __cplusplus
extern "C" {
#endif
HITLS_CERT_Store *HITLS_X509_Adapt_StoreNew(void);
HITLS_CERT_Store *HITLS_X509_Adapt_StoreDup(HITLS_CERT_Store *store);
void HITLS_X509_Adapt_StoreFree(HITLS_CERT_Store *store);
int32_t HITLS_X509_Adapt_StoreCtrl(HITLS_Config *config, HITLS_CERT_Store *store, HITLS_CERT_CtrlCmd cmd,
void *input, void *output);
int32_t HITLS_X509_Adapt_BuildCertChain(HITLS_Config *config, HITLS_CERT_Store *store, HITLS_CERT_X509 *cert,
HITLS_CERT_X509 **list, uint32_t *num);
int32_t HITLS_X509_Adapt_VerifyCertChain(HITLS_Ctx *ctx, HITLS_CERT_Store *store, HITLS_CERT_X509 **list, uint32_t num);
int32_t HITLS_X509_Adapt_CertEncode(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert, uint8_t *buf, uint32_t len,
uint32_t *usedLen);
HITLS_CERT_X509 *HITLS_X509_Adapt_CertParse(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, HITLS_ParseFormat format);
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_CERT_X509 *HITLS_CERT_ProviderCertParse(HITLS_Lib_Ctx *libCtx, const char *attrName, const uint8_t *buf,
uint32_t len, HITLS_ParseType type, const char *format);
#endif
HITLS_CERT_Chain *HITLS_X509_Adapt_BundleCertParse(HITLS_Lib_Ctx *libCtx, const char *attrName, const uint8_t *buf,
uint32_t len, HITLS_ParseType type, const char *format);
HITLS_CERT_X509 *HITLS_X509_Adapt_CertDup(HITLS_CERT_X509 *cert);
HITLS_CERT_X509 *HITLS_X509_Adapt_CertRef(HITLS_CERT_X509 *cert);
void HITLS_X509_Adapt_CertFree(HITLS_CERT_X509 *cert);
int32_t HITLS_X509_Adapt_CertCtrl(HITLS_Config *config, HITLS_CERT_X509 *cert, HITLS_CERT_CtrlCmd cmd,
void *input, void *output);
HITLS_CERT_Key *HITLS_X509_Adapt_KeyParse(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, HITLS_ParseFormat format);
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_CERT_Key *HITLS_X509_Adapt_ProviderKeyParse(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, const char *format, const char *encodeType);
#endif
HITLS_CERT_Key *HITLS_X509_Adapt_KeyDup(HITLS_CERT_Key *key);
void HITLS_X509_Adapt_KeyFree(HITLS_CERT_Key *key);
int32_t HITLS_X509_Adapt_KeyCtrl(HITLS_Config *config, HITLS_CERT_Key *key, HITLS_CERT_CtrlCmd cmd,
void *input, void *output);
int32_t HITLS_X509_Adapt_CreateSign(HITLS_Ctx *ctx, HITLS_CERT_Key *key, HITLS_SignAlgo signAlgo,
HITLS_HashAlgo hashAlgo, const uint8_t *data, uint32_t dataLen, uint8_t *sign, uint32_t *signLen);
int32_t HITLS_X509_Adapt_VerifySign(HITLS_Ctx *ctx, HITLS_CERT_Key *key, HITLS_SignAlgo signAlgo,
HITLS_HashAlgo hashAlgo, const uint8_t *data, uint32_t dataLen, const uint8_t *sign, uint32_t signLen);
int32_t HITLS_X509_Adapt_Encrypt(HITLS_Ctx *ctx, HITLS_CERT_Key *key, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
int32_t HITLS_X509_Adapt_Decrypt(HITLS_Ctx *ctx, HITLS_CERT_Key *key, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
int32_t HITLS_X509_Adapt_CheckPrivateKey(const HITLS_Config *config, HITLS_CERT_X509 *cert, HITLS_CERT_Key *key);
HITLS_CERT_CRLList *HITLS_X509_Adapt_CrlParse(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, HITLS_ParseFormat format);
void HITLS_X509_Adapt_CrlFree(HITLS_CERT_CRLList *crlList);
#ifdef __cplusplus
}
#endif
#endif // HITLS_X509_ADAPT_LOCAL_H | 2302_82127028/openHiTLS-examples_1508 | tls/cert/include/hitls_x509_adapt.h | C | unknown | 4,067 |
/*
* 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 CONN_INIT_H
#define CONN_INIT_H
#include <stdint.h>
#include "hitls_build.h"
#include "tls.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Initialize TLS resources.
*
* @param ctx [IN] TLS context
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_MEMALLOC_FAIL Memory application failed.
* @retval HITLS_INTERNAL_EXCEPTION The input parameter is a null pointer.
*/
int32_t CONN_Init(TLS_Ctx *ctx);
/**
* @brief Release TLS resources.
*
* @param ctx [IN] TLS context
*/
void CONN_Deinit(TLS_Ctx *ctx);
#ifdef __cplusplus
}
#endif
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/cm/include/conn_init.h | C | unknown | 1,120 |
/*
* 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.
*/
#include <stddef.h>
#include "hitls_build.h"
#include "bsl_err_internal.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "hitls_cert_type.h"
#include "hitls_cert.h"
#include "tls.h"
int32_t HITLS_SetVerifyStore(HITLS_Ctx *ctx, HITLS_CERT_Store *store, bool isClone)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetVerifyStore(&(ctx->config.tlsConfig), store, isClone);
}
HITLS_CERT_Store *HITLS_GetVerifyStore(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetVerifyStore(&(ctx->config.tlsConfig));
}
int32_t HITLS_SetChainStore(HITLS_Ctx *ctx, HITLS_CERT_Store *store, bool isClone)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetChainStore(&(ctx->config.tlsConfig), store, isClone);
}
HITLS_CERT_Store *HITLS_GetChainStore(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetChainStore(&(ctx->config.tlsConfig));
}
int32_t HITLS_SetCertStore(HITLS_Ctx *ctx, HITLS_CERT_Store *store, bool isClone)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetCertStore(&(ctx->config.tlsConfig), store, isClone);
}
HITLS_CERT_Store *HITLS_GetCertStore(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetCertStore(&(ctx->config.tlsConfig));
}
int32_t HITLS_SetDefaultPasswordCb(HITLS_Ctx *ctx, HITLS_PasswordCb cb)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetDefaultPasswordCb(&(ctx->config.tlsConfig), cb);
}
HITLS_PasswordCb HITLS_GetDefaultPasswordCb(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetDefaultPasswordCb(&(ctx->config.tlsConfig));
}
int32_t HITLS_SetDefaultPasswordCbUserdata(HITLS_Ctx *ctx, void *userdata)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetDefaultPasswordCbUserdata(&(ctx->config.tlsConfig), userdata);
}
void *HITLS_GetDefaultPasswordCbUserdata(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetDefaultPasswordCbUserdata(&(ctx->config.tlsConfig));
}
int32_t HITLS_SetCertificate(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert, bool isClone)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetCertificate(&(ctx->config.tlsConfig), cert, isClone);
}
#ifdef HITLS_TLS_CONFIG_CERT_LOAD_FILE
int32_t HITLS_LoadCertFile(HITLS_Ctx *ctx, const char *file, HITLS_ParseFormat format)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_LoadCertFile(&(ctx->config.tlsConfig), file, format);
}
#endif
int32_t HITLS_LoadCertBuffer(HITLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_LoadCertBuffer(&(ctx->config.tlsConfig), buf, bufLen, format);
}
HITLS_CERT_X509 *HITLS_GetCertificate(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetCertificate(&(ctx->config.tlsConfig));
}
int32_t HITLS_SetPrivateKey(HITLS_Ctx *ctx, HITLS_CERT_Key *key, bool isClone)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetPrivateKey(&(ctx->config.tlsConfig), key, isClone);
}
#ifdef HITLS_TLS_CONFIG_CERT_LOAD_FILE
int32_t HITLS_ProviderLoadKeyFile(HITLS_Ctx *ctx, const char *file, const char *format, const char *type)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_ProviderLoadKeyFile(&(ctx->config.tlsConfig), file, format, type);
}
int32_t HITLS_LoadKeyFile(HITLS_Ctx *ctx, const char *file, HITLS_ParseFormat format)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_LoadKeyFile(&(ctx->config.tlsConfig), file, format);
}
#endif /* HITLS_TLS_CONFIG_CERT_LOAD_FILE */
int32_t HITLS_ProviderLoadKeyBuffer(HITLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, const char *format,
const char *type)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_ProviderLoadKeyBuffer(&(ctx->config.tlsConfig), buf, bufLen, format, type);
}
int32_t HITLS_LoadKeyBuffer(HITLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_LoadKeyBuffer(&(ctx->config.tlsConfig), buf, bufLen, format);
}
HITLS_CERT_Key *HITLS_GetPrivateKey(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetPrivateKey(&(ctx->config.tlsConfig));
}
int32_t HITLS_CheckPrivateKey(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_CheckPrivateKey(&(ctx->config.tlsConfig));
}
int32_t HITLS_RemoveCertAndKey(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_RemoveCertAndKey(&(ctx->config.tlsConfig));
}
int32_t HITLS_SetVerifyCb(HITLS_Ctx *ctx, HITLS_VerifyCb callback)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetVerifyCb(&(ctx->config.tlsConfig), callback);
}
HITLS_VerifyCb HITLS_GetVerifyCb(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetVerifyCb(&(ctx->config.tlsConfig));
}
int32_t HITLS_LoadCrlFile(HITLS_Ctx *ctx, const char *file, HITLS_ParseFormat format)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_LoadCrlFile(&(ctx->config.tlsConfig), file, format);
}
int32_t HITLS_LoadCrlBuffer(HITLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_LoadCrlBuffer(&(ctx->config.tlsConfig), buf, bufLen, format);
}
int32_t HITLS_ClearVerifyCrls(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_ClearVerifyCrls(&(ctx->config.tlsConfig));
}
#ifdef HITLS_TLS_CONFIG_CERT_LOAD_FILE
int32_t HITLS_UseCertificateChainFile(HITLS_Ctx *ctx, const char *file)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_UseCertificateChainFile(&(ctx->config.tlsConfig), file);
}
#endif /* HITLS_TLS_CONFIG_CERT_LOAD_FILE */ | 2302_82127028/openHiTLS-examples_1508 | tls/cm/src/conn_cert.c | C | unknown | 6,936 |
/*
* 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.
*/
#include "hitls_build.h"
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_list.h"
#include "tls.h"
#include "hitls.h"
#include "hitls_error.h"
#include "hitls_type.h"
#ifdef HITLS_TLS_FEATURE_PSK
#include "hitls_psk.h"
#endif
#ifdef HITLS_TLS_FEATURE_ALPN
#include "hitls_alpn.h"
#endif
#include "hs.h"
#include "alert.h"
#include "app.h"
#ifdef HITLS_TLS_FEATURE_SESSION
#include "session.h"
#endif
#ifdef HITLS_TLS_FEATURE_INDICATOR
#include "indicator.h"
#endif
#include "rec.h"
#ifdef HITLS_TLS_FEATURE_SECURITY
#include "security.h"
#endif
#include "hs_ctx.h"
#include "conn_common.h"
static const char *GetStateString(uint32_t state)
{
/* * Unknown status */
if (state >= CM_STATE_END) {
return "Unknown";
}
static const char *stateMachineStr[CM_STATE_END] = {
[CM_STATE_IDLE] = "Idle",
[CM_STATE_RENEGOTIATION] = "SecRenego",
[CM_STATE_HANDSHAKING] = "Handshaking",
[CM_STATE_TRANSPORTING] = "Transporting",
[CM_STATE_ALERTING] = "Alerting",
[CM_STATE_ALERTED] = "Alerted",
[CM_STATE_CLOSED] = "Closed",
};
/* Current status */
return stateMachineStr[state];
}
void ChangeConnState(HITLS_Ctx *ctx, CM_State state)
{
if (GetConnState(ctx) == state) {
return;
}
ctx->preState = ctx->state;
ctx->state = state;
BSL_LOG_BINLOG_VARLEN(BINLOG_ID15839, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN, "state [%s]",
GetStateString(ctx->preState));
BSL_LOG_BINLOG_VARLEN(BINLOG_ID15840, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN, "change to [%s]",
GetStateString(state));
return;
}
int32_t CommonEventInAlertingState(HITLS_Ctx *ctx)
{
/* The alerting state indicates that an alert message is being sent over the current link. In this case, the alert
* message should firstly be sent and then the link status will be updated */
ALERT_Info alertInfo = { 0 };
ALERT_GetInfo(ctx, &alertInfo);
if (alertInfo.level > ALERT_LEVEL_FATAL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16458, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "level error", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
return HITLS_INTERNAL_EXCEPTION;
}
int32_t ret = ALERT_Flush(ctx);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16459, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ALERT_Flush fail", 0, 0, 0, 0);
/* If the alert fails to be sent, return error code to user */
return ret;
}
#ifdef HITLS_TLS_FEATURE_INDICATOR
uint8_t data[2] = {alertInfo.level, alertInfo.description};
INDICATOR_MessageIndicate(1, HS_GetVersion(ctx), REC_TYPE_ALERT, data, sizeof(data) / sizeof(uint8_t), ctx,
ctx->config.tlsConfig.msgArg);
INDICATOR_StatusIndicate(ctx, INDICATE_EVENT_WRITE_ALERT,
(int32_t)(((uint32_t)(alertInfo.level) << INDICATOR_ALERT_LEVEL_OFFSET) | (uint32_t)(alertInfo.description)));
#endif
/* If a fatal alert is sent, the link must be disconnected */
if (alertInfo.level == ALERT_LEVEL_FATAL) {
#ifdef HITLS_TLS_FEATURE_SESSION
SESS_Disable(ctx->session);
#endif
ChangeConnState(ctx, CM_STATE_ALERTED);
return HITLS_SUCCESS;
}
/* If the close_notify message is sent, the link must be disconnected */
if (alertInfo.description == ALERT_CLOSE_NOTIFY) {
if (ctx->userShutDown) {
ChangeConnState(ctx, CM_STATE_CLOSED);
} else {
ChangeConnState(ctx, CM_STATE_ALERTED);
}
ctx->shutdownState |= HITLS_SENT_SHUTDOWN;
/* If the previous state was not in the transporting state, the connection should be closed directly, and
* reading and writing are not allowed. */
if (ctx->preState != CM_STATE_TRANSPORTING) {
ctx->shutdownState |= HITLS_RECEIVED_SHUTDOWN;
}
return HITLS_SUCCESS;
}
/* Other warning alerts will not terminate the connection and the status will be restored to the previous status */
ctx->state = ctx->preState;
ALERT_CleanInfo(ctx);
return HITLS_SUCCESS;
}
static int32_t AlertRecvProcess(HITLS_Ctx *ctx, const ALERT_Info *alertInfo)
{
#ifdef HITLS_TLS_FEATURE_INDICATOR
uint8_t data[2] = {alertInfo->level, alertInfo->description};
INDICATOR_MessageIndicate(0, HS_GetVersion(ctx), REC_TYPE_ALERT, data, sizeof(data) / sizeof(uint8_t), ctx,
ctx->config.tlsConfig.msgArg);
INDICATOR_StatusIndicate(ctx, INDICATE_EVENT_READ_ALERT,
(int32_t)(((uint32_t)(alertInfo->level) << INDICATOR_ALERT_LEVEL_OFFSET) | (uint32_t)(alertInfo->description)));
#endif
/* If a fatal alert is received, the link must be disconnected */
if (alertInfo->level == ALERT_LEVEL_FATAL) {
#ifdef HITLS_TLS_FEATURE_SESSION
SESS_Disable(ctx->session);
#endif
ChangeConnState(ctx, CM_STATE_ALERTED);
ctx->shutdownState |= HITLS_RECEIVED_SHUTDOWN;
return HITLS_SUCCESS;
}
/* If a warning alert is received, the connection must be terminated if the alert is close_notify. Otherwise, the
* alert will not be processed */
ALERT_CleanInfo(ctx);
if (alertInfo->description != ALERT_CLOSE_NOTIFY) {
/* Other warning alerts will not be processed */
return HITLS_SUCCESS;
}
ctx->shutdownState |= HITLS_RECEIVED_SHUTDOWN;
/* In quiet disconnection mode, close_notify does not need to be sent */
if (ctx->config.tlsConfig.isQuietShutdown) {
ctx->shutdownState |= HITLS_SENT_SHUTDOWN;
ChangeConnState(ctx, CM_STATE_ALERTED);
return HITLS_SUCCESS;
}
if ((ctx->shutdownState & HITLS_SENT_SHUTDOWN) == 0) {
if (GetConnState(ctx) != CM_STATE_TRANSPORTING) {
/* If the close_notify message is received, the close_notify message must be sent to the peer */
ALERT_Send(ctx, ALERT_LEVEL_WARNING, ALERT_CLOSE_NOTIFY);
ChangeConnState(ctx, CM_STATE_ALERTING);
int32_t ret = ALERT_Flush(ctx);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16460, "ALERT_Flush fail");
}
ctx->shutdownState |= HITLS_SENT_SHUTDOWN;
} else {
ChangeConnState(ctx, CM_STATE_CLOSED);
}
}
if (ctx->state != CM_STATE_CLOSED) {
ChangeConnState(ctx, CM_STATE_ALERTED);
}
return HITLS_CM_LINK_CLOSED;
}
int32_t AlertEventProcess(HITLS_Ctx *ctx)
{
ALERT_Info alertInfo = { 0 };
ALERT_GetInfo(ctx, &alertInfo);
/* An alert message is received. */
if (alertInfo.flag == ALERT_FLAG_RECV) {
return AlertRecvProcess(ctx, &alertInfo);
}
/* An alert message needs to be sent */
if (alertInfo.flag == ALERT_FLAG_SEND) {
ChangeConnState(ctx, CM_STATE_ALERTING);
return CommonEventInAlertingState(ctx);
}
return HITLS_SUCCESS;
}
int32_t CommonEventInHandshakingState(HITLS_Ctx *ctx)
{
int32_t ret;
int32_t alertRet;
do {
ret = HS_DoHandshake(ctx);
if (ret == HITLS_SUCCESS) {
/* The handshake has completed */
break;
}
if (ret == HITLS_REC_NORMAL_RECV_UNEXPECT_MSG && REC_GetUnexpectedMsgType(ctx) == REC_TYPE_APP) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16489, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"The app message is received in the handshake state", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
}
if (!ALERT_GetFlag(ctx)) {
/* The handshake fails, but no alert is received. Return the error code to the user */
return ret;
}
if (ALERT_HaveExceeded(ctx, MAX_ALERT_COUNT)) {
/* If there are multiple consecutive alerts, the link is abnormal and needs to be terminated. */
ALERT_Send(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
alertRet = AlertEventProcess(ctx);
return (alertRet == HITLS_SUCCESS) ? ret : alertRet;
}
alertRet = AlertEventProcess(ctx);
if (alertRet != HITLS_SUCCESS) {
/* If the alert message fails to be sent, return the error code to the user */
return alertRet;
}
/* If fatal alert or close_notify has been processed, the handshake must be terminated */
if (ctx->state == CM_STATE_ALERTED) {
return ret;
}
} while (ret != HITLS_SUCCESS);
// If HS_DoHandshake returns success, the connection has been established.
ChangeConnState(ctx, CM_STATE_TRANSPORTING);
HS_DeInit(ctx);
return HITLS_SUCCESS;
}
const HITLS_Config *HITLS_GetConfig(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return &(ctx->config.tlsConfig);
}
HITLS_Config *HITLS_GetGlobalConfig(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return ctx->globalConfig;
}
#ifdef HITLS_TLS_PROTO_TLS13
int32_t HITLS_ClearTLS13CipherSuites(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_ClearTLS13CipherSuites(&(ctx->config.tlsConfig));
}
#endif
int32_t HITLS_SetCipherSuites(HITLS_Ctx *ctx, const uint16_t *cipherSuites, uint32_t cipherSuitesSize)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetCipherSuites(&(ctx->config.tlsConfig), cipherSuites, cipherSuitesSize);
}
#ifdef HITLS_TLS_FEATURE_ALPN
int32_t HITLS_SetAlpnProtos(HITLS_Ctx *ctx, const uint8_t *protos, uint32_t protosLen)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetAlpnProtos(&(ctx->config.tlsConfig), protos, protosLen);
}
#endif
#ifdef HITLS_TLS_FEATURE_PSK
int32_t HITLS_SetPskClientCallback(HITLS_Ctx *ctx, HITLS_PskClientCb cb)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetPskClientCallback(&(ctx->config.tlsConfig), cb);
}
int32_t HITLS_SetPskServerCallback(HITLS_Ctx *ctx, HITLS_PskServerCb cb)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetPskServerCallback(&(ctx->config.tlsConfig), cb);
}
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
int32_t HITLS_SetPskIdentityHint(HITLS_Ctx *ctx, const uint8_t *identityHint, uint32_t identityHintLen)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetPskIdentityHint(&(ctx->config.tlsConfig), identityHint, identityHintLen);
}
#endif
#endif
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
const HITLS_Cipher *HITLS_GetCurrentCipher(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return &(ctx->negotiatedInfo.cipherSuiteInfo);
}
#endif
int32_t HITLS_IsClient(const HITLS_Ctx *ctx, bool *isClient)
{
if (ctx == NULL || isClient == NULL) {
return HITLS_NULL_INPUT;
}
*isClient = ctx->isClient;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
int32_t HITLS_GetHsRandom(const HITLS_Ctx *ctx, uint8_t *out, uint32_t *outlen, bool isClient)
{
if (ctx == NULL || outlen == NULL) {
return HITLS_NULL_INPUT;
}
if (*outlen == 0) {
*outlen = RANDOM_SIZE;
return HITLS_SUCCESS;
}
uint32_t resLen = *outlen;
if (resLen > RANDOM_SIZE) {
resLen = RANDOM_SIZE;
}
if (out == NULL) {
*outlen = resLen;
return HITLS_SUCCESS;
}
if (isClient) {
(void)memcpy_s(out, resLen, ctx->negotiatedInfo.clientRandom, resLen);
} else {
(void)memcpy_s(out, resLen, ctx->negotiatedInfo.serverRandom, resLen);
}
*outlen = resLen;
return HITLS_SUCCESS;
}
/*
* If current endpoint is a server and the server preference is supported, the local server group array is preferred.
* If current endpoint is a server and the client preference is supported, the peer (client)group array is preferred
*/
static uint16_t FindPreference(const HITLS_Ctx *ctx, int32_t nmatch, bool *haveFound)
{
uint16_t ans = 0;
uint32_t preferGroupSize = 0;
uint32_t secondPreferGroupSize = 0;
uint16_t *preferGroups = NULL;
uint16_t *secondPreferGroups = NULL;
uint32_t peerGroupSize = ctx->peerInfo.groupsSize;
uint32_t localGroupSize = ctx->config.tlsConfig.groupsSize;
uint16_t *peerGroups = ctx->peerInfo.groups;
uint16_t *localGroups = ctx->config.tlsConfig.groups;
bool chooseServerPre = ctx->config.tlsConfig.isSupportServerPreference;
uint16_t intersectionCnt = 0;
preferGroupSize = (chooseServerPre == true) ? localGroupSize : peerGroupSize;
secondPreferGroupSize = (chooseServerPre == true) ? peerGroupSize : localGroupSize;
preferGroups = (chooseServerPre == true) ? localGroups : peerGroups;
secondPreferGroups = (chooseServerPre == true) ? peerGroups : localGroups;
for (uint32_t i = 0; i < preferGroupSize; i++) {
for (uint32_t j = 0; j < secondPreferGroupSize; j++) {
if (preferGroups[i] == secondPreferGroups[j]) {
intersectionCnt++;
// Currently, the preferred nmatch is already matched
bool isMatch = (intersectionCnt == nmatch);
*haveFound = (isMatch ? true : (*haveFound));
ans = (isMatch ? preferGroups[i] : ans);
// Jump out of the inner village and change
break;
}
}
if (*haveFound) {
// Exit a loop
break;
}
}
if (nmatch == GET_GROUPS_CNT) {
return (uint16_t)intersectionCnt;
}
return ans;
}
/*
* nmatch Value range: - 1 or a positive integer
* This function can be invoked only after negotiation and can be invoked only by the server.
* When nmatch is a positive integer, check the intersection of groups on the client and server, and return the nmatch
* group in the intersection by groupId. If the value of nmatch is - 1, the number of intersection groups on the client
* and server is returned based on groupId.
*/
int32_t HITLS_GetSharedGroup(const HITLS_Ctx *ctx, int32_t nmatch, uint16_t *groupId)
{
bool haveFound = false;
if (ctx == NULL || groupId == NULL) {
return HITLS_NULL_INPUT;
}
*groupId = 0;
// Check the value range of nmatch and whether the interface is invoked by the server. The client cannot invoke the
// interface because the client cannot sense the peerInfo.
if (nmatch < GET_GROUPS_CNT || nmatch == 0 || ctx->isClient) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16464, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "invalid input", 0, 0, 0, 0);
return HITLS_INVALID_INPUT;
}
*groupId = FindPreference(ctx, nmatch, &haveFound);
if (nmatch == GET_GROUPS_CNT) {
// The value of *groupId is the number of intersections
return HITLS_SUCCESS;
} else if (haveFound == false) {
// If nmatch is not equal to GET_GROUPS_CNT and haveFound is false
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16465, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input err", 0, 0, 0, 0);
return HITLS_INVALID_INPUT;
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_CONNECTION_INFO_NEGOTIATION */
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
int32_t HITLS_GetPeerFinishVerifyData(const HITLS_Ctx *ctx, void *buf, uint32_t bufLen, uint32_t *dataLen)
{
uint32_t verifyDataSize, bufSize;
const uint8_t *verifyData = NULL;
if (ctx == NULL || buf == NULL || bufLen == 0 || dataLen == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->isClient) {
verifyDataSize = ctx->negotiatedInfo.serverVerifyDataSize;
verifyData = ctx->negotiatedInfo.serverVerifyData;
} else {
verifyDataSize = ctx->negotiatedInfo.clientVerifyDataSize;
verifyData = ctx->negotiatedInfo.clientVerifyData;
}
if (bufLen > verifyDataSize) {
bufSize = verifyDataSize;
} else {
bufSize = bufLen;
}
(void)memcpy_s(buf, bufLen, verifyData, bufSize);
*dataLen = verifyDataSize;
return HITLS_SUCCESS;
}
int32_t HITLS_GetFinishVerifyData(const HITLS_Ctx *ctx, void *buf, uint32_t bufLen, uint32_t *dataLen)
{
uint32_t verifyDataSize, bufSize;
const uint8_t *verifyData = NULL;
if (ctx == NULL || buf == NULL || bufLen == 0 || dataLen == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->isClient) {
verifyDataSize = ctx->negotiatedInfo.clientVerifyDataSize;
verifyData = ctx->negotiatedInfo.clientVerifyData;
} else {
verifyDataSize = ctx->negotiatedInfo.serverVerifyDataSize;
verifyData = ctx->negotiatedInfo.serverVerifyData;
}
if (bufLen > verifyDataSize) {
bufSize = verifyDataSize;
} else {
bufSize = bufLen;
}
(void)memcpy_s(buf, bufLen, verifyData, bufSize);
*dataLen = verifyDataSize;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_RENEGOTIATION */
#ifdef HITLS_TLS_PROTO_ALL
int32_t HITLS_GetVersionSupport(const HITLS_Ctx *ctx, uint32_t *version)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetVersionSupport(&(ctx->config.tlsConfig), version);
}
int32_t HITLS_SetVersionSupport(HITLS_Ctx *ctx, uint32_t version)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetVersionSupport(&(ctx->config.tlsConfig), version);
}
#endif
#ifdef HITLS_TLS_SUITE_KX_RSA
int32_t HITLS_SetNeedCheckPmsVersion(HITLS_Ctx *ctx, bool needCheck)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetNeedCheckPmsVersion(&(ctx->config.tlsConfig), needCheck);
}
#endif
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
static bool HS_IsAppDataAllowed(TLS_Ctx *ctx)
{
uint32_t hsState = HS_GetState(ctx);
if (ctx->isClient) {
if (hsState == TRY_RECV_SERVER_HELLO) {
return true;
}
} else {
if (hsState == TRY_RECV_CLIENT_HELLO) {
return true;
}
}
return false;
}
void InnerRenegotiationProcess(HITLS_Ctx *ctx)
{
ALERT_Info alertInfo = { 0 };
ALERT_GetInfo(ctx, &alertInfo);
if ((alertInfo.level == ALERT_LEVEL_WARNING) && (alertInfo.description == ALERT_NO_RENEGOTIATION)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16234, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Receive no renegotiation alert during renegotiation process", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_HANDSHAKE_FAILURE);
}
}
int32_t CommonEventInRenegotiationState(HITLS_Ctx *ctx)
{
int32_t ret;
do {
ret = HS_DoHandshake(ctx);
if (ret == HITLS_SUCCESS) {
/* The handshake has completed */
break;
}
if (ret == HITLS_REC_NORMAL_RECV_UNEXPECT_MSG && REC_GetUnexpectedMsgType(ctx) == REC_TYPE_APP) {
if (ctx->allowAppOut && HS_IsAppDataAllowed(ctx)) {
return ret;
}
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17106, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"The app message is received in the handshake state", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
}
if (!ALERT_GetFlag(ctx)) {
/* The handshake fails, but no alert is displayed. The system returns a message
* to the user for processing */
return ret;
}
InnerRenegotiationProcess(ctx);
if (ALERT_HaveExceeded(ctx, MAX_ALERT_COUNT)) {
/* If multiple consecutive alerts exist, the link is abnormal and needs to be terminated */
ALERT_Send(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
}
int32_t alertRet = AlertEventProcess(ctx);
if (alertRet != HITLS_SUCCESS) {
if (alertRet != HITLS_CM_LINK_CLOSED) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16466, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"AlertEventProcess fail", 0, 0, 0, 0);
}
/* If the alert fails to be sent, the system sends a message to the user for processing */
return alertRet;
}
/*
If fatal alert or close_notify has been processed, the handshake must be terminated.
*/
if (ctx->state == CM_STATE_ALERTED) {
return ret;
}
} while (ret != HITLS_SUCCESS);
// If the HS_DoHandshake message is returned successfully, the link has been terminated.
ChangeConnState(ctx, CM_STATE_TRANSPORTING);
HS_DeInit(ctx);
// Prevent the renegotiation status from being changed after the Hello Request message is sent.
if (ctx->negotiatedInfo.isRenegotiation) {
ctx->userRenego = false;
ctx->negotiatedInfo.isRenegotiation = false; /* Disabling renegotiation */
BSL_LOG_BINLOG_FIXLEN(
BINLOG_ID15952, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN, "renegotiate completed.", 0, 0, 0, 0);
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_RENEGOTIATION */
#if defined(HITLS_TLS_FEATURE_PSK) && defined(HITLS_TLS_PROTO_TLS13)
int32_t HITLS_SetPskFindSessionCallback(HITLS_Ctx *ctx, HITLS_PskFindSessionCb cb)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetPskFindSessionCallback(&(ctx->config.tlsConfig), cb);
}
int32_t HITLS_SetPskUseSessionCallback(HITLS_Ctx *ctx, HITLS_PskUseSessionCb cb)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetPskUseSessionCallback(&(ctx->config.tlsConfig), cb);
}
#endif
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
int32_t HITLS_GetNegotiateGroup(const HITLS_Ctx *ctx, uint16_t *group)
{
if (ctx == NULL || group == NULL) {
return HITLS_NULL_INPUT;
}
*group = ctx->negotiatedInfo.negotiatedGroup;
return HITLS_SUCCESS;
}
#endif
int32_t HITLS_GetOutPendingSize(const HITLS_Ctx *ctx, uint32_t *size)
{
if (ctx == NULL || size == NULL || ctx->recCtx == NULL) {
return HITLS_NULL_INPUT;
}
*size = REC_GetOutBufPendingSize(ctx);
return HITLS_SUCCESS;
}
int32_t HITLS_Flush(HITLS_Ctx *ctx)
{
if (ctx == NULL || ctx->recCtx == NULL) {
return HITLS_NULL_INPUT;
}
#ifdef HITLS_TLS_PROTO_TLS
return REC_OutBufFlush(ctx);
#else
return HITLS_SUCCESS;
#endif
} | 2302_82127028/openHiTLS-examples_1508 | tls/cm/src/conn_common.c | C | unknown | 23,002 |
/*
* 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 CONN_COMMON_H
#define CONN_COMMON_H
#include <stdint.h>
#include "hitls_build.h"
#include "tls.h"
#include "hitls_type.h"
#ifdef __cplusplus
extern "C" {
#endif
#define MAX_ALERT_COUNT 5u
#define GET_GROUPS_CNT (-1)
typedef int32_t (*ManageEventProcess)(HITLS_Ctx *ctx);
typedef int32_t (*WriteEventProcess)(HITLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t *writeLen);
typedef int32_t (*ReadEventProcess)(HITLS_Ctx *ctx, uint8_t *data, uint32_t bufSize, uint32_t *readLen);
static inline CM_State GetConnState(const HITLS_Ctx *ctx)
{
return ctx->state;
}
#ifdef HITLS_TLS_FEATURE_PHA
int32_t CommonCheckPostHandshakeAuth(TLS_Ctx *ctx);
#endif
/**
* @ingroup hitls
* @brief General processing of all events in alerting state
*/
int32_t CommonEventInAlertingState(HITLS_Ctx *ctx);
/**
* @ingroup hitls
* @brief Processe of common events in hanshaking state, attempt to establish a connection
*/
int32_t CommonEventInHandshakingState(HITLS_Ctx *ctx);
/**
* @ingroup hitls
* @brief If the local end generates an Alert message when sending or receiving messages or processing handshake
* messages, or receives an Alert message from the peer end, the AlertEventProcess needs to be invoked to
* process the Alert status.
*/
int32_t AlertEventProcess(HITLS_Ctx *ctx);
void ChangeConnState(HITLS_Ctx *ctx, CM_State state);
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
/**
* @ingroup hitls
* @brief In the renegotiation state, process the renegotiation event and attempt to establish a connection
*
* @param ctx [IN] TLS connection handle
*
* @retval HITLS_SUCCESS succeeded
* @retval For other error codes, see hitls_error.h
*/
int32_t CommonEventInRenegotiationState(HITLS_Ctx *ctx);
/**
* @ingroup hitls
* @brief In the renegotiation state, process no_renegotiation alert.
* Send a handshake_failure alert if no_renegotiation alert is received.
*
* @param ctx [IN] TLS connection handle
*
*/
void InnerRenegotiationProcess(HITLS_Ctx *ctx);
#endif
#ifdef __cplusplus
}
#endif
#endif
| 2302_82127028/openHiTLS-examples_1508 | tls/cm/src/conn_common.h | C | unknown | 2,625 |
/*
* 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.
*/
#include "securec.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "bsl_sal.h"
#include "bsl_errno.h"
#include "bsl_list.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "hitls_config.h"
#include "hitls_cert_type.h"
#include "hitls.h"
#include "tls.h"
#include "tls_config.h"
#include "cert.h"
#ifdef HITLS_TLS_FEATURE_SESSION
#include "session.h"
#include "session_mgr.h"
#endif
#include "bsl_uio.h"
#include "config.h"
#include "config_check.h"
#include "conn_common.h"
#include "conn_init.h"
#include "crypt.h"
#include "cipher_suite.h"
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
static int32_t PeerInfoInit(HITLS_Ctx *ctx)
{
/* The peerInfo.caList is used to adapt to the OpenSSL behavior. When creating the SSL_CTX object, OpenSSL
* initializes the member so that the member is not null */
ctx->peerInfo.caList = BSL_LIST_New(sizeof(HITLS_TrustedCANode *));
if (ctx->peerInfo.caList == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16468, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "LIST_New fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
return HITLS_SUCCESS;
}
#endif
/**
* @ingroup hitls
* @brief Create a TLS object and deep Copy the HITLS_Config to the HITLS_Ctx.
* @attention After the creation is successful, the HITLS_Config can be released.
* @param config [IN] config Context
* @return HITLS_Ctx Pointer. If the operation fails, null is returned.
*/
HITLS_Ctx *HITLS_New(HITLS_Config *config)
{
if (config == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16469, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "config null", 0, 0, 0, 0);
return NULL;
}
HITLS_Ctx *newCtx = (HITLS_Ctx *)BSL_SAL_Calloc(1u, sizeof(HITLS_Ctx));
if (newCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16470, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
return NULL;
}
int32_t ret = CheckConfig(config);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16471, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CheckConfig fail, ret %d", ret, 0, 0, 0);
BSL_SAL_FREE(newCtx);
return NULL;
}
ret = DumpConfig(newCtx, config);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16472, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DumpConfig fail, ret %d", ret, 0, 0, 0);
BSL_SAL_FREE(newCtx);
return NULL;
}
(void)HITLS_CFG_UpRef(config);
newCtx->globalConfig = config;
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
ret = PeerInfoInit(newCtx);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16473, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PeerInfoInit fail, ret %d", ret, 0, 0, 0);
HITLS_Free(newCtx);
return NULL;
}
#endif
ChangeConnState(newCtx, CM_STATE_IDLE);
return newCtx;
}
static void CaListNodeDestroy(void *data)
{
HITLS_TrustedCANode *tmpData = (HITLS_TrustedCANode *)data;
BSL_SAL_FREE(tmpData->data);
BSL_SAL_FREE(tmpData);
return;
}
static void CleanPeerInfo(PeerInfo *peerInfo)
{
BSL_SAL_FREE(peerInfo->groups);
BSL_SAL_FREE(peerInfo->cipherSuites);
BSL_LIST_FREE(peerInfo->caList, (BSL_LIST_PFUNC_FREE)CaListNodeDestroy);
BSL_SAL_FREE(peerInfo->signatureAlgorithms);
}
#if defined(HITLS_TLS_EXTENSION_COOKIE) || defined(HITLS_TLS_FEATURE_ALPN)
static void CleanNegotiatedInfo(TLS_NegotiatedInfo *negotiatedInfo)
{
#ifdef HITLS_TLS_EXTENSION_COOKIE
BSL_SAL_FREE(negotiatedInfo->cookie);
#endif
#ifdef HITLS_TLS_FEATURE_ALPN
BSL_SAL_FREE(negotiatedInfo->alpnSelected);
#endif
return;
}
#endif
/**
* @ingroup hitls
* @brief Release the TLS connection.
* @param ctx [IN] TLS connection handle.
* @return void
*/
void HITLS_Free(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return;
}
#ifdef HITLS_TLS_CONFIG_STATE
ctx->rwstate = HITLS_NOTHING;
#endif
CONN_Deinit(ctx);
BSL_UIO_Free(ctx->uio);
#ifdef HITLS_TLS_FEATURE_FLIGHT
BSL_UIO_Free(ctx->rUio);
ctx->rUio = NULL;
#endif
ctx->uio = NULL;
#ifdef HITLS_TLS_FEATURE_SESSION
/* Release certificate resources before releasing the config file. Otherwise, memory leakage occurs */
HITLS_SESS_Free(ctx->session);
#endif
CFG_CleanConfig(&ctx->config.tlsConfig);
HITLS_CFG_FreeConfig(ctx->globalConfig);
CleanPeerInfo(&(ctx->peerInfo));
#if defined(HITLS_TLS_EXTENSION_COOKIE) || defined(HITLS_TLS_FEATURE_ALPN)
CleanNegotiatedInfo(&ctx->negotiatedInfo);
#endif
#ifdef HITLS_TLS_FEATURE_PHA
SAL_CRYPT_DigestFree(ctx->phaHash);
ctx->phaHash = NULL;
SAL_CRYPT_DigestFree(ctx->phaCurHash);
ctx->phaCurHash = NULL;
ctx->phaState = PHA_NONE;
BSL_SAL_FREE(ctx->certificateReqCtx);
ctx->certificateReqCtxSize = 0;
#endif
BSL_SAL_FREE(ctx);
return;
}
#ifdef HITLS_TLS_FEATURE_FLIGHT
int32_t HITLS_SetReadUio(HITLS_Ctx *ctx, BSL_UIO *uio)
{
if ((ctx == NULL) || (uio == NULL)) {
return HITLS_NULL_INPUT;
}
int32_t ret = BSL_UIO_UpRef(uio);
if (ret != BSL_SUCCESS) {
return HITLS_UIO_FAIL;
}
if (ctx->rUio != NULL) {
/* A message is displayed, warning the user that the UIO is set repeatedly */
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15662, BSL_LOG_LEVEL_WARN, BSL_LOG_BINLOG_TYPE_RUN,
"Warning: Repeated uio setting.", 0, 0, 0, 0);
/* Release the original UIO */
BSL_UIO_Free(ctx->rUio);
}
ctx->rUio = uio;
return HITLS_SUCCESS;
}
#endif
static void ConfigPmtu(HITLS_Ctx *ctx, BSL_UIO *uio)
{
(void)ctx;
(void)uio;
#ifdef HITLS_TLS_PROTO_DTLS12
/* The PMTU needs to be set for DTLS. If the PMTU is not set, use the default value */
if ((ctx->config.pmtu == 0) && IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
if (BSL_UIO_GetUioChainTransportType(uio, BSL_UIO_UDP)) {
uint8_t overhead = 0;
(void)BSL_UIO_Ctrl(ctx->uio, BSL_UIO_UDP_GET_MTU_OVERHEAD, sizeof(uint8_t), &overhead);
ctx->config.pmtu = DTLS_DEFAULT_PMTU - (uint16_t)overhead;
} else {
ctx->config.pmtu = DTLS_SCTP_PMTU;
}
}
#endif
}
/**
* @ingroup hitls
* @brief Set the UIO for the HiTLS context.
* @attention This function must be called before HITLS_Connect and HITLS_Accept and released after HITLS_Free. If this
* function has been called, you must call BSL_UIO_Free to release the UIO.
* @param ctx [OUT] TLS connection handle.
* @param uio [IN] UIO object
* @return HITLS_SUCCESS succeeded
* Other Error Codes, see hitls_error.h
*/
int32_t HITLS_SetUio(HITLS_Ctx *ctx, BSL_UIO *uio)
{
if ((ctx == NULL) || (uio == NULL)) {
return HITLS_NULL_INPUT;
}
/* The UIO count increases by 1, and the reference counting is performed for the write UIO */
int32_t ret = BSL_UIO_UpRef(uio);
if (ret != BSL_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16474, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
"UIO_UpRef fail, ret %d", ret, 0, 0, 0);
return HITLS_UIO_FAIL;
}
#ifdef HITLS_TLS_FEATURE_FLIGHT
/* The UIO count increases by 1, and the reference counting is performed for reading the UIO */
ret = BSL_UIO_UpRef(uio);
if (ret != BSL_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16475, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
"UIO_UpRef fail, ret %d", ret, 0, 0, 0);
BSL_UIO_Free(uio); // free Drop the one on the top.
return HITLS_UIO_FAIL;
}
#endif
/* The original write uio is not empty */
if (ctx->uio != NULL) {
/* A message is displayed, warning the user that the UIO is set repeatedly. */
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15960, BSL_LOG_LEVEL_WARN, BSL_LOG_BINLOG_TYPE_RUN,
"Warning: Repeated uio setting.", 0, 0, 0, 0);
/* Release the original write UIO */
if (ctx->bUio != NULL) {
ctx->uio = BSL_UIO_PopCurrent(ctx->uio);
}
BSL_UIO_FreeChain(ctx->uio);
}
ctx->uio = uio;
#ifdef HITLS_TLS_FEATURE_FLIGHT
if (ctx->bUio != NULL) {
ret = BSL_UIO_Append(ctx->bUio, ctx->uio);
if (ret != BSL_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16476, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
"UIO_Append fail, ret %d", ret, 0, 0, 0);
BSL_UIO_Free(uio); // free Drop the one on the top.
return HITLS_UIO_FAIL;
}
ctx->uio = ctx->bUio;
}
/* The original read UIO is not empty */
if (ctx->rUio != NULL) {
/* A message is displayed, warning the user that the UIO is set repeatedly */
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15253, BSL_LOG_LEVEL_WARN, BSL_LOG_BINLOG_TYPE_RUN,
"Warning: Repeated uio setting.", 0, 0, 0, 0);
/* Release the original read UIO */
BSL_UIO_Free(ctx->rUio);
}
ctx->rUio = uio;
#endif
ConfigPmtu(ctx, uio);
return HITLS_SUCCESS;
}
BSL_UIO *HITLS_GetUio(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
#ifdef HITLS_TLS_FEATURE_FLIGHT
/* If |bUio| is active, the true caller-configured uio is its |next_uio|. */
if (ctx->config.tlsConfig.isFlightTransmitEnable == true && ctx->bUio != NULL) {
return BSL_UIO_Next(ctx->bUio);
}
#endif
return ctx->uio;
}
BSL_UIO *HITLS_GetReadUio(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return ctx->rUio;
}
/**
* @ingroup hitls
* @brief Obtain user data from the HiTLS context. Generally, this interface is invoked during the callback registered
* with the HiTLS.
* @attention must be invoked before HITLS_Connect and HITLS_Accept. The life cycle of the user identifier must be
* longer than the life cycle of the TLS object.
* @param ctx [OUT] TLS connection handle.
* @param userData [IN] User identifier.
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_NULL_INPUT The input parameter TLS object is a null pointer.
*/
void *HITLS_GetUserData(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return ctx->config.userData;
}
/**
* @ingroup hitls
* @brief User data is stored in the HiTLS context and can be obtained from the callback registered with the HiTLS.
* @attention must be invoked before HITLS_Connect and HITLS_Accept. The life cycle of the user identifier must be
* longer than the life cycle of the TLS object. If the user data needs to be cleared, the
* HITLS_SetUserData(ctx, NULL) interface can be invoked directly. The Clean interface is not provided separately.
* @param ctx [OUT] TLS connection handle.
* @param userData [IN] User identifier.
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_NULL_INPUT The input parameter TLS object is a null pointer.
*/
int32_t HITLS_SetUserData(HITLS_Ctx *ctx, void *userData)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
ctx->config.userData = userData;
return HITLS_SUCCESS;
}
int32_t HITLS_SetErrorCode(HITLS_Ctx *ctx, int32_t errorCode)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
ctx->errorCode = errorCode;
return HITLS_SUCCESS;
}
int32_t HITLS_GetErrorCode(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return ctx->errorCode;
}
#ifdef HITLS_TLS_FEATURE_ALPN
int32_t HITLS_GetSelectedAlpnProto(HITLS_Ctx *ctx, uint8_t **proto, uint32_t *protoLen)
{
if (ctx == NULL || proto == NULL || protoLen == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->negotiatedInfo.alpnSelected == NULL) {
return HITLS_NULL_INPUT;
}
*proto = ctx->negotiatedInfo.alpnSelected;
*protoLen = ctx->negotiatedInfo.alpnSelectedSize;
return HITLS_SUCCESS;
}
#endif
int32_t HITLS_IsServer(const HITLS_Ctx *ctx, uint8_t *isServer)
{
if (ctx == NULL || isServer == NULL) {
return HITLS_NULL_INPUT;
}
*isServer = 0;
if (ctx->isClient == false) {
*isServer = 1;
}
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_SESSION
/* Configure the handle for the session information about the HITLS link */
int32_t HITLS_SetSession(HITLS_Ctx *ctx, HITLS_Session *session)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
/* The client and server are specified only in hitls connect/accept. Therefore, the client cannot be specified here
*/
HITLS_SESS_Free(ctx->session);
/* Ignore whether the HITLS_SESS_Dup return is NULL or non-NULL */
ctx->session = HITLS_SESS_Dup(session);
return HITLS_SUCCESS;
}
/* Obtain the session information handle and directly obtain the pointer */
HITLS_Session *HITLS_GetSession(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return ctx->session;
}
/* Obtain the handle of the copied session information */
HITLS_Session *HITLS_GetDupSession(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_SESS_Dup(ctx->session);
}
#endif
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
int32_t HITLS_GetPeerSignatureType(const HITLS_Ctx *ctx, HITLS_SignAlgo *sigType)
{
HITLS_SignAlgo signAlg = HITLS_SIGN_BUTT;
HITLS_HashAlgo hashAlg = HITLS_HASH_BUTT;
if (ctx == NULL || sigType == NULL) {
return HITLS_NULL_INPUT;
}
if (CFG_GetSignParamBySchemes(ctx, ctx->peerInfo.peerSignHashAlg,
&signAlg, &hashAlg) == false) {
return HITLS_CONFIG_NO_SUITABLE_CIPHER_SUITE;
}
*sigType = signAlg;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
int32_t HITLS_GetLocalSignScheme(const HITLS_Ctx *ctx, HITLS_SignHashAlgo *localSignScheme)
{
if (ctx == NULL || localSignScheme == NULL) {
return HITLS_NULL_INPUT;
}
*localSignScheme = ctx->negotiatedInfo.signScheme;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
int32_t HITLS_GetPeerSignScheme(const HITLS_Ctx *ctx, HITLS_SignHashAlgo *peerSignScheme)
{
if (ctx == NULL || peerSignScheme == NULL) {
return HITLS_NULL_INPUT;
}
*peerSignScheme = ctx->peerInfo.peerSignHashAlg;
return HITLS_SUCCESS;
}
#endif
int32_t HITLS_SetEcGroups(HITLS_Ctx *ctx, uint16_t *lst, uint32_t groupSize)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetGroups(&(ctx->config.tlsConfig), lst, groupSize);
}
int32_t HITLS_SetSigalgsList(HITLS_Ctx *ctx, const uint16_t *signAlgs, uint16_t signAlgsSize)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetSignature(&(ctx->config.tlsConfig), signAlgs, signAlgsSize);
}
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
int32_t HITLS_GetRenegotiationSupport(const HITLS_Ctx *ctx, uint8_t *isSupportRenegotiation)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetRenegotiationSupport(&(ctx->config.tlsConfig), isSupportRenegotiation);
}
#endif
int32_t HITLS_SetEcPointFormats(HITLS_Ctx *ctx, const uint8_t *pointFormats, uint32_t pointFormatsSize)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetEcPointFormats(&(ctx->config.tlsConfig), pointFormats, pointFormatsSize);
}
int32_t HITLS_ClearChainCerts(HITLS_Ctx *ctx)
{
if (ctx == NULL || ctx->config.tlsConfig.certMgrCtx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_ClearChainCerts(&(ctx->config.tlsConfig));
}
#ifdef HITLS_TLS_FEATURE_CERT_MODE
int32_t HITLS_SetClientVerifySupport(HITLS_Ctx *ctx, bool support)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetClientVerifySupport(&(ctx->config.tlsConfig), support);
}
int32_t HITLS_SetNoClientCertSupport(HITLS_Ctx *ctx, bool support)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetNoClientCertSupport(&(ctx->config.tlsConfig), support);
}
#endif
#ifdef HITLS_TLS_FEATURE_PHA
int32_t HITLS_SetPostHandshakeAuthSupport(HITLS_Ctx *ctx, bool support)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetPostHandshakeAuthSupport(&(ctx->config.tlsConfig), support);
}
#endif
#ifdef HITLS_TLS_FEATURE_CERT_MODE
int32_t HITLS_SetVerifyNoneSupport(HITLS_Ctx *ctx, bool support)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetVerifyNoneSupport(&(ctx->config.tlsConfig), support);
}
#endif
#if defined(HITLS_TLS_FEATURE_CERT_MODE) && defined(HITLS_TLS_FEATURE_RENEGOTIATION)
int32_t HITLS_SetClientOnceVerifySupport(HITLS_Ctx *ctx, bool support)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetClientOnceVerifySupport(&(ctx->config.tlsConfig), support);
}
#endif
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
int32_t HITLS_SetDhAutoSupport(HITLS_Ctx *ctx, bool support)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetDhAutoSupport(&(ctx->config.tlsConfig), support);
}
int32_t HITLS_SetTmpDh(HITLS_Ctx *ctx, HITLS_CRYPT_Key *dhPkey)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetTmpDh(&(ctx->config.tlsConfig), dhPkey);
}
#endif
#if defined(HITLS_TLS_CONNECTION_INFO_NEGOTIATION) && defined(HITLS_TLS_FEATURE_SESSION)
HITLS_CERT_Chain *HITLS_GetPeerCertChain(const HITLS_Ctx *ctx)
{
CERT_Pair *certPair = NULL;
if (ctx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16477, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "ctx null", 0, 0, 0, 0);
return NULL;
}
int32_t ret = SESS_GetPeerCert(ctx->session, &certPair);
if (ret != HITLS_SUCCESS || certPair == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16478, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ret %d, GetPeerCert fail", ret, 0, 0, 0);
return NULL;
}
HITLS_CERT_Chain *certChain = SAL_CERT_PairGetChain(certPair);
return certChain;
}
#endif
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
HITLS_TrustedCAList *HITLS_GetPeerCAList(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return ctx->peerInfo.caList;
}
#endif
#ifdef HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES
HITLS_TrustedCAList *HITLS_GetCAList(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetCAList(&(ctx->config.tlsConfig));
}
int32_t HITLS_SetCAList(HITLS_Ctx *ctx, HITLS_TrustedCAList *list)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetCAList(&(ctx->config.tlsConfig), list);
}
#endif /* HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES */
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
int32_t HITLS_GetSecureRenegotiationSupport(const HITLS_Ctx *ctx, uint8_t *isSecureRenegotiation)
{
if (ctx == NULL || isSecureRenegotiation == NULL) {
return HITLS_NULL_INPUT;
}
*isSecureRenegotiation = (uint8_t)ctx->negotiatedInfo.isSecureRenegotiation;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_MAINTAIN_KEYLOG
static int32_t Uint8ToHex(const uint8_t *srcBuf, size_t srcLen, size_t *offset,
size_t destMaxSize, uint8_t *destBuf)
{
if (destMaxSize < 1) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16479, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"destMaxSize err", 0, 0, 0, 0);
return HITLS_NULL_INPUT;
}
size_t length = (destMaxSize - 1) / 2;
if (destBuf == NULL || offset == NULL || srcLen == 0 || srcBuf == NULL || length < srcLen) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16480, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
return HITLS_NULL_INPUT;
}
/* Initialize Offset */
size_t offsetTemp = 0u;
/* Converting an Array to a Hexadecimal Character String */
for (size_t i = 0u; i < srcLen; i++) {
if (sprintf_s((char *)&destBuf[offsetTemp], (destMaxSize - offsetTemp), "%02x", srcBuf[i]) == -1) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16481, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"sprintf_s fail", 0, 0, 0, 0);
return HITLS_INVALID_INPUT;
}
offsetTemp += sizeof(uint16_t);
if (offsetTemp >= destMaxSize) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16482, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"There's not enough memory", 0, 0, 0, 0);
return HITLS_INVALID_INPUT;
}
}
/* Update Offset */
*offset = offsetTemp;
return HITLS_SUCCESS;
}
int32_t HITLS_LogSecret(HITLS_Ctx *ctx, const char *label, const uint8_t *secret, size_t secretLen)
{
if (ctx == NULL || label == NULL || secret == NULL || secretLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16483, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
return HITLS_NULL_INPUT;
}
if (ctx->globalConfig->keyLogCb == NULL) {
return HITLS_SUCCESS;
}
size_t offset = 0;
uint8_t *random = ctx->negotiatedInfo.clientRandom;
uint32_t randomLen = RANDOM_SIZE;
size_t labelLen = strlen(label);
const uint8_t blankSpace = 0x20;
// The lengths of random and secret need to be converted into hexadecimal so they are doubled.
size_t outLen = labelLen + randomLen + randomLen + secretLen + secretLen + 3;
uint8_t *outBuffer = (uint8_t *)BSL_SAL_Calloc((uint32_t)outLen, sizeof(uint8_t));
if (outBuffer == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16484, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
// Combine label, random, and secret into a character string separated by spaces and end with '\0'.
(void)memcpy_s(outBuffer, outLen, label, labelLen);
offset += labelLen;
outBuffer[offset++] = blankSpace;
size_t index = 0;
// Convert random to a hexadecimal character string.
int32_t ret = Uint8ToHex(random, randomLen, &index, outLen - offset, &outBuffer[offset]);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16485, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"random Uint8ToHex fail", 0, 0, 0, 0);
BSL_SAL_FREE(outBuffer);
return ret;
}
offset += index;
outBuffer[offset++] = blankSpace;
// Convert the master key buffer to a hexadecimal character string.
ret = Uint8ToHex(secret, secretLen, &index, outLen - offset, &outBuffer[offset]);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16486, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"secret Uint8ToHex fail", 0, 0, 0, 0);
BSL_SAL_FREE(outBuffer);
return ret;
}
ctx->globalConfig->keyLogCb(ctx, (const char *)outBuffer);
BSL_SAL_CleanseData(outBuffer, outLen);
BSL_SAL_FREE(outBuffer);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_MAINTAIN_KEYLOG */
#ifdef HITLS_TLS_FEATURE_CERT_CB
int32_t HITLS_SetCertCb(HITLS_Ctx *ctx, HITLS_CertCb certCb, void *arg)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetCertCb(&(ctx->config.tlsConfig), certCb, arg);
}
#endif /* HITLS_TLS_FEATURE_CERT_CB */
#ifdef HITLS_TLS_CONFIG_CERT_BUILD_CHAIN
int32_t HITLS_BuildCertChain(HITLS_Ctx *ctx, HITLS_BUILD_CHAIN_FLAG flag)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_BuildCertChain(&(ctx->config.tlsConfig), flag);
}
#endif
int32_t HITLS_CtrlSetVerifyParams(HITLS_Ctx *ctx, HITLS_CERT_Store *store, uint32_t cmd, int64_t in, void *inArg)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_CtrlSetVerifyParams(&(ctx->config.tlsConfig), store, cmd, in, inArg);
}
int32_t HITLS_CtrlGetVerifyParams(HITLS_Ctx *ctx, HITLS_CERT_Store *store, uint32_t cmd, void *out)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_CtrlGetVerifyParams(&(ctx->config.tlsConfig), store, cmd, out);
}
| 2302_82127028/openHiTLS-examples_1508 | tls/cm/src/conn_create.c | C | unknown | 24,472 |
/*
* 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.
*/
#include "hitls_build.h"
#include "hitls_error.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "hitls_type.h"
#include "hitls_config.h"
#include "tls.h"
#ifdef HITLS_TLS_FEATURE_SESSION
#include "session.h"
#endif
#include "cert_method.h"
#include "record.h"
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
int32_t HITLS_GetNegotiatedVersion(const HITLS_Ctx *ctx, uint16_t *version)
{
if (ctx == NULL || version == NULL) {
return HITLS_NULL_INPUT;
}
*version = ctx->negotiatedInfo.version;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_PROTO_ALL
int32_t HITLS_GetMaxProtoVersion(const HITLS_Ctx *ctx, uint16_t *maxVersion)
{
if (ctx == NULL || maxVersion == NULL) {
return HITLS_NULL_INPUT;
}
*maxVersion = ctx->config.tlsConfig.maxVersion;
return HITLS_SUCCESS;
}
int32_t HITLS_GetMinProtoVersion(const HITLS_Ctx *ctx, uint16_t *minVersion)
{
if (ctx == NULL || minVersion == NULL) {
return HITLS_NULL_INPUT;
}
*minVersion = ctx->config.tlsConfig.minVersion;
return HITLS_SUCCESS;
}
int32_t HITLS_SetMinProtoVersion(HITLS_Ctx *ctx, uint16_t version)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
uint16_t maxVersion = ctx->config.tlsConfig.maxVersion;
return HITLS_CFG_SetVersion(&(ctx->config.tlsConfig), version, maxVersion);
}
int32_t HITLS_SetMaxProtoVersion(HITLS_Ctx *ctx, uint16_t version)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
uint16_t minVersion = ctx->config.tlsConfig.minVersion;
return HITLS_CFG_SetVersion(&(ctx->config.tlsConfig), minVersion, version);
}
#endif
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
int32_t HITLS_IsAead(const HITLS_Ctx *ctx, uint8_t *isAead)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
/* Check whether the input parameter is empty. The system does not need to check whether the input parameter is
* empty */
return HITLS_CIPHER_IsAead(&(ctx->negotiatedInfo.cipherSuiteInfo), isAead);
}
#endif
#ifdef HITLS_TLS_PROTO_DTLS
int32_t HITLS_IsDtls(const HITLS_Ctx *ctx, uint8_t *isDtls)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_IsDtls(&(ctx->config.tlsConfig), isDtls);
}
#endif
#ifdef HITLS_TLS_FEATURE_SESSION
int32_t HITLS_IsSessionReused(HITLS_Ctx *ctx, uint8_t *isReused)
{
if (ctx == NULL || isReused == NULL) {
return HITLS_NULL_INPUT;
}
*isReused = (uint8_t)ctx->negotiatedInfo.isResume;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_SESSION_ID
int32_t HITLS_SetSessionIdCtx(HITLS_Ctx *ctx, const uint8_t *sessionIdCtx, uint32_t len)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetSessionIdCtx(&ctx->config.tlsConfig, sessionIdCtx, len);
}
#endif
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
int32_t HITLS_GetSessionTicketKey(const HITLS_Ctx *ctx, uint8_t *key, uint32_t keySize, uint32_t *outSize)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetSessionTicketKey(&ctx->config.tlsConfig, key, keySize, outSize);
}
int32_t HITLS_SetSessionTicketKey(HITLS_Ctx *ctx, const uint8_t *key, uint32_t keySize)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetSessionTicketKey(&ctx->config.tlsConfig, key, keySize);
}
#endif
int32_t HITLS_SetVerifyResult(HITLS_Ctx *ctx, HITLS_ERROR verifyResult)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
ctx->peerInfo.verifyResult = verifyResult;
return HITLS_SUCCESS;
}
int32_t HITLS_GetVerifyResult(const HITLS_Ctx *ctx, HITLS_ERROR *verifyResult)
{
if (ctx == NULL || verifyResult == NULL) {
return HITLS_NULL_INPUT;
}
*verifyResult = ctx->peerInfo.verifyResult;
return HITLS_SUCCESS;
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
int32_t HITLS_SetDtlsTimerCb(HITLS_Ctx *ctx, HITLS_DtlsTimerCb cb)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetDtlsTimerCb(&(ctx->config.tlsConfig), cb);
}
#endif
#if defined(HITLS_TLS_CONNECTION_INFO_NEGOTIATION) && defined(HITLS_TLS_FEATURE_SESSION)
HITLS_CERT_X509 *HITLS_GetPeerCertificate(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
CERT_Pair *peerCert = NULL;
int32_t ret = SESS_GetPeerCert(ctx->session, &peerCert);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17157, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GetPeerCert fail", 0, 0, 0, 0);
return NULL;
}
HITLS_CERT_X509 *cert = SAL_CERT_PairGetX509(peerCert);
/* Certificate reference increments by one */
return cert == NULL ? NULL : SAL_CERT_X509Ref(ctx->config.tlsConfig.certMgrCtx, cert);
}
#endif
int32_t HITLS_SetQuietShutdown(HITLS_Ctx *ctx, int32_t mode)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
// The mode value 0 indicates that the quiet disconnection mode is disabled. The mode value 1 indicates that the
// quiet disconnection mode is enabled
if (mode != 0 && mode != 1) {
return HITLS_CONFIG_INVALID_SET;
}
ctx->config.tlsConfig.isQuietShutdown = (mode != 0);
return HITLS_SUCCESS;
}
int32_t HITLS_GetQuietShutdown(const HITLS_Ctx *ctx, int32_t *mode)
{
if (ctx == NULL || mode == NULL) {
return HITLS_NULL_INPUT;
}
*mode = (int32_t)ctx->config.tlsConfig.isQuietShutdown;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
int32_t HITLS_GetRenegotiationState(const HITLS_Ctx *ctx, uint8_t *isRenegotiationState)
{
if (ctx == NULL || isRenegotiationState == NULL) {
return HITLS_NULL_INPUT;
}
*isRenegotiationState = (uint8_t)ctx->negotiatedInfo.isRenegotiation;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_CONFIG_STATE
int32_t HITLS_GetRwstate(const HITLS_Ctx *ctx, uint8_t *rwstate)
{
if (ctx == NULL || rwstate == NULL) {
return HITLS_NULL_INPUT;
}
*rwstate = ctx->rwstate;
return HITLS_SUCCESS;
}
#endif
int32_t HITLS_SetShutdownState(HITLS_Ctx *ctx, uint32_t mode)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
ctx->shutdownState = mode;
return HITLS_SUCCESS;
}
int32_t HITLS_GetShutdownState(const HITLS_Ctx *ctx, uint32_t *mode)
{
if (ctx == NULL || mode == NULL) {
return HITLS_NULL_INPUT;
}
*mode = ctx->shutdownState;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_CERT_MODE
int32_t HITLS_GetClientVerifySupport(HITLS_Ctx *ctx, uint8_t *isSupport)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetClientVerifySupport(&(ctx->config.tlsConfig), isSupport);
}
int32_t HITLS_GetNoClientCertSupport(HITLS_Ctx *ctx, uint8_t *isSupport)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetNoClientCertSupport(&(ctx->config.tlsConfig), isSupport);
}
#endif
#ifdef HITLS_TLS_FEATURE_PHA
int32_t HITLS_GetPostHandshakeAuthSupport(HITLS_Ctx *ctx, uint8_t *isSupport)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetPostHandshakeAuthSupport(&(ctx->config.tlsConfig), isSupport);
}
#endif
#ifdef HITLS_TLS_FEATURE_CERT_MODE
int32_t HITLS_GetVerifyNoneSupport(HITLS_Ctx *ctx, uint8_t *isSupport)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetVerifyNoneSupport(&(ctx->config.tlsConfig), isSupport);
}
#endif
#if defined(HITLS_TLS_FEATURE_CERT_MODE) && defined(HITLS_TLS_FEATURE_RENEGOTIATION)
int32_t HITLS_GetClientOnceVerifySupport(HITLS_Ctx *ctx, uint8_t *isSupport)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetClientOnceVerifySupport(&(ctx->config.tlsConfig), isSupport);
}
#endif
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
int32_t HITLS_ClearRenegotiationNum(HITLS_Ctx *ctx, uint32_t *renegotiationNum)
{
if (ctx == NULL || renegotiationNum == NULL) {
return HITLS_NULL_INPUT;
}
*renegotiationNum = ctx->negotiatedInfo.renegotiationNum;
ctx->negotiatedInfo.renegotiationNum = 0;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_MODE
int32_t HITLS_SetModeSupport(HITLS_Ctx *ctx, uint32_t mode)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetModeSupport(&(ctx->config.tlsConfig), mode);
}
int32_t HITLS_ClearModeSupport(HITLS_Ctx *ctx, uint32_t mode)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_ClearModeSupport(&(ctx->config.tlsConfig), mode);
}
int32_t HITLS_GetModeSupport(const HITLS_Ctx *ctx, uint32_t *mode)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetModeSupport(&(ctx->config.tlsConfig), mode);
}
#endif
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
int32_t HITLS_SetEncryptThenMac(HITLS_Ctx *ctx, uint32_t encryptThenMacType)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetEncryptThenMac(&(ctx->config.tlsConfig), encryptThenMacType);
}
int32_t HITLS_GetEncryptThenMac(const HITLS_Ctx *ctx, uint32_t *encryptThenMacType)
{
if (ctx == NULL || encryptThenMacType == NULL) {
return HITLS_NULL_INPUT;
}
// Returns the negotiated value if it has been negotiated
if (ctx->negotiatedInfo.version > 0) {
*encryptThenMacType = (uint32_t)ctx->negotiatedInfo.isEncryptThenMac;
return HITLS_SUCCESS;
} else {
return HITLS_CFG_GetEncryptThenMac(&(ctx->config.tlsConfig), encryptThenMacType);
}
}
#endif
#ifdef HITLS_TLS_FEATURE_SNI
int32_t HITLS_SetServerName(HITLS_Ctx *ctx, uint8_t *serverName, uint32_t serverNameStrlen)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetServerName(&(ctx->config.tlsConfig), serverName, serverNameStrlen);
}
#endif
int32_t HITLS_SetCipherServerPreference(HITLS_Ctx *ctx, bool isSupport)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetCipherServerPreference(&(ctx->config.tlsConfig), isSupport);
}
int32_t HITLS_GetCipherServerPreference(const HITLS_Ctx *ctx, bool *isSupport)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetCipherServerPreference(&(ctx->config.tlsConfig), isSupport);
}
int32_t HITLS_SetRenegotiationSupport(HITLS_Ctx *ctx, bool isSupport)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetRenegotiationSupport(&(ctx->config.tlsConfig), isSupport);
}
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
int32_t HITLS_SetClientRenegotiateSupport(HITLS_Ctx *ctx, bool isSupport)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetClientRenegotiateSupport(&(ctx->config.tlsConfig), isSupport);
}
#endif
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
int32_t HITLS_SetLegacyRenegotiateSupport(HITLS_Ctx *ctx, bool isSupport)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetLegacyRenegotiateSupport(&(ctx->config.tlsConfig), isSupport);
}
#endif /* defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12) */
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
int32_t HITLS_SetSessionTicketSupport(HITLS_Ctx *ctx, bool isSupport)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetSessionTicketSupport(&(ctx->config.tlsConfig), isSupport);
}
int32_t HITLS_GetSessionTicketSupport(const HITLS_Ctx *ctx, uint8_t *isSupport)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetSessionTicketSupport(&(ctx->config.tlsConfig), isSupport);
}
#endif
int32_t HITLS_SetEmptyRecordsNum(HITLS_Ctx *ctx, uint32_t emptyNum)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetEmptyRecordsNum(&(ctx->config.tlsConfig), emptyNum);
}
int32_t HITLS_GetEmptyRecordsNum(const HITLS_Ctx *ctx, uint32_t *emptyNum)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetEmptyRecordsNum(&(ctx->config.tlsConfig), emptyNum);
}
#ifdef HITLS_TLS_FEATURE_MAX_SEND_FRAGMENT
int32_t HITLS_SetMaxSendFragment(HITLS_Ctx *ctx, uint16_t maxSendFragment)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->recCtx != NULL && ctx->recCtx->outBuf != NULL && ctx->recCtx->outBuf->start != ctx->recCtx->outBuf->end) {
return HITLS_REC_NORMAL_IO_BUSY;
}
return HITLS_CFG_SetMaxSendFragment(&(ctx->config.tlsConfig), maxSendFragment);
}
int32_t HITLS_GetMaxSendFragment(const HITLS_Ctx *ctx, uint16_t *maxSendFragment)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetMaxSendFragment(&(ctx->config.tlsConfig), maxSendFragment);
}
#endif
#ifdef HITLS_TLS_FEATURE_REC_INBUFFER_SIZE
int32_t HITLS_SetRecInbufferSize(HITLS_Ctx *ctx, uint32_t recInbufferSize)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetRecInbufferSize(&(ctx->config.tlsConfig), recInbufferSize);
}
int32_t HITLS_GetRecInbufferSize(const HITLS_Ctx *ctx, uint32_t *recInbufferSize)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetRecInbufferSize(&(ctx->config.tlsConfig), recInbufferSize);
}
#endif
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
int32_t HITLS_SetTicketNums(HITLS_Ctx *ctx, uint32_t ticketNums)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetTicketNums(&ctx->config.tlsConfig, ticketNums);
}
uint32_t HITLS_GetTicketNums(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetTicketNums(&ctx->config.tlsConfig);
}
#endif
#ifdef HITLS_TLS_FEATURE_FLIGHT
int32_t HITLS_SetFlightTransmitSwitch(HITLS_Ctx *ctx, uint8_t isEnable)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetFlightTransmitSwitch(&(ctx->config.tlsConfig), isEnable);
}
int32_t HITLS_GetFlightTransmitSwitch(const HITLS_Ctx *ctx, uint8_t *isEnable)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetFlightTransmitSwitch(&(ctx->config.tlsConfig), isEnable);
}
#endif
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
int32_t HITLS_SetDtlsCookieExangeSupport(HITLS_Ctx *ctx, bool isEnable)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetDtlsCookieExchangeSupport(&(ctx->config.tlsConfig), isEnable);
}
int32_t HITLS_GetDtlsCookieExangeSupport(const HITLS_Ctx *ctx, bool *isEnable)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetDtlsCookieExchangeSupport(&(ctx->config.tlsConfig), isEnable);
}
#endif
#ifdef HITLS_TLS_CONFIG_CERT
/**
* @ingroup hitls
* @brief Set the maximum size of the certificate chain that can be sent by the peer end.
*
* @param ctx [IN/OUT] TLS connection handle
* @param maxSize [IN] Set the maximum size of the certificate chain that can be sent by the peer end.
* @retval HITLS_NULL_INPUT The input parameter pointer is null.
* @retval HITLS_SUCCESS succeeded.
*/
int32_t HITLS_SetMaxCertList(HITLS_Ctx *ctx, uint32_t maxSize)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetMaxCertList(&(ctx->config.tlsConfig), maxSize);
}
/**
* @ingroup hitls
* @brief Obtain the maximum size of the certificate chain that can be sent by the peer end.
*
* @param ctx [IN] TLS connection handle
* @param maxSize [OUT] Maximum size of the certificate chain that can be sent by the peer end
* @retval HITLS_NULL_INPUT The input parameter pointer is null.
* @retval HITLS_SUCCESS succeeded.
*/
int32_t HITLS_GetMaxCertList(const HITLS_Ctx *ctx, uint32_t *maxSize)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetMaxCertList(&(ctx->config.tlsConfig), maxSize);
}
#endif
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
int32_t HITLS_SetTmpDhCb(HITLS_Ctx *ctx, HITLS_DhTmpCb cb)
{
if (ctx == NULL || cb == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetTmpDhCb(&(ctx->config.tlsConfig), cb);
}
#endif /* HITLS_TLS_CONFIG_MANUAL_DH */
#ifdef HITLS_TLS_CONFIG_RECORD_PADDING
int32_t HITLS_SetRecordPaddingCb(HITLS_Ctx *ctx, HITLS_RecordPaddingCb cb)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetRecordPaddingCb(&(ctx->config.tlsConfig), cb);
}
HITLS_RecordPaddingCb HITLS_GetRecordPaddingCb(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetRecordPaddingCb(&(ctx->config.tlsConfig));
}
int32_t HITLS_SetRecordPaddingCbArg(HITLS_Ctx *ctx, void *arg)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetRecordPaddingCbArg(&(ctx->config.tlsConfig), arg);
}
void *HITLS_GetRecordPaddingCbArg(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetRecordPaddingCbArg(&(ctx->config.tlsConfig));
}
#endif
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
int32_t HITLS_SetCheckKeyUsage(HITLS_Ctx *ctx, bool isCheck)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetCheckKeyUsage(&(ctx->config.tlsConfig), isCheck);
}
#endif
#ifdef HITLS_TLS_PROTO_TLS13
int32_t HITLS_SetMiddleBoxCompat(HITLS_Ctx *ctx, bool isMiddleBox)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetMiddleBoxCompat(&(ctx->config.tlsConfig), isMiddleBox);
}
int32_t HITLS_GetMiddleBoxCompat(HITLS_Ctx *ctx, bool *isMiddleBox)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetMiddleBoxCompat(&(ctx->config.tlsConfig), isMiddleBox);
}
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/cm/src/conn_ctrl.c | C | unknown | 18,324 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_INDICATOR
#include <stddef.h>
#include "tls.h"
#include "hitls_error.h"
#include "bsl_err_internal.h"
#include "hitls_debug.h"
int32_t HITLS_SetInfoCb(HITLS_Ctx *ctx, HITLS_InfoCb callback)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
ctx->config.tlsConfig.infoCb = callback;
return HITLS_SUCCESS;
}
HITLS_InfoCb HITLS_GetInfoCb(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return ctx->config.tlsConfig.infoCb;
}
int32_t HITLS_CFG_SetInfoCb(HITLS_Config *config, HITLS_InfoCb callback)
{
/* support NULL callback */
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->infoCb = callback;
return HITLS_SUCCESS;
}
HITLS_InfoCb HITLS_CFG_GetInfoCb(const HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return config->infoCb;
}
int32_t HITLS_SetMsgCb(HITLS_Ctx *ctx, HITLS_MsgCb callback)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetMsgCb(&(ctx->config.tlsConfig), callback);
}
int32_t HITLS_CFG_SetMsgCb(HITLS_Config *config, HITLS_MsgCb callback)
{
/* support NULL callback */
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->msgCb = callback;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetMsgCbArg(HITLS_Config *config, void *arg)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->msgArg = arg;
return HITLS_SUCCESS;
}
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/cm/src/conn_debug.c | C | unknown | 2,069 |
/*
* 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.
*/
#include "hitls_build.h"
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_err_internal.h"
#include "hitls.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "tls.h"
#include "hs.h"
#include "alert.h"
#include "conn_init.h"
#include "conn_common.h"
#include "rec.h"
#include "app.h"
#include "bsl_uio.h"
#include "record.h"
#include "hs_ctx.h"
#include "hs_state_recv.h"
#include "hs_state_send.h"
#include "hs_common.h"
#ifdef HITLS_TLS_PROTO_DTLS12
#define DTLS_MAX_MTU_OVERHEAD 48 /* Max overhead, ipv6 40 + udp 8 */
#endif
#define DATA_MAX_LENGTH 1024
static int32_t ConnectEventInIdleState(HITLS_Ctx *ctx)
{
ctx->isClient = true; // Set the configuration as a client
int32_t ret = CONN_Init(ctx);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16487, "CONN_Init fail");
}
ChangeConnState(ctx, CM_STATE_HANDSHAKING);
// In idle state, after initialization, the handshake process is directly started. Therefore, the handshake status
// function is directly invoked.
return CommonEventInHandshakingState(ctx);
}
static int32_t AcceptEventInIdleState(HITLS_Ctx *ctx)
{
ctx->isClient = false; // Set the configuration as the server
int32_t ret = CONN_Init(ctx);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16488, "CONN_Init fail");
}
ChangeConnState(ctx, CM_STATE_HANDSHAKING);
// In idle state, after initialization, the handshake process is directly started. Therefore, the handshake status
// function is directly invoked.
return CommonEventInHandshakingState(ctx);
}
static int32_t EstablishEventInTransportingState(HITLS_Ctx *ctx)
{
(void)ctx;
// In the renegotiation state, the renegotiation handshake procedure is started.
return HITLS_SUCCESS;
}
static int32_t EstablishEventInRenegotiationState(HITLS_Ctx *ctx)
{
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
// In the renegotiation state, the renegotiation handshake procedure is started.
int32_t ret = CommonEventInRenegotiationState(ctx);
if (ret != HITLS_SUCCESS) {
if (ret == HITLS_REC_NORMAL_RECV_UNEXPECT_MSG && ctx->state != CM_STATE_ALERTED) {
// In this case, the HITLS initiates renegotiation, but the peer end does not respond to the renegotiation
// request but returns an APP message. In this case, the success message should be returned.
return HITLS_SUCCESS;
}
return ret;
}
return HITLS_SUCCESS;
#else
(void)ctx;
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15405, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
"invalid conn states %d", CM_STATE_RENEGOTIATION, NULL, NULL, NULL);
return HITLS_INTERNAL_EXCEPTION;
#endif
}
static int32_t CloseEventInRenegotiationState(HITLS_Ctx *ctx)
{
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
if ((ctx->shutdownState & HITLS_SENT_SHUTDOWN) == 0) {
ALERT_Send(ctx, ALERT_LEVEL_WARNING, ALERT_CLOSE_NOTIFY);
int32_t ret = ALERT_Flush(ctx);
if (ret != HITLS_SUCCESS) {
ChangeConnState(ctx, CM_STATE_ALERTED);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16528, "ALERT_Flush fail");
}
ctx->shutdownState |= HITLS_SENT_SHUTDOWN;
}
/* In the renegotiation state, if the HITLS_Close function is called, the connection is directly disconnected
* and read/write operations are not allowed. */
ctx->shutdownState |= HITLS_RECEIVED_SHUTDOWN;
ChangeConnState(ctx, CM_STATE_CLOSED);
return HITLS_SUCCESS;
#else
(void)ctx;
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15406, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
"invalid conn states %d", CM_STATE_RENEGOTIATION, NULL, NULL, NULL);
return HITLS_INTERNAL_EXCEPTION;
#endif
}
static int32_t EstablishEventInAlertedState(HITLS_Ctx *ctx)
{
(void)ctx;
// Directly return a message indicating that the link status is abnormal.
return HITLS_CM_LINK_FATAL_ALERTED;
}
static int32_t EstablishEventInClosedState(HITLS_Ctx *ctx)
{
(void)ctx;
// Directly return a message indicating that the link status is abnormal.
return HITLS_CM_LINK_CLOSED;
}
static int32_t CloseEventInIdleState(HITLS_Ctx *ctx)
{
ChangeConnState(ctx, CM_STATE_CLOSED);
ctx->shutdownState |= (HITLS_SENT_SHUTDOWN | HITLS_RECEIVED_SHUTDOWN);
return HITLS_SUCCESS;
}
static int32_t CloseEventInHandshakingState(HITLS_Ctx *ctx)
{
if ((ctx->shutdownState & HITLS_SENT_SHUTDOWN) == 0) {
ALERT_Send(ctx, ALERT_LEVEL_WARNING, ALERT_CLOSE_NOTIFY);
int32_t ret = ALERT_Flush(ctx);
if (ret != HITLS_SUCCESS) {
ChangeConnState(ctx, CM_STATE_ALERTED);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16463, "ALERT_Flush fail");
}
ctx->shutdownState |= HITLS_SENT_SHUTDOWN;
}
/* In the handshaking state, if the close function is called, the connection is directly disconnected
* and read/write operations are not allowed. */
ctx->shutdownState |= HITLS_RECEIVED_SHUTDOWN;
ChangeConnState(ctx, CM_STATE_CLOSED);
return HITLS_SUCCESS;
}
static int32_t CloseEventInTransportingState(HITLS_Ctx *ctx)
{
if ((ctx->shutdownState & HITLS_SENT_SHUTDOWN) == 0) {
ALERT_Send(ctx, ALERT_LEVEL_WARNING, ALERT_CLOSE_NOTIFY);
int32_t ret = ALERT_Flush(ctx);
if (ret != HITLS_SUCCESS) {
ChangeConnState(ctx, CM_STATE_ALERTING);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16490, "ALERT_Flush fail");
}
ctx->shutdownState |= HITLS_SENT_SHUTDOWN;
}
ChangeConnState(ctx, CM_STATE_CLOSED);
return HITLS_SUCCESS;
}
static int32_t CloseEventInAlertingState(HITLS_Ctx *ctx)
{
/* If there are fatal alerts that are not sent, the system continues to send the alert. Otherwise, the system sends
* the close_notify alert */
ALERT_Send(ctx, ALERT_LEVEL_WARNING, ALERT_CLOSE_NOTIFY);
return CommonEventInAlertingState(ctx);
}
static int32_t CloseEventInAlertedState(HITLS_Ctx *ctx)
{
/*
* 1. Receive a fatal alert from the peer end.
* 2. A fatal alert has been sent to the peer end.
* 3. Receive the close notification from the peer end.
*/
// Read and write operations are not allowed in the alerted state
ChangeConnState(ctx, CM_STATE_CLOSED);
ctx->shutdownState |= (HITLS_SENT_SHUTDOWN | HITLS_RECEIVED_SHUTDOWN);
return HITLS_SUCCESS;
}
static int32_t CloseEventInClosedState(HITLS_Ctx *ctx)
{
int32_t ret;
/* When a user invokes the close function for the first time, a close notify message is sent to the peer end. When
* the user invokes the close function for the second time, the user attempts to receive the close notify message.
*/
if ((ctx->shutdownState & HITLS_RECEIVED_SHUTDOWN) == 0) {
uint8_t data[DATA_MAX_LENGTH]; // Discard the received APP message.
uint32_t readLen = 0;
ALERT_CleanInfo(ctx);
ret = APP_Read(ctx, data, sizeof(data), &readLen);
if (ret == HITLS_SUCCESS) {
return HITLS_SUCCESS;
}
if (ALERT_GetFlag(ctx) == false) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16491, "Read fail");
}
int32_t alertRet = AlertEventProcess(ctx);
if (alertRet == HITLS_CM_LINK_CLOSED) {
return HITLS_SUCCESS;
}
if (alertRet != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(alertRet, BINLOG_ID16492, "AlertEventProcess fail");
}
return ret;
}
if ((ctx->shutdownState & HITLS_SENT_SHUTDOWN) == 0) {
ALERT_Send(ctx, ALERT_LEVEL_WARNING, ALERT_CLOSE_NOTIFY);
ret = ALERT_Flush(ctx);
if (ret != HITLS_SUCCESS) {
ChangeConnState(ctx, CM_STATE_ALERTING);
return ret;
}
ctx->shutdownState |= HITLS_SENT_SHUTDOWN;
}
ChangeConnState(ctx, CM_STATE_CLOSED);
return HITLS_SUCCESS;
}
// Check and process the CTX status before HITLS_Connect and HITLS_Accept.
int32_t ProcessCtxState(HITLS_Ctx *ctx)
{
int32_t ret;
if (ctx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16493, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
return HITLS_NULL_INPUT;
}
/* Process the unsent alert message first, and then enter the corresponding state processing function based on the
* processing result */
if (GetConnState(ctx) == CM_STATE_ALERTING) {
ret = CommonEventInAlertingState(ctx);
if (ret != HITLS_SUCCESS) {
/* If the alert fails to be sent, a response is returned to the user */
return ret;
}
}
if ((GetConnState(ctx) >= CM_STATE_END) || (GetConnState(ctx) == CM_STATE_ALERTING)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16494, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"internal exception occurs", 0, 0, 0, 0);
/* If the alert message is sent successfully, the system switches to another state. Otherwise, an internal
* exception occurs */
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
int32_t HITLS_SetEndPoint(HITLS_Ctx *ctx, bool isClient)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
if (GetConnState(ctx) != CM_STATE_IDLE) {
return HITLS_MSG_HANDLE_STATE_ILLEGAL;
}
ctx->isClient = isClient;
int32_t ret = CONN_Init(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
ChangeConnState(ctx, CM_STATE_HANDSHAKING);
return HITLS_SUCCESS;
}
static int32_t ProcessEvent(HITLS_Ctx *ctx, ManageEventProcess proc)
{
return proc(ctx);
}
int32_t HITLS_Connect(HITLS_Ctx *ctx)
{
int32_t ret = ProcessCtxState(ctx);
// Process the alerting state
if (ret != HITLS_SUCCESS) {
return ret;
}
ctx->allowAppOut = false;
ManageEventProcess connectEventProcess[CM_STATE_END] = {
ConnectEventInIdleState,
CommonEventInHandshakingState,
EstablishEventInTransportingState,
EstablishEventInRenegotiationState,
NULL, // The alerting phase has been processed in the ProcessCtxState function
EstablishEventInAlertedState,
EstablishEventInClosedState
};
ManageEventProcess proc = connectEventProcess[GetConnState(ctx)];
return ProcessEvent(ctx, proc);
}
int32_t HITLS_Accept(HITLS_Ctx *ctx)
{
int32_t ret = ProcessCtxState(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
ctx->allowAppOut = false;
#ifdef HITLS_TLS_FEATURE_PHA
ret = CommonCheckPostHandshakeAuth(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif
ManageEventProcess acceptEventProcess[CM_STATE_END] = {
AcceptEventInIdleState,
CommonEventInHandshakingState,
EstablishEventInTransportingState,
EstablishEventInRenegotiationState,
NULL,
EstablishEventInAlertedState,
EstablishEventInClosedState
};
ManageEventProcess proc = acceptEventProcess[GetConnState(ctx)];
return ProcessEvent(ctx, proc);
}
int32_t HITLS_Close(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
ctx->userShutDown = 1;
if (ctx->config.tlsConfig.isQuietShutdown) {
ctx->shutdownState |= (HITLS_SENT_SHUTDOWN | HITLS_RECEIVED_SHUTDOWN);
ChangeConnState(ctx, CM_STATE_CLOSED);
return HITLS_SUCCESS;
}
ManageEventProcess closeEventProcess[CM_STATE_END] = {
CloseEventInIdleState,
CloseEventInHandshakingState, // Notify is sent to the peer end when the close interface is invoked during and
// after link establishment.
CloseEventInTransportingState, // Therefore, the same function is used for processing.
CloseEventInRenegotiationState, // In the renegotiation process, invoking the close function also sends a notify
// message to the peer end.
CloseEventInAlertingState,
CloseEventInAlertedState,
CloseEventInClosedState};
if (GetConnState(ctx) >= CM_STATE_END) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16497, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"internal exception occurs", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
int32_t ret;
do {
ManageEventProcess proc = closeEventProcess[GetConnState(ctx)];
ret = ProcessEvent(ctx, proc);
if (ret != HITLS_SUCCESS) {
return ret;
}
} while (GetConnState(ctx) != CM_STATE_CLOSED);
return HITLS_SUCCESS;
}
int32_t HITLS_GetError(const HITLS_Ctx *ctx, int32_t ret)
{
if (ctx == NULL) {
/* Unknown error */
return RETURN_ERROR_NUMBER_PROCESS(HITLS_ERR_SYSCALL, BINLOG_ID16498, "ctx null");
}
/* No internal error occurs in the SSL */
if (ret == HITLS_SUCCESS) {
return HITLS_SUCCESS;
}
if (ret == HITLS_CALLBACK_CLIENT_HELLO_RETRY) {
return HITLS_WANT_CLIENT_HELLO_CB;
}
if (ret == HITLS_CALLBACK_CERT_RETRY) {
return HITLS_WANT_X509_LOOKUP;
}
/* HANDSHAKING state */
if (ctx->state == CM_STATE_HANDSHAKING) {
/* In non-blocking mode, I/O read/write failure is acceptable and link establishment is allowed */
if (ret == HITLS_REC_NORMAL_IO_BUSY || ret == HITLS_REC_NORMAL_RECV_BUF_EMPTY) {
return (ctx->isClient == true) ? HITLS_WANT_CONNECT : HITLS_WANT_ACCEPT;
}
/* Unacceptable exceptions occur on the underlying I/O */
if (ret == HITLS_REC_ERR_IO_EXCEPTION) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_ERR_SYSCALL, BINLOG_ID16499, "Unacceptable exceptions occured");
}
/* The TLS protocol is incorrect */
return RETURN_ERROR_NUMBER_PROCESS(HITLS_ERR_TLS, BINLOG_ID16500, "TLS protocol err");
}
/* TRANSPORTING state */
if (ctx->state == CM_STATE_TRANSPORTING) {
/* An I/O read/write failure occurs in non-blocking mode. This failure is acceptable and data can be written */
if (ret == HITLS_REC_NORMAL_IO_BUSY) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_WANT_WRITE, BINLOG_ID16501, "This failure is acceptable");
}
/* An I/O read/write failure occurs in non-blocking mode. This failure is acceptable and data can be read
* continuously */
if (ret == HITLS_REC_NORMAL_RECV_BUF_EMPTY) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_WANT_READ, BINLOG_ID16502, "This failure is acceptable");
}
/* Unacceptable exceptions occur on the underlying I/O */
if (ret == HITLS_REC_ERR_IO_EXCEPTION) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_ERR_SYSCALL, BINLOG_ID16503, "Unacceptable exceptions occured");
}
/* The TLS protocol is incorrect */
return RETURN_ERROR_NUMBER_PROCESS(HITLS_ERR_TLS, BINLOG_ID16504, "TLS protocol err");
}
/* ALERTING state */
if (ctx->state == CM_STATE_ALERTING) {
if (ret == HITLS_REC_NORMAL_IO_BUSY) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_WANT_WRITE, BINLOG_ID16505, "This failure is acceptable");
}
if (ret == HITLS_REC_NORMAL_RECV_BUF_EMPTY) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_WANT_READ, BINLOG_ID16506, "This failure is acceptable");
}
}
/* ALERTED state ,indicating that the TLS protocol is faulty and the link is abnormal */
if (ctx->state == CM_STATE_ALERTED) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_ERR_TLS, BINLOG_ID16507, "TLS protocol is faulty");
}
/* Unknown error */
return RETURN_ERROR_NUMBER_PROCESS(HITLS_ERR_SYSCALL, BINLOG_ID16508, "unknown error");
}
#ifdef HITLS_TLS_CONFIG_STATE
int32_t HITLS_IsHandShakeDone(const HITLS_Ctx *ctx, uint8_t *isDone)
{
if (ctx == NULL || isDone == NULL) {
return HITLS_NULL_INPUT;
}
*isDone = 0;
if (ctx->state == CM_STATE_TRANSPORTING) {
*isDone = 1;
}
return HITLS_SUCCESS;
}
int32_t HITLS_GetHandShakeState(const HITLS_Ctx *ctx, uint32_t *state)
{
if (ctx == NULL || state == NULL) {
return HITLS_NULL_INPUT;
}
uint32_t hsState = TLS_IDLE;
/* In initialization state */
if (ctx->state == CM_STATE_IDLE) {
hsState = TLS_IDLE;
}
/* The link has been set up */
if (ctx->state == CM_STATE_TRANSPORTING) {
hsState = TLS_CONNECTED;
}
/* The link is being established. If hsctx is not empty, obtain the status */
if (ctx->state == CM_STATE_HANDSHAKING ||
ctx->state == CM_STATE_RENEGOTIATION) {
hsState = HS_GetState(ctx);
}
if (ctx->state == CM_STATE_ALERTING) {
/* If hsCtx is not empty, it indicates that the link is being established. Obtain the corresponding status */
if (ctx->hsCtx != NULL) {
hsState = HS_GetState(ctx);
} else {
/* After the link is established, the hsCtx is released. In this case, the hsCtx is in connected state */
hsState = TLS_CONNECTED;
}
}
if (ctx->state == CM_STATE_ALERTED || ctx->state == CM_STATE_CLOSED) {
if (ctx->preState == CM_STATE_IDLE && ctx->hsCtx == NULL) {
hsState = TLS_IDLE;
} else if (ctx->hsCtx != NULL) {
/* If the value of ctx->hsCtx is not NULL, it indicates that the link is being established */
hsState = HS_GetState(ctx);
} else {
/* If hsCtx is NULL, the link has been established */
hsState = TLS_CONNECTED;
}
}
*state = hsState;
return HITLS_SUCCESS;
}
int32_t HITLS_IsHandShaking(const HITLS_Ctx *ctx, uint8_t *isHandShaking)
{
if (ctx == NULL || isHandShaking == NULL) {
return HITLS_NULL_INPUT;
}
*isHandShaking = 0;
uint32_t state = GetConnState(ctx);
if ((state == CM_STATE_HANDSHAKING) || (state == CM_STATE_RENEGOTIATION)) {
*isHandShaking = 1;
}
return HITLS_SUCCESS;
}
int32_t HITLS_IsBeforeHandShake(const HITLS_Ctx *ctx, uint8_t *isBefore)
{
if (ctx == NULL || isBefore == NULL) {
return HITLS_NULL_INPUT;
}
*isBefore = 0;
if (GetConnState(ctx) == CM_STATE_IDLE) {
*isBefore = 1;
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_CONFIG_STATE */
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
int32_t HITLS_SetLinkMtu(HITLS_Ctx *ctx, uint16_t linkMtu)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
if (linkMtu < DTLS_MIN_MTU) {
return HITLS_CONFIG_INVALID_LENGTH;
}
ctx->config.linkMtu = linkMtu;
return HITLS_SUCCESS;
}
int32_t HITLS_SetMtu(HITLS_Ctx *ctx, uint16_t mtu)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
if (mtu < DTLS_MIN_MTU - DTLS_MAX_MTU_OVERHEAD) {
return HITLS_CONFIG_INVALID_LENGTH;
}
ctx->config.pmtu = mtu;
ctx->mtuModified = true;
return HITLS_SUCCESS;
}
int32_t HITLS_SetNoQueryMtu(HITLS_Ctx *ctx, bool noQueryMtu)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
ctx->noQueryMtu = noQueryMtu;
return HITLS_SUCCESS;
}
int32_t HITLS_GetNeedQueryMtu(HITLS_Ctx *ctx, bool *needQueryMtu)
{
if (ctx == NULL || needQueryMtu == NULL) {
return HITLS_NULL_INPUT;
}
*needQueryMtu = ctx->needQueryMtu;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_DTLS12 && HITLS_BSL_UIO_UDP */
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
int32_t HITLS_GetClientVersion(const HITLS_Ctx *ctx, uint16_t *clientVersion)
{
if (ctx == NULL || clientVersion == NULL) {
return HITLS_NULL_INPUT;
}
*clientVersion = ctx->negotiatedInfo.clientVersion;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_CONFIG_STATE
const char *HITLS_GetStateString(uint32_t state)
{
return HS_GetStateStr(state);
}
#endif
int32_t HITLS_DoHandShake(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->isClient) {
return HITLS_Connect(ctx);
} else {
return HITLS_Accept(ctx);
}
}
#ifdef HITLS_TLS_FEATURE_KEY_UPDATE
/* The updateType types are as follows: HITLS_UPDATE_NOT_REQUESTED (0), HITLS_UPDATE_REQUESTED (1) or
* HITLS_KEY_UPDATE_REQ_END(255). The local end sends 1 and the peer end sends 0 to the local end. The local end sends 0
* and the peer end does not send 0 to the local end.
*/
int32_t HITLS_KeyUpdate(HITLS_Ctx *ctx, uint32_t updateType)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
// Check whether the version is TLS1.3, whether the current status is transporting, and whether update is allowed.
int32_t ret = HS_CheckKeyUpdateState(ctx, updateType);
if (ret != HITLS_SUCCESS) {
return ret;
}
ctx->keyUpdateType = updateType;
ctx->isKeyUpdateRequest = true;
ret = HS_Init(ctx);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15955, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"HS_Init fail when start keyupdate.", 0, 0, 0, 0);
return ret;
}
// Successfully sendKeyUpdate. Set isKeyUpdateRequest to false and keyUpdateType to HITLS_KEY_UPDATE_REQ_END.
ChangeConnState(ctx, CM_STATE_HANDSHAKING);
HS_ChangeState(ctx, TRY_SEND_KEY_UPDATE);
return HITLS_SUCCESS;
}
int32_t HITLS_GetKeyUpdateType(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->isKeyUpdateRequest) {
return (int32_t)ctx->keyUpdateType;
}
return HITLS_KEY_UPDATE_REQ_END;
}
#endif
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
static int32_t CheckRenegotiateValid(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
uint8_t isSupport = false;
(void)HITLS_GetRenegotiationSupport(ctx, &isSupport);
/* Renegotiation is disabled */
if (isSupport == false) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16071, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"forbid renegotiate.", 0, 0, 0, 0);
return HITLS_CM_LINK_UNSUPPORT_SECURE_RENEGOTIATION;
}
/* If the version is TLS1.3 or the current link does not support security renegotiation, the system returns. */
if ((ctx->negotiatedInfo.version == HITLS_VERSION_TLS13) || (!ctx->negotiatedInfo.isSecureRenegotiation)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15953, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"unsupported renegotiate.", 0, 0, 0, 0);
return HITLS_CM_LINK_UNSUPPORT_SECURE_RENEGOTIATION;
}
/* If the link is not established, renegotiation cannot be performed. */
if ((ctx->state != CM_STATE_TRANSPORTING) && (ctx->state != CM_STATE_RENEGOTIATION)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15954, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"please complete the link establishment first.", 0, 0, 0, 0);
return HITLS_CM_LINK_UNESTABLISHED;
}
return HITLS_SUCCESS;
}
int32_t HITLS_Renegotiate(HITLS_Ctx *ctx)
{
int32_t ret = CheckRenegotiateValid(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (ctx->negotiatedInfo.isRenegotiation) {
/* If the current state is renegotiation, no change is made. */
return HITLS_SUCCESS;
}
ctx->negotiatedInfo.isRenegotiation = true; /* Start renegotiation */
if (ctx->hsCtx != NULL) {
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
/* The retransmission queue needs to be cleared in the dtls over UDP scenario. */
REC_RetransmitListClean(ctx->recCtx);
#endif
HS_DeInit(ctx);
}
ret = HS_Init(ctx);
if (ret != HITLS_SUCCESS) {
ctx->negotiatedInfo.isRenegotiation = false; /* renegotiation fails */
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15955, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"HS_Init fail when start renegotiate.", 0, 0, 0, 0);
return ret;
}
ctx->userRenego = true; /* renegotiation initiated by the local end */
ctx->negotiatedInfo.renegotiationNum++;
ChangeConnState(ctx, CM_STATE_RENEGOTIATION);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_RENEGOTIATION */
#ifdef HITLS_TLS_FEATURE_PHA
int32_t HITLS_VerifyClientPostHandshake(HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->isClient) {
return HITLS_INVALID_INPUT;
}
if (ctx->state != CM_STATE_TRANSPORTING || ctx->phaState != PHA_EXTENSION) {
return HITLS_MSG_HANDLE_STATE_ILLEGAL;
}
ctx->phaState = PHA_PENDING;
return HITLS_SUCCESS;
}
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/cm/src/conn_establish.c | C | unknown | 25,192 |
/*
* 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.
*/
#include <stdbool.h>
#include "hitls_build.h"
#include "hitls_error.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "hitls_type.h"
#include "rec.h"
#include "hs.h"
#include "app.h"
#include "alert.h"
#include "change_cipher_spec.h"
#include "conn_common.h"
#include "hs_ctx.h"
// an instance of unexpectedMsgProcessCb
int32_t ConnUnexpectedMsg(HITLS_Ctx *ctx, uint32_t msgType, const uint8_t *data, uint32_t dataLen, bool isPlain)
{
(void)isPlain;
if (ctx == NULL || data == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16509, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
if (msgType != REC_TYPE_ALERT) {
ALERT_ClearWarnCount(ctx);
}
int32_t ret = HITLS_REC_NORMAL_RECV_UNEXPECT_MSG;
#ifdef HITLS_TLS_PROTO_TLS13
if (isPlain) { // tls13
if (msgType == REC_TYPE_CHANGE_CIPHER_SPEC) {
return ProcessPlainCCS(ctx, data, dataLen);
}
return ProcessPlainAlert(ctx, data, dataLen);
}
#endif
switch (msgType) {
case REC_TYPE_CHANGE_CIPHER_SPEC:
return ProcessDecryptedCCS(ctx, data, dataLen);
case REC_TYPE_ALERT:
return ProcessDecryptedAlert(ctx, data, dataLen);
default:
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16512, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"unknown msgType", 0, 0, 0, 0);
ALERT_Send(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
break;
}
return ret;
}
int32_t CONN_Init(TLS_Ctx *ctx)
{
int32_t ret = REC_Init(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = ALERT_Init(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = CCS_Init(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = HS_Init(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
ctx->method.isRecvCCS = CCS_IsRecv;
ctx->method.sendCCS = CCS_Send;
ctx->method.ctrlCCS = CCS_Ctrl;
ctx->method.sendAlert = ALERT_Send;
ctx->method.getAlertFlag = ALERT_GetFlag;
ctx->method.unexpectedMsgProcessCb = ConnUnexpectedMsg;
#ifdef HITLS_TLS_FEATURE_KEY_UPDATE
ctx->keyUpdateType = HITLS_KEY_UPDATE_REQ_END;
ctx->isKeyUpdateRequest = false;
#endif
// default value is X509_V_OK(0)
ctx->peerInfo.verifyResult = 0;
#ifdef HITLS_TLS_CONFIG_STATE
ctx->rwstate = HITLS_NOTHING;
#endif
return HITLS_SUCCESS;
}
void CONN_Deinit(TLS_Ctx *ctx)
{
REC_DeInit(ctx);
ALERT_Deinit(ctx);
CCS_DeInit(ctx);
HS_DeInit(ctx);
return;
} | 2302_82127028/openHiTLS-examples_1508 | tls/cm/src/conn_init.c | C | unknown | 3,199 |
/*
* 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.
*/
#include "hitls_build.h"
#include "hitls_error.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "hitls_type.h"
#include "tls.h"
#include "rec.h"
#include "alert.h"
#include "app.h"
#include "conn_common.h"
#include "hs.h"
#include "hs_msg.h"
#include "hs_common.h"
#include "hs_ctx.h"
#include "crypt.h"
#include "hs_state_recv.h"
#include "bsl_bytes.h"
#include "hs_dtls_timer.h"
#define HS_MESSAGE_LEN_FIELD 3u
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
// The HITLS protocol specifies the specification for the maximum timeout period, 3600 seconds.
#define DTLS_SPECIFY_MAX_TIMEOUT_VALUE 3600
#endif
static int32_t ReadEventInIdleState(HITLS_Ctx *ctx, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
(void)ctx;
(void)data;
(void)bufSize;
(void)readLen;
return HITLS_CM_LINK_UNESTABLISHED;
}
int32_t RecvUnexpectMsgInTransportingStateProcess(HITLS_Ctx *ctx)
{
if (ctx->state == CM_STATE_HANDSHAKING) {
return CommonEventInHandshakingState(ctx);
}
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
if (ctx->state == CM_STATE_RENEGOTIATION) {
int32_t ret = CommonEventInRenegotiationState(ctx);
if (ret == HITLS_SUCCESS) {
/* The renegotiation initiated by the peer is processed and returned. */
return ret;
}
if (ret != HITLS_REC_NORMAL_RECV_UNEXPECT_MSG) {
/* If an error is returned during renegotiation, the error code must be sent to the user */
return ret;
}
if (ctx->state == CM_STATE_ALERTED) {
/* If the alert message has been processed, the link must be disconnected */
return ret;
}
}
#endif
return HITLS_SUCCESS;
}
static int32_t RecvRenegoReqPreprocess(TLS_Ctx *ctx, uint8_t type)
{
/* If the version is TLS1.3, ignore the message */
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLS13) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16514, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"tls13 not support Renegotiation", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE;
}
/* If the message is not a renegotiation request, ignore the message */
if ((ctx->isClient && (type == CLIENT_HELLO)) ||
(!ctx->isClient && (type == HELLO_REQUEST))) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16515, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ignore the message", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE;
}
/* if client renegotiate is not allowed, send no renegotiate alert, change state to CM_STATE_HANDSHAKING to
finish this process */
if (type == CLIENT_HELLO && !ctx->config.tlsConfig.allowClientRenegotiate && !ctx->userRenego) {
ChangeConnState(ctx, CM_STATE_HANDSHAKING);
(void)HS_ChangeState(ctx, TRY_RECV_CLIENT_HELLO);
return HITLS_SUCCESS;
}
/* Renegotiation request is processed only after security renegotiation is negotiated. Otherwise, no renegotiation
* alert is generated and the peer determines whether to disconnect the link */
if (!ctx->negotiatedInfo.isSecureRenegotiation || !ctx->config.tlsConfig.isSupportRenegotiation) {
if (type == HELLO_REQUEST) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16516, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"not support Renegotiation", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_WARNING, ALERT_NO_RENEGOTIATION);
return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG;
} else {
ChangeConnState(ctx, CM_STATE_HANDSHAKING);
(void)HS_ChangeState(ctx, TRY_RECV_CLIENT_HELLO);
return HITLS_SUCCESS;
}
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
REC_RetransmitListClean(ctx->recCtx); /* dtls over udp scenario, the retransmission queue needs to be cleared */
#endif
ChangeConnState(ctx, CM_STATE_RENEGOTIATION);
if (type == CLIENT_HELLO) {
// When the server start renegotiation, it sends a hello request message first, and the value of
// nextSendSeq increases to 1. Then, the hsctx is released and the nextSendSeq is reset to 0.
// Therefore, the value of nextSendSeq should return to 1 when sending server hello.
#ifdef HITLS_TLS_PROTO_DTLS12
if (ctx->userRenego && IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
ctx->hsCtx->nextSendSeq++;
}
#endif
(void)HS_ChangeState(ctx, TRY_RECV_CLIENT_HELLO);
} else {
(void)HS_ChangeState(ctx, TRY_RECV_HELLO_REQUEST);
}
return HITLS_SUCCESS;
}
static int32_t RecvKeyUpdatePreprocess(TLS_Ctx *ctx)
{
if (ctx->negotiatedInfo.version != HITLS_VERSION_TLS13) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16517, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"negotiatedInfo version is not tls13", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG;
}
ChangeConnState(ctx, CM_STATE_HANDSHAKING);
return HS_ChangeState(ctx, TRY_RECV_KEY_UPDATE);
}
static int32_t RecvCertReqPreprocess(TLS_Ctx *ctx)
{
if (ctx->state != CM_STATE_TRANSPORTING || ctx->phaState != PHA_EXTENSION ||
!ctx->isClient || ctx->negotiatedInfo.version != HITLS_VERSION_TLS13) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16518, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ctx state err", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE;
};
SAL_CRYPT_DigestFree(ctx->hsCtx->verifyCtx->hashCtx);
ctx->hsCtx->verifyCtx->hashCtx = SAL_CRYPT_DigestCopy(ctx->phaHash);
if (ctx->hsCtx->verifyCtx->hashCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16178, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pha hash copy error: digest copy fail.", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
ctx->phaState = PHA_REQUESTED;
ChangeConnState(ctx, CM_STATE_HANDSHAKING);
return HS_ChangeState(ctx, TRY_RECV_CERTIFICATE_REQUEST);
}
static int32_t RecvCertPreprocess(TLS_Ctx *ctx)
{
if (ctx->state != CM_STATE_TRANSPORTING || ctx->phaState != PHA_REQUESTED ||
ctx->isClient || ctx->negotiatedInfo.version != HITLS_VERSION_TLS13) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16519, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ctx state err", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE;
}
SAL_CRYPT_DigestFree(ctx->hsCtx->verifyCtx->hashCtx);
ctx->hsCtx->verifyCtx->hashCtx = ctx->phaCurHash;
ctx->phaCurHash = NULL;
ChangeConnState(ctx, CM_STATE_HANDSHAKING);
return HS_ChangeState(ctx, TRY_RECV_CERTIFICATE);
}
static int32_t RecvNSTPreprocess(TLS_Ctx *ctx)
{
if (ctx->negotiatedInfo.version != HITLS_VERSION_TLS13 || ctx->isClient == false) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16520, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"version err or it is server", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG;
}
ChangeConnState(ctx, CM_STATE_HANDSHAKING);
return HS_ChangeState(ctx, TRY_RECV_NEW_SESSION_TICKET);
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
static int32_t RecvPostFinishPreprocess(TLS_Ctx *ctx)
{
if (!IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
BSL_LOG_BINLOG_VARLEN(BINLOG_ID16131, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Unexpected %s handshake state message.", HS_GetMsgTypeStr(ctx->hsCtx->msgBuf[0]));
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE;
}
bool isTimeout = false;
if (!BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_UDP)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16521, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GetUioChainTransportType fail", 0, 0, 0, 0);
return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG;
}
if (HS_IsTimeout(ctx, &isTimeout) != HITLS_SUCCESS || isTimeout) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16522, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"HS_IsTimeout fail or timeout", 0, 0, 0, 0);
REC_RetransmitListClean(ctx->recCtx);
HS_DeInit(ctx);
return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG;
}
if ((ctx->isClient && !ctx->negotiatedInfo.isResume) || (!ctx->isClient && ctx->negotiatedInfo.isResume)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16523, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"RecvPostFinishPreprocess fail", 0, 0, 0, 0);
return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG;
}
ChangeConnState(ctx, CM_STATE_HANDSHAKING);
return HS_ChangeState(ctx, TRY_RECV_FINISH);
}
#endif
static int32_t PreprocessUnexpectHsMsg(HITLS_Ctx *ctx)
{
if (ctx->hsCtx != NULL) {
HS_DeInit(ctx);
}
int32_t ret = HS_Init(ctx);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15977, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"HS_Init fail when receive unexpected handshake message.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return ret;
}
// get the handshake message type
ret = ReadHsMessage(ctx, 1);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16524, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ReadHsMessage fail", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return ret;
}
HS_Ctx *hsCtx = ctx->hsCtx;
switch (hsCtx->msgBuf[0]) {
case HELLO_REQUEST:
case CLIENT_HELLO:
ret = RecvRenegoReqPreprocess(ctx, hsCtx->msgBuf[0]);
break;
case KEY_UPDATE:
ret = RecvKeyUpdatePreprocess(ctx);
break;
case CERTIFICATE_REQUEST:
ret = RecvCertReqPreprocess(ctx);
break;
case CERTIFICATE:
ret = RecvCertPreprocess(ctx);
break;
case NEW_SESSION_TICKET:
ret = RecvNSTPreprocess(ctx);
break;
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
case FINISHED:
ret = RecvPostFinishPreprocess(ctx);
break;
#endif
default:
BSL_LOG_BINLOG_VARLEN(BINLOG_ID16529, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Unexpected %s handshake state message.", HS_GetMsgTypeStr(hsCtx->msgBuf[0]));
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
ret = HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE;
}
return ret;
}
static void ConsumeHandshakeMessage(HITLS_Ctx *ctx)
{
bool isDtls = IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask);
uint32_t headerLen = isDtls ? DTLS_HS_MSG_HEADER_SIZE : HS_MSG_HEADER_SIZE;
int32_t ret = ReadHsMessage(ctx, headerLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16525, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ReadHsMessage fail", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
return;
}
uint32_t length = BSL_ByteToUint24(&ctx->hsCtx->msgBuf[headerLen - HS_MESSAGE_LEN_FIELD]);
ret = ReadHsMessage(ctx, length + headerLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16526, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ReadHsMessage fail", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
return;
}
}
static int32_t ReadEventInTransportingState(HITLS_Ctx *ctx, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
int32_t ret = 0;
int32_t unexpectMsgRet = 0;
do {
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
/* In UDP scenarios, the 2MSL timer expires */
ret = HS_CheckAndProcess2MslTimeout(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif
ret = APP_Read(ctx, data, bufSize, readLen);
if (ret == HITLS_SUCCESS) {
if ((!ctx->negotiatedInfo.isRenegotiation) && (ctx->hsCtx != NULL)) {
HS_DeInit(ctx);
}
/* An APP message is received */
break;
}
if (ret == HITLS_REC_NORMAL_RECV_UNEXPECT_MSG && REC_GetUnexpectedMsgType(ctx) == REC_TYPE_HANDSHAKE) {
unexpectMsgRet = PreprocessUnexpectHsMsg(ctx);
if (unexpectMsgRet != HITLS_SUCCESS) {
ConsumeHandshakeMessage(ctx);
HS_DeInit(ctx);
ret = unexpectMsgRet;
}
}
if (ALERT_GetFlag(ctx)) {
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
/* After the server sends a hello request, the status changes to transporting. In this case, the read
command is used to read the message. If the no_renegotiation alert is received, the connection
needs to be disconnected. */
if (ctx->userRenego) {
InnerRenegotiationProcess(ctx);
}
#endif
if (ALERT_HaveExceeded(ctx, MAX_ALERT_COUNT)) {
/* If multiple consecutive alerts exist, the link is abnormal and needs to be disconnected */
ALERT_Send(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
}
unexpectMsgRet = AlertEventProcess(ctx);
if (unexpectMsgRet != HITLS_SUCCESS) {
/* If the alert fails to be sent, a response is returned to the user for processing */
return unexpectMsgRet;
}
/* If fatal alert or close_notify has been processed, the link must be disconnected */
if (ctx->state == CM_STATE_ALERTED || ctx->state == CM_STATE_CLOSED) {
return ret;
}
}
if (ret != HITLS_REC_NORMAL_RECV_UNEXPECT_MSG) {
return ret;
}
unexpectMsgRet = RecvUnexpectMsgInTransportingStateProcess(ctx);
if (unexpectMsgRet != HITLS_SUCCESS) {
return unexpectMsgRet;
}
#ifdef HITLS_TLS_FEATURE_MODE_AUTO_RETRY
if ((ctx->config.tlsConfig.modeSupport & HITLS_MODE_AUTO_RETRY) == 0) {
return HITLS_REC_NORMAL_RECV_BUF_EMPTY;
}
#endif
} while (ret != HITLS_SUCCESS);
return ret;
}
static int32_t ReadEventInHandshakingState(HITLS_Ctx *ctx, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
int32_t ret = CommonEventInHandshakingState(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
return ReadEventInTransportingState(ctx, data, bufSize, readLen);
}
static int32_t ReadEventInRenegotiationState(HITLS_Ctx *ctx, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
int32_t ret = CommonEventInRenegotiationState(ctx);
if (ret != HITLS_SUCCESS) {
if (ret != HITLS_REC_NORMAL_RECV_UNEXPECT_MSG || ctx->state == CM_STATE_ALERTED) {
/* If an error is returned during the renegotiation, the error code must be sent to the user */
return ret;
}
/* The scenario is that the HITLS initiates renegotiation, but the peer end does not respond with a handshake
* message and continues to send the app message. In this case, you need to read the app message to prevent
* message blocking.
*/
ret = APP_Read(ctx, data, bufSize, readLen);
return ret;
}
return ReadEventInTransportingState(ctx, data, bufSize, readLen);
#else
(void)ctx;
(void)data;
(void)bufSize;
(void)readLen;
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15407, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
"invalid conn states %d", CM_STATE_RENEGOTIATION, NULL, NULL, NULL);
return HITLS_INTERNAL_EXCEPTION;
#endif
}
static int32_t ReadEventInAlertedState(HITLS_Ctx *ctx, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
(void)ctx;
(void)data;
(void)bufSize;
(void)readLen;
// A message indicating that the link status is abnormal is displayed.
return HITLS_CM_LINK_FATAL_ALERTED;
}
static int32_t ReadEventInClosedState(HITLS_Ctx *ctx, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
// Non-closed state
if ((ctx->shutdownState & HITLS_RECEIVED_SHUTDOWN) == 0) {
ALERT_CleanInfo(ctx);
int32_t ret = APP_Read(ctx, data, bufSize, readLen);
if (ret == HITLS_SUCCESS) {
return HITLS_SUCCESS;
}
// There is no alert message to be processed.
if (ALERT_GetFlag(ctx) == false) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16531, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Read fail", 0, 0, 0, 0);
return ret;
}
int32_t alertRet = AlertEventProcess(ctx);
if (alertRet != HITLS_SUCCESS) {
return alertRet;
}
/* Other warning alerts have been processed. */
if ((ctx->shutdownState & HITLS_RECEIVED_SHUTDOWN) == 0) {
return ret;
}
}
// Directly return to link closed.
return HITLS_CM_LINK_CLOSED;
}
static int32_t ReadProcess(HITLS_Ctx *ctx, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
ReadEventProcess readEventProcess[CM_STATE_END] = {
ReadEventInIdleState,
ReadEventInHandshakingState,
ReadEventInTransportingState,
ReadEventInRenegotiationState,
NULL,
ReadEventInAlertedState,
ReadEventInClosedState
};
if ((GetConnState(ctx) >= CM_STATE_END) || (GetConnState(ctx) == CM_STATE_ALERTING)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16532, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"internal exception occurs", 0, 0, 0, 0);
/* If the alert message is sent successfully, the system switches to another state. Otherwise, an internal
* exception occurs */
return HITLS_INTERNAL_EXCEPTION;
}
ReadEventProcess proc = readEventProcess[GetConnState(ctx)];
return proc(ctx, data, bufSize, readLen);
}
int32_t HITLS_Read(HITLS_Ctx *ctx, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
int32_t ret;
if (ctx == NULL || data == NULL || readLen == NULL) {
return HITLS_NULL_INPUT;
}
ctx->allowAppOut = true;
/* Process the unsent alert message first, and then enter the corresponding state processing function based on the
* processing result */
if (GetConnState(ctx) == CM_STATE_ALERTING) {
ret = CommonEventInAlertingState(ctx);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16533, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Alerting fail", 0, 0, 0, 0);
/* If the alert message fails to be sent, the system returns the message to the user for processing */
return ret;
}
}
return ReadProcess(ctx, data, bufSize, readLen);
}
int32_t HITLS_Peek(HITLS_Ctx *ctx, uint8_t *data, uint32_t bufSize, uint32_t *readLen)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
ctx->peekFlag = 1;
int32_t ret = HITLS_Read(ctx, data, bufSize, readLen);
ctx->peekFlag = 0;
return ret;
}
int32_t HITLS_ReadHasPending(const HITLS_Ctx *ctx, uint8_t *isPending)
{
if (ctx == NULL || isPending == NULL) {
return HITLS_NULL_INPUT;
}
*isPending = APP_GetReadPendingBytes(ctx) > 0 || REC_ReadHasPending(ctx) ? 1 : 0;
return HITLS_SUCCESS;
}
uint32_t HITLS_GetReadPendingBytes(const HITLS_Ctx *ctx)
{
return APP_GetReadPendingBytes(ctx);
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
int32_t HITLS_DtlsProcessTimeout(HITLS_Ctx *ctx)
{
if (ctx == NULL || ctx->hsCtx == NULL) {
return HITLS_NULL_INPUT;
}
bool isTimeout = false;
int32_t ret = HS_IsTimeout(ctx, &isTimeout);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17032, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"HS_IsTimeout fail", 0, 0, 0, 0);
return ret;
}
if (isTimeout) {
ret = HS_TimeoutProcess(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Receive the message of the last flight when the receiving times out */
ret = REC_RetransmitListFlush(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
return HITLS_SUCCESS;
}
return HITLS_MSG_HANDLE_DTLS_RETRANSMIT_NOT_TIMEOUT;
}
int32_t HITLS_DtlsGetTimeout(HITLS_Ctx *ctx, uint64_t *remainTimeOut)
{
if (ctx == NULL || ctx->hsCtx == NULL || remainTimeOut == NULL) {
return HITLS_NULL_INPUT;
}
*remainTimeOut = 0;
if (!BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_UDP) || ctx->hsCtx->timeoutValue == 0) {
return HITLS_MSG_HANDLE_ERR_WITHOUT_TIMEOUT_ACTION;
}
BSL_TIME curTime;
int32_t ret = BSL_SAL_SysTimeGet(&curTime);
if (ret != BSL_SUCCESS) {
return ret;
}
BSL_TIME endTime = ctx->hsCtx->deadline;
ret = BSL_SAL_DateTimeCompareByUs(&curTime, &endTime);
if (ret == BSL_TIME_DATE_AFTER || ret == BSL_TIME_CMP_EQUAL) {
return HITLS_SUCCESS;
} else if (ret == BSL_TIME_CMP_ERROR) {
return BSL_TIME_CMP_ERROR;
}
int64_t curUtcTime = 0;
int64_t endUtcTime = 0;
/* Convert the date into seconds. */
ret = BSL_SAL_DateToUtcTimeConvert(&curTime, &curUtcTime);
if (ret != BSL_SUCCESS) {
return ret;
}
ret = BSL_SAL_DateToUtcTimeConvert(&endTime, &endUtcTime);
if (ret != BSL_SUCCESS) {
return ret;
}
uint64_t remainSecTimeout = (uint64_t)(endUtcTime - curUtcTime);
if (remainSecTimeout >= DTLS_SPECIFY_MAX_TIMEOUT_VALUE) {
*remainTimeOut = DTLS_SPECIFY_MAX_TIMEOUT_VALUE * BSL_SECOND_TRANSFER_RATIO * BSL_SECOND_TRANSFER_RATIO;
return HITLS_SUCCESS;
}
uint64_t endMicroSec = endTime.millSec * BSL_SECOND_TRANSFER_RATIO + endTime.microSec;
uint64_t curMicroSec = curTime.millSec * BSL_SECOND_TRANSFER_RATIO + curTime.microSec;
*remainTimeOut = remainSecTimeout * BSL_SECOND_TRANSFER_RATIO * BSL_SECOND_TRANSFER_RATIO +
endMicroSec - curMicroSec;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_DTLS12 && HITLS_BSL_UIO_UDP */
| 2302_82127028/openHiTLS-examples_1508 | tls/cm/src/conn_read.c | C | unknown | 23,329 |
/*
* 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.
*/
#include "hitls_build.h"
#include "bsl_log_internal.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "bsl_log.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "tls.h"
#include "alert.h"
#include "app.h"
#include "conn_common.h"
#include "hs.h"
#include "hs_ctx.h"
#include "record.h"
int32_t HITLS_GetMaxWriteSize(const HITLS_Ctx *ctx, uint32_t *len)
{
if (ctx == NULL || len == NULL) {
return HITLS_NULL_INPUT;
}
return APP_GetMaxWriteSize(ctx, len);
}
static int32_t WriteEventInIdleState(HITLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t *writeLen)
{
(void)ctx;
(void)data;
(void)dataLen;
(void)writeLen;
return HITLS_CM_LINK_UNESTABLISHED;
}
static int32_t WriteEventInTransportingState(HITLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t *writeLen)
{
int32_t ret;
int32_t alertRet;
do {
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
/* In UDP scenarios, the 2MSL timer expires */
ret = HS_CheckAndProcess2MslTimeout(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif
ret = APP_Write(ctx, data, dataLen, writeLen);
if (ret == HITLS_SUCCESS) {
/* The message is sent successfully */
break;
}
if (!ALERT_GetFlag(ctx)) {
/* Failed to send a message but no alert is displayed */
break;
}
if (ALERT_HaveExceeded(ctx, MAX_ALERT_COUNT)) {
/* If multiple consecutive alerts exist, the link is abnormal and needs to be disconnected */
ALERT_Send(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
}
alertRet = AlertEventProcess(ctx);
if (alertRet != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16546, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"AlertEventProcess fail", 0, 0, 0, 0);
/* If the alert fails to be sent, a response is returned to the user */
return alertRet;
}
/* If fatal alert or close_notify has been processed, the link must be disconnected. */
if (ctx->state == CM_STATE_ALERTED) {
break;
}
} while (ret != HITLS_SUCCESS);
return ret;
}
static int32_t WriteEventInHandshakingState(HITLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t *writeLen)
{
// The link is being established. Therefore, the link establishment is triggered first. If the link is successfully
// established, the message is directly sent.
int32_t ret = CommonEventInHandshakingState(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
return WriteEventInTransportingState(ctx, data, dataLen, writeLen);
}
static int32_t WriteEventInRenegotiationState(HITLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t *writeLen)
{
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
int32_t ret;
if (ctx->recCtx->pendingData != NULL) {
// Send the app data first.
return WriteEventInTransportingState(ctx, data, dataLen, writeLen);
}
do {
/* If an unexpected message is received, the system ignores the return value and continues to establish a link.
* Otherwise, the system returns the return value to the user for processing */
ret = CommonEventInRenegotiationState(ctx);
} while (ret == HITLS_REC_NORMAL_RECV_UNEXPECT_MSG && ctx->state != CM_STATE_ALERTED);
if (ret != HITLS_SUCCESS) {
if (ctx->negotiatedInfo.isRenegotiation || (ret != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
/* If an error is returned during renegotiation, the error code must be sent to the user */
return ret;
}
/* The scenario is that the HITLS server initiates renegotiation, but the peer end does not respond with the
* client hello message. In this case,the app message needs to be sent to the peer end to prevent message
* blocking
*/
}
return WriteEventInTransportingState(ctx, data, dataLen, writeLen);
#else
(void)ctx;
(void)data;
(void)dataLen;
(void)writeLen;
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15583, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
"invalid conn states %d", CM_STATE_RENEGOTIATION, NULL, NULL, NULL);
return HITLS_INTERNAL_EXCEPTION;
#endif
}
static int32_t WriteEventInAlertedState(HITLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t *writeLen)
{
(void)ctx;
(void)data;
(void)dataLen;
(void)writeLen;
// Directly return a message indicating that the link status is abnormal.
return HITLS_CM_LINK_FATAL_ALERTED;
}
static int32_t WriteEventInClosedState(HITLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t *writeLen)
{
if ((ctx->shutdownState & HITLS_SENT_SHUTDOWN) == 0) {
ALERT_CleanInfo(ctx);
int ret = APP_Write(ctx, data, dataLen, writeLen);
if (ret == HITLS_SUCCESS || ret == HITLS_REC_NORMAL_IO_BUSY) {
return ret;
}
// There is no alert message to be processed.
if (ALERT_GetFlag(ctx) == false) {
return ret;
}
int32_t alertRet = AlertEventProcess(ctx);
if (alertRet != HITLS_SUCCESS) {
return alertRet;
}
return ret;
}
// Directly return a message indicating that the link status is abnormal.
return HITLS_CM_LINK_CLOSED;
}
#ifdef HITLS_TLS_FEATURE_PHA
int32_t CommonCheckPostHandshakeAuth(TLS_Ctx *ctx)
{
if (!ctx->isClient && ctx->phaState == PHA_PENDING && ctx->state == CM_STATE_TRANSPORTING) {
ChangeConnState(ctx, CM_STATE_HANDSHAKING);
return HS_CheckPostHandshakeAuth(ctx);
}
return HITLS_SUCCESS;
}
#endif
static int32_t HITLS_WritePreporcess(HITLS_Ctx *ctx)
{
int32_t ret = HITLS_SUCCESS;
/* Process the unsent alert message first, and then enter the corresponding state processing function based on the
* processing result */
if (GetConnState(ctx) == CM_STATE_ALERTING) {
ret = CommonEventInAlertingState(ctx);
if (ret != HITLS_SUCCESS) {
/* If the alert message fails to be sent, the system returns the message to the user for processing */
return ret;
}
}
#ifdef HITLS_TLS_FEATURE_PHA
return CommonCheckPostHandshakeAuth(ctx);
#else
return ret;
#endif
}
int32_t HITLS_Write(HITLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t *writeLen)
{
if (ctx == NULL || data == NULL || dataLen == 0 || writeLen == NULL) {
return HITLS_NULL_INPUT;
}
ctx->allowAppOut = false;
int32_t ret = HITLS_WritePreporcess(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
WriteEventProcess writeEventProcess[CM_STATE_END] = {
WriteEventInIdleState,
WriteEventInHandshakingState,
WriteEventInTransportingState,
WriteEventInRenegotiationState,
NULL,
WriteEventInAlertedState,
WriteEventInClosedState
};
if ((GetConnState(ctx) >= CM_STATE_END) || (GetConnState(ctx) == CM_STATE_ALERTING)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16548, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"internal exception occurs", 0, 0, 0, 0);
/* If the alert message is sent successfully, the system switches to another state. Otherwise, an internal
* exception occurs */
return HITLS_INTERNAL_EXCEPTION;
}
WriteEventProcess proc = writeEventProcess[GetConnState(ctx)];
ret = proc(ctx, data, dataLen, writeLen);
if (ret != HITLS_SUCCESS) {
*writeLen = 0;
}
return ret;
}
| 2302_82127028/openHiTLS-examples_1508 | tls/cm/src/conn_write.c | C | unknown | 8,203 |
/*
* 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 CONFIG_H
#define CONFIG_H
#include <stdint.h>
#include "bsl_log_internal.h"
#include "bsl_binlog_id.h"
#include "hitls_type.h"
#ifdef __cplusplus
extern "C" {
#endif
#define PROCESS_PARAM_INT32(tmpParam, paramObj, params, paramName, destField) \
do { \
(tmpParam) = BSL_PARAM_FindParam((BSL_Param *)(uintptr_t)(params), (paramName)); \
if ((tmpParam) == NULL || (tmpParam)->valueType != BSL_PARAM_TYPE_INT32) { \
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05075, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, \
"tls config: not found int32 param %s", #paramName, 0, 0, 0); \
goto ERR; \
} \
(paramObj)->destField = *(int32_t *)(tmpParam)->value; \
} while (0)
#define PROCESS_PARAM_UINT16(tmpParam, paramObj, params, paramName, destField) \
do { \
(tmpParam) = BSL_PARAM_FindParam((BSL_Param *)(uintptr_t)(params), (paramName)); \
if ((tmpParam) == NULL || (tmpParam)->valueType != BSL_PARAM_TYPE_UINT16) { \
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05076, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, \
"tls config: not found uint16 param %s", #paramName, 0, 0, 0); \
goto ERR; \
} \
(paramObj)->destField = *(uint16_t *)(tmpParam)->value; \
} while (0)
#define PROCESS_PARAM_UINT32(tmpParam, paramObj, params, paramName, destField) \
do { \
(tmpParam) = BSL_PARAM_FindParam((BSL_Param *)(uintptr_t)(params), (paramName)); \
if ((tmpParam) == NULL || (tmpParam)->valueType != BSL_PARAM_TYPE_UINT32) { \
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05077, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, \
"tls config: not found uint32 param %s", #paramName, 0, 0, 0); \
goto ERR; \
} \
(paramObj)->destField = *(uint32_t *)(tmpParam)->value; \
} while (0)
#define PROCESS_PARAM_BOOL(tmpParam, paramObj, params, paramName, destField) \
do { \
(tmpParam) = BSL_PARAM_FindParam((BSL_Param *)(uintptr_t)(params), (paramName)); \
if ((tmpParam) == NULL || (tmpParam)->valueType != BSL_PARAM_TYPE_BOOL) { \
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05078, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, \
"tls config: not found bool param %s", #paramName, 0, 0, 0); \
goto ERR; \
} \
(paramObj)->destField = *(bool *)(tmpParam)->value; \
} while (0)
#define PROCESS_STRING_PARAM(tmpParam, paramObj, params, paramName, destField) \
do { \
(tmpParam) = BSL_PARAM_FindParam((BSL_Param *)(uintptr_t)(params), (paramName)); \
if ((tmpParam) == NULL || (tmpParam)->valueType != BSL_PARAM_TYPE_OCTETS_PTR) { \
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05079, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, \
"tls config: not found string param %s", #paramName, 0, 0, 0); \
goto ERR; \
} \
(paramObj)->destField = BSL_SAL_Calloc((tmpParam)->valueLen + 1, sizeof(char)); \
if ((paramObj)->destField == NULL) { \
goto ERR; \
} \
(void)memcpy_s((paramObj)->destField, (tmpParam)->valueLen + 1, (tmpParam)->value, (tmpParam)->valueLen); \
} while (0)
#define PROCESS_OPTIONAL_STRING_PARAM(tmpParam, params, paramName, outString, outStringLen, nameParamName, outName) \
do { \
(tmpParam) = BSL_PARAM_FindParam((BSL_Param *)(uintptr_t)(params), (paramName)); \
if ((tmpParam) == NULL) { \
(outString) = NULL; \
} else if ((tmpParam)->valueType == BSL_PARAM_TYPE_OCTETS_PTR) { \
(outString) = (const char *)(tmpParam)->value; \
(outStringLen) = (tmpParam)->valueLen; \
(tmpParam) = BSL_PARAM_FindParam((BSL_Param *)(uintptr_t)(params), (nameParamName)); \
if ((tmpParam) == NULL || (tmpParam)->valueType != BSL_PARAM_TYPE_OCTETS_PTR) { \
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID05080, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, \
"tls config: not found optional string param %s", #nameParamName, 0, 0, 0); \
goto ERR; \
} \
(outName) = (const char *)(tmpParam)->value; \
} else { \
goto ERR; \
} \
} while (0)
/** clear the TLS configuration */
void CFG_CleanConfig(HITLS_Config *config);
/** copy the TLS configuration */
int32_t DumpConfig(HITLS_Ctx *ctx, const HITLS_Config *srcConfig);
#ifdef __cplusplus
}
#endif
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/config/include/config.h | C | unknown | 4,997 |
/*
* 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 CONFIG_CHECK_H
#define CONFIG_CHECK_H
#include <stdint.h>
#include "hitls_type.h"
#ifdef __cplusplus
extern "C" {
#endif
/** check the version */
int32_t CheckVersion(uint16_t minVersion, uint16_t maxVersion);
/** check whether the TLS configuration is valid */
int32_t CheckConfig(const HITLS_Config *config);
uint32_t MapVersion2VersionBit(bool isDatagram, uint16_t version);
#ifdef __cplusplus
}
#endif
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/config/include/config_check.h | C | unknown | 971 |
/*
* 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 CONFIG_TYPE_H
#define CONFIG_TYPE_H
#include <stdint.h>
#include "hitls_type.h"
#include "tls_config.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Load group information
* @param config: config context
* @return HITLS_SUCCESS: success, other: error
*/
int32_t ConfigLoadGroupInfo(HITLS_Config *config);
/**
* @brief Get group information
* @param config: config context
* @param groupId: group id
* @return group information
*/
const TLS_GroupInfo *ConfigGetGroupInfo(const HITLS_Config *config, uint16_t groupId);
/**
* @brief Get group information list
* @param config: config context
* @param size: size of group information list
* @return group information list
*/
const TLS_GroupInfo *ConfigGetGroupInfoList(const HITLS_Config *config, uint32_t *size);
/**
* @brief Load signature scheme information
* @param config: config context
* @return HITLS_SUCCESS: success, other: error
*/
int32_t ConfigLoadSignatureSchemeInfo(HITLS_Config *config);
/**
* @brief Get signature scheme information
* @param config: config context
* @param signatureScheme: signature scheme
* @return signature scheme information
*/
const TLS_SigSchemeInfo *ConfigGetSignatureSchemeInfo(const HITLS_Config *config, uint16_t signatureScheme);
/**
* @brief Get signature scheme information list
* @param config: config context
* @param size: size of signature scheme information list
* @return signature scheme information list
*/
const TLS_SigSchemeInfo *ConfigGetSignatureSchemeInfoList(const HITLS_Config *config, uint32_t *size);
#ifdef __cplusplus
}
#endif
#endif /* CONFIG_TYPE_H */
| 2302_82127028/openHiTLS-examples_1508 | tls/config/include/config_type.h | C | unknown | 2,163 |
/*
* 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.
*/
#include "hitls_build.h"
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "hitls_error.h"
#include "tls.h"
#include "tls_config.h"
#include "cipher_suite.h"
#include "config_type.h"
#ifndef HITLS_TLS_CONFIG_CIPHER_SUITE
#define CIPHER_NAME(name) NULL
#else
#define CIPHER_NAME(name) name
#endif
#define KEY_BLOCK_PARTITON_LENGTH(fixedIvLth, encKeyLth, macKeyLth, blockLth, recordIvLth, macLth) \
.fixedIvLength = (fixedIvLth), \
.encKeyLen = (encKeyLth), \
.macKeyLen = (macKeyLth), \
.blockLength = (blockLth), \
.recordIvLength = (recordIvLth), \
.macLen = (macLth) \
#define VERSION_SCOPE(minV, maxV, minDtlsV, maxDtlsV) \
.minVersion = (minV), \
.maxVersion = (maxV), \
.minDtlsVersion = (minDtlsV), \
.maxDtlsVersion = (maxDtlsV)
#ifdef HITLS_TLS_CONFIG_CIPHER_SUITE
#define CIPHERSUITE_DESCRIPTION_MAXLEN 128
#endif
/* If cipher suites need to be added in the future, you need to consider whether the cipher suites are suitable for DTLS
in terms of design. If DTLS is not supported, perform related operations. For example, the RC4 stream encryption
algorithm is not applicable to DTLS. */
static const CipherSuiteInfo g_cipherSuiteList[] = {
#ifdef HITLS_TLS_SUITE_AES_128_GCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_AES_128_GCM_SHA256"),
.stdName = CIPHER_NAME("TLS_AES_128_GCM_SHA256"),
.cipherSuite = HITLS_AES_128_GCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_GCM,
.kxAlg = HITLS_KEY_EXCH_NULL,
.authAlg = HITLS_AUTH_ANY,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(12u, 16u, 0u, 0u, 0u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS13, HITLS_VERSION_TLS13, 0u, 0u),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_AES_256_GCM_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_AES_256_GCM_SHA384"),
.stdName = CIPHER_NAME("TLS_AES_256_GCM_SHA384"),
.cipherSuite = HITLS_AES_256_GCM_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_GCM,
.kxAlg = HITLS_KEY_EXCH_NULL,
.authAlg = HITLS_AUTH_ANY,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(12u, 32u, 0u, 0u, 0u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS13, HITLS_VERSION_TLS13, 0u, 0u),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_CHACHA20_POLY1305_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_CHACHA20_POLY1305_SHA256"),
.stdName = CIPHER_NAME("TLS_CHACHA20_POLY1305_SHA256"),
.cipherSuite = HITLS_CHACHA20_POLY1305_SHA256,
.cipherAlg = HITLS_CIPHER_CHACHA20_POLY1305,
.kxAlg = HITLS_KEY_EXCH_NULL,
.authAlg = HITLS_AUTH_ANY,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(12u, 32u, 0u, 0u, 0u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS13, HITLS_VERSION_TLS13, 0u, 0u),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_AES_128_CCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_AES_128_CCM_SHA256"),
.stdName = CIPHER_NAME("TLS_AES_128_CCM_SHA256"),
.cipherSuite = HITLS_AES_128_CCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CCM,
.kxAlg = HITLS_KEY_EXCH_NULL,
.authAlg = HITLS_AUTH_ANY,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(12u, 16u, 0u, 0u, 0u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS13, HITLS_VERSION_TLS13, 0u, 0u),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_AES_128_CCM_8_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_AES_128_CCM_8_SHA256"),
.stdName = CIPHER_NAME("TLS_AES_128_CCM_8_SHA256"),
.cipherSuite = HITLS_AES_128_CCM_8_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CCM8,
.kxAlg = HITLS_KEY_EXCH_NULL,
.authAlg = HITLS_AUTH_ANY,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(12u, 16u, 0u, 0u, 0u, 8u),
VERSION_SCOPE(HITLS_VERSION_TLS13, HITLS_VERSION_TLS13, 0u, 0u),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_RSA_WITH_AES_128_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_WITH_AES_128_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_RSA_WITH_AES_128_CBC_SHA"),
.cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_RSA,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_RSA_WITH_AES_256_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_WITH_AES_256_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_RSA_WITH_AES_256_CBC_SHA"),
.cipherSuite = HITLS_RSA_WITH_AES_256_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_RSA,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_RSA_WITH_AES_128_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_WITH_AES_128_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_RSA_WITH_AES_128_CBC_SHA256"),
.cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_RSA,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_RSA_WITH_AES_256_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_WITH_AES_256_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_RSA_WITH_AES_256_CBC_SHA256"),
.cipherSuite = HITLS_RSA_WITH_AES_256_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_RSA,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_RSA_WITH_AES_128_GCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_WITH_AES_128_GCM_SHA256"),
.stdName = CIPHER_NAME("TLS_RSA_WITH_AES_128_GCM_SHA256"),
.cipherSuite = HITLS_RSA_WITH_AES_128_GCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_GCM,
.kxAlg = HITLS_KEY_EXCH_RSA,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_RSA_WITH_AES_256_GCM_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_WITH_AES_256_GCM_SHA384"),
.stdName = CIPHER_NAME("TLS_RSA_WITH_AES_256_GCM_SHA384"),
.cipherSuite = HITLS_RSA_WITH_AES_256_GCM_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_GCM,
.kxAlg = HITLS_KEY_EXCH_RSA,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_RSA_WITH_AES_128_GCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256"),
.stdName = CIPHER_NAME("TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"),
.cipherSuite = HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_GCM,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DHE_RSA_WITH_AES_256_GCM_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_RSA_WITH_AES_256_GCM_SHA384"),
.stdName = CIPHER_NAME("TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"),
.cipherSuite = HITLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_GCM,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"),
.cipherSuite = HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_ECDSA,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_ECDSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"),
.cipherSuite = HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_ECDSA,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_ECDSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"),
.cipherSuite = HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_ECDSA,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_ECDSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"),
.stdName = CIPHER_NAME("TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"),
.cipherSuite = HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_ECDSA,
.macAlg = HITLS_MAC_384,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_ECDSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 48u, 16u, 16u, 48u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"),
.stdName = CIPHER_NAME("TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"),
.cipherSuite = HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_GCM,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_ECDSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_ECDSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"),
.stdName = CIPHER_NAME("TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"),
.cipherSuite = HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_GCM,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_ECDSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_ECDSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_RSA_WITH_AES_128_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"),
.cipherSuite = HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_RSA_WITH_AES_256_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"),
.cipherSuite = HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_RSA_WITH_AES_128_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"),
.cipherSuite = HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_RSA_WITH_AES_256_CBC_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"),
.stdName = CIPHER_NAME("TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"),
.cipherSuite = HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_384,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 48u, 16u, 16u, 48u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_RSA_WITH_AES_128_GCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"),
.stdName = CIPHER_NAME("TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"),
.cipherSuite = HITLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_GCM,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_RSA_WITH_AES_256_GCM_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"),
.stdName = CIPHER_NAME("TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"),
.cipherSuite = HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_GCM,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"),
.stdName = CIPHER_NAME("TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"),
.cipherSuite = HITLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
.cipherAlg = HITLS_CIPHER_CHACHA20_POLY1305,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(12u, 32u, 0u, 0u, 0u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"),
.stdName = CIPHER_NAME("TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"),
.cipherSuite = HITLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
.cipherAlg = HITLS_CIPHER_CHACHA20_POLY1305,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_ECDSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_ECDSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(12u, 32u, 0u, 0u, 0u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256"),
.stdName = CIPHER_NAME("TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256"),
.cipherSuite = HITLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
.cipherAlg = HITLS_CIPHER_CHACHA20_POLY1305,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(12u, 32u, 0u, 0u, 0u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_DSS_WITH_AES_128_GCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_DSS_WITH_AES_128_GCM_SHA256"),
.stdName = CIPHER_NAME("TLS_DHE_DSS_WITH_AES_128_GCM_SHA256"),
.cipherSuite = HITLS_DHE_DSS_WITH_AES_128_GCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_GCM,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_DSS,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_DSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DHE_DSS_WITH_AES_256_GCM_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_DSS_WITH_AES_256_GCM_SHA384"),
.stdName = CIPHER_NAME("TLS_DHE_DSS_WITH_AES_256_GCM_SHA384"),
.cipherSuite = HITLS_DHE_DSS_WITH_AES_256_GCM_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_GCM,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_DSS,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_DSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_DSS_WITH_AES_128_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_DSS_WITH_AES_128_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_DHE_DSS_WITH_AES_128_CBC_SHA"),
.cipherSuite = HITLS_DHE_DSS_WITH_AES_128_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_DSS,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_DSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DHE_DSS_WITH_AES_256_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_DSS_WITH_AES_256_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_DHE_DSS_WITH_AES_256_CBC_SHA"),
.cipherSuite = HITLS_DHE_DSS_WITH_AES_256_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_DSS,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_DSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_DSS_WITH_AES_128_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_DSS_WITH_AES_128_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"),
.cipherSuite = HITLS_DHE_DSS_WITH_AES_128_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_DSS,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_DSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DHE_DSS_WITH_AES_256_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_DSS_WITH_AES_256_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"),
.cipherSuite = HITLS_DHE_DSS_WITH_AES_256_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_DSS,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_DSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_RSA_WITH_AES_128_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_RSA_WITH_AES_128_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_DHE_RSA_WITH_AES_128_CBC_SHA"),
.cipherSuite = HITLS_DHE_RSA_WITH_AES_128_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DHE_RSA_WITH_AES_256_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_RSA_WITH_AES_256_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_DHE_RSA_WITH_AES_256_CBC_SHA"),
.cipherSuite = HITLS_DHE_RSA_WITH_AES_256_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_RSA_WITH_AES_128_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_RSA_WITH_AES_128_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"),
.cipherSuite = HITLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DHE_RSA_WITH_AES_256_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_RSA_WITH_AES_256_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"),
.cipherSuite = HITLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
// psk nego
#ifdef HITLS_TLS_SUITE_PSK_WITH_AES_128_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_PSK_WITH_AES_128_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_PSK_WITH_AES_128_CBC_SHA"),
.cipherSuite = HITLS_PSK_WITH_AES_128_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_PSK_WITH_AES_256_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_PSK_WITH_AES_256_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_PSK_WITH_AES_256_CBC_SHA"),
.cipherSuite = HITLS_PSK_WITH_AES_256_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_PSK_WITH_AES_128_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_PSK_WITH_AES_128_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_DHE_PSK_WITH_AES_128_CBC_SHA"),
.cipherSuite = HITLS_DHE_PSK_WITH_AES_128_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DHE_PSK_WITH_AES_256_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_PSK_WITH_AES_256_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_DHE_PSK_WITH_AES_256_CBC_SHA"),
.cipherSuite = HITLS_DHE_PSK_WITH_AES_256_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_RSA_PSK_WITH_AES_128_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_PSK_WITH_AES_128_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_RSA_PSK_WITH_AES_128_CBC_SHA"),
.cipherSuite = HITLS_RSA_PSK_WITH_AES_128_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_RSA_PSK,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_RSA_PSK_WITH_AES_256_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_PSK_WITH_AES_256_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_RSA_PSK_WITH_AES_256_CBC_SHA"),
.cipherSuite = HITLS_RSA_PSK_WITH_AES_256_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_RSA_PSK,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_PSK_WITH_AES_128_GCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_PSK_WITH_AES_128_GCM_SHA256"),
.stdName = CIPHER_NAME("TLS_PSK_WITH_AES_128_GCM_SHA256"),
.cipherSuite = HITLS_PSK_WITH_AES_128_GCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_GCM,
.kxAlg = HITLS_KEY_EXCH_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_PSK_WITH_AES_256_GCM_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_PSK_WITH_AES_256_GCM_SHA384"),
.stdName = CIPHER_NAME("TLS_PSK_WITH_AES_256_GCM_SHA384"),
.cipherSuite = HITLS_PSK_WITH_AES_256_GCM_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_GCM,
.kxAlg = HITLS_KEY_EXCH_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_PSK_WITH_AES_256_CCM
{.enable = true,
.name = CIPHER_NAME("HITLS_PSK_WITH_AES_256_CCM"),
.stdName = CIPHER_NAME("TLS_PSK_WITH_AES_256_CCM"),
.cipherSuite = HITLS_PSK_WITH_AES_256_CCM,
.cipherAlg = HITLS_CIPHER_AES_256_CCM,
.kxAlg = HITLS_KEY_EXCH_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_PSK_WITH_AES_128_GCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_PSK_WITH_AES_128_GCM_SHA256"),
.stdName = CIPHER_NAME("TLS_DHE_PSK_WITH_AES_128_GCM_SHA256"),
.cipherSuite = HITLS_DHE_PSK_WITH_AES_128_GCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_GCM,
.kxAlg = HITLS_KEY_EXCH_DHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DHE_PSK_WITH_AES_256_GCM_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_PSK_WITH_AES_256_GCM_SHA384"),
.stdName = CIPHER_NAME("TLS_DHE_PSK_WITH_AES_256_GCM_SHA384"),
.cipherSuite = HITLS_DHE_PSK_WITH_AES_256_GCM_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_GCM,
.kxAlg = HITLS_KEY_EXCH_DHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_PSK_WITH_AES_128_CCM
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_PSK_WITH_AES_128_CCM"),
.stdName = CIPHER_NAME("TLS_DHE_PSK_WITH_AES_128_CCM"),
.cipherSuite = HITLS_DHE_PSK_WITH_AES_128_CCM,
.cipherAlg = HITLS_CIPHER_AES_128_CCM,
.kxAlg = HITLS_KEY_EXCH_DHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DHE_PSK_WITH_AES_256_CCM
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_PSK_WITH_AES_256_CCM"),
.stdName = CIPHER_NAME("TLS_DHE_PSK_WITH_AES_256_CCM"),
.cipherSuite = HITLS_DHE_PSK_WITH_AES_256_CCM,
.cipherAlg = HITLS_CIPHER_AES_256_CCM,
.kxAlg = HITLS_KEY_EXCH_DHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_RSA_PSK_WITH_AES_128_GCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_PSK_WITH_AES_128_GCM_SHA256"),
.stdName = CIPHER_NAME("TLS_RSA_PSK_WITH_AES_128_GCM_SHA256"),
.cipherSuite = HITLS_RSA_PSK_WITH_AES_128_GCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_GCM,
.kxAlg = HITLS_KEY_EXCH_RSA_PSK,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_RSA_PSK_WITH_AES_256_GCM_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_PSK_WITH_AES_256_GCM_SHA384"),
.stdName = CIPHER_NAME("TLS_RSA_PSK_WITH_AES_256_GCM_SHA384"),
.cipherSuite = HITLS_RSA_PSK_WITH_AES_256_GCM_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_GCM,
.kxAlg = HITLS_KEY_EXCH_RSA_PSK,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_PSK_WITH_AES_128_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_PSK_WITH_AES_128_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_PSK_WITH_AES_128_CBC_SHA256"),
.cipherSuite = HITLS_PSK_WITH_AES_128_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_PSK_WITH_AES_256_CBC_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_PSK_WITH_AES_256_CBC_SHA384"),
.stdName = CIPHER_NAME("TLS_PSK_WITH_AES_256_CBC_SHA384"),
.cipherSuite = HITLS_PSK_WITH_AES_256_CBC_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_384,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 48u, 16u, 16u, 48u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_PSK_WITH_AES_128_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_PSK_WITH_AES_128_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_DHE_PSK_WITH_AES_128_CBC_SHA256"),
.cipherSuite = HITLS_DHE_PSK_WITH_AES_128_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DHE_PSK_WITH_AES_256_CBC_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_PSK_WITH_AES_256_CBC_SHA384"),
.stdName = CIPHER_NAME("TLS_DHE_PSK_WITH_AES_256_CBC_SHA384"),
.cipherSuite = HITLS_DHE_PSK_WITH_AES_256_CBC_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_384,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 48u, 16u, 16u, 48u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_RSA_PSK_WITH_AES_128_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_PSK_WITH_AES_128_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_RSA_PSK_WITH_AES_128_CBC_SHA256"),
.cipherSuite = HITLS_RSA_PSK_WITH_AES_128_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_RSA_PSK,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_RSA_PSK_WITH_AES_256_CBC_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_PSK_WITH_AES_256_CBC_SHA384"),
.stdName = CIPHER_NAME("TLS_RSA_PSK_WITH_AES_256_CBC_SHA384"),
.cipherSuite = HITLS_RSA_PSK_WITH_AES_256_CBC_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_RSA_PSK,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_384,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 48u, 16u, 16u, 48u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_PSK_WITH_AES_128_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA"),
.cipherSuite = HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_PSK_WITH_AES_256_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA"),
.cipherSuite = HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_PSK_WITH_AES_128_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256"),
.cipherSuite = HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_PSK_WITH_AES_256_CBC_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384"),
.stdName = CIPHER_NAME("TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384"),
.cipherSuite = HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_384,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 48u, 16u, 16u, 48u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_PSK_WITH_CHACHA20_POLY1305_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_PSK_WITH_CHACHA20_POLY1305_SHA256"),
.stdName = CIPHER_NAME("TLS_PSK_WITH_CHACHA20_POLY1305_SHA256"),
.cipherSuite = HITLS_PSK_WITH_CHACHA20_POLY1305_SHA256,
.cipherAlg = HITLS_CIPHER_CHACHA20_POLY1305,
.kxAlg = HITLS_KEY_EXCH_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(12u, 32u, 0u, 0u, 0u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"),
.stdName = CIPHER_NAME("TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"),
.cipherSuite = HITLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256,
.cipherAlg = HITLS_CIPHER_CHACHA20_POLY1305,
.kxAlg = HITLS_KEY_EXCH_ECDHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(12u, 32u, 0u, 0u, 0u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256"),
.stdName = CIPHER_NAME("TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256"),
.cipherSuite = HITLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256,
.cipherAlg = HITLS_CIPHER_CHACHA20_POLY1305,
.kxAlg = HITLS_KEY_EXCH_DHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(12u, 32u, 0u, 0u, 0u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256"),
.stdName = CIPHER_NAME("TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256"),
.cipherSuite = HITLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256,
.cipherAlg = HITLS_CIPHER_CHACHA20_POLY1305,
.kxAlg = HITLS_KEY_EXCH_RSA_PSK,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(12u, 32u, 0u, 0u, 0u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_PSK_WITH_AES_128_CCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256"),
.stdName = CIPHER_NAME("TLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256"),
.cipherSuite = HITLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CCM,
.kxAlg = HITLS_KEY_EXCH_ECDHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_PSK_WITH_AES_128_GCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256"),
.stdName = CIPHER_NAME("TLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256"),
.cipherSuite = HITLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_GCM,
.kxAlg = HITLS_KEY_EXCH_ECDHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_PSK_WITH_AES_256_GCM_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384"),
.stdName = CIPHER_NAME("TLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384"),
.cipherSuite = HITLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_GCM,
.kxAlg = HITLS_KEY_EXCH_ECDHE_PSK,
.authAlg = HITLS_AUTH_PSK,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
/* Anonymous cipher suites support */
#ifdef HITLS_TLS_SUITE_DH_ANON_WITH_AES_128_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_DH_ANON_WITH_AES_128_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_DH_anon_WITH_AES_128_CBC_SHA"),
.cipherSuite = HITLS_DH_ANON_WITH_AES_128_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_NULL,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DH_ANON_WITH_AES_256_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_DH_ANON_WITH_AES_256_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_DH_anon_WITH_AES_256_CBC_SHA"),
.cipherSuite = HITLS_DH_ANON_WITH_AES_256_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_NULL,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_SSL30, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DH_ANON_WITH_AES_128_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DH_ANON_WITH_AES_128_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_DH_anon_WITH_AES_128_CBC_SHA256"),
.cipherSuite = HITLS_DH_ANON_WITH_AES_128_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_NULL,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DH_ANON_WITH_AES_256_CBC_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DH_ANON_WITH_AES_256_CBC_SHA256"),
.stdName = CIPHER_NAME("TLS_DH_anon_WITH_AES_256_CBC_SHA256"),
.cipherSuite = HITLS_DH_ANON_WITH_AES_256_CBC_SHA256,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_NULL,
.macAlg = HITLS_MAC_256,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DH_ANON_WITH_AES_128_GCM_SHA256
{.enable = true,
.name = CIPHER_NAME("HITLS_DH_ANON_WITH_AES_128_GCM_SHA256"),
.stdName = CIPHER_NAME("TLS_DH_anon_WITH_AES_128_GCM_SHA256"),
.cipherSuite = HITLS_DH_ANON_WITH_AES_128_GCM_SHA256,
.cipherAlg = HITLS_CIPHER_AES_128_GCM,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_NULL,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DH_ANON_WITH_AES_256_GCM_SHA384
{.enable = true,
.name = CIPHER_NAME("HITLS_DH_ANON_WITH_AES_256_GCM_SHA384"),
.stdName = CIPHER_NAME("TLS_DH_anon_WITH_AES_256_GCM_SHA384"),
.cipherSuite = HITLS_DH_ANON_WITH_AES_256_GCM_SHA384,
.cipherAlg = HITLS_CIPHER_AES_256_GCM,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_NULL,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_384,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDH_ANON_WITH_AES_128_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDH_ANON_WITH_AES_128_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_ECDH_anon_WITH_AES_128_CBC_SHA"),
.cipherSuite = HITLS_ECDH_ANON_WITH_AES_128_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_128_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_NULL,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDH_ANON_WITH_AES_256_CBC_SHA
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDH_ANON_WITH_AES_256_CBC_SHA"),
.stdName = CIPHER_NAME("TLS_ECDH_anon_WITH_AES_256_CBC_SHA"),
.cipherSuite = HITLS_ECDH_ANON_WITH_AES_256_CBC_SHA,
.cipherAlg = HITLS_CIPHER_AES_256_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_NULL,
.macAlg = HITLS_MAC_1,
.hashAlg = HITLS_HASH_SHA1,
.signScheme = CERT_SIG_SCHEME_UNKNOWN,
KEY_BLOCK_PARTITON_LENGTH(16u, 32u, 20u, 16u, 16u, 20u),
VERSION_SCOPE(HITLS_VERSION_TLS10, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_ECDSA_WITH_AES_128_CCM
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_ECDSA_WITH_AES_128_CCM"),
.stdName = CIPHER_NAME("TLS_ECDHE_ECDSA_WITH_AES_128_CCM"),
.cipherSuite = HITLS_ECDHE_ECDSA_WITH_AES_128_CCM,
.cipherAlg = HITLS_CIPHER_AES_128_CCM,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_ECDSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_ECDSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_ECDSA_WITH_AES_256_CCM
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_ECDSA_WITH_AES_256_CCM"),
.stdName = CIPHER_NAME("TLS_ECDHE_ECDSA_WITH_AES_256_CCM"),
.cipherSuite = HITLS_ECDHE_ECDSA_WITH_AES_256_CCM,
.cipherAlg = HITLS_CIPHER_AES_256_CCM,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_ECDSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_ECDSA_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_DHE_RSA_WITH_AES_128_CCM
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_RSA_WITH_AES_128_CCM"),
.stdName = CIPHER_NAME("TLS_DHE_RSA_WITH_AES_128_CCM"),
.cipherSuite = HITLS_DHE_RSA_WITH_AES_128_CCM,
.cipherAlg = HITLS_CIPHER_AES_128_CCM,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_DHE_RSA_WITH_AES_256_CCM
{.enable = true,
.name = CIPHER_NAME("HITLS_DHE_RSA_WITH_AES_256_CCM"),
.stdName = CIPHER_NAME("TLS_DHE_RSA_WITH_AES_256_CCM"),
.cipherSuite = HITLS_DHE_RSA_WITH_AES_256_CCM,
.cipherAlg = HITLS_CIPHER_AES_256_CCM,
.kxAlg = HITLS_KEY_EXCH_DHE,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_RSA_WITH_AES_128_CCM
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_WITH_AES_128_CCM"),
.stdName = CIPHER_NAME("TLS_RSA_WITH_AES_128_CCM"),
.cipherSuite = HITLS_RSA_WITH_AES_128_CCM,
.cipherAlg = HITLS_CIPHER_AES_128_CCM,
.kxAlg = HITLS_KEY_EXCH_RSA,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_RSA_WITH_AES_128_CCM_8
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_WITH_AES_128_CCM_8"),
.stdName = CIPHER_NAME("TLS_RSA_WITH_AES_128_CCM_8"),
.cipherSuite = HITLS_RSA_WITH_AES_128_CCM_8,
.cipherAlg = HITLS_CIPHER_AES_128_CCM8,
.kxAlg = HITLS_KEY_EXCH_RSA,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 8u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_RSA_WITH_AES_256_CCM
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_WITH_AES_256_CCM"),
.stdName = CIPHER_NAME("TLS_RSA_WITH_AES_256_CCM"),
.cipherSuite = HITLS_RSA_WITH_AES_256_CCM,
.cipherAlg = HITLS_CIPHER_AES_256_CCM,
.kxAlg = HITLS_KEY_EXCH_RSA,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_SUITE_RSA_WITH_AES_256_CCM_8
{.enable = true,
.name = CIPHER_NAME("HITLS_RSA_WITH_AES_256_CCM_8"),
.stdName = CIPHER_NAME("TLS_RSA_WITH_AES_256_CCM_8"),
.cipherSuite = HITLS_RSA_WITH_AES_256_CCM_8,
.cipherAlg = HITLS_CIPHER_AES_256_CCM8,
.kxAlg = HITLS_KEY_EXCH_RSA,
.authAlg = HITLS_AUTH_RSA,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SHA_256,
.signScheme = CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
KEY_BLOCK_PARTITON_LENGTH(4u, 32u, 0u, 0u, 8u, 8u),
VERSION_SCOPE(HITLS_VERSION_TLS12, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 256},
#endif
#ifdef HITLS_TLS_PROTO_TLCP11
#ifdef HITLS_TLS_SUITE_ECDHE_SM4_CBC_SM3
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_SM4_CBC_SM3"),
.stdName = CIPHER_NAME("TLS_ECDHE_SM4_CBC_SM3"),
.cipherSuite = HITLS_ECDHE_SM4_CBC_SM3,
.cipherAlg = HITLS_CIPHER_SM4_CBC,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_SM2,
.macAlg = HITLS_MAC_SM3,
.hashAlg = HITLS_HASH_SM3,
.signScheme = CERT_SIG_SCHEME_SM2_SM3,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLCP_DTLCP11, HITLS_VERSION_TLCP_DTLCP11, 0, 0),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECC_SM4_CBC_SM3
{.enable = true,
.name = CIPHER_NAME("HITLS_ECC_SM4_CBC_SM3"),
.stdName = CIPHER_NAME("TLS_ECC_SM4_CBC_SM3"),
.cipherSuite = HITLS_ECC_SM4_CBC_SM3,
.cipherAlg = HITLS_CIPHER_SM4_CBC,
.kxAlg = HITLS_KEY_EXCH_ECC,
.authAlg = HITLS_AUTH_SM2,
.macAlg = HITLS_MAC_SM3,
.hashAlg = HITLS_HASH_SM3,
.signScheme = CERT_SIG_SCHEME_SM2_SM3,
KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
VERSION_SCOPE(HITLS_VERSION_TLCP_DTLCP11, HITLS_VERSION_TLCP_DTLCP11, 0, 0),
.cipherType = HITLS_CBC_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECDHE_SM4_GCM_SM3
{.enable = true,
.name = CIPHER_NAME("HITLS_ECDHE_SM4_GCM_SM3"),
.stdName = CIPHER_NAME("TLS_ECDHE_SM4_GCM_SM3"),
.cipherSuite = HITLS_ECDHE_SM4_GCM_SM3,
.cipherAlg = HITLS_CIPHER_SM4_GCM,
.kxAlg = HITLS_KEY_EXCH_ECDHE,
.authAlg = HITLS_AUTH_SM2,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SM3,
.signScheme = CERT_SIG_SCHEME_SM2_SM3,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLCP_DTLCP11, HITLS_VERSION_TLCP_DTLCP11, 0, 0),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#ifdef HITLS_TLS_SUITE_ECC_SM4_GCM_SM3
{.enable = true,
.name = CIPHER_NAME("HITLS_ECC_SM4_GCM_SM3"),
.stdName = CIPHER_NAME("TLS_ECC_SM4_GCM_SM3"),
.cipherSuite = HITLS_ECC_SM4_GCM_SM3,
.cipherAlg = HITLS_CIPHER_SM4_GCM,
.kxAlg = HITLS_KEY_EXCH_ECC,
.authAlg = HITLS_AUTH_SM2,
.macAlg = HITLS_MAC_AEAD,
.hashAlg = HITLS_HASH_SM3,
.signScheme = CERT_SIG_SCHEME_SM2_SM3,
KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
VERSION_SCOPE(HITLS_VERSION_TLCP_DTLCP11, HITLS_VERSION_TLCP_DTLCP11, 0, 0),
.cipherType = HITLS_AEAD_CIPHER,
.strengthBits = 128},
#endif
#endif
};
const CipherSuiteCertType g_cipherSuiteAndCertTypes[] = {
{ HITLS_RSA_WITH_AES_128_CBC_SHA, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_WITH_AES_256_CBC_SHA, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_WITH_AES_128_CBC_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_WITH_AES_256_CBC_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_WITH_AES_128_GCM_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_WITH_AES_256_GCM_SHA384, CERT_TYPE_RSA_SIGN },
{ HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, CERT_TYPE_RSA_SIGN },
{ HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, CERT_TYPE_RSA_SIGN },
{ HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, CERT_TYPE_RSA_SIGN },
{ HITLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, CERT_TYPE_RSA_SIGN },
{ HITLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_DHE_RSA_WITH_AES_128_CBC_SHA, CERT_TYPE_RSA_SIGN },
{ HITLS_DHE_RSA_WITH_AES_256_CBC_SHA, CERT_TYPE_RSA_SIGN },
{ HITLS_DHE_RSA_WITH_AES_128_CBC_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_DHE_RSA_WITH_AES_256_CBC_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_DHE_RSA_WITH_AES_256_GCM_SHA384, CERT_TYPE_RSA_SIGN },
{ HITLS_DHE_RSA_WITH_AES_128_CCM, CERT_TYPE_RSA_SIGN },
{ HITLS_DHE_RSA_WITH_AES_256_CCM, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_WITH_AES_128_CCM, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_WITH_AES_128_CCM_8, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_WITH_AES_256_CCM, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_WITH_AES_256_CCM_8, CERT_TYPE_RSA_SIGN },
{ HITLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_PSK_WITH_AES_128_CBC_SHA, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_PSK_WITH_AES_256_CBC_SHA, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_PSK_WITH_AES_128_GCM_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_PSK_WITH_AES_256_GCM_SHA384, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_PSK_WITH_AES_128_CBC_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_PSK_WITH_AES_256_CBC_SHA384, CERT_TYPE_RSA_SIGN },
{ HITLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256, CERT_TYPE_RSA_SIGN },
{ HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, CERT_TYPE_ECDSA_SIGN },
{ HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, CERT_TYPE_ECDSA_SIGN },
{ HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, CERT_TYPE_ECDSA_SIGN },
{ HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, CERT_TYPE_ECDSA_SIGN },
{ HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, CERT_TYPE_ECDSA_SIGN },
{ HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, CERT_TYPE_ECDSA_SIGN },
{ HITLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, CERT_TYPE_ECDSA_SIGN },
{ HITLS_ECDHE_ECDSA_WITH_AES_128_CCM, CERT_TYPE_ECDSA_SIGN },
{ HITLS_ECDHE_ECDSA_WITH_AES_256_CCM, CERT_TYPE_ECDSA_SIGN },
{ HITLS_DHE_DSS_WITH_AES_128_CBC_SHA, CERT_TYPE_DSS_SIGN },
{ HITLS_DHE_DSS_WITH_AES_256_CBC_SHA, CERT_TYPE_DSS_SIGN },
{ HITLS_DHE_DSS_WITH_AES_128_CBC_SHA256, CERT_TYPE_DSS_SIGN },
{ HITLS_DHE_DSS_WITH_AES_256_CBC_SHA256, CERT_TYPE_DSS_SIGN },
{ HITLS_DHE_DSS_WITH_AES_128_GCM_SHA256, CERT_TYPE_DSS_SIGN },
{ HITLS_DHE_DSS_WITH_AES_256_GCM_SHA384, CERT_TYPE_DSS_SIGN },
{ HITLS_ECDHE_SM4_CBC_SM3, CERT_TYPE_ECDSA_SIGN },
{ HITLS_ECC_SM4_CBC_SM3, CERT_TYPE_ECDSA_SIGN },
{ HITLS_ECDHE_SM4_GCM_SM3, CERT_TYPE_ECDSA_SIGN },
{ HITLS_ECC_SM4_GCM_SM3, CERT_TYPE_ECDSA_SIGN },
};
/**
* @brief Obtain the cipher suite information
*
* @param cipherSuite [IN] Cipher suite of the information to be obtained
* @param cipherInfo [OUT] Cipher suite information
*
* @retval HITLS_SUCCESS obtained successfully
* @retval HITLS_INTERNAL_EXCEPTION Unexpected internal error
* @retval HITLS_MEMCPY_FAIL memcpy_s failed to be executed.
* @retval HITLS_CONFIG_UNSUPPORT_CIPHER_SUITE No information about the cipher suite is found.
*/
int32_t CFG_GetCipherSuiteInfo(uint16_t cipherSuite, CipherSuiteInfo *cipherInfo)
{
if (cipherInfo == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15858, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CFG:cipherInfo is NULL.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
return HITLS_INTERNAL_EXCEPTION;
}
/* Obtain the cipher suite information. If the cipher suite information is successfully obtained, a response is
* returned. */
for (uint32_t i = 0; i < (sizeof(g_cipherSuiteList) / sizeof(g_cipherSuiteList[0])); i++) {
if (g_cipherSuiteList[i].cipherSuite == cipherSuite) {
if (g_cipherSuiteList[i].enable == false) {
break;
}
int32_t ret = memcpy_s(cipherInfo, sizeof(CipherSuiteInfo), &g_cipherSuiteList[i], sizeof(CipherSuiteInfo));
if (ret != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15859, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CFG:memcpy failed.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
return HITLS_SUCCESS;
}
}
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15860, BSL_LOG_LEVEL_DEBUG, BSL_LOG_BINLOG_TYPE_RUN,
"CFG: [0x%x]cipher suite is not supported.", cipherSuite, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_UNSUPPORT_CIPHER_SUITE);
return HITLS_CONFIG_UNSUPPORT_CIPHER_SUITE;
}
/**
* @brief Check whether the input cipher suite is supported.
*
* @param cipherSuite [IN] Cipher suite to be checked
*
* @retval true support
* @retval false Not supported
*/
bool CFG_CheckCipherSuiteSupported(uint16_t cipherSuite)
{ /** @alias Check the suite and return true if supported. */
for (uint32_t i = 0; i < (sizeof(g_cipherSuiteList) / sizeof(g_cipherSuiteList[0])); i++) {
if (cipherSuite == g_cipherSuiteList[i].cipherSuite) {
return g_cipherSuiteList[i].enable;
}
}
return false;
}
/** Check whether the version is within the allowed range */
static bool CheckTlsVersionInRange(uint16_t cipherMinVersion, uint16_t cipherMaxVersion,
uint16_t cfgMinVersion, uint16_t cfgMaxVersion)
{
if ((cipherMaxVersion < cfgMinVersion) || (cipherMinVersion > cfgMaxVersion)) {
return false;
}
return true;
}
/** Check whether the version of the TLCP is within the allowed range */
static bool CheckTLCPVersionInRange(uint16_t version, uint16_t minVersion, uint16_t maxVersion)
{
return (version >= minVersion) && (version <= maxVersion);
}
/** Check whether the version is within the allowed range. (DTLS version numbers are sorted in reverse order. For
* example, DTLS 1.2 is greater than DTLS 1.3 */
static bool CheckDtlsVersionInRange(uint16_t cipherMinVersion, uint16_t cipherMaxVersion,
uint16_t cfgMinVersion, uint16_t cfgMaxVersion)
{
if ((cipherMaxVersion > cfgMinVersion) || (cipherMinVersion < cfgMaxVersion)) {
return false;
}
return true;
}
/**
* @brief Check whether the input cipher suite complies with the version
*
* @param cipherSuite [IN] Cipher suite to be checked
* minVersion [IN] Indicates the earliest version of the cipher suite
* maxVersion [IN] Indicates the latest version of the cipher suite
*
* @retval true support
* @retval false Not supported
*/
bool CFG_CheckCipherSuiteVersion(uint16_t cipherSuite, uint16_t minVersion, uint16_t maxVersion)
{
const CipherSuiteInfo *suiteInfo = NULL;
/** @alias Check the suite and return true if supported. */
for (uint32_t i = 0; i < (sizeof(g_cipherSuiteList) / sizeof(g_cipherSuiteList[0])); i++) {
suiteInfo = &g_cipherSuiteList[i];
if (cipherSuite == suiteInfo->cipherSuite) { /** tlcp max version equal min version */
return CheckTlsVersionInRange(suiteInfo->minVersion, suiteInfo->maxVersion, minVersion, maxVersion) ||
CheckDtlsVersionInRange(suiteInfo->minDtlsVersion, suiteInfo->maxDtlsVersion, minVersion, maxVersion) ||
CheckTLCPVersionInRange(minVersion, suiteInfo->minVersion, suiteInfo->maxVersion) ||
CheckTLCPVersionInRange(maxVersion, suiteInfo->minVersion, suiteInfo->maxVersion);
}
}
return false;
}
/**
* @brief Obtain the signature algorithm and hash algorithm by combining the parameters of the signature hash
* algorithm.
*
* @param ctx [IN] HITLS context
* @param scheme [IN] Signature and hash algorithm combination
* @param signAlg [OUT] Signature algorithm
* @param hashAlg [OUT] Hash algorithm
*
* @retval true Obtained successfully.
* @retval false Obtaining failed.
*/
bool CFG_GetSignParamBySchemes(const HITLS_Ctx *ctx, HITLS_SignHashAlgo scheme, HITLS_SignAlgo *signAlg,
HITLS_HashAlgo *hashAlg)
{
if (ctx == NULL || signAlg == NULL || hashAlg == NULL) {
return false;
}
const TLS_SigSchemeInfo *info = ConfigGetSignatureSchemeInfo(&ctx->config.tlsConfig, scheme);
if (info == NULL) {
return false;
}
*signAlg = info->signAlgId;
*hashAlg = info->hashAlgId;
return true;
}
/**
* @brief get the group name of the signature algorithm
* @param ctx [IN] HITLS context
* @param scheme [IN] signature algorithm
*
* @retval group name
*/
HITLS_NamedGroup CFG_GetEcdsaCurveNameBySchemes(const HITLS_Ctx *ctx, HITLS_SignHashAlgo scheme)
{
const TLS_SigSchemeInfo *info = ConfigGetSignatureSchemeInfo(&ctx->config.tlsConfig, scheme);
if (info == NULL) {
return HITLS_NAMED_GROUP_BUTT;
}
uint32_t groupInfoNum = 0;
const TLS_GroupInfo *groupInfo = ConfigGetGroupInfoList(&ctx->config.tlsConfig, &groupInfoNum);
if (groupInfo == NULL || groupInfoNum == 0) {
return HITLS_NAMED_GROUP_BUTT;
}
for (uint32_t i = 0; i < groupInfoNum; i++) {
if (groupInfo[i].paraId == info->paraId) {
return groupInfo[i].groupId;
}
}
return HITLS_NAMED_GROUP_BUTT;
}
/**
* @brief Obtain the certificate type based on the cipher suite
*
* @param cipherSuite [IN] Cipher suite
*
* @return Certificate type corresponding to the cipher suite
*/
uint8_t CFG_GetCertTypeByCipherSuite(uint16_t cipherSuite)
{
for (uint32_t i = 0; i < (sizeof(g_cipherSuiteAndCertTypes) / sizeof(g_cipherSuiteAndCertTypes[0])); i++) {
if (cipherSuite == g_cipherSuiteAndCertTypes[i].cipherSuite) {
return g_cipherSuiteAndCertTypes[i].certType;
}
}
return CERT_TYPE_UNKNOWN;
}
#ifdef HITLS_TLS_CONFIG_CIPHER_SUITE
/* Convert the supported version number to the corresponding character string */
static const uint8_t* ProtocolToString(uint16_t version)
{
const char *ret = NULL;
switch (version) {
case HITLS_VERSION_TLS12:
ret = "TLSv1.2";
break;
case HITLS_VERSION_TLS13:
ret = "TLSv1.3";
break;
case HITLS_VERSION_DTLS10:
ret = "DTLSv1";
break;
case HITLS_VERSION_DTLS12:
ret = "DTLSv1.2";
break;
case HITLS_VERSION_TLCP_DTLCP11:
ret = "(D)TLCP1.1";
break;
default:
ret = "unknown";
break;
}
return (const uint8_t *)ret;
}
/* Convert the server authorization algorithm type to the corresponding character string */
static const uint8_t* AuthAlgToString(HITLS_AuthAlgo authAlg)
{
const char *ret = NULL;
switch (authAlg) {
case HITLS_AUTH_RSA:
ret = "RSA";
break;
case HITLS_AUTH_ECDSA:
ret = "ECDSA";
break;
case HITLS_AUTH_DSS:
ret = "DSS";
break;
case HITLS_AUTH_SM2:
ret = "SM2";
break;
default:
ret = "unknown";
break;
}
return (const uint8_t *)ret;
}
/* Convert the key exchange algorithm type to the corresponding character string */
static const uint8_t* KeyExchAlgToString(HITLS_KeyExchAlgo kxAlg)
{
const char *ret = NULL;
switch (kxAlg) {
case HITLS_KEY_EXCH_ECDHE:
ret = "ECDHE";
break;
case HITLS_KEY_EXCH_DHE:
ret = "DHE";
break;
case HITLS_KEY_EXCH_ECDH:
ret = "ECDH";
break;
case HITLS_KEY_EXCH_DH:
ret = "DH";
break;
case HITLS_KEY_EXCH_RSA:
ret = "RSA";
break;
case HITLS_KEY_EXCH_PSK:
ret = "PSK";
break;
case HITLS_KEY_EXCH_ECC:
ret = "ECC";
break;
default:
ret = "unknown";
break;
}
return (const uint8_t *)ret;
}
/* Convert the MAC algorithm type to the corresponding character string */
static const uint8_t* MacAlgToString(HITLS_MacAlgo macAlg)
{
const char *ret = NULL;
switch (macAlg) {
case HITLS_MAC_1:
ret = "SHA1";
break;
case HITLS_MAC_256:
ret = "SHA256";
break;
case HITLS_MAC_384:
ret = "SHA384";
break;
case HITLS_MAC_512:
ret = "SHA512";
break;
case HITLS_MAC_AEAD:
ret = "AEAD";
break;
case HITLS_MAC_SM3:
ret = "SM3";
break;
default:
ret = "unknown";
break;
}
return (const uint8_t *)ret;
}
/* Convert the hash algorithm type to the corresponding character string */
static const uint8_t* HashAlgToString(HITLS_HashAlgo hashAlg)
{
const char *ret = NULL;
switch (hashAlg) {
case HITLS_HASH_MD5:
ret = "MD5";
break;
case HITLS_HASH_SHA1:
ret = "SHA1";
break;
case HITLS_HASH_SHA_256:
ret = "SHA256";
break;
case HITLS_HASH_SHA_384:
ret = "SHA384";
break;
case HITLS_HASH_SHA_512:
ret = "SHA512";
break;
case HITLS_HASH_SM3:
ret = "SM3";
break;
default:
ret = "unknown";
break;
}
return (const uint8_t *)ret;
}
/* Search the corresponding index in the table based on the cipher suite. If the cipher suite is invalid,
* CIPHER_SUITE_NOT_EXIST is returned */
static int32_t FindCipherSuiteIndexByCipherSuite(const uint16_t cipherSuite)
{
uint32_t i;
for (i = 0; i < sizeof(g_cipherSuiteList) / sizeof(CipherSuiteInfo); i++) {
if (g_cipherSuiteList[i].cipherSuite == cipherSuite) {
return (int32_t)i;
}
}
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_UNSUPPORT_CIPHER_SUITE);
return HITLS_CONFIG_UNSUPPORT_CIPHER_SUITE;
}
static int32_t GetCipherSuiteDescription(const CipherSuiteInfo *cipherSuiteInfo, uint8_t *buf, int len)
{
if (cipherSuiteInfo == NULL || buf == NULL || len < CIPHERSUITE_DESCRIPTION_MAXLEN) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
const uint8_t *ver, *kx, *au, *hash, *mac;
static const char *format = "%-30s %-7s Kx=%-8s Au=%-5s Hash=%-22s Mac=%-4s\n";
ver = ProtocolToString(cipherSuiteInfo->minVersion);
kx = KeyExchAlgToString(cipherSuiteInfo->kxAlg);
au = AuthAlgToString(cipherSuiteInfo->authAlg);
mac = MacAlgToString(cipherSuiteInfo->macAlg);
hash = HashAlgToString(cipherSuiteInfo->hashAlg);
int32_t ret = snprintf_s((char *)buf, CIPHERSUITE_DESCRIPTION_MAXLEN, CIPHERSUITE_DESCRIPTION_MAXLEN,
format, cipherSuiteInfo->name, ver, kx, au, hash, mac);
if (ret < 0 || ret > CIPHERSUITE_DESCRIPTION_MAXLEN - 1) {
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_LENGTH);
return HITLS_CONFIG_INVALID_LENGTH;
}
return HITLS_SUCCESS;
}
/**
* @brief Obtain the Symmetric-key algorithm type based on the cipher suite
*
* @param cipher[IN] Cipher suite
* @param cipherAlg [OUT] Obtained Symmetric-key algorithm type.
* @retval HITLS_SUCCESS succeeded
* @retval For other error codes, see hitls_error.h.
*/
int32_t HITLS_CFG_GetCipherId(const HITLS_Cipher *cipher, HITLS_CipherAlgo *cipherAlg)
{
if (cipher == NULL || cipherAlg == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
*cipherAlg = cipher->cipherAlg;
return HITLS_SUCCESS;
}
/**
* @brief Obtain the hash algorithm type based on the cipher suite.
*
* @param cipher [IN] Cipher suite
* @param hashAlg [OUT] Obtained hash algorithm type
* @retval HITLS_SUCCESS succeeded
* @retval For other error codes, see hitls_error.h
*/
int32_t HITLS_CFG_GetHashId(const HITLS_Cipher *cipher, HITLS_HashAlgo *hashAlg)
{
if (cipher == NULL || hashAlg == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
*hashAlg = cipher->hashAlg;
return HITLS_SUCCESS;
}
/**
* @brief Obtain the MAC algorithm type based on the cipher suite.
*
* @param cipher [IN] Cipher suite
* @param macAlg [OUT] Obtained MAC algorithm type.
* @retval HITLS_SUCCESS succeeded
* @retval For other error codes, see hitls_error.h
*/
int32_t HITLS_CFG_GetMacId(const HITLS_Cipher *cipher, HITLS_MacAlgo *macAlg)
{
if (cipher == NULL || macAlg == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
*macAlg = cipher->macAlg;
return HITLS_SUCCESS;
}
/**
* @brief Obtain the server authorization algorithm type based on the cipher suite
*
* @param cipher [IN] Cipher suite
* @param authAlg [OUT] Obtained server authorization type.
* @retval HITLS_SUCCESS succeeded
* @retval For other error codes, see hitls_error.h.
*/
int32_t HITLS_CFG_GetAuthId(const HITLS_Cipher *cipher, HITLS_AuthAlgo *authAlg)
{
if (cipher == NULL || authAlg == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
*authAlg = cipher->authAlg;
return HITLS_SUCCESS;
}
/**
* @brief Obtain the key exchange algorithm type based on the cipher suite.
*
* @param cipher [IN] Cipher suite
* @param kxAlg [OUT] Obtained key exchange algorithm type.
* @retval HITLS_SUCCESS succeeded
* @retval For other error codes, see hitls_error.h.
*/
int32_t HITLS_CFG_GetKeyExchId(const HITLS_Cipher *cipher, HITLS_KeyExchAlgo *kxAlg)
{
if (cipher == NULL || kxAlg == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
*kxAlg = cipher->kxAlg;
return HITLS_SUCCESS;
}
/**
* @brief Obtain the cipher suite name based on the cipher suite.
*
* @param cipher [IN] Cipher suite
* @retval "(NONE)" Invalid cipher suite.
* @retval Name of the given cipher suite
*/
const uint8_t* HITLS_CFG_GetCipherSuiteName(const HITLS_Cipher *cipher)
{
if (cipher == NULL) {
return (const uint8_t *)"(NONE)";
}
return (const uint8_t *)cipher->name;
}
/**
* @brief Obtain the RFC standard name of the cipher suite based on the cipher suite.
*
* @param cipher [IN] Cipher suite
*
* @retval "(NONE)" Invalid cipher suite.
* @retval RFC standard name for the given cipher suite
*/
const uint8_t* HITLS_CFG_GetCipherSuiteStdName(const HITLS_Cipher *cipher)
{
if (cipher == NULL) {
return (const uint8_t *)"(NONE)";
}
return (const uint8_t *)cipher->stdName;
}
static int32_t FindCipherSuiteIndexByStdName(const uint8_t* stdName)
{
for (uint32_t i = 0; i < sizeof(g_cipherSuiteList) / sizeof(CipherSuiteInfo); i++) {
if (strncmp(g_cipherSuiteList[i].stdName, (const char *)stdName, strlen(g_cipherSuiteList[i].stdName) + 1) ==
0) {
return (int32_t)i;
}
}
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_UNSUPPORT_CIPHER_SUITE);
return HITLS_CONFIG_UNSUPPORT_CIPHER_SUITE;
}
const HITLS_Cipher* HITLS_CFG_GetCipherSuiteByStdName(const uint8_t* stdName)
{
if (stdName == NULL) {
return NULL;
}
int32_t index = FindCipherSuiteIndexByStdName(stdName);
if (index == HITLS_CONFIG_UNSUPPORT_CIPHER_SUITE) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16549, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"No proper cipher suite", 0, 0, 0, 0);
return NULL;
}
return &g_cipherSuiteList[index];
}
/**
* @brief Obtain the earliest TLS version supported by the cipher suite based on the cipher suite.
*
* @param cipher [IN] Cipher suite
* @param version [OUT] Obtain the earliest TLS version supported by the cipher suite.
* @retval HITLS_SUCCESS succeeded
* @retval For other error codes, see hitls_error.h.
*/
int32_t HITLS_CFG_GetCipherVersion(const HITLS_Cipher *cipher, int32_t *version)
{
if (cipher == NULL || version == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
*version = cipher->minVersion;
return HITLS_SUCCESS;
}
/**
* @brief Output the description of the cipher suite as a character string.
*
* @param cipherSuite [IN] Cipher suite
* @param buf [OUT] Output the description.
* @param len [IN] Description length
* @retval NULL Failed to obtain the description.
* @retval Description of the cipher suite
*/
int32_t HITLS_CFG_GetDescription(const HITLS_Cipher *cipher, uint8_t *buf, int32_t len)
{
return GetCipherSuiteDescription(cipher, buf, len);
}
/**
* @brief Determine whether to use the AEAD algorithm based on the cipher suite information.
*
* @param cipher [IN] Cipher suite information
* @param isAead [OUT] Indicates whether to use the AEAD algorithm.
* @return HITLS_SUCCESS Obtained successfully.
* HITLS_NULL_INPUT The input parameter pointer is NULL.
*/
int32_t HITLS_CIPHER_IsAead(const HITLS_Cipher *cipher, uint8_t *isAead)
{
if (cipher == NULL || isAead == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
*isAead = (cipher->cipherType == HITLS_AEAD_CIPHER);
return HITLS_SUCCESS;
}
const HITLS_Cipher *HITLS_CFG_GetCipherByID(uint16_t cipherSuite)
{
int32_t index = FindCipherSuiteIndexByCipherSuite(cipherSuite);
if (index == HITLS_CONFIG_UNSUPPORT_CIPHER_SUITE) {
return NULL;
}
return &g_cipherSuiteList[index];
}
int32_t HITLS_CFG_GetCipherSuite(const HITLS_Cipher *cipher, uint16_t *cipherSuite)
{
if (cipher == NULL || cipherSuite == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
*cipherSuite = cipher->cipherSuite;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_CONFIG_CIPHER_SUITE */ | 2302_82127028/openHiTLS-examples_1508 | tls/config/src/cipher_suite.c | C | unknown | 92,874 |
/*
* 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.
*/
#include <stdint.h>
#include <stdbool.h>
#include "hitls_build.h"
#include "securec.h"
#include "bsl_log_internal.h"
#include "bsl_err_internal.h"
#include "bsl_log.h"
#include "bsl_sal.h"
#include "bsl_list.h"
#include "hitls_type.h"
#include "hitls_error.h"
#ifdef HITLS_TLS_FEATURE_PSK
#include "hitls_psk.h"
#endif
#ifdef HITLS_TLS_FEATURE_ALPN
#include "hitls_alpn.h"
#endif
#include "hitls_cert_type.h"
#ifdef HITLS_TLS_FEATURE_SNI
#include "hitls_sni.h"
#endif
#include "tls.h"
#include "tls_binlog_id.h"
#include "cert.h"
#include "crypt.h"
#ifdef HITLS_TLS_FEATURE_SESSION
#include "session_mgr.h"
#endif
#include "config_check.h"
#include "config_default.h"
#include "bsl_list.h"
#include "rec.h"
#include "hitls_cookie.h"
#include "cert_method.h"
#ifdef HITLS_TLS_FEATURE_SECURITY
#include "security.h"
#endif
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
#include "custom_extensions.h"
#endif
#ifdef HITLS_TLS_CONFIG_CIPHER_SUITE
/* Define the upper limit of the group type */
#define MAX_GROUP_TYPE_NUM 128u
#endif
#ifdef HITLS_TLS_FEATURE_MAX_SEND_FRAGMENT
#define MAX_PLAINTEXT_LEN 16384u
#define MIN_MAX_SEND_FRAGMENT 512u
#endif
#ifdef HITLS_TLS_FEATURE_REC_INBUFFER_SIZE
#define MAX_INBUFFER_SIZE 18432u
#define MIN_INBUFFER_SIZE 512u
#endif
void CFG_CleanConfig(HITLS_Config *config)
{
BSL_SAL_FREE(config->cipherSuites);
#ifdef HITLS_TLS_PROTO_TLS13
BSL_SAL_FREE(config->tls13CipherSuites);
#endif
BSL_SAL_FREE(config->pointFormats);
BSL_SAL_FREE(config->groups);
BSL_SAL_FREE(config->signAlgorithms);
#ifdef HITLS_TLS_FEATURE_PROVIDER
for (uint32_t i = 0; i < config->groupInfolen; i++) {
BSL_SAL_FREE(config->groupInfo[i].name);
}
BSL_SAL_FREE(config->groupInfo);
config->groupInfoSize = 0;
config->groupInfolen = 0;
for (uint32_t i = 0; i < config->sigSchemeInfolen; i++) {
BSL_SAL_FREE(config->sigSchemeInfo[i].name);
}
BSL_SAL_FREE(config->sigSchemeInfo);
config->sigSchemeInfoSize = 0;
config->sigSchemeInfolen = 0;
#endif
#if defined(HITLS_TLS_PROTO_TLS12) && defined(HITLS_TLS_FEATURE_PSK)
BSL_SAL_FREE(config->pskIdentityHint);
#endif
#ifdef HITLS_TLS_FEATURE_ALPN
BSL_SAL_FREE(config->alpnList);
#endif
#ifdef HITLS_TLS_FEATURE_SNI
BSL_SAL_FREE(config->serverName);
#endif
#ifdef HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES
HITLS_CFG_ClearCAList(config);
#endif /* HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES */
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
SAL_CRYPT_FreeDhKey(config->dhTmp);
config->dhTmp = NULL;
#endif
#ifdef HITLS_TLS_FEATURE_SESSION
SESSMGR_Free(config->sessMgr);
config->sessMgr = NULL;
#endif
SAL_CERT_MgrCtxFree(config->certMgrCtx);
config->certMgrCtx = NULL;
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
FreeCustomExtensions(config->customExts);
config->customExts = NULL;
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
BSL_SAL_ReferencesFree(&(config->references));
}
static void ShallowCopy(HITLS_Ctx *ctx, const HITLS_Config *srcConfig)
{
HITLS_Config *destConfig = &ctx->config.tlsConfig;
/*
* Other parameters except CipherSuite, PointFormats, Group, SignAlgorithms, Psk, SessionId, CertMgr, and SessMgr
* are shallowly copied, and some of them reference globalConfig.
*/
destConfig->libCtx = LIBCTX_FROM_CONFIG(srcConfig);
destConfig->attrName = ATTRIBUTE_FROM_CONFIG(srcConfig);
destConfig->minVersion = srcConfig->minVersion;
destConfig->maxVersion = srcConfig->maxVersion;
destConfig->isQuietShutdown = srcConfig->isQuietShutdown;
destConfig->isSupportServerPreference = srcConfig->isSupportServerPreference;
destConfig->maxCertList = srcConfig->maxCertList;
destConfig->isSupportExtendMasterSecret = srcConfig->isSupportExtendMasterSecret;
destConfig->emptyRecordsNum = srcConfig->emptyRecordsNum;
destConfig->isKeepPeerCert = srcConfig->isKeepPeerCert;
destConfig->version = srcConfig->version;
destConfig->originVersionMask = srcConfig->originVersionMask;
#ifdef HITLS_TLS_PROTO_TLS13
destConfig->isMiddleBoxCompat = srcConfig->isMiddleBoxCompat;
#endif
#ifdef HITLS_TLS_FEATURE_MAX_SEND_FRAGMENT
destConfig->maxSendFragment = srcConfig->maxSendFragment;
#endif
#ifdef HITLS_TLS_FEATURE_REC_INBUFFER_SIZE
destConfig->recInbufferSize = srcConfig->recInbufferSize;
#endif
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
destConfig->isSupportRenegotiation = srcConfig->isSupportRenegotiation;
destConfig->allowClientRenegotiate = srcConfig->allowClientRenegotiate;
#endif
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
destConfig->allowLegacyRenegotiate = srcConfig->allowLegacyRenegotiate;
#endif
#ifdef HITLS_TLS_SUITE_KX_RSA
destConfig->needCheckPmsVersion = srcConfig->needCheckPmsVersion;
#endif
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
destConfig->needCheckKeyUsage = srcConfig->needCheckKeyUsage;
#endif
destConfig->userData = srcConfig->userData;
destConfig->userDataFreeCb = srcConfig->userDataFreeCb;
#ifdef HITLS_TLS_FEATURE_MODE
destConfig->modeSupport = srcConfig->modeSupport;
#endif
destConfig->readAhead = srcConfig->readAhead;
destConfig->recordPaddingCb = srcConfig->recordPaddingCb;
destConfig->recordPaddingArg = srcConfig->recordPaddingArg;
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
destConfig->isSupportDhAuto = srcConfig->isSupportDhAuto;
destConfig->dhTmpCb = srcConfig->dhTmpCb;
#endif
#if defined(HITLS_TLS_FEATURE_RENEGOTIATION) && defined(HITLS_TLS_FEATURE_SESSION)
destConfig->isResumptionOnRenego = srcConfig->isResumptionOnRenego;
#endif
#ifdef HITLS_TLS_FEATURE_CERT_MODE
destConfig->isSupportClientVerify = srcConfig->isSupportClientVerify;
destConfig->isSupportNoClientCert = srcConfig->isSupportNoClientCert;
destConfig->isSupportVerifyNone = srcConfig->isSupportVerifyNone;
#endif
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
destConfig->isSupportSessionTicket = srcConfig->isSupportSessionTicket;
#endif
#if defined(HITLS_TLS_FEATURE_RENEGOTIATION) && defined(HITLS_TLS_FEATURE_CERT_MODE)
destConfig->isSupportClientOnceVerify = srcConfig->isSupportClientOnceVerify;
#endif
#ifdef HITLS_TLS_FEATURE_PHA
destConfig->isSupportPostHandshakeAuth = srcConfig->isSupportPostHandshakeAuth;
#endif
#ifdef HITLS_TLS_FEATURE_PSK
destConfig->pskClientCb = srcConfig->pskClientCb;
destConfig->pskServerCb = srcConfig->pskServerCb;
#endif
#ifdef HITLS_TLS_PROTO_TLS13
destConfig->keyExchMode = srcConfig->keyExchMode;
#endif
#ifdef HITLS_TLS_FEATURE_INDICATOR
destConfig->infoCb = srcConfig->infoCb;
destConfig->msgCb = srcConfig->msgCb;
destConfig->msgArg = srcConfig->msgArg;
#endif
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
destConfig->dtlsTimerCb = srcConfig->dtlsTimerCb;
destConfig->dtlsPostHsTimeoutVal = srcConfig->dtlsPostHsTimeoutVal;
destConfig->isSupportDtlsCookieExchange = srcConfig->isSupportDtlsCookieExchange;
#endif
#ifdef HITLS_TLS_FEATURE_SECURITY
destConfig->securityCb = srcConfig->securityCb;
destConfig->securityExData = srcConfig->securityExData;
destConfig->securityLevel = srcConfig->securityLevel;
#endif
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
destConfig->isEncryptThenMac = srcConfig->isEncryptThenMac;
#endif
#if defined(HITLS_TLS_PROTO_TLS13) && defined(HITLS_TLS_FEATURE_PSK)
destConfig->pskFindSessionCb = srcConfig->pskFindSessionCb;
destConfig->pskUseSessionCb = srcConfig->pskUseSessionCb;
#endif
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
destConfig->ticketNums = srcConfig->ticketNums;
#endif
#ifdef HITLS_TLS_FEATURE_FLIGHT
destConfig->isFlightTransmitEnable = srcConfig->isFlightTransmitEnable;
#endif
}
static int32_t DeepCopy(void** destConfig, const void* srcConfig, uint32_t logId, uint32_t len)
{
BSL_SAL_FREE(*destConfig);
*destConfig = BSL_SAL_Dump(srcConfig, len);
if (*destConfig == NULL) {
BSL_LOG_BINLOG_FIXLEN(logId, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
return HITLS_SUCCESS;
}
static int32_t PointFormatsCfgDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
if (srcConfig->pointFormats != NULL) {
int32_t ret = DeepCopy((void **)&destConfig->pointFormats, srcConfig->pointFormats, BINLOG_ID16584,
srcConfig->pointFormatsSize * sizeof(uint8_t));
if (ret != HITLS_SUCCESS) {
return ret;
}
destConfig->pointFormatsSize = srcConfig->pointFormatsSize;
}
return HITLS_SUCCESS;
}
static int32_t GroupCfgDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
if (srcConfig->groups != NULL) {
int32_t ret = DeepCopy((void **)&destConfig->groups, srcConfig->groups, BINLOG_ID16585,
srcConfig->groupsSize * sizeof(uint16_t));
if (ret != HITLS_SUCCESS) {
return ret;
}
destConfig->groupsSize = srcConfig->groupsSize;
}
#ifdef HITLS_TLS_FEATURE_PROVIDER
if (srcConfig->groupInfo != NULL) {
for (uint32_t i = 0; i < destConfig->groupInfolen; i++) {
BSL_SAL_FREE(destConfig->groupInfo[i].name);
}
BSL_SAL_FREE(destConfig->groupInfo);
destConfig->groupInfoSize = 0;
destConfig->groupInfolen = 0;
destConfig->groupInfo= BSL_SAL_Calloc(srcConfig->groupInfolen, sizeof(TLS_GroupInfo));
if (destConfig->groupInfo == NULL) {
return HITLS_MEMALLOC_FAIL;
}
for (uint32_t i = 0; i < srcConfig->groupInfolen; i++) {
destConfig->groupInfo[i] = srcConfig->groupInfo[i];
destConfig->groupInfo[i].name =
BSL_SAL_Dump(srcConfig->groupInfo[i].name, strlen(srcConfig->groupInfo[i].name) + 1);
if (destConfig->groupInfo[i].name == NULL) {
return HITLS_MEMALLOC_FAIL;
}
}
destConfig->groupInfoSize = srcConfig->groupInfolen;
destConfig->groupInfolen = srcConfig->groupInfolen;
}
#endif
return HITLS_SUCCESS;
}
#if defined(HITLS_TLS_PROTO_TLS12) && defined(HITLS_TLS_FEATURE_PSK)
static int32_t PskCfgDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
if (srcConfig->pskIdentityHint != NULL) {
BSL_SAL_FREE(destConfig->pskIdentityHint);
destConfig->pskIdentityHint = BSL_SAL_Dump(srcConfig->pskIdentityHint, srcConfig->hintSize * sizeof(uint8_t));
if (destConfig->pskIdentityHint == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16586, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
destConfig->hintSize = srcConfig->hintSize;
}
return HITLS_SUCCESS;
}
#endif
static int32_t SignAlgorithmsCfgDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
if (srcConfig->signAlgorithms != NULL) {
int32_t ret = DeepCopy((void **)&destConfig->signAlgorithms, srcConfig->signAlgorithms, BINLOG_ID16587,
srcConfig->signAlgorithmsSize * sizeof(uint16_t));
if (ret != HITLS_SUCCESS) {
return ret;
}
destConfig->signAlgorithmsSize = srcConfig->signAlgorithmsSize;
}
#ifdef HITLS_TLS_FEATURE_PROVIDER
if (srcConfig->sigSchemeInfo != NULL) {
for (uint32_t i = 0; i < destConfig->sigSchemeInfolen; i++) {
BSL_SAL_FREE(destConfig->sigSchemeInfo[i].name);
}
BSL_SAL_FREE(destConfig->sigSchemeInfo);
destConfig->sigSchemeInfoSize = 0;
destConfig->sigSchemeInfolen = 0;
destConfig->sigSchemeInfo = BSL_SAL_Calloc(srcConfig->sigSchemeInfolen, sizeof(TLS_SigSchemeInfo));
if (destConfig->sigSchemeInfo == NULL) {
return HITLS_MEMALLOC_FAIL;
}
for (uint32_t i = 0; i < srcConfig->sigSchemeInfolen; i++) {
destConfig->sigSchemeInfo[i] = srcConfig->sigSchemeInfo[i];
destConfig->sigSchemeInfo[i].name =
BSL_SAL_Dump(srcConfig->sigSchemeInfo[i].name, strlen(srcConfig->sigSchemeInfo[i].name) + 1);
if (destConfig->sigSchemeInfo[i].name == NULL) {
return HITLS_MEMALLOC_FAIL;
}
}
destConfig->sigSchemeInfoSize = srcConfig->sigSchemeInfolen;
destConfig->sigSchemeInfolen = srcConfig->sigSchemeInfolen;
}
#endif
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_ALPN
static int32_t AlpnListDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
if (srcConfig->alpnListSize == 0 || srcConfig->alpnList == NULL) {
return HITLS_SUCCESS;
}
BSL_SAL_FREE(destConfig->alpnList);
destConfig->alpnList = BSL_SAL_Dump(srcConfig->alpnList, (srcConfig->alpnListSize + 1) * sizeof(uint8_t));
if (destConfig->alpnList == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16588, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
destConfig->alpnListSize = srcConfig->alpnListSize;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_SNI
static int32_t ServerNameDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
if (srcConfig->serverNameSize != 0 && srcConfig->serverName != NULL) {
int32_t ret = DeepCopy((void **)&destConfig->serverName, srcConfig->serverName, BINLOG_ID16589,
srcConfig->serverNameSize * sizeof(uint8_t));
if (ret != HITLS_SUCCESS) {
return ret;
}
destConfig->serverNameSize = srcConfig->serverNameSize;
}
return HITLS_SUCCESS;
}
#endif
static int32_t CipherSuiteDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
if (srcConfig->cipherSuites != NULL) {
int32_t ret = DeepCopy((void **)&destConfig->cipherSuites, srcConfig->cipherSuites, BINLOG_ID16590,
srcConfig->cipherSuitesSize * sizeof(uint16_t));
if (ret != HITLS_SUCCESS) {
return ret;
}
destConfig->cipherSuitesSize = srcConfig->cipherSuitesSize;
}
#ifdef HITLS_TLS_PROTO_TLS13
if (srcConfig->tls13CipherSuites != NULL) {
int32_t ret = DeepCopy((void **)&destConfig->tls13CipherSuites, srcConfig->tls13CipherSuites, BINLOG_ID16591,
srcConfig->tls13cipherSuitesSize * sizeof(uint16_t));
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(destConfig->cipherSuites);
return ret;
}
destConfig->tls13cipherSuitesSize = srcConfig->tls13cipherSuitesSize;
}
#endif
return HITLS_SUCCESS;
}
static int32_t CertMgrDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
if (!SAL_CERT_MgrIsEnable()) {
return HITLS_SUCCESS;
}
destConfig->certMgrCtx = SAL_CERT_MgrCtxDup(srcConfig->certMgrCtx);
if (destConfig->certMgrCtx == NULL) {
return HITLS_CERT_ERR_MGR_DUP;
}
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_SESSION_ID
static int32_t SessionIdCtxCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
if (srcConfig->sessionIdCtxSize != 0 &&
memcpy_s(destConfig->sessionIdCtx, sizeof(destConfig->sessionIdCtx),
srcConfig->sessionIdCtx, srcConfig->sessionIdCtxSize) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16592, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
return HITLS_MEMCPY_FAIL;
}
destConfig->sessionIdCtxSize = srcConfig->sessionIdCtxSize;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_SESSION_ID */
#ifdef HITLS_TLS_FEATURE_SESSION
static int32_t SessMgrDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
destConfig->sessMgr = SESSMGR_Dup(srcConfig->sessMgr);
if (destConfig->sessMgr == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16593, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"MGR_Dup fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetSessionTimeout(HITLS_Config *config, uint64_t timeout)
{
if (config == NULL || config->sessMgr == NULL) {
return HITLS_NULL_INPUT;
}
SESSMGR_SetTimeout(config->sessMgr, timeout);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetSessionTimeout(const HITLS_Config *config, uint64_t *timeout)
{
if (config == NULL || config->sessMgr == NULL || timeout == NULL) {
return HITLS_NULL_INPUT;
}
*timeout = SESSMGR_GetTimeout(config->sessMgr);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetNewSessionCb(HITLS_Config *config, const HITLS_NewSessionCb newSessionCb)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->newSessionCb = newSessionCb;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
static int32_t CryptKeyDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
if (srcConfig->dhTmp != NULL) {
destConfig->dhTmp = SAL_CRYPT_DupDhKey(srcConfig->dhTmp);
if (destConfig->dhTmp == NULL) {
return HITLS_CONFIG_DUP_DH_KEY_FAIL;
}
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_CONFIG_MANUAL_DH */
#ifdef HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES
void FreeNode(HITLS_TrustedCANode *node)
{
BSL_SAL_FREE(node->data);
BSL_SAL_FREE(node);
return;
}
static HITLS_TrustedCANode *DupNameNode(const HITLS_TrustedCANode *src)
{
/* Src is not null. */
HITLS_TrustedCANode *dest = BSL_SAL_Malloc(sizeof(HITLS_TrustedCANode));
if (dest == NULL) {
BSL_ERR_PUSH_ERROR(BSL_MALLOC_FAIL);
return NULL;
}
dest->caType = src->caType;
// nameValue
dest->dataSize = src->dataSize;
if (dest->dataSize != 0) {
dest->data = BSL_SAL_Dump(src->data, src->dataSize);
if (dest->data == NULL) {
BSL_SAL_Free(dest);
BSL_ERR_PUSH_ERROR(BSL_DUMP_FAIL);
return NULL;
}
}
return dest;
}
static int32_t CaListDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
if (srcConfig->caList != NULL) {
destConfig->caList =
BSL_LIST_Copy(srcConfig->caList, (BSL_LIST_PFUNC_DUP)DupNameNode, (BSL_LIST_PFUNC_FREE)FreeNode);
if (destConfig->caList == NULL) {
return HITLS_MEMCPY_FAIL;
}
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES */
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
static int32_t CustomExtsDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
destConfig->customExts = DupCustomExtensions(srcConfig->customExts);
if (srcConfig->customExts != NULL && destConfig->customExts == NULL) {
return HITLS_MEMALLOC_FAIL;
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
static int32_t BasicConfigDeepCopy(HITLS_Config *destConfig, const HITLS_Config *srcConfig)
{
int32_t ret = HITLS_SUCCESS;
const struct {
int32_t (*copyFunc)(HITLS_Config *destConfig, const HITLS_Config *srcConfig);
} copyFeatures[] = {
#ifdef HITLS_TLS_FEATURE_SESSION_ID
{SessionIdCtxCopy},
#endif
{CertMgrDeepCopy},
#ifdef HITLS_TLS_FEATURE_SESSION
{SessMgrDeepCopy},
#endif
#ifdef HITLS_TLS_FEATURE_ALPN
{AlpnListDeepCopy},
#endif
#ifdef HITLS_TLS_FEATURE_SNI
{ServerNameDeepCopy},
#endif
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
{CryptKeyDeepCopy},
#endif
#ifdef HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES
{CaListDeepCopy},
#endif
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
{CustomExtsDeepCopy},
#endif
};
for (size_t i = 0; i < sizeof(copyFeatures) / sizeof(copyFeatures[0]); i++) {
if (copyFeatures[i].copyFunc != NULL) {
ret = copyFeatures[i].copyFunc(destConfig, srcConfig);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
}
return HITLS_SUCCESS;
}
int32_t DumpConfig(HITLS_Ctx *ctx, const HITLS_Config *srcConfig)
{
int32_t ret;
HITLS_Config *destConfig = &ctx->config.tlsConfig;
// shallow copy
ShallowCopy(ctx, srcConfig);
ret = CipherSuiteDeepCopy(destConfig, srcConfig);
if (ret != HITLS_SUCCESS) {
goto EXIT;
}
ret = PointFormatsCfgDeepCopy(destConfig, srcConfig);
if (ret != HITLS_SUCCESS) {
goto EXIT;
}
ret = GroupCfgDeepCopy(destConfig, srcConfig);
if (ret != HITLS_SUCCESS) {
goto EXIT;
}
ret = SignAlgorithmsCfgDeepCopy(destConfig, srcConfig);
if (ret != HITLS_SUCCESS) {
goto EXIT;
}
#if defined(HITLS_TLS_PROTO_TLS12) && defined(HITLS_TLS_FEATURE_PSK)
ret = PskCfgDeepCopy(destConfig, srcConfig);
if (ret != HITLS_SUCCESS) {
goto EXIT;
}
#endif
ret = BasicConfigDeepCopy(destConfig, srcConfig);
if (ret != HITLS_SUCCESS) {
goto EXIT;
}
return HITLS_SUCCESS;
EXIT:
CFG_CleanConfig(destConfig);
return ret;
}
HITLS_Config *CreateConfig(void)
{
HITLS_Config *newConfig = BSL_SAL_Calloc(1u, sizeof(HITLS_Config));
if (newConfig == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16594, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
return NULL;
}
if (BSL_SAL_ReferencesInit(&(newConfig->references)) != BSL_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16595, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ReferencesInit fail", 0, 0, 0, 0);
BSL_SAL_FREE(newConfig);
return NULL;
}
return newConfig;
}
#ifdef HITLS_TLS_PROTO_DTLS12
HITLS_Config *HITLS_CFG_NewDTLS12Config(void)
{
return HITLS_CFG_ProviderNewDTLS12Config(NULL, NULL);
}
HITLS_Config *HITLS_CFG_ProviderNewDTLS12Config(HITLS_Lib_Ctx *libCtx, const char *attrName)
{
HITLS_Config *newConfig = CreateConfig();
if (newConfig == NULL) {
return NULL;
}
newConfig->version |= DTLS12_VERSION_BIT; // Enable DTLS 1.2
if (DefaultConfig(libCtx, attrName, HITLS_VERSION_DTLS12, newConfig) != HITLS_SUCCESS) {
BSL_SAL_FREE(newConfig);
return NULL;
}
newConfig->originVersionMask = newConfig->version;
return newConfig;
}
#endif
#ifdef HITLS_TLS_PROTO_DTLCP11
HITLS_Config *HITLS_CFG_NewDTLCPConfig(void)
{
return HITLS_CFG_ProviderNewDTLCPConfig(NULL, NULL);
}
HITLS_Config *HITLS_CFG_ProviderNewDTLCPConfig(HITLS_Lib_Ctx *libCtx, const char *attrName)
{
HITLS_Config *newConfig = CreateConfig();
if (newConfig == NULL) {
return NULL;
}
newConfig->version |= DTLCP11_VERSION_BIT; // Enable DTLCP 1.1
if (DefaultConfig(libCtx, attrName, HITLS_VERSION_TLCP_DTLCP11, newConfig) != HITLS_SUCCESS) {
BSL_SAL_FREE(newConfig);
return NULL;
}
newConfig->originVersionMask = newConfig->version;
return newConfig;
}
#endif
#ifdef HITLS_TLS_PROTO_TLCP11
HITLS_Config *HITLS_CFG_NewTLCPConfig(void)
{
return HITLS_CFG_ProviderNewTLCPConfig(NULL, NULL);
}
HITLS_Config *HITLS_CFG_ProviderNewTLCPConfig(HITLS_Lib_Ctx *libCtx, const char *attrName)
{
HITLS_Config *newConfig = CreateConfig();
if (newConfig == NULL) {
return NULL;
}
newConfig->version |= TLCP11_VERSION_BIT; // Enable TLCP 1.1
if (DefaultConfig(libCtx, attrName, HITLS_VERSION_TLCP_DTLCP11, newConfig) != HITLS_SUCCESS) {
BSL_SAL_FREE(newConfig);
return NULL;
}
newConfig->originVersionMask = newConfig->version;
return newConfig;
}
#endif
#ifdef HITLS_TLS_PROTO_TLS12
HITLS_Config *HITLS_CFG_NewTLS12Config(void)
{
return HITLS_CFG_ProviderNewTLS12Config(NULL, NULL);
}
HITLS_Config *HITLS_CFG_ProviderNewTLS12Config(HITLS_Lib_Ctx *libCtx, const char *attrName)
{
HITLS_Config *newConfig = CreateConfig();
if (newConfig == NULL) {
return NULL;
}
/* Initialize the version */
newConfig->version |= TLS12_VERSION_BIT; // Enable TLS 1.2
if (DefaultConfig(libCtx, attrName, HITLS_VERSION_TLS12, newConfig) != HITLS_SUCCESS) {
BSL_SAL_FREE(newConfig);
return NULL;
}
newConfig->originVersionMask = newConfig->version;
return newConfig;
}
#endif
#ifdef HITLS_TLS_PROTO_ALL
HITLS_Config *HITLS_CFG_NewTLSConfig(void)
{
return HITLS_CFG_ProviderNewTLSConfig(NULL, NULL);
}
HITLS_Config *HITLS_CFG_ProviderNewTLSConfig(HITLS_Lib_Ctx *libCtx, const char *attrName)
{
HITLS_Config *newConfig = CreateConfig();
if (newConfig == NULL) {
return NULL;
}
newConfig->version |= TLS_VERSION_MASK;
newConfig->libCtx = libCtx;
newConfig->attrName = attrName;
if (DefaultTlsAllConfig(newConfig) != HITLS_SUCCESS) {
BSL_SAL_FREE(newConfig);
return NULL;
}
newConfig->originVersionMask = newConfig->version;
return newConfig;
}
#endif
#ifdef HITLS_TLS_PROTO_DTLS
HITLS_Config *HITLS_CFG_NewDTLSConfig(void)
{
return HITLS_CFG_ProviderNewDTLSConfig(NULL, NULL);
}
HITLS_Config *HITLS_CFG_ProviderNewDTLSConfig(HITLS_Lib_Ctx *libCtx, const char *attrName)
{
HITLS_Config *newConfig = CreateConfig();
if (newConfig == NULL) {
return NULL;
}
newConfig->version |= DTLS_VERSION_MASK; // Enable All Versions
newConfig->libCtx = libCtx;
newConfig->attrName = attrName;
if (DefaultDtlsAllConfig(newConfig) != HITLS_SUCCESS) {
BSL_SAL_FREE(newConfig);
return NULL;
}
newConfig->originVersionMask = newConfig->version;
return newConfig;
}
#endif
void HITLS_CFG_FreeConfig(HITLS_Config *config)
{
if (config == NULL) {
return;
}
int ret = 0;
(void)BSL_SAL_AtomicDownReferences(&(config->references), &ret);
if (ret > 0) {
return;
}
CFG_CleanConfig(config);
#ifdef HITLS_TLS_CONFIG_USER_DATA
if (config->userData != NULL && config->userDataFreeCb != NULL) {
(void)config->userDataFreeCb(config->userData);
config->userData = NULL;
}
#endif
BSL_SAL_FREE(config);
return;
}
int32_t HITLS_CFG_UpRef(HITLS_Config *config)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
int ret = 0;
(void)BSL_SAL_AtomicUpReferences(&(config->references), &ret);
(void)ret;
return HITLS_SUCCESS;
}
uint32_t MapVersion2VersionBit(bool isDatagram, uint16_t version)
{
(void)isDatagram;
uint32_t ret = 0;
switch (version) {
case HITLS_VERSION_TLS12:
ret = TLS12_VERSION_BIT;
break;
case HITLS_VERSION_TLS13:
ret = TLS13_VERSION_BIT;
break;
case HITLS_VERSION_TLCP_DTLCP11:
if (isDatagram) {
ret = DTLCP11_VERSION_BIT;
} else {
ret = TLCP11_VERSION_BIT;
}
break;
case HITLS_VERSION_DTLS12:
ret = DTLS12_VERSION_BIT;
break;
default:
break;
}
return ret;
}
#ifdef HITLS_TLS_PROTO_ALL
static int ChangeVersionMask(HITLS_Config *config, uint16_t minVersion, uint16_t maxVersion)
{
uint32_t originVersionMask = config->originVersionMask;
uint32_t versionMask = 0;
uint32_t versionBit = 0;
/* Creating a DTLS version but setting a TLS version is invalid. */
if (originVersionMask == DTLS_VERSION_MASK) {
if (IS_DTLS_VERSION(minVersion) == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16596, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Config min version [0x%x] err.", minVersion, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_VERSION);
return HITLS_CONFIG_INVALID_VERSION;
}
}
if (originVersionMask == TLS_VERSION_MASK) {
/* Creating a TLS version but setting a DTLS version is invalid. */
if (IS_DTLS_VERSION(minVersion)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16597, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"minVersion err", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_VERSION);
return HITLS_CONFIG_INVALID_VERSION;
}
for (uint16_t version = minVersion; version <= maxVersion; version++) {
versionBit = MapVersion2VersionBit(IS_SUPPORT_DATAGRAM(originVersionMask), version);
versionMask |= versionBit;
}
if ((versionMask & originVersionMask) == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16598, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Config version err", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_VERSION);
return HITLS_CONFIG_INVALID_VERSION;
}
config->version = versionMask;
return HITLS_SUCCESS;
}
return HITLS_SUCCESS;
}
static int32_t CheckVersionValid(HITLS_Config *config, uint16_t minVersion, uint16_t maxVersion)
{
if ((minVersion < HITLS_VERSION_SSL30 && minVersion != 0) ||
(minVersion == HITLS_VERSION_SSL30 && config->minVersion != HITLS_VERSION_SSL30) ||
(maxVersion <= HITLS_VERSION_SSL30 && maxVersion != 0)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16599, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Config version err", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_VERSION);
return HITLS_CONFIG_INVALID_VERSION;
}
return HITLS_SUCCESS;
}
static void ChangeTmpVersion(HITLS_Config *config, uint16_t *tmpMinVersion, uint16_t *tmpMaxVersion)
{
if (*tmpMinVersion == 0) {
if (config->originVersionMask == DTLS_VERSION_MASK) {
*tmpMinVersion = HITLS_VERSION_DTLS12;
} else {
*tmpMinVersion = HITLS_VERSION_TLS12;
}
} else if (*tmpMaxVersion == 0) {
if (config->originVersionMask == DTLS_VERSION_MASK) {
*tmpMaxVersion = HITLS_VERSION_DTLS12;
} else {
*tmpMaxVersion = HITLS_VERSION_TLS13;
}
}
return;
}
#endif
int32_t HITLS_CFG_SetVersion(HITLS_Config *config, uint16_t minVersion, uint16_t maxVersion)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
int32_t ret = 0;
#ifdef HITLS_TLS_PROTO_ALL
if (config->minVersion == minVersion && config->maxVersion == maxVersion && minVersion != 0 && maxVersion != 0) {
return HITLS_SUCCESS;
}
/* TLCP cannot be supported by setting the version number. They can be
* initialized only by using the corresponding configuration initialization interface.
*/
ret = CheckVersionValid(config, minVersion, maxVersion);
if (ret != HITLS_SUCCESS) {
return ret;
}
config->minVersion = 0;
config->maxVersion = 0;
/* If both the latest version and the earliest version supported are 0, clear the versionMask. */
if (minVersion == maxVersion && minVersion == 0) {
config->version = 0;
return HITLS_SUCCESS;
}
#endif
uint16_t tmpMinVersion = minVersion;
uint16_t tmpMaxVersion = maxVersion;
#ifdef HITLS_TLS_PROTO_ALL
ChangeTmpVersion(config, &tmpMinVersion, &tmpMaxVersion);
#endif
ret = CheckVersion(tmpMinVersion, tmpMaxVersion);
if (ret != HITLS_SUCCESS) {
return ret;
}
#ifdef HITLS_TLS_PROTO_ALL
/* In invalid cases, both maxVersion and minVersion are 0 */
if (ChangeVersionMask(config, tmpMinVersion, tmpMaxVersion) == HITLS_SUCCESS) {
#endif
config->minVersion = tmpMinVersion;
config->maxVersion = tmpMaxVersion;
#ifdef HITLS_TLS_PROTO_ALL
}
#endif
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_PROTO_ALL
int32_t HITLS_CFG_SetVersionForbid(HITLS_Config *config, uint32_t noVersion)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
// Now only DTLS1.2 is supported, so single version is not supported (disable to version 0)
if ((config->originVersionMask & TLS_VERSION_MASK) == TLS_VERSION_MASK) {
uint32_t noVersionBit = MapVersion2VersionBit(IS_SUPPORT_DATAGRAM(config->originVersionMask),
(uint16_t)noVersion);
if ((config->version & (~noVersionBit)) == 0) {
return HITLS_SUCCESS; // Not all is disabled but the return value is SUCCESS
}
config->version &= ~noVersionBit;
uint32_t versionBits[] = {
TLS12_VERSION_BIT, TLS13_VERSION_BIT};
uint16_t versions[] = {
HITLS_VERSION_TLS12, HITLS_VERSION_TLS13};
uint32_t versionBitsSize = sizeof(versionBits) / sizeof(uint32_t);
for (uint32_t i = 0; i < versionBitsSize; i++) {
if ((config->version & versionBits[i]) == versionBits[i]) {
config->minVersion = versions[i];
break;
}
}
for (int i = (int)versionBitsSize - 1; i >= 0; i--) {
if ((config->version & versionBits[i]) == versionBits[i]) {
config->maxVersion = versions[i];
break;
}
}
}
return HITLS_SUCCESS;
}
#endif
static void GetCipherSuitesCnt(const uint16_t *cipherSuites, uint32_t cipherSuitesSize,
uint32_t *tls13CipherSize, uint32_t *tlsCipherSize)
{
(void)cipherSuites;
uint32_t tmpCipherSize = *tlsCipherSize;
uint32_t tmpTls13CipherSize = *tls13CipherSize;
for (uint32_t i = 0; i < cipherSuitesSize; i++) {
#ifdef HITLS_TLS_PROTO_TLS13
if (cipherSuites[i] >= HITLS_AES_128_GCM_SHA256 && cipherSuites[i] <= HITLS_AES_128_CCM_8_SHA256) {
tmpTls13CipherSize++;
continue;
}
#endif
tmpCipherSize++;
}
*tls13CipherSize = tmpTls13CipherSize;
*tlsCipherSize = tmpCipherSize;
}
int32_t HITLS_CFG_SetCipherSuites(HITLS_Config *config, const uint16_t *cipherSuites, uint32_t cipherSuitesSize)
{
if (config == NULL || cipherSuites == NULL || cipherSuitesSize == 0) {
return HITLS_NULL_INPUT;
}
if (cipherSuitesSize > HITLS_CFG_MAX_SIZE) {
return HITLS_CONFIG_INVALID_LENGTH;
}
uint32_t tlsCipherSize = 0;
uint32_t validTlsCipher = 0;
uint32_t tls13CipherSize = 0;
#ifdef HITLS_TLS_PROTO_TLS13
uint32_t validTls13Cipher = 0;
#endif
GetCipherSuitesCnt(cipherSuites, cipherSuitesSize, &tls13CipherSize, &tlsCipherSize);
uint16_t *cipherSuite = BSL_SAL_Calloc(1u, (tlsCipherSize + 1) * sizeof(uint16_t));
if (cipherSuite == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16600, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
#ifdef HITLS_TLS_PROTO_TLS13
uint16_t *tls13CipherSuite = BSL_SAL_Calloc(1u, (tls13CipherSize + 1) * sizeof(uint16_t));
if (tls13CipherSuite == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16601, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
BSL_SAL_FREE(cipherSuite);
return HITLS_MEMALLOC_FAIL;
}
#endif
for (uint32_t i = 0; i < cipherSuitesSize; i++) {
if (CFG_CheckCipherSuiteSupported(cipherSuites[i]) != true) {
continue;
}
if (cipherSuites[i] >= HITLS_AES_128_GCM_SHA256 && cipherSuites[i] <= HITLS_AES_128_CCM_8_SHA256) {
#ifdef HITLS_TLS_PROTO_TLS13
tls13CipherSuite[validTls13Cipher] = cipherSuites[i];
validTls13Cipher++;
#endif
continue;
}
cipherSuite[validTlsCipher] = cipherSuites[i];
validTlsCipher++;
}
#ifdef HITLS_TLS_PROTO_TLS13
if (validTls13Cipher == 0) {
BSL_SAL_FREE(tls13CipherSuite);
} else {
BSL_SAL_FREE(config->tls13CipherSuites);
config->tls13CipherSuites = tls13CipherSuite;
config->tls13cipherSuitesSize = validTls13Cipher;
}
#endif
if (validTlsCipher == 0) {
BSL_SAL_FREE(cipherSuite);
} else {
BSL_SAL_FREE(config->cipherSuites);
config->cipherSuites = cipherSuite;
config->cipherSuitesSize = validTlsCipher;
}
if (validTlsCipher == 0
#ifdef HITLS_TLS_PROTO_TLS13
&& validTls13Cipher == 0
#endif
) {
return HITLS_CONFIG_NO_SUITABLE_CIPHER_SUITE;
}
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetEcPointFormats(HITLS_Config *config, const uint8_t *pointFormats, uint32_t pointFormatsSize)
{
if ((config == NULL) || (pointFormats == NULL) || (pointFormatsSize == 0)) {
return HITLS_NULL_INPUT;
}
if (pointFormatsSize > HITLS_CFG_MAX_SIZE) {
return HITLS_CONFIG_INVALID_LENGTH;
}
uint8_t *newData = BSL_SAL_Dump(pointFormats, pointFormatsSize * sizeof(uint8_t));
if (newData == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16602, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
BSL_SAL_FREE(config->pointFormats);
config->pointFormats = newData;
config->pointFormatsSize = pointFormatsSize;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetGroups(HITLS_Config *config, const uint16_t *groups, uint32_t groupsSize)
{
if ((config == NULL) || (groups == NULL) || (groupsSize == 0u)) {
return HITLS_NULL_INPUT;
}
if (groupsSize > HITLS_CFG_MAX_SIZE) {
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_LENGTH);
return HITLS_CONFIG_INVALID_LENGTH;
}
uint16_t *newData = BSL_SAL_Dump(groups, groupsSize * sizeof(uint16_t));
if (newData == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16603, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
BSL_SAL_FREE(config->groups);
config->groups = newData;
config->groupsSize = groupsSize;
return HITLS_SUCCESS;
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
int32_t HITLS_CFG_SetCookieGenCb(HITLS_Config *config, HITLS_AppGenCookieCb callback)
{
if (config == NULL || callback == NULL) {
return HITLS_NULL_INPUT;
}
config->appGenCookieCb = callback;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetCookieVerifyCb(HITLS_Config *config, HITLS_AppVerifyCookieCb callback)
{
if (config == NULL || callback == NULL) {
return HITLS_NULL_INPUT;
}
config->appVerifyCookieCb = callback;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetDtlsTimerCb(HITLS_Config *config, HITLS_DtlsTimerCb callback)
{
if (config == NULL || callback == NULL) {
return HITLS_NULL_INPUT;
}
config->dtlsTimerCb = callback;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_CLIENT_HELLO_CB
int32_t HITLS_CFG_SetClientHelloCb(HITLS_Config *config, HITLS_ClientHelloCb callback, void *arg)
{
if (config == NULL || callback == NULL) {
return HITLS_NULL_INPUT;
}
config->clientHelloCb = callback;
config->clientHelloCbArg = arg;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
int32_t HITLS_CFG_SetDhAutoSupport(HITLS_Config *config, bool support)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isSupportDhAuto = support;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetTmpDh(HITLS_Config *config, HITLS_CRYPT_Key *dhPkey)
{
if ((config == NULL) || (dhPkey == NULL)) {
return HITLS_NULL_INPUT;
}
#ifdef HITLS_TLS_FEATURE_SECURITY
int32_t secBits = 0;
/* Temporary DH security check */
int32_t ret = SAL_CERT_KeyCtrl(config, dhPkey, CERT_KEY_CTRL_GET_SECBITS, NULL, (void *)&secBits);
if (ret != HITLS_SUCCESS) {
return HITLS_CERT_KEY_CTRL_ERR_GET_SECBITS;
}
ret = SECURITY_CfgCheck(config, HITLS_SECURITY_SECOP_TMP_DH, secBits, 0, dhPkey);
if (ret != SECURITY_SUCCESS) {
return HITLS_CRYPT_ERR_DH;
}
#endif /* HITLS_TLS_FEATURE_SECURITY */
SAL_CRYPT_FreeDhKey(config->dhTmp);
config->dhTmp = dhPkey;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetDhAutoSupport(HITLS_Config *config, uint8_t *isSupport)
{
if (config == NULL || isSupport == NULL) {
return HITLS_NULL_INPUT;
}
*isSupport = (uint8_t)config->isSupportDhAuto;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_CONFIG_MANUAL_DH */
#ifdef HITLS_TLS_SUITE_KX_RSA
int32_t HITLS_CFG_SetNeedCheckPmsVersion(HITLS_Config *config, bool needCheck)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->needCheckPmsVersion = needCheck;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_MODE
int32_t HITLS_CFG_SetModeSupport(HITLS_Config *config, uint32_t mode)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->modeSupport |= mode;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_ClearModeSupport(HITLS_Config *config, uint32_t mode)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->modeSupport &= (~mode);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetModeSupport(const HITLS_Config *config, uint32_t *mode)
{
if (config == NULL || mode == NULL) {
return HITLS_NULL_INPUT;
}
*mode = config->modeSupport;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_CONFIG_USER_DATA
void *HITLS_CFG_GetConfigUserData(const HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return config->userData;
}
int32_t HITLS_CFG_SetConfigUserData(HITLS_Config *config, void *userData)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->userData = userData;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetConfigUserDataFreeCb(HITLS_Config *config, HITLS_ConfigUserDataFreeCb callback)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->userDataFreeCb = callback;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_CONFIG_CERT
int32_t HITLS_CFG_SetMaxCertList(HITLS_Config *config, uint32_t maxSize)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->maxCertList = maxSize;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetMaxCertList(const HITLS_Config *config, uint32_t *maxSize)
{
if (config == NULL || maxSize == NULL) {
return HITLS_NULL_INPUT;
}
*maxSize = config->maxCertList;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
int32_t HITLS_CFG_SetTmpDhCb(HITLS_Config *config, HITLS_DhTmpCb callback)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->dhTmpCb = callback;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_CONFIG_MANUAL_DH */
#ifdef HITLS_TLS_CONFIG_RECORD_PADDING
int32_t HITLS_CFG_SetRecordPaddingCb(HITLS_Config *config, HITLS_RecordPaddingCb callback)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->recordPaddingCb = callback;
return HITLS_SUCCESS;
}
HITLS_RecordPaddingCb HITLS_CFG_GetRecordPaddingCb(HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return config->recordPaddingCb;
}
int32_t HITLS_CFG_SetRecordPaddingCbArg(HITLS_Config *config, void *arg)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->recordPaddingArg = arg;
return HITLS_SUCCESS;
}
void *HITLS_CFG_GetRecordPaddingCbArg(HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return config->recordPaddingArg;
}
#endif
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
int32_t HITLS_CFG_SetCheckKeyUsage(HITLS_Config *config, bool isCheck)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->needCheckKeyUsage = isCheck;
return HITLS_SUCCESS;
}
#endif
int32_t HITLS_CFG_SetReadAhead(HITLS_Config *config, int32_t onOff)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->readAhead = onOff;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetReadAhead(HITLS_Config *config, int32_t *onOff)
{
if (config == NULL || onOff == NULL) {
return HITLS_NULL_INPUT;
}
*onOff = config->readAhead;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetSignature(HITLS_Config *config, const uint16_t *signAlgs, uint16_t signAlgsSize)
{
if ((config == NULL) || (signAlgs == NULL) || (signAlgsSize == 0)) {
return HITLS_NULL_INPUT;
}
if (signAlgsSize > HITLS_CFG_MAX_SIZE) {
return HITLS_CONFIG_INVALID_LENGTH;
}
uint16_t *newData = BSL_SAL_Dump(signAlgs, signAlgsSize * sizeof(uint16_t));
if (newData == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16605, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
BSL_SAL_FREE(config->signAlgorithms);
config->signAlgorithms = newData;
config->signAlgorithmsSize = signAlgsSize;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_SNI
int32_t HITLS_CFG_SetServerName(HITLS_Config *config, uint8_t *serverName, uint32_t serverNameStrlen)
{
if ((config == NULL) || (serverName == NULL) || (serverNameStrlen == 0)) {
return HITLS_NULL_INPUT;
}
if (serverNameStrlen > HITLS_CFG_MAX_SIZE) {
return HITLS_CONFIG_INVALID_LENGTH;
}
uint32_t serverNameSize = serverNameStrlen;
if (serverName[serverNameStrlen - 1] != '\0') {
serverNameSize += 1;
}
uint8_t *newData = (uint8_t *) BSL_SAL_Malloc(serverNameSize * sizeof(uint8_t));
if (newData == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16606, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
(void)memcpy_s(newData, serverNameSize, serverName, serverNameStrlen);
newData[serverNameSize - 1] = '\0';
BSL_SAL_FREE(config->serverName);
config->serverName = newData;
config->serverNameSize = serverNameSize;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetServerName(HITLS_Config *config, uint8_t **serverName, uint32_t *serverNameStrlen)
{
if (config == NULL || serverName == NULL || serverNameStrlen == NULL) {
return HITLS_NULL_INPUT;
}
*serverName = config->serverName;
*serverNameStrlen = config->serverNameSize;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetServerNameCb(HITLS_Config *config, HITLS_SniDealCb callback)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->sniDealCb = callback;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetServerNameArg(HITLS_Config *config, void *arg)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->sniArg = arg;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetServerNameCb(HITLS_Config *config, HITLS_SniDealCb *callback)
{
if (config == NULL || callback == NULL) {
return HITLS_NULL_INPUT;
}
*callback = config->sniDealCb;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetServerNameArg(HITLS_Config *config, void **arg)
{
if (config == NULL || arg == NULL) {
return HITLS_NULL_INPUT;
}
*arg = config->sniArg;
return HITLS_SUCCESS;
}
#endif
int32_t HITLS_CFG_SetRenegotiationSupport(HITLS_Config *config, bool support)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isSupportRenegotiation = support;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
int32_t HITLS_CFG_SetClientRenegotiateSupport(HITLS_Config *config, bool support)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->allowClientRenegotiate = support;
return HITLS_SUCCESS;
}
#endif
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
int32_t HITLS_CFG_SetLegacyRenegotiateSupport(HITLS_Config *config, bool support)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->allowLegacyRenegotiate = support;
return HITLS_SUCCESS;
}
#endif /* defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12) */
#if defined(HITLS_TLS_FEATURE_RENEGOTIATION) && defined(HITLS_TLS_FEATURE_SESSION)
int32_t HITLS_CFG_SetResumptionOnRenegoSupport(HITLS_Config *config, bool support)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isResumptionOnRenego = support;
return HITLS_SUCCESS;
}
#endif
int32_t HITLS_CFG_SetExtenedMasterSecretSupport(HITLS_Config *config, bool support)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isSupportExtendMasterSecret = support;
return HITLS_SUCCESS;
}
#if defined(HITLS_TLS_FEATURE_PSK) && (defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12))
int32_t HITLS_CFG_SetPskIdentityHint(HITLS_Config *config, const uint8_t *hint, uint32_t hintSize)
{
if ((config == NULL) || (hint == NULL) || (hintSize == 0)) {
return HITLS_NULL_INPUT;
}
if (hintSize > HITLS_IDENTITY_HINT_MAX_SIZE) {
return HITLS_CONFIG_INVALID_LENGTH;
}
uint8_t *newData = BSL_SAL_Dump(hint, hintSize * sizeof(uint8_t));
if (newData == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16607, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
BSL_SAL_FREE(config->pskIdentityHint);
config->pskIdentityHint = newData;
config->hintSize = hintSize;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_PSK
// Configure clientCb, which is used to obtain the PSK through identity hints
int32_t HITLS_CFG_SetPskClientCallback(HITLS_Config *config, HITLS_PskClientCb callback)
{
if (config == NULL || callback == NULL) {
return HITLS_NULL_INPUT;
}
config->pskClientCb = callback;
return HITLS_SUCCESS;
}
// Set serverCb to obtain the PSK through identity.
int32_t HITLS_CFG_SetPskServerCallback(HITLS_Config *config, HITLS_PskServerCb callback)
{
if (config == NULL || callback == NULL) {
return HITLS_NULL_INPUT;
}
config->pskServerCb = callback;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
int32_t HITLS_CFG_SetSessionTicketSupport(HITLS_Config *config, bool support)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isSupportSessionTicket = support;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
int32_t HITLS_CFG_GetRenegotiationSupport(const HITLS_Config *config, uint8_t *isSupport)
{
if (config == NULL || isSupport == NULL) {
return HITLS_NULL_INPUT;
}
*isSupport = (uint8_t)config->isSupportRenegotiation;
return HITLS_SUCCESS;
}
#endif
int32_t HITLS_CFG_GetExtenedMasterSecretSupport(HITLS_Config *config, uint8_t *isSupport)
{
if (config == NULL || isSupport == NULL) {
return HITLS_NULL_INPUT;
}
*isSupport = (uint8_t)config->isSupportExtendMasterSecret;
return HITLS_SUCCESS;
}
#if defined(HITLS_TLS_FEATURE_SESSION_TICKET)
int32_t HITLS_CFG_GetSessionTicketSupport(const HITLS_Config *config, uint8_t *isSupport)
{
if (config == NULL || isSupport == NULL) {
return HITLS_NULL_INPUT;
}
*isSupport = (uint8_t)config->isSupportSessionTicket;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetTicketKeyCallback(HITLS_Config *config, HITLS_TicketKeyCb callback)
{
if (config == NULL || config->sessMgr == NULL) {
return HITLS_NULL_INPUT;
}
SESSMGR_SetTicketKeyCb(config->sessMgr, callback);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetSessionTicketKey(const HITLS_Config *config, uint8_t *key, uint32_t keySize, uint32_t *outSize)
{
if (config == NULL || config->sessMgr == NULL || key == NULL || outSize == NULL) {
return HITLS_NULL_INPUT;
}
return SESSMGR_GetTicketKey(config->sessMgr, key, keySize, outSize);
}
int32_t HITLS_CFG_SetSessionTicketKey(HITLS_Config *config, const uint8_t *key, uint32_t keySize)
{
if (config == NULL || config->sessMgr == NULL || key == NULL ||
(keySize != HITLS_TICKET_KEY_NAME_SIZE + HITLS_TICKET_KEY_SIZE + HITLS_TICKET_KEY_SIZE)) {
return HITLS_NULL_INPUT;
}
return SESSMGR_SetTicketKey(config->sessMgr, key, keySize);
}
#endif
#if defined(HITLS_TLS_FEATURE_CERT_MODE) && defined(HITLS_TLS_FEATURE_RENEGOTIATION)
int32_t HITLS_CFG_SetClientOnceVerifySupport(HITLS_Config *config, bool support)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isSupportClientOnceVerify = support;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetClientOnceVerifySupport(HITLS_Config *config, uint8_t *isSupport)
{
if (config == NULL || isSupport == NULL) {
return HITLS_NULL_INPUT;
}
*isSupport = (uint8_t)config->isSupportClientOnceVerify;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_PROTO_ALL
int32_t HITLS_CFG_GetMaxVersion(const HITLS_Config *config, uint16_t *maxVersion)
{
if (config == NULL || maxVersion == NULL) {
return HITLS_NULL_INPUT;
}
*maxVersion = config->maxVersion;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetMinVersion(const HITLS_Config *config, uint16_t *minVersion)
{
if (config == NULL || minVersion == NULL) {
return HITLS_NULL_INPUT;
}
*minVersion = config->minVersion;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_ALPN
static int32_t AlpnListValidationCheck(const uint8_t *alpnList, uint32_t alpnProtosLen)
{
uint32_t index = 0u;
while (index < alpnProtosLen) {
if (alpnList[index] == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16608, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"alpnList null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_LENGTH);
return HITLS_CONFIG_INVALID_LENGTH;
}
index += (alpnList[index] + 1);
}
if (index != alpnProtosLen) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16609, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"alpnProtosLen err", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_LENGTH);
return HITLS_CONFIG_INVALID_LENGTH;
}
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetAlpnProtos(HITLS_Config *config, const uint8_t *alpnProtos, uint32_t alpnProtosLen)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
/* If the input parameter is empty or the length is 0, clear the original alpn list */
if (alpnProtosLen == 0 || alpnProtos == NULL) {
BSL_SAL_FREE(config->alpnList);
config->alpnListSize = 0;
return HITLS_SUCCESS;
}
/* Add the check on alpnList. The expected format is |protoLen1|proto1|protoLen2|proto2|...| */
if (AlpnListValidationCheck(alpnProtos, alpnProtosLen) != HITLS_SUCCESS) {
return HITLS_CONFIG_INVALID_LENGTH;
}
uint8_t *alpnListTmp = (uint8_t *)BSL_SAL_Calloc(alpnProtosLen + 1, sizeof(uint8_t));
if (alpnListTmp == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16610, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
(void)memcpy_s(alpnListTmp, alpnProtosLen + 1, alpnProtos, alpnProtosLen);
BSL_SAL_FREE(config->alpnList);
config->alpnList = alpnListTmp;
/* Ignore ending 0s */
config->alpnListSize = alpnProtosLen;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetAlpnProtosSelectCb(HITLS_Config *config, HITLS_AlpnSelectCb callback, void *userData)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->alpnSelectCb = callback;
config->alpnUserData = userData;
return HITLS_SUCCESS;
}
#endif
#if defined(HITLS_TLS_FEATURE_SESSION_ID)
int32_t HITLS_CFG_SetSessionIdCtx(HITLS_Config *config, const uint8_t *sessionIdCtx, uint32_t len)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
if (len != 0 && memcpy_s(config->sessionIdCtx, sizeof(config->sessionIdCtx), sessionIdCtx, len) != EOK) {
return HITLS_MEMCPY_FAIL;
}
/* The allowed value is 0 */
config->sessionIdCtxSize = len;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_SESSION
int32_t HITLS_CFG_SetSessionCacheMode(HITLS_Config *config, HITLS_SESS_CACHE_MODE mode)
{
if (config == NULL || config->sessMgr == NULL) {
return HITLS_NULL_INPUT;
}
SESSMGR_SetCacheMode(config->sessMgr, mode);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetSessionCacheMode(HITLS_Config *config, HITLS_SESS_CACHE_MODE *mode)
{
if (config == NULL || config->sessMgr == NULL || mode == NULL) {
return HITLS_NULL_INPUT;
}
*mode = SESSMGR_GetCacheMode(config->sessMgr);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetSessionCacheSize(HITLS_Config *config, uint32_t size)
{
if (config == NULL || config->sessMgr == NULL) {
return HITLS_NULL_INPUT;
}
SESSMGR_SetCacheSize(config->sessMgr, size);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetSessionCacheSize(HITLS_Config *config, uint32_t *size)
{
if (config == NULL || config->sessMgr == NULL || size == NULL) {
return HITLS_NULL_INPUT;
}
*size = SESSMGR_GetCacheSize(config->sessMgr);
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_PROTO_ALL
int32_t HITLS_CFG_GetVersionSupport(const HITLS_Config *config, uint32_t *version)
{
if ((config == NULL) || (version == NULL)) {
return HITLS_NULL_INPUT;
}
*version = config->version;
return HITLS_SUCCESS;
}
static void ChangeSupportVersion(HITLS_Config *config)
{
uint32_t versionMask = config->version;
uint32_t originVersionMask = config->originVersionMask;
config->maxVersion = 0;
config->minVersion = 0;
/* The original supported version is disabled. This is abnormal and packets cannot be sent */
if ((versionMask & originVersionMask) == 0) {
return;
}
/* Currently, only DTLS1.2 is supported. DTLS1.0 is not supported */
if ((versionMask & DTLS12_VERSION_BIT) == DTLS12_VERSION_BIT) {
config->maxVersion = HITLS_VERSION_DTLS12;
config->minVersion = HITLS_VERSION_DTLS12;
return;
}
/* Description TLS_ANY_VERSION */
uint32_t versionBits[] = {TLS12_VERSION_BIT, TLS13_VERSION_BIT};
uint16_t versions[] = {HITLS_VERSION_TLS12, HITLS_VERSION_TLS13};
uint32_t versionBitsSize = sizeof(versionBits) / sizeof(uint32_t);
for (uint32_t i = 0; i < versionBitsSize; i++) {
if ((versionMask & versionBits[i]) == versionBits[i]) {
config->maxVersion = versions[i];
if (config->minVersion == 0) {
config->minVersion = versions[i];
}
}
}
}
int32_t HITLS_CFG_SetVersionSupport(HITLS_Config *config, uint32_t version)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
if ((version & SSLV3_VERSION_BIT) == SSLV3_VERSION_BIT) {
return HITLS_CONFIG_INVALID_VERSION;
}
config->version = version;
/* Update the maximum supported version */
ChangeSupportVersion(config);
return HITLS_SUCCESS;
}
int32_t HITLS_SetVersion(HITLS_Ctx *ctx, uint32_t minVersion, uint32_t maxVersion)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetVersion(&(ctx->config.tlsConfig), (uint16_t)minVersion, (uint16_t)maxVersion);
}
int32_t HITLS_SetVersionForbid(HITLS_Ctx *ctx, uint32_t noVersion)
{
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetVersionForbid(&(ctx->config.tlsConfig), noVersion);
}
#endif
int32_t HITLS_CFG_SetQuietShutdown(HITLS_Config *config, int32_t mode)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
/* The value 0 indicates that the quiet disconnection mode is disabled. The value 1 indicates that the quiet
* disconnection mode is enabled.
*/
if (mode != 0 && mode != 1) {
return HITLS_CONFIG_INVALID_SET;
}
if (mode == 0) {
config->isQuietShutdown = false;
} else {
config->isQuietShutdown = true;
}
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetQuietShutdown(const HITLS_Config *config, int32_t *mode)
{
if (config == NULL || mode == NULL) {
return HITLS_NULL_INPUT;
}
*mode = (int32_t)config->isQuietShutdown;
return HITLS_SUCCESS;
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
int32_t HITLS_CFG_SetDtlsPostHsTimeoutVal(HITLS_Config *config, uint32_t timeoutVal)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->dtlsPostHsTimeoutVal = timeoutVal;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
int32_t HITLS_CFG_SetEncryptThenMac(HITLS_Config *config, uint32_t encryptThenMacType)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
if (encryptThenMacType == 0) {
config->isEncryptThenMac = false;
} else {
config->isEncryptThenMac = true;
}
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetEncryptThenMac(const HITLS_Config *config, uint32_t *encryptThenMacType)
{
if (config == NULL || encryptThenMacType == NULL) {
return HITLS_NULL_INPUT;
}
*encryptThenMacType = (uint32_t)config->isEncryptThenMac;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_PROTO_DTLS
int32_t HITLS_CFG_IsDtls(const HITLS_Config *config, uint8_t *isDtls)
{
if (config == NULL || isDtls == NULL) {
return HITLS_NULL_INPUT;
}
*isDtls = ((config->originVersionMask & DTLS12_VERSION_BIT) != 0);
return HITLS_SUCCESS;
}
#endif
int32_t HITLS_CFG_SetCipherServerPreference(HITLS_Config *config, bool isSupport)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isSupportServerPreference = isSupport;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetCipherServerPreference(const HITLS_Config *config, bool *isSupport)
{
if (config == NULL || isSupport == NULL) {
return HITLS_NULL_INPUT;
}
*isSupport = config->isSupportServerPreference;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
int32_t HITLS_CFG_SetTicketNums(HITLS_Config *config, uint32_t ticketNums)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->ticketNums = ticketNums;
return HITLS_SUCCESS;
}
uint32_t HITLS_CFG_GetTicketNums(HITLS_Config *config)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
return config->ticketNums;
}
#endif
#ifdef HITLS_TLS_FEATURE_FLIGHT
int32_t HITLS_CFG_SetFlightTransmitSwitch(HITLS_Config *config, uint8_t isEnable)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
if (isEnable == 0) {
config->isFlightTransmitEnable = false;
} else {
config->isFlightTransmitEnable = true;
}
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetFlightTransmitSwitch(const HITLS_Config *config, uint8_t *isEnable)
{
if (config == NULL || isEnable == NULL) {
return HITLS_NULL_INPUT;
}
*isEnable = config->isFlightTransmitEnable;
return HITLS_SUCCESS;
}
#endif
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
int32_t HITLS_CFG_SetDtlsCookieExchangeSupport(HITLS_Config *config, bool isSupport)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isSupportDtlsCookieExchange = isSupport;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetDtlsCookieExchangeSupport(const HITLS_Config *config, bool *isSupport)
{
if (config == NULL || isSupport == NULL) {
return HITLS_NULL_INPUT;
}
*isSupport = config->isSupportDtlsCookieExchange;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_MAINTAIN_KEYLOG
int32_t HITLS_CFG_SetKeyLogCb(HITLS_Config *config, HITLS_KeyLogCb callback)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->keyLogCb = callback;
return HITLS_SUCCESS;
}
HITLS_KeyLogCb HITLS_CFG_GetKeyLogCb(HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return config->keyLogCb;
}
#endif
int32_t HITLS_CFG_SetEmptyRecordsNum(HITLS_Config *config, uint32_t emptyNum)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->emptyRecordsNum = emptyNum;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetEmptyRecordsNum(const HITLS_Config *config, uint32_t *emptyNum)
{
if (config == NULL || emptyNum == NULL) {
return HITLS_NULL_INPUT;
}
*emptyNum = config->emptyRecordsNum;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_MAX_SEND_FRAGMENT
int32_t HITLS_CFG_SetMaxSendFragment(HITLS_Config *config, uint16_t maxSendFragment)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
if (maxSendFragment > MAX_PLAINTEXT_LEN || maxSendFragment < MIN_MAX_SEND_FRAGMENT) {
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_LENGTH);
return HITLS_CONFIG_INVALID_LENGTH;
}
config->maxSendFragment = maxSendFragment;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetMaxSendFragment(const HITLS_Config *config, uint16_t *maxSendFragment)
{
if (config == NULL || maxSendFragment == NULL) {
return HITLS_NULL_INPUT;
}
*maxSendFragment = config->maxSendFragment;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_REC_INBUFFER_SIZE
int32_t HITLS_CFG_SetRecInbufferSize(HITLS_Config *config, uint32_t recInbufferSize)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
if (recInbufferSize > MAX_INBUFFER_SIZE || recInbufferSize < MIN_INBUFFER_SIZE) {
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_LENGTH);
return HITLS_CONFIG_INVALID_LENGTH;
}
config->recInbufferSize = recInbufferSize;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetRecInbufferSize(const HITLS_Config *config, uint32_t *recInbufferSize)
{
if (config == NULL || recInbufferSize == NULL) {
return HITLS_NULL_INPUT;
}
*recInbufferSize = config->recInbufferSize;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_PROTO_TLS13
int32_t HITLS_CFG_SetMiddleBoxCompat(HITLS_Config *config, bool isMiddleBox)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isMiddleBoxCompat = isMiddleBox;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetMiddleBoxCompat(HITLS_Config *config, bool *isMiddleBox)
{
if (config == NULL || isMiddleBox == NULL) {
return HITLS_NULL_INPUT;
}
*isMiddleBox = config->isMiddleBoxCompat;
return HITLS_SUCCESS;
}
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/config/src/config.c | C | unknown | 66,337 |
/*
* 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.
*/
#include <stdlib.h>
#include <string.h>
#include "securec.h"
#include "hitls_build.h"
#include "bsl_err_internal.h"
#include "bsl_list.h"
#include "tls_binlog_id.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "hitls_cert_type.h"
#include "tls_config.h"
#include "cert_method.h"
#include "cert_mgr.h"
#include "cert.h"
#include "cert_mgr.h"
#ifdef HITLS_TLS_FEATURE_SECURITY
#include "security.h"
#endif
#define MAX_PATH_LEN 4096
#ifdef HITLS_TLS_FEATURE_SECURITY
static int32_t CheckCertSecuritylevel(HITLS_Config *config, HITLS_CERT_X509 *cert, bool isCACert)
{
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
if (mgrCtx == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID16550, "unregistered callback");
}
HITLS_CERT_Key *pubkey = NULL;
int32_t ret = SAL_CERT_X509Ctrl(config, cert, CERT_CTRL_GET_PUB_KEY, NULL, (void *)&pubkey);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16551, "GET_PUB_KEY fail");
}
do {
int32_t secBits = 0;
ret = SAL_CERT_KeyCtrl(config, pubkey, CERT_KEY_CTRL_GET_SECBITS, NULL, (void *)&secBits);
if (ret != HITLS_SUCCESS) {
break;
}
if (isCACert == true) {
ret = SECURITY_CfgCheck(config, HITLS_SECURITY_SECOP_CA_KEY, secBits, 0, cert);
if (ret != SECURITY_SUCCESS) {
(void)RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16552, "CfgCheck fail");
ret = HITLS_CERT_ERR_CA_KEY_WITH_INSECURE_SECBITS;
break;
}
} else {
ret = SECURITY_CfgCheck(config, HITLS_SECURITY_SECOP_EE_KEY, secBits, 0, cert);
if (ret != SECURITY_SUCCESS) {
(void)RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16553, "CfgCheck fail");
ret = HITLS_CERT_ERR_EE_KEY_WITH_INSECURE_SECBITS;
break;
}
}
int32_t signAlg = 0;
ret = SAL_CERT_X509Ctrl(config, cert, CERT_CTRL_GET_SIGN_ALGO, NULL, (void *)&signAlg);
if (ret != HITLS_SUCCESS) {
(void)RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16554, "GET_SIGN_ALGO fail");
break;
}
ret = SECURITY_CfgCheck(config, HITLS_SECURITY_SECOP_SIGALG_CHECK, 0, signAlg, NULL);
if (ret != SECURITY_SUCCESS) {
(void)RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16555, "CfgCheck fail");
ret = HITLS_CERT_ERR_INSECURE_SIG_ALG;
break;
}
ret = HITLS_SUCCESS;
} while (false);
SAL_CERT_KeyFree(mgrCtx, pubkey);
return ret;
}
#endif
int32_t HITLS_CFG_SetVerifyStore(HITLS_Config *config, HITLS_CERT_Store *store, bool isClone)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
HITLS_CERT_Store *newStore = NULL;
if (isClone && store != NULL) {
newStore = SAL_CERT_StoreDup(config->certMgrCtx, store);
if (newStore == NULL) {
return HITLS_CERT_ERR_STORE_DUP;
}
} else {
newStore = store;
}
int32_t ret = SAL_CERT_SetVerifyStore(config->certMgrCtx, newStore);
if (ret != HITLS_SUCCESS) {
if (isClone && newStore != NULL) {
SAL_CERT_StoreFree(config->certMgrCtx, newStore);
}
}
return ret;
}
HITLS_CERT_Store *HITLS_CFG_GetVerifyStore(const HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return SAL_CERT_GetVerifyStore(config->certMgrCtx);
}
int32_t HITLS_CFG_SetChainStore(HITLS_Config *config, HITLS_CERT_Store *store, bool isClone)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
HITLS_CERT_Store *newStore = NULL;
if (isClone && store != NULL) {
newStore = SAL_CERT_StoreDup(config->certMgrCtx, store);
if (newStore == NULL) {
return HITLS_CERT_ERR_STORE_DUP;
}
} else {
newStore = store;
}
int32_t ret = SAL_CERT_SetChainStore(config->certMgrCtx, newStore);
if (ret != HITLS_SUCCESS) {
if (isClone && newStore != NULL) {
SAL_CERT_StoreFree(config->certMgrCtx, newStore);
}
}
return ret;
}
HITLS_CERT_Store *HITLS_CFG_GetChainStore(const HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return SAL_CERT_GetChainStore(config->certMgrCtx);
}
int32_t HITLS_CFG_SetCertStore(HITLS_Config *config, HITLS_CERT_Store *store, bool isClone)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
HITLS_CERT_Store *newStore = NULL;
if (isClone && store != NULL) {
newStore = SAL_CERT_StoreDup(config->certMgrCtx, store);
if (newStore == NULL) {
return HITLS_CERT_ERR_STORE_DUP;
}
} else {
newStore = store;
}
int32_t ret = SAL_CERT_SetCertStore(config->certMgrCtx, newStore);
if (ret != HITLS_SUCCESS) {
if (isClone && newStore != NULL) {
SAL_CERT_StoreFree(config->certMgrCtx, newStore);
}
}
return ret;
}
HITLS_CERT_Store *HITLS_CFG_GetCertStore(const HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return SAL_CERT_GetCertStore(config->certMgrCtx);
}
int32_t HITLS_CFG_SetDefaultPasswordCb(HITLS_Config *config, HITLS_PasswordCb cb)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
return SAL_CERT_SetDefaultPasswordCb(config->certMgrCtx, cb);
}
HITLS_PasswordCb HITLS_CFG_GetDefaultPasswordCb(HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return SAL_CERT_GetDefaultPasswordCb(config->certMgrCtx);
}
int32_t HITLS_CFG_SetDefaultPasswordCbUserdata(HITLS_Config *config, void *userdata)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
return SAL_CERT_SetDefaultPasswordCbUserdata(config->certMgrCtx, userdata);
}
void *HITLS_CFG_GetDefaultPasswordCbUserdata(HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return SAL_CERT_GetDefaultPasswordCbUserdata(config->certMgrCtx);
}
static int32_t CFG_SetCertificate(HITLS_Config *config, HITLS_CERT_X509 *cert, bool isClone, bool isTlcpEncCert)
{
if (config == NULL || cert == NULL) {
return HITLS_NULL_INPUT;
}
HITLS_CERT_X509 *newCert = cert;
if (isClone) {
newCert = SAL_CERT_X509Dup(config->certMgrCtx, cert);
if (newCert == NULL) {
return HITLS_CERT_ERR_X509_DUP;
}
}
int32_t ret = SAL_CERT_SetCurrentCert(config, newCert, isTlcpEncCert);
if (ret != HITLS_SUCCESS) {
if (isClone) {
SAL_CERT_X509Free(newCert);
}
}
return ret;
}
int32_t HITLS_CFG_SetCertificate(HITLS_Config *config, HITLS_CERT_X509 *cert, bool isClone)
{
if (config == NULL || cert == NULL || config->certMgrCtx == NULL) {
return HITLS_NULL_INPUT;
}
#ifdef HITLS_TLS_FEATURE_SECURITY
int32_t ret = CheckCertSecuritylevel(config, cert, false);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif
return CFG_SetCertificate(config, cert, isClone, false);
}
#ifdef HITLS_TLS_CONFIG_CERT_LOAD_FILE
int32_t HITLS_CFG_LoadCertFile(HITLS_Config *config, const char *file, HITLS_ParseFormat format)
{
if (config == NULL || file == NULL || strlen(file) == 0) {
return HITLS_NULL_INPUT;
}
int32_t ret;
HITLS_CERT_X509 *cert = SAL_CERT_X509Parse(LIBCTX_FROM_CONFIG(config),
ATTRIBUTE_FROM_CONFIG(config), config, (const uint8_t *)file, (uint32_t)strlen(file),
TLS_PARSE_TYPE_FILE, format);
if (cert == NULL) {
return HITLS_CFG_ERR_LOAD_CERT_FILE;
}
#ifdef HITLS_TLS_FEATURE_SECURITY
ret = CheckCertSecuritylevel(config, cert, false);
if (ret != HITLS_SUCCESS) {
SAL_CERT_X509Free(cert);
return ret;
}
#endif
ret = SAL_CERT_SetCurrentCert(config, cert, false);
if (ret != HITLS_SUCCESS) {
SAL_CERT_X509Free(cert);
}
return ret;
}
#endif /* HITLS_TLS_CONFIG_CERT_LOAD_FILE */
int32_t HITLS_CFG_LoadCertBuffer(HITLS_Config *config, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format)
{
if (config == NULL || buf == NULL || bufLen == 0) {
return HITLS_NULL_INPUT;
}
HITLS_CERT_X509 *newCert = SAL_CERT_X509Parse(LIBCTX_FROM_CONFIG(config),
ATTRIBUTE_FROM_CONFIG(config),config, buf, bufLen, TLS_PARSE_TYPE_BUFF, format);
if (newCert == NULL) {
return HITLS_CFG_ERR_LOAD_CERT_BUFFER;
}
int ret = HITLS_SUCCESS;
#ifdef HITLS_TLS_FEATURE_SECURITY
ret = CheckCertSecuritylevel(config, newCert, false);
if (ret != HITLS_SUCCESS) {
SAL_CERT_X509Free(newCert);
return ret;
}
#endif
ret = SAL_CERT_SetCurrentCert(config, newCert, false);
if (ret != HITLS_SUCCESS) {
SAL_CERT_X509Free(newCert);
}
return ret;
}
HITLS_CERT_X509 *HITLS_CFG_GetCertificate(const HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return SAL_CERT_GetCurrentCert(config->certMgrCtx);
}
static int32_t CFG_SetPrivateKey(HITLS_Config *config, HITLS_CERT_Key *privateKey, bool isClone,
bool isTlcpEncCertPriKey)
{
if (config == NULL || privateKey == NULL) {
return HITLS_NULL_INPUT;
}
HITLS_CERT_Key *newKey = NULL;
if (isClone) {
newKey = SAL_CERT_KeyDup(config->certMgrCtx, privateKey);
if (newKey == NULL) {
return HITLS_CERT_ERR_X509_DUP;
}
} else {
newKey = privateKey;
}
int32_t ret = SAL_CERT_SetCurrentPrivateKey(config, newKey, isTlcpEncCertPriKey);
if (ret != HITLS_SUCCESS) {
if (isClone) {
SAL_CERT_KeyFree(config->certMgrCtx, newKey);
}
}
return ret;
}
#ifdef HITLS_TLS_PROTO_TLCP11
int32_t HITLS_CFG_SetTlcpPrivateKey(HITLS_Config *config, HITLS_CERT_Key *privateKey,
bool isClone, bool isTlcpEncCertPriKey)
{
return CFG_SetPrivateKey(config, privateKey, isClone, isTlcpEncCertPriKey);
}
int32_t HITLS_CFG_SetTlcpCertificate(HITLS_Config *config, HITLS_CERT_X509 *cert, bool isClone, bool isTlcpEncCert)
{
return CFG_SetCertificate(config, cert, isClone, isTlcpEncCert);
}
#endif
int32_t HITLS_CFG_SetPrivateKey(HITLS_Config *config, HITLS_CERT_Key *privateKey, bool isClone)
{
return CFG_SetPrivateKey(config, privateKey, isClone, false);
}
#ifdef HITLS_TLS_CONFIG_CERT_LOAD_FILE
int32_t HITLS_CFG_ProviderLoadKeyFile(HITLS_Config *config, const char *file, const char *format, const char *type)
{
if (config == NULL || file == NULL || strlen(file) == 0) {
return HITLS_NULL_INPUT;
}
HITLS_CERT_Key *newKey = SAL_CERT_KeyParse(config, (const uint8_t *)file, (uint32_t)strlen(file),
TLS_PARSE_TYPE_FILE, format, type);
if (newKey == NULL) {
return HITLS_CFG_ERR_LOAD_KEY_FILE;
}
int32_t ret = SAL_CERT_SetCurrentPrivateKey(config, newKey, false);
if (ret != HITLS_SUCCESS) {
SAL_CERT_KeyFree(config->certMgrCtx, newKey);
}
return ret;
}
int32_t HITLS_CFG_LoadKeyFile(HITLS_Config *config, const char *file, HITLS_ParseFormat format)
{
if (config == NULL || file == NULL || strlen(file) == 0) {
return HITLS_NULL_INPUT;
}
HITLS_CERT_Key *newKey = SAL_CERT_KeyParse(config, (const uint8_t *)file, (uint32_t)strlen(file),
TLS_PARSE_TYPE_FILE, SAL_CERT_GetParseFormatStr(format), NULL);
if (newKey == NULL) {
return HITLS_CFG_ERR_LOAD_KEY_FILE;
}
int32_t ret = SAL_CERT_SetCurrentPrivateKey(config, newKey, false);
if (ret != HITLS_SUCCESS) {
SAL_CERT_KeyFree(config->certMgrCtx, newKey);
}
return ret;
}
#endif /* HITLS_TLS_CONFIG_CERT_LOAD_FILE */
int32_t HITLS_CFG_ProviderLoadKeyBuffer(HITLS_Config *config, const uint8_t *buf, uint32_t bufLen, const char *format,
const char *type)
{
if (config == NULL || buf == NULL || bufLen == 0) {
return HITLS_NULL_INPUT;
}
HITLS_CERT_Key *newKey = SAL_CERT_KeyParse(config, buf, bufLen, TLS_PARSE_TYPE_BUFF, type, format);
if (newKey == NULL) {
return HITLS_CFG_ERR_LOAD_KEY_BUFFER;
}
int32_t ret = SAL_CERT_SetCurrentPrivateKey(config, newKey, false);
if (ret != HITLS_SUCCESS) {
SAL_CERT_KeyFree(config->certMgrCtx, newKey);
}
return ret;
}
int32_t HITLS_CFG_LoadKeyBuffer(HITLS_Config *config, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format)
{
if (config == NULL || buf == NULL || bufLen == 0) {
return HITLS_NULL_INPUT;
}
HITLS_CERT_Key *newKey = SAL_CERT_KeyParse(config, buf, bufLen, TLS_PARSE_TYPE_BUFF,
SAL_CERT_GetParseFormatStr(format), NULL);
if (newKey == NULL) {
return HITLS_CFG_ERR_LOAD_KEY_BUFFER;
}
int32_t ret = SAL_CERT_SetCurrentPrivateKey(config, newKey, false);
if (ret != HITLS_SUCCESS) {
SAL_CERT_KeyFree(config->certMgrCtx, newKey);
}
return ret;
}
HITLS_CERT_Key *HITLS_CFG_GetPrivateKey(HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return SAL_CERT_GetCurrentPrivateKey(config->certMgrCtx, false);
}
int32_t HITLS_CFG_CheckPrivateKey(HITLS_Config *config)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
CERT_MgrCtx *certMgrCtx = config->certMgrCtx;
if (certMgrCtx == NULL) {
/* If no certificate callback is registered, the certificate management module will not initialized. */
return HITLS_UNREGISTERED_CALLBACK;
}
HITLS_CERT_X509 *cert = SAL_CERT_GetCurrentCert(certMgrCtx);
if (cert == NULL) {
/* no certificate is added */
return HITLS_CONFIG_NO_CERT;
}
HITLS_CERT_Key *privateKey = SAL_CERT_GetCurrentPrivateKey(certMgrCtx, false);
if (privateKey == NULL) {
/* no private key is added */
return HITLS_CONFIG_NO_PRIVATE_KEY;
}
return SAL_CERT_CheckPrivateKey(config, cert, privateKey);
}
int32_t HITLS_CFG_AddChainCert(HITLS_Config *config, HITLS_CERT_X509 *cert, bool isClone)
{
if (config == NULL || cert == NULL || config->certMgrCtx == NULL) {
return HITLS_NULL_INPUT;
}
int32_t ret = HITLS_SUCCESS;
#ifdef HITLS_TLS_FEATURE_SECURITY
ret = CheckCertSecuritylevel(config, cert, true);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif
HITLS_CERT_X509 *newCert = cert;
if (isClone) {
newCert = SAL_CERT_X509Dup(config->certMgrCtx, cert);
if (newCert == NULL) {
return HITLS_CERT_ERR_X509_DUP;
}
}
ret = SAL_CERT_AddChainCert(config->certMgrCtx, newCert);
if (ret != HITLS_SUCCESS) {
if (isClone) {
SAL_CERT_X509Free(newCert);
}
}
return ret;
}
int32_t HITLS_CFG_AddCertToStore(HITLS_Config *config, HITLS_CERT_X509 *cert, HITLS_CERT_StoreType storeType,
bool isClone)
{
if (config == NULL || cert == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
HITLS_CERT_Store *store = NULL;
switch (storeType) {
case TLS_CERT_STORE_TYPE_DEFAULT:
store = SAL_CERT_GetCertStore(config->certMgrCtx);
break;
case TLS_CERT_STORE_TYPE_VERIFY:
store = SAL_CERT_GetVerifyStore(config->certMgrCtx);
break;
case TLS_CERT_STORE_TYPE_CHAIN:
store = SAL_CERT_GetChainStore(config->certMgrCtx);
break;
default:
return HITLS_CERT_ERR_INVALID_STORE_TYPE;
}
HITLS_CERT_X509 *newCert = cert;
if (isClone) {
newCert = SAL_CERT_X509Dup(config->certMgrCtx, cert);
if (newCert == NULL) {
return HITLS_CERT_ERR_X509_DUP;
}
}
int32_t ret = SAL_CERT_StoreCtrl(config, store, CERT_STORE_CTRL_ADD_CERT_LIST, newCert, NULL);
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
if (isClone) {
SAL_CERT_X509Free(newCert);
}
}
return ret;
}
HITLS_CERT_X509 *HITLS_CFG_ParseCert(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, HITLS_ParseFormat format)
{
if (config == NULL || buf == NULL || len == 0) {
return NULL;
}
HITLS_CERT_X509 *newCert = SAL_CERT_X509Parse(LIBCTX_FROM_CONFIG(config),
ATTRIBUTE_FROM_CONFIG(config), config, buf, len, type, format);
if (newCert == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17158, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"X509Parse fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CFG_ERR_LOAD_CERT_BUFFER);
return NULL;
}
return newCert;
}
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)
{
if (config == NULL || buf == NULL || len == 0) {
return NULL;
}
HITLS_CERT_Key *newKey = SAL_CERT_KeyParse(config, buf, len, type, format, encodeType);
if (newKey == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17165, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Provider KeyParse fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CFG_ERR_LOAD_KEY_BUFFER);
return NULL;
}
return newKey;
}
HITLS_CERT_Key *HITLS_CFG_ParseKey(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, HITLS_ParseFormat format)
{
if (config == NULL || buf == NULL || len == 0) {
return NULL;
}
HITLS_CERT_Key *newKey = SAL_CERT_KeyParse(config, buf, len, type,
SAL_CERT_GetParseFormatStr(format), NULL);
if (newKey == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17164, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"KeyParse fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CFG_ERR_LOAD_KEY_BUFFER);
return NULL;
}
return newKey;
}
HITLS_CERT_Chain *HITLS_CFG_GetChainCerts(HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return SAL_CERT_GetCurrentChainCerts(config->certMgrCtx);
}
int32_t HITLS_CFG_ClearChainCerts(HITLS_Config *config)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
SAL_CERT_ClearCurrentChainCerts(config->certMgrCtx);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_AddExtraChainCert(HITLS_Config *config, HITLS_CERT_X509 *cert)
{
if (config == NULL || cert == NULL) {
return HITLS_NULL_INPUT;
}
return SAL_CERT_AddExtraChainCert(config->certMgrCtx, cert);
}
HITLS_CERT_Chain *HITLS_CFG_GetExtraChainCerts(HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return SAL_CERT_GetExtraChainCerts(config->certMgrCtx, false);
}
int32_t HITLS_CFG_ClearExtraChainCerts(HITLS_Config *config)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
SAL_CERT_ClearExtraChainCerts(config->certMgrCtx);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_RemoveCertAndKey(HITLS_Config *config)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
SAL_CERT_ClearCertAndKey(config->certMgrCtx);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetVerifyCb(HITLS_Config *config, HITLS_VerifyCb callback)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
return SAL_CERT_SetVerifyCb(config->certMgrCtx, callback);
}
HITLS_VerifyCb HITLS_CFG_GetVerifyCb(HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return SAL_CERT_GetVerifyCb(config->certMgrCtx);
}
#ifdef HITLS_TLS_FEATURE_CERT_CB
int32_t HITLS_CFG_SetCertCb(HITLS_Config *config, HITLS_CertCb certCb, void *arg)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
return SAL_CERT_SetCertCb(config->certMgrCtx, certCb, arg);
}
#endif /* HITLS_TLS_FEATURE_CERT_CB */
#ifdef HITLS_TLS_FEATURE_CERT_MODE
int32_t HITLS_CFG_SetVerifyNoneSupport(HITLS_Config *config, bool support)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isSupportVerifyNone = support;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetVerifyNoneSupport(HITLS_Config *config, uint8_t *isSupport)
{
if (config == NULL || isSupport == NULL) {
return HITLS_NULL_INPUT;
}
*isSupport = (uint8_t)config->isSupportVerifyNone;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetClientVerifySupport(HITLS_Config *config, uint8_t *isSupport)
{
if (config == NULL || isSupport == NULL) {
return HITLS_NULL_INPUT;
}
*isSupport = (uint8_t)config->isSupportClientVerify;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetNoClientCertSupport(HITLS_Config *config, uint8_t *isSupport)
{
if (config == NULL || isSupport == NULL) {
return HITLS_NULL_INPUT;
}
*isSupport = (uint8_t)config->isSupportNoClientCert;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetClientVerifySupport(HITLS_Config *config, bool support)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isSupportClientVerify = support;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetNoClientCertSupport(HITLS_Config *config, bool support)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isSupportNoClientCert = support;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES
static void HitlsTrustedCANodeFree(void *caNode)
{
if (caNode == NULL) {
return;
}
HITLS_TrustedCANode *newCaNode = (HITLS_TrustedCANode *)caNode;
BSL_SAL_FREE(newCaNode->data);
newCaNode->data = NULL;
BSL_SAL_FREE(newCaNode);
}
void HITLS_CFG_ClearCAList(HITLS_Config *config)
{
if (config == NULL) {
return;
}
BSL_LIST_FREE(config->caList, HitlsTrustedCANodeFree);
config->caList = NULL;
return;
}
int32_t HITLS_CFG_AddCAIndication(HITLS_Config *config, HITLS_TrustedCAType caType, const uint8_t *data, uint32_t len)
{
if ((config == NULL) || (data == NULL) || (len == 0)) {
return HITLS_NULL_INPUT;
}
HITLS_TrustedCANode *newCaNode = BSL_SAL_Calloc(1u, sizeof(HITLS_TrustedCANode));
if (newCaNode == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16558, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
newCaNode->caType = caType;
if (len >= UINT16_MAX) {
BSL_SAL_FREE(newCaNode);
return HITLS_CONFIG_INVALID_LENGTH;
}
newCaNode->data = BSL_SAL_Dump(data, len);
if (newCaNode->data == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16559, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
BSL_SAL_FREE(newCaNode);
return HITLS_MEMALLOC_FAIL;
}
newCaNode->dataSize = len;
if (config->caList == NULL) {
config->caList = BSL_LIST_New(sizeof(HITLS_TrustedCANode *));
if (config->caList == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16560, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"LIST_New fail", 0, 0, 0, 0);
BSL_SAL_FREE(newCaNode->data);
BSL_SAL_FREE(newCaNode);
return HITLS_MEMALLOC_FAIL;
}
}
/* tail insertion */
int32_t ret = (int32_t)BSL_LIST_AddElement((BslList *)config->caList, newCaNode, BSL_LIST_POS_END);
if (ret != 0) {
BSL_SAL_FREE(newCaNode->data);
BSL_SAL_FREE(newCaNode);
}
return ret;
}
HITLS_TrustedCAList *HITLS_CFG_GetCAList(const HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return config->caList;
}
int32_t HITLS_CFG_SetCAList(HITLS_Config *config, HITLS_TrustedCAList *list)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
if (config->caList != NULL) {
HITLS_CFG_ClearCAList(config);
}
config->caList = list;
return HITLS_SUCCESS;
}
static int32_t ParseAndGetSubjectDN(HITLS_Config *config, const char *input, uint32_t len, HITLS_ParseFormat format,
HITLS_ParseType type, BSL_Buffer *nodeBufferOut)
{
if (config == NULL || input == NULL || len == 0 || nodeBufferOut == NULL) {
return HITLS_NULL_INPUT;
}
int32_t ret;
HITLS_CERT_X509 *cert = SAL_CERT_X509Parse(LIBCTX_FROM_CONFIG(config),
ATTRIBUTE_FROM_CONFIG(config), config, (const uint8_t *)input, len,
type, format);
if (cert == NULL) {
return HITLS_CFG_ERR_LOAD_CERT_FILE;
}
#ifdef HITLS_TLS_FEATURE_SECURITY
ret = CheckCertSecuritylevel(config, cert, false);
if (ret != HITLS_SUCCESS) {
SAL_CERT_X509Free(cert);
return ret;
}
#endif
ret = SAL_CERT_X509Ctrl(config, cert, CERT_CTRL_GET_ENCODE_SUBJECT_DN, NULL, (void *)nodeBufferOut);
if (ret != HITLS_SUCCESS) {
SAL_CERT_X509Free(cert);
return ret;
}
SAL_CERT_X509Free(cert);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_ParseCAList(HITLS_Config *config, const char *input, uint32_t inputLen, HITLS_ParseType inputType,
HITLS_ParseFormat format, HITLS_TrustedCAList **caList)
{
if (config == NULL || input == NULL || inputLen == 0) {
return HITLS_NULL_INPUT;
}
int32_t ret;
HITLS_TrustedCAList *list = NULL;
HITLS_TrustedCANode *newCaNode = BSL_SAL_Calloc(1u, sizeof(HITLS_TrustedCANode));
if (newCaNode == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17367, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
ret = HITLS_MEMALLOC_FAIL;
goto ERR;
}
BSL_Buffer nodeBuffer = {0};
ret = ParseAndGetSubjectDN(config, input, inputLen, format, inputType, &nodeBuffer);
if (ret != HITLS_SUCCESS) {
goto ERR;
}
newCaNode->caType = HITLS_TRUSTED_CA_X509_NAME;
newCaNode->data = nodeBuffer.data;
newCaNode->dataSize = nodeBuffer.dataLen;
list = BSL_LIST_New(sizeof(HITLS_TrustedCANode *));
if (list == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17366, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"LIST_New fail", 0, 0, 0, 0);
ret = HITLS_MEMALLOC_FAIL;
goto ERR;
}
ret = BSL_LIST_AddElement(list, newCaNode, BSL_LIST_POS_END);
if (ret != BSL_SUCCESS) {
goto ERR;
}
*caList = list;
return ret;
ERR:
BSL_LIST_FREE(list, HitlsTrustedCANodeFree);
if (newCaNode != NULL) {
BSL_SAL_Free(newCaNode->data);
}
BSL_SAL_Free(newCaNode);
return ret;
}
#endif /* HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES */
#ifdef HITLS_TLS_CONFIG_CERT_BUILD_CHAIN
static void FreeCertList(HITLS_CERT_X509 **certList, uint32_t certNum)
{
if (certList == NULL) {
return;
}
for (uint32_t i = 0; i < certNum; i++) {
SAL_CERT_X509Free(certList[i]);
}
}
static int32_t CFG_BuildCertChain(HITLS_Config *config, HITLS_CERT_Store *store, HITLS_CERT_X509 *cert,
HITLS_BUILD_CHAIN_FLAG flag)
{
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
HITLS_CERT_X509 *certList[TLS_DEFAULT_VERIFY_DEPTH] = {0};
uint32_t certNum = TLS_DEFAULT_VERIFY_DEPTH;
int32_t ret = SAL_CERT_BuildChain(config, store, cert, certList, &certNum);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (flag & HITLS_BUILD_CHAIN_FLAG_NO_ROOT) {
if (certNum > 0) {
bool isSelfSigned = false;
ret =
SAL_CERT_X509Ctrl(config, certList[certNum - 1], CERT_CTRL_IS_SELF_SIGNED, NULL, (void *)&isSelfSigned);
if (ret != HITLS_SUCCESS) {
FreeCertList(certList, certNum);
return ret;
}
if (isSelfSigned) {
SAL_CERT_X509Free(certList[certNum - 1]);
certNum--;
}
}
}
#ifdef HITLS_TLS_FEATURE_SECURITY
ret = CheckCertSecuritylevel(config, cert, false);
if (ret != HITLS_SUCCESS) {
FreeCertList(certList, certNum);
return ret;
}
#endif
SAL_CERT_ClearCurrentChainCerts(mgrCtx);
for (uint32_t i = 1; i < certNum; i++) {
#ifdef HITLS_TLS_FEATURE_SECURITY
ret = CheckCertSecuritylevel(config, certList[i], true);
if (ret != HITLS_SUCCESS) {
FreeCertList(certList, certNum);
return ret;
}
#endif
HITLS_CERT_X509 *tempCert = SAL_CERT_X509Ref(mgrCtx, certList[i]);
ret = SAL_CERT_AddChainCert(mgrCtx, tempCert);
if (ret != HITLS_SUCCESS) {
SAL_CERT_X509Free(tempCert);
FreeCertList(certList, certNum);
return ret;
}
}
FreeCertList(certList, certNum);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_BuildCertChain(HITLS_Config *config, HITLS_BUILD_CHAIN_FLAG flag)
{
if (config == NULL || config->certMgrCtx == NULL) {
return HITLS_NULL_INPUT;
}
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
int32_t ret = HITLS_SUCCESS;
HITLS_CERT_X509 *cert = SAL_CERT_GetCurrentCert(mgrCtx);
if (cert == NULL) {
/* no certificate is added */
return HITLS_CONFIG_NO_CERT;
}
HITLS_CERT_Store *store = NULL;
if (flag & HITLS_BUILD_CHAIN_FLAG_CHECK) {
HITLS_CERT_Chain *chainCertList = SAL_CERT_GetCurrentChainCerts(mgrCtx);
if (chainCertList == NULL) {
return HITLS_SUCCESS;
}
store = SAL_CERT_StoreNew(mgrCtx);
if (store == NULL) {
return HITLS_MEMALLOC_FAIL;
}
HITLS_CERT_X509 *tempCert = (HITLS_CERT_X509 *)BSL_LIST_GET_FIRST(chainCertList);
while (tempCert != NULL) {
HITLS_CERT_X509 *refCert = SAL_CERT_X509Ref(mgrCtx, tempCert);
ret = SAL_CERT_StoreCtrl(config, store, CERT_STORE_CTRL_ADD_CERT_LIST, refCert, NULL);
if (ret != HITLS_SUCCESS) {
SAL_CERT_X509Free(refCert);
SAL_CERT_StoreFree(mgrCtx, store);
return ret;
}
tempCert = (HITLS_CERT_X509 *)BSL_LIST_GET_NEXT(chainCertList);
}
} else {
HITLS_CERT_Store *chainStore = SAL_CERT_GetChainStore(mgrCtx);
HITLS_CERT_Store *certStore = SAL_CERT_GetCertStore(mgrCtx);
store = (chainStore != NULL) ? chainStore : certStore;
if (store == NULL) {
SAL_CERT_ClearCurrentChainCerts(mgrCtx);
return HITLS_SUCCESS;
}
}
ret = CFG_BuildCertChain(config, store, cert, flag);
if (flag & HITLS_BUILD_CHAIN_FLAG_CHECK) {
SAL_CERT_StoreFree(mgrCtx, store);
}
return ret;
}
#endif
int32_t HITLS_CFG_CtrlSetVerifyParams(
HITLS_Config *config, HITLS_CERT_Store *store, uint32_t cmd, int64_t in, void *inArg)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
if (inArg == NULL) {
return SAL_CERT_CtrlVerifyParams(config, store, cmd, &in, NULL);
}
return SAL_CERT_CtrlVerifyParams(config, store, cmd, inArg, NULL);
}
int32_t HITLS_CFG_CtrlGetVerifyParams(HITLS_Config *config, HITLS_CERT_Store *store, uint32_t cmd, void *out)
{
if (config == NULL || out == NULL) {
return HITLS_NULL_INPUT;
}
return SAL_CERT_CtrlVerifyParams(config, store, cmd, NULL, out);
}
static int32_t LoadCrlCommon(HITLS_Config *config, const uint8_t *data, uint32_t dataLen,
HITLS_ParseType parseType, HITLS_ParseFormat format,
uint32_t crlParseFailErr)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
if (mgrCtx == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID16566, "unregistered callback");
}
HITLS_CERT_CRLList *crlList = SAL_CERT_CrlParse(config, data, dataLen, parseType, format);
if (crlList == NULL) {
return crlParseFailErr;
}
HITLS_CERT_Store *certStore = SAL_CERT_GetVerifyStore(mgrCtx) == NULL ?
SAL_CERT_GetCertStore(mgrCtx) : SAL_CERT_GetVerifyStore(mgrCtx);
if (certStore == NULL) {
SAL_CERT_CrlFree(crlList);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CONFIG_NO_CERT, BINLOG_ID16567, "store is null");
}
int32_t ret = SAL_CERT_StoreCtrl(config, certStore, CERT_STORE_CTRL_ADD_CRL_LIST, crlList, NULL);
SAL_CERT_CrlFree(crlList);
return ret;
}
int32_t HITLS_CFG_LoadCrlFile(HITLS_Config *config, const char *file, HITLS_ParseFormat format)
{
if (file == NULL || strlen(file) == 0) {
return HITLS_NULL_INPUT;
}
return LoadCrlCommon(config, (const uint8_t *)file, (uint32_t)strlen(file),
TLS_PARSE_TYPE_FILE, format, HITLS_CFG_ERR_LOAD_CRL_FILE);
}
int32_t HITLS_CFG_LoadCrlBuffer(HITLS_Config *config, const uint8_t *buf, uint32_t bufLen, HITLS_ParseFormat format)
{
if (buf == NULL || bufLen == 0) {
return HITLS_NULL_INPUT;
}
return LoadCrlCommon(config, buf, bufLen, TLS_PARSE_TYPE_BUFF, format,
HITLS_CFG_ERR_LOAD_CRL_BUFFER);
}
int32_t HITLS_CFG_ClearVerifyCrls(HITLS_Config *config)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
if (mgrCtx == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID16569, "unregistered callback");
}
HITLS_CERT_Store *certStore = SAL_CERT_GetCertStore(mgrCtx);
if (certStore == NULL) {
return HITLS_SUCCESS; /* No store, nothing to clear */
}
return SAL_CERT_StoreCtrl(config, certStore, CERT_STORE_CTRL_CLEAR_CRL_LIST, NULL, NULL);
}
#ifdef HITLS_TLS_CONFIG_CERT_LOAD_FILE
int32_t HITLS_CFG_UseCertificateChainFile(HITLS_Config *config, const char *file)
{
if (config == NULL || file == NULL) {
return HITLS_NULL_INPUT;
}
int32_t ret = HITLS_SUCCESS;
HITLS_CERT_Chain *certList = SAL_CERT_X509ParseBundleFile(LIBCTX_FROM_CONFIG(config), ATTRIBUTE_FROM_CONFIG(config),
config, (const uint8_t *)file, (uint32_t)strlen(file),
TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_PEM);
if (certList == NULL) {
return HITLS_CFG_ERR_LOAD_CERT_FILE;
}
HITLS_CERT_X509 *tempCert = (HITLS_CERT_X509 *)BSL_LIST_GET_FIRST(certList);
if (tempCert == NULL) {
SAL_CERT_ChainFree(certList);
return HITLS_CFG_ERR_LOAD_CERT_FILE;
}
ret = HITLS_CFG_SetCertificate(config, tempCert, true);
if (ret != HITLS_SUCCESS) {
SAL_CERT_ChainFree(certList);
return ret;
}
tempCert = (HITLS_CERT_X509 *)BSL_LIST_GET_NEXT(certList);
if (tempCert != NULL) {
ret = HITLS_CFG_ClearChainCerts(config);
if (ret != HITLS_SUCCESS) {
SAL_CERT_ChainFree(certList);
return ret;
}
}
while (tempCert != NULL) {
ret = HITLS_CFG_AddChainCert(config, tempCert, true);
if (ret != HITLS_SUCCESS) {
SAL_CERT_ChainFree(certList);
return ret;
}
tempCert = (HITLS_CERT_X509 *)BSL_LIST_GET_NEXT(certList);
}
SAL_CERT_ChainFree(certList);
return ret;
}
int32_t HITLS_CFG_LoadVerifyFile(HITLS_Config *config, const char *file)
{
if (config == NULL || file == NULL || strlen(file) == 0 || config->certMgrCtx == NULL) {
return HITLS_NULL_INPUT;
}
int32_t ret;
HITLS_CERT_X509 *cert =
SAL_CERT_X509Parse(LIBCTX_FROM_CONFIG(config), ATTRIBUTE_FROM_CONFIG(config), config, (const uint8_t *)file,
(uint32_t)strlen(file), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_PEM);
if (cert == NULL) {
return HITLS_CFG_ERR_LOAD_CERT_FILE;
}
#ifdef HITLS_TLS_FEATURE_SECURITY
ret = CheckCertSecuritylevel(config, cert, false);
if (ret != HITLS_SUCCESS) {
SAL_CERT_X509Free(cert);
return ret;
}
#endif
HITLS_CERT_Store *store = SAL_CERT_GetCertStore(config->certMgrCtx);
ret = SAL_CERT_StoreCtrl(config, store, CERT_STORE_CTRL_ADD_CERT_LIST, cert, NULL);
if (ret != HITLS_SUCCESS) {
SAL_CERT_X509Free(cert);
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
#endif /* HITLS_TLS_CONFIG_CERT_LOAD_FILE */
static int32_t LoadVerifyDirAddPath(HITLS_Config *config, HITLS_CERT_Store *store,
const char *start, size_t len)
{
if (start == NULL) {
return HITLS_CONFIG_INVALID_LENGTH;
}
if (len == 0) {
return HITLS_SUCCESS; /* nothing to add */
}
if (len >= MAX_PATH_LEN) {
return HITLS_CONFIG_INVALID_LENGTH;
}
char buf[MAX_PATH_LEN + 1] = {0};
if (memcpy_s(buf, sizeof(buf), start, len) != EOK) {
return HITLS_MEMCPY_FAIL;
}
buf[len] = '\0';
return SAL_CERT_StoreCtrl(config, store, CERT_STORE_CTRL_ADD_CA_PATH, (void *)buf, NULL);
}
int32_t HITLS_CFG_LoadVerifyDir(HITLS_Config *config, const char *path)
{
if (config == NULL || path == NULL || strlen(path) == 0 || config->certMgrCtx == NULL) {
return HITLS_NULL_INPUT;
}
HITLS_CERT_Store *store = SAL_CERT_GetCertStore(config->certMgrCtx);
/* Single path without separator */
if (strchr(path, ':') == NULL) {
return LoadVerifyDirAddPath(config, store, path, strlen(path));
}
/* Multiple colon-separated paths */
int32_t ret = HITLS_SUCCESS;
const char *start = path;
const char *p = path;
while (*p != '\0') {
if (*p == ':') {
uint32_t len = (uint32_t)(p - start);
ret = LoadVerifyDirAddPath(config, store, start, len);
if (ret != HITLS_SUCCESS) {
return ret;
}
start = p + 1;
}
p++;
}
/* trailing segment */
if (start < p) {
ret = LoadVerifyDirAddPath(config, store, start, (uint32_t)(p - start));
}
return ret;
}
int32_t HITLS_CFG_FreeCert(HITLS_Config *config, HITLS_CERT_X509 *cert)
{
if (config == NULL || config->certMgrCtx == NULL) {
return HITLS_NULL_INPUT;
}
SAL_CERT_X509Free(cert);
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_FreeKey(HITLS_Config *config, HITLS_CERT_Key *key)
{
if (config == NULL || config->certMgrCtx == NULL) {
return HITLS_NULL_INPUT;
}
SAL_CERT_KeyFree(config->certMgrCtx, key);
return HITLS_SUCCESS;
} | 2302_82127028/openHiTLS-examples_1508 | tls/config/src/config_cert.c | C | unknown | 38,730 |
/*
* 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.
*/
#include <stdbool.h>
#include <stdint.h>
#include "hitls_build.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "hitls_crypt_type.h"
#include "hitls_cert_type.h"
#include "hitls_error.h"
#include "hitls_config.h"
#include "tls.h"
#include "tls_config.h"
#include "cipher_suite.h"
#include "config_type.h"
static bool CFG_IsValidVersion(uint16_t version)
{
switch (version) {
case HITLS_VERSION_TLS12:
case HITLS_VERSION_TLS13:
case HITLS_VERSION_DTLS12:
case HITLS_VERSION_TLCP_DTLCP11:
return true;
default:
break;
}
return false;
}
static bool HaveMatchSignAlg(const TLS_Config *config, HITLS_AuthAlgo authAlg, const uint16_t *signatureAlgorithms,
uint32_t signatureAlgorithmsSize)
{
HITLS_SignAlgo signAlg = HITLS_SIGN_BUTT;
/** Traverse the signature algorithms. If the matching is successful, return true */
for (uint32_t i = 0u; i < signatureAlgorithmsSize; i++) {
const TLS_SigSchemeInfo *info = ConfigGetSignatureSchemeInfo(config, signatureAlgorithms[i]);
if (info == NULL) {
continue;
}
signAlg = info->signAlgId;
if (((signAlg == HITLS_SIGN_RSA_PKCS1_V15) || (signAlg == HITLS_SIGN_RSA_PSS)) &&
(authAlg == HITLS_AUTH_RSA)) {
return true;
}
if (((signAlg == HITLS_SIGN_ECDSA) || (signAlg == HITLS_SIGN_ED25519)) &&
(authAlg == HITLS_AUTH_ECDSA)) {
return true;
}
if (signAlg == HITLS_SIGN_DSA && authAlg == HITLS_AUTH_DSS) {
return true;
}
if (signAlg == HITLS_SIGN_SM2 && authAlg == HITLS_AUTH_SM2) {
return true;
}
}
return false;
}
static int32_t CheckPointFormats(const TLS_Config *config)
{
if ((config->pointFormats == NULL) || (config->pointFormatsSize == 0)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16561, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"pointFormats null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_SET);
return HITLS_CONFIG_INVALID_SET;
}
/** Currently, only one point format is supported */
if ((config->pointFormatsSize != 1) || (config->pointFormats[0] != HITLS_POINT_FORMAT_UNCOMPRESSED)) {
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_UNSUPPORT_POINT_FORMATS);
return HITLS_CONFIG_UNSUPPORT_POINT_FORMATS;
}
return HITLS_SUCCESS;
}
static bool IsCipherSuiteValid(const TLS_Config *config, uint16_t cipherSuite)
{
if ((CFG_CheckCipherSuiteSupported(cipherSuite) != true) ||
(CFG_CheckCipherSuiteVersion(cipherSuite, config->minVersion, config->maxVersion) != true)) {
/* The cipher suite must match the configured version */
return false;
}
return true;
}
static int32_t CheckSign(const TLS_Config *config)
{
uint16_t *signAlgorithms = config->signAlgorithms;
uint32_t signAlgorithmsSize = config->signAlgorithmsSize;
/** If the signature algorithm is empty, the default signature algorithm in the cipher suite is used and no further
* check is required */
if ((signAlgorithms == NULL) || (signAlgorithmsSize == 0)) {
return HITLS_SUCCESS;
}
/** Check the validity of the signature algorithms one by one */
for (uint32_t i = 0; i < signAlgorithmsSize; i++) {
if (ConfigGetSignatureSchemeInfo(config, signAlgorithms[i]) == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_UNSUPPORT_SIGNATURE_ALGORITHM);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15779, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
"Unsupported signature algorithms: 0x%04x.", signAlgorithms[i], 0, 0, 0);
return HITLS_CONFIG_UNSUPPORT_SIGNATURE_ALGORITHM;
}
}
/*
In this case, only the 1.3 cipher suite is configured, or only TLS1.3 is supported.
The authentication algorithm is not specified in the TLS 1.3 cipher suite and therefore does not need to be
checked.
*/
if (config->cipherSuitesSize == 0 || ((config->minVersion == HITLS_VERSION_TLS13) &&
(config->maxVersion == HITLS_VERSION_TLS13))) {
return HITLS_SUCCESS;
}
/** Check the compatibility between the signature algorithm and the cipher suite */
for (uint32_t i = 0; i < config->cipherSuitesSize; i++) {
CipherSuiteInfo info = {0};
if (IsCipherSuiteValid(config, config->cipherSuites[i]) == false) {
continue;
}
(void)CFG_GetCipherSuiteInfo(config->cipherSuites[i], &info);
/** PSK does not require the signature algorithm */
if ((info.kxAlg == HITLS_KEY_EXCH_PSK) || (info.kxAlg == HITLS_KEY_EXCH_DHE_PSK) ||
(info.kxAlg == HITLS_KEY_EXCH_ECDHE_PSK)) {
return HITLS_SUCCESS;
}
/* Anon does not require the signature algorithm */
if (info.authAlg == HITLS_AUTH_NULL) {
return HITLS_SUCCESS;
}
/** Check whether a signature algorithm matching the cipher suite exists */
if (HaveMatchSignAlg(config, info.authAlg, signAlgorithms, signAlgorithmsSize)) {
return HITLS_SUCCESS;
}
}
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_NO_SUITABLE_SIGNATURE_ALGORITHM);
return HITLS_CONFIG_NO_SUITABLE_SIGNATURE_ALGORITHM;
}
static bool IsHaveEccCipherSuite(const TLS_Config *config)
{
for (uint32_t i = 0u; i < config->cipherSuitesSize; i++) {
CipherSuiteInfo info = {0};
if (IsCipherSuiteValid(config, config->cipherSuites[i]) == false) {
continue;
}
(void)CFG_GetCipherSuiteInfo(config->cipherSuites[i], &info);
/* The ECC cipher suite exists */
if ((info.authAlg == HITLS_AUTH_ECDSA) ||
(info.kxAlg == HITLS_KEY_EXCH_ECDHE) ||
(info.kxAlg == HITLS_KEY_EXCH_ECDH) ||
(info.kxAlg == HITLS_KEY_EXCH_ECDHE_PSK)) {
return true;
}
}
return false;
}
static int32_t CheckGroup(const TLS_Config *config)
{
if (config->groupsSize == 0u) {
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_NO_GROUPS);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15780, BSL_LOG_LEVEL_WARN, BSL_LOG_BINLOG_TYPE_RUN,
"Set ecdhe cipher with no group id", 0, 0, 0, 0);
return HITLS_CONFIG_NO_GROUPS;
}
return HITLS_SUCCESS;
}
int32_t CheckVersion(uint16_t minVersion, uint16_t maxVersion)
{
if ((CFG_IsValidVersion(minVersion) == false) || (CFG_IsValidVersion(maxVersion) == false) ||
(IS_DTLS_VERSION(minVersion) != IS_DTLS_VERSION(maxVersion))) {
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_VERSION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15781, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Config max version [0x%x] or min version [0x%x] is invalid.", maxVersion, minVersion, 0, 0);
return HITLS_CONFIG_INVALID_VERSION;
}
if ((IS_DTLS_VERSION(maxVersion) && (maxVersion > minVersion))) {
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_VERSION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15782, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Config max version [0x%x] or min version [0x%x] is invalid.", maxVersion, minVersion, 0, 0);
return HITLS_CONFIG_INVALID_VERSION;
}
if ((IS_DTLS_VERSION(maxVersion) == false) && (maxVersion < minVersion)) {
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_VERSION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15783, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Config max version [0x%x] or min version [0x%x] is invalid.", maxVersion, minVersion, 0, 0);
return HITLS_CONFIG_INVALID_VERSION;
}
#ifdef HITLS_TLS_PROTO_TLCP11
if (minVersion == HITLS_VERSION_TLCP_DTLCP11 || maxVersion == HITLS_VERSION_TLCP_DTLCP11) {
if (minVersion != maxVersion) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16233, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Config max version [0x%x] or min version [0x%x] is invalid.", maxVersion,
minVersion, 0, 0);
return HITLS_CONFIG_INVALID_VERSION;
}
}
#endif
return HITLS_SUCCESS;
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
static int32_t CheckCallbackFunc(const TLS_Config *config)
{
/* Check the cookie callback. The user must register the cookie callback at the same time or
not register the cookie callback */
if ((config->appGenCookieCb != NULL && config->appVerifyCookieCb == NULL) ||
(config->appGenCookieCb == NULL && config->appVerifyCookieCb != NULL)) {
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_SET);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15784, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"cannot register only one cookie callback, either appGenCookieCb or appVerifyCookieCb is NULL.",
0, 0, 0, 0);
return HITLS_CONFIG_INVALID_SET;
}
return HITLS_SUCCESS;
}
#endif
int32_t CheckConfig(const TLS_Config *config)
{
int32_t ret;
/** The check of the cipher suite is checked during setting. The algorithm suite needs to be sorted and the memory
* overhead increases. Therefore, the algorithm suite is still placed in the Set interface */
if (config->cipherSuitesSize == 0
#ifdef HITLS_TLS_PROTO_TLS13
&& config->tls13cipherSuitesSize == 0
#endif
) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16562, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"cipherSuitesSize is 0", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_SET);
return HITLS_CONFIG_INVALID_SET;
}
/* The checkpoint format and group are required only when the ecdhe cipher suite is available */
if (IsHaveEccCipherSuite(config)) {
ret = CheckPointFormats(config);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = CheckGroup(config);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
ret = CheckSign(config);
if (ret != HITLS_SUCCESS) {
return ret;
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
ret = CheckCallbackFunc(config);
#endif
return ret;
}
| 2302_82127028/openHiTLS-examples_1508 | tls/config/src/config_check.c | C | unknown | 10,747 |
/*
* 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.
*/
#include "hitls_build.h"
#include "bsl_sal.h"
#include "tls_binlog_id.h"
#include "hitls_type.h"
#include "hitls_crypt_type.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "tls_config.h"
#include "config.h"
#include "cipher_suite.h"
#include "cert_mgr.h"
#ifdef HITLS_TLS_FEATURE_SESSION
#include "session_mgr.h"
#endif
#ifdef HITLS_TLS_FEATURE_SECURITY
#include "security.h"
#endif
#include "config_type.h"
#ifdef HITLS_TLS_PROTO_TLCP11
uint16_t g_tlcpCipherSuites[] = {
HITLS_ECDHE_SM4_CBC_SM3,
HITLS_ECC_SM4_CBC_SM3,
HITLS_ECDHE_SM4_GCM_SM3,
HITLS_ECC_SM4_GCM_SM3,
};
#endif
uint16_t g_tls12CipherSuites[] = {
HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
HITLS_DHE_DSS_WITH_AES_256_GCM_SHA384,
HITLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
HITLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
HITLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
HITLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
HITLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
HITLS_DHE_DSS_WITH_AES_128_GCM_SHA256,
HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
HITLS_ECDHE_ECDSA_WITH_AES_128_CCM,
HITLS_ECDHE_ECDSA_WITH_AES_256_CCM,
HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
HITLS_DHE_RSA_WITH_AES_128_CCM,
HITLS_DHE_RSA_WITH_AES_256_CCM,
HITLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
HITLS_DHE_DSS_WITH_AES_256_CBC_SHA256,
HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
HITLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
HITLS_DHE_DSS_WITH_AES_128_CBC_SHA256,
HITLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
HITLS_DHE_RSA_WITH_AES_256_CBC_SHA,
HITLS_DHE_DSS_WITH_AES_256_CBC_SHA,
HITLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
HITLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
HITLS_DHE_RSA_WITH_AES_128_CBC_SHA,
HITLS_ECDHE_PSK_WITH_AES_256_GCM_SHA384,
HITLS_RSA_PSK_WITH_AES_256_GCM_SHA384,
HITLS_DHE_PSK_WITH_AES_256_GCM_SHA384,
HITLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256,
HITLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256,
HITLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256,
HITLS_DHE_DSS_WITH_AES_128_CBC_SHA,
HITLS_RSA_WITH_AES_256_GCM_SHA384,
HITLS_PSK_WITH_AES_256_GCM_SHA384,
HITLS_PSK_WITH_CHACHA20_POLY1305_SHA256,
HITLS_ECDHE_PSK_WITH_AES_128_GCM_SHA256,
HITLS_RSA_PSK_WITH_AES_128_GCM_SHA256,
HITLS_DHE_PSK_WITH_AES_128_GCM_SHA256,
HITLS_RSA_WITH_AES_128_GCM_SHA256,
HITLS_PSK_WITH_AES_128_GCM_SHA256,
HITLS_PSK_WITH_AES_256_CCM,
HITLS_RSA_WITH_AES_256_CBC_SHA256,
HITLS_RSA_WITH_AES_128_CBC_SHA256,
HITLS_ECDHE_PSK_WITH_AES_128_CCM_SHA256,
HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
HITLS_ECDHE_PSK_WITH_AES_256_CBC_SHA,
HITLS_RSA_PSK_WITH_AES_256_CBC_SHA384,
HITLS_DHE_PSK_WITH_AES_128_CCM,
HITLS_DHE_PSK_WITH_AES_256_CCM,
HITLS_DHE_PSK_WITH_AES_256_CBC_SHA384,
HITLS_RSA_PSK_WITH_AES_256_CBC_SHA,
HITLS_DHE_PSK_WITH_AES_256_CBC_SHA,
HITLS_RSA_WITH_AES_256_CBC_SHA,
HITLS_PSK_WITH_AES_256_CBC_SHA384,
HITLS_PSK_WITH_AES_256_CBC_SHA,
HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA,
HITLS_RSA_PSK_WITH_AES_128_CBC_SHA256,
HITLS_DHE_PSK_WITH_AES_128_CBC_SHA256,
HITLS_RSA_PSK_WITH_AES_128_CBC_SHA,
HITLS_DHE_PSK_WITH_AES_128_CBC_SHA,
HITLS_RSA_WITH_AES_128_CBC_SHA,
HITLS_PSK_WITH_AES_128_CBC_SHA256,
HITLS_PSK_WITH_AES_128_CBC_SHA,
};
int32_t SetDefaultCipherSuite(HITLS_Config *config, const uint16_t *cipherSuites, uint32_t cipherSuiteSize)
{
BSL_SAL_FREE(config->cipherSuites);
config->cipherSuites = BSL_SAL_Dump(cipherSuites, cipherSuiteSize);
if (config->cipherSuites == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16563, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
config->cipherSuitesSize = cipherSuiteSize / sizeof(uint16_t);
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_PROTO_TLS13
static int32_t SetTLS13DefaultCipherSuites(HITLS_Config *config)
{
const uint16_t ciphersuites13[] = {
HITLS_AES_256_GCM_SHA384,
HITLS_CHACHA20_POLY1305_SHA256,
HITLS_AES_128_GCM_SHA256,
};
BSL_SAL_FREE(config->tls13CipherSuites);
config->tls13CipherSuites = BSL_SAL_Dump(ciphersuites13, sizeof(ciphersuites13));
if (config->tls13CipherSuites == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16564, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
config->tls13cipherSuitesSize = sizeof(ciphersuites13) / sizeof(uint16_t);
return HITLS_SUCCESS;
}
#endif
static int32_t SetDefaultPointFormats(HITLS_Config *config)
{
const uint8_t pointFormats[] = {HITLS_POINT_FORMAT_UNCOMPRESSED};
uint32_t size = sizeof(pointFormats);
BSL_SAL_FREE(config->pointFormats);
config->pointFormats = BSL_SAL_Dump(pointFormats, size);
if (config->pointFormats == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16565, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
config->pointFormatsSize = size / sizeof(uint8_t);
return HITLS_SUCCESS;
}
static void BasicInitConfig(HITLS_Config *config)
{
config->isSupportExtendMasterSecret = false;
config->emptyRecordsNum = HITLS_MAX_EMPTY_RECORDS;
#ifdef HITLS_TLS_PROTO_TLS13
config->isMiddleBoxCompat = true;
#endif
#ifdef HITLS_TLS_FEATURE_MODE
config->modeSupport = HITLS_MODE_AUTO_RETRY;
#endif
#ifdef HITLS_TLS_FEATURE_MAX_SEND_FRAGMENT
config->maxSendFragment = HITLS_MAX_SEND_FRAGMENT_DEFAULT;
#endif
#ifdef HITLS_TLS_FEATURE_REC_INBUFFER_SIZE
config->recInbufferSize = 0;
#endif
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
config->allowLegacyRenegotiate = false;
#endif
#ifdef HITLS_TLS_FEATURE_ETM
config->isEncryptThenMac = true;
#endif
}
static void InitConfig(HITLS_Config *config)
{
BasicInitConfig(config);
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
config->allowClientRenegotiate = false;
config->isSupportRenegotiation = false;
#endif
#if defined(HITLS_TLS_FEATURE_RENEGOTIATION) && defined(HITLS_TLS_FEATURE_SESSION)
config->isResumptionOnRenego = false;
#endif
#ifdef HITLS_TLS_SUITE_KX_RSA
config->needCheckPmsVersion = false;
#endif
config->readAhead = 0;
#ifdef HITLS_TLS_CONFIG_KEY_USAGE
config->needCheckKeyUsage = true;
#endif
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
config->isSupportDhAuto = false;
#endif
if (config->maxVersion == HITLS_VERSION_TLCP_DTLCP11) {
config->isSupportExtendMasterSecret = false;
}
#ifdef HITLS_TLS_FEATURE_FLIGHT
config->isFlightTransmitEnable = true;
#endif
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
config->isSupportDtlsCookieExchange = false;
#endif
#ifdef HITLS_TLS_FEATURE_CERT_MODE
/** Set the certificate verification mode */
config->isSupportClientVerify = false;
config->isSupportNoClientCert = true;
config->isSupportVerifyNone = false;
#endif
#ifdef HITLS_TLS_FEATURE_PHA
config->isSupportPostHandshakeAuth = false;
#endif
#if defined(HITLS_TLS_FEATURE_RENEGOTIATION) && defined(HITLS_TLS_FEATURE_CERT_MODE)
config->isSupportClientOnceVerify = false;
#endif
config->isQuietShutdown = false;
config->maxCertList = HITLS_MAX_CERT_LIST_DEFAULT;
config->isKeepPeerCert = true;
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
config->isSupportSessionTicket = true;
config->ticketNums = HITLS_TLS13_TICKET_NUM_DEFAULT;
#endif
#ifdef HITLS_TLS_FEATURE_SECURITY
// Default security settings
SECURITY_SetDefault(config);
#endif
}
static int32_t DefaultCipherSuitesByVersion(uint16_t version, HITLS_Config *config)
{
const uint16_t *groups = g_tls12CipherSuites;
uint32_t size = sizeof(g_tls12CipherSuites);
switch (version) {
#ifdef HITLS_TLS_PROTO_TLCP11
case HITLS_VERSION_TLCP_DTLCP11:
groups = g_tlcpCipherSuites;
size = sizeof(g_tlcpCipherSuites);
break;
#endif
default:
break;
}
return SetDefaultCipherSuite(config, groups, size);
}
int32_t DefaultConfig(HITLS_Lib_Ctx *libCtx, const char *attrName, uint16_t version, HITLS_Config *config)
{
// Static settings
config->minVersion = version;
config->maxVersion = version;
config->libCtx = libCtx;
config->attrName = attrName;
InitConfig(config);
int32_t ret = DefaultCipherSuitesByVersion(version, config);
if (ret != HITLS_SUCCESS) {
goto ERR;
}
#ifdef HITLS_TLS_PROTO_TLS13
/* Configure the TLS1.3 cipher suite for all TLS versions */
ret = SetTLS13DefaultCipherSuites(config);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16570, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SetCipherSuites fail", 0, 0, 0, 0);
goto ERR;
}
#endif
if (ConfigLoadSignatureSchemeInfo(config) != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16571, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SetSignHashAlg fail", 0, 0, 0, 0);
goto ERR;
}
if ((SetDefaultPointFormats(config) != HITLS_SUCCESS) ||
(ConfigLoadGroupInfo(config) != HITLS_SUCCESS)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16572, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SetPointFormats or SetGroups fail", 0, 0, 0, 0);
goto ERR;
}
if (SAL_CERT_MgrIsEnable()) {
config->certMgrCtx = SAL_CERT_MgrCtxProviderNew(libCtx, attrName);
if (config->certMgrCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16573, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"sessMgr new fail", 0, 0, 0, 0);
goto ERR;
}
}
#ifdef HITLS_TLS_FEATURE_SESSION
config->sessMgr = SESSMGR_New(config->libCtx);
if (config->sessMgr == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16574, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"sessMgr new fail", 0, 0, 0, 0);
goto ERR;
}
#endif
return HITLS_SUCCESS;
ERR:
CFG_CleanConfig(config);
return HITLS_MEMALLOC_FAIL;
}
#ifdef HITLS_TLS_PROTO_TLS13
int32_t DefaultTLS13Config(HITLS_Config *config)
{
// Static settings
config->minVersion = HITLS_VERSION_TLS13;
config->maxVersion = HITLS_VERSION_TLS13;
InitConfig(config);
// Dynamic setting. By default, only the cipher suite and point format are set. For details, see the comments in
// HITLS_CFG_NewDTLS12Config.
if ((SetTLS13DefaultCipherSuites(config) != HITLS_SUCCESS) ||
(SetDefaultPointFormats(config) != HITLS_SUCCESS) ||
(ConfigLoadGroupInfo(config) != HITLS_SUCCESS) ||
(ConfigLoadSignatureSchemeInfo(config) != HITLS_SUCCESS)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16575, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Failed to set the default configuration of tls13", 0, 0, 0, 0);
CFG_CleanConfig(config);
return HITLS_MEMALLOC_FAIL;
}
config->keyExchMode = TLS13_KE_MODE_PSK_WITH_DHE;
if (SAL_CERT_MgrIsEnable()) {
config->certMgrCtx = SAL_CERT_MgrCtxProviderNew(LIBCTX_FROM_CONFIG(config), ATTRIBUTE_FROM_CONFIG(config));
if (config->certMgrCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16576, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"certMgrCtx new fail", 0, 0, 0, 0);
CFG_CleanConfig(config);
return HITLS_MEMALLOC_FAIL;
}
}
#ifdef HITLS_TLS_FEATURE_SESSION
config->sessMgr = SESSMGR_New(config->libCtx);
if (config->sessMgr == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16577, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"sessMgr new fail", 0, 0, 0, 0);
CFG_CleanConfig(config);
return HITLS_MEMALLOC_FAIL;
}
#endif
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_PROTO_ALL
static int32_t SetDefaultTlsAllCipherSuites(HITLS_Config *config)
{
#ifdef HITLS_TLS_PROTO_TLS13
int32_t ret = SetTLS13DefaultCipherSuites(config);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif
return SetDefaultCipherSuite(config, g_tls12CipherSuites, sizeof(g_tls12CipherSuites));
}
#endif
#ifdef HITLS_TLS_PROTO_ALL
int32_t DefaultTlsAllConfig(HITLS_Config *config)
{
// Support full version
config->minVersion = HITLS_VERSION_TLS12;
config->maxVersion = HITLS_VERSION_TLS13;
InitConfig(config);
// Dynamic setting
if ((SetDefaultTlsAllCipherSuites(config) != HITLS_SUCCESS) ||
(SetDefaultPointFormats(config) != HITLS_SUCCESS) ||
(ConfigLoadGroupInfo(config) != HITLS_SUCCESS) ||
(ConfigLoadSignatureSchemeInfo(config) != HITLS_SUCCESS)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16578, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Failed to set the default configuration of tls_all", 0, 0, 0, 0);
CFG_CleanConfig(config);
return HITLS_MEMALLOC_FAIL;
}
config->keyExchMode = TLS13_KE_MODE_PSK_WITH_DHE;
if (SAL_CERT_MgrIsEnable()) {
config->certMgrCtx = SAL_CERT_MgrCtxProviderNew(LIBCTX_FROM_CONFIG(config), ATTRIBUTE_FROM_CONFIG(config));
if (config->certMgrCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16579, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"MgrCtx new fail", 0, 0, 0, 0);
CFG_CleanConfig(config);
return HITLS_MEMALLOC_FAIL;
}
}
#ifdef HITLS_TLS_FEATURE_SESSION
config->sessMgr = SESSMGR_New(config->libCtx);
if (config->sessMgr == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16580, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"sessMgr new fail", 0, 0, 0, 0);
CFG_CleanConfig(config);
return HITLS_MEMALLOC_FAIL;
}
#endif
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_PROTO_DTLS
static int32_t SetDefaultDtlsAllCipherSuites(HITLS_Config *config)
{
const uint16_t cipherSuites[] = {
/* DTLS1.2 */
HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
HITLS_DHE_DSS_WITH_AES_256_GCM_SHA384, HITLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
HITLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, HITLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
HITLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256, HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
HITLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, HITLS_DHE_DSS_WITH_AES_128_GCM_SHA256,
HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
/* The DTLS1.0 cipher suite is not supported */
};
return SetDefaultCipherSuite(config, cipherSuites, sizeof(cipherSuites));
}
int32_t DefaultDtlsAllConfig(HITLS_Config *config)
{
// Static settings
config->minVersion =
HITLS_VERSION_DTLS12; // does not support DTLS 1.0. Therefore, the minimum version number is set to DTLS 1.2.
config->maxVersion = HITLS_VERSION_DTLS12;
InitConfig(config);
// Dynamic setting
if ((SetDefaultDtlsAllCipherSuites(config) != HITLS_SUCCESS) ||
(SetDefaultPointFormats(config) != HITLS_SUCCESS) ||
(ConfigLoadGroupInfo(config) != HITLS_SUCCESS) ||
(ConfigLoadSignatureSchemeInfo(config) != HITLS_SUCCESS)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16581, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"set default config fail", 0, 0, 0, 0);
CFG_CleanConfig(config);
return HITLS_MEMALLOC_FAIL;
}
if (SAL_CERT_MgrIsEnable()) {
config->certMgrCtx = SAL_CERT_MgrCtxProviderNew(LIBCTX_FROM_CONFIG(config), ATTRIBUTE_FROM_CONFIG(config));
if (config->certMgrCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16582, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"MgrCtxNew fail", 0, 0, 0, 0);
CFG_CleanConfig(config);
return HITLS_MEMALLOC_FAIL;
}
}
#ifdef HITLS_TLS_FEATURE_SESSION
config->sessMgr = SESSMGR_New(config->libCtx);
if (config->sessMgr == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16583, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SESSMGR_New fail", 0, 0, 0, 0);
CFG_CleanConfig(config);
return HITLS_MEMALLOC_FAIL;
}
#endif
return HITLS_SUCCESS;
}
#endif
| 2302_82127028/openHiTLS-examples_1508 | tls/config/src/config_default.c | C | unknown | 16,906 |
/*
* 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 CONFIG_DEFAULT_H
#define CONFIG_DEFAULT_H
#include <stdint.h>
#include "hitls_type.h"
#ifdef __cplusplus
extern "C" {
#endif
HITLS_Config *CreateConfig(void);
#ifdef HITLS_TLS_PROTO_ALL
/* provide default configuration */
int32_t DefaultTlsAllConfig(HITLS_Config *config);
#endif
#ifdef HITLS_TLS_PROTO_DTLS
int32_t DefaultDtlsAllConfig(HITLS_Config *config);
#endif
int32_t DefaultConfig(HITLS_Lib_Ctx *libCtx, const char *attrName, uint16_t version, HITLS_Config *config);
#ifdef HITLS_TLS_PROTO_TLS13
int32_t DefaultTLS13Config(HITLS_Config *config);
#endif
#ifdef __cplusplus
}
#endif
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/config/src/config_default.h | C | unknown | 1,150 |
/*
* 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.
*/
#include <stddef.h>
#include "hitls_build.h"
#include "config_type.h"
#include "hitls_crypt_type.h"
#include "tls_config.h"
#include "hitls_error.h"
#include "crypt_algid.h"
#include "config.h"
#ifdef HITLS_TLS_FEATURE_PROVIDER
#include "securec.h"
#include "crypt_eal_provider.h"
#include "crypt_params_key.h"
#include "crypt_eal_implprovider.h"
#include "crypt_eal_pkey.h"
#endif
static const uint16_t DEFAULT_GROUP_ID[] = {
HITLS_HYBRID_X25519_MLKEM768,
HITLS_EC_GROUP_CURVE25519,
HITLS_EC_GROUP_SECP256R1,
HITLS_EC_GROUP_SECP384R1,
HITLS_EC_GROUP_SECP521R1,
HITLS_EC_GROUP_SM2,
HITLS_FF_DHE_2048,
HITLS_FF_DHE_3072,
HITLS_FF_DHE_4096,
HITLS_FF_DHE_6144,
HITLS_FF_DHE_8192,
};
#ifndef HITLS_TLS_FEATURE_PROVIDER
static const TLS_GroupInfo GROUP_INFO[] = {
{
"x25519",
CRYPT_PKEY_PARAID_MAX,
CRYPT_PKEY_X25519,
128, // secBits
HITLS_EC_GROUP_CURVE25519, // groupId
32, 32, 0, // pubkeyLen=32, sharedkeyLen=32 (256 bits)
TLS_VERSION_MASK | DTLS_VERSION_MASK, // versionBits
false,
},
#ifdef HITLS_TLS_FEATURE_KEM
{
"X25519MLKEM768",
CRYPT_HYBRID_X25519_MLKEM768,
CRYPT_PKEY_HYBRID_KEM,
192, // secBits
HITLS_HYBRID_X25519_MLKEM768, // groupId
1184 + 32, 32 + 32, 1088 + 32, // pubkeyLen=1216, sharedkeyLen=64, ciphertextLen=1120
TLS13_VERSION_BIT, // versionBits
true,
},
{
"SecP256r1MLKEM768",
CRYPT_HYBRID_ECDH_NISTP256_MLKEM768,
CRYPT_PKEY_HYBRID_KEM,
192, // secBits
HITLS_HYBRID_ECDH_NISTP256_MLKEM768, // groupId
1184 + 65, 32 + 32, 1088 + 65, // pubkeyLen=1249, sharedkeyLen=64, ciphertextLen=1153
TLS13_VERSION_BIT, // versionBits
true,
},
{
"SecP384r1MLKEM1024",
CRYPT_HYBRID_ECDH_NISTP384_MLKEM1024,
CRYPT_PKEY_HYBRID_KEM,
256, // secBits
HITLS_HYBRID_ECDH_NISTP384_MLKEM1024, // groupId
1568 + 97, 32 + 48, 1568 + 97, // pubkeyLen=1665, sharedkeyLen=80, ciphertextLen=1665
TLS13_VERSION_BIT, // versionBits
true,
},
#endif /* HITLS_TLS_FEATURE_KEM */
{
"secp256r1",
CRYPT_ECC_NISTP256, // CRYPT_ECC_NISTP256
CRYPT_PKEY_ECDH, // CRYPT_PKEY_ECDH
128, // secBits
HITLS_EC_GROUP_SECP256R1, // groupId
65, 32, 0, // pubkeyLen=65, sharedkeyLen=32 (256 bits)
TLS_VERSION_MASK | DTLS_VERSION_MASK, // versionBits
false,
},
{
"secp384r1",
CRYPT_ECC_NISTP384, // CRYPT_ECC_NISTP384
CRYPT_PKEY_ECDH, // CRYPT_PKEY_ECDH
192, // secBits
HITLS_EC_GROUP_SECP384R1, // groupId
97, 48, 0, // pubkeyLen=97, sharedkeyLen=48 (384 bits)
TLS_VERSION_MASK | DTLS_VERSION_MASK, // versionBits
false,
},
{
"secp521r1",
CRYPT_ECC_NISTP521, // CRYPT_ECC_NISTP521
CRYPT_PKEY_ECDH, // CRYPT_PKEY_ECDH
256, // secBits
HITLS_EC_GROUP_SECP521R1, // groupId
133, 66, 0, // pubkeyLen=133, sharedkeyLen=66 (521 bits)
TLS_VERSION_MASK | DTLS_VERSION_MASK, // versionBits
false,
},
{
"brainpoolP256r1",
CRYPT_ECC_BRAINPOOLP256R1, // CRYPT_ECC_BRAINPOOLP256R1
CRYPT_PKEY_ECDH, // CRYPT_PKEY_ECDH
128, // secBits
HITLS_EC_GROUP_BRAINPOOLP256R1, // groupId
65, 32, 0, // pubkeyLen=65, sharedkeyLen=32 (256 bits)
TLS10_VERSION_BIT | TLS11_VERSION_BIT| TLS12_VERSION_BIT | DTLS_VERSION_MASK, // versionBits
false,
},
{
"brainpoolP384r1",
CRYPT_ECC_BRAINPOOLP384R1, // CRYPT_ECC_BRAINPOOLP384R1
CRYPT_PKEY_ECDH, // CRYPT_PKEY_ECDH
192, // secBits
HITLS_EC_GROUP_BRAINPOOLP384R1, // groupId
97, 48, 0, // pubkeyLen=97, sharedkeyLen=48 (384 bits)
TLS10_VERSION_BIT| TLS11_VERSION_BIT|TLS12_VERSION_BIT | DTLS_VERSION_MASK, // versionBits
false,
},
{
"brainpoolP512r1",
CRYPT_ECC_BRAINPOOLP512R1, // CRYPT_ECC_BRAINPOOLP512R1
CRYPT_PKEY_ECDH, // CRYPT_PKEY_ECDH
256, // secBits
HITLS_EC_GROUP_BRAINPOOLP512R1, // groupId
129, 64, 0, // pubkeyLen=129, sharedkeyLen=64 (512 bits)
TLS10_VERSION_BIT| TLS11_VERSION_BIT|TLS12_VERSION_BIT | DTLS_VERSION_MASK, // versionBits
false,
},
{
"sm2",
CRYPT_PKEY_PARAID_MAX, // CRYPT_PKEY_PARAID_MAX
CRYPT_PKEY_SM2, // CRYPT_PKEY_SM2
128, // secBits
HITLS_EC_GROUP_SM2, // groupId
65, 32, 0, // pubkeyLen=65, sharedkeyLen=32 (256 bits)
TLCP11_VERSION_BIT | DTLCP11_VERSION_BIT, // versionBits
false,
},
{
"ffdhe8192",
CRYPT_DH_RFC7919_8192, // CRYPT_DH_8192
CRYPT_PKEY_DH, // CRYPT_PKEY_DH
192, // secBits
HITLS_FF_DHE_8192, // groupId
1024, 1024, 0, // pubkeyLen=1024, sharedkeyLen=1024 (8192 bits)
TLS13_VERSION_BIT, // versionBits
false,
},
{
"ffdhe6144",
CRYPT_DH_RFC7919_6144, // CRYPT_DH_6144
CRYPT_PKEY_DH, // CRYPT_PKEY_DH
128, // secBits
HITLS_FF_DHE_6144, // groupId
768, 768, 0, // pubkeyLen=768, sharedkeyLen=768 (6144 bits)
TLS13_VERSION_BIT, // versionBits
false,
},
{
"ffdhe4096",
CRYPT_DH_RFC7919_4096, // CRYPT_DH_4096
CRYPT_PKEY_DH, // CRYPT_PKEY_DH
128, // secBits
HITLS_FF_DHE_4096, // groupId
512, 512, 0, // pubkeyLen=512, sharedkeyLen=512 (4096 bits)
TLS13_VERSION_BIT, // versionBits
false,
},
{
"ffdhe3072",
CRYPT_DH_RFC7919_3072, // Fixed constant name
CRYPT_PKEY_DH,
128,
HITLS_FF_DHE_3072,
384, 384, 0, // pubkeyLen=384, sharedkeyLen=384 (3072 bits)
TLS13_VERSION_BIT,
false,
},
{
"ffdhe2048",
CRYPT_DH_RFC7919_2048, // CRYPT_DH_2048
CRYPT_PKEY_DH, // CRYPT_PKEY_DH
112, // secBits
HITLS_FF_DHE_2048, // groupId
256, 256, 0, // pubkeyLen=256, sharedkeyLen=256 (2048 bits)
TLS13_VERSION_BIT, // versionBits
false,
}
};
int32_t ConfigLoadGroupInfo(HITLS_Config *config)
{
if (config == NULL) {
return HITLS_INVALID_INPUT;
}
return HITLS_CFG_SetGroups(config, DEFAULT_GROUP_ID, sizeof(DEFAULT_GROUP_ID) / sizeof(DEFAULT_GROUP_ID[0]));
}
const TLS_GroupInfo *ConfigGetGroupInfo(const HITLS_Config *config, uint16_t groupId)
{
(void)config;
for (uint32_t i = 0; i < sizeof(GROUP_INFO) / sizeof(TLS_GroupInfo); i++) {
if (GROUP_INFO[i].groupId == groupId) {
return &GROUP_INFO[i];
}
}
return NULL;
}
const TLS_GroupInfo *ConfigGetGroupInfoList(const HITLS_Config *config, uint32_t *size)
{
(void)config;
*size = sizeof(GROUP_INFO) / sizeof(GROUP_INFO[0]);
return &GROUP_INFO[0];
}
#else
static int32_t ProviderAddGroupInfo(const BSL_Param *params, void *args)
{
if (params == NULL || args == NULL) {
return HITLS_INVALID_INPUT;
}
TLS_CapabilityData *data = (TLS_CapabilityData *)args;
TLS_Config *config = data->config;
TLS_GroupInfo *group = NULL;
CRYPT_EAL_PkeyCtx *pkey = NULL;
BSL_Param *param = NULL;
int32_t ret = HITLS_CONFIG_ERR_LOAD_GROUP_INFO;
if (config->groupInfolen == config->groupInfoSize) {
void *ptr = BSL_SAL_Realloc(config->groupInfo,
(config->groupInfoSize + TLS_CAPABILITY_LIST_MALLOC_SIZE) * sizeof(TLS_GroupInfo),
config->groupInfoSize * sizeof(TLS_GroupInfo));
if (ptr == NULL) {
return HITLS_MEMALLOC_FAIL;
}
config->groupInfo = ptr;
(void)memset_s(config->groupInfo + config->groupInfoSize,
TLS_CAPABILITY_LIST_MALLOC_SIZE * sizeof(TLS_GroupInfo),
0,
TLS_CAPABILITY_LIST_MALLOC_SIZE * sizeof(TLS_GroupInfo));
config->groupInfoSize += TLS_CAPABILITY_LIST_MALLOC_SIZE;
}
group = config->groupInfo + config->groupInfolen;
PROCESS_STRING_PARAM(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_IANA_GROUP_NAME, name);
PROCESS_PARAM_UINT16(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_IANA_GROUP_ID, groupId);
PROCESS_PARAM_INT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_PARA_ID, paraId);
PROCESS_PARAM_INT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_ALG_ID, algId);
PROCESS_PARAM_INT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_SEC_BITS, secBits);
PROCESS_PARAM_UINT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_VERSION_BITS, versionBits);
PROCESS_PARAM_BOOL(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_IS_KEM, isKem);
PROCESS_PARAM_INT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_PUBKEY_LEN, pubkeyLen);
PROCESS_PARAM_INT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_SHAREDKEY_LEN, sharedkeyLen);
PROCESS_PARAM_INT32(param, group, params, CRYPT_PARAM_CAP_TLS_GROUP_CIPHERTEXT_LEN, ciphertextLen);
ret = HITLS_SUCCESS;
pkey = CRYPT_EAL_ProviderPkeyNewCtx(LIBCTX_FROM_CONFIG(config), group->algId, group->isKem ? CRYPT_EAL_PKEY_KEM_OPERATE : CRYPT_EAL_PKEY_EXCH_OPERATE,
ATTRIBUTE_FROM_CONFIG(config));
if (pkey != NULL) {
config->groupInfolen++;
CRYPT_EAL_PkeyFreeCtx(pkey);
group = NULL;
}
ERR:
if (group != NULL) {
BSL_SAL_Free(group->name);
(void)memset_s(group, sizeof(TLS_GroupInfo), 0, sizeof(TLS_GroupInfo));
}
return ret;
}
static int32_t ProviderLoadGroupInfo(CRYPT_EAL_ProvMgrCtx *ctx, void *args)
{
if (ctx == NULL || args == NULL) {
return HITLS_INVALID_INPUT;
}
TLS_CapabilityData data = {
.config = (TLS_Config *)args,
.provMgrCtx = ctx,
};
return CRYPT_EAL_ProviderGetCaps(ctx, CRYPT_EAL_GET_GROUP_CAP, ProviderAddGroupInfo, &data);
}
int32_t ConfigLoadGroupInfo(HITLS_Config *config)
{
HITLS_Lib_Ctx *libCtx = LIBCTX_FROM_CONFIG(config);
int32_t ret = CRYPT_EAL_ProviderProcessAll(libCtx, ProviderLoadGroupInfo, config);
if (ret != HITLS_SUCCESS) {
return ret;
}
return HITLS_CFG_SetGroups(config, DEFAULT_GROUP_ID, sizeof(DEFAULT_GROUP_ID) / sizeof(DEFAULT_GROUP_ID[0]));
}
const TLS_GroupInfo *ConfigGetGroupInfo(const HITLS_Config *config, uint16_t groupId)
{
for (uint32_t i = 0; i < config->groupInfolen; i++) {
if (config->groupInfo[i].groupId == groupId) {
return &config->groupInfo[i];
}
}
return NULL;
}
const TLS_GroupInfo *ConfigGetGroupInfoList(const HITLS_Config *config, uint32_t *size)
{
*size = config->groupInfolen;
return config->groupInfo;
}
#endif
| 2302_82127028/openHiTLS-examples_1508 | tls/config/src/config_group.c | C | unknown | 11,592 |
/*
* 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.
*/
#include <stddef.h>
#include "hitls_build.h"
#include "config_type.h"
#include "hitls_cert_type.h"
#include "tls_config.h"
#include "crypt_algid.h"
#include "hitls_error.h"
#include "cipher_suite.h"
#include "config.h"
#ifdef HITLS_TLS_FEATURE_PROVIDER
#include "securec.h"
#include "crypt_eal_provider.h"
#include "crypt_params_key.h"
#include "crypt_eal_implprovider.h"
#include "crypt_eal_pkey.h"
#endif
static const uint16_t DEFAULT_SIGSCHEME_ID[] = {
CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256,
CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384,
CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512,
CERT_SIG_SCHEME_ED25519,
CERT_SIG_SCHEME_SM2_SM3,
CERT_SIG_SCHEME_RSA_PSS_PSS_SHA256,
CERT_SIG_SCHEME_RSA_PSS_PSS_SHA384,
CERT_SIG_SCHEME_RSA_PSS_PSS_SHA512,
CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256,
CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384,
CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512,
CERT_SIG_SCHEME_RSA_PKCS1_SHA256,
CERT_SIG_SCHEME_RSA_PKCS1_SHA384,
CERT_SIG_SCHEME_RSA_PKCS1_SHA512,
CERT_SIG_SCHEME_ECDSA_SHA224,
CERT_SIG_SCHEME_ECDSA_SHA1,
CERT_SIG_SCHEME_RSA_PKCS1_SHA224,
CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
CERT_SIG_SCHEME_DSA_SHA224,
CERT_SIG_SCHEME_DSA_SHA256,
CERT_SIG_SCHEME_DSA_SHA384,
CERT_SIG_SCHEME_DSA_SHA512,
CERT_SIG_SCHEME_DSA_SHA1,
};
static int32_t UpdateSignAlgorithmsArray(TLS_Config *config)
{
if (config == NULL) {
return HITLS_INVALID_INPUT;
}
uint16_t *tempItems = BSL_SAL_Calloc(sizeof(DEFAULT_SIGSCHEME_ID), sizeof(uint8_t));
if (tempItems == NULL) {
return HITLS_MEMALLOC_FAIL;
}
uint32_t size = 0;
for (uint32_t i = 0; i < sizeof(DEFAULT_SIGSCHEME_ID) / sizeof(DEFAULT_SIGSCHEME_ID[0]); i++) {
const TLS_SigSchemeInfo *info = ConfigGetSignatureSchemeInfo(config, DEFAULT_SIGSCHEME_ID[i]);
if (info == NULL || (config->version & info->chainVersionBits) == 0) {
continue;
}
tempItems[size] = DEFAULT_SIGSCHEME_ID[i];
size++;
}
if (size == 0) {
BSL_SAL_Free(tempItems);
return HITLS_INVALID_INPUT;
}
BSL_SAL_FREE(config->signAlgorithms);
config->signAlgorithms = tempItems;
config->signAlgorithmsSize = size;
return HITLS_SUCCESS;
}
#ifndef HITLS_TLS_FEATURE_PROVIDER
static const TLS_SigSchemeInfo SIGNATURE_SCHEME_INFO[] = {
{
"ecdsa_secp521r1_sha512",
CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512,
TLS_CERT_KEY_TYPE_ECDSA,
CRYPT_ECC_NISTP521,
BSL_CID_ECDSAWITHSHA512,
HITLS_SIGN_ECDSA,
HITLS_HASH_SHA_512,
256,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"ecdsa_secp384r1_sha384",
CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384,
TLS_CERT_KEY_TYPE_ECDSA,
CRYPT_ECC_NISTP384,
BSL_CID_ECDSAWITHSHA384,
HITLS_SIGN_ECDSA,
HITLS_HASH_SHA_384,
192,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"ed25519",
CERT_SIG_SCHEME_ED25519,
TLS_CERT_KEY_TYPE_ED25519,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_ED25519,
HITLS_SIGN_ED25519,
HITLS_HASH_SHA_512,
128,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"ecdsa_secp256r1_sha256",
CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256,
TLS_CERT_KEY_TYPE_ECDSA,
CRYPT_ECC_NISTP256,
BSL_CID_ECDSAWITHSHA256,
HITLS_SIGN_ECDSA,
HITLS_HASH_SHA_256,
128,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"sm2_sm3",
CERT_SIG_SCHEME_SM2_SM3,
TLS_CERT_KEY_TYPE_SM2,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_SM2DSAWITHSM3,
HITLS_SIGN_SM2,
HITLS_HASH_SM3,
128,
TLCP11_VERSION_BIT | DTLCP11_VERSION_BIT,
TLCP11_VERSION_BIT | DTLCP11_VERSION_BIT,
},
{
"rsa_pss_pss_sha512",
CERT_SIG_SCHEME_RSA_PSS_PSS_SHA512,
TLS_CERT_KEY_TYPE_RSA_PSS,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_RSASSAPSS,
HITLS_SIGN_RSA_PSS,
HITLS_HASH_SHA_512,
256,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"rsa_pss_pss_sha384",
CERT_SIG_SCHEME_RSA_PSS_PSS_SHA384,
TLS_CERT_KEY_TYPE_RSA_PSS,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_RSASSAPSS,
HITLS_SIGN_RSA_PSS,
HITLS_HASH_SHA_384,
192,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"rsa_pss_pss_sha256",
CERT_SIG_SCHEME_RSA_PSS_PSS_SHA256,
TLS_CERT_KEY_TYPE_RSA_PSS,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_RSASSAPSS,
HITLS_SIGN_RSA_PSS,
HITLS_HASH_SHA_256,
128,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"rsa_pss_rsae_sha512",
CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512,
TLS_CERT_KEY_TYPE_RSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_RSASSAPSS,
HITLS_SIGN_RSA_PSS,
HITLS_HASH_SHA_512,
256,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"rsa_pss_rsae_sha384",
CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384,
TLS_CERT_KEY_TYPE_RSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_RSASSAPSS,
HITLS_SIGN_RSA_PSS,
HITLS_HASH_SHA_384,
192,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"rsa_pss_rsae_sha256",
CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256,
TLS_CERT_KEY_TYPE_RSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_RSASSAPSS,
HITLS_SIGN_RSA_PSS,
HITLS_HASH_SHA_256,
128,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"rsa_pkcs1_sha512",
CERT_SIG_SCHEME_RSA_PKCS1_SHA512,
TLS_CERT_KEY_TYPE_RSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_SHA512WITHRSAENCRYPTION,
HITLS_SIGN_RSA_PKCS1_V15,
HITLS_HASH_SHA_512,
256,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"dsa_sha512",
CERT_SIG_SCHEME_DSA_SHA512,
TLS_CERT_KEY_TYPE_DSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_DSAWITHSHA512,
HITLS_SIGN_DSA,
HITLS_HASH_SHA_512,
256,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
},
{
"rsa_pkcs1_sha384",
CERT_SIG_SCHEME_RSA_PKCS1_SHA384,
TLS_CERT_KEY_TYPE_RSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_SHA384WITHRSAENCRYPTION,
HITLS_SIGN_RSA_PKCS1_V15,
HITLS_HASH_SHA_384,
192,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"dsa_sha384",
CERT_SIG_SCHEME_DSA_SHA384,
TLS_CERT_KEY_TYPE_DSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_DSAWITHSHA384,
HITLS_SIGN_DSA,
HITLS_HASH_SHA_384,
192,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
},
{
"rsa_pkcs1_sha256",
CERT_SIG_SCHEME_RSA_PKCS1_SHA256,
TLS_CERT_KEY_TYPE_RSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_SHA256WITHRSAENCRYPTION,
HITLS_SIGN_RSA_PKCS1_V15,
HITLS_HASH_SHA_256,
128,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
TLS_VERSION_MASK | DTLS_VERSION_MASK,
},
{
"dsa_sha256",
CERT_SIG_SCHEME_DSA_SHA256,
TLS_CERT_KEY_TYPE_DSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_DSAWITHSHA256,
HITLS_SIGN_DSA,
HITLS_HASH_SHA_256,
128,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
},
{
"ecdsa_sha224",
CERT_SIG_SCHEME_ECDSA_SHA224,
TLS_CERT_KEY_TYPE_ECDSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_ECDSAWITHSHA224,
HITLS_SIGN_ECDSA,
HITLS_HASH_SHA_224,
112,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
},
{
"rsa_pkcs1_sha224",
CERT_SIG_SCHEME_RSA_PKCS1_SHA224,
TLS_CERT_KEY_TYPE_RSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_SHA224WITHRSAENCRYPTION,
HITLS_SIGN_RSA_PKCS1_V15,
HITLS_HASH_SHA_224,
112,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
},
{
"dsa_sha224",
CERT_SIG_SCHEME_DSA_SHA224,
TLS_CERT_KEY_TYPE_DSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_DSAWITHSHA224,
HITLS_SIGN_DSA,
HITLS_HASH_SHA_224,
112,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
},
{
"ecdsa_sha1",
CERT_SIG_SCHEME_ECDSA_SHA1,
TLS_CERT_KEY_TYPE_ECDSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_ECDSAWITHSHA1,
HITLS_SIGN_ECDSA,
HITLS_HASH_SHA1,
-1,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
},
{
"rsa_pkcs1_sha1",
CERT_SIG_SCHEME_RSA_PKCS1_SHA1,
TLS_CERT_KEY_TYPE_RSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_SHA1WITHRSA,
HITLS_SIGN_RSA_PKCS1_V15,
HITLS_HASH_SHA1,
-1,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
},
{
"dsa_sha1",
CERT_SIG_SCHEME_DSA_SHA1,
TLS_CERT_KEY_TYPE_DSA,
CRYPT_PKEY_PARAID_MAX,
BSL_CID_DSAWITHSHA1,
HITLS_SIGN_DSA,
HITLS_HASH_SHA1,
-1,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
TLS12_VERSION_BIT | DTLS12_VERSION_BIT,
},
};
int32_t ConfigLoadSignatureSchemeInfo(HITLS_Config *config)
{
return UpdateSignAlgorithmsArray(config);
}
const TLS_SigSchemeInfo *ConfigGetSignatureSchemeInfo(const HITLS_Config *config, uint16_t signatureScheme)
{
(void)config;
for (uint32_t i = 0; i < sizeof(SIGNATURE_SCHEME_INFO) / sizeof(TLS_SigSchemeInfo); i++) {
if (SIGNATURE_SCHEME_INFO[i].signatureScheme == signatureScheme) {
return &SIGNATURE_SCHEME_INFO[i];
}
}
return NULL;
}
const TLS_SigSchemeInfo *ConfigGetSignatureSchemeInfoList(const HITLS_Config *config, uint32_t *size)
{
(void)config;
*size = sizeof(SIGNATURE_SCHEME_INFO) / sizeof(SIGNATURE_SCHEME_INFO[0]);
return SIGNATURE_SCHEME_INFO;
}
#else // HITLS_TLS_FEATURE_PROVIDER
static int32_t PrepareSignSchemeStorage(TLS_Config *config, TLS_SigSchemeInfo **scheme)
{
if (config->sigSchemeInfolen == config->sigSchemeInfoSize) {
void *ptr = BSL_SAL_Realloc(config->sigSchemeInfo,
(config->sigSchemeInfoSize + TLS_CAPABILITY_LIST_MALLOC_SIZE) * sizeof(TLS_SigSchemeInfo),
config->sigSchemeInfoSize * sizeof(TLS_SigSchemeInfo));
if (ptr == NULL) {
return HITLS_MEMALLOC_FAIL;
}
config->sigSchemeInfo = ptr;
(void)memset_s(config->sigSchemeInfo + config->sigSchemeInfoSize,
TLS_CAPABILITY_LIST_MALLOC_SIZE * sizeof(TLS_SigSchemeInfo),
0,
TLS_CAPABILITY_LIST_MALLOC_SIZE * sizeof(TLS_SigSchemeInfo));
config->sigSchemeInfoSize += TLS_CAPABILITY_LIST_MALLOC_SIZE;
}
*scheme = config->sigSchemeInfo + config->sigSchemeInfolen;
return HITLS_SUCCESS;
}
typedef struct {
BslOidString oidStr;
const char *oidName;
} BslOidInfo;
static int32_t ProcessOids(TLS_SigSchemeInfo *scheme, BslOidInfo *keyTypeOidInfo, BslOidInfo *paraOidInfo,
BslOidInfo *signHashAlgOidInfo, BslOidInfo *hashOidInfo)
{
int32_t ret = HITLS_SUCCESS;
if (keyTypeOidInfo != NULL && keyTypeOidInfo->oidStr.octs != NULL) {
ret = BSL_OBJ_Create(keyTypeOidInfo->oidStr.octs, keyTypeOidInfo->oidStr.octetLen,
keyTypeOidInfo->oidName, scheme->keyType);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
if (paraOidInfo != NULL && paraOidInfo->oidStr.octs != NULL) {
ret = BSL_OBJ_Create(paraOidInfo->oidStr.octs, paraOidInfo->oidStr.octetLen,
paraOidInfo->oidName, scheme->paraId);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
if (hashOidInfo != NULL && hashOidInfo->oidStr.octs != NULL) {
ret = BSL_OBJ_Create(hashOidInfo->oidStr.octs, hashOidInfo->oidStr.octetLen,
hashOidInfo->oidName, scheme->hashAlgId);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
if (signHashAlgOidInfo != NULL && signHashAlgOidInfo->oidStr.octs != NULL) {
ret = BSL_OBJ_Create(signHashAlgOidInfo->oidStr.octs, signHashAlgOidInfo->oidStr.octetLen,
signHashAlgOidInfo->oidName, scheme->signHashAlgId);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
return BSL_OBJ_CreateSignId(scheme->signHashAlgId, scheme->signAlgId, scheme->hashAlgId);
}
static int32_t ProviderAddSignatureSchemeInfo(const BSL_Param *params, void *args)
{
if (params == NULL || args == NULL) {
return HITLS_INVALID_INPUT;
}
TLS_CapabilityData *data = (TLS_CapabilityData *)args;
TLS_Config *config = data->config;
TLS_SigSchemeInfo *scheme = NULL;
CRYPT_EAL_PkeyCtx *pkey = NULL;
BSL_Param *param = NULL;
const char *keyTypeOid = NULL, *keyTypeName = NULL, *paraOid = NULL, *paraName = NULL;
const char *signHashAlgOid = NULL, *signHashAlgName = NULL, *hashOid = NULL, *hashName = NULL;
uint32_t keyTypeOidLen = 0, paraOidLen = 0, signHashAlgOidLen = 0, hashOidLen = 0;
int32_t ret = PrepareSignSchemeStorage(config, &scheme);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = HITLS_CONFIG_ERR_LOAD_SIGN_SCHEME_INFO;
PROCESS_STRING_PARAM(param, scheme, params, CRYPT_PARAM_CAP_TLS_SIGNALG_IANA_SIGN_NAME, name);
PROCESS_PARAM_UINT16(param, scheme, params, CRYPT_PARAM_CAP_TLS_SIGNALG_IANA_SIGN_ID, signatureScheme);
PROCESS_PARAM_INT32(param, scheme, params, CRYPT_PARAM_CAP_TLS_SIGNALG_KEY_TYPE, keyType);
PROCESS_PARAM_INT32(param, scheme, params, CRYPT_PARAM_CAP_TLS_SIGNALG_PARA_ID, paraId);
PROCESS_PARAM_INT32(param, scheme, params, CRYPT_PARAM_CAP_TLS_SIGNALG_SIGNWITHMD_ID, signHashAlgId);
PROCESS_PARAM_INT32(param, scheme, params, CRYPT_PARAM_CAP_TLS_SIGNALG_SIGN_ID, signAlgId);
PROCESS_PARAM_INT32(param, scheme, params, CRYPT_PARAM_CAP_TLS_SIGNALG_MD_ID, hashAlgId);
PROCESS_PARAM_INT32(param, scheme, params, CRYPT_PARAM_CAP_TLS_SIGNALG_SEC_BITS, secBits);
PROCESS_PARAM_UINT32(param, scheme, params, CRYPT_PARAM_CAP_TLS_SIGNALG_CHAIN_VERSION_BITS, chainVersionBits);
PROCESS_PARAM_UINT32(param, scheme, params, CRYPT_PARAM_CAP_TLS_SIGNALG_CERT_VERSION_BITS, certVersionBits);
PROCESS_OPTIONAL_STRING_PARAM(param, params, CRYPT_PARAM_CAP_TLS_SIGNALG_KEY_TYPE_OID, keyTypeOid, keyTypeOidLen,
CRYPT_PARAM_CAP_TLS_SIGNALG_KEY_TYPE_NAME, keyTypeName);
PROCESS_OPTIONAL_STRING_PARAM(param, params, CRYPT_PARAM_CAP_TLS_SIGNALG_PARA_OID, paraOid, paraOidLen,
CRYPT_PARAM_CAP_TLS_SIGNALG_PARA_NAME, paraName);
PROCESS_OPTIONAL_STRING_PARAM(param, params, CRYPT_PARAM_CAP_TLS_SIGNALG_SIGNWITHMD_OID, signHashAlgOid,
signHashAlgOidLen, CRYPT_PARAM_CAP_TLS_SIGNALG_SIGNWITHMD_NAME, signHashAlgName);
PROCESS_OPTIONAL_STRING_PARAM(param, params, CRYPT_PARAM_CAP_TLS_SIGNALG_MD_OID, hashOid, hashOidLen,
CRYPT_PARAM_CAP_TLS_SIGNALG_MD_NAME, hashName);
if (scheme->keyType == TLS_CERT_KEY_TYPE_RSA_PSS) {
pkey = CRYPT_EAL_ProviderPkeyNewCtx(LIBCTX_FROM_CONFIG(config), TLS_CERT_KEY_TYPE_RSA,
CRYPT_EAL_PKEY_SIGN_OPERATE, ATTRIBUTE_FROM_CONFIG(config));
} else {
pkey = CRYPT_EAL_ProviderPkeyNewCtx(LIBCTX_FROM_CONFIG(config), scheme->keyType,
CRYPT_EAL_PKEY_SIGN_OPERATE, ATTRIBUTE_FROM_CONFIG(config));
}
if (pkey == NULL) {
goto ERR;
}
BslOidInfo keyTypeOidInfo = { { keyTypeOidLen, (char *)(uintptr_t)keyTypeOid, 0 }, keyTypeName };
BslOidInfo paraOidInfo = { { paraOidLen, (char *)(uintptr_t)paraOid, 0 }, paraName };
BslOidInfo signHashAlgOidInfo = { { signHashAlgOidLen, (char *)(uintptr_t)signHashAlgOid, 0 }, signHashAlgName };
BslOidInfo hashOidInfo = { { hashOidLen, (char *)(uintptr_t)hashOid, 0 }, hashName };
ret = ProcessOids(scheme, &keyTypeOidInfo, ¶OidInfo, &signHashAlgOidInfo, &hashOidInfo);
if (ret != HITLS_SUCCESS) {
goto ERR;
}
config->sigSchemeInfolen++;
CRYPT_EAL_PkeyFreeCtx(pkey);
return HITLS_SUCCESS;
ERR:
if (pkey != NULL) {
CRYPT_EAL_PkeyFreeCtx(pkey);
}
if (scheme != NULL) {
BSL_SAL_Free(scheme->name);
(void)memset_s(scheme, sizeof(TLS_SigSchemeInfo), 0, sizeof(TLS_SigSchemeInfo));
}
return ret != HITLS_SUCCESS ? ret : HITLS_CONFIG_ERR_LOAD_SIGN_SCHEME_INFO;
}
static int32_t ProviderLoadSignSchemeInfo(CRYPT_EAL_ProvMgrCtx *ctx, void *args)
{
if (ctx == NULL || args == NULL) {
return HITLS_INVALID_INPUT;
}
TLS_CapabilityData data = {
.config = (TLS_Config *)args,
.provMgrCtx = ctx,
};
return CRYPT_EAL_ProviderGetCaps(ctx, CRYPT_EAL_GET_SIGALG_CAP, ProviderAddSignatureSchemeInfo, &data);
}
int32_t ConfigLoadSignatureSchemeInfo(HITLS_Config *config)
{
HITLS_Lib_Ctx *libCtx = LIBCTX_FROM_CONFIG(config);
int32_t ret = CRYPT_EAL_ProviderProcessAll(libCtx, ProviderLoadSignSchemeInfo, config);
if (ret != HITLS_SUCCESS) {
return ret;
}
return UpdateSignAlgorithmsArray(config);
}
const TLS_SigSchemeInfo *ConfigGetSignatureSchemeInfo(const HITLS_Config *config, uint16_t signatureScheme)
{
for (uint32_t i = 0; i < config->sigSchemeInfolen; i++) {
if (config->sigSchemeInfo[i].signatureScheme == signatureScheme) {
return &config->sigSchemeInfo[i];
}
}
return NULL;
}
const TLS_SigSchemeInfo *ConfigGetSignatureSchemeInfoList(const HITLS_Config *config, uint32_t *size)
{
*size = config->sigSchemeInfolen;
return config->sigSchemeInfo;
}
#endif
| 2302_82127028/openHiTLS-examples_1508 | tls/config/src/config_sign.c | C | unknown | 19,071 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_PROTO_TLS13
#include "securec.h"
#include "tls.h"
#include "bsl_err_internal.h"
#include "hitls_error.h"
#include "config_default.h"
#ifdef HITLS_TLS_FEATURE_PSK
#include "hitls_psk.h"
#endif
HITLS_Config *HITLS_CFG_NewTLS13Config(void)
{
return HITLS_CFG_ProviderNewTLS13Config(NULL, NULL);
}
HITLS_Config *HITLS_CFG_ProviderNewTLS13Config(HITLS_Lib_Ctx *libCtx, const char *attrName)
{
HITLS_Config *newConfig = CreateConfig();
if (newConfig == NULL) {
return NULL;
}
newConfig->version |= TLS13_VERSION_BIT; // Enable TLS1.3
newConfig->libCtx = libCtx;
newConfig->attrName = attrName;
if (DefaultTLS13Config(newConfig) != HITLS_SUCCESS) {
BSL_SAL_FREE(newConfig);
return NULL;
}
newConfig->originVersionMask = newConfig->version;
return newConfig;
}
int32_t HITLS_CFG_ClearTLS13CipherSuites(HITLS_Config *config)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
BSL_SAL_FREE(config->tls13CipherSuites);
config->tls13cipherSuitesSize = 0;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetKeyExchMode(HITLS_Config *config, uint32_t mode)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
if (((mode & TLS13_KE_MODE_PSK_ONLY) == TLS13_KE_MODE_PSK_ONLY) ||
((mode & TLS13_KE_MODE_PSK_WITH_DHE) == TLS13_KE_MODE_PSK_WITH_DHE)) {
config->keyExchMode = (mode & (TLS13_KE_MODE_PSK_ONLY | TLS13_KE_MODE_PSK_WITH_DHE));
return HITLS_SUCCESS;
}
return HITLS_CONFIG_INVALID_SET;
}
uint32_t HITLS_CFG_GetKeyExchMode(HITLS_Config *config)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
return config->keyExchMode;
}
#ifdef HITLS_TLS_FEATURE_PSK
int32_t HITLS_CFG_SetPskFindSessionCallback(HITLS_Config *config, HITLS_PskFindSessionCb callback)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->pskFindSessionCb = callback;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetPskUseSessionCallback(HITLS_Config *config, HITLS_PskUseSessionCb callback)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->pskUseSessionCb = callback;
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_PHA
int32_t HITLS_CFG_SetPostHandshakeAuthSupport(HITLS_Config *config, bool support)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->isSupportPostHandshakeAuth = support;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetPostHandshakeAuthSupport(HITLS_Config *config, uint8_t *isSupport)
{
if (config == NULL || isSupport == NULL) {
return HITLS_NULL_INPUT;
}
*isSupport = (uint8_t)config->isSupportPostHandshakeAuth;
return HITLS_SUCCESS;
}
#endif
#endif /* HITLS_TLS_PROTO_TLS13 */ | 2302_82127028/openHiTLS-examples_1508 | tls/config/src/config_tls13.c | C | unknown | 3,342 |
/*
* 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.
*/
#include <stddef.h>
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "hitls_crypt_reg.h"
#include "crypt.h"
#include "config_type.h"
#include "crypt_algid.h"
#ifdef HITLS_TLS_FEATURE_PROVIDER
#include "hitls_crypt.h"
#endif
#ifndef HITLS_TLS_FEATURE_PROVIDER
HITLS_CRYPT_BaseMethod g_cryptBaseMethod = {0};
HITLS_CRYPT_EcdhMethod g_cryptEcdhMethod = {0};
HITLS_CRYPT_DhMethod g_cryptDhMethod = {0};
#endif
#ifdef HITLS_TLS_PROTO_TLS13
#define TLS13_MAX_LABEL_LEN 255
#define TLS13_MAX_CTX_LEN 255
#define TLS13_HKDF_LABEL_LEN(labelLen, ctxLen) \
(sizeof(uint16_t) + sizeof(uint8_t) + (labelLen) + sizeof(uint8_t) + (ctxLen))
#define TLS13_MAX_HKDF_LABEL_LEN TLS13_HKDF_LABEL_LEN(TLS13_MAX_LABEL_LEN, TLS13_MAX_CTX_LEN)
#ifndef HITLS_TLS_FEATURE_PROVIDER
HITLS_CRYPT_KdfMethod g_cryptKdfMethod = {0};
#endif /* HITLS_TLS_FEATURE_PROVIDER */
typedef struct {
uint16_t length; /* Length of the derived key */
uint8_t labelLen; /* Label length */
uint8_t ctxLen; /* Length of the context information */
const uint8_t *label; /* Label */
const uint8_t *ctx; /* Context information */
} HkdfLabel;
#endif
const char *g_cryptCallBackStr[] = {
[HITLS_CRYPT_CALLBACK_RAND_BYTES] = "random bytes",
[HITLS_CRYPT_CALLBACK_HMAC_SIZE] = "hmac size",
[HITLS_CRYPT_CALLBACK_HMAC_INIT] = "hmac init",
[HITLS_CRYPT_CALLBACK_HMAC_FREE] = "hmac free",
[HITLS_CRYPT_CALLBACK_HMAC_UPDATE] = "hmac update",
[HITLS_CRYPT_CALLBACK_HMAC_FINAL] = "hmac final",
[HITLS_CRYPT_CALLBACK_HMAC] = "hmac calc",
[HITLS_CRYPT_CALLBACK_DIGEST_SIZE] = "digest size",
[HITLS_CRYPT_CALLBACK_DIGEST_INIT] = "digest init",
[HITLS_CRYPT_CALLBACK_DIGEST_COPY] = "digest copy",
[HITLS_CRYPT_CALLBACK_DIGEST_FREE] = "digest free",
[HITLS_CRYPT_CALLBACK_DIGEST_UPDATE] = "digest update",
[HITLS_CRYPT_CALLBACK_DIGEST_FINAL] = "digest final",
[HITLS_CRYPT_CALLBACK_DIGEST] = "digest calc",
[HITLS_CRYPT_CALLBACK_ENCRYPT] = "encrypt",
[HITLS_CRYPT_CALLBACK_DECRYPT] = "decrpt",
[HITLS_CRYPT_CALLBACK_GENERATE_ECDH_KEY_PAIR] = "generate ecdh key",
[HITLS_CRYPT_CALLBACK_FREE_ECDH_KEY] = "free ecdh key",
[HITLS_CRYPT_CALLBACK_GET_ECDH_ENCODED_PUBKEY] = "get ecdh public key",
[HITLS_CRYPT_CALLBACK_CALC_ECDH_SHARED_SECRET] = "calculate ecdh shared secret",
[HITLS_CRYPT_CALLBACK_SM2_CALC_ECDH_SHARED_SECRET] = "calculate sm2 ecdh shared secret",
[HITLS_CRYPT_CALLBACK_GENERATE_DH_KEY_BY_SECBITS] = "generate Dh key by secbits",
[HITLS_CRYPT_CALLBACK_GENERATE_DH_KEY_BY_PARAMS] = "generate Dh key by params",
[HITLS_CRYPT_CALLBACK_DUP_DH_KEY] = "dup Dh key",
[HITLS_CRYPT_CALLBACK_FREE_DH_KEY] = "free Dh key",
[HITLS_CRYPT_CALLBACK_DH_GET_PARAMETERS] = "get dh params",
[HITLS_CRYPT_CALLBACK_GET_DH_ENCODED_PUBKEY] = "get dh public key",
[HITLS_CRYPT_CALLBACK_CALC_DH_SHARED_SECRET] = "calculate dh shared secret",
[HITLS_CRYPT_CALLBACK_HKDF_EXTRACT] = "HKDF-Extract",
[HITLS_CRYPT_CALLBACK_HKDF_EXPAND] = "HKDF-Expand",
[HITLS_CRYPT_CALLBACK_KEM_ENCAPSULATE] = "KEM-Encapsulate",
[HITLS_CRYPT_CALLBACK_KEM_DECAPSULATE] = "KEM-Decapsulate",
};
#ifndef HITLS_TLS_FEATURE_PROVIDER
int32_t HITLS_CRYPT_RegisterBaseMethod(HITLS_CRYPT_BaseMethod *userCryptCallBack)
{
if (userCryptCallBack == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15063, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Register base crypt method error: input NULL.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
g_cryptBaseMethod.randBytes = userCryptCallBack->randBytes;
g_cryptBaseMethod.hmacSize = userCryptCallBack->hmacSize;
g_cryptBaseMethod.hmacInit = userCryptCallBack->hmacInit;
g_cryptBaseMethod.hmacReinit = userCryptCallBack->hmacReinit;
g_cryptBaseMethod.hmacFree = userCryptCallBack->hmacFree;
g_cryptBaseMethod.hmacUpdate = userCryptCallBack->hmacUpdate;
g_cryptBaseMethod.hmacFinal = userCryptCallBack->hmacFinal;
g_cryptBaseMethod.hmac = userCryptCallBack->hmac;
g_cryptBaseMethod.digestSize = userCryptCallBack->digestSize;
g_cryptBaseMethod.digestInit = userCryptCallBack->digestInit;
g_cryptBaseMethod.digestCopy = userCryptCallBack->digestCopy;
g_cryptBaseMethod.digestFree = userCryptCallBack->digestFree;
g_cryptBaseMethod.digestUpdate = userCryptCallBack->digestUpdate;
g_cryptBaseMethod.digestFinal = userCryptCallBack->digestFinal;
g_cryptBaseMethod.digest = userCryptCallBack->digest;
g_cryptBaseMethod.encrypt = userCryptCallBack->encrypt;
g_cryptBaseMethod.decrypt = userCryptCallBack->decrypt;
g_cryptBaseMethod.cipherFree = userCryptCallBack->cipherFree;
return HITLS_SUCCESS;
}
int32_t HITLS_CRYPT_RegisterEcdhMethod(HITLS_CRYPT_EcdhMethod *userCryptCallBack)
{
if (userCryptCallBack == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15064, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Register ECDH crypt method error: input NULL.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
g_cryptEcdhMethod.generateEcdhKeyPair = userCryptCallBack->generateEcdhKeyPair;
g_cryptEcdhMethod.freeEcdhKey = userCryptCallBack->freeEcdhKey;
g_cryptEcdhMethod.getEcdhPubKey = userCryptCallBack->getEcdhPubKey;
g_cryptEcdhMethod.calcEcdhSharedSecret = userCryptCallBack->calcEcdhSharedSecret;
#ifdef HITLS_TLS_PROTO_TLCP11
g_cryptEcdhMethod.sm2CalEcdhSharedSecret = userCryptCallBack->sm2CalEcdhSharedSecret;
#endif /* HITLS_TLS_PROTO_TLCP11 */
g_cryptEcdhMethod.kemEncapsulate = userCryptCallBack->kemEncapsulate;
g_cryptEcdhMethod.kemDecapsulate = userCryptCallBack->kemDecapsulate;
return HITLS_SUCCESS;
}
int32_t HITLS_CRYPT_RegisterDhMethod(const HITLS_CRYPT_DhMethod *userCryptCallBack)
{
if (userCryptCallBack == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15065, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Register Dh crypt method error: input NULL.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
g_cryptDhMethod.getDhParameters = userCryptCallBack->getDhParameters;
g_cryptDhMethod.generateDhKeyBySecbits = userCryptCallBack->generateDhKeyBySecbits;
g_cryptDhMethod.generateDhKeyByParams = userCryptCallBack->generateDhKeyByParams;
g_cryptDhMethod.freeDhKey = userCryptCallBack->freeDhKey;
g_cryptDhMethod.getDhPubKey = userCryptCallBack->getDhPubKey;
g_cryptDhMethod.calcDhSharedSecret = userCryptCallBack->calcDhSharedSecret;
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
g_cryptDhMethod.dupDhKey = userCryptCallBack->dupDhKey;
#endif /* HITLS_TLS_CONFIG_MANUAL_DH */
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_PROTO_TLS13
int32_t HITLS_CRYPT_RegisterHkdfMethod(HITLS_CRYPT_KdfMethod *userCryptCallBack)
{
if (userCryptCallBack == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15066, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Register HKDF crypt method error: input NULL.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
g_cryptKdfMethod.hkdfExtract = userCryptCallBack->hkdfExtract;
g_cryptKdfMethod.hkdfExpand = userCryptCallBack->hkdfExpand;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS13 */
#endif /* HITLS_TLS_FEATURE_PROVIDER */
int32_t CheckCallBackRetVal(int32_t cmd, int32_t callBackRet, uint32_t bingLogId, uint32_t hitlsRet)
{
if (callBackRet != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(bingLogId, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"%s error: callback ret = 0x%x.", g_cryptCallBackStr[cmd], callBackRet, 0, 0);
BSL_ERR_PUSH_ERROR((int32_t)hitlsRet);
return (int32_t)hitlsRet;
}
return HITLS_SUCCESS;
}
int32_t SAL_CRYPT_Rand(HITLS_Lib_Ctx *libCtx, uint8_t *buf, uint32_t len)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_RandbytesEx(libCtx, buf, len);
#else
(void)libCtx;
if (g_cryptBaseMethod.randBytes == NULL) {
return HITLS_CRYPT_ERR_GENERATE_RANDOM;
}
int32_t ret = g_cryptBaseMethod.randBytes(buf, len);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_RAND_BYTES, ret, BINLOG_ID15068,
HITLS_CRYPT_ERR_GENERATE_RANDOM);
}
uint32_t SAL_CRYPT_HmacSize(HITLS_HashAlgo hashAlgo)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_CRYPT_DigestSize(hashAlgo);
#else
if (g_cryptBaseMethod.hmacSize == NULL) {
return 0;
}
return g_cryptBaseMethod.hmacSize(hashAlgo);
#endif
}
#ifdef HITLS_TLS_CALLBACK_CRYPT_HMAC_PRIMITIVES
HITLS_HMAC_Ctx *SAL_CRYPT_HmacInit(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t len)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_CRYPT_HMAC_Init(libCtx, attrName, hashAlgo, key, len);
#else
(void)libCtx;
(void)attrName;
if (g_cryptBaseMethod.hmacInit == NULL) {
return NULL;
}
return g_cryptBaseMethod.hmacInit(hashAlgo, key, len);
#endif
}
void SAL_CRYPT_HmacFree(HITLS_HMAC_Ctx *hmac)
{
if (hmac != NULL) {
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_CRYPT_HMAC_Free(hmac);
#else
if (g_cryptBaseMethod.hmacFree == NULL) {
return;
}
g_cryptBaseMethod.hmacFree(hmac);
#endif
}
return;
}
int32_t SAL_CRYPT_HmacReInit(HITLS_HMAC_Ctx *ctx)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_CRYPT_HMAC_ReInit(ctx);
#else
if (g_cryptBaseMethod.hmacReinit == NULL) {
return HITLS_CRYPT_ERR_HMAC;
}
return g_cryptBaseMethod.hmacReinit(ctx);
#endif
}
int32_t SAL_CRYPT_HmacUpdate(HITLS_HMAC_Ctx *hmac, const uint8_t *data, uint32_t len)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_HMAC_Update(hmac, data, len);
#else
if (g_cryptBaseMethod.hmacUpdate == NULL) {
return HITLS_CRYPT_ERR_HMAC;
}
int32_t ret = g_cryptBaseMethod.hmacUpdate(hmac, data, len);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_HMAC_UPDATE, ret, BINLOG_ID15073, HITLS_CRYPT_ERR_HMAC);
}
int32_t SAL_CRYPT_HmacFinal(HITLS_HMAC_Ctx *hmac, uint8_t *out, uint32_t *len)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_HMAC_Final(hmac, out, len);
#else
if (g_cryptBaseMethod.hmacFinal == NULL) {
return HITLS_CRYPT_ERR_HMAC;
}
int32_t ret = g_cryptBaseMethod.hmacFinal(hmac, out, len);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_HMAC_FINAL, ret, BINLOG_ID15075, HITLS_CRYPT_ERR_HMAC);
}
#endif /* HITLS_TLS_CALLBACK_CRYPT_HMAC_PRIMITIVES */
int32_t SAL_CRYPT_Hmac(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t keyLen,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_HMAC(libCtx, attrName, hashAlgo, key, keyLen, in, inLen, out, outLen);
#else
(void)libCtx;
(void)attrName;
if (g_cryptBaseMethod.hmac == NULL) {
return HITLS_CRYPT_ERR_HMAC;
}
int32_t ret = g_cryptBaseMethod.hmac(hashAlgo, key, keyLen, in, inLen, out, outLen);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_HMAC, ret, BINLOG_ID15077, HITLS_CRYPT_ERR_HMAC);
}
#ifndef HITLS_TLS_FEATURE_PROVIDER
static int32_t IteratorInit(CRYPT_KeyDeriveParameters *input, uint32_t hmacSize,
uint8_t **iterator, uint32_t *iteratorSize)
{
uint8_t *seed = BSL_SAL_Calloc(1u, hmacSize + input->labelLen + input->seedLen);
if (seed == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15078, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"P_Hash error: out of memory.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
(void)memcpy_s(&seed[hmacSize], input->labelLen, input->label, input->labelLen);
(void)memcpy_s(&seed[hmacSize + input->labelLen], input->seedLen, input->seed, input->seedLen);
int32_t ret = SAL_CRYPT_Hmac(input->libCtx, input->attrName,
input->hashAlgo, input->secret, input->secretLen,
&seed[hmacSize], input->labelLen + input->seedLen, seed, &hmacSize);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15079, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"P_Hash error: iterator init fail, HMAC ret = 0x%x.", ret, 0, 0, 0);
BSL_SAL_FREE(seed);
return ret;
}
*iterator = seed;
*iteratorSize = hmacSize + input->labelLen + input->seedLen;
return HITLS_SUCCESS;
}
static int32_t PHashPre(uint32_t *hmacSize, uint32_t *alignLen, uint32_t outLen, HITLS_HashAlgo hashAlgo)
{
if (hmacSize == NULL || alignLen == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16611, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
*alignLen = outLen;
*hmacSize = SAL_CRYPT_HmacSize(hashAlgo);
if (*hmacSize == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15080, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"P_Hash error: hmac size is zero.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CRYPT_ERR_HMAC);
return HITLS_CRYPT_ERR_HMAC;
}
if ((outLen % *hmacSize) != 0) {
/* Padded based on the HMAC length. */
*alignLen += *hmacSize - (outLen % *hmacSize);
}
return HITLS_SUCCESS;
}
int32_t P_Hash(CRYPT_KeyDeriveParameters *input, uint8_t *out, uint32_t outLen)
{
uint8_t *iterator = NULL;
uint32_t iteratorSize = 0;
uint8_t *data = NULL;
uint32_t alignLen;
uint32_t srcLen = outLen;
uint32_t offset = 0;
uint32_t hmacSize;
int32_t ret = PHashPre(&hmacSize, &alignLen, outLen, input->hashAlgo);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16612, "PHashPre fail");
}
data = BSL_SAL_Calloc(1u, alignLen);
if (data == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMALLOC_FAIL, BINLOG_ID15081, "Calloc fail");
}
uint32_t tmpLen = hmacSize;
ret = IteratorInit(input, hmacSize, &iterator, &iteratorSize);
if (ret != HITLS_SUCCESS) {
(void)RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16613, "IteratorInit fail");
goto EXIT;
}
while (alignLen > 0) {
ret = SAL_CRYPT_Hmac(input->libCtx, input->attrName, input->hashAlgo, input->secret, input->secretLen,
iterator, iteratorSize, data + offset, &tmpLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15082, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"P_Hash error: produce output data fail, HMAC ret = 0x%x.", ret, 0, 0, 0);
goto EXIT;
}
alignLen -= tmpLen;
offset += tmpLen;
ret = SAL_CRYPT_Hmac(input->libCtx, input->attrName, input->hashAlgo, input->secret, input->secretLen, iterator, tmpLen, iterator, &tmpLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15083, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"P_Hash error: iterator update fail, HMAC ret = 0x%x.", ret, 0, 0, 0);
goto EXIT;
}
}
if (memcpy_s(out, outLen, data, srcLen) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16614, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
ret = HITLS_MEMCPY_FAIL;
}
EXIT:
BSL_SAL_FREE(iterator);
BSL_SAL_FREE(data);
return ret;
}
#if defined(HITLS_CRYPTO_MD5) && defined(HITLS_CRYPTO_SHA1)
int32_t PRF_MD5_SHA1(CRYPT_KeyDeriveParameters *input, uint8_t *out, uint32_t outLen)
{
uint32_t secretLen = input->secretLen;
const uint8_t *secret = input->secret;
int32_t ret;
uint32_t i;
/* The key is divided into two parts. The first part is the MD5 key, and the second part is the SHA1 key.
If the value is an odd number, for example, 7, the first half of the key is [1, 4]
and the second half of the key is [4, 7]. Both keys have the fourth byte. */
input->secretLen = ((secretLen + 1) >> 1);
input->hashAlgo = HITLS_HASH_MD5;
ret = P_Hash(input, out, outLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16615, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "P_Hash fail", 0, 0, 0, 0);
return ret;
}
uint8_t *sha1data = BSL_SAL_Calloc(1u, outLen);
if (sha1data == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15084, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PRF_MD5_SHA1 error: out of memory.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
input->secret += (secretLen >> 1);
input->hashAlgo = HITLS_HASH_SHA1;
ret = P_Hash(input, sha1data, outLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16616, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "P_Hash fail", 0, 0, 0, 0);
BSL_SAL_FREE(sha1data);
return ret;
}
for (i = 0; i < outLen; i++) {
out[i] ^= sha1data[i];
}
input->secret = secret;
input->secretLen = secretLen;
BSL_SAL_FREE(sha1data);
return HITLS_SUCCESS;
}
#endif /* HITLS_CRYPTO_MD5 && HITLS_CRYPTO_SHA1 */
#endif /* !HITLS_TLS_FEATURE_PROVIDER */
int32_t SAL_CRYPT_PRF(CRYPT_KeyDeriveParameters *input, uint8_t *out, uint32_t outLen)
{
// Other versions
if (input->hashAlgo < HITLS_HASH_SHA_256) {
/* The PRF function must use the digest algorithm with SHA-256 or higher strength. */
input->hashAlgo = HITLS_HASH_SHA_256;
}
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_CRYPT_PRF(input, out, outLen);
#else
return P_Hash(input, out, outLen);
#endif
}
HITLS_HASH_Ctx *SAL_CRYPT_DigestInit(HITLS_Lib_Ctx *libCtx, const char *attrName, HITLS_HashAlgo hashAlgo)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_CRYPT_DigestInit(libCtx, attrName, hashAlgo);
#else
(void)libCtx;
(void)attrName;
if (g_cryptBaseMethod.digestInit == NULL) {
return NULL;
}
return g_cryptBaseMethod.digestInit(hashAlgo);
#endif
}
HITLS_HASH_Ctx *SAL_CRYPT_DigestCopy(HITLS_HASH_Ctx *ctx)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_CRYPT_DigestCopy(ctx);
#else
if (g_cryptBaseMethod.digestCopy == NULL) {
return NULL;
}
return g_cryptBaseMethod.digestCopy(ctx);
#endif
}
void SAL_CRYPT_DigestFree(HITLS_HASH_Ctx *ctx)
{
if (ctx != NULL) {
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_CRYPT_DigestFree(ctx);
#else
if (g_cryptBaseMethod.digestFree == NULL) {
return;
}
g_cryptBaseMethod.digestFree(ctx);
#endif
}
return;
}
int32_t SAL_CRYPT_DigestUpdate(HITLS_HASH_Ctx *ctx, const uint8_t *data, uint32_t len)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_DigestUpdate(ctx, data, len);
#else
if (g_cryptBaseMethod.digestUpdate == NULL) {
return HITLS_CRYPT_ERR_DIGEST;
}
int32_t ret = g_cryptBaseMethod.digestUpdate(ctx, data, len);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_DIGEST_UPDATE, ret, BINLOG_ID15090,
HITLS_CRYPT_ERR_DIGEST);
}
int32_t SAL_CRYPT_DigestFinal(HITLS_HASH_Ctx *ctx, uint8_t *out, uint32_t *len)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_DigestFinal(ctx, out, len);
#else
if (g_cryptBaseMethod.digestFinal == NULL) {
return HITLS_CRYPT_ERR_DIGEST;
}
int32_t ret = g_cryptBaseMethod.digestFinal(ctx, out, len);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_DIGEST_FINAL, ret, BINLOG_ID15092,
HITLS_CRYPT_ERR_DIGEST);
}
#ifdef HITLS_TLS_PROTO_TLS13
uint32_t SAL_CRYPT_DigestSize(HITLS_HashAlgo hashAlgo)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_CRYPT_DigestSize(hashAlgo);
#else
if (g_cryptBaseMethod.digestSize == NULL) {
return 0;
}
return g_cryptBaseMethod.digestSize(hashAlgo);
#endif
}
int32_t SAL_CRYPT_Digest(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_Digest(libCtx, attrName, hashAlgo, in, inLen, out, outLen);
#else
(void)libCtx;
(void)attrName;
if (g_cryptBaseMethod.digest == NULL) {
return HITLS_CRYPT_ERR_DIGEST;
}
int32_t ret = g_cryptBaseMethod.digest(hashAlgo, in, inLen, out, outLen);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_DIGEST, ret, BINLOG_ID15094, HITLS_CRYPT_ERR_DIGEST);
}
#endif
int32_t SAL_CRYPT_Encrypt(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_Encrypt(libCtx, attrName, cipher, in, inLen, out, outLen);
#else
(void)libCtx;
(void)attrName;
if (g_cryptBaseMethod.encrypt == NULL) {
return HITLS_CRYPT_ERR_ENCRYPT;
}
int32_t ret = g_cryptBaseMethod.encrypt(cipher, in, inLen, out, outLen);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_ENCRYPT, ret, BINLOG_ID15096, HITLS_CRYPT_ERR_ENCRYPT);
}
int32_t SAL_CRYPT_Decrypt(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_Decrypt(libCtx, attrName, cipher, in, inLen, out, outLen);
#else
(void)libCtx;
(void)attrName;
if (g_cryptBaseMethod.decrypt == NULL) {
return HITLS_CRYPT_ERR_DECRYPT;
}
int32_t ret = g_cryptBaseMethod.decrypt(cipher, in, inLen, out, outLen);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_DECRYPT, ret, BINLOG_ID15098, HITLS_CRYPT_ERR_DECRYPT);
}
void SAL_CRYPT_CipherFree(HITLS_Cipher_Ctx *ctx)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_CRYPT_CipherFree(ctx);
#else
if (g_cryptBaseMethod.cipherFree != NULL) {
g_cryptBaseMethod.cipherFree(ctx);
}
#endif
}
HITLS_CRYPT_Key *SAL_CRYPT_GenEcdhKeyPair(TLS_Ctx *ctx, const HITLS_ECParameters *curveParams)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_CRYPT_GenerateEcdhKey(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
&ctx->config.tlsConfig, curveParams);
#else
(void) ctx;
if (g_cryptEcdhMethod.generateEcdhKeyPair == NULL) {
return NULL;
}
return g_cryptEcdhMethod.generateEcdhKeyPair(curveParams);
#endif
}
void SAL_CRYPT_FreeEcdhKey(HITLS_CRYPT_Key *key)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_CRYPT_FreeKey(key);
#else
if (key != NULL) {
if (g_cryptEcdhMethod.freeEcdhKey == NULL) {
return;
}
g_cryptEcdhMethod.freeEcdhKey(key);
}
#endif
return;
}
int32_t SAL_CRYPT_EncodeEcdhPubKey(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen, uint32_t *usedLen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_GetPubKey(key, pubKeyBuf, bufLen, usedLen);
#else
if (g_cryptEcdhMethod.getEcdhPubKey == NULL) {
return HITLS_CRYPT_ERR_ENCODE_ECDH_KEY;
}
int32_t ret = g_cryptEcdhMethod.getEcdhPubKey(key, pubKeyBuf, bufLen, usedLen);
#endif
return CheckCallBackRetVal(
HITLS_CRYPT_CALLBACK_GET_ECDH_ENCODED_PUBKEY, ret, BINLOG_ID15102, HITLS_CRYPT_ERR_ENCODE_ECDH_KEY);
}
int32_t SAL_CRYPT_CalcEcdhSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_EcdhCalcSharedSecret(libCtx, attrName,
key, peerPubkey, pubKeyLen, sharedSecret, sharedSecretLen);
#else
(void)libCtx;
(void)attrName;
if (g_cryptEcdhMethod.calcEcdhSharedSecret == NULL) {
return HITLS_CRYPT_ERR_CALC_SHARED_KEY;
}
int32_t ret = g_cryptEcdhMethod.calcEcdhSharedSecret(key, peerPubkey, pubKeyLen, sharedSecret, sharedSecretLen);
#endif
return CheckCallBackRetVal(
HITLS_CRYPT_CALLBACK_CALC_ECDH_SHARED_SECRET, ret, BINLOG_ID15104, HITLS_CRYPT_ERR_CALC_SHARED_KEY);
}
#ifdef HITLS_TLS_PROTO_TLCP11
int32_t SAL_CRYPT_CalcSm2dhSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_Sm2GenShareKeyParameters *sm2ShareKeyParam, uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_CalcSM2SharedSecret(libCtx, attrName,
sm2ShareKeyParam, sharedSecret, sharedSecretLen);
#else
(void)libCtx;
(void)attrName;
if (g_cryptEcdhMethod.sm2CalEcdhSharedSecret == NULL) {
return HITLS_CRYPT_ERR_CALC_SHARED_KEY;
}
int32_t ret = g_cryptEcdhMethod.sm2CalEcdhSharedSecret(sm2ShareKeyParam, sharedSecret, sharedSecretLen);
#endif
return CheckCallBackRetVal(
HITLS_CRYPT_CALLBACK_SM2_CALC_ECDH_SHARED_SECRET, ret, BINLOG_ID16212,
HITLS_CRYPT_ERR_ENCODE_ECDH_KEY);
}
#endif /* HITLS_TLS_PROTO_TLCP11 */
HITLS_CRYPT_Key *SAL_CRYPT_GenerateDhKeyByParams(HITLS_Lib_Ctx *libCtx,
const char *attrName, uint8_t *p, uint16_t plen, uint8_t *g, uint16_t glen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_CRYPT_GenerateDhKeyByParameters(libCtx, attrName, p, plen, g, glen);
#else
(void)libCtx;
(void)attrName;
if (g_cryptDhMethod.generateDhKeyByParams == NULL) {
return NULL;
}
return g_cryptDhMethod.generateDhKeyByParams(p, plen, g, glen);
#endif
}
HITLS_CRYPT_Key *SAL_CRYPT_GenerateDhKeyBySecbits(TLS_Ctx *ctx, int32_t secBits)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_CRYPT_GenerateDhKeyBySecbits(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
&ctx->config.tlsConfig, secBits);
#else
(void)ctx;
if (g_cryptDhMethod.generateDhKeyBySecbits == NULL) {
return NULL;
}
return g_cryptDhMethod.generateDhKeyBySecbits(secBits);
#endif
}
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
HITLS_CRYPT_Key *SAL_CRYPT_DupDhKey(HITLS_CRYPT_Key *key)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_CRYPT_DupKey(key);
#else
if (g_cryptDhMethod.dupDhKey == NULL) {
return NULL;
}
return g_cryptDhMethod.dupDhKey(key);
#endif
}
#endif /* HITLS_TLS_CONFIG_MANUAL_DH */
void SAL_CRYPT_FreeDhKey(HITLS_CRYPT_Key *key)
{
if (key != NULL) {
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_CRYPT_FreeKey(key);
#else
if (g_cryptDhMethod.freeDhKey == NULL) {
return;
}
g_cryptDhMethod.freeDhKey(key);
#endif
}
return;
}
int32_t SAL_CRYPT_GetDhParameters(HITLS_CRYPT_Key *key, uint8_t *p, uint16_t *plen, uint8_t *g, uint16_t *glen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_CRYPT_GetDhParameters(key, p, plen, g, glen);
#else
if (g_cryptDhMethod.getDhParameters == NULL) {
return HITLS_CRYPT_ERR_DH;
}
return g_cryptDhMethod.getDhParameters(key, p, plen, g, glen);
#endif
}
int32_t SAL_CRYPT_EncodeDhPubKey(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen, uint32_t *usedLen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_GetPubKey(key, pubKeyBuf, bufLen, usedLen);
#else
if (g_cryptDhMethod.getDhPubKey == NULL) {
return HITLS_CRYPT_ERR_ENCODE_DH_KEY;
}
int32_t ret = g_cryptDhMethod.getDhPubKey(key, pubKeyBuf, bufLen, usedLen);
#endif
return CheckCallBackRetVal(
HITLS_CRYPT_CALLBACK_GET_DH_ENCODED_PUBKEY, ret, BINLOG_ID15110, HITLS_CRYPT_ERR_ENCODE_DH_KEY);
}
int32_t SAL_CRYPT_CalcDhSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen, uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_DhCalcSharedSecret(libCtx, attrName,
key, peerPubkey, pubKeyLen, sharedSecret, sharedSecretLen);
#else
(void)libCtx;
(void)attrName;
if (g_cryptDhMethod.calcDhSharedSecret == NULL) {
return HITLS_CRYPT_ERR_CALC_SHARED_KEY;
}
int32_t ret = g_cryptDhMethod.calcDhSharedSecret(key, peerPubkey, pubKeyLen, sharedSecret, sharedSecretLen);
#endif
return CheckCallBackRetVal(
HITLS_CRYPT_CALLBACK_CALC_DH_SHARED_SECRET, ret, BINLOG_ID15112, HITLS_CRYPT_ERR_CALC_SHARED_KEY);
}
uint32_t SAL_CRYPT_GetCryptLength(const TLS_Ctx *ctx, int32_t cmd, int32_t param)
{
const TLS_GroupInfo *groupInfo = NULL;
if (ctx == NULL) {
return 0;
}
groupInfo = ConfigGetGroupInfo(&ctx->config.tlsConfig, (uint16_t)param);
switch (cmd) {
case HITLS_CRYPT_INFO_CMD_GET_PUBLIC_KEY_LEN:
if (groupInfo == NULL) {
return 0;
}
return groupInfo->pubkeyLen;
case HITLS_CRYPT_INFO_CMD_GET_CIPHERTEXT_LEN:
if (groupInfo == NULL) {
return 0;
}
return groupInfo->ciphertextLen;
default:
break;
}
return 0;
}
#ifdef HITLS_TLS_PROTO_TLS13
int32_t SAL_CRYPT_HkdfExtract(HITLS_Lib_Ctx *libCtx,
const char *attrName, HITLS_CRYPT_HkdfExtractInput *input, uint8_t *prk, uint32_t *prkLen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_HkdfExtract(libCtx, attrName, input, prk, prkLen);
#else
(void)libCtx;
(void)attrName;
if (g_cryptKdfMethod.hkdfExtract == NULL) {
return HITLS_CRYPT_ERR_HKDF_EXTRACT;
}
int32_t ret = g_cryptKdfMethod.hkdfExtract(input, prk, prkLen);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_HKDF_EXTRACT, ret, BINLOG_ID15114,
HITLS_CRYPT_ERR_HKDF_EXTRACT);
}
int32_t SAL_CRYPT_HkdfExpand(HITLS_Lib_Ctx *libCtx,
const char *attrName, HITLS_CRYPT_HkdfExpandInput *input, uint8_t *okm, uint32_t okmLen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_HkdfExpand(libCtx, attrName, input, okm, okmLen);
#else
(void)libCtx;
(void)attrName;
if (g_cryptKdfMethod.hkdfExpand == NULL) {
return HITLS_CRYPT_ERR_HKDF_EXPAND;
}
int32_t ret = g_cryptKdfMethod.hkdfExpand(input, okm, okmLen);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_HKDF_EXPAND, ret, BINLOG_ID15116,
HITLS_CRYPT_ERR_HKDF_EXPAND);
}
/*
* 2 bytes for length of derived secret + 1 byte for length of combined
* prefix and label + bytes for the label itself + 1 byte length of hash
* + bytes for the hash itself
*/
static int32_t SAL_CRYPT_EncodeHkdfLabel(HkdfLabel *hkdfLabel, uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)
{
char labelPrefix[] = "tls13 ";
size_t labelPrefixLen = strlen(labelPrefix);
uint32_t offset = 0;
BSL_Uint16ToByte(hkdfLabel->length, buf);
offset += sizeof(uint16_t);
/* The truncation won't happen, as the label length will not be greater than 64, all possible labels are as follows:
* "ext binder", "res binder", "finished", "c e traffic", "e exp master", "derived", "c hs traffic", "s hs traffic"
* "finished", "derived", "c ap traffic", "s ap traffic", "exp master", "finished", "res master",
* "TLS 1.3,serverCertificateVerify", "TLS 1.3,clientCertificateVerify".
*/
buf[offset] = (uint8_t)(hkdfLabel->labelLen + labelPrefixLen);
offset += sizeof(uint8_t);
if (memcpy_s(&buf[offset], bufLen - offset, labelPrefix, labelPrefixLen) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15117, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Encode HkdfLabel error: memcpy fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
offset += (uint32_t)labelPrefixLen;
if (hkdfLabel->labelLen != 0 &&
memcpy_s(&buf[offset], bufLen - offset, hkdfLabel->label, hkdfLabel->labelLen) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15118, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Encode HkdfLabel error: memcpy fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
offset += hkdfLabel->labelLen;
buf[offset] = hkdfLabel->ctxLen;
offset += sizeof(uint8_t);
if (hkdfLabel->ctxLen != 0) {
if (memcpy_s(&buf[offset], bufLen - offset, hkdfLabel->ctx, hkdfLabel->ctxLen) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15119, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Encode HkdfLabel error: memcpy fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
offset += hkdfLabel->ctxLen;
}
*usedLen = offset;
return HITLS_SUCCESS;
}
int32_t SAL_CRYPT_HkdfExpandLabel(CRYPT_KeyDeriveParameters *deriveInfo, uint8_t *outSecret, uint32_t outLen)
{
uint8_t hkdfLabel[TLS13_MAX_HKDF_LABEL_LEN] = {0};
uint32_t hkdfLabelLen = 0;
HkdfLabel info = {0};
info.length = (uint16_t)outLen;
info.labelLen = (uint8_t)deriveInfo->labelLen;
info.ctxLen = (uint8_t)deriveInfo->seedLen;
info.label = deriveInfo->label;
info.ctx = deriveInfo->seed;
int32_t ret = SAL_CRYPT_EncodeHkdfLabel(&info, hkdfLabel, TLS13_MAX_HKDF_LABEL_LEN, &hkdfLabelLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16626, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"EncodeHkdfLabel fail", 0, 0, 0, 0);
return ret;
}
HITLS_CRYPT_HkdfExpandInput expandInput = {0};
expandInput.hashAlgo = deriveInfo->hashAlgo;
expandInput.prk = deriveInfo->secret;
expandInput.prkLen = deriveInfo->secretLen;
expandInput.info = hkdfLabel;
expandInput.infoLen = hkdfLabelLen;
return SAL_CRYPT_HkdfExpand(deriveInfo->libCtx, deriveInfo->attrName, &expandInput, outSecret, outLen);
}
#endif /* HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_FEATURE_KEM
int32_t SAL_CRYPT_KemEncapsulate(TLS_Ctx *ctx, HITLS_KemEncapsulateParams *params)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_KemEncapsulate(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
&ctx->config.tlsConfig, params);
#else
(void)ctx;
(void)params;
if (g_cryptEcdhMethod.kemEncapsulate == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16627, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"kemEncapsulate callback not registered", 0, 0, 0, 0);
return HITLS_UNREGISTERED_CALLBACK;
}
int32_t ret = g_cryptEcdhMethod.kemEncapsulate(params);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_KEM_ENCAPSULATE, ret, BINLOG_ID16617,
HITLS_CRYPT_ERR_KEM_ENCAPSULATE);
}
int32_t SAL_CRYPT_KemDecapsulate(HITLS_CRYPT_Key *key, const uint8_t *ciphertext, uint32_t ciphertextLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t ret = HITLS_CRYPT_KemDecapsulate(key, ciphertext, ciphertextLen, sharedSecret, sharedSecretLen);
#else
if (g_cryptEcdhMethod.kemDecapsulate == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16630, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"kemDecapsulate callback not registered", 0, 0, 0, 0);
return HITLS_UNREGISTERED_CALLBACK;
}
int32_t ret = g_cryptEcdhMethod.kemDecapsulate(key, ciphertext, ciphertextLen, sharedSecret, sharedSecretLen);
#endif
return CheckCallBackRetVal(HITLS_CRYPT_CALLBACK_KEM_DECAPSULATE, ret, BINLOG_ID16637,
HITLS_CRYPT_ERR_KEM_DECAPSULATE);
}
#endif /* HITLS_TLS_FEATURE_KEM */
| 2302_82127028/openHiTLS-examples_1508 | tls/crypt/crypt_adapt/crypt.c | C | unknown | 36,109 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_CALLBACK_CRYPT
#include <string.h>
#include "securec.h"
#include "bsl_log_internal.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "crypt_algid.h"
#include "hitls_crypt_type.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_md.h"
#include "crypt_eal_mac.h"
#include "crypt_eal_cipher.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_kdf.h"
#include "crypt_errno.h"
#include "hitls_error.h"
#include "crypt_default.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
#include "config_type.h"
#include "hitls_crypt.h"
#ifndef HITLS_CRYPTO_EAL
#error "Missing definition of HITLS_CRYPTO_EAL"
#endif
int32_t CRYPT_DEFAULT_RandomBytes(uint8_t *buf, uint32_t len)
{
#ifdef HITLS_CRYPTO_DRBG
return CRYPT_EAL_Randbytes(buf, len);
#else
(void)buf;
(void)len;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
uint32_t CRYPT_DEFAULT_HMAC_Size(HITLS_HashAlgo hashAlgo)
{
return CRYPT_DEFAULT_DigestSize(hashAlgo);
}
#ifdef HITLS_TLS_CALLBACK_CRYPT_HMAC_PRIMITIVES
HITLS_HMAC_Ctx *CRYPT_DEFAULT_HMAC_Init(HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t len)
{
return HITLS_CRYPT_HMAC_Init(NULL, NULL, hashAlgo, key, len);
}
int32_t CRYPT_DEFAULT_HMAC_ReInit(HITLS_HMAC_Ctx *ctx)
{
return HITLS_CRYPT_HMAC_ReInit(ctx);
}
void CRYPT_DEFAULT_HMAC_Free(HITLS_HMAC_Ctx *ctx)
{
HITLS_CRYPT_HMAC_Free(ctx);
}
int32_t CRYPT_DEFAULT_HMAC_Update(HITLS_HMAC_Ctx *ctx, const uint8_t *data, uint32_t len)
{
return HITLS_CRYPT_HMAC_Update(ctx, data, len);
}
int32_t CRYPT_DEFAULT_HMAC_Final(HITLS_HMAC_Ctx *ctx, uint8_t *out, uint32_t *len)
{
return HITLS_CRYPT_HMAC_Final(ctx, out, len);
}
#endif /* HITLS_TLS_CALLBACK_CRYPT_HMAC_PRIMITIVES */
int32_t CRYPT_DEFAULT_HMAC(HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t keyLen,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
return HITLS_CRYPT_HMAC(NULL, NULL, hashAlgo, key, keyLen, in, inLen, out, outLen);
}
uint32_t CRYPT_DEFAULT_DigestSize(HITLS_HashAlgo hashAlgo)
{
return HITLS_CRYPT_DigestSize(hashAlgo);
}
HITLS_HASH_Ctx *CRYPT_DEFAULT_DigestInit(HITLS_HashAlgo hashAlgo)
{
return HITLS_CRYPT_DigestInit(NULL, NULL, hashAlgo);
}
HITLS_HASH_Ctx *CRYPT_DEFAULT_DigestCopy(HITLS_HASH_Ctx *ctx)
{
return HITLS_CRYPT_DigestCopy(ctx);
}
void CRYPT_DEFAULT_DigestFree(HITLS_HASH_Ctx *ctx)
{
HITLS_CRYPT_DigestFree(ctx);
}
int32_t CRYPT_DEFAULT_DigestUpdate(HITLS_HASH_Ctx *ctx, const uint8_t *data, uint32_t len)
{
return HITLS_CRYPT_DigestUpdate(ctx, data, len);
}
int32_t CRYPT_DEFAULT_DigestFinal(HITLS_HASH_Ctx *ctx, uint8_t *out, uint32_t *len)
{
return HITLS_CRYPT_DigestFinal(ctx, out, len);
}
int32_t CRYPT_DEFAULT_Digest(HITLS_HashAlgo hashAlgo, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
return HITLS_CRYPT_Digest(NULL, NULL, hashAlgo, in, inLen, out, outLen);
}
int32_t CRYPT_DEFAULT_Encrypt(const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
return HITLS_CRYPT_Encrypt(NULL, NULL, cipher, in, inLen, out, outLen);
}
int32_t CRYPT_DEFAULT_Decrypt(const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
return HITLS_CRYPT_Decrypt(NULL, NULL, cipher, in, inLen, out, outLen);
}
void CRYPT_DEFAULT_CipherFree(HITLS_Cipher_Ctx *ctx)
{
HITLS_CRYPT_CipherFree(ctx);
}
HITLS_CRYPT_Key *CRYPT_DEFAULT_GenerateEcdhKey(const HITLS_ECParameters *curveParams)
{
return HITLS_CRYPT_GenerateEcdhKey(NULL, NULL, NULL, curveParams);
}
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
HITLS_CRYPT_Key *CRYPT_DEFAULT_DupKey(HITLS_CRYPT_Key *key)
{
return HITLS_CRYPT_DupKey(key);
}
#endif /* HITLS_TLS_CONFIG_MANUAL_DH */
void CRYPT_DEFAULT_FreeKey(HITLS_CRYPT_Key *key)
{
HITLS_CRYPT_FreeKey(key);
}
int32_t CRYPT_DEFAULT_GetPubKey(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen, uint32_t *pubKeyLen)
{
return HITLS_CRYPT_GetPubKey(key, pubKeyBuf, bufLen, pubKeyLen);
}
#ifdef HITLS_TLS_PROTO_TLCP11
int32_t CRYPT_DEFAULT_CalcSM2SharedSecret(HITLS_Sm2GenShareKeyParameters *sm2Params, uint8_t *sharedSecret,
uint32_t *sharedSecretLen)
{
return HITLS_CRYPT_CalcSM2SharedSecret(NULL, NULL, sm2Params, sharedSecret, sharedSecretLen);
}
#endif /* HITLS_TLS_PROTO_TLCP11 */
int32_t CRYPT_DEFAULT_DhCalcSharedSecret(HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
return HITLS_CRYPT_DhCalcSharedSecret(NULL, NULL, key, peerPubkey, pubKeyLen, sharedSecret, sharedSecretLen);
}
int32_t CRYPT_DEFAULT_EcdhCalcSharedSecret(HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
return HITLS_CRYPT_EcdhCalcSharedSecret(NULL, NULL, key, peerPubkey, pubKeyLen, sharedSecret, sharedSecretLen);
}
#ifdef HITLS_TLS_SUITE_KX_DHE
HITLS_CRYPT_Key *CRYPT_DEFAULT_GenerateDhKeyBySecbits(int32_t secbits)
{
return HITLS_CRYPT_GenerateDhKeyBySecbits(NULL, NULL, NULL, secbits);
}
HITLS_CRYPT_Key *CRYPT_DEFAULT_GenerateDhKeyByParameters(uint8_t *p, uint16_t pLen, uint8_t *g, uint16_t gLen)
{
return HITLS_CRYPT_GenerateDhKeyByParameters(NULL, NULL, p, pLen, g, gLen);
}
int32_t CRYPT_DEFAULT_GetDhParameters(HITLS_CRYPT_Key *key, uint8_t *p, uint16_t *pLen, uint8_t *g, uint16_t *gLen)
{
return HITLS_CRYPT_GetDhParameters(key, p, pLen, g, gLen);
}
#endif /* HITLS_TLS_SUITE_KX_DHE */
int32_t CRYPT_DEFAULT_HkdfExtract(const HITLS_CRYPT_HkdfExtractInput *input, uint8_t *prk, uint32_t *prkLen)
{
return HITLS_CRYPT_HkdfExtract(NULL, NULL, input, prk, prkLen);
}
int32_t CRYPT_DEFAULT_HkdfExpand(const HITLS_CRYPT_HkdfExpandInput *input, uint8_t *okm, uint32_t okmLen)
{
return HITLS_CRYPT_HkdfExpand(NULL, NULL, input, okm, okmLen);
}
#ifdef HITLS_TLS_FEATURE_KEM
int32_t CRYPT_DEFAULT_KemEncapsulate(HITLS_KemEncapsulateParams *params)
{
return HITLS_CRYPT_KemEncapsulate(NULL, NULL, NULL, params);
}
int32_t CRYPT_DEFAULT_KemDecapsulate(HITLS_CRYPT_Key *key, const uint8_t *ciphertext, uint32_t ciphertextLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
return HITLS_CRYPT_KemDecapsulate(key, ciphertext, ciphertextLen, sharedSecret, sharedSecretLen);
}
#endif /* HITLS_TLS_FEATURE_KEM */
#endif /* HITLS_TLS_CALLBACK_CRYPT */
| 2302_82127028/openHiTLS-examples_1508 | tls/crypt/crypt_self/crypt_default.c | C | unknown | 6,946 |
/*
* 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 CRYPT_DEFAULT_H
#define CRYPT_DEFAULT_H
#include <stdint.h>
#include "hitls_crypt_type.h"
#include "hitls_crypt_reg.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Generate a random number.
*
* @param buf [OUT] Random number
* @param len [IN] Random number length
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_RandomBytes(uint8_t *buf, uint32_t len);
/**
* @brief Obtain the HMAC length.
*
* @param hashAlgo [IN] hash algorithm
*
* @return HMAC length
*/
uint32_t CRYPT_DEFAULT_HMAC_Size(HITLS_HashAlgo hashAlgo);
/**
* @brief Initialize the HMAC context.
*
* @param hashAlgo [IN] Hash algorithm
* @param key [IN] Key
* @param len [IN] Key length
*
* @return HMAC context
*/
HITLS_HMAC_Ctx *CRYPT_DEFAULT_HMAC_Init(HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t len);
/**
* @brief ReInitialize the HMAC context.
*
* @param ctx [IN] HMAC context.
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_HMAC_ReInit(HITLS_HMAC_Ctx *ctx);
/**
* @brief Release the HMAC context.
*
* @param hmac [IN] HMAC context. The CTX is set NULL by the invoker.
*/
void CRYPT_DEFAULT_HMAC_Free(HITLS_HMAC_Ctx *ctx);
/**
* @brief Add the HMAC input data.
*
* @param hmac [IN] HMAC context
* @param data [IN] Input data
* @param len [IN] Input data length
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_HMAC_Update(HITLS_HMAC_Ctx *ctx, const uint8_t *data, uint32_t len);
/**
* @brief HMAC calculation result
*
* @param hmac [IN] HMAC context
* @param out [OUT] Output data
* @param len [IN/OUT] IN: Maximum length of data padding OUT: Output data length
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_HMAC_Final(HITLS_HMAC_Ctx *ctx, uint8_t *out, uint32_t *len);
/**
* @brief HMAC function
*
* @param hashAlgo [IN] Hash algorithm
* @param key [IN] Key
* @param keyLen [IN] Key length
* @param in [IN] Input data
* @param inLen [IN] Input data length
* @param out [OUT] Output data
* @param outLen [IN/OUT] IN: Maximum length of data padding OUT: Output data length
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_HMAC(HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t keyLen,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);
/**
* @brief Obtain the hash length.
*
* @param hashAlgo [IN] hash algorithm
*
* @return Hash length
*/
uint32_t CRYPT_DEFAULT_DigestSize(HITLS_HashAlgo hashAlgo);
/**
* @brief Initialize the hash context.
*
* @param hashAlgo [IN] Hash algorithm
*
* @return hash context
*/
HITLS_HASH_Ctx *CRYPT_DEFAULT_DigestInit(HITLS_HashAlgo hashAlgo);
/**
* @brief Copy the hash context.
*
* @param ctx [IN] hash context
*
* @return hash context
*/
HITLS_HASH_Ctx *CRYPT_DEFAULT_DigestCopy(HITLS_HASH_Ctx *ctx);
/**
* @brief Release the hash context.
*
* @param ctx [IN] Hash context. The CTX is set NULL by the invoker.
*/
void CRYPT_DEFAULT_DigestFree(HITLS_HASH_Ctx *ctx);
/**
* @brief Add the hash input data.
*
* @param ctx [IN] hash Context
* @param data [IN] Input data
* @param len [IN] Length of the input data
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_DigestUpdate(HITLS_HASH_Ctx *ctx, const uint8_t *data, uint32_t len);
/**
* @brief Calculate the hash result.
*
* @param ctx [IN] hash context
* @param out [OUT] Output data
* @param len [IN/OUT] IN: Maximum length of data padding OUT: Length of output data
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_DigestFinal(HITLS_HASH_Ctx *ctx, uint8_t *out, uint32_t *len);
/**
* @brief hash function
*
* @param hashAlgo [IN] hash algorithm
* @param in [IN] Input data
* @param inLen [IN] Input data length
* @param out [OUT] Output data
* @param outLen [IN/OUT] IN: Maximum length of data padding OUT: Output data length
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_Digest(HITLS_HashAlgo hashAlgo, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
/**
* @brief Encryption
*
* @param cipher [IN] Key parameters
* @param in [IN] Plaintext data
* @param inLen [IN] Length of the plaintext data
* @param out [OUT] Ciphertext data
* @param outLen [IN/OUT] IN: Maximum length of data padding OUT: Length of ciphertext data
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_Encrypt(const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
/**
* @brief Decrypt
*
* @param cipher [IN] Key parameters
* @param in [IN] Ciphertext data
* @param inLen [IN] Length of the ciphertext data
* @param out [OUT] Plaintext data
* @param outLen [IN/OUT] IN: Maximum length of data padding OUT: Length of plaintext data
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_Decrypt(const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
/**
* @brief Release the cipher ctx.
*
* @param ctx [IN] cipher ctx handle. The handle is set NULL by the invoker.
*/
void CRYPT_DEFAULT_CipherFree(HITLS_Cipher_Ctx *ctx);
/**
* @brief Generate the ECDH key pair.
*
* @param curveParams [IN] ECDH parameter
*
* @return Key handle
*/
HITLS_CRYPT_Key *CRYPT_DEFAULT_GenerateEcdhKey(const HITLS_ECParameters *curveParams);
/**
* @brief Generate a DH key pair.
*
* @param secbits [IN] Key security level
*
* @return Key handle
*/
HITLS_CRYPT_Key *CRYPT_DEFAULT_GenerateDhKeyBySecbits(int32_t secbits);
/**
* @brief Generate a DH key pair.
*
* @param p [IN] p Parameter
* @param plen [IN] p Parameter length
* @param g [IN] g Parameter
* @param glen [IN] g Parameter length
*
* @return Key handle
*/
HITLS_CRYPT_Key *CRYPT_DEFAULT_GenerateDhKeyByParameters(uint8_t *p, uint16_t pLen, uint8_t *g, uint16_t gLen);
/**
* @brief Obtain the DH parameter.
*
* @param key [IN] Key handle
* @param p [OUT] p Parameter
* @param plen [IN/OUT] IN: Maximum length of data padding OUT: p Parameter length
* @param g [OUT] g Parameter
* @param glen [IN/OUT] IN: Maximum length of data padding OUT: g Parameter length
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_GetDhParameters(HITLS_CRYPT_Key *key, uint8_t *p, uint16_t *pLen, uint8_t *g, uint16_t *gLen);
/**
* @brief Deep copy key
*
* @param key [IN] Key handle
* @retval Key handle
*/
HITLS_CRYPT_Key *CRYPT_DEFAULT_DupKey(HITLS_CRYPT_Key *key);
/**
* @brief Release the key.
*
* @param key [IN] Key handle. The key is set NULL by the invoker.
*/
void CRYPT_DEFAULT_FreeKey(HITLS_CRYPT_Key *key);
/**
* @brief Obtain the public key data.
*
* @param key [IN] Key handle
* @param pubKeyBuf [OUT] Public key data
* @param bufLen [IN] Maximum length of data padding.
* @param usedLen [OUT] Public key data length
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_GetPubKey(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen, uint32_t *pubKeyLen);
/**
* @brief Calculate the shared key. Ref RFC 5246 section 8.1.2, this interface will remove the pre-zeros.
*
* @param key [IN] Local key handle
* @param peerPubkey [IN] Peer public key data
* @param pubKeyLen [IN] Public key data length
* @param sharedSecret [OUT] Shared key
* @param sharedSecretLen [IN/OUT] IN: Maximum length of data padding OUT: length of the shared key
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_DhCalcSharedSecret(HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen);
/**
* @brief Calculate the shared key. Ref RFC 8446 section 7.4.1, this interface will retain the leading zeros.
* after calculation.
*
* @param key [IN] Local key handle
* @param peerPubkey [IN] Peer public key data
* @param pubKeyLen [IN] Public key data length
* @param sharedSecret [OUT] Shared key
* @param sharedSecretLen [IN/OUT] IN: Maximum length of data padding OUT: length of the shared key
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_EcdhCalcSharedSecret(HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen);
/**
* @brief Calculate the SM2 shared key.
*
* @param sm2Params [IN] SM2 parameters
* @param sharedSecret [OUT] Shared key
* @param sharedSecretLen [IN/OUT] IN: Maximum length of data padding OUT: length of the shared key
*
* @retval HITLS_SUCCESS
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_CalcSM2SharedSecret(HITLS_Sm2GenShareKeyParameters *sm2Params,
uint8_t *sharedSecret, uint32_t *sharedSecretLen);
/**
* @brief HKDF-Extract
*
* @param input [IN] Input key material.
* @param prk [OUT] Output key
* @param prkLen [IN/OUT] IN: Maximum buffer length OUT: Output key length
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_HkdfExtract(const HITLS_CRYPT_HkdfExtractInput *input, uint8_t *prk, uint32_t *prkLen);
/**
* @brief HKDF-Expand
*
* @param input [IN] Input key material.
* @param okm [OUT] Output key
* @param okmLen [IN] Output key length
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_HkdfExpand(const HITLS_CRYPT_HkdfExpandInput *input, uint8_t *okm, uint32_t okmLen);
/**
* @brief KEM-Encapsulate
*
* @param params [IN] KEM encapsulation parameters
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t CRYPT_DEFAULT_KemEncapsulate(HITLS_KemEncapsulateParams *params);
/**
* @brief KEM-Decapsulate
*
* @param key [IN] Key handle
* @param ciphertext [IN] Ciphertext data
* @param ciphertextLen [IN] Ciphertext data length
* @param sharedSecret [OUT] Shared key
* @param sharedSecretLen [IN/OUT] IN: Maximum length of data padding OUT: length of the shared key
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t CRYPT_DEFAULT_KemDecapsulate(HITLS_CRYPT_Key *key, const uint8_t *ciphertext, uint32_t ciphertextLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen);
#ifdef __cplusplus
}
#endif
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/crypt/crypt_self/crypt_default.h | C | unknown | 11,060 |
/*
* 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.
*/
#include "hitls_build.h"
#include "hitls_crypt_reg.h"
#include "crypt_default.h"
void HITLS_CryptMethodInit(void)
{
#ifdef HITLS_TLS_CALLBACK_CRYPT
HITLS_CRYPT_BaseMethod baseMethod = {0};
baseMethod.randBytes = CRYPT_DEFAULT_RandomBytes;
baseMethod.hmacSize = CRYPT_DEFAULT_HMAC_Size;
#ifdef HITLS_TLS_CALLBACK_CRYPT_HMAC_PRIMITIVES
baseMethod.hmacInit = CRYPT_DEFAULT_HMAC_Init;
baseMethod.hmacReinit = CRYPT_DEFAULT_HMAC_ReInit;
baseMethod.hmacFree = CRYPT_DEFAULT_HMAC_Free;
baseMethod.hmacUpdate = CRYPT_DEFAULT_HMAC_Update;
baseMethod.hmacFinal = CRYPT_DEFAULT_HMAC_Final;
#endif
baseMethod.hmac = CRYPT_DEFAULT_HMAC;
baseMethod.digestSize = CRYPT_DEFAULT_DigestSize;
baseMethod.digestInit = CRYPT_DEFAULT_DigestInit;
baseMethod.digestCopy = CRYPT_DEFAULT_DigestCopy;
baseMethod.digestFree = CRYPT_DEFAULT_DigestFree;
baseMethod.digestUpdate = CRYPT_DEFAULT_DigestUpdate;
baseMethod.digestFinal = CRYPT_DEFAULT_DigestFinal;
baseMethod.digest = CRYPT_DEFAULT_Digest;
baseMethod.encrypt = CRYPT_DEFAULT_Encrypt;
baseMethod.decrypt = CRYPT_DEFAULT_Decrypt;
baseMethod.cipherFree = CRYPT_DEFAULT_CipherFree;
HITLS_CRYPT_RegisterBaseMethod(&baseMethod);
HITLS_CRYPT_EcdhMethod ecdhMethod = {0};
ecdhMethod.generateEcdhKeyPair = CRYPT_DEFAULT_GenerateEcdhKey;
ecdhMethod.freeEcdhKey = CRYPT_DEFAULT_FreeKey;
ecdhMethod.getEcdhPubKey = CRYPT_DEFAULT_GetPubKey;
ecdhMethod.calcEcdhSharedSecret = CRYPT_DEFAULT_EcdhCalcSharedSecret;
#ifdef HITLS_TLS_PROTO_TLCP11
ecdhMethod.sm2CalEcdhSharedSecret = CRYPT_DEFAULT_CalcSM2SharedSecret;
#endif /* HITLS_TLS_PROTO_TLCP11 */
#ifdef HITLS_TLS_FEATURE_KEM
ecdhMethod.kemEncapsulate = CRYPT_DEFAULT_KemEncapsulate;
ecdhMethod.kemDecapsulate = CRYPT_DEFAULT_KemDecapsulate;
#endif /* HITLS_TLS_FEATURE_KEM */
HITLS_CRYPT_RegisterEcdhMethod(&ecdhMethod);
#ifdef HITLS_TLS_SUITE_KX_DHE
HITLS_CRYPT_DhMethod dhMethod = {0};
dhMethod.generateDhKeyBySecbits = CRYPT_DEFAULT_GenerateDhKeyBySecbits;
dhMethod.generateDhKeyByParams = CRYPT_DEFAULT_GenerateDhKeyByParameters;
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
dhMethod.dupDhKey = CRYPT_DEFAULT_DupKey;
#endif /* HITLS_TLS_CONFIG_MANUAL_DH */
dhMethod.freeDhKey = CRYPT_DEFAULT_FreeKey;
dhMethod.getDhParameters = CRYPT_DEFAULT_GetDhParameters;
dhMethod.getDhPubKey = CRYPT_DEFAULT_GetPubKey;
dhMethod.calcDhSharedSecret = CRYPT_DEFAULT_DhCalcSharedSecret;
HITLS_CRYPT_RegisterDhMethod(&dhMethod);
#endif /* HITLS_TLS_SUITE_KX_DHE */
#ifdef HITLS_TLS_PROTO_TLS13
HITLS_CRYPT_KdfMethod hkdfMethod = {0};
hkdfMethod.hkdfExtract = CRYPT_DEFAULT_HkdfExtract;
hkdfMethod.hkdfExpand = CRYPT_DEFAULT_HkdfExpand;
HITLS_CRYPT_RegisterHkdfMethod(&hkdfMethod);
#endif
#endif /* HITLS_TLS_CALLBACK_CRYPT */
} | 2302_82127028/openHiTLS-examples_1508 | tls/crypt/crypt_self/crypt_init.c | C | unknown | 3,390 |
/*
* 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.
*/
#include "hitls_build.h"
#if defined(HITLS_TLS_FEATURE_PROVIDER) || defined(HITLS_TLS_CALLBACK_CRYPT)
#include <string.h>
#include "securec.h"
#include "bsl_log_internal.h"
#include "bsl_err_internal.h"
#include "bsl_params.h"
#include "tls_binlog_id.h"
#include "crypt_algid.h"
#include "hitls_crypt_type.h"
#include "crypt_eal_rand.h"
#include "crypt_eal_md.h"
#include "crypt_eal_mac.h"
#include "crypt_eal_cipher.h"
#include "crypt_eal_pkey.h"
#include "crypt_eal_kdf.h"
#include "crypt_errno.h"
#include "hitls_error.h"
#include "crypt_default.h"
#include "bsl_params.h"
#include "crypt_params_key.h"
#include "config_type.h"
#include "hitls_crypt.h"
#ifndef HITLS_CRYPTO_EAL
#error "Missing definition of HITLS_CRYPTO_EAL"
#endif
#ifdef HITLS_TLS_SUITE_KX_DHE
#define MIN_DH8192_SECBITS 192
#define MIN_DH4096_SECBITS 152
#define MIN_DH3072_SECBITS 128
#define MIN_DH2048_SECBITS 112
#ifdef HITLS_CRYPTO_PKEY
#define MAX_PKEY_PARA_LEN 1024
#endif
#endif // HITLS_TLS_SUITE_KX_DHE
#define CCM_TLS_TAG_LEN 16u
#define CCM8_TLS_TAG_LEN 8u
/* The default user id as specified in GM/T 0009-2012 */
char g_SM2DefaultUserid[] = "1234567812345678";
#ifdef HITLS_TLS_PROTO_TLCP11
#define SM2_DEFAULT_USERID_LEN 16u
#define SM2_PUBKEY_LEN 65
#define SM2_PRVKEY_LEN 33
#endif // HITLS_TLS_PROTO_TLCP11
#ifdef HITLS_CRYPTO_MAC
static uint32_t GetHmacAlgId(HITLS_HashAlgo hashAlgo)
{
switch (hashAlgo) {
case HITLS_HASH_SHA_256:
return CRYPT_MAC_HMAC_SHA256;
case HITLS_HASH_SHA_384:
return CRYPT_MAC_HMAC_SHA384;
case HITLS_HASH_SHA_512:
return CRYPT_MAC_HMAC_SHA512;
case HITLS_HASH_MD5:
return CRYPT_MAC_HMAC_MD5;
case HITLS_HASH_SHA1:
return CRYPT_MAC_HMAC_SHA1;
case HITLS_HASH_SHA_224:
return CRYPT_MAC_HMAC_SHA224;
case HITLS_HASH_SM3:
return CRYPT_MAC_HMAC_SM3;
default:
break;
}
return CRYPT_MAC_MAX;
}
#endif // HITLS_CRYPTO_MAC
#ifdef HITLS_CRYPTO_CIPHER
static int32_t GetCipherAlgId(HITLS_CipherAlgo cipherAlgo)
{
switch (cipherAlgo) {
case HITLS_CIPHER_AES_128_CCM8:
return CRYPT_CIPHER_AES128_CCM;
case HITLS_CIPHER_AES_256_CCM8:
return CRYPT_CIPHER_AES256_CCM;
default:
break;
}
return cipherAlgo;
}
static bool IsCipherCCM8(HITLS_CipherAlgo cipherAlgo)
{
switch (cipherAlgo) {
case HITLS_CIPHER_AES_128_CCM8:
return true;
case HITLS_CIPHER_AES_256_CCM8:
return true;
default:
break;
}
return false;
}
#endif
static int32_t SetHmacMdAttr(CRYPT_EAL_MacCtx *ctx, const char *attrName)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
if (attrName == NULL) {
return CRYPT_SUCCESS;
}
BSL_Param param[] = {
{.key = CRYPT_PARAM_MD_ATTR, .valueType = BSL_PARAM_TYPE_UTF8_STR,
.value = (void *)(uintptr_t)attrName, .valueLen = strlen(attrName), .useLen = 0},
BSL_PARAM_END
};
int32_t ret = CRYPT_EAL_MacSetParam(ctx, param);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_MacFreeCtx(ctx);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID17372, "MacSetParam fail");
}
return ret;
#else
(void)ctx;
(void)attrName;
return CRYPT_SUCCESS;
#endif
}
#ifdef HITLS_TLS_CALLBACK_CRYPT_HMAC_PRIMITIVES
HITLS_HMAC_Ctx *HITLS_CRYPT_HMAC_Init(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t len)
{
#ifdef HITLS_CRYPTO_MAC
CRYPT_MAC_AlgId id = GetHmacAlgId(hashAlgo);
if (id == CRYPT_MAC_MAX) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16618, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "hashAlgo err", 0, 0, 0, 0);
return NULL;
}
CRYPT_EAL_MacCtx *ctx = NULL;
ctx = CRYPT_EAL_ProviderMacNewCtx(libCtx, id, attrName);
if (ctx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16619, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "MacNewCtx fail", 0, 0, 0, 0);
return NULL;
}
int32_t ret = SetHmacMdAttr(ctx, attrName);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17365, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "MacSetParam fail", 0, 0, 0,
0);
CRYPT_EAL_MacFreeCtx(ctx);
return NULL;
}
ret = CRYPT_EAL_MacInit(ctx, key, len);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16620, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "MacInit fail", 0, 0, 0, 0);
CRYPT_EAL_MacFreeCtx(ctx);
return NULL;
}
return ctx;
#else // HITLS_CRYPTO_MAC
(void)hashAlgo;
(void)key;
(void)len;
(void)libCtx;
(void)attrName;
return NULL;
#endif // HITLS_CRYPTO_MAC
}
int32_t HITLS_CRYPT_HMAC_ReInit(HITLS_HMAC_Ctx *ctx)
{
#ifdef HITLS_CRYPTO_MAC
return CRYPT_EAL_MacReinit(ctx);
#else
(void)ctx;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
void HITLS_CRYPT_HMAC_Free(HITLS_HMAC_Ctx *ctx)
{
#ifdef HITLS_CRYPTO_MAC
CRYPT_EAL_MacFreeCtx(ctx);
#else
(void)ctx;
#endif
return;
}
int32_t HITLS_CRYPT_HMAC_Update(HITLS_HMAC_Ctx *ctx, const uint8_t *data, uint32_t len)
{
#ifdef HITLS_CRYPTO_MAC
return CRYPT_EAL_MacUpdate(ctx, data, len);
#else
(void)ctx;
(void)data;
(void)len;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
int32_t HITLS_CRYPT_HMAC_Final(HITLS_HMAC_Ctx *ctx, uint8_t *out, uint32_t *len)
{
#ifdef HITLS_CRYPTO_MAC
return CRYPT_EAL_MacFinal(ctx, out, len);
#else
(void)ctx;
(void)out;
(void)len;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
#endif /* HITLS_TLS_CALLBACK_CRYPT_HMAC_PRIMITIVES */
int32_t HITLS_CRYPT_HMAC(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t keyLen,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
#ifdef HITLS_CRYPTO_MAC
CRYPT_MAC_AlgId id = GetHmacAlgId(hashAlgo);
if (id == CRYPT_MAC_MAX) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CRYPT_ERR_HMAC, BINLOG_ID16621, "No proper id");
}
CRYPT_EAL_MacCtx *ctx = NULL;
ctx = CRYPT_EAL_ProviderMacNewCtx(libCtx, id, attrName);
if (ctx == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CRYPT_ERR_HMAC, BINLOG_ID16622, "new ctx fail");
}
int32_t ret = SetHmacMdAttr(ctx, attrName);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_MacFreeCtx(ctx);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID17373, "MacSetParam fail");
}
ret = CRYPT_EAL_MacInit(ctx, key, keyLen);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_MacFreeCtx(ctx);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16623, "mac init fail");
}
ret = CRYPT_EAL_MacUpdate(ctx, in, inLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
CRYPT_EAL_MacFreeCtx(ctx);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16624, "MacUpdate fail");
}
ret = CRYPT_EAL_MacFinal(ctx, out, outLen);
if (ret != CRYPT_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
CRYPT_EAL_MacFreeCtx(ctx);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16625, "MacFinal fail");
}
CRYPT_EAL_MacFreeCtx(ctx);
return HITLS_SUCCESS;
#else // HITLS_CRYPTO_MAC
(void)hashAlgo;
(void)key;
(void)keyLen;
(void)in;
(void)inLen;
(void)out;
(void)outLen;
(void)libCtx;
(void)attrName;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif // HITLS_CRYPTO_MAC
}
HITLS_HASH_Ctx *HITLS_CRYPT_DigestInit(HITLS_Lib_Ctx *libCtx, const char *attrName, HITLS_HashAlgo hashAlgo)
{
#ifdef HITLS_CRYPTO_MD
CRYPT_EAL_MdCTX *ctx = NULL;
ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, hashAlgo, attrName);
if (ctx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16628, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "MdNewCtx fail", 0, 0, 0, 0);
return NULL;
}
int32_t ret = CRYPT_EAL_MdInit(ctx);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16629, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "MdInit fail", 0, 0, 0, 0);
CRYPT_EAL_MdFreeCtx(ctx);
return NULL;
}
return ctx;
#else // HITLS_CRYPTO_MD
(void)hashAlgo;
(void)libCtx;
(void)attrName;
return NULL;
#endif // HITLS_CRYPTO_MD
}
int32_t HITLS_CRYPT_Digest(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen)
{
#ifdef HITLS_CRYPTO_MD
int32_t ret;
CRYPT_EAL_MdCTX *ctx = NULL;
ctx = CRYPT_EAL_ProviderMdNewCtx(libCtx, hashAlgo, attrName);
if (ctx == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CRYPT_ERR_DIGEST, BINLOG_ID16631, "MdNewCtx fail");
}
ret = CRYPT_EAL_MdInit(ctx);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_MdFreeCtx(ctx);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16632, "MdInit fail");
}
ret = CRYPT_EAL_MdUpdate(ctx, in, inLen);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_MdFreeCtx(ctx);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16633, "MdUpdate fail");
}
ret = CRYPT_EAL_MdFinal(ctx, out, outLen);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_MdFreeCtx(ctx);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16634, "MdFinal fail");
}
CRYPT_EAL_MdFreeCtx(ctx);
return HITLS_SUCCESS;
#else // HITLS_CRYPTO_MD
(void)hashAlgo;
(void)in;
(void)inLen;
(void)out;
(void)outLen;
(void)libCtx;
(void)attrName;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif // HITLS_CRYPTO_MD
}
static int32_t SpecialModeEncryptPreSolve(CRYPT_EAL_CipherCtx *ctx, const HITLS_CipherParameters *cipher,
uint64_t inLen)
{
#ifdef HITLS_CRYPTO_CIPHER
int32_t ret = CRYPT_SUCCESS;
if (IsCipherCCM8(cipher->algo)) {
uint32_t tagLen = CCM8_TLS_TAG_LEN;
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen));
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16635, "SET_TAGLEN fail");
}
}
// In the case of CCM processing, msgLen needs to be set.
if ((cipher->algo == HITLS_CIPHER_AES_128_CCM) || (cipher->algo == HITLS_CIPHER_AES_128_CCM8) ||
(cipher->algo == HITLS_CIPHER_AES_256_CCM) || (cipher->algo == HITLS_CIPHER_AES_256_CCM8)) {
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &inLen, sizeof(inLen));
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16636, "SET_MSGLEN fail");
}
}
if (cipher->type == HITLS_AEAD_CIPHER) {
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_AAD, cipher->aad, cipher->aadLen);
}
return ret;
#else // HITLS_CRYPTO_CIPHER
(void)ctx;
(void)cipher;
(void)inLen;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif // HITLS_CRYPTO_CIPHER
}
#ifdef HITLS_CRYPTO_CIPHER
static int32_t GetCipherInitCtx(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_CipherParameters *cipher, CRYPT_EAL_CipherCtx **ctx, bool enc)
{
if (*ctx != NULL) {
return CRYPT_EAL_CipherReinit(*ctx, (uint8_t *)(uintptr_t)cipher->iv, cipher->ivLen);
}
*ctx = CRYPT_EAL_ProviderCipherNewCtx(libCtx, GetCipherAlgId(cipher->algo), attrName);
int32_t ret = CRYPT_EAL_CipherInit(*ctx, cipher->key, cipher->keyLen, cipher->iv, cipher->ivLen, enc);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_CipherFreeCtx(*ctx);
*ctx = NULL;
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16639, "CipherInit fail");
}
return CRYPT_SUCCESS;
}
#endif
int32_t HITLS_CRYPT_Encrypt(HITLS_Lib_Ctx *libCtx, const char *attrName, const HITLS_CipherParameters *cipher,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
#ifdef HITLS_CRYPTO_CIPHER
if (cipher == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_NULL_INPUT, BINLOG_ID17313, "encrypt null input");
}
CRYPT_EAL_CipherCtx *tmpCtx = NULL;
CRYPT_EAL_CipherCtx **ctx = cipher->ctx == NULL ? &tmpCtx : (CRYPT_EAL_CipherCtx **)cipher->ctx;
int32_t ret = GetCipherInitCtx(libCtx, attrName, cipher, ctx, true);
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16640, "GetCipherInitCtx fail");
}
ret = SpecialModeEncryptPreSolve(*ctx, cipher, inLen);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_CipherFreeCtx(*ctx);
*ctx = NULL;
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16641, "SpecialModeEncryptPreSolve fail");
}
uint32_t cipherLen = *outLen;
ret = CRYPT_EAL_CipherUpdate(*ctx, in, inLen, out, &cipherLen);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_CipherFreeCtx(*ctx);
*ctx = NULL;
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16642, "CipherUpdate fail");
}
if (*outLen < cipherLen) {
CRYPT_EAL_CipherFreeCtx(*ctx);
*ctx = NULL;
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CRYPT_ERR_ENCRYPT, BINLOG_ID16643, "outLen less than cipherLen");
}
uint32_t finLen = *outLen - cipherLen;
if (cipher->type == HITLS_AEAD_CIPHER) {
finLen = IsCipherCCM8(cipher->algo) ? CCM8_TLS_TAG_LEN : CCM_TLS_TAG_LEN;
ret = CRYPT_EAL_CipherCtrl(*ctx, CRYPT_CTRL_GET_TAG, out + cipherLen, finLen);
} else {
ret = CRYPT_EAL_CipherFinal(*ctx, out + cipherLen, &finLen);
}
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16644, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"%d , get finLen fail", cipher->type, 0, 0, 0);
CRYPT_EAL_CipherFreeCtx(*ctx);
*ctx = NULL;
return ret;
}
*outLen = cipherLen + finLen;
if (cipher->ctx == NULL) {
CRYPT_EAL_CipherFreeCtx(*ctx);
}
return HITLS_SUCCESS;
#else // HITLS_CRYPTO_CIPHER
(void)cipher;
(void)in;
(void)inLen;
(void)out;
(void)outLen;
(void)libCtx;
(void)attrName;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif // HITLS_CRYPTO_CIPHER
}
static int32_t AeadDecrypt(CRYPT_EAL_CipherCtx *ctx, const HITLS_CipherParameters *cipher, const uint8_t *in,
uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
#ifdef HITLS_CRYPTO_CIPHER
int32_t ret;
uint32_t tagLen = IsCipherCCM8(cipher->algo) ?
CCM8_TLS_TAG_LEN : CCM_TLS_TAG_LEN;
uint32_t cipherLen = inLen - tagLen;
uint32_t plainLen = *outLen;
ret = CRYPT_EAL_CipherUpdate(ctx, in, cipherLen, out, &plainLen);
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16645, "CipherUpdate fail");
}
if (plainLen != cipherLen) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CRYPT_ERR_DECRYPT, BINLOG_ID16646, "decrypt err");
}
uint8_t tag[16u] = {0};
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_GET_TAG, tag, tagLen);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16647, "GET_TAG err");
}
if (memcmp(tag, in + cipherLen, tagLen) != 0) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CRYPT_ERR_DECRYPT, BINLOG_ID16648, "memcmp tag fail");
}
*outLen = plainLen;
return HITLS_SUCCESS;
#else // HITLS_CRYPTO_CIPHER
(void)cipher;
(void)out;
(void)outLen;
(void)in;
(void)inLen;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif // HITLS_CRYPTO_CIPHER
}
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
int32_t CbcDecrypt(CRYPT_EAL_CipherCtx *ctx, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
#ifdef HITLS_CRYPTO_CIPHER
int32_t ret;
uint32_t plainLen = *outLen;
ret = CRYPT_EAL_CipherUpdate(ctx, in, inLen, out, &plainLen);
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16649, "CipherUpdate fail");
}
if (*outLen < plainLen) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CRYPT_ERR_DECRYPT, BINLOG_ID16650, "CipherUpdate fail");
}
uint32_t finLen = *outLen - plainLen;
ret = CRYPT_EAL_CipherFinal(ctx, out + plainLen, &finLen);
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16651, "CipherUpdate fail");
}
plainLen += finLen;
*outLen = plainLen;
return HITLS_SUCCESS;
#else
(void)ctx;
(void)out;
(void)outLen;
(void)in;
(void)inLen;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
#endif /* HITLS_TLS_SUITE_CIPHER_CBC */
#ifdef HITLS_CRYPTO_CIPHER
static int32_t DEFAULT_DecryptPrepare(CRYPT_EAL_CipherCtx *ctx, const HITLS_CipherParameters *cipher, uint32_t inLen)
{
int32_t ret = CRYPT_SUCCESS;
uint32_t tagLen = CCM_TLS_TAG_LEN;
if (IsCipherCCM8(cipher->algo)) {
tagLen = CCM8_TLS_TAG_LEN;
/* The default value of tagLen is 16 for the ctx generated by the CRYPT_EAL_CipherNewCtx.
Therefore, need to set this parameter again. */
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_TAGLEN, &tagLen, sizeof(tagLen));
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_CipherFreeCtx(ctx);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16652, "CipherUpdate fail");
}
}
if ((cipher->algo == HITLS_CIPHER_AES_128_CCM) || (cipher->algo == HITLS_CIPHER_AES_128_CCM8) ||
(cipher->algo == HITLS_CIPHER_AES_256_CCM) || (cipher->algo == HITLS_CIPHER_AES_256_CCM8)) {
// The length of the decrypted ciphertext consists of msgLen and tagLen, so tagLen needs to be subtracted.
uint64_t msgLen = inLen - tagLen;
ret = CRYPT_EAL_CipherCtrl(ctx, CRYPT_CTRL_SET_MSGLEN, &msgLen, sizeof(msgLen));
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_CipherFreeCtx(ctx);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16653, "CipherUpdate fail");
}
}
return ret;
}
#endif
int32_t HITLS_CRYPT_Decrypt(HITLS_Lib_Ctx *libCtx, const char *attrName, const HITLS_CipherParameters *cipher,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen)
{
#ifdef HITLS_CRYPTO_CIPHER
if (cipher == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_NULL_INPUT, BINLOG_ID17312, "encrypt null input");
}
CRYPT_EAL_CipherCtx *tmpCtx = NULL;
CRYPT_EAL_CipherCtx **ctx = cipher->ctx == NULL ? &tmpCtx : (CRYPT_EAL_CipherCtx **)cipher->ctx;
int32_t ret = GetCipherInitCtx(libCtx, attrName, cipher, ctx, false);
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16654, "CipherUpdate fail");
}
ret = DEFAULT_DecryptPrepare(*ctx, cipher, inLen);
if (ret != CRYPT_SUCCESS) {
*ctx = NULL;
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16655, "CipherUpdate fail");
}
if (cipher->type == HITLS_AEAD_CIPHER) {
ret = CRYPT_EAL_CipherCtrl(*ctx, CRYPT_CTRL_SET_AAD, cipher->aad, cipher->aadLen);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_CipherFreeCtx(*ctx);
*ctx = NULL;
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16656, "SET_AAD fail");
}
ret = AeadDecrypt(*ctx, cipher, in, inLen, out, outLen);
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
} else if (cipher->type == HITLS_CBC_CIPHER) {
ret = CbcDecrypt(*ctx, in, inLen, out, outLen);
#endif
} else {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16657, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"not support other cipher type", 0, 0, 0, 0);
ret = HITLS_CRYPT_ERR_DECRYPT;
}
if (cipher->ctx == NULL) {
CRYPT_EAL_CipherFreeCtx(*ctx);
}
return ret;
#else
(void)cipher;
(void)in;
(void)out;
(void)outLen;
(void)inLen;
(void)libCtx;
(void)attrName;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
#ifdef HITLS_CRYPTO_PKEY
CRYPT_EAL_PkeyCtx *GeneratePkeyByParaId(HITLS_Lib_Ctx *libCtx, const char *attrName,
CRYPT_PKEY_AlgId algId, CRYPT_PKEY_ParaId paraId, bool isKem)
{
int32_t ret;
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, algId, isKem ? CRYPT_EAL_PKEY_KEM_OPERATE : CRYPT_EAL_PKEY_EXCH_OPERATE, attrName);
if (pkey == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16658, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PkeyNewCtx fail", 0, 0, 0, 0);
return NULL;
}
if (paraId != CRYPT_PKEY_PARAID_MAX) {
ret = CRYPT_EAL_PkeySetParaById(pkey, paraId);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16659, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PkeySetParaById fail", 0, 0, 0, 0);
CRYPT_EAL_PkeyFreeCtx(pkey);
return NULL;
}
}
ret = CRYPT_EAL_PkeyGen(pkey);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16660, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "PkeyGen fail %u", ret, 0, 0, 0);
CRYPT_EAL_PkeyFreeCtx(pkey);
return NULL;
}
return pkey;
}
#endif
CRYPT_EAL_PkeyCtx *GenerateKeyByNamedGroup(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_Config *config, HITLS_NamedGroup groupId)
{
#ifdef HITLS_CRYPTO_PKEY
const TLS_GroupInfo *groupInfo = ConfigGetGroupInfo(config, groupId);
if (groupInfo == NULL) {
return NULL;
}
return GeneratePkeyByParaId(libCtx, attrName, groupInfo->algId, groupInfo->paraId, groupInfo->isKem);
#else
(void)libCtx;
(void)attrName;
(void)config;
(void)groupId;
#endif
return NULL;
}
HITLS_CRYPT_Key *HITLS_CRYPT_GenerateEcdhKey(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_Config *config, const HITLS_ECParameters *curveParams)
{
switch (curveParams->type) {
case HITLS_EC_CURVE_TYPE_NAMED_CURVE:
return GenerateKeyByNamedGroup(libCtx, attrName, config, curveParams->param.namedcurve);
default:
break;
}
return NULL;
}
#ifdef HITLS_CRYPTO_PKEY
#ifdef HITLS_TLS_PROTO_TLCP11
static int32_t SetSM2SelfCtx(CRYPT_EAL_PkeyCtx *selfCtx, HITLS_Sm2GenShareKeyParameters *sm2Params)
{
uint8_t localPrvData[SM2_PRVKEY_LEN] = {0};
CRYPT_EAL_PkeyPrv localPrv = { 0 };
localPrv.id = CRYPT_PKEY_SM2;
localPrv.key.eccPrv.data = localPrvData;
localPrv.key.eccPrv.len = sizeof(localPrvData);
int32_t ret = CRYPT_EAL_PkeyGetPrv(sm2Params->tmpPriKey, &localPrv);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16667, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "GetPrv fail", 0, 0, 0, 0);
return ret;
}
ret = CRYPT_EAL_PkeyCtrl(selfCtx, CRYPT_CTRL_SET_SM2_RANDOM, localPrv.key.eccPrv.data, localPrv.key.eccPrv.len);
(void)memset_s(localPrvData, SM2_PRVKEY_LEN, 0, SM2_PRVKEY_LEN);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16668, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SET_SM2_RANDOM fail", 0, 0, 0, 0);
return ret;
}
ret = CRYPT_EAL_PkeyCtrl(selfCtx, CRYPT_CTRL_SET_SM2_USER_ID, (void *)g_SM2DefaultUserid, SM2_DEFAULT_USERID_LEN);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16669, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SET_SM2_USER_ID fail", 0, 0, 0, 0);
return ret;
}
int32_t server = sm2Params->isClient ? 0 : 1;
return CRYPT_EAL_PkeyCtrl(selfCtx, CRYPT_CTRL_SET_SM2_SERVER, &server, sizeof(int32_t));
}
static int32_t CalcSM2SecretPre(
CRYPT_EAL_PkeyCtx *peerCtx, HITLS_Sm2GenShareKeyParameters *sm2Params)
{
uint8_t peerPubData[SM2_PUBKEY_LEN] = {0};
BSL_Param param[2] = { {0}, BSL_PARAM_END };
(void)BSL_PARAM_InitValue(param, CRYPT_PARAM_PKEY_ENCODE_PUBKEY, BSL_PARAM_TYPE_OCTETS,
peerPubData, SM2_PUBKEY_LEN);
int32_t ret = CRYPT_EAL_PkeyGetPubEx(sm2Params->peerPubKey, param);
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16673, "GetPub fail");
}
param[0].valueLen = param[0].useLen;
ret = CRYPT_EAL_PkeySetPubEx(peerCtx, param);
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16674, "SetPub fail");
}
ret = CRYPT_EAL_PkeyCtrl(peerCtx, CRYPT_CTRL_SET_SM2_R, sm2Params->tmpPeerPubkey, sm2Params->tmpPeerPubKeyLen);
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16675, "SET_SM2_R fail");
}
ret = CRYPT_EAL_PkeyCtrl(peerCtx, CRYPT_CTRL_SET_SM2_USER_ID, (void *)g_SM2DefaultUserid, SM2_DEFAULT_USERID_LEN);
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16676, "SET_SM2_USER_ID fail");
}
return CRYPT_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLCP11 */
#endif
#ifdef HITLS_TLS_PROTO_TLCP11
int32_t HITLS_CRYPT_CalcSM2SharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_Sm2GenShareKeyParameters *sm2Params, uint8_t *sharedSecret,
uint32_t *sharedSecretLen)
{
#ifdef HITLS_CRYPTO_PKEY
if (sm2Params->priKey == NULL || sm2Params->peerPubKey == NULL || sm2Params->tmpPriKey == NULL ||
sm2Params->tmpPeerPubkey == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CRYPT_ERR_CALC_SHARED_KEY, BINLOG_ID16670, "input null");
}
CRYPT_EAL_PkeyCtx *selfCtx = (CRYPT_EAL_PkeyCtx *)sm2Params->priKey;
int32_t ret = SetSM2SelfCtx(selfCtx, sm2Params);
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16671, "SetSM2SelfCtx fail");
}
CRYPT_EAL_PkeyCtx *peerCtx = NULL;
peerCtx = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_SM2, CRYPT_EAL_PKEY_EXCH_OPERATE, attrName);
if (peerCtx == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CRYPT_ERR_CALC_SHARED_KEY, BINLOG_ID16672, "peerCtx new fail");
}
ret = CalcSM2SecretPre(peerCtx, sm2Params);
if (ret != CRYPT_SUCCESS) {
goto EXIT;
}
ret = CRYPT_EAL_PkeyComputeShareKey(selfCtx, peerCtx, sharedSecret, sharedSecretLen);
EXIT:
CRYPT_EAL_PkeyFreeCtx(peerCtx);
return ret;
#else
(void)sm2Params;
(void)sharedSecret;
(void)sharedSecretLen;
(void)libCtx;
(void)attrName;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
#endif /* HITLS_TLS_PROTO_TLCP11 */
int32_t HITLS_CRYPT_DhCalcSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
#ifdef HITLS_CRYPTO_PKEY
uint32_t flag = CRYPT_DH_NO_PADZERO;
int32_t ret = CRYPT_EAL_PkeyCtrl(key, CRYPT_CTRL_SET_DH_FLAG, (void *)&flag, sizeof(uint32_t));
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID17354, "SET_DH_NOLEANDING_FLAG fail");
}
return HITLS_CRYPT_EcdhCalcSharedSecret(libCtx, attrName, key, peerPubkey, pubKeyLen, sharedSecret,
sharedSecretLen);
#else // HITLS_CRYPTO_PKEY
(void)key;
(void)pubKeyLen;
(void)peerPubkey;
(void)sharedSecret;
(void)sharedSecretLen;
(void)libCtx;
(void)attrName;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
int32_t HITLS_CRYPT_EcdhCalcSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
#ifdef HITLS_CRYPTO_PKEY
int32_t ret;
int32_t id = CRYPT_EAL_PkeyGetId(key);
CRYPT_EAL_PkeyCtx *peerPk = NULL;
peerPk = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, id, CRYPT_EAL_PKEY_EXCH_OPERATE, attrName);
if (peerPk == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CRYPT_ERR_CALC_SHARED_KEY, BINLOG_ID16678, "peerPk new fail");
}
if (id == CRYPT_PKEY_ECDH) {
CRYPT_PKEY_ParaId paraId = CRYPT_EAL_PkeyGetParaId(key);
if (paraId == CRYPT_PKEY_PARAID_MAX) {
ret = CRYPT_EAL_ERR_ALGID;
(void)RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16679, "paraId error");
goto EXIT;
}
ret = CRYPT_EAL_PkeySetParaById(peerPk, paraId);
if (ret != CRYPT_SUCCESS) {
(void)RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16680, "SetParaById fail");
goto EXIT;
}
}
BSL_Param param[2] = { {0}, BSL_PARAM_END };
(void)BSL_PARAM_InitValue(param, CRYPT_PARAM_PKEY_ENCODE_PUBKEY, BSL_PARAM_TYPE_OCTETS, peerPubkey, pubKeyLen);
ret = CRYPT_EAL_PkeySetPubEx(peerPk, param);
if (ret != CRYPT_SUCCESS) {
(void)RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16681, "SetPub fail");
goto EXIT;
}
ret = CRYPT_EAL_PkeyComputeShareKey(key, peerPk, sharedSecret, sharedSecretLen);
if (ret != CRYPT_SUCCESS) {
(void)RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16682, "ComputeShareKey fail");
}
EXIT:
CRYPT_EAL_PkeyFreeCtx(peerPk);
return ret;
#else // HITLS_CRYPTO_PKEY
(void)key;
(void)pubKeyLen;
(void)peerPubkey;
(void)sharedSecret;
(void)sharedSecretLen;
(void)libCtx;
(void)attrName;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
#ifdef HITLS_TLS_SUITE_KX_DHE
HITLS_CRYPT_Key *HITLS_CRYPT_GenerateDhKeyBySecbits(HITLS_Lib_Ctx *libCtx,
const char *attrName, const HITLS_Config *tlsConfig, int32_t secBits)
{
(void)tlsConfig;
CRYPT_PKEY_ParaId paraId = CRYPT_DH_RFC2409_1024;
if (secBits >= MIN_DH8192_SECBITS) {
paraId = CRYPT_DH_RFC3526_8192;
} else if (secBits >= MIN_DH4096_SECBITS) {
paraId = CRYPT_DH_RFC3526_4096;
} else if (secBits >= MIN_DH3072_SECBITS) {
paraId = CRYPT_DH_RFC3526_3072;
} else if (secBits >= MIN_DH2048_SECBITS) {
paraId = CRYPT_DH_RFC3526_2048;
}
return GeneratePkeyByParaId(libCtx, attrName, CRYPT_PKEY_DH, paraId, false);
}
HITLS_CRYPT_Key *HITLS_CRYPT_GenerateDhKeyByParameters(HITLS_Lib_Ctx *libCtx,
const char *attrName, uint8_t *p, uint16_t pLen, uint8_t *g, uint16_t gLen)
{
#ifdef HITLS_CRYPTO_DH
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, CRYPT_PKEY_DH, CRYPT_EAL_PKEY_EXCH_OPERATE, attrName);
if (pkey == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16683, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PkeyNewCtx fail", 0, 0, 0, 0);
return NULL;
}
CRYPT_EAL_PkeyPara para = {0};
para.id = CRYPT_PKEY_DH;
para.para.dhPara.p = p;
para.para.dhPara.pLen = pLen;
para.para.dhPara.g = g;
para.para.dhPara.gLen = gLen;
int32_t ret = CRYPT_EAL_PkeySetPara(pkey, ¶);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16684, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "SetPara fail", 0, 0, 0, 0);
CRYPT_EAL_PkeyFreeCtx(pkey);
return NULL;
}
ret = CRYPT_EAL_PkeyGen(pkey);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16685, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "PkeyGen fail", 0, 0, 0, 0);
CRYPT_EAL_PkeyFreeCtx(pkey);
return NULL;
}
return pkey;
#else
(void)p;
(void)pLen;
(void)g;
(void)gLen;
(void)libCtx;
(void)attrName;
return NULL;
#endif
}
int32_t HITLS_CRYPT_GetDhParameters(HITLS_CRYPT_Key *key, uint8_t *p, uint16_t *pLen, uint8_t *g, uint16_t *gLen)
{
#ifdef HITLS_CRYPTO_PKEY
int32_t ret;
uint8_t tmpP[MAX_PKEY_PARA_LEN] = {0};
uint8_t tmpQ[MAX_PKEY_PARA_LEN] = {0};
uint8_t tmpG[MAX_PKEY_PARA_LEN] = {0};
CRYPT_EAL_PkeyPara para = {0};
para.id = CRYPT_PKEY_DH;
para.para.dhPara.p = p;
para.para.dhPara.pLen = *pLen;
para.para.dhPara.q = tmpQ;
para.para.dhPara.qLen = sizeof(tmpQ);
para.para.dhPara.g = g;
para.para.dhPara.gLen = *gLen;
if (p == NULL) {
para.para.dhPara.p = tmpP;
para.para.dhPara.pLen = sizeof(tmpP);
}
if (g == NULL) {
para.para.dhPara.g = tmpG;
para.para.dhPara.gLen = sizeof(tmpG);
}
ret = CRYPT_EAL_PkeyGetPara(key, ¶);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16686, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "GetPara fail", 0, 0, 0, 0);
return ret;
}
*pLen = (uint16_t)para.para.dhPara.pLen;
*gLen = (uint16_t)para.para.dhPara.gLen;
return HITLS_SUCCESS;
#else
(void)key;
(void)p;
(void)pLen;
(void)g;
(void)gLen;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
#endif /* HITLS_TLS_SUITE_KX_DHE */
int32_t HITLS_CRYPT_HkdfExtract(HITLS_Lib_Ctx *libCtx,
const char *attrName, const HITLS_CRYPT_HkdfExtractInput *input, uint8_t *prk, uint32_t *prkLen)
{
#ifdef HITLS_CRYPTO_HKDF
int32_t ret;
uint32_t tmpLen = *prkLen;
CRYPT_MAC_AlgId id = GetHmacAlgId(input->hashAlgo);
if (id == CRYPT_MAC_MAX) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16687, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GetHmacAlgId fail", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_HMAC;
}
CRYPT_EAL_KdfCTX *kdfCtx = NULL;
kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, attrName);
if (kdfCtx == NULL) {
return HITLS_CRYPT_ERR_HKDF_EXTRACT;
}
CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_EXTRACT;
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &id, sizeof(id));
(void)BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32, &mode, sizeof(mode));
(void)BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
(void *)(uintptr_t)input->inputKeyMaterial, input->inputKeyMaterialLen);
(void)BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SALT, BSL_PARAM_TYPE_OCTETS,
(void *)(uintptr_t)input->salt, input->saltLen);
(void)BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_KDF_EXLEN, BSL_PARAM_TYPE_UINT32_PTR, &tmpLen, sizeof(tmpLen));
ret = CRYPT_EAL_KdfSetParam(kdfCtx, params);
if (ret != CRYPT_SUCCESS) {
goto EXIT;
}
ret = CRYPT_EAL_KdfDerive(kdfCtx, prk, tmpLen);
if (ret != CRYPT_SUCCESS) {
goto EXIT;
}
*prkLen = tmpLen;
ret = HITLS_SUCCESS;
EXIT:
CRYPT_EAL_KdfFreeCtx(kdfCtx);
return ret;
#else
(void)input;
(void)prk;
(void)prkLen;
(void)libCtx;
(void)attrName;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
int32_t HITLS_CRYPT_HkdfExpand(HITLS_Lib_Ctx *libCtx,
const char *attrName, const HITLS_CRYPT_HkdfExpandInput *input, uint8_t *okm, uint32_t okmLen)
{
#ifdef HITLS_CRYPTO_HKDF
int32_t ret;
CRYPT_MAC_AlgId id = GetHmacAlgId(input->hashAlgo);
if (id == CRYPT_MAC_MAX) {
return HITLS_CRYPT_ERR_HMAC;
}
CRYPT_EAL_KdfCTX *kdfCtx = NULL;
kdfCtx = CRYPT_EAL_ProviderKdfNewCtx(libCtx, CRYPT_KDF_HKDF, attrName);
if (kdfCtx == NULL) {
return HITLS_CRYPT_ERR_HKDF_EXPAND;
}
CRYPT_HKDF_MODE mode = CRYPT_KDF_HKDF_MODE_EXPAND;
BSL_Param params[5] = {{0}, {0}, {0}, {0}, BSL_PARAM_END};
(void)BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, &id, sizeof(id));
(void)BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_MODE, BSL_PARAM_TYPE_UINT32, &mode, sizeof(mode));
(void)BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_PRK, BSL_PARAM_TYPE_OCTETS,
(void *)(uintptr_t)input->prk, input->prkLen);
(void)BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_INFO, BSL_PARAM_TYPE_OCTETS,
(void *)(uintptr_t)input->info, input->infoLen);
ret = CRYPT_EAL_KdfSetParam(kdfCtx, params);
if (ret != CRYPT_SUCCESS) {
goto EXIT;
}
ret = CRYPT_EAL_KdfDerive(kdfCtx, okm, okmLen);
EXIT:
CRYPT_EAL_KdfFreeCtx(kdfCtx);
return ret;
#else
(void)input;
(void)okm;
(void)okmLen;
(void)libCtx;
(void)attrName;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
#ifdef HITLS_TLS_FEATURE_PROVIDER
int32_t HITLS_CRYPT_RandbytesEx(HITLS_Lib_Ctx *libCtx, uint8_t *bytes, uint32_t bytesLen)
{
return CRYPT_EAL_RandbytesEx(libCtx, bytes, bytesLen);
}
#endif /*HITLS_TLS_FEATURE_PROVIDER */
void HITLS_CRYPT_FreeKey(HITLS_CRYPT_Key *key)
{
CRYPT_EAL_PkeyFreeCtx(key);
}
uint32_t HITLS_CRYPT_DigestSize(HITLS_HashAlgo hashAlgo)
{
#ifdef HITLS_CRYPTO_MD
return CRYPT_EAL_MdGetDigestSize((CRYPT_MD_AlgId)hashAlgo);
#else
(void)hashAlgo;
return 0;
#endif
}
HITLS_HASH_Ctx *HITLS_CRYPT_DigestCopy(HITLS_HASH_Ctx *ctx)
{
#ifdef HITLS_CRYPTO_MD
return CRYPT_EAL_MdDupCtx(ctx);
#else
(void)ctx;
return NULL;
#endif
}
void HITLS_CRYPT_DigestFree(HITLS_HASH_Ctx *ctx)
{
#ifdef HITLS_CRYPTO_MD
CRYPT_EAL_MdFreeCtx(ctx);
#else
(void)ctx;
#endif
return;
}
int32_t HITLS_CRYPT_DigestUpdate(HITLS_HASH_Ctx *ctx, const uint8_t *data, uint32_t len)
{
#ifdef HITLS_CRYPTO_MD
return CRYPT_EAL_MdUpdate(ctx, data, len);
#else
(void)ctx;
(void)data;
(void)len;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
int32_t HITLS_CRYPT_DigestFinal(HITLS_HASH_Ctx *ctx, uint8_t *out, uint32_t *len)
{
#ifdef HITLS_CRYPTO_MD
return CRYPT_EAL_MdFinal(ctx, out, len);
#else
(void)ctx;
(void)out;
(void)len;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
void HITLS_CRYPT_CipherFree(HITLS_Cipher_Ctx *ctx)
{
CRYPT_EAL_CipherFreeCtx(ctx);
}
#ifdef HITLS_TLS_CONFIG_MANUAL_DH
HITLS_CRYPT_Key *HITLS_CRYPT_DupKey(HITLS_CRYPT_Key *key)
{
#ifdef HITLS_CRYPTO_PKEY
return CRYPT_EAL_PkeyDupCtx(key);
#else
(void)key;
return NULL;
#endif
}
#endif /* HITLS_TLS_CONFIG_MANUAL_DH */
int32_t HITLS_CRYPT_GetPubKey(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen, uint32_t *pubKeyLen)
{
#ifdef HITLS_CRYPTO_PKEY
BSL_Param param[2] = { {0}, BSL_PARAM_END };
(void)BSL_PARAM_InitValue(param, CRYPT_PARAM_PKEY_ENCODE_PUBKEY, BSL_PARAM_TYPE_OCTETS, pubKeyBuf, bufLen);
int32_t ret = CRYPT_EAL_PkeyGetPubEx(key, param);
if (ret != CRYPT_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16664, "GetPub fail");
}
*pubKeyLen = param[0].useLen;
return ret;
#else
(void)key;
(void)pubKeyBuf;
(void)bufLen;
(void)pubKeyLen;
return HITLS_CRYPT_ERR_ENCODE_ECDH_KEY;
#endif
}
#ifdef HITLS_TLS_FEATURE_KEM
int32_t HITLS_CRYPT_KemEncapsulate(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_Config *config, HITLS_KemEncapsulateParams *params)
{
const TLS_GroupInfo *groupInfo = ConfigGetGroupInfo(config, params->groupId);
if (groupInfo == NULL) {
return HITLS_INVALID_INPUT;
}
int32_t ret;
CRYPT_EAL_PkeyCtx *pkey = NULL;
pkey = CRYPT_EAL_ProviderPkeyNewCtx(libCtx, groupInfo->algId, CRYPT_EAL_PKEY_KEM_OPERATE, attrName);
if (pkey == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16658, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PkeyNewCtx fail", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_KEM_ENCAPSULATE;
}
if (groupInfo->paraId != CRYPT_PKEY_PARAID_MAX) {
ret = CRYPT_EAL_PkeySetParaById(pkey, groupInfo->paraId);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16659, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PkeySetParaById fail", 0, 0, 0, 0);
CRYPT_EAL_PkeyFreeCtx(pkey);
return ret;
}
}
BSL_Param param[2] = { {0}, BSL_PARAM_END };
(void)BSL_PARAM_InitValue(param, CRYPT_PARAM_PKEY_ENCODE_PUBKEY, BSL_PARAM_TYPE_OCTETS, params->peerPubkey,
params->pubKeyLen);
ret = CRYPT_EAL_PkeySetPubEx(pkey, param);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16660, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PkeySetPub fail", 0, 0, 0, 0);
CRYPT_EAL_PkeyFreeCtx(pkey);
return ret;
}
ret = CRYPT_EAL_PkeyEncaps(pkey, params->ciphertext, params->ciphertextLen, params->sharedSecret,
params->sharedSecretLen);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16661, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PkeyEncaps fail", 0, 0, 0, 0);
}
CRYPT_EAL_PkeyFreeCtx(pkey);
return ret;
}
int32_t HITLS_CRYPT_KemDecapsulate(HITLS_CRYPT_Key *key, const uint8_t *ciphertext, uint32_t ciphertextLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen)
{
return CRYPT_EAL_PkeyDecaps(key, ciphertext, ciphertextLen, sharedSecret, sharedSecretLen);
}
#endif /* HITLS_TLS_FEATURE_KEM */
#ifdef HITLS_CRYPTO_KDFTLS12
static void InitKdfTls12Param(CRYPT_KeyDeriveParameters *input, CRYPT_MAC_AlgId *id, BSL_Param *params)
{
(void)BSL_PARAM_InitValue(¶ms[0], CRYPT_PARAM_KDF_MAC_ID, BSL_PARAM_TYPE_UINT32, id, sizeof(CRYPT_MAC_AlgId));
(void)BSL_PARAM_InitValue(¶ms[1], CRYPT_PARAM_KDF_KEY, BSL_PARAM_TYPE_OCTETS,
(void *)(uintptr_t)input->secret, input->secretLen);
(void)BSL_PARAM_InitValue(¶ms[2], CRYPT_PARAM_KDF_LABEL, BSL_PARAM_TYPE_OCTETS, // 2: index of label
(void *)(uintptr_t)input->label, input->labelLen);
(void)BSL_PARAM_InitValue(¶ms[3], CRYPT_PARAM_KDF_SEED, BSL_PARAM_TYPE_OCTETS, // 3: index of seed
(void *)(uintptr_t)input->seed, input->seedLen);
if (input->attrName != NULL && strlen(input->attrName) > 0) {
(void)BSL_PARAM_InitValue(¶ms[4], CRYPT_PARAM_MD_ATTR, BSL_PARAM_TYPE_UTF8_STR, // 4: index of md attr
(void *)(uintptr_t)input->attrName, strlen(input->attrName));
}
}
#endif
int32_t HITLS_CRYPT_PRF(CRYPT_KeyDeriveParameters *input, uint8_t *out, uint32_t outLen)
{
#ifdef HITLS_CRYPTO_KDFTLS12
CRYPT_MAC_AlgId id = GetHmacAlgId(input->hashAlgo);
BSL_Param params[6] = {{0}, {0}, {0}, {0}, {0}, BSL_PARAM_END}; // Set 5 parameters for kdftls12
InitKdfTls12Param(input, &id, params);
CRYPT_EAL_KdfCTX *ctx = CRYPT_EAL_ProviderKdfNewCtx(input->libCtx, CRYPT_KDF_KDFTLS12, input->attrName);
if (ctx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17374, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"KdfNewCtx fail", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_KDF;
}
int32_t ret = CRYPT_EAL_KdfSetParam(ctx, params);
if (ret != CRYPT_SUCCESS) {
CRYPT_EAL_KdfFreeCtx(ctx);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17375, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"KdfSetParam fail", 0, 0, 0, 0);
return ret;
}
ret = CRYPT_EAL_KdfDerive(ctx, out, outLen);
CRYPT_EAL_KdfFreeCtx(ctx);
if (ret != CRYPT_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17376, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"KdfDerive fail", 0, 0, 0, 0);
}
return ret;
#else
(void)input;
(void)out;
(void)outLen;
return CRYPT_EAL_ALG_NOT_SUPPORT;
#endif
}
#endif /* HITLS_TLS_CALLBACK_CRYPT || HITLS_TLS_FEATURE_PROVIDER */ | 2302_82127028/openHiTLS-examples_1508 | tls/crypt/crypt_self/hitls_crypt.c | C | unknown | 43,043 |
/*
* 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_CRYPT_H
#define HITLS_CRYPT_H
#include <stdint.h>
#include "hitls_crypt_type.h"
#include "hitls_crypt_reg.h"
#include "crypt.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Initialize the HMAC context.
*
* This function initializes the HMAC (Hash-based Message Authentication Code) context
* with the given library context, attribute name, hash algorithm, key, and key length.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param hashAlgo [IN] Hash algorithm to be used in the HMAC operation, e.g., HITLS_SHA256.
* @param key [IN] Secret key used for HMAC calculation.
* @param len [IN] Length of the secret key in bytes.
*
* @return HMAC context
* Returns a pointer to the initialized HMAC context.
* Returns NULL if the initialization fails.
*/
HITLS_HMAC_Ctx *HITLS_CRYPT_HMAC_Init(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t len);
/**
* @brief Perform HMAC calculation.
*
* This function calculates the HMAC (Hash-based Message Authentication Code)
* using the given library context, attribute name, hash algorithm, key, input data,
* and stores the result in the output buffer.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param hashAlgo [IN] Hash algorithm to be used in the HMAC operation, e.g., HITLS_SHA256.
* @param key [IN] Secret key used for HMAC calculation.
* @param keyLen [IN] Length of the secret key in bytes.
* @param in [IN] Input data to be processed for HMAC calculation.
* @param inLen [IN] Length of the input data in bytes.
* @param out [OUT] Buffer to store the calculated HMAC output.
* @param outLen [IN/OUT] IN: Maximum length of the output buffer. OUT: Actual length of the calculated HMAC output.
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t HITLS_CRYPT_HMAC(HITLS_Lib_Ctx *libCtx, const char *attrName, HITLS_HashAlgo hashAlgo, const uint8_t *key,
uint32_t keyLen, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);
/**
* @brief Perform hash calculation.
*
* This function calculates the hash of the input data using the given library context,
* attribute name, hash algorithm, and stores the result in the output buffer.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param hashAlgo [IN] Hash algorithm to be used in the hash operation, e.g., HITLS_SHA256.
* @param in [IN] Input data to be processed for hash calculation.
* @param inLen [IN] Length of the input data in bytes.
* @param out [OUT] Buffer to store the calculated hash output.
* @param outLen [IN/OUT] IN: Maximum length of the output buffer. OUT: Actual length of the calculated hash output.
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t HITLS_CRYPT_Digest(HITLS_Lib_Ctx *libCtx, const char *attrName, HITLS_HashAlgo hashAlgo, const uint8_t *in,
uint32_t inLen, uint8_t *out, uint32_t *outLen);
/**
* @brief Perform encryption operation.
*
* This function encrypts the input data using the given library context, attribute name,
* cipher parameters, and stores the encrypted data in the output buffer.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param cipher [IN] Key parameters for the encryption operation.
* @param in [IN] Plaintext data to be encrypted.
* @param inLen [IN] Length of the plaintext data in bytes.
* @param out [OUT] Buffer to store the encrypted data (ciphertext).
* @param outLen [IN/OUT] IN: Maximum length of the output buffer. OUT: Actual length of the encrypted data.
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t HITLS_CRYPT_Encrypt(HITLS_Lib_Ctx *libCtx, const char *attrName, const HITLS_CipherParameters *cipher,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);
/**
* @brief Perform decryption operation.
*
* This function decrypts the input ciphertext using the given library context, attribute name,
* cipher parameters, and stores the decrypted data in the output buffer.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param cipher [IN] Key parameters for the decryption operation.
* @param in [IN] Ciphertext data to be decrypted.
* @param inLen [IN] Length of the ciphertext data in bytes.
* @param out [OUT] Buffer to store the decrypted data (plaintext).
* @param outLen [IN/OUT] IN: Maximum length of the output buffer. OUT: Actual length of the decrypted data.
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t HITLS_CRYPT_Decrypt(HITLS_Lib_Ctx *libCtx, const char *attrName, const HITLS_CipherParameters *cipher,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);
/**
* @brief Generate an ECDH key pair.
*
* This function generates an ECDH (Elliptic Curve Diffie-Hellman) key pair
* using the given library context, attribute name, configuration, and curve parameters.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param config [IN] Configuration for the ECDH key generation.
* @param curveParams [IN] ECDH parameter specifying the elliptic curve.
*
* @return Key handle
* Returns a pointer to the generated ECDH key handle.
* Returns NULL if the key generation fails.
*/
HITLS_CRYPT_Key *HITLS_CRYPT_GenerateEcdhKey(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_Config *config, const HITLS_ECParameters *curveParams);
/**
* @brief Calculate the shared secret.
*
* This function calculates the shared secret using the given library context, attribute name, local key handle,
* peer public key data, and its length. Ref RFC 5246 section 8.1.2, this interface will remove the pre-zeros.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param key [IN] Local key handle.
* @param peerPubkey [IN] Peer public key data.
* @param pubKeyLen [IN] Length of the peer public key data.
* @param sharedSecret [OUT] Buffer to store the shared secret.
* @param sharedSecretLen [IN/OUT] IN: Maximum length of the buffer. OUT: Actual length of the shared secret.
*
* @retval HITLS_SUCCESS Succeeded.
* @retval Other Failed.
*/
int32_t HITLS_CRYPT_DhCalcSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName, HITLS_CRYPT_Key *key,
uint8_t *peerPubkey, uint32_t pubKeyLen, uint8_t *sharedSecret, uint32_t *sharedSecretLen);
/**
* @brief Calculate the shared secret.
*
* This function calculates the shared secret using the given library context, attribute name, local key handle,
* peer public key data, and its length. Ref RFC 8446 section 7.4.1, this interface will retain the leading zeros.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param key [IN] Local key handle.
* @param peerPubkey [IN] Peer public key data.
* @param pubKeyLen [IN] Length of the peer public key data.
* @param sharedSecret [OUT] Buffer to store the shared secret.
* @param sharedSecretLen [IN/OUT] IN: Maximum length of the buffer. OUT: Actual length of the shared secret.
*
* @retval HITLS_SUCCESS Succeeded.
* @retval Other Failed.
*/
int32_t HITLS_CRYPT_EcdhCalcSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName, HITLS_CRYPT_Key *key,
uint8_t *peerPubkey, uint32_t pubKeyLen, uint8_t *sharedSecret, uint32_t *sharedSecretLen);
/**
* @brief Calculate the SM2 shared secret.
*
* This function calculates the SM2 shared secret using the given library context, attribute name, and SM2 parameters.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param sm2Params [IN] Parameters for SM2 shared key generation.
* @param sharedSecret [OUT] Buffer to store the shared secret.
* @param sharedSecretLen [IN/OUT] IN: Maximum length of the buffer. OUT: Actual length of the shared secret.
*
* @retval HITLS_SUCCESS Succeeded.
* @retval Other Failed.
*/
int32_t HITLS_CRYPT_CalcSM2SharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_Sm2GenShareKeyParameters *sm2Params, uint8_t *sharedSecret, uint32_t *sharedSecretLen);
/**
* @brief Generate a DH key pair based on the security level.
*
* This function generates a DH key pair using the given library context, attribute name, configuration, and named group ID.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param tlsConfig [IN] TLS configuration.
* @param secBits [IN] Security level.
*
* @return Key handle
* Returns a pointer to the generated DH key pair handle.
* Returns NULL if the key generation fails.
*/
HITLS_CRYPT_Key *HITLS_CRYPT_GenerateDhKeyBySecbits(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_Config *tlsConfig, int32_t secBits);
/**
* @brief Generate a DH key pair based on parameters.
*
* This function generates a DH key pair using the given library context, attribute name, p parameter, and g parameter.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param p [IN] p parameter.
* @param pLen [IN] Length of the p parameter.
* @param g [IN] g parameter.
* @param gLen [IN] Length of the g parameter.
*
* @return Key handle
* Returns a pointer to the generated DH key pair handle.
* Returns NULL if the key generation fails.
*/
HITLS_CRYPT_Key *HITLS_CRYPT_GenerateDhKeyByParameters(HITLS_Lib_Ctx *libCtx,
const char *attrName, uint8_t *p, uint16_t pLen, uint8_t *g, uint16_t gLen);
/**
* @brief HKDF expand function.
*
* This function performs the HKDF expand operation using the given library context, attribute name, and HKDF expand input.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param input [IN] HKDF expand input.
* @param okm [OUT] Buffer to store the output key.
* @param okmLen [IN] Length of the output key.
*
* @retval HITLS_SUCCESS Succeeded.
* @retval Other Failed.
*/
int32_t HITLS_CRYPT_HkdfExpand(HITLS_Lib_Ctx *libCtx, const char *attrName, const HITLS_CRYPT_HkdfExpandInput *input,
uint8_t *okm, uint32_t okmLen);
/**
* @brief HKDF extract function.
*
* This function performs the HKDF extract operation using the given library context, attribute name, and HKDF extract input.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param input [IN] HKDF extract input.
* @param prk [OUT] Buffer to store the output key.
* @param prkLen [IN/OUT] IN: Maximum length of the buffer. OUT: Actual length of the output key.
*
* @retval HITLS_SUCCESS Succeeded.
* @retval Other Failed.
*/
int32_t HITLS_CRYPT_HkdfExtract(HITLS_Lib_Ctx *libCtx, const char *attrName, const HITLS_CRYPT_HkdfExtractInput *input,
uint8_t *prk, uint32_t *prkLen);
/**
* @brief Generate a sequence of random bytes of the specified length.
*
* This function is used to generate a sequence of random bytes of the specified length
* and store it in the provided buffer. It uses the passed library context for random number generation.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param bytes [OUT] Buffer used to store the generated random byte sequence.
* @param bytesLen [IN] Length (in bytes) of the random byte sequence to be generated.
*
* @retval Returns HITLS_SUCCESS on success, and other error codes on failure.
*/
int32_t HITLS_CRYPT_RandbytesEx(HITLS_Lib_Ctx *libCtx, uint8_t *bytes, uint32_t bytesLen);
/**
* @brief Initialize the hash context.
*
* This function initializes the hash context with the given library context, attribute name, and hash algorithm.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, which may be used for specific configuration.
* @param hashAlgo [IN] Hash algorithm to be used in the hash operation, e.g., HITLS_SHA256.
*/
HITLS_HASH_Ctx *HITLS_CRYPT_DigestInit(HITLS_Lib_Ctx *libCtx, const char *attrName, HITLS_HashAlgo hashAlgo);
/**
* @brief Free DH key structure.
*
* @param key [IN] Pointer to DH key structure to be freed.
*/
void HITLS_CRYPT_FreeKey(HITLS_CRYPT_Key *key);
/**
* @brief Get DH parameters from key.
*
* @param key [IN] DH key structure.
* @param p [OUT] Prime modulus parameter.
* @param pLen [IN/OUT] IN: Buffer length, OUT: Actual length of prime modulus.
* @param g [OUT] Generator parameter.
* @param gLen [IN/OUT] IN: Buffer length, OUT: Actual length of generator.
*
* @retval HITLS_SUCCESS Succeeded.
* @retval Other Failed.
*/
int32_t HITLS_CRYPT_GetDhParameters(HITLS_CRYPT_Key *key, uint8_t *p, uint16_t *pLen, uint8_t *g, uint16_t *gLen);
/**
* @brief Reinitialize an HMAC context for reuse.
*
* @param ctx [IN] HMAC context to reinitialize.
* @retval HITLS_SUCCESS Reinitialization succeeded.
* @retval Other Failed to reinitialize context.
*/
int32_t HITLS_CRYPT_HMAC_ReInit(HITLS_HMAC_Ctx *ctx);
/**
* @brief Free an HMAC context.
*
* @param ctx [IN] HMAC context to free.
*/
void HITLS_CRYPT_HMAC_Free(HITLS_HMAC_Ctx *ctx);
/**
* @brief Update HMAC computation with input data.
*
* @param ctx [IN] HMAC context.
* @param data [IN] Input data to process.
* @param len [IN] Length of input data in bytes.
* @retval HITLS_SUCCESS Update succeeded.
* @retval Other Failed to update HMAC.
*/
int32_t HITLS_CRYPT_HMAC_Update(HITLS_HMAC_Ctx *ctx, const uint8_t *data, uint32_t len);
/**
* @brief Finalize HMAC computation and get the MAC value.
*
* @param ctx [IN] HMAC context.
* @param out [OUT] Buffer to store the MAC value.
* @param len [IN/OUT] IN: Buffer size, OUT: Actual MAC length.
* @retval HITLS_SUCCESS Finalization succeeded.
* @retval Other Failed to finalize HMAC.
*/
int32_t HITLS_CRYPT_HMAC_Final(HITLS_HMAC_Ctx *ctx, uint8_t *out, uint32_t *len);
/**
* @brief Get the output size of a hash algorithm.
*
* @param hashAlgo [IN] Hash algorithm identifier.
* @return Digest size in bytes. Returns 0 for unsupported algorithms.
*/
uint32_t HITLS_CRYPT_DigestSize(HITLS_HashAlgo hashAlgo);
/**
* @brief Create a copy of a hash context.
*
* @param ctx [IN] Original hash context to copy.
* @return New hash context copy. Returns NULL on failure.
*/
HITLS_HASH_Ctx *HITLS_CRYPT_DigestCopy(HITLS_HASH_Ctx *ctx);
/**
* @brief Free a hash context.
*
* @param ctx [IN] Hash context to free.
*/
void HITLS_CRYPT_DigestFree(HITLS_HASH_Ctx *ctx);
/**
* @brief Update hash computation with input data.
*
* @param ctx [IN] Hash context.
* @param data [IN] Input data to process.
* @param len [IN] Length of input data in bytes.
* @retval HITLS_SUCCESS Update succeeded.
* @retval Other Failed to update hash.
*/
int32_t HITLS_CRYPT_DigestUpdate(HITLS_HASH_Ctx *ctx, const uint8_t *data, uint32_t len);
/**
* @brief Finalize hash computation and get the digest.
*
* @param ctx [IN] Hash context.
* @param out [OUT] Buffer to store the digest.
* @param len [IN/OUT] IN: Buffer size, OUT: Actual digest length.
* @retval HITLS_SUCCESS Finalization succeeded.
* @retval Other Failed to finalize hash.
*/
int32_t HITLS_CRYPT_DigestFinal(HITLS_HASH_Ctx *ctx, uint8_t *out, uint32_t *len);
/**
* @brief Free a cipher context.
*
* @param ctx [IN] Cipher context to free.
*/
void HITLS_CRYPT_CipherFree(HITLS_Cipher_Ctx *ctx);
/**
* @brief Create a copy of a cryptographic key.
*
* @param key [IN] Original key to duplicate.
* @return New key handle copy. Returns NULL on failure.
*/
HITLS_CRYPT_Key *HITLS_CRYPT_DupKey(HITLS_CRYPT_Key *key);
/**
* @brief Get the public key of a cryptographic key.
*
* @param key [IN] Key to get public key from.
* @param pubKeyBuf [OUT] Buffer to store the public key.
* @param bufLen [IN] Buffer length.
* @param pubKeyLen [IN/OUT] IN: Buffer length, OUT: Actual public key length.
* @retval HITLS_SUCCESS Succeeded.
* @retval Other Failed.
*/
int32_t HITLS_CRYPT_GetPubKey(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen, uint32_t *pubKeyLen);
/**
* @brief KEM-Encapsulate
*
* @param libCtx [IN] Library context, used to manage cryptographic operations
* @param attrName [IN] Attribute name, used to configure the cryptographic algorithm
* @param config [IN] TLS configuration
* @param params [IN] KEM encapsulation parameters
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t HITLS_CRYPT_KemEncapsulate(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_Config *config, HITLS_KemEncapsulateParams *params);
/**
* @brief KEM-Decapsulate
*
* @param key [IN] Key handle
* @param ciphertext [IN] Ciphertext data
* @param ciphertextLen [IN] Ciphertext data length
* @param sharedSecret [OUT] Shared key
* @param sharedSecretLen [IN/OUT] IN: Maximum length of data padding OUT: length of the shared key
*
* @retval HITLS_SUCCESS succeeded.
* @retval Other failure
*/
int32_t HITLS_CRYPT_KemDecapsulate(HITLS_CRYPT_Key *key, const uint8_t *ciphertext, uint32_t ciphertextLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen);
/**
* @brief PRF function
*
* @param input [IN] Key derivation parameter
* @param out [OUT] Output key
* @param outLen [IN] Output key length
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t HITLS_CRYPT_PRF(CRYPT_KeyDeriveParameters *input, uint8_t *out, uint32_t outLen);
#ifdef __cplusplus
}
#endif
#endif /* HITLS_CRYPT_H */
| 2302_82127028/openHiTLS-examples_1508 | tls/crypt/crypt_self/hitls_crypt.h | C | unknown | 19,736 |
/*
* 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 CRYPT_H
#define CRYPT_H
#include <stdint.h>
#include "hitls_crypt_type.h"
#include "tls.h"
#include "hitls_crypt_reg.h"
#ifdef __cplusplus
extern "C" {
#endif
/* The maximum length of the RSA signature is 512. The maximum length of the ECC signature does not reach 1024. */
#define MAX_SIGN_SIZE 1024
/* Used to transfer key derivation parameters. */
typedef struct {
HITLS_HashAlgo hashAlgo; /* Hash algorithm */
const uint8_t *secret; /* Initialization key */
uint32_t secretLen; /* Key length */
const uint8_t *label; /* Label */
uint32_t labelLen; /* Label length */
const uint8_t *seed; /* Seed */
uint32_t seedLen; /* Seed length */
HITLS_Lib_Ctx *libCtx;
const char *attrName;
} CRYPT_KeyDeriveParameters;
enum HITLS_CryptInfoCmd {
HITLS_CRYPT_INFO_CMD_GET_PUBLIC_KEY_LEN = 0, /* Get the length of the public key, param is HITLS_NamedGroup */
HITLS_CRYPT_INFO_CMD_GET_SHARED_KEY_LEN, /* Get the length of the shared key, param is HITLS_NamedGroup */
HITLS_CRYPT_INFO_CMD_GET_CIPHERTEXT_LEN, /* Get the length of the ciphertext, param is HITLS_NamedGroup */
HITLS_CRYPT_INFO_CMD_GET_HASH_LEN, /* Get the length of the hash, param is HITLS_HashAlgo */
};
enum HITLS_CryptoCallBack {
HITLS_CRYPT_CALLBACK_RAND_BYTES = 0,
HITLS_CRYPT_CALLBACK_HMAC_SIZE,
HITLS_CRYPT_CALLBACK_HMAC_INIT,
HITLS_CRYPT_CALLBACK_HMAC_FREE,
HITLS_CRYPT_CALLBACK_HMAC_UPDATE,
HITLS_CRYPT_CALLBACK_HMAC_FINAL,
HITLS_CRYPT_CALLBACK_HMAC,
HITLS_CRYPT_CALLBACK_DIGEST_SIZE,
HITLS_CRYPT_CALLBACK_DIGEST_INIT,
HITLS_CRYPT_CALLBACK_DIGEST_COPY,
HITLS_CRYPT_CALLBACK_DIGEST_FREE,
HITLS_CRYPT_CALLBACK_DIGEST_UPDATE,
HITLS_CRYPT_CALLBACK_DIGEST_FINAL,
HITLS_CRYPT_CALLBACK_DIGEST,
HITLS_CRYPT_CALLBACK_ENCRYPT,
HITLS_CRYPT_CALLBACK_DECRYPT,
HITLS_CRYPT_CALLBACK_GENERATE_ECDH_KEY_PAIR,
HITLS_CRYPT_CALLBACK_FREE_ECDH_KEY,
HITLS_CRYPT_CALLBACK_GET_ECDH_ENCODED_PUBKEY,
HITLS_CRYPT_CALLBACK_CALC_ECDH_SHARED_SECRET,
HITLS_CRYPT_CALLBACK_SM2_CALC_ECDH_SHARED_SECRET,
HITLS_CRYPT_CALLBACK_GENERATE_DH_KEY_BY_SECBITS,
HITLS_CRYPT_CALLBACK_GENERATE_DH_KEY_BY_PARAMS,
HITLS_CRYPT_CALLBACK_DUP_DH_KEY,
HITLS_CRYPT_CALLBACK_FREE_DH_KEY,
HITLS_CRYPT_CALLBACK_DH_GET_PARAMETERS,
HITLS_CRYPT_CALLBACK_GET_DH_ENCODED_PUBKEY,
HITLS_CRYPT_CALLBACK_CALC_DH_SHARED_SECRET,
HITLS_CRYPT_CALLBACK_HKDF_EXTRACT,
HITLS_CRYPT_CALLBACK_HKDF_EXPAND,
HITLS_CRYPT_CALLBACK_KEM_ENCAPSULATE,
HITLS_CRYPT_CALLBACK_KEM_DECAPSULATE,
};
/**
* @brief Generate a random number.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param buf [OUT] Random number
* @param len [IN] Random number length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_GENRATE_RANDOM Failed to generate a random number.
*/
int32_t SAL_CRYPT_Rand(HITLS_Lib_Ctx *libCtx, uint8_t *buf, uint32_t len);
/**
* @brief Obtain the HMAC length.
*
* @param hashAlgo [IN] hash algorithm
*
* @return HMAC length
*/
uint32_t SAL_CRYPT_HmacSize(HITLS_HashAlgo hashAlgo);
/**
* @brief Initialize the HMAC context.
*
* This function initializes the HMAC (Hash-based Message Authentication Code) context
* using the specified hash algorithm and key. It prepares the necessary state for
* subsequent HMAC operations.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, used to configure the cryptographic
* algorithm provided by the algorithm provider
* @param hashAlgo [IN] Hash algorithm to be used in the HMAC operation, e.g., HITLS_SHA256.
* @param key [IN] Secret key used for HMAC calculation.
* @param len [IN] Length of the secret key in bytes.
*
* @return HMAC context
* Returns a pointer to the initialized HMAC context.
* Returns NULL if the initialization fails.
*/
HITLS_HMAC_Ctx *SAL_CRYPT_HmacInit(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t len);
/**
* @brief ReInitialize the HMAC context.
*
* @param ctx [IN] HMAC context
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CRYPT_HmacReInit(HITLS_HMAC_Ctx *ctx);
/**
* @brief Release the HMAC context.
*
* @param hmac [IN] HMAC context
*/
void SAL_CRYPT_HmacFree(HITLS_HMAC_Ctx *hmac);
/**
* @brief Add the HMAC input data.
*
* @param hmac [IN] HMAC context
* @param data [IN] Input data
* @param len [IN] Input data length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_HMAC The HMAC operation fails.
*/
int32_t SAL_CRYPT_HmacUpdate(HITLS_HMAC_Ctx *hmac, const uint8_t *data, uint32_t len);
/**
* @brief Calculate the HMAC result.
*
* @param hmac [IN] HMAC context
* @param out [OUT] Output data
* @param len [IN/OUT] IN: Maximum length of data padding OUT: Output data length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_HMAC The HMAC operation fails.
*/
int32_t SAL_CRYPT_HmacFinal(HITLS_HMAC_Ctx *hmac, uint8_t *out, uint32_t *len);
/**
* @brief HMAC function
*
* This function calculates the HMAC (Hash-based Message Authentication Code) using the specified hash algorithm and key.
* It takes input data and produces an output HMAC value.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, used to configure the cryptographic
* algorithm provided by the algorithm provider
* @param hashAlgo [IN] Hash algorithm to be used in the HMAC operation, e.g., HITLS_SHA256.
* @param key [IN] Secret key used for HMAC calculation.
* @param keyLen [IN] Length of the secret key in bytes.
* @param in [IN] Input data to be processed for HMAC calculation.
* @param inLen [IN] Length of the input data in bytes.
* @param out [OUT] Buffer to store the calculated HMAC output.
* @param outLen [IN/OUT] IN: Maximum length of the output buffer. OUT: Actual length of the calculated HMAC output.
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_HMAC The HMAC operation fails.
*/
int32_t SAL_CRYPT_Hmac(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *key, uint32_t keyLen,
const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);
/**
* @brief PRF function
*
* @param input [IN] Key derivation parameter
* @param md [OUT] Output key
* @param outLen [OUT] Output key length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_HMAC The HMAC operation fails.
* @retval HITLS_MEMALLOC_FAIL Memory application failed.
*/
int32_t SAL_CRYPT_PRF(CRYPT_KeyDeriveParameters *input, uint8_t *out, uint32_t outLen);
/**
* @brief Obtain the hash length.
*
* @param hashAlgo [IN] Hash algorithm
*
* @return Hash length
*/
uint32_t SAL_CRYPT_DigestSize(HITLS_HashAlgo hashAlgo);
/**
* @brief Initialize the hash context.
*
* This function initializes a new hash context using the specified hash algorithm.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, used to configure the cryptographic
* algorithm provided by the algorithm provider
* @param hashAlgo [IN] hash algorithm
* The hash algorithm to be used for the calculation. This can be
* one of the predefined hash algorithms, such as HITLS_SHA256.
*
* @return hash context
* Returns a pointer to the initialized hash context.
* Returns NULL if the initialization fails, for example, if there is not
* enough memory available or if the specified hash algorithm is not supported.
*/
HITLS_HASH_Ctx *SAL_CRYPT_DigestInit(HITLS_Lib_Ctx *libCtx, const char *attrName, HITLS_HashAlgo hashAlgo);
/**
* @brief Copy the hash context.
*
* @param ctx [IN] hash Context
*
* @return hash context
*/
HITLS_HASH_Ctx *SAL_CRYPT_DigestCopy(HITLS_HASH_Ctx *ctx);
/**
* @brief Release the hash context.
*
* @param ctx [IN] hash Context
*/
void SAL_CRYPT_DigestFree(HITLS_HASH_Ctx *ctx);
/**
* @brief Add the hash input data.
*
* @param ctx [IN] hash Context
* @param data [IN] Input data
* @param len [IN] Length of the input data
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_DIGEST hash operation failed.
*/
int32_t SAL_CRYPT_DigestUpdate(HITLS_HASH_Ctx *ctx, const uint8_t *data, uint32_t len);
/**
* @brief Calculate the hash result.
*
* @param ctx [IN] hash context
* @param out [OUT] Output data
* @param len [IN/OUT] IN: Maximum length of data padding OUT: Length of output data
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_DIGEST hash operation failed.
*/
int32_t SAL_CRYPT_DigestFinal(HITLS_HASH_Ctx *ctx, uint8_t *out, uint32_t *len);
/**
* @brief Calculate the hash.
*
* This function calculates the hash of the input data using the specified hash algorithm.
* It takes input data and produces an output hash value.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, used to configure the cryptographic
* algorithm provided by the algorithm provider
* @param hashAlgo [IN] hash algorithm
* The hash algorithm to be used for the calculation. This can be
* one of the predefined hash algorithms, such as HITLS_SHA256.
* @param in [IN] Input data
* The data to be hashed. This can be any sequence of bytes.
* @param inLen [IN] Length of the input data
* The length of the input data in bytes.
* @param out [OUT] Output data
* The buffer where the calculated hash value will be stored.
* The buffer must be large enough to hold the entire hash value.
* @param outLen [IN/OUT] IN: Maximum length of data padding OUT: Length of output data
* On input, this parameter specifies the maximum length of the output buffer.
* On output, it contains the actual length of the calculated hash value.
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_DIGEST hash operation failed.
*/
int32_t SAL_CRYPT_Digest(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, const uint8_t *in, uint32_t inLen, uint8_t *out, uint32_t *outLen);
/**
* @brief Encryption
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, used to configure the cryptographic
* algorithm provided by the algorithm provider
* @param cipher [IN] Key parameters
* @param in [IN] Plaintext data
* @param inLen [IN] Length of the plaintext data
* @param out [OUT] Ciphertext data
* @param outLen [IN/OUT] IN: Maximum length of data padding OUT: Length of ciphertext data
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_ENCRYPT Encryption failed.
*/
int32_t SAL_CRYPT_Encrypt(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
/**
* @brief Decrypt
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, used to configure the cryptographic
* algorithm provided by the algorithm provider
* @param cipher [IN] Key parameters
* @param in [IN] Ciphertext data
* @param inLen [IN] Length of the ciphertext data
* @param out [OUT] Plaintext data
* @param outLen [IN/OUT] IN: Maximum length of data padding OUT: Length of plaintext data
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_DECRYPT decryption failure
*/
int32_t SAL_CRYPT_Decrypt(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_CipherParameters *cipher, const uint8_t *in, uint32_t inLen,
uint8_t *out, uint32_t *outLen);
/**
* @brief Release the cipher ctx.
*
* @param ctx [IN] cipher ctx handle
*/
void SAL_CRYPT_CipherFree(HITLS_Cipher_Ctx *ctx);
/**
* @brief Generate the ECDH key pair.
*
* @param curveParams [IN] Elliptic curve parameter
*
* @return Key handle
*/
HITLS_CRYPT_Key *SAL_CRYPT_GenEcdhKeyPair(TLS_Ctx *ctx, const HITLS_ECParameters *curveParams);
/**
* @brief Release the ECDH key.
*
* @param key [IN] Key handle
*/
void SAL_CRYPT_FreeEcdhKey(HITLS_CRYPT_Key *key);
/**
* @brief Obtain the ECDH public key data.
*
* @param key [IN] Key handle
* @param pubKeyBuf [OUT] Public key data
* @param bufLen [IN] Maximum length of data padding.
* @param usedLen [OUT] Public key data length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_ENCODE_ECDH_KEY Failed to obtain the public key data.
*/
int32_t SAL_CRYPT_EncodeEcdhPubKey(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen, uint32_t *usedLen);
/**
* @brief Calculate the ECDH shared key.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, used to configure the cryptographic
* algorithm provided by the algorithm provider
* @param key [IN] Local key handle
* @param peerPubkey [IN] Peer public key data
* @param pubKeyLen [IN] Public key data length
* @param sharedSecret [OUT] Shared key
* @param sharedSecretLen [IN/OUT] IN: Maximum length of data padding OUT: length of the shared key
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_CALC_SHARED_KEY Failed to calculate the shared key.
*/
int32_t SAL_CRYPT_CalcEcdhSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen);
/**
* @brief SM2 calculates the ECDH shared key.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, used to configure the cryptographic
* algorithm provided by the algorithm provider
* @param sm2ShareKeyParam [IN] Parameters required for calculating the shared key
* @param sharedSecret [OUT] Shared key
* @param sharedSecretLen [IN/OUT] IN: Maximum length of data padding OUT: length of the shared key
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_CALC_SHARED_KEY Failed to calculate the shared key.
*/
int32_t SAL_CRYPT_CalcSm2dhSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_Sm2GenShareKeyParameters *sm2ShareKeyParam, uint8_t *sharedSecret,
uint32_t *sharedSecretLen);
/**
* @brief Generate a DH key pair.
*
* @param ctx [IN] TLS context
* @param secbits [IN] Key security level
*
* @return Key handle
*/
HITLS_CRYPT_Key *SAL_CRYPT_GenerateDhKeyBySecbits(TLS_Ctx *ctx,
int32_t secBits);
/**
* @brief Generate a DH key pair.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, used to configure the cryptographic
* algorithm provided by the algorithm provider
* @param p [IN] p Parameter
* @param plen [IN] p Parameter length
* @param g [IN] g Parameter
* @param glen [IN] g Parameter length
*
* @return Key handle
*/
HITLS_CRYPT_Key *SAL_CRYPT_GenerateDhKeyByParams(HITLS_Lib_Ctx *libCtx,
const char *attrName, uint8_t *p, uint16_t plen, uint8_t *g, uint16_t glen);
/**
* @brief Deep Copy DH Key Pair
*
* @param key [IN] Key handle
*
* @return Key handle
*/
HITLS_CRYPT_Key *SAL_CRYPT_DupDhKey(HITLS_CRYPT_Key *key);
/**
* @brief Release the DH key.
*
* @param key [IN] Key handle
*/
void SAL_CRYPT_FreeDhKey(HITLS_CRYPT_Key *key);
/**
* @brief Obtain the DH parameter.
*
* @param key [IN] Key handle
* @param p [OUT] p Parameter
* @param plen [IN/OUT] IN: Maximum length of data padding OUT: p Parameter length
* @param g [OUT] g Parameter
* @param glen [IN/OUT] IN: Maximum length of data padding OUT: g Parameter length
*
* @return HITLS_SUCCESS succeeded.
*/
int32_t SAL_CRYPT_GetDhParameters(HITLS_CRYPT_Key *key, uint8_t *p, uint16_t *plen,
uint8_t *g, uint16_t *glen);
/**
* @brief Obtain the DH public key data.
*
* @param key [IN] Key handle
* @param pubKeyBuf [OUT] Public key data
* @param bufLen [IN] Maximum length of data padding.
* @param usedLen [OUT] Public key data length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_ENCODE_DH_KEY Failed to obtain the public key data.
*/
int32_t SAL_CRYPT_EncodeDhPubKey(HITLS_CRYPT_Key *key, uint8_t *pubKeyBuf, uint32_t bufLen, uint32_t *usedLen);
/**
* @brief Calculate the DH shared key.
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, used to configure the cryptographic
* algorithm provided by the algorithm provider
* @param key [IN] Local key handle
* @param peerPubkey [IN] Peer public key data
* @param pubKeyLen [IN] Public key data length
* @param sharedSecret [OUT] Shared key
* @param sharedSecretLen [IN/OUT] IN: Maximum length of data padding OUT: length of the shared key
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_CALC_SHARED_KEY Failed to calculate the shared key.
*/
int32_t SAL_CRYPT_CalcDhSharedSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_CRYPT_Key *key, uint8_t *peerPubkey, uint32_t pubKeyLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen);
/**
* @brief HKDF-Extract
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, used to configure the cryptographic
* algorithm provided by the algorithm provider
* @param input [IN] Input key material
* @param prk [OUT] Output key
* @param prkLen [IN/OUT] IN: Maximum buffer length OUT: Output key length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_HKDF_EXTRACT calculation fails.
*/
int32_t SAL_CRYPT_HkdfExtract(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_CRYPT_HkdfExtractInput *input, uint8_t *prk, uint32_t *prkLen);
/**
* @brief HKDF-Expand
*
* @param libCtx [IN] Library context, used to manage cryptographic operations.
* @param attrName [IN] Attribute name, used to configure the cryptographic
* algorithm provided by the algorithm provider
* @param input [IN] Input key material
* @param okm [OUT] Output key
* @param okmLen [IN] Output key length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_HKDF_EXPAND calculation fails.
*/
int32_t SAL_CRYPT_HkdfExpand(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_CRYPT_HkdfExpandInput *input, uint8_t *okm, uint32_t okmLen);
/**
* @brief HKDF-ExpandLabel
*
* @param deriveInfo [IN] Key derivation parameters, including hash algorithm, secret, label, seed, etc.
* @param outSecret [OUT] Output key buffer
* @param outLen [IN] Output key length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_HKDF_EXTRACT calculation fails.
* @retval HITLS_MEMCPY_FAIL Memory copy failure
*/
int32_t SAL_CRYPT_HkdfExpandLabel(CRYPT_KeyDeriveParameters *deriveInfo,
uint8_t *outSecret, uint32_t outLen);
/**
* @brief Get cryptographic information about length
*
* @param ctx [IN] TLS context
* @param cmd [IN] Command type, see enum HITLS_CryptInfoCmd
* @param param [IN] Input parameter
*
* @return Returns key length and other info, returns 0 on failure
*/
uint32_t SAL_CRYPT_GetCryptLength(const TLS_Ctx *ctx, int32_t cmd, int32_t param);
/**
* @brief Encapsulate a shared secret using KEM
*
* @param ctx [IN] TLS context
* @param params [IN/OUT] KEM encapsulation parameters
*
* @retval HITLS_SUCCESS succeeded.
*/
int32_t SAL_CRYPT_KemEncapsulate(TLS_Ctx *ctx, HITLS_KemEncapsulateParams *params);
/**
* @brief KEM: Decapsulate the ciphertext to recover shared secret
*
* @param key [IN] Key handle
* @param ciphertext [IN] Ciphertext buffer
* @param ciphertextLen [IN] Ciphertext length
* @param sharedSecret [OUT] Shared secret buffer
* @param sharedSecretLen [IN/OUT] IN: Maximum shared secret buffer length OUT: Actual shared secret length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_KEM_DECAP Failed to decapsulate ciphertext
*/
int32_t SAL_CRYPT_KemDecapsulate(HITLS_CRYPT_Key *key, const uint8_t *ciphertext, uint32_t ciphertextLen,
uint8_t *sharedSecret, uint32_t *sharedSecretLen);
#ifdef __cplusplus
}
#endif
#endif
| 2302_82127028/openHiTLS-examples_1508 | tls/crypt/include/crypt.h | C | unknown | 23,209 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_ALPN
#include <stdint.h>
#include "securec.h"
#include "hitls_error.h"
#include "bsl_err_internal.h"
#include "bsl_sal.h"
#include "tls_binlog_id.h"
#include "hs_ctx.h"
#include "tls.h"
#include "alpn.h"
#define MAX_PROTOCOL_LEN 65536
int32_t ALPN_SelectProtocol(uint8_t **out, uint32_t *outLen, uint8_t *clientAlpnList, uint32_t clientAlpnListLen,
uint8_t *servAlpnList, uint32_t servAlpnListLen)
{
if (out == NULL || outLen == NULL || clientAlpnList == NULL || servAlpnList == NULL ||
servAlpnListLen == 0 || clientAlpnListLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16690, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "intput null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
uint32_t i, j;
for (i = 0; i < servAlpnListLen;) {
for (j = 0; j < clientAlpnListLen;) {
if (servAlpnList[i] == clientAlpnList[j] &&
(memcmp(&servAlpnList[i + 1], &clientAlpnList[j + 1], servAlpnList[i]) == 0)) {
*out = &servAlpnList[i + 1];
*outLen = servAlpnList[i];
return HITLS_SUCCESS;
}
j = j + clientAlpnList[j];
++j;
}
i = i + servAlpnList[i];
++i;
}
return HITLS_SUCCESS;
}
static int32_t SelectProtocol(TLS_Ctx *ctx, uint8_t *alpnSelected, uint16_t alpnSelectedSize)
{
uint8_t *protoMatch = NULL;
uint32_t protoMatchLen = 0;
int32_t ret = ALPN_SelectProtocol(&protoMatch, &protoMatchLen, alpnSelected,
alpnSelectedSize, ctx->config.tlsConfig.alpnList, ctx->config.tlsConfig.alpnListSize);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15258, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"client check proposed protocol fail due to invalid params.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return ret;
} else if (protoMatch == NULL) {
/* The RFC 7301 does not specify the behavior when the client selectedProto does not match the local
* configuration list. */
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_ALPN_PROTOCOL_NO_MATCH);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15259, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"server proposed protocol is not supported by client", 0, 0, 0, 0);
return HITLS_SUCCESS;
}
uint8_t *alpnSelectedTmp = (uint8_t *)BSL_SAL_Calloc(1u, (protoMatchLen + 1));
if (alpnSelectedTmp == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15260, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"client malloc selected alpn mem failed.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
if (memcpy_s(alpnSelectedTmp, protoMatchLen + 1, protoMatch,
protoMatchLen) != EOK) {
BSL_SAL_FREE(alpnSelectedTmp);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15261, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"client copy selected alpn failed.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
BSL_SAL_FREE(ctx->negotiatedInfo.alpnSelected);
ctx->negotiatedInfo.alpnSelected = alpnSelectedTmp;
ctx->negotiatedInfo.alpnSelectedSize = protoMatchLen;
return HITLS_SUCCESS;
}
int32_t ClientCheckNegotiatedAlpn(
TLS_Ctx *ctx, bool haveSelectedAlpn, uint8_t *alpnSelected, uint16_t alpnSelectedSize)
{
if ((!ctx->hsCtx->extFlag.haveAlpn) && haveSelectedAlpn) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15257, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"client did not send but get selected alpn protocol.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNSUPPORTED_EXTENSION);
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_EXTENSION_TYPE);
return HITLS_MSG_HANDLE_UNSUPPORT_EXTENSION_TYPE;
}
if (alpnSelectedSize == 0) {
return HITLS_SUCCESS;
}
int32_t ret = SelectProtocol(ctx, alpnSelected, alpnSelectedSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15262, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"ALPN protocol: %s.", ctx->negotiatedInfo.alpnSelected, 0, 0, 0);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_ALPN */ | 2302_82127028/openHiTLS-examples_1508 | tls/feature/alpn/src/alpn.c | C | unknown | 5,096 |
/*
* 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.
*/
#include <stdlib.h>
#include <stdint.h>
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "hitls_config.h"
#include "tls.h"
#include "hs_msg.h"
#include "hs_ctx.h"
#include "hs.h"
#include "securec.h"
#include "bsl_sal.h"
#include "custom_extensions.h"
#include "alert.h"
#include "pack.h"
bool IsPackNeedCustomExtensions(CustomExtMethods *exts, uint32_t context)
{
uint32_t i = 0;
if (exts == NULL) {
return false;
}
CustomExtMethod *meth = exts->meths;
if (meth == NULL) {
return false;
}
for (i = 0; i < exts->methsCount; i++, meth++) {
if ((context & meth->context) != 0) {
return true;
}
}
return false;
}
bool IsParseNeedCustomExtensions(CustomExtMethods *exts, uint16_t extType, uint32_t context)
{
uint32_t i = 0;
if (exts == NULL) {
return false;
}
CustomExtMethod *meth = exts->meths;
if (meth == NULL) {
return false;
}
for (i = 0; i < exts->methsCount; i++, meth++) {
if (extType == meth->extType && (context & meth->context) != 0) {
return true;
}
}
return false;
}
bool IsCustomExtensionTypeAdded(CustomExtMethods *exts, uint16_t extType)
{
uint32_t i = 0;
if (exts == NULL) {
return false;
}
CustomExtMethod *meth = exts->meths;
if (meth == NULL) {
return false;
}
for (i = 0; i < exts->methsCount; i++, meth++) {
if (extType == meth->extType) {
return true;
}
}
return false;
}
CustomExtMethod *FindCustomExtensions(CustomExtMethods *exts, uint16_t extType, uint32_t context)
{
uint32_t i = 0;
if (exts == NULL) {
return NULL;
}
CustomExtMethod *meth = exts->meths;
if (meth == NULL) {
return NULL;
}
for (i = 0; i < exts->methsCount; i++, meth++) {
if (extType == meth->extType && (context & meth->context) != 0) {
return meth;
}
}
return NULL;
}
uint32_t HITLS_CFG_AddCustomExtension(HITLS_Config *config, const HITLS_CustomExtParams *params)
{
CustomExtMethod *meth = NULL;
CustomExtMethod *tmp = NULL;
if (config == NULL || params == NULL) {
return HITLS_NULL_INPUT;
}
if (params->addCb == NULL && params->freeCb != NULL) {
return HITLS_INVALID_INPUT;
}
CustomExtMethods *exts = config->customExts;
if (IsCustomExtensionTypeAdded(exts, params->extType) ||
FindCustomExtensions(exts, params->extType, params->context) != NULL) {
return HITLS_CONFIG_DUP_CUSTOM_EXT;
}
if (exts == NULL) {
exts = (CustomExtMethods *)BSL_SAL_Malloc(sizeof(CustomExtMethods));
if (exts == NULL) {
return HITLS_MEMALLOC_FAIL;
}
exts->meths = NULL;
exts->methsCount = 0;
config->customExts = exts;
}
if (exts->methsCount >= MAX_LIMIT_CUSTOM_EXT) {
return HITLS_CONFIG_ERR_MAX_LIMIT_CUSTOM_EXT;
}
tmp = BSL_SAL_Realloc(exts->meths, (exts->methsCount + 1) * sizeof(CustomExtMethod),
exts->methsCount * sizeof(CustomExtMethod));
if (tmp == NULL) {
return HITLS_MEMALLOC_FAIL;
}
exts->meths = tmp;
meth = exts->meths + exts->methsCount;
(void)memset_s(meth, sizeof(*meth), 0, sizeof(*meth));
meth->extType = params->extType;
meth->context = params->context;
meth->addCb = params->addCb;
meth->freeCb = params->freeCb;
meth->addArg = params->addArg;
meth->parseCb = params->parseCb;
meth->parseArg = params->parseArg;
exts->methsCount++;
return HITLS_SUCCESS;
}
uint32_t HITLS_AddCustomExtension(HITLS_Ctx *ctx, const HITLS_CustomExtParams *params)
{
if (ctx == NULL || params == NULL) {
return HITLS_NULL_INPUT;
}
return HITLS_CFG_AddCustomExtension(&(ctx->config.tlsConfig), params);
}
int32_t PackCustomExtensions(const struct TlsCtx *ctx, PackPacket *pkt, uint32_t context,
HITLS_CERT_X509 *cert, uint32_t certIndex)
{
uint32_t alert = 0u;
if (ctx == NULL) {
return HITLS_NULL_INPUT;
}
CustomExtMethods *exts = CUSTOM_EXT_FROM_CTX(ctx);
CustomExtMethod *meth = NULL;
if (exts == NULL) {
return HITLS_SUCCESS;
}
for (uint32_t i = 0; i < exts->methsCount; i++) {
uint8_t *out = NULL;
uint32_t outLen = 0;
int32_t ret = HITLS_ADD_CUSTOM_EXTENSION_RET_PASS;
meth = exts->meths + i;
if ((meth->context & context) == 0 || meth->addCb == NULL) {
continue;
}
ret = meth->addCb(ctx, meth->extType, context, &out, &outLen, cert, certIndex, &alert, meth->addArg);
if (ret != HITLS_ADD_CUSTOM_EXTENSION_RET_PACK && ret != HITLS_ADD_CUSTOM_EXTENSION_RET_PASS) {
ALERT_Send(ctx, ALERT_LEVEL_FATAL, alert);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17350, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack custom extension content fail.", 0, 0, 0, 0);
return ret;
}
if (ret == HITLS_ADD_CUSTOM_EXTENSION_RET_PASS) {
continue;
}
if (outLen >= UINT16_MAX) {
if (meth->freeCb != NULL) {
meth->freeCb(ctx, meth->extType, context, out, meth->addArg);
}
return HITLS_PACK_NOT_ENOUGH_BUF_LENGTH;
}
ret = PackReserveBytes(pkt, sizeof(uint16_t) + sizeof(uint16_t) + outLen, NULL);
if (ret != HITLS_SUCCESS) {
if (meth->freeCb != NULL) {
meth->freeCb(ctx, meth->extType, context, out, meth->addArg);
}
return ret;
}
(void)PackAppendUint16ToBuf(pkt, meth->extType);
(void)PackAppendUint16ToBuf(pkt, outLen);
(void)PackAppendDataToBuf(pkt, out, outLen);
if (meth->freeCb != NULL) {
meth->freeCb(ctx, meth->extType, context, out, meth->addArg);
}
}
return HITLS_SUCCESS;
}
int32_t ParseCustomExtensions(const struct TlsCtx *ctx, const uint8_t *buf, uint16_t extType, uint32_t extLen,
uint32_t context, HITLS_CERT_X509 *cert, uint32_t certIndex)
{
uint32_t alert = 0u;
CustomExtMethods *exts = CUSTOM_EXT_FROM_CTX(ctx);
CustomExtMethod *meth = FindCustomExtensions(exts, extType, context);
if (meth == NULL) {
return HITLS_SUCCESS;
}
// Create a local pointer starting from the position after the type byte
if (meth->parseCb != NULL) {
int32_t ret = meth->parseCb(ctx, meth->extType, context, &buf, &extLen, cert, certIndex, &alert,
meth->parseArg);
if (ret != HITLS_SUCCESS) {
ALERT_Send(ctx, ALERT_LEVEL_FATAL, alert);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17351, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"parse custom extension content fail.", 0, 0, 0, 0);
return ret;
}
}
return HITLS_SUCCESS;
}
void FreeCustomExtensions(CustomExtMethods *exts)
{
if (exts == NULL) {
return;
}
if (exts->meths == NULL) {
BSL_SAL_Free(exts);
return;
}
BSL_SAL_Free(exts->meths);
BSL_SAL_Free(exts);
}
CustomExtMethods *DupCustomExtensions(CustomExtMethods *exts)
{
if (exts == NULL) {
return NULL;
}
CustomExtMethods *newExts = (CustomExtMethods *)BSL_SAL_Malloc(sizeof(CustomExtMethods));
if (newExts == NULL) {
return NULL;
}
newExts->meths = (CustomExtMethod *)BSL_SAL_Dump(exts->meths, exts->methsCount * sizeof(CustomExtMethod));
if (newExts->meths == NULL) {
BSL_SAL_Free(newExts);
return NULL;
}
newExts->methsCount = exts->methsCount;
return newExts;
}
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
| 2302_82127028/openHiTLS-examples_1508 | tls/feature/custom_extensions/src/custom_extensions.c | C | unknown | 8,506 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_INDICATOR
#include "tls.h"
#include "indicator.h"
void INDICATOR_StatusIndicate(const HITLS_Ctx *ctx, int32_t eventType, int32_t value)
{
if (ctx == NULL || ctx->config.tlsConfig.infoCb == NULL) {
return;
}
ctx->config.tlsConfig.infoCb(ctx, eventType, value);
}
void INDICATOR_MessageIndicate(int32_t writePoint, uint32_t tlsVersion, int32_t contentType, const void *msg,
uint32_t msgLen, HITLS_Ctx *ctx, void *arg)
{
if (ctx == NULL || ctx->config.tlsConfig.msgCb == NULL) {
return;
}
ctx->config.tlsConfig.msgCb(writePoint, (int32_t)tlsVersion, contentType, msg, msgLen, ctx, arg);
}
#endif /* HITLS_TLS_FEATURE_INDICATOR */ | 2302_82127028/openHiTLS-examples_1508 | tls/feature/indicator/src/indicator.c | C | unknown | 1,267 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_SECURITY
#include <stdint.h>
#include "bsl_err_internal.h"
#include "hitls_error.h"
#include "hitls_security.h"
#include "tls.h"
int32_t HITLS_CFG_SetSecurityLevel(HITLS_Config *config, int32_t securityLevel)
{
if (config == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
config->securityLevel = securityLevel;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_GetSecurityLevel(const HITLS_Config *config, int32_t *securityLevel)
{
if (config == NULL || securityLevel == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
*securityLevel = config->securityLevel;
return HITLS_SUCCESS;
}
int32_t HITLS_CFG_SetSecurityCb(HITLS_Config *config, HITLS_SecurityCb securityCb)
{
if (config == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
config->securityCb = securityCb;
return HITLS_SUCCESS;
}
HITLS_SecurityCb HITLS_CFG_GetSecurityCb(const HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return config->securityCb;
}
int32_t HITLS_CFG_SetSecurityExData(HITLS_Config *config, void *securityExData)
{
if (config == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
config->securityExData = securityExData;
return HITLS_SUCCESS;
}
void *HITLS_CFG_GetSecurityExData(const HITLS_Config *config)
{
if (config == NULL) {
return NULL;
}
return config->securityExData;
}
int32_t HITLS_SetSecurityLevel(HITLS_Ctx *ctx, int32_t securityLevel)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetSecurityLevel(&(ctx->config.tlsConfig), securityLevel);
}
int32_t HITLS_GetSecurityLevel(const HITLS_Ctx *ctx, int32_t *securityLevel)
{
if (ctx == NULL || securityLevel == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
return HITLS_CFG_GetSecurityLevel(&(ctx->config.tlsConfig), securityLevel);
}
int32_t HITLS_SetSecurityCb(HITLS_Ctx *ctx, HITLS_SecurityCb securityCb)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetSecurityCb(&(ctx->config.tlsConfig), securityCb);
}
HITLS_SecurityCb HITLS_GetSecurityCb(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetSecurityCb(&(ctx->config.tlsConfig));
}
int32_t HITLS_SetSecurityExData(HITLS_Ctx *ctx, void *securityExData)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
return HITLS_CFG_SetSecurityExData(&(ctx->config.tlsConfig), securityExData);
}
void *HITLS_GetSecurityExData(const HITLS_Ctx *ctx)
{
if (ctx == NULL) {
return NULL;
}
return HITLS_CFG_GetSecurityExData(&(ctx->config.tlsConfig));
}
#endif /* HITLS_TLS_FEATURE_SECURITY */ | 2302_82127028/openHiTLS-examples_1508 | tls/feature/security/src/security.c | C | unknown | 3,610 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_SECURITY
#include <stdint.h>
#include "securec.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "hitls_error.h"
#include "hitls_security.h"
#include "tls.h"
#include "security.h"
#include "config_type.h"
/* Number of security bits corresponding to the security level */
static const int32_t g_minBits[] = {HITLS_SECURITY_LEVEL_ONE_SECBITS,
HITLS_SECURITY_LEVEL_TWO_SECBITS,
HITLS_SECURITY_LEVEL_THREE_SECBITS,
HITLS_SECURITY_LEVEL_FOUR_SECBITS,
HITLS_SECURITY_LEVEL_FIVE_SECBITS};
int32_t SECURITY_GetSecbits(int32_t level)
{
if (level <= HITLS_SECURITY_LEVEL_MIN) {
return 0;
} else {
level = (level > HITLS_SECURITY_LEVEL_MAX) ? HITLS_SECURITY_LEVEL_MAX : level;
}
return g_minBits[level - 1];
}
static int32_t CheckCipherSuite(void *other, int32_t level)
{
if (other == NULL) {
return SECURITY_ERR;
}
CipherSuiteInfo *info = (CipherSuiteInfo *)other;
int32_t minBits = SECURITY_GetSecbits(level);
if (info->strengthBits < minBits) {
return SECURITY_ERR;
}
/* The anonymous cipher suite is insecure. */
if (info->minVersion != HITLS_VERSION_TLS13 && info->authAlg == HITLS_AUTH_NULL) {
return SECURITY_ERR;
}
/* The level is greater than or equal to 1, and the export cipher suite and the MD5 algorithm for calculating MAC
* addresses are prohibited. Currently, the export cipher suite and the MD5 algorithm for calculating MAC addresses
* are not supported. Therefore, the check is not required. */
/* The RC4 stream encryption algorithm is not supported because the RC4 stream encryption algorithm is not
* supported. */
/* Forbidding non-forward security cipher suites when Level is greater than or equal to 3. */
if ((level >= HITLS_SECURITY_LEVEL_THREE) &&
(info->kxAlg != HITLS_KEY_EXCH_DHE && info->kxAlg != HITLS_KEY_EXCH_ECDHE &&
info->kxAlg != HITLS_KEY_EXCH_DHE_PSK && info->kxAlg != HITLS_KEY_EXCH_ECDHE_PSK &&
info->minVersion != HITLS_VERSION_TLS13)) {
return SECURITY_ERR;
}
/* If the level is greater than or equal to 4, disable the SHA1 algorithm. */
if ((level >= HITLS_SECURITY_LEVEL_FOUR) && (info->macAlg == HITLS_MAC_1)) {
return SECURITY_ERR;
}
return SECURITY_SUCCESS;
}
static int32_t CheckVersion(int32_t id, int32_t level)
{
/* Check the DTLS version. */
if (IS_DTLS_VERSION((uint32_t)id)) {
/* The level is greater than or equal to 1, and DTLS1.0 cannot be used. */
if ((level >= HITLS_SECURITY_LEVEL_ONE) && ((uint32_t)id > HITLS_VERSION_DTLS12)) {
return SECURITY_ERR;
}
return SECURITY_SUCCESS;
}
#ifdef HITLS_TLS_PROTO_TLCP11
/* If the level is greater than or equal to 1, SSL2.0, SSL3.0, TLS1.0, and TLS1.1 cannot be used. */
if ((level >= HITLS_SECURITY_LEVEL_ONE) && ((uint32_t)id < HITLS_VERSION_TLS12) &&
((uint32_t)id != HITLS_VERSION_TLCP_DTLCP11)) {
return SECURITY_ERR;
}
/* Level is greater than or equal to 4 and TLCP1.1 is prohibited because the security strength of the signature
* algorithm CERT_SIG_SCHEME_SM2_SM3 is 128 bits. */
if ((level >= HITLS_SECURITY_LEVEL_FOUR) && ((uint32_t)id == HITLS_VERSION_TLCP_DTLCP11)) {
return SECURITY_ERR;
}
#else
/* If the level is greater than or equal to 1, SSL2.0, SSL3.0, TLS1.0, and TLS1.1 cannot be used. */
if ((level >= HITLS_SECURITY_LEVEL_ONE) && ((uint32_t)id < HITLS_VERSION_TLS12)) {
return SECURITY_ERR;
}
#endif
return SECURITY_SUCCESS;
}
static int32_t CheckSessionTicket(int32_t level)
{
/* If the level is greater than or equal to 3, the session ticket is prohibited. */
if (level >= HITLS_SECURITY_LEVEL_THREE) {
return SECURITY_ERR;
}
return SECURITY_SUCCESS;
}
/* Default callback function */
int32_t SECURITY_DefaultCb(const HITLS_Ctx *ctx, const HITLS_Config *config, int32_t option, int32_t bits, int32_t id,
void *other, void *exData)
{
(void)exData;
int32_t ret;
int32_t level = HITLS_DEFAULT_SECURITY_LEVEL;
int32_t minBits;
const TLS_GroupInfo *groupInfo = NULL;
const TLS_SigSchemeInfo *schemeInfo = NULL;
if (ctx == NULL && config == NULL) {
return SECURITY_ERR;
} else if (config != NULL) {
(void)HITLS_CFG_GetSecurityLevel(config, &level);
} else if (ctx != NULL) {
(void)HITLS_GetSecurityLevel(ctx, &level);
}
/* No restrictions are imposed when Level is 0. */
if (level <= HITLS_SECURITY_LEVEL_MIN) {
return SECURITY_SUCCESS;
}
if (level > HITLS_SECURITY_LEVEL_MAX) {
level = HITLS_SECURITY_LEVEL_MAX;
}
/* Check the number of security bits. */
minBits = SECURITY_GetSecbits(level);
switch (option) {
case HITLS_SECURITY_SECOP_VERSION:
/* Check the version. */
ret = CheckVersion(id, level);
break;
case HITLS_SECURITY_SECOP_CIPHER_SUPPORTED:
case HITLS_SECURITY_SECOP_CIPHER_SHARED:
case HITLS_SECURITY_SECOP_CIPHER_CHECK:
/* Check the algorithm suite. */
ret = CheckCipherSuite(other, level);
break;
case HITLS_SECURITY_SECOP_SIGALG_SUPPORTED:
case HITLS_SECURITY_SECOP_SIGALG_SHARED:
case HITLS_SECURITY_SECOP_SIGALG_CHECK:
/* Check the signature algorithm. */
schemeInfo = ConfigGetSignatureSchemeInfo(config, (uint16_t)id);
if (schemeInfo != NULL && schemeInfo->secBits >= g_minBits[level - 1]) {
ret = SECURITY_SUCCESS;
} else {
ret = SECURITY_ERR;
}
break;
case HITLS_SECURITY_SECOP_CURVE_SUPPORTED:
case HITLS_SECURITY_SECOP_CURVE_SHARED:
case HITLS_SECURITY_SECOP_CURVE_CHECK:
/* Check the group. */
groupInfo = ConfigGetGroupInfo(config, (uint16_t)id);
if (groupInfo != NULL && groupInfo->secBits >= g_minBits[level - 1]) {
ret = SECURITY_SUCCESS;
} else {
ret = SECURITY_ERR;
}
break;
case HITLS_SECURITY_SECOP_TICKET:
/* Check the session ticket. */
ret = CheckSessionTicket(level);
break;
default:
if (bits < minBits) {
return SECURITY_ERR;
}
return SECURITY_SUCCESS;
}
return ret;
}
void SECURITY_SetDefault(HITLS_Config *config)
{
if (config == NULL) {
return;
}
/* Default security settings. Set the default security level and default security callback function. */
config->securityLevel = HITLS_DEFAULT_SECURITY_LEVEL;
config->securityCb = SECURITY_DefaultCb;
return;
}
int32_t SECURITY_CfgCheck(const HITLS_Config *config, int32_t option, int32_t bits, int32_t id, void *other)
{
if (config == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16698, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "config null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
if (config->securityCb == NULL) {
/* The security callback function is empty and does not need to be checked. */
return SECURITY_SUCCESS;
}
return config->securityCb(NULL, config, option, bits, id, other, config->securityExData);
}
int32_t SECURITY_SslCheck(const HITLS_Ctx *ctx, int32_t option, int32_t bits, int32_t id, void *other)
{
if (ctx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16699, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "ctx null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
return SECURITY_CfgCheck(&(ctx->config.tlsConfig), option, bits, id, other);
}
#endif /* HITLS_TLS_FEATURE_SECURITY */ | 2302_82127028/openHiTLS-examples_1508 | tls/feature/security/src/security_default.c | C | unknown | 8,468 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_SESSION
#include <stdbool.h>
#include <time.h>
#include <stdarg.h>
#include "securec.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "bsl_list.h"
#include "bsl_err_internal.h"
#include "bsl_errno.h"
#include "tls_binlog_id.h"
#include "cert_method.h"
#include "cert.h"
#include "cert_mgr.h"
#include "session_type.h"
#include "session.h"
#include "cert_mgr_ctx.h"
#ifdef HITLS_TLS_FEATURE_SESSION
#define MAX_PRINTF_BUF 1024
#define CTIME_BUF 26
#endif
/**
* Apply for a session
*/
HITLS_Session *HITLS_SESS_New(void)
{
HITLS_Session *sess = (HITLS_Session *)BSL_SAL_Calloc(1u, sizeof(HITLS_Session));
if (sess == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16714, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
return NULL;
}
sess->certMgrCtx = SAL_CERT_MgrCtxNew();
if (sess->certMgrCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16715, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "MgrCtxNew fail", 0, 0, 0, 0);
BSL_SAL_FREE(sess);
return NULL;
}
if (BSL_SAL_ThreadLockNew(&sess->lock) != BSL_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16716, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ThreadLockNew fail", 0, 0, 0, 0);
SAL_CERT_MgrCtxFree(sess->certMgrCtx);
BSL_SAL_FREE(sess);
return NULL;
}
sess->startTime = (uint64_t)BSL_SAL_CurrentSysTimeGet(); // default value
sess->references = 1;
sess->enable = true;
sess->cipherSuite = HITLS_AES_128_GCM_SHA256;
return sess;
}
/**
* To copy a session, increase the number of references by 1
*/
HITLS_Session *HITLS_SESS_Dup(HITLS_Session *sess)
{
if (sess == NULL) {
return NULL;
}
BSL_SAL_ThreadWriteLock(sess->lock);
sess->references++;
BSL_SAL_ThreadUnlock(sess->lock);
return sess;
}
/**
* Increase the number of references by 1
*/
void HITLS_SESS_UpRef(HITLS_Session *sess)
{
if (sess == NULL) {
return;
}
BSL_SAL_ThreadWriteLock(sess->lock);
sess->references++;
BSL_SAL_ThreadUnlock(sess->lock);
return;
}
void HITLS_SESS_Free(HITLS_Session *sess)
{
if (sess != NULL) {
BSL_SAL_ThreadWriteLock(sess->lock);
sess->references--;
if (sess->references > 0) {
BSL_SAL_ThreadUnlock(sess->lock);
return;
}
BSL_SAL_ThreadUnlock(sess->lock);
if (sess->peerCert != NULL) {
SAL_CERT_PairFree(sess->certMgrCtx, sess->peerCert);
}
sess->peerCert = NULL;
BSL_SAL_FREE(sess->ticket);
#ifdef HITLS_TLS_FEATURE_SNI
BSL_SAL_FREE(sess->hostName);
#endif
memset_s(sess->masterKey, MAX_MASTER_KEY_SIZE, 0, MAX_MASTER_KEY_SIZE);
SAL_CERT_MgrCtxFree(sess->certMgrCtx);
BSL_SAL_ThreadLockFree(sess->lock);
BSL_SAL_FREE(sess);
}
}
static HITLS_Session *DeepCopySess(HITLS_Session *src, HITLS_Session *dest)
{
dest->certMgrCtx = SAL_CERT_MgrCtxProviderNew(LIBCTX_FROM_CERT_MGR_CTX(src->certMgrCtx),
ATTRIBUTE_FROM_CERT_MGR_CTX(src->certMgrCtx));
if (dest->certMgrCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16717, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "MgrCtxNew fail", 0, 0, 0, 0);
return NULL;
}
if (src->peerCert != NULL) {
dest->peerCert = SAL_CERT_PairDup(dest->certMgrCtx, src->peerCert);
if (dest->peerCert == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16718, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PairDup fail", 0, 0, 0, 0);
return NULL;
}
}
#ifdef HITLS_TLS_FEATURE_SNI
if (src->hostNameSize > 0) {
if (SESS_SetHostName(dest, src->hostNameSize, src->hostName) != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16719, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SetHostName fail", 0, 0, 0, 0);
return NULL;
}
}
#endif
if (src->ticketSize > 0) {
if (SESS_SetTicket(dest, src->ticket, src->ticketSize) != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16722, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SetTicket fail", 0, 0, 0, 0);
return NULL;
}
}
return dest;
}
HITLS_Session *SESS_Copy(HITLS_Session *src)
{
HITLS_Session *dest = (HITLS_Session *)BSL_SAL_Dump(src, sizeof(HITLS_Session));
if (dest == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16723, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "dump fail", 0, 0, 0, 0);
return NULL;
}
if (BSL_SAL_ThreadLockNew(&dest->lock) != BSL_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16724, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ThreadLockNew fail", 0, 0, 0, 0);
BSL_SAL_FREE(dest);
return NULL;
}
dest->references = 1;
dest->enable = true;
dest->peerCert = NULL;
#ifdef HITLS_TLS_FEATURE_SNI
dest->hostName = NULL;
#endif
dest->ticket = NULL;
if (DeepCopySess(src, dest) == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16725, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DeepCopySess fail", 0, 0, 0, 0);
HITLS_SESS_Free(dest);
return NULL;
}
return dest;
}
/* Just make a simple judgment */
bool HITLS_SESS_IsResumable(const HITLS_Session *sess)
{
bool isResumable = 0;
if (sess != NULL) {
BSL_SAL_ThreadReadLock(sess->lock);
isResumable = (sess->enable && (sess->sessionIdSize > 0 || sess->ticketSize > 0));
BSL_SAL_ThreadUnlock(sess->lock);
}
return isResumable;
}
/**
* Session is deprecated
*/
void SESS_Disable(HITLS_Session *sess)
{
if (sess != NULL) {
BSL_SAL_ThreadWriteLock(sess->lock);
sess->enable = false;
BSL_SAL_ThreadUnlock(sess->lock);
}
return;
}
#ifdef HITLS_TLS_FEATURE_SESSION_ID
int32_t HITLS_SESS_GetSessionId(const HITLS_Session *sess, uint8_t *sessionId, uint32_t *sessionIdSize)
{
if (sess == NULL || sessionId == NULL || sessionIdSize == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16726, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadReadLock(sess->lock);
if (memcpy_s(sessionId, *sessionIdSize, sess->sessionId, sess->sessionIdSize) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16727, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_SAL_ThreadUnlock(sess->lock);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
*sessionIdSize = sess->sessionIdSize;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
int32_t HITLS_SESS_SetSessionIdCtx(HITLS_Session *sess, uint8_t *sessionIdCtx, uint32_t sessionIdCtxSize)
{
if (sess == NULL || sessionIdCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16728, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
if (sessionIdCtxSize != 0 &&
memcpy_s(sess->sessionIdCtx, sizeof(sess->sessionIdCtx), sessionIdCtx, sessionIdCtxSize) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16729, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_SAL_ThreadUnlock(sess->lock);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
/* The allowed value for sessionIdCtxSize is 0 */
sess->sessionIdCtxSize = sessionIdCtxSize;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
int32_t HITLS_SESS_GetSessionIdCtx(const HITLS_Session *sess, uint8_t *sessionIdCtx, uint32_t *sessionIdCtxSize)
{
if (sess == NULL || sessionIdCtx == NULL || sessionIdCtxSize == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16730, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadReadLock(sess->lock);
if (memcpy_s(sessionIdCtx, *sessionIdCtxSize, sess->sessionIdCtx, sess->sessionIdCtxSize) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16731, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_SAL_ThreadUnlock(sess->lock);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
*sessionIdCtxSize = sess->sessionIdCtxSize;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_SESSION_ID */
int32_t HITLS_SESS_SetSessionId(HITLS_Session *sess, uint8_t *sessionId, uint32_t sessionIdSize)
{
if (sess == NULL || sessionId == NULL || sessionIdSize == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16732, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
if (memcpy_s(sess->sessionId, sizeof(sess->sessionId), sessionId, sessionIdSize) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16733, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_SAL_ThreadUnlock(sess->lock);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
sess->sessionIdSize = sessionIdSize;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
int32_t HITLS_SESS_SetHaveExtMasterSecret(HITLS_Session *sess, uint8_t haveExtMasterSecret)
{
if (sess == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16734, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
sess->haveExtMasterSecret = (haveExtMasterSecret > 0);
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
int32_t HITLS_SESS_GetHaveExtMasterSecret(HITLS_Session *sess, uint8_t *haveExtMasterSecret)
{
if (sess == NULL || haveExtMasterSecret == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16735, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadReadLock(sess->lock);
*haveExtMasterSecret = (uint8_t)sess->haveExtMasterSecret;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
#if defined(HITLS_TLS_FEATURE_SNI) && defined(HITLS_TLS_FEATURE_SESSION)
/* Set the server_name extension required for TLS1.2 session resumption */
int32_t SESS_SetHostName(HITLS_Session *sess, uint32_t hostNameSize, uint8_t *hostName)
{
if (sess == NULL || hostName == NULL || hostNameSize == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16736, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
BSL_SAL_FREE(sess->hostName);
sess->hostName = (uint8_t *)BSL_SAL_Dump(hostName, hostNameSize * sizeof(uint8_t));
if (sess->hostName == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16737, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
BSL_SAL_ThreadUnlock(sess->lock);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
sess->hostNameSize = hostNameSize;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
/* Get the server_name extension required for TLS1.2 session resumption */
int32_t SESS_GetHostName(HITLS_Session *sess, uint32_t *hostNameSize, uint8_t **hostName)
{
if (sess == NULL || hostNameSize == NULL || hostName == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16738, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadReadLock(sess->lock);
*hostName = sess->hostName;
*hostNameSize = sess->hostNameSize;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_SNI */
int32_t HITLS_SESS_SetProtocolVersion(HITLS_Session *sess, uint16_t version)
{
if (sess == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16739, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
sess->version = version;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
int32_t HITLS_SESS_GetProtocolVersion(const HITLS_Session *sess, uint16_t *version)
{
if (sess == NULL || version == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16740, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadReadLock(sess->lock);
*version = sess->version;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
int32_t SESS_SetPeerCert(HITLS_Session *sess, CERT_Pair *peerCert, bool isClient)
{
int32_t ret = HITLS_SUCCESS;
if (sess == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16741, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "sess null", 0, 0, 0, 0);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
sess->peerCert = peerCert;
/* The peer_cert_chain of the client stores the device certificate of the server */
if (isClient && peerCert != NULL) {
/* Obtain the cert */
HITLS_CERT_X509 *tmpCert = SAL_CERT_PairGetX509(peerCert);
if (tmpCert == NULL) {
/* If cert in CERT_Pair is empty, the unlocking is returned */
goto EXIT;
}
/* Obtain the chain */
HITLS_CERT_Chain *tmpChain = SAL_CERT_PairGetChain(peerCert);
if (tmpChain == NULL) {
/* If the chain in CERT_Pair is empty, the unlocking is returned */
goto EXIT;
}
/* Make a copy of the cert */
HITLS_CERT_X509 *newSubjectCert = SAL_CERT_X509Dup(sess->certMgrCtx, tmpCert);
if (newSubjectCert == NULL) {
ret = HITLS_CERT_ERR_X509_DUP;
goto EXIT;
}
ret = (int32_t)BSL_LIST_AddElement(tmpChain, newSubjectCert, BSL_LIST_POS_BEGIN);
if (ret != 0) {
SAL_CERT_X509Free(newSubjectCert);
}
}
EXIT:
BSL_SAL_ThreadUnlock(sess->lock);
return ret;
}
int32_t SESS_GetPeerCert(HITLS_Session *sess, CERT_Pair **peerCert)
{
if (sess == NULL || peerCert == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16742, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadReadLock(sess->lock);
*peerCert = sess->peerCert;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_CONNECTION_INFO_NEGOTIATION */
uint64_t SESS_GetStartTime(HITLS_Session *sess)
{
if (sess == NULL) {
return 0;
}
uint64_t startTime = 0u;
BSL_SAL_ThreadReadLock(sess->lock);
startTime = sess->startTime;
BSL_SAL_ThreadUnlock(sess->lock);
return startTime;
}
int32_t SESS_SetStartTime(HITLS_Session *sess, uint64_t startTime)
{
if (sess == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16743, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
sess->startTime = startTime;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
int32_t HITLS_SESS_SetTimeout(HITLS_Session *sess, uint64_t timeout)
{
if (sess == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16744, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
sess->timeout = timeout;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
int32_t HITLS_SESS_SetCipherSuite(HITLS_Session *sess, uint16_t cipherSuite)
{
if (sess == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16745, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
sess->cipherSuite = cipherSuite;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
int32_t HITLS_SESS_GetCipherSuite(const HITLS_Session *sess, uint16_t *cipherSuite)
{
if (sess == NULL || cipherSuite == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16746, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadReadLock(sess->lock);
*cipherSuite = sess->cipherSuite;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
int32_t HITLS_SESS_SetMasterKey(HITLS_Session *sess, const uint8_t *masterKey, uint32_t masterKeySize)
{
if (sess == NULL || masterKey == NULL || masterKeySize == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16747, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
if (memcpy_s(sess->masterKey, sizeof(sess->masterKey), masterKey, masterKeySize) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16748, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_SAL_ThreadUnlock(sess->lock);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
sess->masterKeySize = masterKeySize;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_SESSION
uint32_t HITLS_SESS_GetMasterKeyLen(const HITLS_Session *sess)
{
uint32_t masterKeySize = 0;
if (sess == NULL) {
return 0;
}
BSL_SAL_ThreadReadLock(sess->lock);
masterKeySize = sess->masterKeySize;
BSL_SAL_ThreadUnlock(sess->lock);
return masterKeySize;
}
#endif
int32_t HITLS_SESS_GetMasterKey(const HITLS_Session *sess, uint8_t *masterKey, uint32_t *masterKeySize)
{
if (sess == NULL || masterKey == NULL || masterKeySize == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16749, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadReadLock(sess->lock);
if (memcpy_s(masterKey, *masterKeySize, sess->masterKey, sess->masterKeySize) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16750, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_SAL_ThreadUnlock(sess->lock);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
*masterKeySize = sess->masterKeySize;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
int32_t SESS_SetTicket(HITLS_Session *sess, uint8_t *ticket, uint32_t ticketSize)
{
if (sess == NULL || ticket == NULL || ticketSize == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16751, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
BSL_SAL_FREE(sess->ticket);
sess->ticket = (uint8_t *)BSL_SAL_Dump(ticket, ticketSize);
if (sess->ticket == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16752, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
BSL_SAL_ThreadUnlock(sess->lock);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
sess->ticketSize = ticketSize;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
int32_t SESS_GetTicket(const HITLS_Session *sess, uint8_t **ticket, uint32_t *ticketSize)
{
if (sess == NULL || ticket == NULL || ticketSize == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadReadLock(sess->lock);
*ticket = sess->ticket;
*ticketSize = sess->ticketSize;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
bool HITLS_SESS_HasTicket(const HITLS_Session *sess)
{
if (sess == NULL) {
return false;
}
bool flag = 0;
BSL_SAL_ThreadReadLock(sess->lock);
flag = (sess->ticket != NULL);
BSL_SAL_ThreadUnlock(sess->lock);
return flag;
}
#endif
bool SESS_CheckValidity(HITLS_Session *sess, uint64_t curTime)
{
if (sess == NULL) {
return false;
}
bool flag = false;
BSL_SAL_ThreadReadLock(sess->lock);
if ((sess->enable) && (curTime < sess->startTime + sess->timeout)) {
flag = true;
}
BSL_SAL_ThreadUnlock(sess->lock);
return flag;
}
int32_t SESS_SetTicketAgeAdd(HITLS_Session *sess, uint32_t ticketAgeAdd)
{
if (sess == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16754, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
sess->ticketAgeAdd = ticketAgeAdd;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
uint32_t SESS_GetTicketAgeAdd(const HITLS_Session *sess)
{
uint32_t ticketAgeAdd = 0;
if (sess == NULL) {
return 0;
}
BSL_SAL_ThreadReadLock(sess->lock);
ticketAgeAdd = sess->ticketAgeAdd;
BSL_SAL_ThreadUnlock(sess->lock);
return ticketAgeAdd;
}
void *HITLS_SESS_GetUserData(const HITLS_Session *sess)
{
if (sess == NULL) {
return NULL;
}
void *data = NULL;
BSL_SAL_ThreadReadLock(sess->lock);
data = sess->userData;
BSL_SAL_ThreadUnlock(sess->lock);
return data;
}
int32_t HITLS_SESS_SetUserData(HITLS_Session *sess, void *userData)
{
if (sess == NULL) {
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(sess->lock);
sess->userData = userData;
BSL_SAL_ThreadUnlock(sess->lock);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_SESSION */ | 2302_82127028/openHiTLS-examples_1508 | tls/feature/session/src/session.c | C | unknown | 23,148 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
#include <stdbool.h>
#include "securec.h"
#include "tlv.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "bsl_bytes.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "session_enc.h"
#include "session_type.h"
#include "cert_mgr_ctx.h"
#include "cert_method.h"
#include "parse_common.h"
#define MAX_PSK_IDENTITY_LEN 0xffff
#ifdef HITLS_TLS_FEATURE_SNI
#define MAX_HOST_NAME_LEN 0xff
#endif
typedef int32_t (*PfuncDecSessionObjFunc)(HITLS_Session *sess, SessionObjType type, const uint8_t *data,
uint32_t length, uint32_t *readLen);
typedef struct {
SessionObjType type;
PfuncDecSessionObjFunc func;
} SessObjDecFunc;
static int32_t DecSessObjVersion(HITLS_Session *sess, SessionObjType type, const uint8_t *data, uint32_t length,
uint32_t *readLen)
{
int32_t ret;
uint16_t version = 0;
BSL_Tlv tlv = {0};
tlv.length = sizeof(version);
tlv.value = (uint8_t *)&version;
ret = BSL_TLV_Parse(type, data, length, &tlv, readLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DEC_VERSION_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15993, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode session version fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_DEC_VERSION_FAIL;
}
sess->version = version;
return HITLS_SUCCESS;
}
static int32_t DecSessObjCipherSuite(HITLS_Session *sess, SessionObjType type, const uint8_t *data, uint32_t length,
uint32_t *readLen)
{
int32_t ret;
uint16_t cipherSuite = 0;
BSL_Tlv tlv = {0};
tlv.length = sizeof(cipherSuite);
tlv.value = (uint8_t *)&cipherSuite;
ret = BSL_TLV_Parse(type, data, length, &tlv, readLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DEC_CIPHER_SUITE_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15994, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode session cipher suite fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_DEC_CIPHER_SUITE_FAIL;
}
sess->cipherSuite = cipherSuite;
return HITLS_SUCCESS;
}
static int32_t DecSessObjMasterSecret(HITLS_Session *sess, SessionObjType type, const uint8_t *data, uint32_t length,
uint32_t *readLen)
{
int32_t ret;
BSL_Tlv tlv = {0};
tlv.length = MAX_MASTER_KEY_SIZE;
tlv.value = sess->masterKey;
ret = BSL_TLV_Parse(type, data, length, &tlv, readLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DEC_MASTER_SECRET_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15995, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode session master secret fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_DEC_MASTER_SECRET_FAIL;
}
sess->masterKeySize = tlv.length;
return HITLS_SUCCESS;
}
static int32_t DecSessObjStartTime(HITLS_Session *sess, SessionObjType type, const uint8_t *data, uint32_t length,
uint32_t *readLen)
{
int32_t ret;
uint64_t startTime = 0;
BSL_Tlv tlv = {0};
tlv.length = sizeof(startTime);
tlv.value = (uint8_t *)&startTime;
ret = BSL_TLV_Parse(type, data, length, &tlv, readLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DEC_START_TIME_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15998, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode session start time fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_DEC_START_TIME_FAIL;
}
sess->startTime = startTime;
return HITLS_SUCCESS;
}
static int32_t DecSessObjTimeout(HITLS_Session *sess, SessionObjType type, const uint8_t *data, uint32_t length,
uint32_t *readLen)
{
int32_t ret;
uint64_t timeout = 0;
BSL_Tlv tlv = {0};
tlv.length = sizeof(timeout);
tlv.value = (uint8_t *)&timeout;
ret = BSL_TLV_Parse(type, data, length, &tlv, readLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DEC_TIME_OUT_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15999, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode session timeout fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_DEC_TIME_OUT_FAIL;
}
sess->timeout = timeout;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_SNI
static int32_t DecSessObjHostName(HITLS_Session *sess, SessionObjType type, const uint8_t *data, uint32_t length,
uint32_t *readLen)
{
int32_t ret;
uint32_t offset = sizeof(uint32_t);
// The length has been verified at the upper layer and must be greater than 8 bytes.
uint32_t tlvLen = BSL_ByteToUint32(&data[offset]);
if (tlvLen > MAX_HOST_NAME_LEN || tlvLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16701, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "tlvLen error", 0, 0, 0, 0);
return HITLS_SESS_ERR_DEC_HOST_NAME_FAIL;
}
uint8_t *hostName = BSL_SAL_Calloc(1u, tlvLen);
if (hostName == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16000, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"malloc hostName fail when decode session obj host name.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
BSL_Tlv tlv = {0};
tlv.length = tlvLen;
tlv.value = hostName;
ret = BSL_TLV_Parse(type, data, length, &tlv, readLen);
if (ret != BSL_SUCCESS) {
BSL_SAL_FREE(hostName);
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DEC_HOST_NAME_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16001, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode session host name fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_DEC_HOST_NAME_FAIL;
}
sess->hostName = tlv.value;
sess->hostNameSize = tlv.length;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_SNI */
static int32_t DecSessObjSessionIdCtx(HITLS_Session *sess, SessionObjType type, const uint8_t *data, uint32_t length,
uint32_t *readLen)
{
int32_t ret;
BSL_Tlv tlv = {0};
tlv.length = HITLS_SESSION_ID_MAX_SIZE;
tlv.value = sess->sessionIdCtx;
ret = BSL_TLV_Parse(type, data, length, &tlv, readLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DEC_SESSION_ID_CTX_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16002, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode session session id ctx fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_DEC_SESSION_ID_CTX_FAIL;
}
sess->sessionIdCtxSize = tlv.length;
return HITLS_SUCCESS;
}
static int32_t DecSessObjSessionId(HITLS_Session *sess, SessionObjType type, const uint8_t *data, uint32_t length,
uint32_t *readLen)
{
int32_t ret;
BSL_Tlv tlv = {0};
tlv.length = HITLS_SESSION_ID_MAX_SIZE;
tlv.value = sess->sessionId;
ret = BSL_TLV_Parse(type, data, length, &tlv, readLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DEC_SESSION_ID_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16003, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode session session id fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_DEC_SESSION_ID_FAIL;
}
sess->sessionIdSize = tlv.length;
return HITLS_SUCCESS;
}
static int32_t DecSessObjExtendMasterSecret(HITLS_Session *sess, SessionObjType type, const uint8_t *data,
uint32_t length, uint32_t *readLen)
{
int32_t ret;
uint8_t haveExtMasterSecret = 0;
BSL_Tlv tlv = {0};
tlv.length = sizeof(haveExtMasterSecret);
tlv.value = &haveExtMasterSecret;
ret = BSL_TLV_Parse(type, data, length, &tlv, readLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DEC_EXT_MASTER_SECRET_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16004, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode session extend master secret fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_DEC_EXT_MASTER_SECRET_FAIL;
}
sess->haveExtMasterSecret = (bool)haveExtMasterSecret;
return HITLS_SUCCESS;
}
static int32_t DecSessObjVerifyResult(HITLS_Session *sess, SessionObjType type, const uint8_t *data, uint32_t length,
uint32_t *readLen)
{
int32_t ret;
uint32_t verifyResult = 0;
BSL_Tlv tlv = {0};
tlv.length = sizeof(verifyResult);
tlv.value = (uint8_t *)&verifyResult;
ret = BSL_TLV_Parse(type, data, length, &tlv, readLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DEC_VERIFY_RESULT_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16005, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode session verify result fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_DEC_VERIFY_RESULT_FAIL;
}
sess->verifyResult = (int32_t)verifyResult;
return HITLS_SUCCESS;
}
static int32_t ParseBufToCert(HITLS_Session *sess, const uint8_t *buf, uint32_t bufLen)
{
uint32_t offset = 0;
ParsePacket pkt = {.ctx = NULL, .buf = buf, .bufLen = bufLen, .bufOffset = &offset};
/* Obtain the certificate length */
uint32_t certLen = 0;
int32_t ret = ParseBytesToUint24(&pkt, &certLen);
if (ret != HITLS_SUCCESS || (certLen != (pkt.bufLen - CERT_LEN_TAG_SIZE))) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16260, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode certLen fail.", 0, 0, 0, 0);
return HITLS_PARSE_INVALID_MSG_LEN;
}
#ifndef HITLS_TLS_FEATURE_PROVIDER
CERT_MgrCtx *certMgrCtx = sess->certMgrCtx;
if (certMgrCtx == NULL || certMgrCtx->method.certParse == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16261, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"certMgrCtx or certMgrCtx->method.certParse is null.", 0, 0, 0, 0);
return HITLS_NULL_INPUT;
}
/* Parse the first device certificate. */
HITLS_CERT_X509 *cert = certMgrCtx->method.certParse(NULL, &pkt.buf[*pkt.bufOffset], certLen,
TLS_PARSE_TYPE_BUFF, TLS_PARSE_FORMAT_ASN1);
#else
HITLS_CERT_X509 *cert = SAL_CERT_X509Parse(LIBCTX_FROM_SESSION_CTX(sess),
ATTRIBUTE_FROM_SESSION_CTX(sess), NULL, &pkt.buf[*pkt.bufOffset], certLen,
TLS_PARSE_TYPE_BUFF, TLS_PARSE_FORMAT_ASN1);
#endif
if (cert == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16262, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"parse peer eecert error", 0, 0, 0, 0);
return HITLS_CERT_ERR_PARSE_MSG;
}
CERT_Pair *newCertPair = BSL_SAL_Calloc(1u, sizeof(CERT_Pair));
if (newCertPair == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16263, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"peer cert malloc fail.", 0, 0, 0, 0);
SAL_CERT_X509Free(cert);
return HITLS_MEMALLOC_FAIL;
}
newCertPair->cert = cert;
sess->peerCert = newCertPair;
return HITLS_SUCCESS;
}
static int32_t DecSessObjPeerCert(HITLS_Session *sess, SessionObjType type, const uint8_t *data, uint32_t length,
uint32_t *readLen)
{
(void)type;
uint32_t offset = sizeof(uint32_t);
// The length has been verified at the upper layer and must be greater than 8 bytes.
uint32_t tlvLen = BSL_ByteToUint32(&data[offset]);
offset += sizeof(uint32_t);
if ((tlvLen == 0) || (tlvLen > length - offset)) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DEC_PEER_CERT_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16264, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode peercert fail.", 0, 0, 0, 0);
return HITLS_SESS_ERR_DEC_PEER_CERT_FAIL;
}
*readLen = tlvLen + offset;
return ParseBufToCert(sess, &data[offset], tlvLen);
}
static int32_t DecSessObjTicketAgeAdd(HITLS_Session *sess, SessionObjType type, const uint8_t *data, uint32_t length,
uint32_t *readLen)
{
int32_t ret;
uint32_t ticketAgeAdd = 0;
BSL_Tlv tlv = {0};
tlv.length = sizeof(ticketAgeAdd);
tlv.value = (uint8_t *)&ticketAgeAdd;
ret = BSL_TLV_Parse(type, data, length, &tlv, readLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DEC_START_TIME_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15998, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"decode session TicketAgeAdd fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_DEC_START_TIME_FAIL;
}
sess->ticketAgeAdd = ticketAgeAdd;
return HITLS_SUCCESS;
}
/*
* Decoding function list.
* Ensure that the sequence of decode and encode types is the same.
*/
static const SessObjDecFunc OBJ_LIST[] = {
{SESS_OBJ_VERSION, DecSessObjVersion},
{SESS_OBJ_CIPHER_SUITE, DecSessObjCipherSuite},
{SESS_OBJ_MASTER_SECRET, DecSessObjMasterSecret},
{SESS_OBJ_PEER_CERT, DecSessObjPeerCert},
{SESS_OBJ_START_TIME, DecSessObjStartTime},
{SESS_OBJ_TIMEOUT, DecSessObjTimeout},
#ifdef HITLS_TLS_FEATURE_SNI
{SESS_OBJ_HOST_NAME, DecSessObjHostName},
#endif
{SESS_OBJ_SESSION_ID_CTX, DecSessObjSessionIdCtx},
{SESS_OBJ_SESSION_ID, DecSessObjSessionId},
{SESS_OBJ_SUPPORT_EXTEND_MASTER_SECRET, DecSessObjExtendMasterSecret},
{SESS_OBJ_VERIFY_RESULT, DecSessObjVerifyResult},
{SESS_OBJ_AGE_ADD, DecSessObjTicketAgeAdd},
};
int32_t SESS_Decode(HITLS_Session *sess, const uint8_t *data, uint32_t length)
{
if (sess == NULL || data == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16006, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SESS_Decode input parameter is NULL.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
int32_t ret;
uint32_t index;
const uint8_t *curPos = data;
uint32_t offset = 0;
uint32_t readLen = 0;
for (index = 0; index < sizeof(OBJ_LIST) / sizeof(SessObjDecFunc); index++) {
if (length - offset < TLV_HEADER_LENGTH) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DECODE_TICKET);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16009, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SESS_Decode length error, offset is %u, length is %u.", offset, length, 0, 0);
return HITLS_SESS_ERR_DECODE_TICKET;
}
uint32_t type = BSL_ByteToUint32(curPos);
if (OBJ_LIST[index].type != type) {
continue;
}
readLen = 0;
ret = OBJ_LIST[index].func(sess, OBJ_LIST[index].type, curPos, length - offset, &readLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
offset += readLen;
curPos += readLen;
}
if (offset != length) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_DECODE_TICKET);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16007, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SESS_Decode fail, offset is %u, length is %u.", offset, length, 0, 0);
return HITLS_SESS_ERR_DECODE_TICKET;
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_SESSION_TICKET */ | 2302_82127028/openHiTLS-examples_1508 | tls/feature/session/src/session_dec.c | C | unknown | 15,397 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
#include "tlv.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "bsl_bytes.h"
#include "bsl_list.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "session_type.h"
#include "cert_mgr_ctx.h"
#include "session_enc.h"
#include "cert_method.h"
typedef int32_t (*PfuncEncSessionObjFunc)(const HITLS_Session *sess, SessionObjType type, uint8_t *data,
uint32_t length, uint32_t *encLen);
typedef struct {
SessionObjType type;
PfuncEncSessionObjFunc func;
} SessObjEncFunc;
static int32_t EncSessObjVersion(const HITLS_Session *sess, SessionObjType type, uint8_t *data, uint32_t length,
uint32_t *encLen)
{
int ret;
uint16_t version = sess->version;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sizeof(version);
tlv.value = (uint8_t *)&version;
if (data == NULL) {
/* If the input parameter is NULL, return the length after encoding. */
*encLen = sizeof(tlv.type) + sizeof(tlv.length) + tlv.length;
return HITLS_SUCCESS;
}
ret = BSL_TLV_Pack(&tlv, data, length, encLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_ENC_VERSION_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15992, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode session version fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_ENC_VERSION_FAIL;
}
return HITLS_SUCCESS;
}
static int32_t EncSessObjCipherSuite(const HITLS_Session *sess, SessionObjType type, uint8_t *data, uint32_t length,
uint32_t *encLen)
{
int ret;
uint16_t cipherSuite = sess->cipherSuite;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sizeof(cipherSuite);
tlv.value = (uint8_t *)&cipherSuite;
if (data == NULL) {
/* If the input parameter is NULL, return the length after encoding. */
*encLen = sizeof(tlv.type) + sizeof(tlv.length) + tlv.length;
return HITLS_SUCCESS;
}
ret = BSL_TLV_Pack(&tlv, data, length, encLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_ENC_CIPHER_SUITE_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15982, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode session cipher suite fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_ENC_CIPHER_SUITE_FAIL;
}
return HITLS_SUCCESS;
}
static int32_t EncSessObjMasterSecret(const HITLS_Session *sess, SessionObjType type, uint8_t *data, uint32_t length,
uint32_t *encLen)
{
int ret;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sess->masterKeySize;
tlv.value = (uint8_t *)(uintptr_t)(sess->masterKey);
if (data == NULL) {
/* If the input parameter is NULL, return the length after encoding. */
*encLen = sizeof(tlv.type) + sizeof(tlv.length) + tlv.length;
return HITLS_SUCCESS;
}
ret = BSL_TLV_Pack(&tlv, data, length, encLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_ENC_MASTER_SECRET_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15983, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode session master secret fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_ENC_MASTER_SECRET_FAIL;
}
return HITLS_SUCCESS;
}
static int32_t EncSessObjStartTime(const HITLS_Session *sess, SessionObjType type, uint8_t *data, uint32_t length,
uint32_t *encLen)
{
int ret;
uint64_t startTime = sess->startTime;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sizeof(startTime);
tlv.value = (uint8_t *)&startTime;
if (data == NULL) {
/* If the input parameter is NULL, return the length after encoding. */
*encLen = sizeof(tlv.type) + sizeof(tlv.length) + tlv.length;
return HITLS_SUCCESS;
}
ret = BSL_TLV_Pack(&tlv, data, length, encLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_ENC_START_TIME_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15985, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode session start time fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_ENC_START_TIME_FAIL;
}
return HITLS_SUCCESS;
}
static int32_t EncSessObjTimeout(const HITLS_Session *sess, SessionObjType type, uint8_t *data, uint32_t length,
uint32_t *encLen)
{
int ret;
uint64_t timeout = sess->timeout;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sizeof(timeout);
tlv.value = (uint8_t *)&timeout;
if (data == NULL) {
/* If the input parameter is NULL, return the length after encoding. */
*encLen = sizeof(tlv.type) + sizeof(tlv.length) + tlv.length;
return HITLS_SUCCESS;
}
ret = BSL_TLV_Pack(&tlv, data, length, encLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_ENC_TIME_OUT_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15986, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode session timeout fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_ENC_TIME_OUT_FAIL;
}
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_SNI
static int32_t EncSessObjHostName(const HITLS_Session *sess, SessionObjType type, uint8_t *data, uint32_t length,
uint32_t *encLen)
{
if (sess->hostNameSize == 0) {
return HITLS_SUCCESS;
}
int ret;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sess->hostNameSize;
tlv.value = (uint8_t *)sess->hostName;
if (data == NULL) {
/* If the input parameter is NULL, return the length after encoding. */
*encLen = sizeof(tlv.type) + sizeof(tlv.length) + tlv.length;
return HITLS_SUCCESS;
}
ret = BSL_TLV_Pack(&tlv, data, length, encLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_ENC_HOST_NAME_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15987, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode session host name fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_ENC_HOST_NAME_FAIL;
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_SNI */
static int32_t EncSessObjSessionIdCtx(const HITLS_Session *sess, SessionObjType type, uint8_t *data, uint32_t length,
uint32_t *encLen)
{
if (sess->sessionIdCtxSize == 0) {
return HITLS_SUCCESS;
}
int ret;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sess->sessionIdCtxSize;
tlv.value = (uint8_t *)(uintptr_t)(sess->sessionIdCtx);
if (data == NULL) {
/* If the input parameter is NULL, return the length after encoding. */
*encLen = sizeof(tlv.type) + sizeof(tlv.length) + tlv.length;
return HITLS_SUCCESS;
}
ret = BSL_TLV_Pack(&tlv, data, length, encLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_ENC_SESSION_ID_CTX_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15988, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode session session id ctx fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_ENC_SESSION_ID_CTX_FAIL;
}
return HITLS_SUCCESS;
}
static int32_t EncSessObjSessionId(const HITLS_Session *sess, SessionObjType type, uint8_t *data, uint32_t length,
uint32_t *encLen)
{
if (sess->sessionIdSize == 0) {
return HITLS_SUCCESS;
}
int ret;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sess->sessionIdSize;
tlv.value = (uint8_t *)(uintptr_t)(sess->sessionId);
if (data == NULL) {
/* If the input parameter is NULL, return the length after encoding. */
*encLen = sizeof(tlv.type) + sizeof(tlv.length) + tlv.length;
return HITLS_SUCCESS;
}
ret = BSL_TLV_Pack(&tlv, data, length, encLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_ENC_SESSION_ID_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15989, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode session session id fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_ENC_SESSION_ID_FAIL;
}
return HITLS_SUCCESS;
}
static int32_t EncSessObjExtendMasterSecret(const HITLS_Session *sess, SessionObjType type, uint8_t *data,
uint32_t length, uint32_t *encLen)
{
int ret;
uint8_t haveExtMasterSecret = (uint8_t)sess->haveExtMasterSecret;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sizeof(haveExtMasterSecret);
tlv.value = (uint8_t *)&haveExtMasterSecret;
if (data == NULL) {
/* If the input parameter is NULL, return the length after encoding. */
*encLen = sizeof(tlv.type) + sizeof(tlv.length) + tlv.length;
return HITLS_SUCCESS;
}
ret = BSL_TLV_Pack(&tlv, data, length, encLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_ENC_EXT_MASTER_SECRET_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15990, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode session extend master secret fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_ENC_EXT_MASTER_SECRET_FAIL;
}
return HITLS_SUCCESS;
}
static int32_t EncSessObjVerifyResult(const HITLS_Session *sess, SessionObjType type, uint8_t *data, uint32_t length,
uint32_t *encLen)
{
int ret;
int32_t verifyResult = sess->verifyResult;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sizeof(verifyResult);
tlv.value = (uint8_t *)&verifyResult;
if (data == NULL) {
/* If the input parameter is NULL, return the length after encoding. */
*encLen = sizeof(tlv.type) + sizeof(tlv.length) + tlv.length;
return HITLS_SUCCESS;
}
ret = BSL_TLV_Pack(&tlv, data, length, encLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_ENC_VERIFY_RESULT_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15991, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode session verify result fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_ENC_VERIFY_RESULT_FAIL;
}
return HITLS_SUCCESS;
}
static int32_t PackCertToBuf(const HITLS_Session *sess, uint8_t *buf, uint32_t bufLen)
{
CERT_Pair *peerCert = sess->peerCert;
HITLS_CERT_X509 *cert = peerCert->cert;
uint32_t encodeLen = 0;
#ifndef HITLS_TLS_FEATURE_PROVIDER
CERT_MgrCtx *mgrCtx = sess->certMgrCtx;
if (mgrCtx->method.certEncode == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16254, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"mgrCtx->method.certEncode is null.", 0, 0, 0, 0);
return HITLS_NULL_INPUT;
}
/* Write the certificate data. */
int32_t ret = mgrCtx->method.certEncode(NULL, cert, &buf[CERT_LEN_TAG_SIZE],
bufLen - CERT_LEN_TAG_SIZE, &encodeLen);
#else
int32_t ret = SAL_CERT_X509Encode(NULL, cert, &buf[CERT_LEN_TAG_SIZE],
bufLen - CERT_LEN_TAG_SIZE, &encodeLen);
#endif
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16255, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"certEncode error.", 0, 0, 0, 0);
return HITLS_CERT_ERR_ENCODE_CERT;
}
if (bufLen - CERT_LEN_TAG_SIZE != encodeLen) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16256, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encodeLen error.", 0, 0, 0, 0);
return HITLS_CERT_ERR_ENCODE_CERT;
}
BSL_Uint24ToByte(encodeLen, buf);
return HITLS_SUCCESS;
}
static uint32_t GetPeertCertSize(const HITLS_Session *sess)
{
uint32_t certLen = 0;
CERT_Pair *peerCert = sess->peerCert;
#ifndef HITLS_TLS_FEATURE_PROVIDER
CERT_MgrCtx *mgrCtx = sess->certMgrCtx;
if (mgrCtx == NULL || mgrCtx->method.certCtrl == NULL || peerCert->cert == NULL) {
return 0;
}
int32_t ret = mgrCtx->method.certCtrl(NULL, peerCert->cert, CERT_CTRL_GET_ENCODE_LEN, NULL, (void *)&certLen);
#else
int32_t ret = SAL_CERT_X509Ctrl(NULL, peerCert->cert, CERT_CTRL_GET_ENCODE_LEN, NULL, (void *)&certLen);
#endif
if (ret != HITLS_SUCCESS || certLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16257, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CERT_CTRL_GET_ENCODE_LEN error.", 0, 0, 0, 0);
return 0;
}
return certLen + CERT_LEN_TAG_SIZE;
}
static int32_t EncSessObjPeerCert(const HITLS_Session *sess, SessionObjType type, uint8_t *data, uint32_t length,
uint32_t *encLen)
{
CERT_Pair *peerCert = sess->peerCert;
if (peerCert == NULL) {
return HITLS_SUCCESS;
}
uint32_t bufLen = GetPeertCertSize(sess);
if (bufLen == 0) {
return HITLS_SUCCESS;
}
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = bufLen;
if (data == NULL) {
/* If the input parameter is NULL, return the length after encoding. */
*encLen = sizeof(tlv.type) + sizeof(tlv.length) + tlv.length;
return HITLS_SUCCESS;
}
uint8_t *curPos = data;
if ((length < TLV_HEADER_LENGTH) || (tlv.length > length - TLV_HEADER_LENGTH)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16258, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"TLV build error: length = %u is not enough for tlv length = %u, tlv type = 0x%x.",
length, tlv.length, tlv.type, 0);
BSL_ERR_PUSH_ERROR(BSL_TLV_ERR_BAD_PARAM);
return BSL_TLV_ERR_BAD_PARAM;
}
/* Write the TLV type */
BSL_Uint32ToByte(tlv.type, curPos);
curPos += sizeof(uint32_t);
/* Write the TLV length */
BSL_Uint32ToByte(tlv.length, curPos);
curPos += sizeof(uint32_t);
int32_t ret = PackCertToBuf(sess, curPos, tlv.length);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16265, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PackCertToBuf fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_ENC_PEER_CERT_FAIL;
}
*encLen = TLV_HEADER_LENGTH + tlv.length;
return HITLS_SUCCESS;
}
static int32_t EncSessObjTicketAgeAdd(const HITLS_Session *sess, SessionObjType type, uint8_t *data, uint32_t length,
uint32_t *encLen)
{
int ret;
uint32_t ticketAgeAdd = sess->ticketAgeAdd;
BSL_Tlv tlv = {0};
tlv.type = type;
tlv.length = sizeof(ticketAgeAdd);
tlv.value = (uint8_t *)&ticketAgeAdd;
if (data == NULL) {
/* If the input parameter is NULL, the length after encoding is returned. */
*encLen = sizeof(tlv.type) + sizeof(tlv.length) + tlv.length;
return HITLS_SUCCESS;
}
ret = BSL_TLV_Pack(&tlv, data, length, encLen);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_ENC_VERIFY_RESULT_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16183, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode session TicketAgeAdd fail. ret %d", ret, 0, 0, 0);
return HITLS_SESS_ERR_ENC_VERIFY_RESULT_FAIL;
}
return HITLS_SUCCESS;
}
/*
* Encoding function list.
* Ensure that the sequence of decode and encode types is the same.
*/
static const SessObjEncFunc OBJ_LIST[] = {
{SESS_OBJ_VERSION, EncSessObjVersion},
{SESS_OBJ_CIPHER_SUITE, EncSessObjCipherSuite},
{SESS_OBJ_MASTER_SECRET, EncSessObjMasterSecret},
{SESS_OBJ_PEER_CERT, EncSessObjPeerCert},
{SESS_OBJ_START_TIME, EncSessObjStartTime},
{SESS_OBJ_TIMEOUT, EncSessObjTimeout},
#ifdef HITLS_TLS_FEATURE_SNI
{SESS_OBJ_HOST_NAME, EncSessObjHostName},
#endif
{SESS_OBJ_SESSION_ID_CTX, EncSessObjSessionIdCtx},
{SESS_OBJ_SESSION_ID, EncSessObjSessionId},
{SESS_OBJ_SUPPORT_EXTEND_MASTER_SECRET, EncSessObjExtendMasterSecret},
{SESS_OBJ_VERIFY_RESULT, EncSessObjVerifyResult},
{SESS_OBJ_AGE_ADD, EncSessObjTicketAgeAdd},
};
uint32_t SESS_GetTotalEncodeSize(const HITLS_Session *sess)
{
if (sess == NULL) {
return 0;
}
uint32_t index;
uint32_t offset = 0;
uint32_t encLen = 0;
for (index = 0; index < sizeof(OBJ_LIST) / sizeof(SessObjEncFunc); index++) {
encLen = 0;
/* This parameter is used only to obtain the encoded length and will not verified the returned value. */
(void)OBJ_LIST[index].func(sess, OBJ_LIST[index].type, NULL, 0, &encLen);
offset += encLen;
}
return offset;
}
int32_t SESS_Encode(const HITLS_Session *sess, uint8_t *data, uint32_t length, uint32_t *usedLen)
{
if (sess == NULL || data == NULL || usedLen == 0) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16008, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SESS_Encode input parameter is NULL.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
int32_t ret;
uint32_t index;
uint8_t *curPos = data;
uint32_t offset = 0;
uint32_t encLen = 0;
for (index = 0; index < sizeof(OBJ_LIST) / sizeof(SessObjEncFunc); index++) {
encLen = 0;
ret = OBJ_LIST[index].func(sess, OBJ_LIST[index].type, curPos, length - offset, &encLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
offset += encLen;
curPos += encLen;
}
*usedLen = offset;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_SESSION_TICKET */ | 2302_82127028/openHiTLS-examples_1508 | tls/feature/session/src/session_enc.c | C | unknown | 17,675 |
/*
* 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 SESSION_ENC_H
#define SESSION_ENC_H
#include <stdint.h>
#include "hitls_type.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* Enumerated value of session information
* Do not change the enumerated value. If need add the enumerated value, add at the end
*/
typedef enum {
SESS_OBJ_VERSION = 0x0101,
SESS_OBJ_CIPHER_SUITE = 0x0102,
SESS_OBJ_MASTER_SECRET = 0x0103,
SESS_OBJ_PEER_CERT = 0x0104,
SESS_OBJ_START_TIME = 0x0106,
SESS_OBJ_TIMEOUT = 0x0107,
SESS_OBJ_HOST_NAME = 0x0108,
SESS_OBJ_SESSION_ID_CTX = 0x0109,
SESS_OBJ_SESSION_ID = 0x010A,
SESS_OBJ_SUPPORT_EXTEND_MASTER_SECRET = 0x010B,
SESS_OBJ_VERIFY_RESULT = 0x010C,
SESS_OBJ_AGE_ADD = 0x010D,
} SessionObjType;
/**
* @brief Obtain the length of the encoded SESS information
*
* @param sess [IN] sess structure
*
* @retval Length of the encoded data
*/
uint32_t SESS_GetTotalEncodeSize(const HITLS_Session *sess);
/**
* @brief Encode the SESS information to generate data
*
* @param sess [IN] sess structure
* @param data [OUT] Packed data
* @param length [IN] Maximum length of the data array
* @param usedLen [OUT] Data length after packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t SESS_Encode(const HITLS_Session *sess, uint8_t *data, uint32_t length, uint32_t *usedLen);
/**
* @brief Decode data into SESS information
*
* @param sess [OUT] sess structure
* @param data [IN] Data to be parsed
* @param length [IN] Length of the data to be parsed
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t SESS_Decode(HITLS_Session *sess, const uint8_t *data, uint32_t length);
#ifdef __cplusplus
}
#endif
#endif
| 2302_82127028/openHiTLS-examples_1508 | tls/feature/session/src/session_enc.h | C | unknown | 2,309 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_SESSION
#include <stdbool.h>
#include "securec.h"
#include "bsl_sal.h"
#include "sal_time.h"
#include "bsl_hash.h"
#include "hitls_error.h"
#include "session.h"
#include "bsl_errno.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "crypt.h"
#include "tls.h"
#include "session_type.h"
#include "session_mgr.h"
#define SESSION_DEFAULT_TIMEOUT 7200u
#ifdef HITLS_TLS_FEATURE_SESSION
#define SESSION_DEFAULT_CACHE_SIZE 256u
#endif
#define SESSION_GERNERATE_RETRY_MAX_TIMES 10
#define SESSION_DEFAULT_HASH_BKT_SZIE 64u
typedef struct {
uint32_t sessionIdSize;
uint8_t sessionId[HITLS_SESSION_ID_MAX_SIZE];
} SessionKey;
/* For details about the SessKey hash function, see BSL_CstlHashCodeCalcStr */
static uint32_t SessKeyHashCodeCal(uintptr_t key, uint32_t bktSize)
{
if (bktSize == 0) {
return 0;
}
SessionKey *tmpKey = (SessionKey *)key;
uint32_t hashCode = BSL_HASH_CodeCalc(tmpKey, sizeof(SessionKey));
return hashCode % bktSize;
}
static bool SessKeyHashMacth(uintptr_t key1, uintptr_t key2)
{
SessionKey *tkey1 = (SessionKey *)key1;
SessionKey *tkey2 = (SessionKey *)key2;
if (memcmp(tkey1, tkey2, sizeof(SessionKey)) == 0) {
return true;
}
return false;
}
/* Session key copy function, which returns the address for storing character strings */
static void *SessKeyDupFunc(void *src, size_t size)
{
if (src == NULL || size == 0) {
return NULL;
}
SessionKey *dupKey = (SessionKey *)BSL_SAL_Dump(src, (uint32_t)size);
return (void *)dupKey;
}
static void SessKeyFreeFunc(void *ptr)
{
BSL_SAL_FREE(ptr);
return;
}
/* Session copy function */
static void *SessionDupFunc(void *src, size_t size)
{
(void)size;
return (void *)HITLS_SESS_Dup((HITLS_Session *)src);
}
static void SessionFreeFunc(void *ptr)
{
HITLS_SESS_Free((HITLS_Session *)ptr);
return;
}
TLS_SessionMgr *SESSMGR_New(HITLS_Lib_Ctx *libCtx)
{
TLS_SessionMgr *mgr = (TLS_SessionMgr *)BSL_SAL_Calloc(1u, sizeof(TLS_SessionMgr));
if (mgr == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16702, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
return NULL;
}
if (BSL_SAL_ThreadLockNew(&mgr->lock) != BSL_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16703, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ThreadLockNew fail", 0, 0, 0, 0);
BSL_SAL_FREE(mgr);
return NULL;
}
/* Prepare the default ticket key */
if (SAL_CRYPT_Rand(libCtx, mgr->ticketKeyName, sizeof(mgr->ticketKeyName)) != HITLS_SUCCESS ||
SAL_CRYPT_Rand(libCtx, mgr->ticketAesKey, sizeof(mgr->ticketAesKey)) != HITLS_SUCCESS ||
SAL_CRYPT_Rand(libCtx, mgr->ticketHmacKey, sizeof(mgr->ticketHmacKey)) != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16704, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Rand fail", 0, 0, 0, 0);
BSL_SAL_ThreadLockFree(mgr->lock);
BSL_SAL_FREE(mgr);
return NULL;
}
// Apply for a hash table from mgr->hash
ListDupFreeFuncPair keyFunc = {.dupFunc = SessKeyDupFunc, .freeFunc = SessKeyFreeFunc};
ListDupFreeFuncPair valueFunc = {.dupFunc = SessionDupFunc, .freeFunc = SessionFreeFunc};
mgr->hash = BSL_HASH_Create(SESSION_DEFAULT_HASH_BKT_SZIE,
SessKeyHashCodeCal, SessKeyHashMacth, &keyFunc, &valueFunc);
if (mgr->hash == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16705, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"HASH_Create fail", 0, 0, 0, 0);
BSL_SAL_ThreadLockFree(mgr->lock);
BSL_SAL_FREE(mgr);
return NULL;
}
#ifdef HITLS_TLS_FEATURE_SESSION
mgr->sessCacheMode = HITLS_SESS_CACHE_SERVER;
mgr->sessCacheSize = SESSION_DEFAULT_CACHE_SIZE;
#endif
mgr->sessTimeout = SESSION_DEFAULT_TIMEOUT;
mgr->references = 1;
return mgr;
}
/* Copy the number of references. The number of references increases by 1 */
TLS_SessionMgr *SESSMGR_Dup(TLS_SessionMgr *mgr)
{
if (mgr == NULL) {
return NULL;
}
BSL_SAL_ThreadWriteLock(mgr->lock);
mgr->references++;
BSL_SAL_ThreadUnlock(mgr->lock);
return mgr;
}
void SESSMGR_Free(TLS_SessionMgr *mgr)
{
if (mgr != NULL) {
BSL_SAL_ThreadWriteLock(mgr->lock);
mgr->references--;
if (mgr->references > 0) {
BSL_SAL_ThreadUnlock(mgr->lock);
return;
}
BSL_SAL_ThreadUnlock(mgr->lock);
// Delete all sessions
BSL_HASH_Destory(mgr->hash);
mgr->hash = NULL;
BSL_SAL_ThreadLockFree(mgr->lock);
BSL_SAL_FREE(mgr);
}
return;
}
void SESSMGR_SetTimeout(TLS_SessionMgr *mgr, uint64_t sessTimeout)
{
if (mgr != NULL) {
BSL_SAL_ThreadWriteLock(mgr->lock);
mgr->sessTimeout = sessTimeout;
BSL_SAL_ThreadUnlock(mgr->lock);
}
return;
}
uint64_t SESSMGR_GetTimeout(TLS_SessionMgr *mgr)
{
if (mgr == NULL) {
return SESSION_DEFAULT_TIMEOUT;
}
uint64_t sessTimeout;
BSL_SAL_ThreadReadLock(mgr->lock);
sessTimeout = mgr->sessTimeout;
BSL_SAL_ThreadUnlock(mgr->lock);
return sessTimeout;
}
#ifdef HITLS_TLS_FEATURE_SESSION
void SESSMGR_SetCacheMode(TLS_SessionMgr *mgr, HITLS_SESS_CACHE_MODE mode)
{
if (mgr != NULL) {
BSL_SAL_ThreadWriteLock(mgr->lock);
mgr->sessCacheMode = mode;
BSL_SAL_ThreadUnlock(mgr->lock);
}
return;
}
HITLS_SESS_CACHE_MODE SESSMGR_GetCacheMode(TLS_SessionMgr *mgr)
{
HITLS_SESS_CACHE_MODE mode;
BSL_SAL_ThreadReadLock(mgr->lock);
mode = mgr->sessCacheMode;
BSL_SAL_ThreadUnlock(mgr->lock);
return mode;
}
/* Set the maximum number of cache sessions */
void SESSMGR_SetCacheSize(TLS_SessionMgr *mgr, uint32_t sessCacheSize)
{
if (mgr != NULL) {
BSL_SAL_ThreadWriteLock(mgr->lock);
mgr->sessCacheSize = sessCacheSize;
BSL_SAL_ThreadUnlock(mgr->lock);
}
return;
}
/* Obtain the maximum number of cached sessions. Ensure that the pointer is not NULL */
uint32_t SESSMGR_GetCacheSize(TLS_SessionMgr *mgr)
{
uint32_t sessCacheSize = 0u;
BSL_SAL_ThreadReadLock(mgr->lock);
sessCacheSize = mgr->sessCacheSize;
BSL_SAL_ThreadUnlock(mgr->lock);
return sessCacheSize;
}
#endif
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
void SESSMGR_InsertSession(TLS_SessionMgr *mgr, HITLS_Session *sess, bool isClient)
{
if (mgr == NULL || sess == NULL) {
return;
}
BSL_SAL_ThreadReadLock(mgr->lock);
HITLS_SESS_CACHE_MODE mode = mgr->sessCacheMode;
BSL_SAL_ThreadUnlock(mgr->lock);
SessionKey key = {0};
key.sessionIdSize = sizeof(key.sessionId);
if (HITLS_SESS_GetSessionId(sess, key.sessionId, &(key.sessionIdSize)) != HITLS_SUCCESS) {
return;
}
if (key.sessionIdSize == 0) {
return;
}
if (mode == HITLS_SESS_CACHE_NO) {
return;
}
if (isClient == true && mode == HITLS_SESS_CACHE_SERVER) {
return;
}
if (isClient == false && mode == HITLS_SESS_CACHE_CLIENT) {
return;
}
BSL_SAL_ThreadWriteLock(mgr->lock);
if (BSL_HASH_Size(mgr->hash) < mgr->sessCacheSize) {
/* Insert a session node */
BSL_HASH_Insert(mgr->hash, (uintptr_t)&key, sizeof(key), (uintptr_t)sess, 0);
} else {
BSL_LOG_BINLOG_FIXLEN(
BINLOG_ID15305, BSL_LOG_LEVEL_WARN, BSL_LOG_BINLOG_TYPE_RUN, "over sess cache size", 0, 0, 0, 0);
}
BSL_SAL_ThreadUnlock(mgr->lock);
return;
}
#endif /* #if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12) */
#ifdef HITLS_TLS_FEATURE_SESSION_ID
/* Find the matching session */
HITLS_Session *SESSMGR_Find(TLS_SessionMgr *mgr, uint8_t *sessionId, uint8_t sessionIdSize)
{
if (mgr == NULL || sessionId == NULL || sessionIdSize == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16706, BSL_LOG_LEVEL_WARN, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
return NULL;
}
BSL_SAL_ThreadReadLock(mgr->lock);
HITLS_Session *sess = NULL;
SessionKey key = {0};
key.sessionIdSize = sessionIdSize;
if (memcpy_s(key.sessionId, sizeof(key.sessionId), sessionId, sessionIdSize) == EOK) {
// Query the session corresponding to the key
if (BSL_HASH_At(mgr->hash, (uintptr_t)&key, (uintptr_t *)&sess) != BSL_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(
BINLOG_ID15353, BSL_LOG_LEVEL_DEBUG, BSL_LOG_BINLOG_TYPE_RUN, "not find sess", 0, 0, 0, 0);
sess = NULL;
goto EXIT;
}
}
uint64_t curTime = (uint64_t)BSL_SAL_CurrentSysTimeGet();
/* Check whether the validity is valid */
if (SESS_CheckValidity(sess, curTime) == false) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16707, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN, "sess time out", 0, 0, 0, 0);
sess = NULL;
}
EXIT:
BSL_SAL_ThreadUnlock(mgr->lock);
return sess;
}
#endif /* HITLS_TLS_FEATURE_SESSION_ID */
/* Search for the matched session without checking the validity of the session */
bool SESSMGR_HasMacthSessionId(TLS_SessionMgr *mgr, uint8_t *sessionId, uint8_t sessionIdSize)
{
if (mgr == NULL || sessionId == NULL || sessionIdSize == 0) {
return false;
}
HITLS_Session *sess = NULL;
BSL_SAL_ThreadReadLock(mgr->lock);
SessionKey key = {0};
key.sessionIdSize = sessionIdSize;
if (memcpy_s(key.sessionId, sizeof(key.sessionId), sessionId, sessionIdSize) == EOK) {
// Query the session corresponding to the key
BSL_HASH_At(mgr->hash, (uintptr_t)&key, (uintptr_t *)&sess);
}
BSL_SAL_ThreadUnlock(mgr->lock);
return (sess == NULL) ? false : true;
}
/* Clear timeout sessions */
void SESSMGR_ClearTimeout(TLS_SessionMgr *mgr)
{
if (mgr == NULL) {
return;
}
uint64_t curTime = (uint64_t)BSL_SAL_CurrentSysTimeGet();
BSL_SAL_ThreadWriteLock(mgr->lock);
BSL_HASH_Iterator it = BSL_HASH_IterBegin(mgr->hash);
while (it != BSL_HASH_IterEnd(mgr->hash)) {
uintptr_t ptr = BSL_HASH_IterValue(mgr->hash, it);
HITLS_Session *sess = (HITLS_Session *)ptr;
if (SESS_CheckValidity(sess, curTime) == false) {
/* Delete the node if it is invalid */
uintptr_t tmpKey = BSL_HASH_HashIterKey(mgr->hash, it);
// Returns the next iterator of the iterator where the key resides
it = BSL_HASH_Erase(mgr->hash, tmpKey);
} else {
it = BSL_HASH_IterNext(mgr->hash, it);
}
}
BSL_SAL_ThreadUnlock(mgr->lock);
return;
}
int32_t SESSMGR_GernerateSessionId(TLS_Ctx *ctx, uint8_t *sessionId, uint32_t sessionIdSize)
{
int32_t ret = 0;
int32_t retry = 0;
do {
ret = SAL_CRYPT_Rand(LIBCTX_FROM_CTX(ctx), sessionId, sessionIdSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* If duplicate session IDs already exist, generate new session ID */
if (SESSMGR_HasMacthSessionId(ctx->config.tlsConfig.sessMgr, sessionId, (uint8_t)sessionIdSize) == false) {
return HITLS_SUCCESS;
}
retry++;
} while (retry < SESSION_GERNERATE_RETRY_MAX_TIMES); // Maximum number of attempts is 10
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15961, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Gernerate server session id error.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_SESSION_ID_GENRATE);
return HITLS_SESS_ERR_SESSION_ID_GENRATE;
}
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
void SESSMGR_SetTicketKeyCb(TLS_SessionMgr *mgr, HITLS_TicketKeyCb ticketKeyCb)
{
if (mgr != NULL) {
BSL_SAL_ThreadWriteLock(mgr->lock);
mgr->ticketKeyCb = ticketKeyCb;
BSL_SAL_ThreadUnlock(mgr->lock);
}
return;
}
HITLS_TicketKeyCb SESSMGR_GetTicketKeyCb(TLS_SessionMgr *mgr)
{
if (mgr == NULL) {
return NULL;
}
HITLS_TicketKeyCb ticketKeyCb;
BSL_SAL_ThreadReadLock(mgr->lock);
ticketKeyCb = mgr->ticketKeyCb;
BSL_SAL_ThreadUnlock(mgr->lock);
return ticketKeyCb;
}
int32_t SESSMGR_GetTicketKey(const TLS_SessionMgr *mgr, uint8_t *key, uint32_t keySize, uint32_t *outSize)
{
if (mgr == NULL || key == NULL || outSize == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16708, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadReadLock(mgr->lock);
uint32_t offset = 0;
if (memcpy_s(key, keySize, mgr->ticketKeyName, HITLS_TICKET_KEY_NAME_SIZE) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16709, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
BSL_SAL_ThreadUnlock(mgr->lock);
return HITLS_MEMCPY_FAIL;
}
offset += HITLS_TICKET_KEY_NAME_SIZE;
if (memcpy_s(&key[offset], keySize - offset, mgr->ticketAesKey, HITLS_TICKET_KEY_SIZE) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16710, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
BSL_SAL_ThreadUnlock(mgr->lock);
return HITLS_MEMCPY_FAIL;
}
offset += HITLS_TICKET_KEY_SIZE;
if (memcpy_s(&key[offset], keySize - offset, mgr->ticketHmacKey, HITLS_TICKET_KEY_SIZE) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16711, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
BSL_SAL_ThreadUnlock(mgr->lock);
return HITLS_MEMCPY_FAIL;
}
offset += HITLS_TICKET_KEY_SIZE;
*outSize = offset;
BSL_SAL_ThreadUnlock(mgr->lock);
return HITLS_SUCCESS;
}
int32_t SESSMGR_SetTicketKey(TLS_SessionMgr *mgr, const uint8_t *key, uint32_t keySize)
{
if (mgr == NULL || key == NULL ||
(keySize != HITLS_TICKET_KEY_NAME_SIZE + HITLS_TICKET_KEY_SIZE + HITLS_TICKET_KEY_SIZE)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16712, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
BSL_SAL_ThreadWriteLock(mgr->lock);
uint32_t offset = 0;
(void)memcpy_s(mgr->ticketKeyName, HITLS_TICKET_KEY_NAME_SIZE, key, HITLS_TICKET_KEY_NAME_SIZE);
offset += HITLS_TICKET_KEY_NAME_SIZE;
(void)memcpy_s(mgr->ticketAesKey, HITLS_TICKET_KEY_SIZE, &key[offset], HITLS_TICKET_KEY_SIZE);
offset += HITLS_TICKET_KEY_SIZE;
(void)memcpy_s(mgr->ticketHmacKey, HITLS_TICKET_KEY_SIZE, &key[offset], HITLS_TICKET_KEY_SIZE);
BSL_SAL_ThreadUnlock(mgr->lock);
return HITLS_SUCCESS;
}
#endif /* #ifdef HITLS_TLS_FEATURE_SESSION_TICKET */
#endif /* HITLS_TLS_FEATURE_SESSION */ | 2302_82127028/openHiTLS-examples_1508 | tls/feature/session/src/session_mgr.c | C | unknown | 15,458 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
#include <stdbool.h>
#include <string.h>
#include "securec.h"
#include "tlv.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "bsl_bytes.h"
#include "bsl_sal.h"
#include "crypt.h"
#include "hitls_error.h"
#include "session_type.h"
#include "session_enc.h"
typedef struct {
uint8_t keyName[HITLS_TICKET_KEY_NAME_SIZE];
uint8_t iv[HITLS_TICKET_IV_SIZE];
uint32_t encryptedStateSize;
uint8_t *encryptedState;
uint8_t mac[HITLS_TICKET_KEY_SIZE];
} Ticket;
#define DEFAULT_SESSION_ENCRYPT_TYPE HITLS_AEAD_CIPHER
#define DEFAULT_SESSION_ENCRYPT_ALGO HITLS_CIPHER_AES_256_GCM
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
#define AES_CBC_BLOCK_LEN 16u
#endif
static void SetCipherInfo(const TLS_SessionMgr *sessMgr, Ticket *ticket, HITLS_CipherParameters *cipher)
{
cipher->type = DEFAULT_SESSION_ENCRYPT_TYPE;
cipher->algo = DEFAULT_SESSION_ENCRYPT_ALGO;
cipher->key = sessMgr->ticketAesKey;
cipher->keyLen = HITLS_TICKET_KEY_SIZE;
cipher->iv = ticket->iv;
cipher->ivLen = HITLS_TICKET_IV_SIZE;
cipher->aad = ticket->iv;
cipher->aadLen = HITLS_TICKET_IV_SIZE;
return;
}
static int32_t GetSessEncryptInfo(TLS_Ctx *ctx, const TLS_SessionMgr *sessMgr, Ticket *ticket, HITLS_CipherParameters *cipher)
{
int32_t ret;
#ifdef HITLS_TLS_FEATURE_SESSION
HITLS_TicketKeyCb cb = sessMgr->ticketKeyCb;
if (cb != NULL) {
ret = cb(ticket->keyName, HITLS_TICKET_KEY_NAME_SIZE, cipher, true);
if (memcpy_s(ticket->iv, HITLS_TICKET_IV_SIZE, cipher->iv, cipher->ivLen) != EOK) {
BSL_ERR_PUSH_ERROR(HITLS_TICKET_KEY_RET_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16069, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"iv copy fail when GetSessEncryptInfo.", 0, 0, 0, 0);
return HITLS_TICKET_KEY_RET_FAIL;
}
return ret;
}
#endif
/* The user does not register the callback. The default ticket key is used. */
(void)memcpy_s(ticket->keyName, HITLS_TICKET_KEY_NAME_SIZE, sessMgr->ticketKeyName, HITLS_TICKET_KEY_NAME_SIZE);
ret = SAL_CRYPT_Rand(LIBCTX_FROM_CTX(ctx), ticket->iv, HITLS_TICKET_IV_SIZE);
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_TICKET_KEY_RET_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16021, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Rand fail", 0, 0, 0, 0);
return HITLS_TICKET_KEY_RET_FAIL;
}
SetCipherInfo(sessMgr, ticket, cipher);
return HITLS_TICKET_KEY_RET_SUCCESS;
}
static int32_t PackKeyNameAndIv(const Ticket *ticket, uint8_t *data, uint32_t len, uint32_t *usedLen)
{
uint32_t offset = 0;
if (memcpy_s(&data[0], len, ticket->keyName, HITLS_TICKET_KEY_NAME_SIZE) != EOK) {
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16022, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"copy keyName fail when encrypt session ticket.", 0, 0, 0, 0);
return HITLS_MEMCPY_FAIL;
}
offset += HITLS_TICKET_KEY_NAME_SIZE;
if (memcpy_s(&data[offset], len - offset, ticket->iv, HITLS_TICKET_IV_SIZE) != EOK) {
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16023, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"copy iv fail when encrypt session ticket.", 0, 0, 0, 0);
return HITLS_MEMCPY_FAIL;
}
offset += HITLS_TICKET_IV_SIZE;
*usedLen = offset;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
static uint32_t GetCbcPendingLen(uint32_t encodeLen, uint8_t *paddingLen)
{
*paddingLen = (encodeLen + sizeof(uint8_t)) % AES_CBC_BLOCK_LEN;
if (*paddingLen != 0) {
*paddingLen = AES_CBC_BLOCK_LEN - *paddingLen;
}
return *paddingLen + sizeof(uint8_t);
}
#endif
static int32_t PackEncryptTicket(HITLS_Lib_Ctx *libCtx, const char *attrName,
const HITLS_Session *sess, HITLS_CipherParameters *cipher, uint8_t *data, uint32_t len, uint32_t *usedLen)
{
int32_t ret = 0;
/* Encode the session. */
uint32_t encodeLen = SESS_GetTotalEncodeSize(sess);
uint32_t plaintextLen = encodeLen;
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
uint8_t paddingLen = 0;
if (cipher->type == HITLS_CBC_CIPHER) {
/* In CBC mode, the padding needs to be calculated. */
/* Plain text length plus padding length */
plaintextLen += GetCbcPendingLen(encodeLen, &paddingLen);
}
#endif
uint8_t *plaintext = BSL_SAL_Calloc(1u, plaintextLen);
if (plaintext == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16024, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encData malloc fail when encrypt session ticket.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
ret = SESS_Encode(sess, plaintext, plaintextLen, &plaintextLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_CleanseData(plaintext, plaintextLen);
BSL_SAL_FREE(plaintext);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16025, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SESS_Encode fail when encrypt session ticket.", 0, 0, 0, 0);
return ret;
}
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
/* Padding is required in CBC mode. */
if (cipher->type == HITLS_CBC_CIPHER) {
/* The last byte is the padding length field, and the padding content is the length value. */
uint32_t count = paddingLen + sizeof(uint8_t);
/* The calculation is accurate when the memory is applied for the plaintext. Therefore, the
* return value does not need to be checked. */
(void)memset_s(&plaintext[encodeLen], count, paddingLen, count);
plaintextLen += count;
}
#endif
uint32_t offset = 0;
/* reserved length field */
offset += sizeof(uint32_t);
/* Encrypt and fill the ticket. */
uint32_t encryptLen = len - offset;
ret = SAL_CRYPT_Encrypt(libCtx, attrName, cipher, plaintext, plaintextLen, &data[offset], &encryptLen);
BSL_SAL_CleanseData(plaintext, plaintextLen);
BSL_SAL_FREE(plaintext);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16026, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SAL_CRYPT_Encrypt fail when encrypt session ticket.", 0, 0, 0, 0);
return ret;
}
/* padding length */
BSL_Uint32ToByte(encryptLen, &data[offset - sizeof(uint32_t)]);
offset += encryptLen;
*usedLen = offset;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
static int32_t PackTicketHmac(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_CipherParameters *cipher, uint8_t *data, uint32_t len, uint32_t offset,
uint32_t *usedLen)
{
/* The HMAC field is filled only in CBC mode. In other modes, the HMAC field is returned. */
if (cipher->type != HITLS_CBC_CIPHER) {
*usedLen = 0;
return HITLS_SUCCESS;
}
int32_t ret;
uint8_t mac[HITLS_TICKET_KEY_SIZE] = {0};
uint32_t macLen = HITLS_TICKET_KEY_SIZE;
ret = SAL_CRYPT_Hmac(libCtx, attrName,
HITLS_HASH_SHA_256, cipher->hmacKey, cipher->hmacKeyLen, data, offset, mac, &macLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16027, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"TicketHmac fail when encrypt session ticket.", 0, 0, 0, 0);
return ret;
}
if (memcpy_s(&data[offset], len - offset, mac, macLen) != EOK) {
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16028, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"copy mac fail when encrypt session ticket.", 0, 0, 0, 0);
return HITLS_MEMCPY_FAIL;
}
*usedLen = macLen;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_SUITE_CIPHER_CBC */
static uint8_t *NewTicketBuf(const HITLS_Session *sess, HITLS_CipherParameters *cipher, uint32_t *ticketBufSize)
{
(void)cipher;
uint32_t encodeLen = SESS_GetTotalEncodeSize(sess);
uint32_t plaintextLen = encodeLen;
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
if (cipher->type == HITLS_CBC_CIPHER) {
/* In CBC mode, the padding needs to be calculated. */
uint8_t paddingLen = (encodeLen + sizeof(uint8_t)) % AES_CBC_BLOCK_LEN;
if (paddingLen != 0) {
paddingLen = AES_CBC_BLOCK_LEN - paddingLen;
}
/* Plain text length plus padding length */
plaintextLen += paddingLen + sizeof(uint8_t);
}
#endif
/* Plain text length plus key name, iv, encrypted data length, and MAC length. */
plaintextLen += HITLS_TICKET_KEY_NAME_SIZE + HITLS_TICKET_IV_SIZE + sizeof(uint32_t) + HITLS_TICKET_KEY_SIZE;
uint8_t *ticketBuf = BSL_SAL_Calloc(1u, plaintextLen);
if (ticketBuf == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16029, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ticketBuf malloc fail when encrypt session ticket.", 0, 0, 0, 0);
return NULL;
}
*ticketBufSize = plaintextLen;
return ticketBuf;
}
int32_t SESSMGR_EncryptSessionTicket(TLS_Ctx *ctx,
const TLS_SessionMgr *sessMgr, const HITLS_Session *sess, uint8_t **ticketBuf, uint32_t *ticketBufSize)
{
if (sessMgr == NULL || sess == NULL || ticketBuf == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16713, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
Ticket ticket = {0};
HITLS_CipherParameters cipher = {0};
int32_t retVal = GetSessEncryptInfo(ctx, sessMgr, &ticket, &cipher);
if (retVal < 0) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_SESSION_TICKET_KEY_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16030, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GetSessEncryptInfo fail when encrypt session ticket.", 0, 0, 0, 0);
return HITLS_SESS_ERR_SESSION_TICKET_KEY_FAIL;
}
if (retVal == HITLS_TICKET_KEY_RET_FAIL) {
/* Failed to obtain the encryption information. An empty ticket is returned. */
*ticketBufSize = 0;
return HITLS_SUCCESS;
}
uint32_t dataLen = 0;
uint8_t *data = NewTicketBuf(sess, &cipher, &dataLen);
if (data == NULL) {
return HITLS_MEMALLOC_FAIL;
}
/* Fill in the key name and iv. */
int32_t ret;
uint32_t packLen = 0;
uint32_t offset = 0;
ret = PackKeyNameAndIv(&ticket, &data[0], dataLen, &packLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(data);
return ret;
}
offset += packLen;
/* Encrypt and fill the ticket. */
ret = PackEncryptTicket(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
sess, &cipher, &data[offset], dataLen - offset, &packLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(data);
return ret;
}
offset += packLen;
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
/* fill HMAC */
ret = PackTicketHmac(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
&cipher, data, dataLen, offset, &packLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(data);
return ret;
}
offset += packLen;
#endif
*ticketBufSize = offset;
*ticketBuf = data;
return HITLS_SUCCESS;
}
static int32_t ParseSessionTicket(Ticket *ticket, const uint8_t *ticketBuf, uint32_t ticketBufSize)
{
uint32_t offset = 0;
if (ticketBufSize < HITLS_TICKET_KEY_NAME_SIZE + HITLS_TICKET_IV_SIZE + sizeof(uint32_t)) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_SESSION_TICKET_SIZE_INCORRECT);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16044, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ticketBufSize is incorrect when parse session ticket.", 0, 0, 0, 0);
return HITLS_SESS_ERR_SESSION_TICKET_SIZE_INCORRECT;
}
(void)memcpy_s(ticket->keyName, HITLS_TICKET_KEY_NAME_SIZE, ticketBuf, HITLS_TICKET_KEY_NAME_SIZE);
offset += HITLS_TICKET_KEY_NAME_SIZE;
(void)memcpy_s(ticket->iv, HITLS_TICKET_IV_SIZE, &ticketBuf[offset], HITLS_TICKET_IV_SIZE);
offset += HITLS_TICKET_IV_SIZE;
ticket->encryptedStateSize = BSL_ByteToUint32(&ticketBuf[offset]);
offset += sizeof(uint32_t);
if ((ticketBufSize - offset) < ticket->encryptedStateSize) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_SESSION_TICKET_SIZE_INCORRECT);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16032, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ticketBufSize is incorrect when parse session ticket encryptedStateSize.", 0, 0, 0, 0);
return HITLS_SESS_ERR_SESSION_TICKET_SIZE_INCORRECT;
}
ticket->encryptedState = (uint8_t *)(uintptr_t)&ticketBuf[offset];
offset += ticket->encryptedStateSize;
if (ticketBufSize != offset) {
if ((ticketBufSize - offset) != HITLS_TICKET_KEY_SIZE) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_SESSION_TICKET_SIZE_INCORRECT);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16033, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ticketBufSize is incorrect when parse session ticket hmac.", 0, 0, 0, 0);
return HITLS_SESS_ERR_SESSION_TICKET_SIZE_INCORRECT;
}
(void)memcpy_s(ticket->mac, HITLS_TICKET_KEY_SIZE, &ticketBuf[offset], HITLS_TICKET_KEY_SIZE);
}
return HITLS_SUCCESS;
}
static int32_t GetSessDecryptInfo(const TLS_SessionMgr *sessMgr, Ticket *ticket, HITLS_CipherParameters *cipher)
{
#ifdef HITLS_TLS_FEATURE_SESSION
HITLS_TicketKeyCb cb = sessMgr->ticketKeyCb;
if (cb != NULL) {
return cb(ticket->keyName, HITLS_TICKET_KEY_NAME_SIZE, cipher, false);
}
#endif
/* The user does not register the callback. Use the default ticket key. */
if (memcmp(ticket->keyName, sessMgr->ticketKeyName, HITLS_TICKET_KEY_NAME_SIZE) != 0) {
/* Failed to match the key name. */
return HITLS_TICKET_KEY_RET_FAIL;
}
SetCipherInfo(sessMgr, ticket, cipher);
return HITLS_TICKET_KEY_RET_SUCCESS;
}
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
static int32_t CheckTicketHmac(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_CipherParameters *cipher, Ticket *ticket, const uint8_t *data, uint32_t len, bool *isPass)
{
/* The HMAC check is required only in CBC mode. In other modes, the HMAC check is returned. */
if (cipher->type != HITLS_CBC_CIPHER) {
*isPass = true;
return HITLS_SUCCESS;
}
int32_t ret;
uint8_t mac[HITLS_TICKET_KEY_SIZE] = {0};
uint32_t macLen = HITLS_TICKET_KEY_SIZE;
ret = SAL_CRYPT_Hmac(libCtx, attrName,
HITLS_HASH_SHA_256, cipher->hmacKey, cipher->hmacKeyLen, data, len - HITLS_TICKET_KEY_SIZE, mac, &macLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16035, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"TicketHmac fail when decrypt session ticket.", 0, 0, 0, 0);
return ret;
}
if (memcmp(ticket->mac, mac, macLen) != 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16036, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"compare mac fail when decrypt session ticket.", 0, 0, 0, 0);
/* The HMAC check fails, but the complete link establishment can be continued. Therefore, HITLS_SUCCESS is
* returned. */
*isPass = false;
return HITLS_SUCCESS;
}
*isPass = true;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_SUITE_CIPHER_CBC */
static int32_t GenerateSessFromTicket(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_CipherParameters *cipher, Ticket *ticket, uint32_t ticketBufSize, HITLS_Session **sess)
{
/* Decrypt the ticket. */
uint32_t plaintextLen = ticketBufSize;
uint8_t *plaintext = BSL_SAL_Calloc(1u, ticketBufSize);
if (plaintext == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16037, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"plaintext malloc fail when decrypt session ticket.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
int32_t ret;
ret = SAL_CRYPT_Decrypt(libCtx, attrName,
cipher, ticket->encryptedState, ticket->encryptedStateSize, plaintext, &plaintextLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(plaintext);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16038, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"SAL_CRYPT_Decrypt fail when decrypt session ticket.", 0, 0, 0, 0);
/* The ticket fails to be decrypted, but the complete connection can be established. Therefore, HITLS_SUCCESS is
* returned. */
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
/* Padding needs to be verified in CBC mode. */
if (cipher->type == HITLS_CBC_CIPHER) {
/* The last byte is the padding length field, and the padding content is the length value. */
uint8_t paddingLen = plaintext[plaintextLen - 1];
for (uint32_t i = 1; i <= paddingLen; i++) {
if (plaintext[plaintextLen - 1 - i] != paddingLen) {
BSL_SAL_FREE(plaintext);
return HITLS_SUCCESS;
}
}
plaintextLen -= paddingLen + sizeof(uint8_t);
}
#endif
/* Parse the ticket content to the SESS. */
HITLS_Session *session = HITLS_SESS_New();
if (session == NULL) {
BSL_SAL_FREE(plaintext);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16039, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"HITLS_SESS_New fail when decrypt session ticket.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
ret = SESS_Decode(session, plaintext, plaintextLen);
BSL_SAL_FREE(plaintext);
if (ret != HITLS_SUCCESS) {
HITLS_SESS_Free(session);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16040, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"SESS_Decode fail when decrypt session ticket.", 0, 0, 0, 0);
/* The ticket content fails to be parsed, but the complete connection can be established. Therefore,
* HITLS_SUCCESS is returned. */
return HITLS_SUCCESS;
}
*sess = session;
return HITLS_SUCCESS;
}
int32_t SESSMGR_DecryptSessionTicket(HITLS_Lib_Ctx *libCtx, const char *attrName,
const TLS_SessionMgr *sessMgr, HITLS_Session **sess, const uint8_t *ticketBuf,
uint32_t ticketBufSize, bool *isTicketExpect)
{
if (sessMgr == NULL || sess == NULL || ticketBuf == NULL || isTicketExpect == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16041, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SESSMGR_DecryptSessionTicket input parameter is NULL.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
int32_t ret;
Ticket ticket = {0};
/* Parse the data into the ticket structure. */
ret = ParseSessionTicket(&ticket, ticketBuf, ticketBufSize);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16042, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"ParseSessionTicket fail when decrypt session ticket.", 0, 0, 0, 0);
/* If the ticket fails to be parsed, the session is not resumption and the complete connection is established.
* Therefore, HITLS_SUCCESS is returned. */
*isTicketExpect = true;
return HITLS_SUCCESS;
}
/* Obtain decryption information. */
HITLS_CipherParameters cipher = {0};
int32_t retVal = GetSessDecryptInfo(sessMgr, &ticket, &cipher);
if (retVal < 0) {
BSL_ERR_PUSH_ERROR(HITLS_SESS_ERR_SESSION_TICKET_KEY_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16043, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GetSessDecryptInfo fail when decrypt session ticket.", 0, 0, 0, 0);
return HITLS_SESS_ERR_SESSION_TICKET_KEY_FAIL;
}
switch (retVal) {
case HITLS_TICKET_KEY_RET_FAIL:
/* If no corresponding key is found, the system directly returns a message and complete link establishment
* is performed. */
*isTicketExpect = true;
return HITLS_SUCCESS;
case HITLS_TICKET_KEY_RET_SUCCESS_RENEW:
*isTicketExpect = true;
break;
case HITLS_TICKET_KEY_RET_SUCCESS:
default:
*isTicketExpect = false;
break;
}
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
/* Verify the MAC address. */
bool isPass = true;
ret = CheckTicketHmac(libCtx, attrName, &cipher, &ticket, ticketBuf, ticketBufSize, &isPass);
if ((ret != HITLS_SUCCESS) || (!isPass)) {
/* If the HMAC check fails, the session is not restored and complete link establishment is performed. */
return ret;
}
#endif
/* Parse the ticket content to the SESS. */
return GenerateSessFromTicket(libCtx, attrName, &cipher, &ticket, ticketBufSize, sess);
}
#endif /* HITLS_TLS_FEATURE_SESSION_TICKET */ | 2302_82127028/openHiTLS-examples_1508 | tls/feature/session/src/session_ticket.c | C | unknown | 21,311 |
/*
* 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 SESSION_TYPE_H
#define SESSION_TYPE_H
#include <stdbool.h>
#include <stdint.h>
#include "hitls_type.h"
#include "hitls_session.h"
#include "tls_config.h"
#include "cert.h"
#include "session.h"
#ifdef __cplusplus
extern "C" {
#endif
struct TlsSessionManager {
void *lock; /* Thread lock */
int32_t references; /* Reference times */
void *hash; /* hash table */
uint64_t sessTimeout; /* Session timeout interval, in seconds */
#ifdef HITLS_TLS_FEATURE_SESSION
uint32_t sessCacheSize; /* session cache size: maximum number of sessions */
HITLS_SESS_CACHE_MODE sessCacheMode; /* session cache mode */
/* TLS1.2 session ticket */
HITLS_TicketKeyCb ticketKeyCb; /* allows users to customize ticket keys through callback */
#endif
/* key_name: is used to identify a specific set of keys used to protect tickets */
uint8_t ticketKeyName[HITLS_TICKET_KEY_NAME_SIZE];
uint8_t ticketAesKey[HITLS_TICKET_KEY_SIZE]; /* aes key */
uint8_t ticketHmacKey[HITLS_TICKET_KEY_SIZE]; /* hmac key */
};
struct TlsSessCtx {
void *lock; /* Thread lock */
/* certificate management context. The certificate interface depends on this field */
CERT_MgrCtx *certMgrCtx;
int32_t references; /* Reference times */
bool enable; /* Whether to enable the session */
bool haveExtMasterSecret; /* Whether an extended master key exists */
bool reserved[2]; /* Four-byte alignment */
uint64_t startTime; /* Start time */
uint64_t timeout; /* Timeout interval */
#ifdef HITLS_TLS_FEATURE_SNI
uint32_t hostNameSize; /* Length of the host name */
uint8_t *hostName; /* Host name */
#endif
uint32_t sessionIdCtxSize; /* Session ID Context Length */
uint8_t sessionIdCtx[HITLS_SESSION_ID_CTX_MAX_SIZE]; /* Session ID Context */
uint32_t sessionIdSize; /* Session ID length */
uint8_t sessionId[HITLS_SESSION_ID_MAX_SIZE]; /* session ID */
int32_t verifyResult; /* Authentication result */
CERT_Pair *peerCert; /* Peer certificate */
uint16_t version; /* Version */
uint16_t cipherSuite; /* Cipher suite */
uint32_t masterKeySize; /* length of the master key */
uint8_t masterKey[MAX_MASTER_KEY_SIZE]; /* Master Key */
uint32_t ticketSize; /* Session ticket length */
uint8_t *ticket; /* Session ticket */
uint32_t ticketLifetime; /* Timeout interval of the ticket */
uint32_t ticketAgeAdd; /* A random number generated each time a ticket is issued */
void *userData;
};
#define LIBCTX_FROM_SESSION_CTX(sessCtx) (sessCtx == NULL) ? NULL : ((sessCtx)->certMgrCtx == NULL ? NULL : (sessCtx)->certMgrCtx->libCtx)
#define ATTRIBUTE_FROM_SESSION_CTX(sessCtx) (sessCtx == NULL) ? NULL : ((sessCtx)->certMgrCtx == NULL ? NULL : (sessCtx)->certMgrCtx->attrName)
#ifdef __cplusplus
}
#endif
#endif
| 2302_82127028/openHiTLS-examples_1508 | tls/feature/session/src/session_type.h | C | unknown | 4,274 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_SNI
#include <ctype.h>
#include <stdint.h>
#include <string.h>
#include "securec.h"
#include "hitls_error.h"
#include "hitls_config.h"
#include "hitls_sni.h"
#include "session.h"
#include "tls_binlog_id.h"
#include "tls.h"
#include "hs.h"
#include "sni.h"
const char *HITLS_GetServerName(const HITLS_Ctx *ctx, const int type)
{
if (ctx == NULL || type != HITLS_SNI_HOSTNAME_TYPE) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16756, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
return NULL;
}
bool isClient = ctx->isClient;
bool isResume = ctx->negotiatedInfo.isResume;
uint16_t version = ctx->config.tlsConfig.maxVersion;
uint8_t *hostName = NULL;
uint32_t nameSize = 0u;
SESS_GetHostName(ctx->session, &nameSize, &hostName);
if (!isClient) {
/* Before Handshake */
if (ctx->state == CM_STATE_IDLE) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16757, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ctx->state is CM_STATE_IDLE", 0, 0, 0, 0);
return NULL;
}
/* During or after handshake */
/* TLS protocol version < TLS1.3 session resumption */
if ((version < HITLS_VERSION_TLS13 || version == HITLS_VERSION_DTLS12) && isResume && ctx->session != NULL) {
return (char *)hostName;
}
} else {
/* Before Handshake */
if (ctx->state == CM_STATE_IDLE) {
/* resume the session */
if (ctx->config.tlsConfig.serverName == NULL && ctx->session != NULL &&
(version < HITLS_VERSION_TLS13 || version == HITLS_VERSION_DTLS12)) {
return (char *)hostName;
}
/* resume non-session */
return (char *)ctx->config.tlsConfig.serverName;
} else {
/* During or after handshake */
/* resume the session */
if (ctx->session != NULL && (version < HITLS_VERSION_TLS13 || version == HITLS_VERSION_DTLS12)) {
return (char *)hostName;
}
/* resume non-session */
return (char *)ctx->config.tlsConfig.serverName;
}
}
return HS_GetServerName(ctx);
}
int32_t HITLS_GetServernameType(const HITLS_Ctx *ctx)
{
int32_t ret = -1;
if (HITLS_GetServerName(ctx, HITLS_SNI_HOSTNAME_TYPE) != NULL) {
return HITLS_SNI_HOSTNAME_TYPE;
}
return ret;
}
/* Check whether the host names are the same */
int32_t SNI_StrcaseCmp(const char *s1, const char *s2)
{
int32_t ret = -1;
if (s1 == NULL && s2 == NULL) {
return 0;
}
if (s1 == NULL || s2 == NULL) {
return ret;
}
const char *a = s1;
const char *b = s2;
int32_t len1 = (int32_t)strlen(s1);
int32_t len2 = (int32_t)strlen(s2);
if (len1 != len2) {
return ret;
}
while (tolower((int32_t)*a) == tolower((int32_t)*b)) {
if (*a == '\0') {
return 0;
}
a++;
b++;
}
return ret;
}
#endif /* HITLS_TLS_FEATURE_SNI */ | 2302_82127028/openHiTLS-examples_1508 | tls/feature/sni/src/sni.c | C | unknown | 3,641 |
/*
* 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 HS_COMMON_H
#define HS_COMMON_H
#include <stdint.h>
#include "tls.h"
#include "hs_ctx.h"
#include "hs_msg.h"
#ifdef __cplusplus
extern "C" {
#endif
#define MAX_CERT_TYPE_LISTS_SIZE 256 /* Maximum length of the certificate type list */
#define HS_DOWNGRADE_RANDOM_SIZE 8u /* downgrade protection random number field */
#define HITLS_CLIENT_HELLO_MAX_SIZE 131396
#define HITLS_SERVER_HELLO_MAX_SIZE 65607
#define HITLS_HELLO_VERIFY_REQUEST_MAX_SIZE 258
#define HITLS_END_OF_EARLY_DATA_MAX_SIZE 0
#define HITLS_HELLO_RETRY_REQUEST_MAX_SIZE 20000
#define HITLS_ENCRYPTED_EXTENSIONS_MAX_SIZE 20000
#define HITLS_SESSION_TICKET_MAX_SIZE_TLS13 131338
#define HITLS_SESSION_TICKET_MAX_SIZE_TLS12 65541
#define HITLS_SERVER_KEY_EXCH_MAX_SIZE 102400
#define HITLS_SERVER_HELLO_DONE_MAX_SIZE 0
#define HITLS_KEY_UPDATE_MAX_SIZE 1
#define HITLS_CLIENT_KEY_EXCH_MAX_SIZE 2048
#define HITLS_NEXT_PROTO_MAX_SIZE 514
#define HITLS_FINISHED_MAX_SIZE 64
#define HITLS_HELLO_REQUEST_MAX_SIZE 0
/**
* @brief Obtain the random number of the hello retry request.
*
* @param len [OUT] Length of the returned array
*
* @return Random number array
*/
const uint8_t *HS_GetHrrRandom(uint32_t *len);
const uint8_t *HS_GetTls12DowngradeRandom(uint32_t *len);
/**
* @brief Obtains the type string of the handshake message.
*
* @param type [IN] Handshake Message Type
*
* @return Character string corresponding to the handshake message type.
*/
const char *HS_GetMsgTypeStr(HS_MsgType type);
/**
* @brief Obtain the type character string of the handshake message.
*
* @param type [IN] Handshake message type.
*
* @return Character string corresponding to the handshake message type.
*/
int32_t HS_ChangeState(TLS_Ctx *ctx, uint32_t nextState);
/**
* @brief Combine two random numbers.
*
* @param random1 [IN] Random number 1
* @param random2 [IN] Random number 2
* @param randomSize [IN] Random number length
* @param dest [OUT] Destination memory address
* @param destSize [IN] Target memory length
*
* @retval HITLS_SUCCESS parsed successfully.
* @retval HITLS_MEMCPY_FAIL Memory Copy Failure
* @retval HITLS_MSG_HANDLE_RANDOM_SIZE_ERR The random number length is incorrect.
*/
int32_t HS_CombineRandom(const uint8_t *random1, const uint8_t *random2, uint32_t randomSize,
uint8_t *dest, uint32_t destSize);
/**
* @brief Obtain all signature data.
*
* @param ctx [IN] TLS context
* @param partSignData [IN] key exchange message data
* @param partSignDataLen [IN] key exchange message data length
* @param signDataLen [OUT] Length of the signature data
*
* @retval Data to be signed
*/
uint8_t *HS_PrepareSignData(const TLS_Ctx *ctx, const uint8_t *partSignData,
uint32_t partSignDataLen, uint32_t *signDataLen);
/**
* @brief Obtain the signature data required by the TLCP.
*
* @param ctx [IN] TLS context
* @param partSignData [IN] key exchange message data
* @param partSignDataLen [IN] key exchange message data length
* @param signDataLen [OUT] Length of the signature data
* @retval Data to be signed
*/
uint8_t *HS_PrepareSignDataTlcp(
const TLS_Ctx *ctx, const uint8_t *partSignData, uint32_t partSignDataLen, uint32_t *signDataLen);
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_SCTP)
/**
* @brief Set the SCTP auth key to the SCTP.
*
* @attention If the UIO_SctpAddAuthKey is added but not activated, the UIO_SctpAddAuthKey returns a success message
* when the interface is invoked again.
* @param ctx [IN] TLS context
*
* @retval HITLS_SUCCESS Operation succeeded.
* @retval HITLS_MSG_HANDLE_RANDOM_SIZE_ERR The random number length is incorrect.
* @retval For details, see UIO_SctpAddAuthKey.
*/
int32_t HS_SetSctpAuthKey(TLS_Ctx *ctx);
/**
* @brief Activate the sctp auth key.
*
* @param ctx [IN] TLS context
*
* @retval HITLS_SUCCESS operation succeeded.
* @retval For details, see UIO_SctpIsSndBuffEmpty and UIO_SctpActiveAuthKey.
*/
int32_t HS_ActiveSctpAuthKey(TLS_Ctx *ctx);
/**
* @brief Delete the previous SCTP auth key.
*
* @param ctx [IN] TLS context
*
* @retval HITLS_SUCCESS Operation succeeded.
* @retval HITLS_REC_NORMAL_IO_BUSY The underlying I/O buffer is not empty.
* @retval For details, see UIO_SctpDelPreAuthKey.
*/
int32_t HS_DeletePreviousSctpAuthKey(TLS_Ctx *ctx);
#endif /* #if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_SCTP) */
bool IsNeedServerKeyExchange(const TLS_Ctx *ctx);
bool IsPskNegotiation(const TLS_Ctx *ctx);
bool IsNeedCertPrepare(const CipherSuiteInfo *cipherSuiteInfo);
bool IsTicketSupport(const TLS_Ctx *ctx);
int32_t CheckClientPsk(TLS_Ctx *ctx);
/**
* @brief Expand the capacity of the msgBuf in the hsCtx based on the received message length.
*
* @param ctx [IN] TLS context
* @param msgSize[IN] Expected length
*
* @retval HITLS_SUCCESS Operation succeeded.
* @retval HITLS_MEMALLOC_FAIL failed to apply for memory.
*/
int32_t HS_ReSizeMsgBuf(TLS_Ctx *ctx, uint32_t msgSize);
/**
* @brief Expand the capacity of the msgBuf in the hsCtx based on the length of the received message. The upper limit of
* the capacity does not exceed upperBound bytes, And you can choose whether to retain the original data
* @param ctx [IN] TLS context
* @param msgSize[IN] Expected length
* @param keepOldData[IN] Indicates whether to retain the old data.
*
* @retval HITLS_SUCCESS Operation succeeded.
* @retval HITLS_MEMALLOC_FAIL failed to apply for memory.
* @retval HITLS_MEMCPY_FAIL Data fails to be copied.
*/
int32_t HS_GrowMsgBuf(TLS_Ctx *ctx, uint32_t msgSize, bool keepOldData);
/**
* @brief Return the maximum packet length allowed by the handshake status.
*
* @param ctx [IN] TLS context
* @param type[IN] Handshake message type
*
* @retval Maximum message length allowed
*/
uint32_t HS_MaxMessageSize(TLS_Ctx *ctx, HS_MsgType type);
/**
* @brief Obtain the Binder length.
*
* @param ctx [IN] TLS context
* @param hashAlg [IN/OUT] Hash algorithm used in the process of calculating the binder
*
* @return Binder length
*/
uint32_t HS_GetBinderLen(HITLS_Session *session, HITLS_HashAlgo* hashAlg);
/**
* @brief Check whether the current version supports this group.
*
* @param version [IN] current version
* @param group [IN] group
*
* @return true: valid; false: invalid
*/
bool GroupConformToVersion(const TLS_Ctx *ctx, uint16_t version, uint16_t group);
/**
* @brief Check whether the ciphersuite is valid
*
* @param ctx [IN] TLS context
* @param cipherSuite [IN] cipherSuite
*
* @return true: valid; false: invalid
*/
bool IsCipherSuiteAllowed(const HITLS_Ctx *ctx, uint16_t cipherSuite);
uint16_t *CheckSupportSignAlgorithms(const TLS_Ctx *ctx, const uint16_t *signAlgorithms,
uint32_t signAlgorithmsSize, uint32_t *newSignAlgorithmsSize);
uint32_t HS_GetExtensionTypeId(uint32_t hsExtensionsType);
int32_t HS_CheckReceivedExtension(HITLS_Ctx *ctx, HS_MsgType hsType, uint64_t hsMsgExtensionsMask,
uint64_t hsMsgAllowedExtensionsMask);
#ifdef __cplusplus
}
#endif
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/include/hs_common.h | C | unknown | 7,642 |
/*
* 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 HS_CTX_H
#define HS_CTX_H
#include <stdint.h>
#include "hitls_build.h"
#include "sal_time.h"
#include "hitls_cert_type.h"
#include "hitls_crypt_type.h"
#include "cert.h"
#include "crypt.h"
#include "rec.h"
#include "hs_msg.h"
#ifdef __cplusplus
extern "C" {
#endif
#define MASTER_SECRET_LEN 48u
#define HS_PSK_IDENTITY_MAX_LEN 128u /* Maximum length of PSK-negotiated identity information */
#define HS_PSK_MAX_LEN 256u
#define COOKIE_SECRET_LIFETIME 5u /* the number of times the cookie's secret is used */
#ifndef HITLS_HS_INIT_BUFFER_SIZE
#define HITLS_HS_INIT_BUFFER_SIZE 4096u
#endif
#ifndef HITLS_HS_BUFFER_SIZE_LIMIT
#define HITLS_HS_BUFFER_SIZE_LIMIT 20480u
#endif
#if HITLS_HS_INIT_BUFFER_SIZE < 32
#error "HITLS_HS_INIT_BUFFER_SIZE must be greater than or equal to 32"
#endif
#if HITLS_HS_BUFFER_SIZE_LIMIT < HITLS_HS_INIT_BUFFER_SIZE
#error "HITLS_HS_BUFFER_SIZE_LIMIT must be greater than or equal to HITLS_HS_INIT_BUFFER_SIZE"
#endif
#define UINT24_SIZE 3u
/* Transmits ECDH key exchange data */
typedef struct {
HITLS_ECParameters curveParams; /* Elliptic curve parameter */
} EcdhParam;
/* Transmits DH key exchange data */
typedef struct {
uint8_t *p; /* prime */
uint8_t *g; /* generator */
uint16_t plen; /* prime length */
uint16_t glen; /* generator length */
} DhParam;
/* Used to transfer RSA key exchange data */
typedef struct {
uint8_t preMasterSecret[MASTER_SECRET_LEN];
} RsaParam;
/* Used to transfer Ecc key exchange data */
typedef struct {
uint8_t preMasterSecret[MASTER_SECRET_LEN];
} EccParam;
typedef struct {
/* For TLS1.3 multi-key share, we try to send two key shares:
* - One for key encapsulation mechanism (KEM)
* - One for key exchange (KEX) */
HITLS_NamedGroup group; /* First group for key share */
HITLS_NamedGroup secondGroup; /* Second group for key share */
} KeyShareParam;
/**
* @ingroup hitls
*
* @brief PskInfo is used for PSK negotiation and stores identity and psk during negotiation
*/
#ifdef HITLS_TLS_FEATURE_PSK
typedef struct {
uint8_t *identity;
uint32_t identityLen;
uint8_t *psk;
uint32_t pskLen;
} PskInfo;
#endif /* HITLS_TLS_FEATURE_PSK */
#ifdef HITLS_TLS_PROTO_TLS13
typedef struct {
uint8_t *identity;
uint32_t identityLen;
HITLS_Session *pskSession;
uint8_t num;
} UserPskList;
typedef struct {
UserPskList *userPskSess; /* tls 1.3 user psk session */
HITLS_Session *resumeSession; /* tls 1.3 psk resume */
int32_t selectIndex; /* selected index */
uint8_t *psk; /* selected psk */
uint32_t pskLen;
} PskInfo13;
#endif /* HITLS_TLS_PROTO_TLS13 */
/* Used to transfer the key exchange context */
typedef struct {
HITLS_KeyExchAlgo keyExchAlgo;
union {
EcdhParam ecdh;
DhParam dh;
RsaParam rsa;
EccParam ecc; /* Sm2 parameter */
KeyShareParam share;
} keyExchParam;
HITLS_CRYPT_Key *key; /* Local key pair */
HITLS_CRYPT_Key *secondKey; /* second key pair for tls1.3 multi-key share */
uint8_t *peerPubkey; /* peer public key or peer ciphertext */
uint32_t pubKeyLen; /* peer public key length */
#ifdef HITLS_TLS_FEATURE_PSK
PskInfo *pskInfo; /* PSK data tls 1.2 */
#endif /* HITLS_TLS_FEATURE_PSK */
#ifdef HITLS_TLS_PROTO_TLS13
PskInfo13 pskInfo13; /* tls 1.3 psk */
uint8_t *ciphertext; /* local ciphertext */
uint32_t ciphertextLen; /* ciphertext length */
#endif /* HITLS_TLS_PROTO_TLS13 */
} KeyExchCtx;
/* Buffer for transmitting handshake data. */
typedef struct HsMsgCache {
uint8_t *data;
uint32_t dataSize;
struct HsMsgCache *next;
} HsMsgCache;
/* Used to transfer the handshake data verification context. */
typedef struct {
HITLS_HashAlgo hashAlgo;
HITLS_HASH_Ctx *hashCtx;
uint8_t verifyData[MAX_SIGN_SIZE];
uint32_t verifyDataSize;
HsMsgCache *dataBuf; /* handshake data buffer */
} VerifyCtx;
/* Used to pass the handshake context */
struct HsCtx {
HITLS_HandshakeState state;
HitlsProcessState readSubState;
HS_Msg *hsMsg;
ExtensionFlag extFlag;
#ifdef HITLS_TLS_PROTO_TLS13
HITLS_HandshakeState ccsNextState;
bool haveHrr; /* Whether the hello retry request has been processed */
#endif
bool isNeedClientCert;
#if defined(HITLS_TLS_FEATURE_SESSION) || defined(HITLS_TLS_PROTO_TLS13)
uint32_t sessionIdSize;
uint8_t *sessionId;
#endif
uint8_t *clientRandom;
uint8_t *serverRandom;
#ifdef HITLS_TLS_PROTO_TLS13
uint8_t earlySecret[MAX_DIGEST_SIZE];
uint8_t handshakeSecret[MAX_DIGEST_SIZE];
#endif
uint8_t masterKey[MAX_DIGEST_SIZE];
CERT_Pair *peerCert;
#ifdef HITLS_TLS_FEATURE_ALPN
uint8_t *clientAlpnList;
uint32_t clientAlpnListSize;
#endif
#ifdef HITLS_TLS_FEATURE_SNI
uint8_t *serverName;
uint32_t serverNameSize;
#endif
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
uint32_t ticketSize;
uint8_t *ticket;
uint32_t ticketLifetimeHint; /* ticket timeout interval, in seconds */
#ifdef HITLS_TLS_PROTO_TLS13
uint32_t ticketAgeAdd; /* Used to obfuscate ticket age */
uint64_t nextTicketNonce; /* TLS1.3 connection, starting from 0 and increasing in ascending order */
uint32_t sentTickets; /* TLS1.3 Number of tickets sent */
#endif /* HITLS_TLS_PROTO_TLS13 */
#endif /* HITLS_TLS_FEATURE_SESSION_TICKET */
KeyExchCtx *kxCtx; /* Key Exchange Context */
VerifyCtx *verifyCtx; /* Verify the context of handshake data. */
uint8_t *msgBuf; /* Buffer for receiving and sending messages */
uint32_t msgOffset; /* messages offset */
uint32_t bufferLen; /* messages buffer size */
uint32_t msgLen; /* Total length of buffered messages */
#ifdef HITLS_TLS_PROTO_TLS13
uint8_t clientHsTrafficSecret[MAX_DIGEST_SIZE]; /* Handshake secret used to encrypt the message sent by the TLS1.3
client */
uint8_t serverHsTrafficSecret[MAX_DIGEST_SIZE]; /* Handshake secret used to encrypt the message sent by the TLS1.3
server */
ClientHelloMsg *firstClientHello; /* TLS1.3 server records the first received ClientHello message */
#endif /* HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_PROTO_DTLS12
uint16_t nextSendSeq; /* message sending sequence number */
uint16_t expectRecvSeq; /* message receiving sequence number */
HS_ReassQueue *reassMsg; /* reassembly message queue, used for reassembly of fragmented messages */
#ifdef HITLS_BSL_UIO_UDP
/* To reduce the calculation amount for determining timeout, use the end time instead of the start time. If the end
* time is exceeded, the receiving times out. */
BSL_TIME deadline; /* End time */
uint32_t timeoutValue; /* Timeout interval, in us. */
uint32_t timeoutNum; /* Timeout count */
#endif /* HITLS_BSL_UIO_UDP */
#endif /* HITLS_TLS_PROTO_DTLS12 */
};
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end HS_CTX_H */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/include/hs_ctx.h | C | unknown | 7,611 |
/*
* 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 HS_DTLS_TIMER_H
#define HS_DTLS_TIMER_H
#include <stdint.h>
#include <stdbool.h>
#include "hs_ctx.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef HITLS_TLS_PROTO_DTLS12
/**
* @brief Start the 2MSL timer.
*
* @param ctx [IN] tls Context
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_MSG_HANDLE_SYS_TIME_FAIL The system time function fails to return.
*/
int32_t HS_Start2MslTimer(TLS_Ctx *ctx);
/**
* @brief Start the timer.
*
* @param ctx [IN] tls Context
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_MSG_HANDLE_SYS_TIME_FAIL The system time function fails to return.
*/
int32_t HS_StartTimer(TLS_Ctx *ctx);
/**
* @brief Judge timer timeout
*
* @param ctx [IN] tls Context
* @param isTimeout [OUT] Timeout or not
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_MSG_HANDLE_SYS_TIME_FAIL The system time function fails to return.
*/
int32_t HS_IsTimeout(TLS_Ctx *ctx, bool *isTimeout);
/**
* @brief DTLS receiving timeout timer processing
*
* @param ctx [IN] tls Context
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_MSG_HANDLE_SYS_TIME_FAIL The system time function fails to return.
* @retval HITLS_MSG_HANDLE_DTLS_CONNECT_TIMEOUT DTLS connection timeout
*/
int32_t HS_TimeoutProcess(TLS_Ctx *ctx);
#endif
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end HS_DTLS_TIMER_H */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/include/hs_dtls_timer.h | C | unknown | 1,912 |
/*
* 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 HS_EXTERNSIONS_H
#define HS_EXTERNSIONS_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
#define HS_EX_HEADER_LEN 4u
/* Handshake Extension message type */
#define HS_EX_TYPE_SERVER_NAME 0u
#define HS_EX_TYPE_MAX_FRAGMENT_LENGTH 1u
#define HS_EX_TYPE_TRUSTED_CA_KEYS 3u
#define HS_EX_TYPE_STATUS_REQUEST 5u
#define HS_EX_TYPE_SUPPORTED_GROUPS 10u
#define HS_EX_TYPE_POINT_FORMATS 11u
#define HS_EX_TYPE_SIGNATURE_ALGORITHMS 13u
#define HS_EX_TYPE_USE_SRTP 14u
#define HS_EX_TYPE_APP_LAYER_PROTOCOLS 16u
#define HS_EX_TYPE_STATUS_REQUEST_V2 17u
#define HS_EX_TYPE_SIGNED_CERTIFICATE_TIMESTAMP 18u
#define HS_EX_TYPE_PADDING 21u
#define HS_EX_TYPE_ENCRYPT_THEN_MAC 22u
#define HS_EX_TYPE_EXTENDED_MASTER_SECRET 23u
#define HS_EX_TYPE_RECORD_SIZE_LIMIT 28u
#define HS_EX_TYPE_SESSION_TICKET 35u
#define HS_EX_TYPE_PRE_SHARED_KEY 41u
#define HS_EX_TYPE_EARLY_DATA 42u
#define HS_EX_TYPE_SUPPORTED_VERSIONS 43u
#define HS_EX_TYPE_COOKIE 44u
#define HS_EX_TYPE_PSK_KEY_EXCHANGE_MODES 45u
#define HS_EX_TYPE_CERTIFICATE_AUTHORITIES 47u
#define HS_EX_TYPE_POST_HS_AUTH 49u
#define HS_EX_TYPE_SIGNATURE_ALGORITHMS_CERT 50u
#define HS_EX_TYPE_KEY_SHARE 51u
#define HS_EX_TYPE_RENEGOTIATION_INFO 0xFF01u
#define HS_EX_TYPE_END 0xFFFFu
#define HS_EX_TYPE_ID_UNRECOGNIZED 0
#define HS_EX_TYPE_ID_SERVER_NAME 1
#define HS_EX_TYPE_ID_MAX_FRAGMENT_LENGTH 2
#define HS_EX_TYPE_ID_TRUSTED_CA_KEYS 3
#define HS_EX_TYPE_ID_STATUS_REQUEST 4
#define HS_EX_TYPE_ID_SUPPORTED_GROUPS 5
#define HS_EX_TYPE_ID_POINT_FORMATS 6
#define HS_EX_TYPE_ID_SIGNATURE_ALGORITHMS 7
#define HS_EX_TYPE_ID_USE_SRTP 8
#define HS_EX_TYPE_ID_APP_LAYER_PROTOCOLS 9
#define HS_EX_TYPE_ID_STATUS_REQUEST_V2 10
#define HS_EX_TYPE_ID_SIGNED_CERTIFICATE_TIMESTAMP 11
#define HS_EX_TYPE_ID_PADDING 12
#define HS_EX_TYPE_ID_ENCRYPT_THEN_MAC 13
#define HS_EX_TYPE_ID_EXTENDED_MASTER_SECRET 14
#define HS_EX_TYPE_ID_RECORD_SIZE_LIMIT 15
#define HS_EX_TYPE_ID_SESSION_TICKET 16
#define HS_EX_TYPE_ID_PRE_SHARED_KEY 17
#define HS_EX_TYPE_ID_EARLY_DATA 18
#define HS_EX_TYPE_ID_SUPPORTED_VERSIONS 19
#define HS_EX_TYPE_ID_COOKIE 20
#define HS_EX_TYPE_ID_PSK_KEY_EXCHANGE_MODES 21
#define HS_EX_TYPE_ID_CERTIFICATE_AUTHORITIES 22
#define HS_EX_TYPE_ID_OID_FILTERS 23
#define HS_EX_TYPE_ID_POST_HS_AUTH 24
#define HS_EX_TYPE_ID_SIGNATURE_ALGORITHMS_CERT 25
#define HS_EX_TYPE_ID_KEY_SHARE 26
#define HS_EX_TYPE_ID_RENEGOTIATION_INFO 27
#define HS_EX_TYPE_MASK(id) (1ULL << (id))
#define HS_EX_TYPE_TLS_ALLOWED_OF_CLIENT_HELLO \
(HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SERVER_NAME) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_MAX_FRAGMENT_LENGTH) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SUPPORTED_GROUPS) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SESSION_TICKET) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_STATUS_REQUEST) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_APP_LAYER_PROTOCOLS) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_USE_SRTP) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_ENCRYPT_THEN_MAC) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SIGNED_CERTIFICATE_TIMESTAMP) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_EXTENDED_MASTER_SECRET) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SIGNATURE_ALGORITHMS_CERT) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_POST_HS_AUTH) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SIGNATURE_ALGORITHMS) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SUPPORTED_VERSIONS) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_PSK_KEY_EXCHANGE_MODES) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_KEY_SHARE) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_EARLY_DATA) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_CERTIFICATE_AUTHORITIES) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_PADDING) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_PRE_SHARED_KEY) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_RECORD_SIZE_LIMIT) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_RENEGOTIATION_INFO) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_POINT_FORMATS) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_COOKIE) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_UNRECOGNIZED))
#define HS_EX_TYPE_TLS1_3_ALLOWED_OF_ENCRYPTED_EXTENSIONS \
(HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SERVER_NAME) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_MAX_FRAGMENT_LENGTH) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SUPPORTED_GROUPS) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_APP_LAYER_PROTOCOLS) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_USE_SRTP) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_EARLY_DATA) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_RECORD_SIZE_LIMIT))
#define HS_EX_TYPE_TLS1_3_ALLOWED_OF_HELLO_RETRY_REQUEST \
(HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SUPPORTED_VERSIONS) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_KEY_SHARE) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_COOKIE))
#define HS_EX_TYPE_TLS1_3_ALLOWED_OF_SERVER_HELLO \
(HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SUPPORTED_VERSIONS) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_KEY_SHARE) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_PRE_SHARED_KEY))
#define HS_EX_TYPE_TLS1_3_ALLOWED_OF_CERTIFICATE_REQUEST \
(HS_EX_TYPE_MASK(HS_EX_TYPE_ID_STATUS_REQUEST) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SIGNED_CERTIFICATE_TIMESTAMP) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SIGNATURE_ALGORITHMS_CERT) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_OID_FILTERS) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SIGNATURE_ALGORITHMS) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_CERTIFICATE_AUTHORITIES) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_UNRECOGNIZED))
#define HS_EX_TYPE_TLS1_3_ALLOWED_OF_CERTIFICATE (HS_EX_TYPE_MASK(HS_EX_TYPE_ID_STATUS_REQUEST) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SIGNED_CERTIFICATE_TIMESTAMP))
#define HS_EX_TYPE_TLS1_2_ALLOWED_OF_SERVER_HELLO \
(HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SERVER_NAME) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_MAX_FRAGMENT_LENGTH) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SUPPORTED_GROUPS) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_APP_LAYER_PROTOCOLS) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_STATUS_REQUEST) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SESSION_TICKET) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_USE_SRTP) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_ENCRYPT_THEN_MAC) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_SIGNED_CERTIFICATE_TIMESTAMP) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_POINT_FORMATS) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_EXTENDED_MASTER_SECRET) | HS_EX_TYPE_MASK(HS_EX_TYPE_ID_RECORD_SIZE_LIMIT) | \
HS_EX_TYPE_MASK(HS_EX_TYPE_ID_RENEGOTIATION_INFO))
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end HS_EXTERNSIONS_H */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/include/hs_extensions.h | C | unknown | 7,412 |
/*
* 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 HS_KX_H
#define HS_KX_H
#include <stdint.h>
#include "hs_ctx.h"
#include "hs_msg.h"
#ifdef __cplusplus
extern "C" {
#endif
#define MASTER_SECRET_LABEL "CLIENT_RANDOM"
#define CLIENT_EARLY_LABEL "CLIENT_EARLY_TRAFFIC_SECRET"
#define CLIENT_HANDSHAKE_LABEL "CLIENT_HANDSHAKE_TRAFFIC_SECRET"
#define SERVER_HANDSHAKE_LABEL "SERVER_HANDSHAKE_TRAFFIC_SECRET"
#define CLIENT_APPLICATION_LABEL "CLIENT_TRAFFIC_SECRET_0"
#define SERVER_APPLICATION_LABEL "SERVER_TRAFFIC_SECRET_0"
#define EARLY_EXPORTER_SECRET_LABEL "EARLY_EXPORTER_SECRET"
#define EXPORTER_SECRET_LABEL "EXPORTER_SECRET"
/* The maximum premaster secret calculated by using the PSK may be:
* |uint16_t|MAX_OTHER_SECRET_SIZE|uint16_t|HS_PSK_MAX_LEN| */
#define MAX_OTHER_SECRET_SIZE 1536
#define MAX_PRE_MASTER_SECRET_SIZE (sizeof(uint16_t) + MAX_OTHER_SECRET_SIZE + sizeof(uint16_t) + HS_PSK_MAX_LEN)
#define MAX_SHA1_SIZE 20
#define MAX_MD5_SIZE 16
/**
* @brief Create a key exchange context.
*
* @return A KeyExchCtx pointer is returned. If NULL is returned, the creation fails.
*/
KeyExchCtx *HS_KeyExchCtxNew(void);
/**
* @brief Release the key exchange context
*
* @param keyExchCtx [IN] Key exchange context. KeyExchCtx is left empty by the invoker
*/
void HS_KeyExchCtxFree(KeyExchCtx *keyExchCtx);
/**
* @brief Process the server ECDHE key exchange message
*
* @param ctx [IN] TLS context
* @param serverKxMsg [IN] Parsed handshake message
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_MEMALLOC_FAIL Memory application failed.
* @retval HITLS_MSG_HANDLE_UNKNOWN_CURVE_TYPE Unsupported elliptic curve type
* @retval HITLS_MSG_HANDLE_UNSUPPORT_NAMED_CURVE Unsupported ECDH elliptic curve
* @retval HITLS_MSG_HANDLE_ERR_ENCODE_ECDH_KEY Failed to obtain the ECDH public key.
*/
int32_t HS_ProcessServerKxMsgEcdhe(TLS_Ctx *ctx, const ServerKeyExchangeMsg *serverKxMsg);
/**
* @brief Process the client ECDHE key exchange message
*
* @param ctx [IN] TLS context
* @param clientKxMsg [IN] Parsed handshake message
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_MEMALLOC_FAIL Memory application failed.
* @retval HITLS_MSG_HANDLE_UNKNOWN_CURVE_TYPE Unsupported elliptic curve type
* @retval HITLS_MSG_HANDLE_UNSUPPORT_NAMED_CURVE Unsupported ECDH elliptic curve
*/
int32_t HS_ProcessClientKxMsgEcdhe(TLS_Ctx *ctx, const ClientKeyExchangeMsg *clientKxMsg);
/**
* @brief Process the server DH key exchange message
*
* @param ctx [IN] TLS context
* @param serverKxMsg [IN] Parsed handshake message
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_MEMALLOC_FAIL Memory application failed.
* @retval HITLS_MSG_HANDLE_ERR_ENCODE_DH_KEY Failed to obtain the DH public key.
*/
int32_t HS_ProcessServerKxMsgDhe(TLS_Ctx *ctx, const ServerKeyExchangeMsg *serverKxMsg);
/**
* @brief Process the client DH key exchange message
*
* @param ctx [IN] TLS context
* @param clientKxMsg [IN] Parsed handshake message
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_MEMALLOC_FAIL Memory application failed.
*/
int32_t HS_ProcessClientKxMsgDhe(TLS_Ctx *ctx, const ClientKeyExchangeMsg *clientKxMsg);
int32_t HS_ProcessClientKxMsgRsa(TLS_Ctx *ctx, const ClientKeyExchangeMsg *clientKxMsg);
int32_t HS_ProcessClientKxMsgSm2(TLS_Ctx *ctx, const ClientKeyExchangeMsg *clientKxMsg);
/**
* @brief Derive the master secret.
*
* @param ctx [IN] TLS context
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_MSG_HANDLE_UNSUPPORT_KX_ALG Unsupported Key Exchange Algorithm
* @retval For other error codes, see SAL_CRYPT_CalcEcdhSharedSecret.
*/
int32_t HS_GenerateMasterSecret(TLS_Ctx *ctx);
/**
* @brief Process the identity hint contained in ServerKeyExchange during PSK negotiation.
*
* @param ctx [IN] TLS context
* @param serverKxMsg [IN] Parsed handshake message
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK The callback for obtaining the PSK on the client is not set.
* @retval HITLS_CONFIG_INVALID_LENGTH The length of the prompt message is incorrect.
* @retval HITLS_MEMALLOC_FAIL Memory application failed.
*/
int32_t HS_ProcessServerKxMsgIdentityHint(TLS_Ctx *ctx, const ServerKeyExchangeMsg *serverKxMsg);
/**
* @brief TLS1.3 derived secret
*
* @param deriveInfo [IN] secret derivation material
* @param isHashed [IN] true: indicates that the seed has been hashed false: indicates that the seed has not been
* hashed.
* @param outSecret [OUT] Output secret
* @param outLen [IN] Output secret length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_DIGEST hash calculation fails.
* @retval HITLS_CRYPT_ERR_HKDF_EXPAND HKDF-Expand calculation fails.
*/
int32_t HS_TLS13DeriveSecret(CRYPT_KeyDeriveParameters *deriveInfo, bool isHashed, uint8_t *outSecret, uint32_t outLen);
int32_t HS_TLS13DeriveBinderKey(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, bool isExternalPsk, uint8_t *earlySecret, uint32_t secretLen,
uint8_t *binderKey, uint32_t keyLen);
/**
* @brief TLS1.3 Calculate the early secret.
*
* @param hashAlg [IN] secret derivation material
* @param psk [IN] PSK
* @param pskLen [OUT] PSK length
* @param earlySecret [IN] Output secret
* @param outLen [IN] Output secret length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_HKDF_EXTRACT HKDF-Extract calculation failure
*/
int32_t HS_TLS13DeriveEarlySecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, uint8_t *psk, uint32_t pskLen, uint8_t *earlySecret, uint32_t *outLen);
/**
* @brief TLS1.3 Calculate the secret in the next phase.
*
* @param hashAlg [IN] Hash algorithm
* @param inSecret [IN] secret of the current phase
* @param inLen [OUT] Current secret length
* @param givenSecret [IN] The secret specified by the
* @param givenLen [IN] Specify the secret length.
* @param outSecret [IN] Output secret
* @param outLen [IN/OUT] IN: Maximum buffer length OUT: Output secret length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_DIGEST hash calculation fails.
* @retval HITLS_CRYPT_ERR_HKDF_EXPAND HKDF-Expand calculation fails.
* @retval HITLS_CRYPT_ERR_HKDF_EXTRACT HKDF-Extract calculation failure
*/
int32_t HS_TLS13DeriveNextStageSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, uint8_t *inSecret, uint32_t inLen, uint8_t *givenSecret,
uint32_t givenLen, uint8_t *outSecret, uint32_t *outLen);
/**
* @brief TLS1.3 Calculate the FinishedKey.
*
* @param hashAlg [IN] Hash algorithm
* @param baseKey [IN] Key of the current phase
* @param baseKeyLen [IN] Current key length
* @param finishedkey [OUT] Output key
* @param finishedkeyLen [IN] Output key length
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_DIGEST hash calculation failed.
* @retval HITLS_CRYPT_ERR_HKDF_EXPAND HKDF-Expand calculation fails.
*/
int32_t HS_TLS13DeriveFinishedKey(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, uint8_t *baseKey, uint32_t baseKeyLen, uint8_t *finishedkey, uint32_t finishedkeyLen);
/**
* @brief TLS1.3 Switch the traffickey.
*
* @param ctx [IN] TLS context
* @param secret [IN] secret for calculating writekey and writeiv
* @param secretLen [IN] Input the secret length.
* @param isOut [IN] It is used to determine writeSate and readState.
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_DIGEST hash calculation failed.
* @retval HITLS_CRYPT_ERR_HKDF_EXPAND HKDF-Expand calculation fails.
* @retval HITLS_INTERNAL_EXCEPTION Invalid null pointer
*/
int32_t HS_SwitchTrafficKey(TLS_Ctx *ctx, uint8_t *secret, uint32_t secretLen, bool isOut);
/**
* @brief Set parameters for initializing the panding state of the record layer.
*
* @param ctx [IN] TLS context
* @param isClient [IN] Whether it is a client
* @param keyPara [OUT] Output parameter
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_MEMCPY_FAIL Memory Copy Failure
*/
int32_t HS_SetInitPendingStateParam(const TLS_Ctx *ctx, bool isClient, REC_SecParameters *keyPara);
/**
* @brief TLS1.3 Derives the secret of the ServerHello procedure.
*
* @param ctx [IN] TLS context
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_HKDF_EXPAND HKDF-Expand calculation fails.
* @retval HITLS_CRYPT_ERR_HKDF_EXTRACT HKDF-Extract calculation failed.
* @retval HITLS_CRYPT_ERR_CALC_SHARED_KEY Failed to calculate the shared key.
* @retval HITLS_CRYPT_ERR_DIGEST hash calculation fails.
* @retval For details about other error codes, see the SAL_CRYPT_DigestFinal interface.
*/
int32_t HS_TLS13CalcServerHelloProcessSecret(TLS_Ctx *ctx);
/**
* @brief TLS1.3 Derives the secret of the ServerFinish process.
*
* @param ctx [IN] TLS context
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_DIGEST hash calculation failed.
* @retval HITLS_CRYPT_ERR_HKDF_EXPAND HKDF-Expand calculation fails.
* @retval HITLS_CRYPT_ERR_HKDF_EXTRACT HKDF-Extract calculation failed.
* @retval For details about other error codes, see the SAL_CRYPT_DigestFinal interface.
*/
int32_t HS_TLS13CalcServerFinishProcessSecret(TLS_Ctx *ctx);
/**
* @brief TLS1.3 Update the traffic secret.
*
* @param ctx [IN] TLS context
* @param isOut [IN] It is used to determine writeSate and readState.
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_DIGEST hash calculation failed.
* @retval HITLS_CRYPT_ERR_HKDF_EXPAND HKDF-Expand calculation fails.
* @retval HITLS_CRYPT_ERR_HKDF_EXTRACT HKDF-Extract calculation failure
* @retval For other error codes, see the SAL_CRYPT_DigestFinal interface.
*/
int32_t HS_TLS13UpdateTrafficSecret(TLS_Ctx *ctx, bool isOut);
/**
* @brief TLS1.3 Derived by resumption_master_secret
*
* @param ctx [IN] TLS context
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_HKDF_EXPAND HKDF-Expand calculation fails.
* @retval HITLS_CRYPT_ERR_HKDF_EXTRACT HKDF-Extract calculation failure
* @retval HITLS_CRYPT_ERR_CALC_SHARED_KEY Failed to calculate the shared key.
* @retval HITLS_CRYPT_ERR_DIGEST hash calculation failed.
* @retval For other error codes, see the SAL_CRYPT_DigestFinal interface
*/
int32_t HS_TLS13DeriveResumptionMasterSecret(TLS_Ctx *ctx);
/**
* @brief TLS1.3 calculate session resumption PSK
*
* @param ctx [IN] TLS context
* @param ticketNonce [IN] Unique ID of the ticket issued on the, which is used to calculate the PSK for session
* resumption.
* @param ticketNonceSize [IN] ticketNonce length
* @param resumePsk [OUT] Output the PSK key.
* @param resumePskLen [IN] Output the PSK length.
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_UNREGISTERED_CALLBACK Unregistered callback
* @retval HITLS_CRYPT_ERR_DIGEST hash calculation fails.
* @retval HITLS_CRYPT_ERR_HKDF_EXPAND HKDF-Expand calculation fails.
*/
int32_t HS_TLS13DeriveResumePsk(
TLS_Ctx *ctx, const uint8_t *ticketNonce, uint32_t ticketNonceSize, uint8_t *resumePsk, uint32_t resumePskLen);
int32_t HS_TLS13DeriveHandshakeTrafficSecret(TLS_Ctx *ctx);
#ifdef __cplusplus
}
#endif
#endif
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/include/hs_kx.h | C | unknown | 12,151 |
/*
* 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 HS_MSG_H
#define HS_MSG_H
#include <stdint.h>
#include <stdbool.h>
#include "hitls_build.h"
#include "bsl_module_list.h"
#include "cert.h"
#include "hitls_crypt_type.h"
#include "hitls_cert_type.h"
#include "hitls_type.h"
#ifdef __cplusplus
extern "C" {
#endif
#define HS_MSG_HEADER_SIZE 4u
#define DTLS_HS_MSG_HEADER_SIZE 12u
#define HS_RANDOM_SIZE 32u
#define HS_RANDOM_DOWNGRADE_SIZE 8u
#define TLS_HS_MAX_SESSION_ID_SIZE 32u
#define TLS_HS_MIN_SESSION_ID_SIZE 24u
#define TLS_HS_MIN_COOKIE_SIZE 1u
#define TLS_HS_MAX_COOKIE_SIZE 255u
#define DTLS_HS_MSGLEN_ADDR 1u /* DTLS message length address, which is used when parsing the DTLS message header. */
/* DTLS message sequence number address, which is used for parsing the DTLS message header. */
#define DTLS_HS_MSGSEQ_ADDR 4u
/* DTLS message fragment offset address, which is used when the DTLS message header is parsed. */
#define DTLS_HS_FRAGMENT_OFFSET_ADDR 6u
/* DTLS message fragment length address, which is used when parsing the DTLS message header. */
#define DTLS_HS_FRAGMENT_LEN_ADDR 9u
/* Handshake message type */
typedef enum {
HELLO_REQUEST = 0,
CLIENT_HELLO = 1,
SERVER_HELLO = 2,
HELLO_VERIFY_REQUEST = 3,
NEW_SESSION_TICKET = 4,
END_OF_EARLY_DATA = 5,
HELLO_RETRY_REQUEST = 6,
ENCRYPTED_EXTENSIONS = 8,
CERTIFICATE = 11,
SERVER_KEY_EXCHANGE = 12,
CERTIFICATE_REQUEST = 13,
SERVER_HELLO_DONE = 14,
CERTIFICATE_VERIFY = 15,
CLIENT_KEY_EXCHANGE = 16,
FINISHED = 20,
CERTIFICATE_URL = 21,
CERTIFICATION_STATUS = 22,
SUPPLEMENTAL_DATA = 23,
KEY_UPDATE = 24,
MESSAGE_HASH = 254,
HS_MSG_TYPE_END = 255
} HS_MsgType;
typedef enum {
PSK_KE = 0,
PSK_DHE_KE = 1,
PSK_KEY_EXCHANGEMODE_END = 255
} HS_PskKeyExchMode;
typedef struct {
HITLS_KeyUpdateRequest requestUpdate;
} KeyUpdateMsg;
typedef struct {
ListHead head;
uint16_t group; /* Naming group of keys to be exchanged */
uint16_t keyExchangeSize;
uint8_t *keyExchange; /* Key exchange information */
} KeyShare;
typedef struct OfferedPsks {
ListHead pskNode; /* Multiple PSK linked lists are formed through pskNode. The actual data of this node is the
following fields */
uint8_t *identity; /* pskid and binder are in one-to-one mapping. */
uint8_t *binder; /* HMAC value */
uint32_t obfuscatedTicketAge; /* An obfuscated version of the age of the key */
uint16_t identitySize; /* bytes of identity */
uint8_t binderSize; /* bytes of binder */
bool isValid; /* is binder valid */
} PreSharedKey;
typedef struct {
uint16_t *supportedGroups;
uint16_t *signatureAlgorithms;
uint16_t *signatureAlgorithmsCert;
uint8_t *pointFormats;
uint8_t *alpnList; /* application-layer protocol negotiation list */
uint8_t *serverName; /* serverName after parsing */
uint8_t *secRenegoInfo; /* renegotiation extension information */
uint8_t *ticket; /* ticket information */
uint32_t ticketSize;
uint16_t supportedGroupsSize;
uint16_t signatureAlgorithmsSize;
uint16_t signatureAlgorithmsCertSize;
uint16_t alpnListSize; /* application-layer protocol negotiation list len */
uint16_t serverNameSize;
uint8_t pointFormatsSize;
uint8_t serverNameType; /* Type of the parsed serverName. */
uint8_t secRenegoInfoSize; /* Length of the security renegotiation information */
uint8_t reserved[1]; /* Four-byte alignment */
/* TLS1.3 */
uint16_t *supportedVersions;
uint8_t *cookie;
uint8_t *keModes;
uint8_t keModesSize;
uint8_t supportedVersionsCount; /* Number of supported version */
uint16_t cookieLen;
HITLS_TrustedCAList *caList;
PreSharedKey *preSharedKey;
KeyShare *keyShare; /* In the ClientHello message, this extension provides a set of KeyShares */
} ExtensionContent;
typedef struct {
bool haveSupportedGroups;
bool haveSignatureAlgorithms;
bool haveSignatureAlgorithmsCert;
bool havePointFormats;
bool haveExtendedMasterSecret;
bool haveSupportedVers;
bool haveCookie; /* Whether there is a cookie (involved in TLS1.3 ClientHello) */
bool haveCA; /* Whether the CA exists (involved in TLS1.3 ClientHello) */
bool havePostHsAuth; /* Indicates whether the Client (TLS1.3) is willing to receive the Certificate Request
message. */
bool haveKeyShare;
bool haveEarlyData;
bool havePskExMode; /* Indicates whether the TLS1.3 key exchange mode exists. */
bool havePreShareKey; /* Indicates whether the pre-shared key exists. */
bool haveAlpn; /* Whether there is Alpn */
bool haveServerName; /* Whether the ServerName extension exists. */
bool haveSecRenego; /* Whether security renegotiation exists. */
bool haveTicket; /* Indicates whether a ticket is available. */
bool haveEncryptThenMac; /* Indicates whether EncryptThenMac is supported. */
} ExtensionFlag;
typedef struct {
ExtensionFlag flag;
ExtensionContent content;
} ClientHelloExt;
/* It is used to transmit client hello message */
typedef struct {
uint8_t randomValue[HS_RANDOM_SIZE]; /* random number group */
uint8_t *sessionId;
uint8_t *cookie; /* Cookie (for DTLS only) */
uint16_t *cipherSuites;
uint16_t version;
uint16_t cipherSuitesSize;
uint8_t sessionIdSize;
uint8_t compressionMethodsSize;
uint8_t *compressionMethods;
uint8_t cookieLen;
bool haveEmptyRenegoScsvCipher; /* According to RFC 5746, a special signaling cipher suite value (SCSV) can be used
to indicate that security renegotiation is supported. */
bool haveFallBackScsvCipher; /* According to RFC 7507, a special signaling cipher suite value (SCSV) can be used
to indicate that a downgrade negotiation process is in progress. */
uint8_t refCnt; /* Do not involve multiple threads. Process the hrr check clientHello. */
uint32_t truncateHelloLen; /* is used for binder calculation. */
ClientHelloExt extension;
uint64_t extensionTypeMask;
uint8_t *extensionBuff;
uint32_t extensionBuffLen;
uint8_t extensionCount; /* Size of the extension buffer */
} ClientHelloMsg;
/* It is used to transmit server hello message */
typedef struct {
uint16_t version;
uint16_t cipherSuite;
uint8_t randomValue[HS_RANDOM_SIZE]; /* random number group */
uint8_t *sessionId;
uint8_t *pointFormats;
uint8_t *alpnSelected; /* selected alpn protocol */
uint8_t *cookie;
uint8_t *secRenegoInfo;
KeyShare keyShare;
uint16_t alpnSelectedSize; /* selected alpn protocol length */
uint16_t supportedVersion;
uint16_t cookieLen;
uint16_t selectedIdentity; /* TLS 1.3 psk required */
uint8_t sessionIdSize;
uint8_t pointFormatsSize;
uint8_t secRenegoInfoSize; /* Length of the security renegotiation information */
uint64_t extensionTypeMask;
bool havePointFormats;
bool haveExtendedMasterSecret;
bool haveSupportedVersion;
bool haveCookie; /* Indicates whether the cookie length is involved in TLS1.3 HelloRetryRequest. */
bool haveKeyShare; /* Whether KeyShare is extended. */
bool haveSelectedIdentity; /* Indicates whether the Pre_PSK is selected. */
bool haveSelectedAlpn; /* Whether the application layer protocol is selected. */
bool haveServerName;
bool haveSecRenego;
bool haveTicket;
bool haveEncryptThenMac;
bool reserved[2]; /* Four-byte alignment */
} ServerHelloMsg;
/* It is used to transmit hello verify request message */
typedef struct {
uint16_t version;
uint8_t cookieLen;
uint8_t reserved[1]; /* fill with 1 byte for 4-byte alignment */
uint8_t *cookie;
} HelloVerifyRequestMsg;
/* Transmits certificate message */
typedef struct {
CERT_Item *cert; /* Certificate message content */
uint32_t certCount; /* Number of certificates */
uint8_t *certificateReqCtx; /* Used by the TLS 1.3 */
uint32_t certificateReqCtxSize; /* Used by the TLS 1.3 */
uint64_t extensionTypeMask; /* Used by the TLS 1.3 */
} CertificateMsg;
typedef struct {
HITLS_ECParameters ecPara; /* Elliptic curve field parameter of the ECDH public key */
uint32_t pubKeySize; /* Length of the ecdh public key */
uint8_t *pubKey; /* ecdh public key content */
uint16_t signAlgorithm;
uint16_t signSize;
uint8_t *signData;
} ServerEcdh;
typedef struct {
uint8_t *p;
uint8_t *g;
uint16_t plen;
uint16_t glen;
uint8_t *pubkey;
uint16_t pubKeyLen;
uint16_t signAlgorithm;
uint16_t signSize;
uint8_t *signData;
} ServerDh;
/* Used to transfer the key exchange content of the server */
typedef struct {
uint8_t *pskIdentityHint; /* psk identity negotiation prompt message */
uint32_t hintSize;
HITLS_KeyExchAlgo keyExType; /* key exchange mode */
union {
ServerEcdh ecdh;
ServerDh dh;
} keyEx;
} ServerKeyExchangeMsg;
/* Used to transfer the client key exchange content */
typedef struct {
uint8_t *pskIdentity;
uint32_t pskIdentitySize;
uint32_t dataSize; /* Key exchange data length */
uint8_t *data; /* Key exchange data. */
} ClientKeyExchangeMsg;
/* Transmits certificate request message */
typedef struct {
uint8_t *certTypes;
uint16_t *signatureAlgorithms;
uint8_t reserved; /* Four-byte alignment */
uint8_t certTypesSize;
uint16_t signatureAlgorithmsSize;
#ifdef HITLS_TLS_PROTO_TLS13
uint16_t *signatureAlgorithmsCert;
uint16_t signatureAlgorithmsCertSize;
uint8_t *certificateReqCtx; /* Used by the TLS 1.3 */
uint32_t certificateReqCtxSize; /* This field is used by the TLS 1.3. The value is not 0 only for the
authentication after the handshake */
uint64_t extensionTypeMask;
bool haveSignatureAndHashAlgoCert;
#endif /* HITLS_TLS_PROTO_TLS13 */
bool haveSignatureAndHashAlgo;
bool haveDistinguishedName;
} CertificateRequestMsg;
/* Transmits certificate verification message */
typedef struct {
uint16_t signHashAlg; /* Signature hash algorithm, which is available only for TLS1.2 and DTLS1.2 */
uint16_t signSize; /* Length of the signature data. */
uint8_t *sign; /* Signature data */
} CertificateVerifyMsg;
/* It is used to transmit Ticket message
RFC5077 3.3 NewSessionTicket Handshake Message
struct {
uint32 ticket_lifetime_hint;
opaque ticket<0..2^16-1>;
} NewSessionTicket;
TLS1.3:
struct {
uint32 ticket_lifetime;
uint32 ticket_age_add;
opaque ticket_nonce<0..255>;
opaque ticket<1..2^16-1>;
Extension extensions<0..2^16-2>;
} NewSessionTicket;
*/
typedef struct {
uint32_t ticketLifetimeHint; /* ticket timeout interval, in seconds */
uint32_t ticketAgeAdd; /* ticket_age_add: a random number generated each time a ticket is issued. */
uint32_t ticketNonceSize; /* ticket_nonce length */
uint8_t *ticketNonce; /* ticketNonce: Unique ID of the ticket issued on the connection, starting from 0 and
increasing in ascending order. */
uint32_t ticketSize;
uint8_t *ticket; /* ticket */
uint64_t extensionTypeMask;
} NewSessionTicketMsg;
/* It is used to transmit finish message */
typedef struct {
uint32_t verifyDataSize;
uint8_t *verifyData;
} FinishedMsg;
typedef struct {
uint16_t *supportedGroups;
uint16_t supportedGroupsSize;
uint16_t alpnSelectedSize; /* selected alpn protocol length */
uint8_t *alpnSelected; /* selected alpn protocol */
uint64_t extensionTypeMask;
bool haveSupportedGroups;
bool haveEarlyData;
bool haveServerName;
bool haveSelectedAlpn;
} EncryptedExtensions;
/* Used to parse the handshake message header. */
typedef struct {
HS_MsgType type;
uint32_t length; /* handshake msg body length */
uint16_t sequence; /* DTLS Indicates the number of the handshake message. Each time a new handshake message is
sent, one is added. Retransmission does not add up */
uint32_t fragmentOffset; /* Fragment offset of DTLS handshake message */
uint32_t fragmentLength; /* Fragment length of the DTLS handshake message */
const uint8_t *rawMsg; /* Complete handshake information */
uint32_t headerAndBodyLen;
} HS_MsgInfo;
/* It is used to transmit handshake message */
typedef struct {
HS_MsgType type;
uint32_t length;
uint16_t sequence; /* DTLS Indicates the number of the handshake message. Each time a new handshake message is
sent, one is added. Retransmission does not add up */
uint8_t reserved[2]; /* fill 2 bytes for 4-byte alignment. */
uint32_t fragmentOffset; /* Fragment offset of DTLS handshake message. */
uint32_t fragmentLength; /* Fragment length of the DTLS handshake message */
union {
ClientHelloMsg clientHello;
ServerHelloMsg serverHello;
HelloVerifyRequestMsg helloVerifyReq;
EncryptedExtensions encryptedExtensions;
CertificateMsg certificate;
ClientKeyExchangeMsg clientKeyExchange;
ServerKeyExchangeMsg serverKeyExchange;
CertificateRequestMsg certificateReq;
CertificateVerifyMsg certificateVerify;
NewSessionTicketMsg newSessionTicket;
FinishedMsg finished;
KeyUpdateMsg keyUpdate;
} body;
} HS_Msg;
#ifdef HITLS_TLS_PROTO_DTLS12
/* Reassembles fragmented messages */
typedef struct {
ListHead head;
HS_MsgType type;
uint16_t sequence; /* DTLS Indicates the number of the handshake message. Each time a new handshake message is
sent, one is added. Retransmission does not add up */
bool isReassComplete; /* Indicates whether the message is reassembled. */
uint8_t reserved; /* Padded with 1 byte for 4-byte alignment. */
uint8_t *reassBitMap; /* bitmap, used for processing duplicate fragmented message and calculating whether the
fragmented message are completely reassembled. */
uint8_t *msg; /* Used to store the handshake messages during the reassembly. */
uint32_t msgLen; /* Total length of a message, including the message header. */
} HS_ReassQueue;
#endif
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end HS_MSG_H */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/include/hs_msg.h | C | unknown | 15,261 |
/*
* 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 HS_VERIFY_H
#define HS_VERIFY_H
#include <stdint.h>
#include <stdbool.h>
#include "hitls_crypt_type.h"
#include "tls.h"
#include "hs_ctx.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Initialize the verify context
* @attention If it has been initialized, the verify context will be reset
*
* @param hsCtx [IN] Handshake context
*
* @retval HITLS_SUCCESS
* @retval HITLS_MEMALLOC_FAIL Memory allocation failed
*/
int32_t VERIFY_Init(HS_Ctx *hsCtx);
/**
* @brief Release verify context
*
* @param hsCtx [IN] Handshake context
*/
void VERIFY_Deinit(HS_Ctx *hsCtx);
/**
* @brief Calculate verify data
*
* @param ctx [IN] tls Context
* @param isClient [IN] Indicates whether the context is client. If yes, the system calculates the verify data
* sent by the client. Otherwise, the system calculates the verify data sent by the server.
* @param masterSecret [IN]
* @param masterSecretLen [IN]
*
* @retval HITLS_SUCCESS
* @retval HITLS_UNREGISTERED_CALLBACK Callback unregistered
* @retval HITLS_CRYPT_ERR_DIGEST Hash operation failed
* @retval HITLS_CRYPT_ERR_HMAC HMAC operation failed
* @retval HITLS_MEMALLOC_FAIL Memory allocation failed
*/
int32_t VERIFY_CalcVerifyData(TLS_Ctx *ctx, bool isClient, const uint8_t *masterSecret, uint32_t masterSecretLen);
/**
* @brief Calculate the client verify signature data
*
* @param ctx [IN] TLS context. Different TLS and DTLS versions require different processing
* @param privateKey [IN] Certificate private key
* @param signScheme [IN] Signature hash algorithm
*
* @retval HITLS_SUCCESS
* @retval HITLS_PACK_SIGNATURE_ERR Signing failed
*/
int32_t VERIFY_CalcSignData(TLS_Ctx *ctx, HITLS_CERT_Key *privateKey, HITLS_SignHashAlgo signScheme);
/**
* @brief Verify the client signature data
*
* @param ctx [IN] TLS context. Different TLS and DTLS versions require different processing
* @param pubkey [IN] Public key of the device certificate
* @param signScheme [IN] Signature hash algorithm
* @param signData [IN] Signature
* @param signDataLen [IN] Signature length
*
* @retval HITLS_SUCCESS
* @retval HITLS_PACK_SIGNATURE_ERR Signing failed
*/
int32_t VERIFY_VerifySignData(TLS_Ctx *ctx, HITLS_CERT_Key *pubkey, HITLS_SignHashAlgo signScheme,
const uint8_t *signData, uint16_t signDataLen);
/**
* @brief Obtain the verify data
*
* @param ctx [IN] verify context
* @param verifyData [OUT]
* @param verifyDataLen [IN/OUT] IN: maximum length of data OUT:verify data Len
*
* @retval HITLS_SUCCESS
* @retval HITLS_MEMCPY_FAIL Memory copy failed
*/
int32_t VERIFY_GetVerifyData(const VerifyCtx *ctx, uint8_t *verifyData, uint32_t *verifyDataLen);
/**
* @brief TLS1.3 calculate verify data
*
* @param ctx [IN] TLS Context
* @param isClient [IN] Indicates whether the context is client. If yes, the system calculates the verify data
* sent by the client. Otherwise, the system calculates the verify data sent by the server.
* @retval HITLS_SUCCESS
* @retval HITLS_UNREGISTERED_CALLBACK Callback unregistered
* @retval HITLS_CRYPT_ERR_DIGEST Hash operation failed
* @retval HITLS_CRYPT_ERR_HMAC HMAC operation failed
* @retval HITLS_MEMALLOC_FAIL Memory allocation failed
*/
int32_t VERIFY_Tls13CalcVerifyData(TLS_Ctx *ctx, bool isClient);
/**
* @brief Reprocess the verify data for the hello retry request message
*
* @param ctx [IN] TLS Context
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t VERIFY_HelloRetryRequestVerifyProcess(TLS_Ctx *ctx);
int32_t VERIFY_CalcPskBinder(const TLS_Ctx *ctx, HITLS_HashAlgo hashAlgo, bool isExternalPsk, uint8_t *psk,
uint32_t pskLen, const uint8_t *msg, uint32_t msgLen, uint8_t *binder, uint32_t binderLen);
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end HS_VERIFY_H */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/include/hs_verify.h | C | unknown | 4,514 |
/*
* 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 TRANSCRIPT_HASH_H
#define TRANSCRIPT_HASH_H
#include <stdint.h>
#include "hitls_crypt_type.h"
#include "hs_ctx.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Set the hash algorithm
*
* @param libCtx [IN] library context for provider
* @param attrName [IN] attribute name of the provider, maybe NULL
* @param ctx [IN] verify context
* @param hashAlgo [IN] hash algorithm
*
* @retval HITLS_SUCCESS
* @retval HITLS_CRYPT_ERR_DIGEST hash operation failed
* @retval HITLS_UNREGISTERED_CALLBACK The callback function is not registered.
*/
int32_t VERIFY_SetHash(HITLS_Lib_Ctx *libCtx, const char *attrName, VerifyCtx *ctx, HITLS_HashAlgo hashAlgo);
/**
* @brief Add handshake message data
*
* @param ctx [IN] verify context
* @param data [IN] Handshake message data
* @param len [IN] Data length
*
* @retval HITLS_SUCCESS
* @retval HITLS_UNREGISTERED_CALLBACK The callback function is not registered.
* @retval HITLS_CRYPT_ERR_DIGEST hash operation failed
* @retval HITLS_MEMCPY_FAIL
* @retval HITLS_MEMALLOC_FAIL
*/
int32_t VERIFY_Append(VerifyCtx *ctx, const uint8_t *data, uint32_t len);
/**
* @brief Calculate the SessionHash
*
* @param ctx [IN] verify context
* @param digest [OUT] digest data
* @param digestLen [IN/OUT] IN:maximum length of digest OUT:digest length
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see SAL_CRYPT_DigestFinal
*/
int32_t VERIFY_CalcSessionHash(VerifyCtx *ctx, uint8_t *digest, uint32_t *digestLen);
/**
* @brief Release the message cache linked list
*
* @param ctx [IN] verify context
*/
void VERIFY_FreeMsgCache(VerifyCtx *ctx);
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end TRANSCRIPT_HASH_H */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/include/transcript_hash.h | C | unknown | 2,301 |
/*
* 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.
*/
#include <string.h>
#include "hitls_build.h"
#include "securec.h"
#include "bsl_bytes.h"
#include "bsl_sal.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "hitls.h"
#include "hitls_error.h"
#include "tls_config.h"
#include "bsl_errno.h"
#include "bsl_uio.h"
#include "uio_base.h"
#ifdef HITLS_TLS_FEATURE_INDICATOR
#include "indicator.h"
#endif /* HITLS_TLS_FEATURE_INDICATOR */
#include "pack.h"
#ifdef HITLS_TLS_FEATURE_SECURITY
#include "security.h"
#endif
#include "parse.h"
#include "hs_kx.h"
#include "hs.h"
#include "hs_extensions.h"
#include "hs_common.h"
#include "config_type.h"
#include "config_check.h"
#include "record.h"
#ifdef HITLS_TLS_PROTO_DTLS12
#define DTLS_SCTP_AUTH_LABEL "EXPORTER_DTLS_OVER_SCTP" /* dtls SCTP auth key label */
#endif
#ifdef HITLS_TLS_PROTO_TLS13
/* Fixed random value of the hello retry request packet */
const uint8_t g_hrrRandom[HS_RANDOM_SIZE] = {
0xcf, 0x21, 0xad, 0x74, 0xe5, 0x9a, 0x61, 0x11, 0xbe, 0x1d, 0x8c, 0x02, 0x1e, 0x65, 0xb8, 0x91,
0xc2, 0xa2, 0x11, 0x16, 0x7a, 0xbb, 0x8c, 0x5e, 0x07, 0x9e, 0x09, 0xe2, 0xc8, 0xa8, 0x33, 0x9c
};
const uint8_t *HS_GetHrrRandom(uint32_t *len)
{
*len = HS_RANDOM_SIZE;
return g_hrrRandom;
}
#ifdef HITLS_TLS_PROTO_TLS_BASIC
const uint8_t g_tls12Downgrade[HS_DOWNGRADE_RANDOM_SIZE] = {
0x44, 0x4f, 0x57, 0x4e, 0x47, 0x52, 0x44, 0x01
};
const uint8_t *HS_GetTls12DowngradeRandom(uint32_t *len)
{
*len = HS_DOWNGRADE_RANDOM_SIZE;
return g_tls12Downgrade;
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC */
#endif /* HITLS_TLS_PROTO_TLS13 */
uint32_t HS_GetVersion(const TLS_Ctx *ctx)
{
if (ctx->negotiatedInfo.version > 0) {
return ctx->negotiatedInfo.version;
} else {
/* If the version is not negotiated, the latest version supported by the local is returned */
return ctx->config.tlsConfig.maxVersion;
}
}
static const char *g_stateMachineStr[] = {
[TLS_IDLE] = "idle",
[TLS_CONNECTED] = "connected",
#ifdef HITLS_TLS_HOST_CLIENT
[TRY_SEND_CLIENT_HELLO] = "send client hello",
[TRY_SEND_CLIENT_KEY_EXCHANGE] = "send client key exchange",
[TRY_RECV_SERVER_HELLO] = "recv server hello",
[TRY_RECV_HELLO_VERIFY_REQUEST] = "recv hello verify request",
[TRY_RECV_SERVER_KEY_EXCHANGE] = "recv server key exchange",
[TRY_RECV_SERVER_HELLO_DONE] = "recv server hello done",
[TRY_RECV_NEW_SESSION_TICKET] = "recv new session ticket",
[TRY_RECV_HELLO_REQUEST] = "recv hello request",
#endif
#ifdef HITLS_TLS_HOST_SERVER
[TRY_SEND_HELLO_REQUEST] = "send hello request",
[TRY_SEND_SERVER_HELLO] = "send server hello",
[TRY_SEND_HELLO_VERIFY_REQUEST] = "send hello verify request",
[TRY_SEND_SERVER_KEY_EXCHANGE] = "send server key exchange",
[TRY_RECV_CLIENT_HELLO] = "recv client hello",
[TRY_RECV_CLIENT_KEY_EXCHANGE] = "recv client key exchange",
[TRY_SEND_SERVER_HELLO_DONE] = "send server hello done",
[TRY_SEND_NEW_SESSION_TICKET] = "send new session ticket",
#endif
#ifdef HITLS_TLS_PROTO_TLS13
[TRY_RECV_KEY_UPDATE] = "recv keyupdate",
[TRY_SEND_KEY_UPDATE] = "send keyupdate",
#ifdef HITLS_TLS_HOST_CLIENT
[TRY_RECV_ENCRYPTED_EXTENSIONS] = "recv encrypted extensions",
[TRY_SEND_END_OF_EARLY_DATA] = "send end of early data",
#endif /* HITLS_TLS_HOST_CLIENT */
#ifdef HITLS_TLS_HOST_SERVER
[TRY_SEND_ENCRYPTED_EXTENSIONS] = "send encrypted extensions",
[TRY_SEND_HELLO_RETRY_REQUEST] = "send hello retry request",
[TRY_RECV_END_OF_EARLY_DATA] = "recv end of early data",
#endif /* HITLS_TLS_HOST_SERVER */
#endif /* HITLS_TLS_PROTO_TLS13 */
[TRY_SEND_CERTIFICATE] = "send certificate",
[TRY_SEND_CERTIFICATE_REQUEST] = "send certificate request",
[TRY_SEND_CERTIFICATE_VERIFY] = "send certificate verify",
[TRY_SEND_CHANGE_CIPHER_SPEC] = "send change cipher spec",
[TRY_RECV_CERTIFICATE] = "recv certificate",
[TRY_RECV_CERTIFICATE_REQUEST] = "recv certificate request",
[TRY_RECV_CERTIFICATE_VERIFY] = "recv certificate verify",
[TRY_RECV_FINISH] = "recv finished",
[TRY_SEND_FINISH] = "send finished",
};
const char *HS_GetStateStr(uint32_t state)
{
if ((state >= (sizeof(g_stateMachineStr) / sizeof(char *))) || (g_stateMachineStr[state] == NULL)) {
return "unknown";
}
return g_stateMachineStr[state];
}
const char *HS_GetMsgTypeStr(HS_MsgType type)
{
switch (type) {
case HELLO_REQUEST:
return "hello request";
case CLIENT_HELLO:
return "client hello";
case SERVER_HELLO:
return "server hello";
#ifdef HITLS_TLS_PROTO_TLS13
case ENCRYPTED_EXTENSIONS:
return "encrypted extensions";
#endif
case CERTIFICATE:
return "certificate";
case SERVER_KEY_EXCHANGE:
return "server key exchange";
case CERTIFICATE_REQUEST:
return "certificate request";
case SERVER_HELLO_DONE:
return "server hello done";
case CERTIFICATE_VERIFY:
return "certificate verify";
case CLIENT_KEY_EXCHANGE:
return "client key exchange";
case NEW_SESSION_TICKET:
return "new session ticket";
case FINISHED:
return "finished";
default:
break;
}
return "unknown";
}
int32_t HS_ChangeState(TLS_Ctx *ctx, uint32_t nextState)
{
HS_Ctx *hsCtx = (HS_Ctx *)ctx->hsCtx;
hsCtx->state = nextState;
#ifdef HITLS_TLS_FEATURE_MODE_RELEASE_BUFFERS
if ((ctx->config.tlsConfig.modeSupport & HITLS_MODE_RELEASE_BUFFERS) != 0) {
if (hsCtx->state == TLS_CONNECTED) {
RecTryFreeRecBuf(ctx, false);
RecTryFreeRecBuf(ctx, true);
} else if (IsHsSendState(hsCtx->state)) {
RecTryFreeRecBuf(ctx, false);
} else {
RecTryFreeRecBuf(ctx, true);
}
}
#endif
/* when link state is transporting, unexpected hs message should be processed, the log shouldn't be printed during
the hsCtx initiation */
if (ctx->state != CM_STATE_TRANSPORTING) {
#ifdef HITLS_TLS_FEATURE_INDICATOR
if (ctx->isClient) {
INDICATOR_StatusIndicate(ctx, INDICATE_EVENT_STATE_CONNECT_LOOP, INDICATE_VALUE_SUCCESS);
} else {
INDICATOR_StatusIndicate(ctx, INDICATE_EVENT_STATE_ACCEPT_LOOP, INDICATE_VALUE_SUCCESS);
}
#endif /* HITLS_TLS_FEATURE_INDICATOR */
BSL_LOG_BINLOG_VARLEN(BINLOG_ID15573, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"handshake state machine change to:%s.", HS_GetStateStr(nextState));
}
return HITLS_SUCCESS;
}
int32_t HS_CombineRandom(const uint8_t *random1, const uint8_t *random2, uint32_t randomSize,
uint8_t *dest, uint32_t destSize)
{
/** If the random number length is 0 or the memory address is less than twice the random number length, return an
* error code. */
if ((randomSize == 0u) || (destSize < randomSize * 2)) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_RANDOM_SIZE_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15574, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"invalid randomSize for combine random.", 0, 0, 0, 0);
return HITLS_MSG_HANDLE_RANDOM_SIZE_ERR;
}
if (memcpy_s(dest, destSize, random1, randomSize) != EOK) {
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15575, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"combine random1 fail.", 0, 0, 0, 0);
return HITLS_MEMCPY_FAIL;
}
if (memcpy_s(&dest[randomSize], destSize - randomSize, random2, randomSize) != EOK) {
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15576, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"combine random2 fail.", 0, 0, 0, 0);
return HITLS_MEMCPY_FAIL;
}
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_PROTO_TLCP11
uint8_t *HS_PrepareSignDataTlcp(const TLS_Ctx *ctx, const uint8_t *partSignData, uint32_t partSignDataLen,
uint32_t *signDataLen)
{
/* Signature data: client random number + server random number + exchange parameter length + key exchange packet
* data/encryption certificate */
uint32_t exchParamLen = 3;
uint32_t randomLen = HS_RANDOM_SIZE * 2u;
uint32_t dataLen = randomLen + partSignDataLen + exchParamLen;
uint8_t *data = BSL_SAL_Calloc(1u, dataLen);
if (data == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15577, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"signature data memory alloc fail.", 0, 0, 0, 0);
return NULL;
}
(void)memcpy_s(data, dataLen, ctx->hsCtx->clientRandom, HS_RANDOM_SIZE);
(void)memcpy_s(&data[HS_RANDOM_SIZE], dataLen - HS_RANDOM_SIZE, ctx->hsCtx->serverRandom, HS_RANDOM_SIZE);
/* Fill the length of the key exchange parameter */
BSL_Uint24ToByte(partSignDataLen, &data[randomLen]);
/* Copy key exchange packet data */
(void)memcpy_s(&data[randomLen] + exchParamLen, dataLen - randomLen - exchParamLen, partSignData, partSignDataLen);
*signDataLen = dataLen;
return data;
}
#endif
uint8_t *HS_PrepareSignData(const TLS_Ctx *ctx, const uint8_t *partSignData,
uint32_t partSignDataLen, uint32_t *signDataLen)
{
int32_t ret;
/* Signature data: client random number + server random number + key exchange packet data/encryption certificate */
uint32_t randomLen = HS_RANDOM_SIZE * 2u;
uint32_t dataLen = randomLen + partSignDataLen;
uint8_t *data = BSL_SAL_Calloc(1u, dataLen);
if (data == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16813, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
return NULL;
}
(void)memcpy_s(data, dataLen, ctx->hsCtx->clientRandom, HS_RANDOM_SIZE);
(void)memcpy_s(&data[HS_RANDOM_SIZE], dataLen - HS_RANDOM_SIZE, ctx->hsCtx->serverRandom, HS_RANDOM_SIZE);
/* Copy key exchange packet data */
ret = memcpy_s(&data[randomLen], dataLen - randomLen, partSignData, partSignDataLen);
if (ret != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16814, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_SAL_Free(data);
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
return NULL;
}
*signDataLen = dataLen;
return data;
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_SCTP)
/**
* @brief Calculate the sctp auth key
* @details auth key: PRF(SecurityParameters.master_secret, label,
* SecurityParameters.client_random +
* SecurityParameters.server_random)[length]
*
* @param ctx [IN] TLS context
* @param authKey [OUT] Authorization key
* @param authKeyLen [IN] Key length
*
* @retval HITLS_SUCCESS calculation is complete.
* @retval HITLS_MSG_HANDLE_RANDOM_SIZE_ERR The random number length is incorrect.
* @retval For other error codes, see SAL_CRYPT_PRF.
*/
int32_t CalcSctpAuthKey(const TLS_Ctx *ctx, uint8_t *authKey, uint32_t authKeyLen)
{
int32_t ret;
uint8_t randomValue[HS_RANDOM_SIZE * 2] = {0}; // key derivation seed, with the length of two random characters
uint32_t randomValueSize = HS_RANDOM_SIZE * 2; // key derivation seed, with the length of two random characters
HS_Ctx *hsCtx = (HS_Ctx *)ctx->hsCtx;
/** Combine the two random values */
ret = HS_CombineRandom(hsCtx->clientRandom, hsCtx->serverRandom, HS_RANDOM_SIZE, randomValue, randomValueSize);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15579, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"combine random fail.", 0, 0, 0, 0);
return ret;
}
CRYPT_KeyDeriveParameters deriveInfo;
deriveInfo.hashAlgo = ctx->negotiatedInfo.cipherSuiteInfo.hashAlg;
deriveInfo.secret = hsCtx->masterKey;
deriveInfo.secretLen = MASTER_SECRET_LEN;
deriveInfo.label = (const uint8_t *)DTLS_SCTP_AUTH_LABEL;
deriveInfo.labelLen = strlen(DTLS_SCTP_AUTH_LABEL);
deriveInfo.seed = randomValue;
deriveInfo.seedLen = randomValueSize;
deriveInfo.libCtx = LIBCTX_FROM_CTX(ctx);
deriveInfo.attrName = ATTRIBUTE_FROM_CTX(ctx);
/** Key derivation */
ret = SAL_CRYPT_PRF(&deriveInfo, authKey, authKeyLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15580, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SAL_CRYPT_PRF fail when calc sctp auth key.", 0, 0, 0, 0);
}
return ret;
}
int32_t HS_SetSctpAuthKey(TLS_Ctx *ctx)
{
if (!BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_SCTP)) {
return HITLS_SUCCESS;
}
int32_t ret;
uint8_t authKey[DTLS_SCTP_SHARED_AUTHKEY_LEN] = {0};
uint16_t authKeyLen = sizeof(authKey);
ret = CalcSctpAuthKey(ctx, authKey, authKeyLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15581, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"calc sctp auth key failed.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return ret;
}
/* If the UIO_SctpAddAuthKey is added but not active, return HITLS_SUCCESS when the interface
is invoked again */
ret = BSL_UIO_Ctrl(ctx->uio, BSL_UIO_SCTP_ADD_AUTH_SHARED_KEY, (int32_t)authKeyLen, authKey);
/* Clear sensitive information */
BSL_SAL_CleanseData(authKey, DTLS_SCTP_SHARED_AUTHKEY_LEN);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_UIO_SCTP_ADD_AUTH_KEY_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15582, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"uio add sctp auth shared key failed.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return HITLS_UIO_SCTP_ADD_AUTH_KEY_FAIL;
}
return HITLS_SUCCESS;
}
int32_t HS_ActiveSctpAuthKey(TLS_Ctx *ctx)
{
if (!BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_SCTP)) {
return HITLS_SUCCESS;
}
int32_t ret = BSL_UIO_Ctrl(ctx->uio, BSL_UIO_SCTP_ACTIVE_AUTH_SHARED_KEY, 0, NULL);
if (ret != BSL_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15583, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"next sctp auth key error.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return HITLS_UIO_SCTP_ACTIVE_AUTH_KEY_FAIL;
}
return HITLS_SUCCESS;
}
int32_t HS_DeletePreviousSctpAuthKey(TLS_Ctx *ctx)
{
if (!BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_SCTP)) {
return HITLS_SUCCESS;
}
/* After the handshake is complete, delete the old sctp auth key */
int32_t ret = BSL_UIO_Ctrl(ctx->uio, BSL_UIO_SCTP_DEL_PRE_AUTH_SHARED_KEY, 0, NULL);
if (ret != BSL_SUCCESS) {
ret = HITLS_UIO_SCTP_DEL_AUTH_KEY_FAIL;
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15584, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"uio delete sctp auth shared key failed.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
}
return ret;
}
#endif /* defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_SCTP) */
bool IsNeedServerKeyExchange(const TLS_Ctx *ctx)
{
HITLS_KeyExchAlgo kxAlg = ctx->negotiatedInfo.cipherSuiteInfo.kxAlg;
/* Special: If the PSK identity hint is set, the PSK and RSA_PSK may also need to send
* the ServerKeyExchange message
*/
if ((kxAlg == HITLS_KEY_EXCH_PSK) || (kxAlg == HITLS_KEY_EXCH_RSA_PSK)) {
/* In this case, the client receives the ServerKeyExchange message by default */
if (ctx->isClient) {
return true;
} else {
/* If the PSK identity hint is set on the server, the ServerKeyExchange message needs to be sent */
if (ctx->config.tlsConfig.pskIdentityHint != NULL) {
return true;
}
return false;
}
}
#ifdef HITLS_TLS_PROTO_TLCP11
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
return true; /* The TLCP needs to send the ServerKeyExchange message. */
}
#endif
/* The ECDH and DH certificates already contain the public key information, and the ServerKeyExchange message
* is not required. */
/* RSA keys are generated by the client, and the ServerKeyExchange message is not required. */
return ((kxAlg != HITLS_KEY_EXCH_ECDH) && (kxAlg != HITLS_KEY_EXCH_DH) && (kxAlg != HITLS_KEY_EXCH_RSA));
}
bool IsNeedCertPrepare(const CipherSuiteInfo *cipherSuiteInfo)
{
if (cipherSuiteInfo == NULL) {
return false;
}
/* PSK related ciphersuite */
switch (cipherSuiteInfo->kxAlg) {
case HITLS_KEY_EXCH_PSK:
case HITLS_KEY_EXCH_DHE_PSK:
case HITLS_KEY_EXCH_ECDHE_PSK:
return false;
default:
break;
}
/* Anonymous ciphersuite related */
switch (cipherSuiteInfo->authAlg) {
case HITLS_AUTH_NULL:
return false;
default:
break;
}
return true;
}
bool IsTicketSupport(const TLS_Ctx *ctx)
{
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
if (ctx->config.tlsConfig.isSupportSessionTicket && (!ctx->config.isSupportPto)
#ifdef HITLS_TLS_FEATURE_SECURITY
&& (SECURITY_SslCheck(ctx, HITLS_SECURITY_SECOP_TICKET, 0, 0, NULL) == SECURITY_SUCCESS)
#endif
) {
return true;
}
#endif
(void)ctx;
return false;
}
#ifdef HITLS_TLS_FEATURE_PSK
bool IsPskNegotiation(const TLS_Ctx *ctx)
{
HITLS_KeyExchAlgo kxAlg = ctx->negotiatedInfo.cipherSuiteInfo.kxAlg;
return ((kxAlg == HITLS_KEY_EXCH_ECDHE_PSK) || (kxAlg == HITLS_KEY_EXCH_DHE_PSK) ||
(kxAlg == HITLS_KEY_EXCH_RSA_PSK) || (kxAlg == HITLS_KEY_EXCH_PSK));
}
int32_t CheckClientPsk(TLS_Ctx *ctx)
{
uint8_t psk[HS_PSK_MAX_LEN] = {0};
uint8_t identity[HS_PSK_IDENTITY_MAX_LEN + 1] = {0};
/* If the value of psk is not NULL, it has been processed. */
if (ctx->hsCtx->kxCtx->pskInfo != NULL && ctx->hsCtx->kxCtx->pskInfo->psk != NULL) {
return HITLS_SUCCESS;
}
if (ctx->config.tlsConfig.pskClientCb == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID16815, "unregistered pskClientCb");
}
uint32_t pskUsedLen = ctx->config.tlsConfig.pskClientCb(ctx, NULL, identity, HS_PSK_IDENTITY_MAX_LEN,
psk, HS_PSK_MAX_LEN);
if (pskUsedLen == 0 || pskUsedLen > HS_PSK_IDENTITY_MAX_LEN) {
(void)memset_s(psk, HS_PSK_MAX_LEN, 0, HS_PSK_MAX_LEN);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MSG_HANDLE_ILLEGAL_PSK_LEN, BINLOG_ID16816, "pskUsedLen incorrect");
}
/* Length of pskid will not exceed 128 bytes */
uint32_t identityUsedLen = (uint32_t)strnlen((char *)identity, HS_PSK_IDENTITY_MAX_LEN + 1);
if (identityUsedLen > HS_PSK_IDENTITY_MAX_LEN) {
(void)memset_s(psk, HS_PSK_MAX_LEN, 0, HS_PSK_MAX_LEN);
return HITLS_MSG_HANDLE_ILLEGAL_IDENTITY_LEN;
}
if (ctx->hsCtx->kxCtx->pskInfo == NULL) {
ctx->hsCtx->kxCtx->pskInfo = (PskInfo *)BSL_SAL_Calloc(1u, sizeof(PskInfo));
if (ctx->hsCtx->kxCtx->pskInfo == NULL) {
(void)memset_s(psk, HS_PSK_MAX_LEN, 0, HS_PSK_MAX_LEN);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMALLOC_FAIL, BINLOG_ID16694, "Calloc fail");
}
}
uint8_t *tmpIdentity = NULL;
if (identityUsedLen > 0) {
tmpIdentity = (uint8_t *)BSL_SAL_Calloc(1u, (identityUsedLen + 1));
if (tmpIdentity == NULL) {
(void)memset_s(psk, HS_PSK_MAX_LEN, 0, HS_PSK_MAX_LEN);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMALLOC_FAIL, BINLOG_ID16817, "Calloc fail");
}
(void)memcpy_s(tmpIdentity, identityUsedLen + 1, identity, identityUsedLen);
}
ctx->hsCtx->kxCtx->pskInfo->psk = (uint8_t *)BSL_SAL_Dump(psk, pskUsedLen);
(void)memset_s(psk, HS_PSK_MAX_LEN, 0, HS_PSK_MAX_LEN);
if (ctx->hsCtx->kxCtx->pskInfo->psk == NULL) {
BSL_SAL_FREE(tmpIdentity);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMALLOC_FAIL, BINLOG_ID16818, "Dump fail");
}
ctx->hsCtx->kxCtx->pskInfo->pskLen = pskUsedLen;
if (tmpIdentity != NULL) {
BSL_SAL_FREE(ctx->hsCtx->kxCtx->pskInfo->identity);
ctx->hsCtx->kxCtx->pskInfo->identity = tmpIdentity;
ctx->hsCtx->kxCtx->pskInfo->identityLen = identityUsedLen;
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_PSK */
uint32_t HS_GetState(const TLS_Ctx *ctx)
{
if (ctx->hsCtx == NULL) {
return HS_STATE_BUTT;
}
return ctx->hsCtx->state;
}
#ifdef HITLS_TLS_FEATURE_SNI
const char *HS_GetServerName(const TLS_Ctx *ctx)
{
if (ctx == NULL || ctx->hsCtx == NULL) {
return NULL;
}
return (char *)ctx->hsCtx->serverName;
}
#endif
int32_t HS_GrowMsgBuf(TLS_Ctx *ctx, uint32_t msgSize, bool keepOldData)
{
if (msgSize <= ctx->hsCtx->bufferLen) {
return HITLS_SUCCESS;
}
uint32_t bufSize = ctx->hsCtx->bufferLen;
uint32_t oldDataSize = bufSize;
uint8_t *oldDataAddr = ctx->hsCtx->msgBuf;
while (bufSize != 0 && bufSize < msgSize) {
bufSize = bufSize << 1;
}
ctx->hsCtx->msgBuf = BSL_SAL_Calloc(1u, bufSize);
if (ctx->hsCtx->msgBuf == NULL) {
ctx->hsCtx->msgBuf = oldDataAddr;
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15935, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"msgBuf malloc fail while get reass msg.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
ctx->hsCtx->bufferLen = bufSize;
if (keepOldData) {
(void)memcpy_s(ctx->hsCtx->msgBuf, bufSize, oldDataAddr, oldDataSize);
}
BSL_SAL_FREE(oldDataAddr);
return HITLS_SUCCESS;
}
int32_t HS_ReSizeMsgBuf(TLS_Ctx *ctx, uint32_t msgSize)
{
bool keepOldData = false;
return HS_GrowMsgBuf(ctx, msgSize, keepOldData);
}
uint32_t HS_MaxMessageSize(TLS_Ctx *ctx, HS_MsgType type)
{
switch (type) {
case HELLO_REQUEST:
return HITLS_HELLO_REQUEST_MAX_SIZE;
case CLIENT_HELLO:
return HITLS_CLIENT_HELLO_MAX_SIZE;
#ifdef HITLS_TLS_PROTO_DTLS12
case HELLO_VERIFY_REQUEST:
return HITLS_HELLO_VERIFY_REQUEST_MAX_SIZE;
#endif
case SERVER_HELLO:
return HITLS_SERVER_HELLO_MAX_SIZE;
case ENCRYPTED_EXTENSIONS:
return HITLS_ENCRYPTED_EXTENSIONS_MAX_SIZE;
case CERTIFICATE:
if (ctx->config.tlsConfig.maxCertList == 0) {
return HITLS_MAX_CERT_LIST_DEFAULT;
}
return ctx->config.tlsConfig.maxCertList;
case SERVER_KEY_EXCHANGE:
return HITLS_SERVER_KEY_EXCH_MAX_SIZE;
case CERTIFICATE_REQUEST:
if (ctx->config.tlsConfig.maxCertList == 0) {
return HITLS_MAX_CERT_LIST_DEFAULT;
}
return ctx->config.tlsConfig.maxCertList;
case SERVER_HELLO_DONE:
return HITLS_SERVER_HELLO_DONE_MAX_SIZE;
case CLIENT_KEY_EXCHANGE:
return HITLS_CLIENT_KEY_EXCH_MAX_SIZE;
case CERTIFICATE_VERIFY:
return REC_MAX_PLAIN_LENGTH;
case NEW_SESSION_TICKET:
if (HS_GetVersion(ctx) == HITLS_VERSION_TLS13) {
return HITLS_SESSION_TICKET_MAX_SIZE_TLS13;
}
return HITLS_SESSION_TICKET_MAX_SIZE_TLS12;
case END_OF_EARLY_DATA:
return HITLS_END_OF_EARLY_DATA_MAX_SIZE;
case FINISHED:
return HITLS_FINISHED_MAX_SIZE;
case KEY_UPDATE:
return HITLS_KEY_UPDATE_MAX_SIZE;
default:
return 0;
}
}
#ifdef HITLS_TLS_PROTO_TLS13
uint32_t HS_GetBinderLen(HITLS_Session *session, HITLS_HashAlgo *hashAlg)
{
if (*hashAlg != HITLS_HASH_BUTT) {
return SAL_CRYPT_HmacSize(*hashAlg);
}
if (session == NULL) {
return 0;
}
uint16_t cipherSuite = 0;
int32_t ret = HITLS_SESS_GetCipherSuite(session, &cipherSuite);
if (ret != HITLS_SUCCESS) {
return 0;
}
CipherSuiteInfo cipherInfo = {0};
ret = CFG_GetCipherSuiteInfo(cipherSuite, &cipherInfo);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16819, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GetCipherSuiteInfo fail", 0, 0, 0, 0);
return 0;
}
*hashAlg = cipherInfo.hashAlg;
return SAL_CRYPT_HmacSize(*hashAlg);
}
#endif /* HITLS_TLS_PROTO_TLS13 */
bool GroupConformToVersion(const TLS_Ctx *ctx, uint16_t version, uint16_t group)
{
uint32_t versionBits = MapVersion2VersionBit(IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask), version);
const TLS_GroupInfo *groupInfo = ConfigGetGroupInfo(&ctx->config.tlsConfig, group);
if (groupInfo == NULL || ((groupInfo->versionBits & versionBits) != versionBits)) {
return false;
}
return true;
}
uint16_t *CheckSupportSignAlgorithms(const TLS_Ctx *ctx, const uint16_t *signAlgorithms,
uint32_t signAlgorithmsSize, uint32_t *newSignAlgorithmsSize)
{
(void)ctx;
uint32_t validNum = 0;
uint16_t *retSignAlgorithms = BSL_SAL_Calloc(signAlgorithmsSize, sizeof(uint16_t));
if (retSignAlgorithms == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17308, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
return NULL;
}
for (uint32_t i = 0; i < signAlgorithmsSize; i++) {
#ifdef HITLS_TLS_PROTO_TLS13
const uint32_t dsaMask = 0x02;
const uint32_t sha1Mask = 0x0200;
const uint32_t sha224Mask = 0x0300;
if (ctx->config.tlsConfig.maxVersion == HITLS_VERSION_TLS13 &&
ctx->config.tlsConfig.minVersion == HITLS_VERSION_TLS13) {
if (ctx->isClient &&
(((signAlgorithms[i] & 0xff00) == sha1Mask) ||
((signAlgorithms[i] & 0xff00) == sha224Mask))) {
continue;
}
if (((signAlgorithms[i] & 0xff) == dsaMask) ||
signAlgorithms[i] == CERT_SIG_SCHEME_RSA_PKCS1_SHA1 ||
signAlgorithms[i] == CERT_SIG_SCHEME_RSA_PKCS1_SHA224) {
continue;
}
}
#endif /* HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_FEATURE_SECURITY
if (SECURITY_SslCheck(ctx, HITLS_SECURITY_SECOP_SIGALG_CHECK, 0, signAlgorithms[i], NULL) != SECURITY_SUCCESS) {
continue;
}
#endif /* HITLS_TLS_FEATURE_SECURITY */
retSignAlgorithms[validNum] = signAlgorithms[i];
validNum++;
}
*newSignAlgorithmsSize = validNum;
return retSignAlgorithms;
}
uint32_t HS_GetExtensionTypeId(uint32_t hsExtensionsType)
{
switch (hsExtensionsType) {
case HS_EX_TYPE_SERVER_NAME: return HS_EX_TYPE_ID_SERVER_NAME;
case HS_EX_TYPE_SUPPORTED_GROUPS: return HS_EX_TYPE_ID_SUPPORTED_GROUPS;
case HS_EX_TYPE_POINT_FORMATS: return HS_EX_TYPE_ID_POINT_FORMATS;
case HS_EX_TYPE_SIGNATURE_ALGORITHMS: return HS_EX_TYPE_ID_SIGNATURE_ALGORITHMS;
case HS_EX_TYPE_APP_LAYER_PROTOCOLS: return HS_EX_TYPE_ID_APP_LAYER_PROTOCOLS;
case HS_EX_TYPE_ENCRYPT_THEN_MAC: return HS_EX_TYPE_ID_ENCRYPT_THEN_MAC;
case HS_EX_TYPE_EXTENDED_MASTER_SECRET: return HS_EX_TYPE_ID_EXTENDED_MASTER_SECRET;
case HS_EX_TYPE_SESSION_TICKET: return HS_EX_TYPE_ID_SESSION_TICKET;
case HS_EX_TYPE_PRE_SHARED_KEY: return HS_EX_TYPE_ID_PRE_SHARED_KEY;
case HS_EX_TYPE_SUPPORTED_VERSIONS: return HS_EX_TYPE_ID_SUPPORTED_VERSIONS;
case HS_EX_TYPE_COOKIE: return HS_EX_TYPE_ID_COOKIE;
case HS_EX_TYPE_PSK_KEY_EXCHANGE_MODES: return HS_EX_TYPE_ID_PSK_KEY_EXCHANGE_MODES;
case HS_EX_TYPE_CERTIFICATE_AUTHORITIES: return HS_EX_TYPE_ID_CERTIFICATE_AUTHORITIES;
case HS_EX_TYPE_POST_HS_AUTH: return HS_EX_TYPE_ID_POST_HS_AUTH;
case HS_EX_TYPE_KEY_SHARE: return HS_EX_TYPE_ID_KEY_SHARE;
case HS_EX_TYPE_RENEGOTIATION_INFO: return HS_EX_TYPE_ID_RENEGOTIATION_INFO;
default: break;
}
return HS_EX_TYPE_ID_UNRECOGNIZED;
}
int32_t HS_CheckReceivedExtension(HITLS_Ctx *ctx, HS_MsgType hsType, uint64_t hsMsgExtensionsMask,
uint64_t hsMsgAllowedExtensionsMask)
{
if ((hsMsgExtensionsMask & hsMsgAllowedExtensionsMask) != hsMsgExtensionsMask) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_EXTENSION_TYPE);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17311, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"%d msg have illegal extensions, extensionMask: %lu", hsType, hsMsgExtensionsMask, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_ILLEGAL_PARAMETER);
return HITLS_MSG_HANDLE_UNSUPPORT_EXTENSION_TYPE;
}
return HITLS_SUCCESS;
}
bool IsCipherSuiteAllowed(const HITLS_Ctx *ctx, uint16_t cipherSuite)
{
if (!CFG_CheckCipherSuiteSupported(cipherSuite)) {
return false;
}
uint16_t minVersion = ctx->config.tlsConfig.minVersion;
uint16_t maxVersion = ctx->config.tlsConfig.maxVersion;
if (!CFG_CheckCipherSuiteVersion(cipherSuite, minVersion, maxVersion)) {
return false;
}
CipherSuiteInfo cipherInfo = {0};
(void)CFG_GetCipherSuiteInfo(cipherSuite, &cipherInfo);
if ((ctx->isClient && ctx->config.tlsConfig.pskClientCb == NULL) ||
(!ctx->isClient && ctx->config.tlsConfig.pskServerCb == NULL)) {
if ((cipherInfo.kxAlg == HITLS_KEY_EXCH_PSK) ||
(cipherInfo.kxAlg == HITLS_KEY_EXCH_DHE_PSK) ||
(cipherInfo.kxAlg == HITLS_KEY_EXCH_ECDHE_PSK) ||
(cipherInfo.kxAlg == HITLS_KEY_EXCH_RSA_PSK)) {
return false;
}
}
uint16_t negotiatedVersion = ctx->negotiatedInfo.version;
if (negotiatedVersion > 0) {
if (!CFG_CheckCipherSuiteVersion(cipherSuite, negotiatedVersion, negotiatedVersion)) {
return false;
}
}
return true;
} | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/src/hs_common.c | C | unknown | 30,583 |
/*
* 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.
*/
#include "hitls_build.h"
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_uio.h"
#include "bsl_errno.h"
#include "sal_time.h"
#include "hitls.h"
#include "hitls_error.h"
#include "tls_config.h"
#include "hs_ctx.h"
#include "hs_dtls_timer.h"
#define DTLS_HS_2MSL_TIMEOUT_VALUE 240000000 /* 2 times the MSL(Maximum Segment Lifetime) time. Unit: us */
#define DTLS_HS_DEFAULT_TIMEOUT_VALUE 1000000
#define DTLS_HS_MAX_TIMEOUT_VALUE 60000000
#define DTLS_HS_MAX_TIMEOUT_NUM 12 /* Maximum Timeout Times */
#define DTLS_IP_MIN_MTU 548 /* ipv4 min mtu is 576, ipv4 protocol header 20, udp header 8, it needs subtraction here */
#define NEED_REDUCE_MTU_TIMEOUT_NUM 2
static int32_t SetDtlsTimerDeadLine(TLS_Ctx *ctx, uint32_t timeoutValue)
{
HS_Ctx *hsCtx = ctx->hsCtx;
BSL_TIME curTime = {0};
int32_t ret = (int32_t)BSL_SAL_SysTimeGet(&curTime);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_SYS_TIME_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15774, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"BSL_SAL_SysTimeGet fail when start dtls timer.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return HITLS_MSG_HANDLE_SYS_TIME_FAIL;
}
ret = (int32_t)BSL_DateTimeAddUs(&hsCtx->deadline, &curTime, timeoutValue);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_SYS_TIME_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15775, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"BSL_DateTimeAddUs fail when start dtls timer.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return HITLS_MSG_HANDLE_SYS_TIME_FAIL;
}
return HITLS_SUCCESS;
}
int32_t HS_Start2MslTimer(TLS_Ctx *ctx)
{
HS_Ctx *hsCtx = ctx->hsCtx;
if (!BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_UDP)) {
return HITLS_SUCCESS;
}
uint32_t timeoutValue = DTLS_HS_2MSL_TIMEOUT_VALUE;
if (ctx->config.tlsConfig.dtlsPostHsTimeoutVal != 0) {
timeoutValue = ctx->config.tlsConfig.dtlsPostHsTimeoutVal;
}
int32_t ret = SetDtlsTimerDeadLine(ctx, timeoutValue);
if (ret != BSL_SUCCESS) {
return ret;
}
hsCtx->timeoutValue = timeoutValue;
hsCtx->timeoutNum = 0;
return HITLS_SUCCESS;
}
int32_t HS_StartTimer(TLS_Ctx *ctx)
{
HS_Ctx *hsCtx = ctx->hsCtx;
if (!BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_UDP)) {
return HITLS_SUCCESS;
}
uint32_t timeoutValue = DTLS_HS_DEFAULT_TIMEOUT_VALUE;
if (ctx->config.tlsConfig.dtlsTimerCb != NULL) {
timeoutValue = ctx->config.tlsConfig.dtlsTimerCb(ctx, 0);
}
int32_t ret = SetDtlsTimerDeadLine(ctx, timeoutValue);
if (ret != BSL_SUCCESS) {
return ret;
}
hsCtx->timeoutValue = timeoutValue;
hsCtx->timeoutNum = 0;
return HITLS_SUCCESS;
}
int32_t HS_IsTimeout(TLS_Ctx *ctx, bool *isTimeout)
{
HS_Ctx *hsCtx = ctx->hsCtx;
if (!BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_UDP)) {
*isTimeout = false;
return HITLS_SUCCESS;
}
BSL_TIME curTime = {0};
int32_t ret = (int32_t)BSL_SAL_SysTimeGet(&curTime);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_SYS_TIME_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15776, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"BSL_SAL_SysTimeGet fail when judgment dtls timeout.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return HITLS_MSG_HANDLE_SYS_TIME_FAIL;
}
*isTimeout = false;
/* When the server sends the hello verify request, the timer does not need to be started. In this case, the function
* returns a failure. Therefore, the failure is not considered as timeout */
ret = (int32_t)BSL_SAL_DateTimeCompareByUs(&curTime, &hsCtx->deadline);
if (ret == BSL_TIME_DATE_AFTER) {
*isTimeout = true;
}
return HITLS_SUCCESS;
}
int32_t HS_TimeoutProcess(TLS_Ctx *ctx)
{
HS_Ctx *hsCtx = ctx->hsCtx;
if (!BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_UDP)) {
return HITLS_SUCCESS;
}
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15777, BSL_LOG_LEVEL_DEBUG, BSL_LOG_BINLOG_TYPE_RUN,
"dtls timeout, timeoutNum = %u, timeoutValue = %u(us).",
hsCtx->timeoutNum, hsCtx->timeoutValue, 0, 0);
uint32_t timeoutValue = hsCtx->timeoutValue;
if (ctx->config.tlsConfig.dtlsTimerCb != NULL) {
timeoutValue = ctx->config.tlsConfig.dtlsTimerCb(ctx, timeoutValue);
} else {
timeoutValue *= 2; /* 2 indicates that the timeout period for each retransmission is doubled. */
if (timeoutValue > DTLS_HS_MAX_TIMEOUT_VALUE) {
/* The maximum timeout duration of the timer is 60s */
timeoutValue = DTLS_HS_MAX_TIMEOUT_VALUE;
}
}
int32_t ret = SetDtlsTimerDeadLine(ctx, timeoutValue);
if (ret != BSL_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16827, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SetDtlsTimerDeadLine fail", 0, 0, 0, 0);
return ret;
}
hsCtx->timeoutValue = timeoutValue;
hsCtx->timeoutNum++;
if (hsCtx->timeoutNum > NEED_REDUCE_MTU_TIMEOUT_NUM && !ctx->noQueryMtu) {
if (ctx->config.pmtu > DTLS_IP_MIN_MTU) {
ctx->config.pmtu = DTLS_IP_MIN_MTU;
ctx->mtuModified = true;
}
}
if (hsCtx->timeoutNum > DTLS_HS_MAX_TIMEOUT_NUM) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_DTLS_CONNECT_TIMEOUT);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15778, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"dtls connect timeout.", 0, 0, 0, 0);
/* There is no need to send an alert to peer after multiple connection failures */
return HITLS_MSG_HANDLE_DTLS_CONNECT_TIMEOUT;
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_DTLS12 && HITLS_BSL_UIO_UDP */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/src/hs_dtls_timer.c | C | unknown | 6,617 |
/*
* 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.
*/
#include <string.h>
#include "hitls_build.h"
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "hitls_security.h"
#include "crypt.h"
#include "cert_method.h"
#include "session.h"
#ifdef HITLS_TLS_FEATURE_SECURITY
#include "security.h"
#endif
#include "hs_ctx.h"
#include "transcript_hash.h"
#include "hs_common.h"
#include "hs_kx.h"
KeyExchCtx *HS_KeyExchCtxNew(void)
{
KeyExchCtx *keyExchCtx = (KeyExchCtx *)BSL_SAL_Malloc(sizeof(KeyExchCtx));
if (keyExchCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15514, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"keyExchCtx malloc failed.", 0, 0, 0, 0);
return NULL;
}
(void)memset_s(keyExchCtx, sizeof(KeyExchCtx), 0, sizeof(KeyExchCtx));
return keyExchCtx;
}
void HS_KeyExchCtxFree(KeyExchCtx *keyExchCtx)
{
if (keyExchCtx == NULL) {
return;
}
#ifdef HITLS_TLS_FEATURE_PSK
if (keyExchCtx->pskInfo != NULL) {
BSL_SAL_CleanseData(keyExchCtx->pskInfo->psk, keyExchCtx->pskInfo->pskLen);
BSL_SAL_FREE(keyExchCtx->pskInfo->identity);
BSL_SAL_FREE(keyExchCtx->pskInfo->psk);
BSL_SAL_FREE(keyExchCtx->pskInfo);
}
#endif /* HITLS_TLS_FEATURE_PSK */
#ifdef HITLS_TLS_PROTO_TLS13
BSL_SAL_CleanseData(keyExchCtx->pskInfo13.psk, keyExchCtx->pskInfo13.pskLen);
BSL_SAL_FREE(keyExchCtx->pskInfo13.psk);
HITLS_SESS_Free(keyExchCtx->pskInfo13.resumeSession);
keyExchCtx->pskInfo13.resumeSession = NULL;
if (keyExchCtx->pskInfo13.userPskSess != NULL) {
HITLS_SESS_Free(keyExchCtx->pskInfo13.userPskSess->pskSession);
keyExchCtx->pskInfo13.userPskSess->pskSession = NULL;
BSL_SAL_FREE(keyExchCtx->pskInfo13.userPskSess->identity);
BSL_SAL_FREE(keyExchCtx->pskInfo13.userPskSess);
}
BSL_SAL_FREE(keyExchCtx->ciphertext);
#endif /* HITLS_TLS_PROTO_TLS13 */
BSL_SAL_FREE(keyExchCtx->peerPubkey);
SAL_CRYPT_FreeEcdhKey(keyExchCtx->secondKey);
switch (keyExchCtx->keyExchAlgo) {
case HITLS_KEY_EXCH_NULL:
case HITLS_KEY_EXCH_ECDHE:
case HITLS_KEY_EXCH_ECDH:
case HITLS_KEY_EXCH_ECDHE_PSK:
SAL_CRYPT_FreeEcdhKey(keyExchCtx->key);
break;
case HITLS_KEY_EXCH_DHE:
case HITLS_KEY_EXCH_DHE_PSK:
case HITLS_KEY_EXCH_DH:
SAL_CRYPT_FreeDhKey(keyExchCtx->key);
BSL_SAL_FREE(keyExchCtx->keyExchParam.dh.p);
BSL_SAL_FREE(keyExchCtx->keyExchParam.dh.g);
break;
case HITLS_KEY_EXCH_RSA:
default:
break;
}
BSL_SAL_FREE(keyExchCtx);
return;
}
#ifdef HITLS_TLS_HOST_CLIENT
#ifdef HITLS_TLS_SUITE_KX_ECDHE
static bool NamedCurveSupport(HITLS_NamedGroup inNamedGroup, const TLS_Config *config)
{
for (uint32_t i = 0u; i < config->groupsSize; i++) {
if (inNamedGroup == config->groups[i]) {
return true;
}
}
return false;
}
static int32_t ProcessServerKxMsgNamedCurve(TLS_Ctx *ctx, const ServerKeyExchangeMsg *serverKxMsg)
{
HITLS_ECCurveType type = serverKxMsg->keyEx.ecdh.ecPara.type;
HITLS_NamedGroup namedGroup = serverKxMsg->keyEx.ecdh.ecPara.param.namedcurve;
if (NamedCurveSupport(namedGroup, &ctx->config.tlsConfig) == false) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_NAMED_CURVE);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15515, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"no supported curves found.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_ILLEGAL_PARAMETER);
return HITLS_MSG_HANDLE_UNSUPPORT_NAMED_CURVE;
}
uint32_t peerPubkeyLen = serverKxMsg->keyEx.ecdh.pubKeySize;
uint8_t *peerPubkey = BSL_SAL_Malloc(peerPubkeyLen);
if (peerPubkey == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15516, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pubkey malloc fail when process server kx msg named curve.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
(void)memcpy_s(peerPubkey, peerPubkeyLen, serverKxMsg->keyEx.ecdh.pubKey, peerPubkeyLen);
ctx->hsCtx->kxCtx->keyExchParam.ecdh.curveParams.type = type;
ctx->hsCtx->kxCtx->keyExchParam.ecdh.curveParams.param.namedcurve = namedGroup;
HITLS_CRYPT_Key *key = SAL_CRYPT_GenEcdhKeyPair(ctx, &ctx->hsCtx->kxCtx->keyExchParam.ecdh.curveParams);
if (key == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_ERR_ENCODE_ECDH_KEY);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15517, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"get ecdh key pair fail when process server kx msg named curve.", 0, 0, 0, 0);
BSL_SAL_FREE(peerPubkey);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return HITLS_MSG_HANDLE_ERR_ENCODE_ECDH_KEY;
}
ctx->hsCtx->kxCtx->key = key;
ctx->hsCtx->kxCtx->peerPubkey = peerPubkey;
ctx->hsCtx->kxCtx->pubKeyLen = peerPubkeyLen;
ctx->negotiatedInfo.negotiatedGroup = namedGroup;
return HITLS_SUCCESS;
}
int32_t HS_ProcessServerKxMsgEcdhe(TLS_Ctx *ctx, const ServerKeyExchangeMsg *serverKxMsg)
{
HITLS_ECCurveType type = serverKxMsg->keyEx.ecdh.ecPara.type;
switch (type) {
case HITLS_EC_CURVE_TYPE_NAMED_CURVE:
return ProcessServerKxMsgNamedCurve(ctx, serverKxMsg);
default:
break;
}
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNKNOWN_CURVE_TYPE);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15518, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"unknow the curve type in server kx msg.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return HITLS_MSG_HANDLE_UNKNOWN_CURVE_TYPE;
}
#endif /* HITLS_TLS_SUITE_KX_ECDHE */
#ifdef HITLS_TLS_SUITE_KX_DHE
int32_t HS_ProcessServerKxMsgDhe(TLS_Ctx *ctx, const ServerKeyExchangeMsg *serverKxMsg)
{
const ServerDh *dh = &serverKxMsg->keyEx.dh;
HITLS_CRYPT_Key *key = SAL_CRYPT_GenerateDhKeyByParams(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
dh->p, dh->plen, dh->g, dh->glen);
if (key == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_ERR_ENCODE_DH_KEY);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15519, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"get dhe key pair fail when process server dhe kx msg.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return HITLS_MSG_HANDLE_ERR_ENCODE_DH_KEY;
}
uint8_t *pubkey = BSL_SAL_Dump(dh->pubkey, dh->pubKeyLen);
if (pubkey == NULL) {
SAL_CRYPT_FreeDhKey(key);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15520, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pubkey malloc fail when process server dhe kx msg.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
ctx->hsCtx->kxCtx->keyExchParam.dh.plen = dh->plen;
ctx->hsCtx->kxCtx->key = key;
ctx->hsCtx->kxCtx->peerPubkey = pubkey;
ctx->hsCtx->kxCtx->pubKeyLen = dh->pubKeyLen;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_SUITE_KX_DHE */
#endif /* HITLS_TLS_HOST_CLIENT */
#ifdef HITLS_TLS_HOST_SERVER
#ifdef HITLS_TLS_SUITE_KX_ECDHE
static int32_t ProcessClientKxMsgNamedCurve(TLS_Ctx *ctx, const ClientKeyExchangeMsg *clientKxMsg)
{
uint32_t peerPubkeyLen = clientKxMsg->dataSize;
uint8_t *peerPubkey = BSL_SAL_Malloc(peerPubkeyLen);
if (peerPubkey == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15521, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pubkey malloc fail when process client kx msg named curve.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
(void)memcpy_s(peerPubkey, peerPubkeyLen, clientKxMsg->data, peerPubkeyLen);
ctx->hsCtx->kxCtx->peerPubkey = peerPubkey;
ctx->hsCtx->kxCtx->pubKeyLen = peerPubkeyLen;
return HITLS_SUCCESS;
}
int32_t HS_ProcessClientKxMsgEcdhe(TLS_Ctx *ctx, const ClientKeyExchangeMsg *clientKxMsg)
{
HITLS_ECCurveType type = ctx->hsCtx->kxCtx->keyExchParam.ecdh.curveParams.type;
switch (type) {
case HITLS_EC_CURVE_TYPE_NAMED_CURVE:
return ProcessClientKxMsgNamedCurve(ctx, clientKxMsg);
default:
break;
}
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNKNOWN_CURVE_TYPE);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15522, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"unknow the curve type in client kx msg.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return HITLS_MSG_HANDLE_UNKNOWN_CURVE_TYPE;
}
#endif /* HITLS_TLS_SUITE_KX_ECDHE */
#ifdef HITLS_TLS_SUITE_KX_DHE
int32_t HS_ProcessClientKxMsgDhe(TLS_Ctx *ctx, const ClientKeyExchangeMsg *clientKxMsg)
{
uint32_t peerPubkeyLen = clientKxMsg->dataSize;
uint8_t *peerPubkey = BSL_SAL_Dump(clientKxMsg->data, peerPubkeyLen);
if (peerPubkey == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15523, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pubkey malloc fail when process client dhe kx msg.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
ctx->hsCtx->kxCtx->peerPubkey = peerPubkey;
ctx->hsCtx->kxCtx->pubKeyLen = peerPubkeyLen;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_SUITE_KX_DHE */
#ifdef HITLS_TLS_SUITE_KX_RSA
int32_t HS_ProcessClientKxMsgRsa(TLS_Ctx *ctx, const ClientKeyExchangeMsg *clientKxMsg)
{
int32_t ret = HITLS_SUCCESS;
HS_Ctx *hsCtx = ctx->hsCtx;
KeyExchCtx *keyExchCtx = hsCtx->kxCtx;
uint32_t secretLen = clientKxMsg->dataSize < MASTER_SECRET_LEN ? MASTER_SECRET_LEN : clientKxMsg->dataSize;
uint8_t *premasterSecret = BSL_SAL_Calloc(1u, secretLen);
if (premasterSecret == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15524, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Decrypt RSA-Encrypted Premaster Secret error: out of memory.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
uint8_t premaster[MASTER_SECRET_LEN];
ret = SAL_CRYPT_Rand(LIBCTX_FROM_CTX(ctx), premaster, MASTER_SECRET_LEN);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(premasterSecret);
return ret;
}
CERT_MgrCtx *certMgrCtx = ctx->config.tlsConfig.certMgrCtx;
HITLS_CERT_Key *privateKey = SAL_CERT_GetCurrentPrivateKey(certMgrCtx, false);
uint32_t valid = ~(uint32_t)SAL_CERT_KeyDecrypt(ctx, privateKey, clientKxMsg->data,
clientKxMsg->dataSize, premasterSecret, &secretLen);
valid &= Uint32ConstTimeEqual(secretLen, MASTER_SECRET_LEN);
// Check the version in the premaster secret
uint16_t version = ctx->negotiatedInfo.clientVersion;
uint32_t versionCheck = Uint32ConstTimeEqual(version, HITLS_VERSION_TLS11) |
Uint32ConstTimeEqual(version, HITLS_VERSION_TLS12) |
Uint32ConstTimeEqual(version, HITLS_VERSION_DTLS12) |
~Uint32ConstTimeIsZero((uint32_t)ctx->config.tlsConfig.needCheckPmsVersion);
valid &= (~versionCheck) | Uint32ConstTimeEqual(version, BSL_ByteToUint16(premasterSecret));
for (uint32_t i = 0; i < MASTER_SECRET_LEN; i++) {
uint32_t mask = valid & Uint32ConstTimeLt(i, secretLen);
keyExchCtx->keyExchParam.rsa.preMasterSecret[i] =
Uint8ConstTimeSelect(mask, premasterSecret[i & mask], premaster[i]);
}
BSL_SAL_CleanseData(premasterSecret, secretLen);
BSL_SAL_FREE(premasterSecret);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_SUITE_KX_RSA */
#ifdef HITLS_TLS_PROTO_TLCP11
int32_t HS_ProcessClientKxMsgSm2(TLS_Ctx *ctx, const ClientKeyExchangeMsg *clientKxMsg)
{
int32_t ret = HITLS_SUCCESS;
HS_Ctx *hsCtx = ctx->hsCtx;
KeyExchCtx *keyExchCtx = hsCtx->kxCtx;
uint8_t *preMasterSecret = BSL_SAL_Calloc(1u, clientKxMsg->dataSize);
if (preMasterSecret == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16213, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Decrypt SM2-Encrypted PremasterSecret error: out of memory", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
uint32_t secretLen = clientKxMsg->dataSize;
CERT_MgrCtx *certMgrCtx = ctx->config.tlsConfig.certMgrCtx;
HITLS_CERT_Key *privateKey = SAL_CERT_GetCurrentPrivateKey(certMgrCtx, true);
ret = SAL_CERT_KeyDecrypt(ctx, privateKey, clientKxMsg->data, clientKxMsg->dataSize, preMasterSecret, &secretLen);
if ((ret != HITLS_SUCCESS) || (secretLen != MASTER_SECRET_LEN)) {
/* If the server fails to process the message, it is prohibited to send the alert message. The randomly
* generated premaster secret must be used to continue the handshake */
SAL_CRYPT_Rand(LIBCTX_FROM_CTX(ctx), keyExchCtx->keyExchParam.ecc.preMasterSecret, MASTER_SECRET_LEN);
BSL_SAL_FREE(preMasterSecret);
return HITLS_SUCCESS;
}
uint16_t clientVersion = BSL_ByteToUint16(preMasterSecret);
// In any case, a TLS server MUST NOT generate an alert if processing an RSA-encrypted
// premaster secret message fails, or the version number is not as expected.
if (ctx->negotiatedInfo.clientVersion != clientVersion) {
// If the version does not match, a 46-byte preMasterSecret is randomly generated
uint16_t version = ctx->negotiatedInfo.clientVersion;
uint32_t offset = 0u;
// 8：right shift a byte
keyExchCtx->keyExchParam.ecc.preMasterSecret[offset++] = (uint8_t)(version >> 8);
keyExchCtx->keyExchParam.ecc.preMasterSecret[offset++] = (uint8_t)(version);
SAL_CRYPT_Rand(LIBCTX_FROM_CTX(ctx), keyExchCtx->keyExchParam.ecc.preMasterSecret + offset, MASTER_SECRET_LEN - offset);
BSL_SAL_CleanseData(preMasterSecret, secretLen);
BSL_SAL_FREE(preMasterSecret);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15348, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Parse RSA-Encrypted Premaster Secret client version mismatch: msg clientVersion = %u, \
ctx->negotiatedInfo.clientVersion = %u.", clientVersion, ctx->negotiatedInfo.clientVersion, 0, 0);
return HITLS_SUCCESS;
}
(void)memcpy_s(keyExchCtx->keyExchParam.ecc.preMasterSecret, MASTER_SECRET_LEN, preMasterSecret, secretLen);
BSL_SAL_CleanseData(preMasterSecret, secretLen);
BSL_SAL_FREE(preMasterSecret);
return HITLS_SUCCESS;
}
#endif
#endif /* HITLS_TLS_HOST_SERVER */
#ifdef HITLS_TLS_FEATURE_PSK
static int32_t AppendPsk(uint8_t *pskPmsBuf, uint32_t pskPmsBufLen, uint8_t *psk, uint32_t pskLen)
{
uint32_t offset = 0u;
uint8_t *pskPmsBufTmp = pskPmsBuf;
BSL_Uint16ToByte((uint16_t)pskLen, pskPmsBufTmp);
offset += sizeof(uint16_t);
if (memcpy_s(&pskPmsBufTmp[offset], pskPmsBufLen - offset, psk, pskLen) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16828, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
return HITLS_MEMCPY_FAIL;
}
return HITLS_SUCCESS;
}
static int32_t GeneratePskPreMasterSecret(TLS_Ctx *ctx, uint8_t *pmsBuf, uint32_t pmsBufLen, uint32_t *pmsUsedLen)
{
int32_t ret = HITLS_SUCCESS;
uint32_t offset = 0u;
uint8_t tmpPskPmsBufTmp[MAX_PRE_MASTER_SECRET_SIZE] = {0};
uint8_t *psk = ctx->hsCtx->kxCtx->pskInfo->psk;
uint32_t pskLen = ctx->hsCtx->kxCtx->pskInfo->pskLen;
if (psk == NULL || pskLen > HS_PSK_MAX_LEN) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_NULL_INPUT, BINLOG_ID16829, "input null");
}
switch (ctx->hsCtx->kxCtx->keyExchAlgo) {
/* |shareKeyLen(2 byte)|shareKey|PskLen(2 byte)|psk| */
case HITLS_KEY_EXCH_DHE_PSK:
case HITLS_KEY_EXCH_ECDHE_PSK:
/* Padding ShareKeyLen */
BSL_Uint16ToByte((uint16_t)*pmsUsedLen, &tmpPskPmsBufTmp[offset]);
offset += sizeof(uint16_t);
/* Padding ShareKey */
ret = memcpy_s(&tmpPskPmsBufTmp[offset], MAX_PRE_MASTER_SECRET_SIZE - offset, pmsBuf, *pmsUsedLen);
offset += *pmsUsedLen;
break;
/* |48(2 byte)|version number(2 byte)|rand value(46 byte)|pskLen(2 byte)|psk| */
case HITLS_KEY_EXCH_RSA_PSK:
/* Padding the length (Version + RandValue). The value is fixed to 48 */
BSL_Uint16ToByte(MASTER_SECRET_LEN, &tmpPskPmsBufTmp[offset]);
offset = sizeof(uint16_t);
/* Padding |Version|RandValue| */
ret = memcpy_s(&tmpPskPmsBufTmp[offset], MAX_PRE_MASTER_SECRET_SIZE - offset, pmsBuf, *pmsUsedLen);
offset += MASTER_SECRET_LEN;
break;
/* |N(2 byte)|N 0s|N(2 byte)|psk|, N stands for pskLen */
case HITLS_KEY_EXCH_PSK:
/* Padding pskLen */
BSL_Uint16ToByte((uint16_t)pskLen, &tmpPskPmsBufTmp[offset]);
offset = sizeof(uint16_t);
/* padding pskLen with zeros */
ret = memset_s(&tmpPskPmsBufTmp[offset], MAX_PRE_MASTER_SECRET_SIZE - offset, 0, pskLen);
offset += pskLen;
break;
default:
/* no key exchange algo matched */
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MSG_HANDLE_UNSUPPORT_KX_ALG, BINLOG_ID16830, "unknow keyExchAlgo");
}
if (ret != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16831, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"key exchange algo is %d, memcpy fail", ctx->hsCtx->kxCtx->keyExchAlgo, 0, 0, 0);
goto ERR;
}
if (AppendPsk(&tmpPskPmsBufTmp[offset], MAX_PRE_MASTER_SECRET_SIZE - offset, psk, pskLen) != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16832, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "AppendPsk fail", 0, 0, 0, 0);
goto ERR;
}
offset += (sizeof(uint16_t) + pskLen);
if (memcpy_s(pmsBuf, pmsBufLen, tmpPskPmsBufTmp, offset) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16833, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
goto ERR;
}
*pmsUsedLen = offset;
(void)memset_s(tmpPskPmsBufTmp, MAX_PRE_MASTER_SECRET_SIZE, 0, MAX_PRE_MASTER_SECRET_SIZE);
return HITLS_SUCCESS;
ERR:
(void)memset_s(tmpPskPmsBufTmp, MAX_PRE_MASTER_SECRET_SIZE, 0, MAX_PRE_MASTER_SECRET_SIZE);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
#endif /* HITLS_TLS_FEATURE_PSK */
int32_t DeriveMasterSecret(TLS_Ctx *ctx, const uint8_t *preMasterSecret, uint32_t len)
{
int32_t ret = HITLS_SUCCESS;
const uint8_t masterSecretLabel[] = "master secret";
const uint8_t exMasterSecretLabel[] = "extended master secret";
uint8_t seed[HS_RANDOM_SIZE * 2] = {0}; // seed size is twice the random size
uint32_t seedLen = sizeof(seed);
bool isExtendedMasterSecret = ctx->negotiatedInfo.isExtendedMasterSecret;
CRYPT_KeyDeriveParameters deriveInfo;
deriveInfo.hashAlgo = ctx->negotiatedInfo.cipherSuiteInfo.hashAlg;
deriveInfo.secret = preMasterSecret;
deriveInfo.secretLen = len;
if (isExtendedMasterSecret) {
deriveInfo.label = exMasterSecretLabel;
deriveInfo.labelLen = sizeof(exMasterSecretLabel) - 1u;
ret = VERIFY_CalcSessionHash(
ctx->hsCtx->verifyCtx, seed, &seedLen); // Use session hash as seed for key deriviation
} else {
deriveInfo.label = masterSecretLabel;
deriveInfo.labelLen = sizeof(masterSecretLabel) - 1u;
ret = HS_CombineRandom(ctx->hsCtx->clientRandom, ctx->hsCtx->serverRandom, HS_RANDOM_SIZE, seed, seedLen);
}
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(
BINLOG_ID15525, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "get PRF seed fail.", 0, 0, 0, 0);
return ret;
}
deriveInfo.seed = seed;
deriveInfo.seedLen = seedLen;
deriveInfo.libCtx = LIBCTX_FROM_CTX(ctx);
deriveInfo.attrName = ATTRIBUTE_FROM_CTX(ctx);
ret = SAL_CRYPT_PRF(&deriveInfo, ctx->hsCtx->masterKey, MASTER_SECRET_LEN);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15526, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"failed to invoke the PRF function.", 0, 0, 0, 0);
return ret;
}
#ifdef HITLS_TLS_MAINTAIN_KEYLOG
if (HITLS_LogSecret(ctx, MASTER_SECRET_LABEL, ctx->hsCtx->masterKey,
MASTER_SECRET_LEN) != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15336, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"failed to LogSecret, MASTER_SECRET_LABEL.", 0, 0, 0, 0);
}
#endif /* HITLS_TLS_MAINTAIN_KEYLOG */
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_SUITE_KX_ECDHE
static int32_t GenPremasterSecretFromEcdhe(TLS_Ctx *ctx, uint8_t *preMasterSecret, uint32_t *preMasterSecretLen)
{
#ifdef HITLS_TLS_PROTO_TLCP11
int32_t ret = HITLS_SUCCESS;
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
HITLS_Config *config = &ctx->config.tlsConfig;
CERT_MgrCtx *certMgrCtx = config->certMgrCtx;
HITLS_CERT_Key *priKey = SAL_CERT_GetCurrentPrivateKey(certMgrCtx, true);
if (priKey == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16834, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GetCurrentPrivateKey fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CERT_ERR_EXP_CERT);
return HITLS_CERT_ERR_EXP_CERT;
}
HITLS_CRYPT_Key *peerPubKey = NULL;
HITLS_CERT_X509 *cert = SAL_CERT_GetTlcpEncCert(ctx->hsCtx->peerCert);
ret = SAL_CERT_X509Ctrl(config, cert, CERT_CTRL_GET_PUB_KEY, NULL, (void *)&peerPubKey);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16835, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GET_PUB_KEY fail", 0, 0, 0, 0);
return ret;
}
*preMasterSecretLen = MASTER_SECRET_LEN;
HITLS_Sm2GenShareKeyParameters sm2ShareKeyParam = {ctx->hsCtx->kxCtx->key, ctx->hsCtx->kxCtx->peerPubkey,
ctx->hsCtx->kxCtx->pubKeyLen, priKey, peerPubKey, ctx->isClient };
ret = SAL_CRYPT_CalcSm2dhSharedSecret(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
&sm2ShareKeyParam, preMasterSecret, preMasterSecretLen);
SAL_CERT_KeyFree(certMgrCtx, peerPubKey);
return ret;
}
#endif
return SAL_CRYPT_CalcEcdhSharedSecret(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
ctx->hsCtx->kxCtx->key, ctx->hsCtx->kxCtx->peerPubkey,
ctx->hsCtx->kxCtx->pubKeyLen, preMasterSecret, preMasterSecretLen);
}
#endif /* HITLS_TLS_SUITE_KX_ECDHE */
static int32_t GenPreMasterSecret(TLS_Ctx *ctx, uint8_t *preMasterSecret, uint32_t *preMasterSecretLen)
{
int32_t ret = HITLS_SUCCESS;
KeyExchCtx *keyExchCtx = ctx->hsCtx->kxCtx;
(void)preMasterSecret;
(void)preMasterSecretLen;
switch (keyExchCtx->keyExchAlgo) {
#ifdef HITLS_TLS_SUITE_KX_ECDHE
case HITLS_KEY_EXCH_ECDHE:
case HITLS_KEY_EXCH_ECDHE_PSK:
ret = GenPremasterSecretFromEcdhe(ctx, preMasterSecret, preMasterSecretLen);
break;
#endif /* HITLS_TLS_SUITE_KX_ECDHE */
#ifdef HITLS_TLS_SUITE_KX_DHE
case HITLS_KEY_EXCH_DHE:
case HITLS_KEY_EXCH_DHE_PSK:
ret = SAL_CRYPT_CalcDhSharedSecret(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx), keyExchCtx->key,
keyExchCtx->peerPubkey, keyExchCtx->pubKeyLen,
preMasterSecret, preMasterSecretLen);
break;
#endif /* HITLS_TLS_SUITE_KX_DHE */
#ifdef HITLS_TLS_SUITE_KX_RSA
case HITLS_KEY_EXCH_RSA:
case HITLS_KEY_EXCH_RSA_PSK:
if (memcpy_s(preMasterSecret, *preMasterSecretLen,
keyExchCtx->keyExchParam.rsa.preMasterSecret, MASTER_SECRET_LEN) != EOK) {
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMCPY_FAIL, BINLOG_ID16836, "memcpy fail");
}
*preMasterSecretLen = MASTER_SECRET_LEN;
break;
#endif /* HITLS_TLS_SUITE_KX_RSA */
#ifdef HITLS_TLS_PROTO_TLCP11
case HITLS_KEY_EXCH_ECC:
if (memcpy_s(preMasterSecret, *preMasterSecretLen,
keyExchCtx->keyExchParam.ecc.preMasterSecret, MASTER_SECRET_LEN) != EOK) {
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMCPY_FAIL, BINLOG_ID16837, "memcpy fail");
}
*preMasterSecretLen = MASTER_SECRET_LEN;
break;
#endif
case HITLS_KEY_EXCH_PSK:
break;
default:
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_KX_ALG);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MSG_HANDLE_UNSUPPORT_KX_ALG, BINLOG_ID16838, "unknow keyExchAlgo");
}
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
int32_t HS_GenerateMasterSecret(TLS_Ctx *ctx)
{
int32_t ret = HITLS_SUCCESS;
uint8_t preMasterSecret[MAX_PRE_MASTER_SECRET_SIZE] = {0};
/* key exchange algorithm contains psk, preMasterSecret: |uint16_t|MAX_OTHER_SECRET_SIZE|uint16_t|HS_PSK_MAX_LEN|
key exchange algorithm not contains psk, preMasterSecret: |MAX_OTHER_SECRET_SIZE| */
uint32_t preMasterSecretLen = MAX_OTHER_SECRET_SIZE;
ret = GenPreMasterSecret(ctx, preMasterSecret, &preMasterSecretLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15527, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"calc ecdh shared secret failed.", 0, 0, 0, 0);
return ret;
}
#ifdef HITLS_TLS_FEATURE_PSK
/* re-arrange preMasterSecret for psk negotiation */
if (IsPskNegotiation(ctx)) {
ret = GeneratePskPreMasterSecret(ctx, preMasterSecret, MAX_PRE_MASTER_SECRET_SIZE, &preMasterSecretLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_CleanseData(preMasterSecret, MAX_PRE_MASTER_SECRET_SIZE);
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
}
#endif /* HITLS_TLS_FEATURE_PSK */
ret = DeriveMasterSecret(ctx, preMasterSecret, preMasterSecretLen);
BSL_SAL_CleanseData(preMasterSecret, MAX_PRE_MASTER_SECRET_SIZE);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15528, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"derive master secret failed.", 0, 0, 0, 0);
}
return ret;
}
int32_t HS_SetInitPendingStateParam(const TLS_Ctx *ctx, bool isClient, REC_SecParameters *keyPara)
{
const HS_Ctx *hsCtx = (HS_Ctx *)ctx->hsCtx;
const CipherSuiteInfo *cipherSuiteInfo = &ctx->negotiatedInfo.cipherSuiteInfo;
keyPara->isClient = isClient;
keyPara->prfAlg = cipherSuiteInfo->hashAlg;
keyPara->macAlg = cipherSuiteInfo->macAlg;
keyPara->cipherAlg = cipherSuiteInfo->cipherAlg;
keyPara->cipherType = cipherSuiteInfo->cipherType;
keyPara->fixedIvLength = cipherSuiteInfo->fixedIvLength; /** iv length. In the TLS1.2 AEAD algorithm, iv length is
the implicit IV length. */
keyPara->encKeyLen = cipherSuiteInfo->encKeyLen;
keyPara->macKeyLen = cipherSuiteInfo->macKeyLen; /** If the AEAD algorithm is used, the MAC key length is zero. */
keyPara->blockLength = cipherSuiteInfo->blockLength;
keyPara->recordIvLength = cipherSuiteInfo->recordIvLength; /** The explicit IV needs to be sent to the peer. */
keyPara->macLen = cipherSuiteInfo->macLen;
if (ctx->negotiatedInfo.version != HITLS_VERSION_TLS13) {
uint32_t clientRandomSize = HS_RANDOM_SIZE;
if (memcpy_s(keyPara->clientRandom, clientRandomSize, hsCtx->clientRandom, HS_RANDOM_SIZE) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16114, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Client random value copy failed.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
uint32_t serverRandomSize = HS_RANDOM_SIZE;
if (memcpy_s(keyPara->serverRandom, serverRandomSize, hsCtx->serverRandom, HS_RANDOM_SIZE) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16115, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Server random value copy failed.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
}
return HITLS_SUCCESS;
}
int32_t HS_KeyEstablish(TLS_Ctx *ctx, bool isClient)
{
int32_t ret = HITLS_SUCCESS;
REC_SecParameters keyPara;
uint32_t masterSecretSize = MASTER_SECRET_LEN;
ret = HS_SetInitPendingStateParam(ctx, isClient, &keyPara);
if (ret != HITLS_SUCCESS) {
return ret;
}
(void)memcpy_s(keyPara.masterSecret, masterSecretSize, ctx->hsCtx->masterKey, MASTER_SECRET_LEN);
ret = REC_InitPendingState(ctx, &keyPara);
(void)memset_s(keyPara.masterSecret, MASTER_SECRET_LEN, 0, MASTER_SECRET_LEN);
return ret;
}
#ifdef HITLS_TLS_FEATURE_SESSION
int32_t HS_ResumeKeyEstablish(TLS_Ctx *ctx)
{
HS_Ctx *hsCtx = (HS_Ctx *)ctx->hsCtx;
uint32_t masterKeySize = MAX_DIGEST_SIZE;
int32_t ret = HITLS_SESS_GetMasterKey(ctx->session, hsCtx->masterKey, &masterKeySize);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15529, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Resume session: get master secret failed.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return ret;
}
ret = HS_KeyEstablish(ctx, ctx->isClient);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15530, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"server key establish fail.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return ret;
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_SCTP)
ret = HS_SetSctpAuthKey(ctx);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16839, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
"SetSctpAuthKey fail", 0, 0, 0, 0);
}
#endif
return ret;
}
#endif /* HITLS_TLS_FEATURE_SESSION */
#ifdef HITLS_TLS_FEATURE_PSK
int32_t HS_ProcessServerKxMsgIdentityHint(TLS_Ctx *ctx, const ServerKeyExchangeMsg *serverKxMsg)
{
if (ctx == NULL || serverKxMsg == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16840, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
return HITLS_NULL_INPUT;
}
uint8_t psk[HS_PSK_MAX_LEN] = {0};
uint8_t identity[HS_PSK_IDENTITY_MAX_LEN + 1] = {0};
int32_t ret = HITLS_SUCCESS;
do {
if (ctx->config.tlsConfig.pskClientCb == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16841, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pskClientCb null", 0, 0, 0, 0);
ret = HITLS_UNREGISTERED_CALLBACK;
break;
}
uint32_t pskUsedLen = ctx->config.tlsConfig.pskClientCb(ctx, serverKxMsg->pskIdentityHint, identity,
HS_PSK_IDENTITY_MAX_LEN, psk, HS_PSK_MAX_LEN);
if (pskUsedLen == 0 || pskUsedLen > HS_PSK_MAX_LEN) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16842, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"psk len err", 0, 0, 0, 0);
ret = HITLS_MSG_HANDLE_ILLEGAL_PSK_LEN;
break;
}
uint32_t identityUsedLen = (uint32_t)strnlen((char *)identity, HS_PSK_IDENTITY_MAX_LEN + 1);
if (identityUsedLen > HS_PSK_IDENTITY_MAX_LEN) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16843, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"identity len err", 0, 0, 0, 0);
ret = HITLS_MSG_HANDLE_ILLEGAL_IDENTITY_LEN;
break;
}
if (ctx->hsCtx->kxCtx->pskInfo == NULL) {
ctx->hsCtx->kxCtx->pskInfo = (PskInfo *)BSL_SAL_Calloc(1u, sizeof(PskInfo));
if (ctx->hsCtx->kxCtx->pskInfo == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16844, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Calloc fail", 0, 0, 0, 0);
ret = HITLS_MEMALLOC_FAIL;
break;
}
}
uint8_t *tmpIdentity = (uint8_t *)BSL_SAL_Calloc(1u, (identityUsedLen + 1) * sizeof(uint8_t));
if (tmpIdentity == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16845, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc err", 0, 0, 0, 0);
ret = HITLS_MEMALLOC_FAIL;
break;
}
(void)memcpy_s(tmpIdentity, identityUsedLen + 1, identity, identityUsedLen);
uint8_t *tmpPsk = (uint8_t *)BSL_SAL_Dump(psk, pskUsedLen);
if (tmpPsk == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16846, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
BSL_SAL_FREE(tmpIdentity);
ret = HITLS_MEMALLOC_FAIL;
break;
}
BSL_SAL_FREE(ctx->hsCtx->kxCtx->pskInfo->identity);
ctx->hsCtx->kxCtx->pskInfo->identity = tmpIdentity;
ctx->hsCtx->kxCtx->pskInfo->identityLen = identityUsedLen;
BSL_SAL_FREE(ctx->hsCtx->kxCtx->pskInfo->psk);
ctx->hsCtx->kxCtx->pskInfo->psk = tmpPsk;
ctx->hsCtx->kxCtx->pskInfo->pskLen = pskUsedLen;
} while (false);
(void)memset_s(psk, HS_PSK_MAX_LEN, 0, HS_PSK_MAX_LEN);
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
#endif /* HITLS_TLS_FEATURE_PSK */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/src/hs_kx.c | C | unknown | 34,033 |
/*
* 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.
*/
#include <string.h>
#include "hitls_build.h"
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "hs_kx.h"
#include "transcript_hash.h"
#include "hs_verify.h"
#define HS_VERIFY_DATA_LEN 12u
#define CLIENT_FINISHED_LABEL "client finished"
#define SERVER_FINISHED_LABEL "server finished"
#ifdef HITLS_TLS_PROTO_TLS13
#define MSG_HASH_HEADER_SIZE 4 /* message_hash message header length */
#define MAX_MSG_HASH_SIZE (MAX_DIGEST_SIZE + MSG_HASH_HEADER_SIZE) /* Maximum message_hash message length */
#endif /* HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_PROTO_TLS13
#define TLS13_CLIENT_CERT_VERIFY_LABEL "TLS 1.3, client CertificateVerify"
#define TLS13_SERVER_CERT_VERIFY_LABEL "TLS 1.3, server CertificateVerify"
#define TLS13_CERT_VERIFY_PREFIX 0x20 /* The signature data in TLS 1.3 is firstly filled with 64 0x20s */
#define TLS13_CERT_VERIFY_PREFIX_LEN 64
#endif /* #ifdef HITLS_TLS_PROTO_TLS13 */
int32_t VERIFY_Init(HS_Ctx *hsCtx)
{
VERIFY_Deinit(hsCtx);
VerifyCtx *verifyCtx = (VerifyCtx *)BSL_SAL_Calloc(1u, sizeof(VerifyCtx));
if (verifyCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15475, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Verify init error: out of memory.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
verifyCtx->dataBuf = (HsMsgCache *)BSL_SAL_Calloc(1u, sizeof(HsMsgCache));
if (verifyCtx->dataBuf == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15476, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Verify databuf malloc error: out of memory.", 0, 0, 0, 0);
BSL_SAL_FREE(verifyCtx);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
hsCtx->verifyCtx = verifyCtx;
return HITLS_SUCCESS;
}
void VERIFY_Deinit(HS_Ctx *hsCtx)
{
if (hsCtx == NULL) {
return;
}
VerifyCtx *verifyCtx = hsCtx->verifyCtx;
if (verifyCtx == NULL) {
return;
}
if (verifyCtx->hashCtx != NULL) {
SAL_CRYPT_DigestFree(verifyCtx->hashCtx);
}
VERIFY_FreeMsgCache(verifyCtx);
BSL_SAL_FREE(verifyCtx);
hsCtx->verifyCtx = NULL;
return;
}
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
static int32_t SaveVerifyData(TLS_Ctx *ctx, bool isClient)
{
VerifyCtx *verifyCtx = ctx->hsCtx->verifyCtx;
uint8_t *verifyData = isClient ? ctx->negotiatedInfo.clientVerifyData : ctx->negotiatedInfo.serverVerifyData;
if (memcpy_s(verifyData, MAX_DIGEST_SIZE, verifyCtx->verifyData, verifyCtx->verifyDataSize) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15909, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"copy verifyData fail.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
if (isClient) {
ctx->negotiatedInfo.clientVerifyDataSize = verifyCtx->verifyDataSize;
} else {
ctx->negotiatedInfo.serverVerifyDataSize = verifyCtx->verifyDataSize;
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_RENEGOTIATION */
int32_t VERIFY_CalcVerifyData(TLS_Ctx *ctx, bool isClient, const uint8_t *masterSecret, uint32_t masterSecretLen)
{
int32_t ret = HITLS_SUCCESS;
uint32_t digestLen = MAX_DIGEST_SIZE;
uint8_t digest[MAX_DIGEST_SIZE] = {0};
VerifyCtx *verifyCtx = ctx->hsCtx->verifyCtx;
ret = VERIFY_CalcSessionHash(verifyCtx, digest, &digestLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15477, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Verify data calculate error: calc session hash fail.", 0, 0, 0, 0);
return ret;
}
CRYPT_KeyDeriveParameters deriveInfo;
deriveInfo.hashAlgo = verifyCtx->hashAlgo;
deriveInfo.secret = masterSecret;
deriveInfo.secretLen = masterSecretLen;
deriveInfo.label = isClient ? ((const uint8_t *)CLIENT_FINISHED_LABEL) : ((const uint8_t *)SERVER_FINISHED_LABEL);
deriveInfo.labelLen = isClient ? strlen(CLIENT_FINISHED_LABEL) : strlen(SERVER_FINISHED_LABEL);
deriveInfo.seed = digest;
deriveInfo.seedLen = digestLen;
deriveInfo.libCtx = LIBCTX_FROM_CTX(ctx);
deriveInfo.attrName = ATTRIBUTE_FROM_CTX(ctx);
ret = SAL_CRYPT_PRF(&deriveInfo, verifyCtx->verifyData, HS_VERIFY_DATA_LEN);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15478, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Verify data calculate error: PRF fail.", 0, 0, 0, 0);
return ret;
}
verifyCtx->verifyDataSize = HS_VERIFY_DATA_LEN;
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
ret = SaveVerifyData(ctx, isClient);
#endif /* HITLS_TLS_FEATURE_RENEGOTIATION */
return ret;
}
static uint32_t GetHsDataLen(const VerifyCtx *ctx)
{
uint32_t len = 0;
const HsMsgCache *block = ctx->dataBuf;
/* Calculate the signature data length */
while (block != NULL) {
len += block->dataSize;
block = block->next;
}
return len;
}
static void LoopBlocks(const HsMsgCache *block, uint8_t *data, uint32_t len)
{
uint32_t offset = 0;
while ((block != NULL) && (block->dataSize > 0)) {
(void) memcpy_s(data + offset, len - offset, block->data, block->dataSize);
offset += block->dataSize;
block = block->next;
}
}
static int32_t GetHsData(VerifyCtx *ctx, uint8_t **data, uint32_t *dataLen)
{
uint32_t hsDataLen = GetHsDataLen(ctx);
if (hsDataLen == 0) {
*dataLen = 0;
*data = NULL;
return HITLS_SUCCESS;
}
uint8_t *hsData = BSL_SAL_Malloc(hsDataLen);
if (hsData == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16847, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Malloc fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
const HsMsgCache *block = ctx->dataBuf;
LoopBlocks(block, hsData, hsDataLen);
*dataLen = hsDataLen;
*data = hsData;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_PROTO_TLS13
/* The sender packs the data, calculates the binder, and then appends verified data.
* The receiver parses the data, and then calculates the binder. */
static int32_t GetHsDataForBinder(VerifyCtx *ctx, uint32_t *dataLen, bool isClient, uint8_t **data)
{
if (isClient) {
return GetHsData(ctx, data, dataLen);
}
const HsMsgCache *block = ctx->dataBuf;
if (block == NULL || block->next == NULL || block->next->data == 0) {
return HITLS_SUCCESS;
}
uint32_t lenExcludeLastBlock = 0;
/* Calculate the total length excluding the last block. */
while (block->next != NULL && block->next->dataSize != 0) {
lenExcludeLastBlock += block->dataSize;
block = block->next;
}
uint32_t lastBlockLen = block->dataSize;
if (lenExcludeLastBlock == 0) {
*data = NULL;
*dataLen = lenExcludeLastBlock;
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15479, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN, "In verify ctx, empty data.",
0, 0, 0, 0);
return HITLS_SUCCESS;
}
uint8_t *hsData = BSL_SAL_Malloc(lenExcludeLastBlock + lastBlockLen);
if (hsData == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16869, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Malloc fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
(void)LoopBlocks(ctx->dataBuf, hsData, lenExcludeLastBlock + lastBlockLen);
*dataLen = lenExcludeLastBlock;
*data = hsData;
return HITLS_SUCCESS;
}
static const char *GetCertVerifyLabel(bool isClient, uint32_t *len)
{
if (isClient) {
*len = strlen(TLS13_CLIENT_CERT_VERIFY_LABEL);
return TLS13_CLIENT_CERT_VERIFY_LABEL;
}
*len = strlen(TLS13_SERVER_CERT_VERIFY_LABEL);
return TLS13_SERVER_CERT_VERIFY_LABEL;
}
static uint8_t *Tls13GetUnsignData(TLS_Ctx *ctx, uint32_t *dataLen, bool isClient)
{
VerifyCtx *verifyCtx = ctx->hsCtx->verifyCtx;
uint32_t digestLen = MAX_DIGEST_SIZE;
uint8_t digest[MAX_DIGEST_SIZE] = {0};
int32_t ret = VERIFY_CalcSessionHash(verifyCtx, digest, &digestLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15480, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"calc session hash fail when get unsign data.", 0, 0, 0, 0);
return NULL;
}
uint32_t labelLen = 0;
const char *label = GetCertVerifyLabel(isClient, &labelLen);
/* sixty-four 0x20 s + label + 0x00 + SessionHash */
uint32_t unsignDataLen = TLS13_CERT_VERIFY_PREFIX_LEN + labelLen + 1 + digestLen;
uint8_t *unsignData = BSL_SAL_Malloc(unsignDataLen);
if (unsignData == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15481, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"malloc unsignData fail when get unsign data.", 0, 0, 0, 0);
return NULL;
}
uint32_t offset = 0;
/* Filled prefix: sixty-four 0x20 s */
(void)memset_s(unsignData, unsignDataLen, TLS13_CERT_VERIFY_PREFIX, TLS13_CERT_VERIFY_PREFIX_LEN);
offset += TLS13_CERT_VERIFY_PREFIX_LEN;
/* Filled labels */
if (memcpy_s(&unsignData[offset], unsignDataLen - offset, label, labelLen) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16870, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_SAL_FREE(unsignData);
return NULL;
}
offset += labelLen;
/* Filled with one 0 */
unsignData[offset] = 0;
offset++;
/* Filled SessionHash */
if (memcpy_s(&unsignData[offset], unsignDataLen - offset, digest, digestLen) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16871, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_SAL_FREE(unsignData);
return NULL;
}
*dataLen = unsignDataLen;
return unsignData;
}
#endif /* HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_PROTO_TLCP11
static uint8_t *TlcpGetUnsignData(TLS_Ctx *ctx, uint32_t *dataLen)
{
int32_t ret = HITLS_SUCCESS;
uint32_t unsignDataLen = MAX_DIGEST_SIZE;
uint8_t *unsignData = BSL_SAL_Malloc(unsignDataLen);
if (unsignData == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16214, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"malloc unsignData fail when get unsign data", 0, 0, 0, 0);
return NULL;
}
VerifyCtx *verifyCtx = ctx->hsCtx->verifyCtx;
ret = VERIFY_CalcSessionHash(verifyCtx, unsignData, &unsignDataLen);
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_SAL_Free(unsignData);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16215, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"calc session hash fail when get unsign data", 0, 0, 0, 0);
return NULL;
}
*dataLen = unsignDataLen;
return unsignData;
}
#endif
static uint8_t *GetUnsignData(TLS_Ctx *ctx, uint32_t *dataLen, bool isClient, HITLS_HashAlgo hashAlgo)
{
(void)isClient;
(void)hashAlgo;
#ifdef HITLS_TLS_PROTO_TLS13
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLS13) {
return Tls13GetUnsignData(ctx, dataLen, isClient);
}
#endif /* HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_PROTO_TLCP11
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
return TlcpGetUnsignData(ctx, dataLen);
}
#endif
uint8_t *data = NULL;
(void)GetHsData(ctx->hsCtx->verifyCtx, &data, dataLen);
return data;
}
int32_t VERIFY_CalcSignData(TLS_Ctx *ctx, HITLS_CERT_Key *privateKey, HITLS_SignHashAlgo signScheme)
{
int32_t ret = HITLS_SUCCESS;
HITLS_SignAlgo signAlgo = 0;
HITLS_HashAlgo hashAlgo = 0;
VerifyCtx *verifyCtx = ctx->hsCtx->verifyCtx;
if (CFG_GetSignParamBySchemes(ctx, signScheme, &signAlgo, &hashAlgo) != true) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15482, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"get sign parm fail.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_PACK_SIGNATURE_ERR);
return HITLS_PACK_SIGNATURE_ERR;
}
/* Obtaining the data to be signed */
uint32_t dataLen = 0u;
uint8_t *data = GetUnsignData(ctx, &dataLen, ctx->isClient, hashAlgo); // 签名的时候使用的是本端的isClient
if (data == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16872, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GetUnsignData fail", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_GET_UNSIGN_DATA_FAIL);
return HITLS_MSG_HANDLE_GET_UNSIGN_DATA_FAIL;
}
CERT_SignParam signParam = {0};
signParam.signAlgo = signAlgo;
signParam.hashAlgo = hashAlgo;
signParam.data = data;
signParam.dataLen = dataLen;
signParam.sign = verifyCtx->verifyData;
signParam.signLen = MAX_SIGN_SIZE;
ret = SAL_CERT_CreateSign(ctx, privateKey, &signParam);
if ((ret != HITLS_SUCCESS) || (signParam.signLen > MAX_SIGN_SIZE)) {
BSL_SAL_FREE(data);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15483, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"create signature fail.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_PACK_SIGNATURE_ERR);
return HITLS_PACK_SIGNATURE_ERR;
}
verifyCtx->verifyDataSize = signParam.signLen;
BSL_SAL_FREE(data);
return HITLS_SUCCESS;
}
int32_t VERIFY_VerifySignData(TLS_Ctx *ctx, HITLS_CERT_Key *pubkey, HITLS_SignHashAlgo signScheme,
const uint8_t *signData, uint16_t signDataLen)
{
int32_t ret = HITLS_SUCCESS;
HITLS_SignAlgo signAlgo = 0;
HITLS_HashAlgo hashAlgo = 0;
if (CFG_GetSignParamBySchemes(ctx, signScheme, &signAlgo, &hashAlgo) != true) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15484, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"get sign parm fail.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_ILLEGAL_PARAMETER);
BSL_ERR_PUSH_ERROR(HITLS_PACK_SIGNATURE_ERR);
return HITLS_PACK_SIGNATURE_ERR;
}
/* Obtain the data to be signed */
uint32_t dataLen = 0;
uint8_t *data = GetUnsignData(ctx, &dataLen, !ctx->isClient, hashAlgo);
if (data == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16873, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "get data fail", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_GET_UNSIGN_DATA_FAIL);
return HITLS_MSG_HANDLE_GET_UNSIGN_DATA_FAIL;
}
CERT_SignParam signParam = {.signAlgo = signAlgo, .hashAlgo = hashAlgo, .data = data, .dataLen = dataLen};
signParam.sign = BSL_SAL_Dump(signData, signDataLen);
if (signParam.sign == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16874, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "dump fail", 0, 0, 0, 0);
BSL_SAL_FREE(data);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
signParam.signLen = signDataLen;
ret = SAL_CERT_VerifySign(ctx, pubkey, &signParam);
BSL_SAL_FREE(signParam.sign);
BSL_SAL_FREE(data);
if (ret != HITLS_SUCCESS) {
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_DECRYPT_ERROR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15485, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"verify signature fail.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_VERIFY_SIGN_FAIL);
return HITLS_MSG_HANDLE_VERIFY_SIGN_FAIL;
}
return HITLS_SUCCESS;
}
int32_t VERIFY_GetVerifyData(const VerifyCtx *ctx, uint8_t *verifyData, uint32_t *verifyDataLen)
{
if (ctx->verifyDataSize > MAX_DIGEST_SIZE) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15488, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Get verify data error: incorrect digest size.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_INCORRECT_DIGEST_LEN);
return HITLS_MSG_HANDLE_INCORRECT_DIGEST_LEN;
}
if (memcpy_s(verifyData, *verifyDataLen, ctx->verifyData, ctx->verifyDataSize) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15489, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Get verify data error: memcpy fail.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
*verifyDataLen = ctx->verifyDataSize;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_PROTO_TLS13
static uint8_t *GetBaseKey(TLS_Ctx *ctx, bool isClient)
{
uint8_t *baseKey = NULL;
#ifdef HITLS_TLS_FEATURE_PHA
if (ctx->phaState == PHA_REQUESTED) {
baseKey = isClient ? ctx->clientAppTrafficSecret : ctx->serverAppTrafficSecret;
} else
#endif /* HITLS_TLS_FEATURE_PHA */
{
baseKey = isClient ? ctx->hsCtx->clientHsTrafficSecret : ctx->hsCtx->serverHsTrafficSecret;
}
return baseKey;
}
int32_t VERIFY_Tls13CalcVerifyData(TLS_Ctx *ctx, bool isClient)
{
int32_t ret = HITLS_SUCCESS;
HITLS_HashAlgo hashAlg = ctx->negotiatedInfo.cipherSuiteInfo.hashAlg;
uint32_t hashLen = SAL_CRYPT_DigestSize(hashAlg);
if (hashLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16875, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "DigestSize err", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
uint8_t finishedKey[MAX_DIGEST_SIZE] = {0};
uint8_t *baseKey = NULL;
baseKey = GetBaseKey(ctx, isClient);
/* finished_key = HKDF-Expand-Label(BaseKey, "finished", "", Hash.length) */
ret = HS_TLS13DeriveFinishedKey(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
hashAlg, baseKey, hashLen, finishedKey, hashLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16876, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DeriveFinishedKey fail", 0, 0, 0, 0);
return ret;
}
VerifyCtx *verifyCtx = ctx->hsCtx->verifyCtx;
uint32_t digestLen = MAX_DIGEST_SIZE;
uint8_t digest[MAX_DIGEST_SIZE] = {0};
ret = VERIFY_CalcSessionHash(verifyCtx, digest, &digestLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15490, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"calc session hash fail when calc tls13 verify data.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return ret;
}
/* verify_data = HMAC(finished_key, Transcript-Hash(Handshake Context, Certificate*, CertificateVerify*)) */
verifyCtx->verifyDataSize = hashLen;
ret = SAL_CRYPT_Hmac(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
hashAlg, finishedKey, hashLen, digest, digestLen, verifyCtx->verifyData, &verifyCtx->verifyDataSize);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15910, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SAL_CRYPT_Hmac fail when calc tls13 verify data.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
}
return ret;
}
static int32_t ConstructMsgHash(HITLS_Lib_Ctx *libCtx, const char *attrName, HITLS_HashAlgo hashAlgo, HsMsgCache *dataBuf,
uint8_t *out, uint32_t *outLen)
{
int32_t ret = HITLS_SUCCESS;
uint32_t digestLen = *outLen - MSG_HASH_HEADER_SIZE;
uint32_t inLen = dataBuf->dataSize;
uint8_t *in = BSL_SAL_Dump(dataBuf->data, dataBuf->dataSize);
if (in == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16877, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Dump fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(BSL_UIO_MEM_ALLOC_FAIL);
return BSL_UIO_MEM_ALLOC_FAIL;
}
ret = SAL_CRYPT_Digest(libCtx, attrName, hashAlgo, in, inLen, &out[MSG_HASH_HEADER_SIZE], &digestLen);
BSL_SAL_FREE(in);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16878, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Digest fail", 0, 0, 0, 0);
return ret;
}
uint32_t offset = 0;
out[offset++] = MESSAGE_HASH;
out[offset++] = 0;
out[offset++] = 0;
out[offset] = (uint8_t)digestLen;
*outLen = digestLen + MSG_HASH_HEADER_SIZE;
return HITLS_SUCCESS;
}
static int32_t ReinitVerify(TLS_Ctx *ctx, uint8_t *msgHash, uint32_t msgHashLen, uint8_t *hrr, uint32_t hrrLen)
{
int32_t ret = HITLS_SUCCESS;
VERIFY_Deinit(ctx->hsCtx);
ret = VERIFY_Init(ctx->hsCtx);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16879, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"VERIFY_Init fail", 0, 0, 0, 0);
return ret;
}
VerifyCtx *verifyCtx = ctx->hsCtx->verifyCtx;
ret = VERIFY_Append(verifyCtx, msgHash, msgHashLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16880, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"VERIFY_Append fail", 0, 0, 0, 0);
return ret;
}
return VERIFY_Append(verifyCtx, hrr, hrrLen);
}
int32_t VERIFY_HelloRetryRequestVerifyProcess(TLS_Ctx *ctx)
{
int32_t ret = HITLS_SUCCESS;
uint32_t msgHashLen = MAX_MSG_HASH_SIZE;
uint8_t msgHash[MAX_MSG_HASH_SIZE] = {0};
VerifyCtx *verifyCtx = ctx->hsCtx->verifyCtx;
HsMsgCache *dataBuf = verifyCtx->dataBuf;
/** Set the verify information. */
ret = VERIFY_SetHash(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
ctx->hsCtx->verifyCtx, ctx->negotiatedInfo.cipherSuiteInfo.hashAlg);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15491, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"set verify info fail.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_ILLEGAL_PARAMETER);
return ret;
}
ret = ConstructMsgHash(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
verifyCtx->hashAlgo, dataBuf, msgHash, &msgHashLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15493, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"construct msg hash fail.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_ILLEGAL_PARAMETER);
return ret;
}
dataBuf = dataBuf->next;
uint32_t helloRetryRequestLen = dataBuf->dataSize;
uint8_t *helloRetryRequest = BSL_SAL_Dump(dataBuf->data, dataBuf->dataSize);
if (helloRetryRequest == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15494, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"malloc helloRetryRequest fail when process hrr verify.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_ILLEGAL_PARAMETER);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
ret = ReinitVerify(ctx, msgHash, msgHashLen, helloRetryRequest, helloRetryRequestLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(helloRetryRequest);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_ILLEGAL_PARAMETER);
return ret;
}
BSL_SAL_FREE(helloRetryRequest);
return HITLS_SUCCESS;
}
/*
Transcript-Hash(Truncate(ClientHello1))
Where Truncate() removes the binders list from the ClientHello
If the server responds with a HelloRetryRequest and the client then sends ClientHello2,
its binder will be computed over:
Transcript-Hash(ClientHello1, HelloRetryRequest, Truncate(ClientHello2))
*/
int32_t VERIFY_CalcPskBinder(const TLS_Ctx *ctx, HITLS_HashAlgo hashAlgo, bool isExternalPsk, uint8_t *psk,
uint32_t pskLen, const uint8_t *msg, uint32_t msgLen, uint8_t *binder, uint32_t binderLen)
{
int32_t ret = HITLS_SUCCESS;
HITLS_HASH_Ctx *hashCtx = NULL;
uint8_t *hsData = NULL;
uint8_t earlySecret[MAX_DIGEST_SIZE] = {0};
uint8_t binderKey[MAX_DIGEST_SIZE] = {0};
uint8_t finishedKey[MAX_DIGEST_SIZE] = {0};
uint8_t transcriptHash[MAX_DIGEST_SIZE] = {0};
uint32_t hashLen = SAL_CRYPT_DigestSize(hashAlgo);
uint32_t hsDataLen = 0u;
uint32_t calcBinderLen = binderLen;
if (hashLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16881, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "DigestSize err", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
// HKDF.Extract PSK to compute EarlySecret
ret = HS_TLS13DeriveEarlySecret(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx), hashAlgo, psk, pskLen, earlySecret, &hashLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16882, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DeriveEarlySecret fail", 0, 0, 0, 0);
goto EXIT;
}
// HKDF.Expand EarlySecret to compute BinderKey
ret = HS_TLS13DeriveBinderKey(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
hashAlgo, isExternalPsk, earlySecret, hashLen, binderKey, hashLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16883, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DeriveBinderKey fail", 0, 0, 0, 0);
goto EXIT;
}
// HKDF.Expand BinderKey to compute Binder Finished Key
ret = HS_TLS13DeriveFinishedKey(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
hashAlgo, binderKey, hashLen, finishedKey, hashLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16884, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DeriveFinishedKey fail", 0, 0, 0, 0);
goto EXIT;
}
hashCtx = SAL_CRYPT_DigestInit(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx), hashAlgo);
if (hashCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16885, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DigestInit fail", 0, 0, 0, 0);
ret = HITLS_CRYPT_ERR_DIGEST;
goto EXIT;
}
ret = GetHsDataForBinder(ctx->hsCtx->verifyCtx, &hsDataLen, ctx->isClient, &hsData);
if (ret != HITLS_SUCCESS) {
goto EXIT;
}
if (hsData != NULL) {
ret = SAL_CRYPT_DigestUpdate(hashCtx, hsData, hsDataLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16886, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DigestUpdate fail", 0, 0, 0, 0);
goto EXIT;
}
}
if (SAL_CRYPT_DigestUpdate(hashCtx, msg, msgLen) != HITLS_SUCCESS ||
SAL_CRYPT_DigestFinal(hashCtx, transcriptHash, &hashLen) != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16887, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DigestUpdate or DigestFinal fail", 0, 0, 0, 0);
ret = HITLS_CRYPT_ERR_DIGEST;
goto EXIT;
}
ret = SAL_CRYPT_Hmac(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
hashAlgo, finishedKey, hashLen, transcriptHash, hashLen, binder, &calcBinderLen);
EXIT:
BSL_SAL_CleanseData(earlySecret, MAX_DIGEST_SIZE);
BSL_SAL_CleanseData(binderKey, MAX_DIGEST_SIZE);
BSL_SAL_CleanseData(finishedKey, MAX_DIGEST_SIZE);
BSL_SAL_FREE(hsData);
SAL_CRYPT_DigestFree(hashCtx);
return ret;
}
#endif /* HITLS_TLS_PROTO_TLS13 */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/src/hs_verify.c | C | unknown | 27,620 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_PROTO_TLS13
#include <stdbool.h>
#include "securec.h"
#include "bsl_bytes.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "hitls_error.h"
#include "hitls_crypt_type.h"
#include "tls.h"
#include "crypt.h"
#include "rec.h"
#include "hs_kx.h"
#include "hs_common.h"
#include "transcript_hash.h"
#include "config_type.h"
int32_t HS_TLS13DeriveSecret(CRYPT_KeyDeriveParameters *deriveInfo, bool isHashed, uint8_t *outSecret, uint32_t outLen)
{
int32_t ret;
uint8_t transcriptHash[MAX_DIGEST_SIZE] = {0};
uint32_t hashLen = SAL_CRYPT_DigestSize(deriveInfo->hashAlgo);
if (hashLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16888, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "DigestSize err", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
if (!isHashed) {
ret = SAL_CRYPT_Digest(deriveInfo->libCtx, deriveInfo->attrName,
deriveInfo->hashAlgo, deriveInfo->seed, deriveInfo->seedLen, transcriptHash, &hashLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16889, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Digest fail", 0, 0, 0, 0);
return ret;
}
deriveInfo->seed = transcriptHash;
deriveInfo->seedLen = hashLen;
}
return SAL_CRYPT_HkdfExpandLabel(deriveInfo, outSecret, outLen);
}
int32_t TLS13HkdfExtract(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_CRYPT_HkdfExtractInput *extractInput, uint8_t *prk, uint32_t *prkLen)
{
uint32_t hashLen = SAL_CRYPT_DigestSize(extractInput->hashAlgo);
if (hashLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16890, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "DigestSize err", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
uint8_t zeros[MAX_DIGEST_SIZE] = {0};
if (extractInput->salt == NULL) {
extractInput->salt = zeros;
extractInput->saltLen = hashLen;
}
if (extractInput->inputKeyMaterial == NULL) {
extractInput->inputKeyMaterial = zeros;
extractInput->inputKeyMaterialLen = hashLen;
}
return SAL_CRYPT_HkdfExtract(libCtx, attrName, extractInput, prk, prkLen);
}
/*
0
|
v
PSK -> HKDF-Extract = Early Secret
*/
int32_t HS_TLS13DeriveEarlySecret(HITLS_Lib_Ctx *libCtx, const char *attrName, HITLS_HashAlgo hashAlgo, uint8_t *psk, uint32_t pskLen,
uint8_t *earlySecret, uint32_t *outLen)
{
HITLS_CRYPT_HkdfExtractInput extractInput = {0};
extractInput.hashAlgo = hashAlgo;
extractInput.salt = NULL;
extractInput.saltLen = 0;
extractInput.inputKeyMaterial = psk;
extractInput.inputKeyMaterialLen = pskLen;
return TLS13HkdfExtract(libCtx, attrName, &extractInput, earlySecret, outLen);
}
int32_t HS_TLS13DeriveBinderKey(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, bool isExternalPsk,
uint8_t *earlySecret, uint32_t secretLen, uint8_t *binderKey, uint32_t keyLen)
{
uint8_t *binderLabel;
uint32_t labelLen;
uint8_t extBinderLabel[] = "ext binder";
uint8_t resBinderLabel[] = "res binder";
if (isExternalPsk) {
binderLabel = extBinderLabel;
labelLen = sizeof(extBinderLabel) - 1;
} else {
binderLabel = resBinderLabel;
labelLen = sizeof(resBinderLabel) - 1;
}
CRYPT_KeyDeriveParameters deriveInfo = {0};
deriveInfo.hashAlgo = hashAlgo;
deriveInfo.secret = earlySecret;
deriveInfo.secretLen = secretLen;
deriveInfo.label = binderLabel;
deriveInfo.labelLen = labelLen;
deriveInfo.seed = NULL;
deriveInfo.seedLen = 0;
deriveInfo.libCtx = libCtx;
deriveInfo.attrName = attrName;
return HS_TLS13DeriveSecret(&deriveInfo, false, binderKey, keyLen);
}
/*
Early Secret
|
v
Derive-Secret(., "derived", "")
|
v
(EC)DHE -> HKDF-Extract = Handshake Secret
|
v
Derive-Secret(., "derived", "")
|
v
0 -> HKDF-Extract = Master Secret
*/
int32_t HS_TLS13DeriveNextStageSecret(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, uint8_t *inSecret, uint32_t inLen,
uint8_t *givenSecret, uint32_t givenLen, uint8_t *outSecret, uint32_t *outLen)
{
int32_t ret;
uint8_t label[] = "derived";
uint8_t tmpSecret[MAX_DIGEST_SIZE];
uint32_t hashLen = SAL_CRYPT_DigestSize(hashAlgo);
if (hashLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16891, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "DigestSize err", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
CRYPT_KeyDeriveParameters deriveInfo = {0};
deriveInfo.hashAlgo = hashAlgo;
deriveInfo.secret = inSecret;
deriveInfo.secretLen = inLen;
deriveInfo.label = label;
deriveInfo.labelLen = sizeof(label) - 1;
deriveInfo.seed = NULL;
deriveInfo.seedLen = 0;
deriveInfo.libCtx = libCtx;
deriveInfo.attrName = attrName;
ret = HS_TLS13DeriveSecret(&deriveInfo, false, tmpSecret, hashLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16892, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DeriveSecret fail", 0, 0, 0, 0);
return ret;
}
HITLS_CRYPT_HkdfExtractInput extractInput = {0};
extractInput.hashAlgo = hashAlgo;
extractInput.salt = tmpSecret;
extractInput.saltLen = hashLen;
extractInput.inputKeyMaterial = givenSecret;
extractInput.inputKeyMaterialLen = givenLen;
ret = TLS13HkdfExtract(libCtx, attrName, &extractInput, outSecret, outLen);
BSL_SAL_CleanseData(tmpSecret, MAX_DIGEST_SIZE);
return ret;
}
int32_t TLS13DeriveDheSecret(TLS_Ctx *ctx, uint8_t *preMasterSecret, uint32_t *preMasterSecretLen, uint32_t hashLen)
{
KeyExchCtx *keyCtx = ctx->hsCtx->kxCtx;
if (keyCtx->peerPubkey == NULL) {
*preMasterSecretLen = hashLen;
return HITLS_SUCCESS;
}
const TLS_GroupInfo *groupInfo = ConfigGetGroupInfo(&ctx->config.tlsConfig, ctx->negotiatedInfo.negotiatedGroup);
if (groupInfo == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16244, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"group info not found", 0, 0, 0, 0);
return HITLS_INVALID_INPUT;
}
if (!groupInfo->isKem) {
return SAL_CRYPT_CalcEcdhSharedSecret(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
keyCtx->key, keyCtx->peerPubkey, keyCtx->pubKeyLen,
preMasterSecret, preMasterSecretLen);
}
#ifdef HITLS_TLS_FEATURE_KEM
if (ctx->isClient) {
return SAL_CRYPT_KemDecapsulate(keyCtx->key, keyCtx->peerPubkey, keyCtx->pubKeyLen,
preMasterSecret, preMasterSecretLen);
}
BSL_SAL_Free(keyCtx->ciphertext);
keyCtx->ciphertext = BSL_SAL_Calloc(1, groupInfo->ciphertextLen);
if (keyCtx->ciphertext == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16245, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ciphertext malloc fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
keyCtx->ciphertextLen = groupInfo->ciphertextLen;
return SAL_CRYPT_KemEncapsulate(ctx,
&(HITLS_KemEncapsulateParams){
.groupId = ctx->negotiatedInfo.negotiatedGroup,
.peerPubkey = keyCtx->peerPubkey,
.pubKeyLen = keyCtx->pubKeyLen,
.ciphertext = keyCtx->ciphertext,
.ciphertextLen = &keyCtx->ciphertextLen,
.sharedSecret = preMasterSecret,
.sharedSecretLen = preMasterSecretLen,
});
#else
return HITLS_INTERNAL_EXCEPTION;
#endif
}
/*
Early Secret
|
v
Derive-Secret(., "derived", "")
|
v
(EC)DHE -> HKDF-Extract = Handshake Secret
*/
int32_t TLS13DeriveHandshakeSecret(TLS_Ctx *ctx)
{
uint16_t hashAlg = ctx->negotiatedInfo.cipherSuiteInfo.hashAlg;
uint32_t hashLen = SAL_CRYPT_DigestSize(hashAlg);
if (hashLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16893, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "DigestSize err", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
uint8_t preMasterSecret[MAX_PRE_MASTER_SECRET_SIZE] = {0};
uint32_t preMasterSecretLen = MAX_PRE_MASTER_SECRET_SIZE;
int32_t ret = TLS13DeriveDheSecret(ctx, preMasterSecret, &preMasterSecretLen, hashLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16894, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DeriveDheSecret fail", 0, 0, 0, 0);
return ret;
}
uint32_t handshakeSecretLen = hashLen;
ret = HS_TLS13DeriveNextStageSecret(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
hashAlg, ctx->hsCtx->earlySecret, hashLen,
preMasterSecret, preMasterSecretLen, ctx->hsCtx->handshakeSecret, &handshakeSecretLen);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16895, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"DeriveNextStageSecret finish", 0, 0, 0, 0);
BSL_SAL_CleanseData(preMasterSecret, MAX_PRE_MASTER_SECRET_SIZE);
return ret;
}
/*
(EC)DHE -> HKDF-Extract = Handshake Secret
|
v
Derive-Secret(., "derived", "")
|
v
0 -> HKDF-Extract = Master Secret
*/
int32_t TLS13DeriveMasterSecret(TLS_Ctx *ctx)
{
uint16_t hashAlg = ctx->negotiatedInfo.cipherSuiteInfo.hashAlg;
uint32_t hashLen = SAL_CRYPT_DigestSize(hashAlg);
if (hashLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16896, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "DigestSize err", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
uint32_t masterKeyLen = hashLen;
return HS_TLS13DeriveNextStageSecret(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
hashAlg, ctx->hsCtx->handshakeSecret, hashLen,
NULL, 0, ctx->hsCtx->masterKey, &masterKeyLen);
}
/*
finished_key = HKDF-Expand-Label(BaseKey, "finished", "", Hash.length)
*/
int32_t HS_TLS13DeriveFinishedKey(HITLS_Lib_Ctx *libCtx, const char *attrName,
HITLS_HashAlgo hashAlgo, uint8_t *baseKey, uint32_t baseKeyLen,
uint8_t *finishedkey, uint32_t finishedkeyLen)
{
uint8_t label[] = "finished";
CRYPT_KeyDeriveParameters deriveInfo = {0};
deriveInfo.hashAlgo = hashAlgo;
deriveInfo.secret = baseKey;
deriveInfo.secretLen = baseKeyLen;
deriveInfo.label = label;
deriveInfo.labelLen = sizeof(label) - 1;
deriveInfo.seed = NULL;
deriveInfo.seedLen = 0;
deriveInfo.libCtx = libCtx;
deriveInfo.attrName = attrName;
return SAL_CRYPT_HkdfExpandLabel(&deriveInfo, finishedkey, finishedkeyLen);
}
/*
HKDF-Expand-Label(resumption_master_secret, "resumption", ticket_nonce, Hash.length)
*/
int32_t HS_TLS13DeriveResumePsk(TLS_Ctx *ctx, const uint8_t *ticketNonce, uint32_t ticketNonceSize,
uint8_t *resumePsk, uint32_t resumePskLen)
{
const uint8_t label[] = "resumption";
HITLS_HashAlgo hashAlg = ctx->negotiatedInfo.cipherSuiteInfo.hashAlg;
uint32_t hashLen = SAL_CRYPT_DigestSize(hashAlg);
if (hashLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16897, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "DigestSize err", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
CRYPT_KeyDeriveParameters deriveInfo = {0};
deriveInfo.hashAlgo = hashAlg;
deriveInfo.secret = ctx->resumptionMasterSecret;
deriveInfo.secretLen = hashLen;
deriveInfo.label = label;
deriveInfo.labelLen = sizeof(label) - 1;
deriveInfo.seed = ticketNonce;
deriveInfo.seedLen = ticketNonceSize;
deriveInfo.libCtx = LIBCTX_FROM_CTX(ctx);
deriveInfo.attrName = ATTRIBUTE_FROM_CTX(ctx);
return SAL_CRYPT_HkdfExpandLabel(&deriveInfo, resumePsk, resumePskLen);
}
int32_t TLS13GetTrafficSecretDeriveInfo(TLS_Ctx *ctx, CRYPT_KeyDeriveParameters *deriveInfo,
uint8_t *seed, uint32_t seedLen)
{
uint32_t tmpSeedLen = seedLen;
int32_t ret;
ret = VERIFY_CalcSessionHash(ctx->hsCtx->verifyCtx, seed, &tmpSeedLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16898, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CalcSessionHash fail", 0, 0, 0, 0);
return ret;
}
uint16_t hashAlg = ctx->negotiatedInfo.cipherSuiteInfo.hashAlg;
uint32_t hashLen = SAL_CRYPT_DigestSize(hashAlg);
if (hashLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16899, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "DigestSize err", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
deriveInfo->hashAlgo = hashAlg;
deriveInfo->seed = seed;
deriveInfo->seedLen = tmpSeedLen;
deriveInfo->secretLen = hashLen;
return HITLS_SUCCESS;
}
/*
Derive-Secret(Handshake Secret, label, ClientHello...ServerHello)
*/
int32_t HS_TLS13DeriveHandshakeTrafficSecret(TLS_Ctx *ctx)
{
uint8_t seed[MAX_DIGEST_SIZE] = {0};
uint32_t seedLen = MAX_DIGEST_SIZE;
CRYPT_KeyDeriveParameters deriveInfo = {0};
int32_t ret;
ret = TLS13GetTrafficSecretDeriveInfo(ctx, &deriveInfo, seed, seedLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16900, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GetTrafficSecretDeriveInfo fail", 0, 0, 0, 0);
return ret;
}
deriveInfo.secret = ctx->hsCtx->handshakeSecret;
uint32_t hashLen = deriveInfo.secretLen;
uint8_t clientLabel[] = "c hs traffic";
deriveInfo.label = clientLabel;
deriveInfo.labelLen = sizeof(clientLabel) - 1;
deriveInfo.libCtx = LIBCTX_FROM_CTX(ctx);
deriveInfo.attrName = ATTRIBUTE_FROM_CTX(ctx);
ret = HS_TLS13DeriveSecret(&deriveInfo, true, ctx->hsCtx->clientHsTrafficSecret, hashLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16901, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DeriveSecret fail", 0, 0, 0, 0);
return ret;
}
#ifdef HITLS_TLS_MAINTAIN_KEYLOG
HITLS_LogSecret(ctx, CLIENT_HANDSHAKE_LABEL, ctx->hsCtx->clientHsTrafficSecret,
deriveInfo.secretLen);
#endif /* HITLS_TLS_MAINTAIN_KEYLOG */
uint8_t serverLabel[] = "s hs traffic";
deriveInfo.label = serverLabel;
deriveInfo.labelLen = sizeof(serverLabel) - 1;
ret = HS_TLS13DeriveSecret(&deriveInfo, true, ctx->hsCtx->serverHsTrafficSecret, hashLen);
#ifdef HITLS_TLS_MAINTAIN_KEYLOG
HITLS_LogSecret(ctx, SERVER_HANDSHAKE_LABEL, ctx->hsCtx->serverHsTrafficSecret,
deriveInfo.secretLen);
#endif /* HITLS_TLS_MAINTAIN_KEYLOG */
return ret;
}
/*
Derive-Secret(Master Secret, label, ClientHello...ServerHello)
*/
int32_t TLS13DeriveApplicationTrafficSecret(TLS_Ctx *ctx)
{
uint8_t seed[MAX_DIGEST_SIZE] = {0};
uint32_t seedLen = MAX_DIGEST_SIZE;
CRYPT_KeyDeriveParameters deriveInfo = {0};
int32_t ret;
ret = TLS13GetTrafficSecretDeriveInfo(ctx, &deriveInfo, seed, seedLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16902, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GetTrafficSecretDeriveInfo fail", 0, 0, 0, 0);
return ret;
}
deriveInfo.secret = ctx->hsCtx->masterKey;
uint32_t hashLen = deriveInfo.secretLen;
uint8_t clientLabel[] = "c ap traffic";
deriveInfo.label = clientLabel;
deriveInfo.labelLen = sizeof(clientLabel) - 1;
deriveInfo.libCtx = LIBCTX_FROM_CTX(ctx);
deriveInfo.attrName = ATTRIBUTE_FROM_CTX(ctx);
ret = HS_TLS13DeriveSecret(&deriveInfo, true, ctx->clientAppTrafficSecret, hashLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16903, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DeriveSecret fail", 0, 0, 0, 0);
return ret;
}
#ifdef HITLS_TLS_MAINTAIN_KEYLOG
HITLS_LogSecret(ctx, CLIENT_APPLICATION_LABEL, ctx->clientAppTrafficSecret,
deriveInfo.secretLen);
#endif /* HITLS_TLS_MAINTAIN_KEYLOG */
uint8_t serverLabel[] = "s ap traffic";
deriveInfo.label = serverLabel;
deriveInfo.labelLen = sizeof(serverLabel) - 1;
ret = HS_TLS13DeriveSecret(&deriveInfo, true, ctx->serverAppTrafficSecret, hashLen);
#ifdef HITLS_TLS_MAINTAIN_KEYLOG
HITLS_LogSecret(ctx, SERVER_APPLICATION_LABEL, ctx->serverAppTrafficSecret,
deriveInfo.secretLen);
#endif /* HITLS_TLS_MAINTAIN_KEYLOG */
return ret;
}
/*
Derive-Secret(., "res master", ClientHello...client Finished) = resumption_master_secret
*/
#ifdef HITLS_TLS_FEATURE_SESSION
int32_t HS_TLS13DeriveResumptionMasterSecret(TLS_Ctx *ctx)
{
uint8_t seed[MAX_DIGEST_SIZE] = {0};
uint32_t seedLen = MAX_DIGEST_SIZE;
CRYPT_KeyDeriveParameters deriveInfo = {0};
int32_t ret;
ret = TLS13GetTrafficSecretDeriveInfo(ctx, &deriveInfo, seed, seedLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16904, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GetTrafficSecretDeriveInfo fail", 0, 0, 0, 0);
return ret;
}
deriveInfo.secret = ctx->hsCtx->masterKey;
uint32_t hashLen = deriveInfo.secretLen;
const uint8_t resLabel[] = "res master";
deriveInfo.label = resLabel;
deriveInfo.labelLen = sizeof(resLabel) - 1;
deriveInfo.libCtx = LIBCTX_FROM_CTX(ctx);
deriveInfo.attrName = ATTRIBUTE_FROM_CTX(ctx);
return HS_TLS13DeriveSecret(&deriveInfo, true, ctx->resumptionMasterSecret, hashLen);
}
#endif /* HITLS_TLS_FEATURE_SESSION */
int32_t HS_TLS13CalcServerHelloProcessSecret(TLS_Ctx *ctx)
{
PskInfo13 *pskInfo = &ctx->hsCtx->kxCtx->pskInfo13;
uint16_t hashAlg = ctx->negotiatedInfo.cipherSuiteInfo.hashAlg;
uint32_t hashLen = SAL_CRYPT_DigestSize(hashAlg);
if (hashLen == 0 || hashLen > MAX_DIGEST_SIZE) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16906, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "DigestSize err", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
uint8_t zero[MAX_DIGEST_SIZE] = {0};
uint8_t *psk = NULL;
uint32_t pskLen = 0;
if (pskInfo->psk != NULL) {
psk = pskInfo->psk;
pskLen = pskInfo->pskLen;
} else {
psk = zero;
pskLen = hashLen;
}
uint32_t earlySecretLen = hashLen;
int32_t ret = HS_TLS13DeriveEarlySecret(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
hashAlg, psk, pskLen, ctx->hsCtx->earlySecret, &earlySecretLen);
BSL_SAL_CleanseData(psk, pskLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16907, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DeriveEarlySecret fail", 0, 0, 0, 0);
return ret;
}
return TLS13DeriveHandshakeSecret(ctx);
}
int32_t HS_TLS13CalcServerFinishProcessSecret(TLS_Ctx *ctx)
{
int32_t ret;
ret = TLS13DeriveMasterSecret(ctx);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16908, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DeriveMasterSecret fail", 0, 0, 0, 0);
return ret;
}
ret = TLS13DeriveApplicationTrafficSecret(ctx);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16909, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DeriveApplicationTrafficSecret fail", 0, 0, 0, 0);
}
return ret;
}
int32_t HS_SwitchTrafficKey(TLS_Ctx *ctx, uint8_t *secret, uint32_t secretLen, bool isOut)
{
int32_t ret;
CipherSuiteInfo *cipherSuiteInfo = &(ctx->negotiatedInfo.cipherSuiteInfo);
uint32_t hashLen = SAL_CRYPT_DigestSize(cipherSuiteInfo->hashAlg);
if (hashLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16910, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "DigestSize err", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
REC_SecParameters keyPara = {0};
ret = HS_SetInitPendingStateParam(ctx, ctx->isClient, &keyPara);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (hashLen > sizeof(keyPara.masterSecret)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16911, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "hashLen err", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
return HITLS_INTERNAL_EXCEPTION;
}
if (memcpy_s(keyPara.masterSecret, sizeof(keyPara.masterSecret), secret, secretLen) != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16912, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
return HITLS_MEMCPY_FAIL;
}
ret = REC_TLS13InitPendingState(ctx, &keyPara, isOut);
(void)memset_s(keyPara.masterSecret, sizeof(keyPara.masterSecret), 0, sizeof(keyPara.masterSecret));
if (ret != HITLS_SUCCESS) {
return ret;
}
/** enable key specification */
return REC_ActivePendingState(ctx, isOut);
}
/*
application_traffic_secret_N+1 = HKDF-Expand-Label(application_traffic_secret_N, "traffic upd", "", Hash.length)
*/
#ifdef HITLS_TLS_FEATURE_KEY_UPDATE
int32_t HS_TLS13UpdateTrafficSecret(TLS_Ctx *ctx, bool isOut)
{
HITLS_HashAlgo hashAlg = ctx->negotiatedInfo.cipherSuiteInfo.hashAlg;
uint32_t hashLen = SAL_CRYPT_DigestSize(hashAlg);
if (hashLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16913, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "DigestSize err", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
uint8_t trafficSecret[MAX_DIGEST_SIZE] = {0};
uint8_t *trafficSecretPointer = trafficSecret;
uint32_t trafficSecretLen = hashLen;
uint8_t *baseKey = NULL;
uint32_t baseKeyLen = hashLen;
if ((ctx->isClient && isOut) || (!ctx->isClient && !isOut)) {
baseKey = ctx->clientAppTrafficSecret;
} else {
baseKey = ctx->serverAppTrafficSecret;
}
uint8_t label[] = "traffic upd";
CRYPT_KeyDeriveParameters deriveInfo = {0};
deriveInfo.hashAlgo = hashAlg;
deriveInfo.secret = baseKey;
deriveInfo.secretLen = baseKeyLen;
deriveInfo.label = label;
deriveInfo.labelLen = sizeof(label) - 1;
deriveInfo.seed = NULL;
deriveInfo.seedLen = 0;
deriveInfo.libCtx = LIBCTX_FROM_CTX(ctx);
deriveInfo.attrName = ATTRIBUTE_FROM_CTX(ctx);
int32_t ret = SAL_CRYPT_HkdfExpandLabel(&deriveInfo, trafficSecretPointer, trafficSecretLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_CleanseData(trafficSecret, MAX_DIGEST_SIZE);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16914, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"HkdfExpandLabel fail", 0, 0, 0, 0);
return ret;
}
ret = memcpy_s(baseKey, baseKeyLen, trafficSecret, trafficSecretLen);
BSL_SAL_CleanseData(trafficSecret, MAX_DIGEST_SIZE);
if (ret != EOK) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16915, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "memcpy fail", 0, 0, 0, 0);
return HITLS_MEMCPY_FAIL;
}
return HS_SwitchTrafficKey(ctx, baseKey, baseKeyLen, isOut);
}
#endif /* HITLS_TLS_FEATURE_KEY_UPDATE */
#endif /* HITLS_TLS_PROTO_TLS13 */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/src/tls13key.c | C | unknown | 23,307 |
/*
* 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.
*/
#include <string.h>
#include "hitls_build.h"
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "transcript_hash.h"
int32_t VERIFY_SetHash(HITLS_Lib_Ctx *libCtx, const char *attrName, VerifyCtx *ctx, HITLS_HashAlgo hashAlgo)
{
int32_t ret;
/* the value must be the same as the PRF function, use the digest algorithm with SHA-256 or higher strength */
HITLS_HashAlgo prfAlgo = (hashAlgo == HITLS_HASH_SHA1) ? HITLS_HASH_SHA_256 : hashAlgo;
ctx->hashCtx = SAL_CRYPT_DigestInit(libCtx, attrName, prfAlgo);
if (ctx->hashCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_CRYPT_ERR_DIGEST);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15716, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Verify set hash error: digest init fail.", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
HsMsgCache *dataBuf = ctx->dataBuf;
while ((dataBuf != NULL) && (dataBuf->dataSize > 0u)) {
ret = SAL_CRYPT_DigestUpdate(ctx->hashCtx, dataBuf->data, dataBuf->dataSize);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15717, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Verify set hash error: digest update fail.", 0, 0, 0, 0);
SAL_CRYPT_DigestFree(ctx->hashCtx);
ctx->hashCtx = NULL;
return ret;
}
dataBuf = dataBuf->next;
}
ctx->hashAlgo = prfAlgo;
return HITLS_SUCCESS;
}
static HsMsgCache *GetLastCache(HsMsgCache *dataBuf)
{
HsMsgCache *cacheBuf = dataBuf;
while (cacheBuf->next != NULL) {
cacheBuf = cacheBuf->next;
}
return cacheBuf;
}
static int32_t CacheMsgData(HsMsgCache *dataBuf, const uint8_t *data, uint32_t len)
{
HsMsgCache *lastCache = GetLastCache(dataBuf);
lastCache->next = BSL_SAL_Calloc(1u, sizeof(HsMsgCache));
if (lastCache->next == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15718, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"malloc HsMsgCache fail when append msg.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
BSL_SAL_FREE(lastCache->data);
lastCache->data = BSL_SAL_Dump(data, len);
if (lastCache->data == NULL) {
BSL_SAL_FREE(lastCache->next);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15719, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"malloc HsMsgCache data fail when append msg.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
lastCache->dataSize = len;
return HITLS_SUCCESS;
}
int32_t VERIFY_Append(VerifyCtx *ctx, const uint8_t *data, uint32_t len)
{
int32_t ret;
if (ctx->hashCtx != NULL) {
ret = SAL_CRYPT_DigestUpdate(ctx->hashCtx, data, len);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15720, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Verify append error: digest update fail.", 0, 0, 0, 0);
return ret;
}
}
if (ctx->dataBuf != NULL) {
return CacheMsgData(ctx->dataBuf, data, len);
}
return HITLS_SUCCESS;
}
int32_t VERIFY_CalcSessionHash(VerifyCtx *ctx, uint8_t *digest, uint32_t *digestLen)
{
int32_t ret;
HITLS_HASH_Ctx *tmpHashCtx = SAL_CRYPT_DigestCopy(ctx->hashCtx);
if (tmpHashCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_CRYPT_ERR_DIGEST);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15721, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Verify data calculate error: digest copy fail.", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_DIGEST;
}
/* get the hash result */
ret = SAL_CRYPT_DigestFinal(tmpHashCtx, digest, digestLen);
SAL_CRYPT_DigestFree(tmpHashCtx);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15722, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Verify data calculate error: digest final fail.", 0, 0, 0, 0);
}
return ret;
}
void VERIFY_FreeMsgCache(VerifyCtx *ctx)
{
HsMsgCache *nextBuf = NULL;
HsMsgCache *dataBuf = ctx->dataBuf;
while (dataBuf != NULL) {
nextBuf = dataBuf->next;
BSL_SAL_FREE(dataBuf->data);
BSL_SAL_FREE(dataBuf);
dataBuf = nextBuf;
}
ctx->dataBuf = NULL;
return;
}
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/common/src/transcript_hash.c | C | unknown | 4,932 |
/*
* 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 HS_COOKIE_H
#define HS_COOKIE_H
#include <stdint.h>
#include <stdbool.h>
#include "tls.h"
#include "hs_msg.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Calculate the cookie
* The mackey is updated each time the number of times that Cookie_SECRET_LIFETIME is calculated.
*
* @param ctx [IN] Handshake context
* @param clientHello [IN] Parsed clientHello structure
* @param cookie [OUT] Calculated cookie
* @param cookieLen [OUT] Calculated cookie length.
*
* @retval HITLS_SUCCESS succeeded.
* @retval For other error codes, see hitls_error.h.
*/
int32_t HS_CalcCookie(TLS_Ctx *ctx, const ClientHelloMsg *clientHello, uint8_t *cookie, uint32_t *cookieLen);
/**
* @brief Verify the cookie.
* If the first cookie verification fails, the previous mackey is used for verification again.
*
* @param ctx [IN] Handshake context
* @param clientHello [IN] Parsed clientHello structure
* @param isCookieValid [OUT] Indicates whether the verification is successful.
*
* @retval HITLS_SUCCESS succeeded.
* @retval For other error codes, see hitls_error.h.
*/
int32_t HS_CheckCookie(TLS_Ctx *ctx, const ClientHelloMsg *clientHello, bool *isCookieValid);
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end HS_COOKIE_H */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/cookie/include/hs_cookie.h | C | unknown | 1,807 |
/*
* 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.
*/
#include "hitls_build.h"
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_sal.h"
#include "bsl_bytes.h"
#include "bsl_errno.h"
#include "sal_net.h"
#include "uio_base.h"
#include "hitls.h"
#include "hitls_error.h"
#include "hitls_cookie.h"
#include "hitls_crypt_type.h"
#include "tls.h"
#include "tls_config.h"
#include "hs_ctx.h"
#include "hs.h"
#define MAX_IP_ADDR_SIZE 256u
static int32_t UpdateMacKey(TLS_Ctx *ctx, CookieInfo *cookieInfo)
{
(void)memcpy_s(cookieInfo->preMacKey, MAC_KEY_LEN, cookieInfo->macKey, MAC_KEY_LEN); /* Save the old key */
int32_t ret = SAL_CRYPT_Rand(LIBCTX_FROM_CTX(ctx), cookieInfo->macKey, MAC_KEY_LEN); /* Create a new key */
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15691, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"generate macKey fail when calc cookie.", 0, 0, 0, 0);
return ret;
}
cookieInfo->algRemainTime = COOKIE_SECRET_LIFETIME; /* Updated the current HMAC algorithm usage times */
return HITLS_SUCCESS;
}
static void FillCipherSuite(const ClientHelloMsg *clientHello, uint8_t *material,
uint32_t *offset)
{
for (uint32_t i = 0; i < clientHello->cipherSuitesSize; i++) {
BSL_Uint16ToByte(clientHello->cipherSuites[i], &material[*offset]);
*offset += sizeof(uint16_t);
}
}
/**
* @brief Generate cookie calculation materials
* @attention The maximum memory required is already applied, so the function does not
* need to check whether the memory is out of bounds
*
* @param ctx [IN] Hitls context
* @param clientHello [IN] ClientHello message
* @param material [OUT] Returned material
* @param materialSize [IN] Maximum length of the material
* @param usedLen [OUT] Returned actual material length
*
* @retval HITLS_SUCCESS
* @retval HITLS_MEMCPY_FAIL
*/
static int32_t GenerateCookieCalcMaterial(const TLS_Ctx *ctx, const ClientHelloMsg *clientHello,
uint8_t *material, uint32_t materialSize, uint32_t *usedLen)
{
uint8_t ipAddr[MAX_IP_ADDR_SIZE] = {0};
BSL_UIO_CtrlGetPeerIpAddrParam param = {ipAddr, sizeof(ipAddr)};
uint32_t offset = 0;
BSL_SAL_SockAddr peerAddr = NULL;
int32_t ret = SAL_SockAddrNew(&peerAddr);
if (ret != BSL_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16916, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "addr New fail", 0, 0, 0, 0);
return HITLS_MEMCPY_FAIL;
}
int32_t peerAddrLen = SAL_SockAddrSize(peerAddr);
/* Add the peer IP address */
ret = BSL_UIO_Ctrl(ctx->uio, BSL_UIO_GET_PEER_IP_ADDR, peerAddrLen, peerAddr);
if (ret == BSL_SUCCESS) {
if (memcpy_s(ipAddr, MAX_IP_ADDR_SIZE, peerAddr, SAL_SockAddrSize(peerAddr)) != EOK) {
SAL_SockAddrFree(peerAddr);
return BSL_MEMCPY_FAIL;
}
param.size = SAL_SockAddrSize(peerAddr);
if (memcpy_s(material, materialSize, ipAddr, param.size) != EOK) {
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15692, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"copy ipAddr fail when calc cookie.", 0, 0, 0, 0);
SAL_SockAddrFree(peerAddr);
return HITLS_MEMCPY_FAIL;
}
offset += param.size;
}
SAL_SockAddrFree(peerAddr);
/* fill the version */
BSL_Uint16ToByte(clientHello->version, &material[offset]);
offset += sizeof(uint16_t);
/* fill client's random value */
if (memcpy_s(&material[offset], materialSize - offset, clientHello->randomValue, HS_RANDOM_SIZE) != EOK) {
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15693, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"copy random fail when calc cookie.", 0, 0, 0, 0);
return HITLS_MEMCPY_FAIL;
}
offset += HS_RANDOM_SIZE;
/* fill session_id */
if (clientHello->sessionIdSize != 0 && clientHello->sessionId != NULL) {
if (memcpy_s(&material[offset], materialSize - offset,
clientHello->sessionId, clientHello->sessionIdSize) != EOK) {
BSL_ERR_PUSH_ERROR(HITLS_MEMCPY_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15694, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"copy sessionId fail when calc cookie.", 0, 0, 0, 0);
return HITLS_MEMCPY_FAIL;
}
offset += clientHello->sessionIdSize;
}
/* fill the cipher suite */
FillCipherSuite(clientHello, material, &offset);
*usedLen = offset;
return HITLS_SUCCESS;
}
/**
* @brief Add cookie calculation materials to the HMAC.
*
* @param ctx [IN] Hitls context
* @param clientHello [IN] ClientHello message
* @param cookieInfo [IN] cookie info
* @param cookie [IN] cookie
* @param cookieLen [IN] cookie len
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h.
*/
static int32_t AddCookieCalcMaterial(
const TLS_Ctx *ctx, const ClientHelloMsg *clientHello, CookieInfo *cookieInfo, uint8_t *cookie, uint32_t *cookieLen)
{
/* Add the cookie calculation material, that is, the peer IP address + version + random + sessionID + cipherSuites
*/
uint32_t materialSize = MAX_IP_ADDR_SIZE + sizeof(uint16_t) + HS_RANDOM_SIZE + clientHello->sessionIdSize +
clientHello->cipherSuitesSize * sizeof(uint16_t);
uint8_t *material = BSL_SAL_Calloc(1u, materialSize);
if (material == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15695, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"material malloc fail when calc cookie.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
int32_t ret;
uint32_t usedLen = 0;
ret = GenerateCookieCalcMaterial(ctx, clientHello, material, materialSize, &usedLen);
if (ret != HITLS_SUCCESS) {
(void)memset_s(material, materialSize, 0, materialSize);
BSL_SAL_FREE(material);
return ret;
}
ret = SAL_CRYPT_Hmac(LIBCTX_FROM_CTX(ctx), ATTRIBUTE_FROM_CTX(ctx),
HITLS_HASH_SHA_256, cookieInfo->macKey, MAC_KEY_LEN, material, usedLen, cookie, cookieLen);
(void)memset_s(material, materialSize, 0, materialSize);
BSL_SAL_FREE(material);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15696, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SAL_CRYPT_Hmac fail when calc cookie.", 0, 0, 0, 0);
}
return ret;
}
int32_t HS_CalcCookie(TLS_Ctx *ctx, const ClientHelloMsg *clientHello, uint8_t *cookie, uint32_t *cookieLen)
{
/* If the user's cookie calculation callback is registered, use the user's callback interface */
if (ctx->globalConfig != NULL && ctx->globalConfig->appGenCookieCb != NULL) {
int32_t returnVal = ctx->globalConfig->appGenCookieCb(ctx, cookie, cookieLen);
/* A return value of zero indicates that the cookie generation failed, and a return value of other values is a
* success, so the judgment here is a failure rather than a non-success */
if (returnVal == HITLS_COOKIE_GENERATE_ERROR) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_COOKIE_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15697, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"appGenCookieCb return error 0x%x.", returnVal, 0, 0, 0);
return HITLS_MSG_HANDLE_COOKIE_ERR;
}
if (*cookieLen > TLS_HS_MAX_COOKIE_SIZE) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_COOKIE_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17353, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"cookie len is too long.", 0, 0, 0, 0);
return HITLS_MSG_HANDLE_COOKIE_ERR;
}
return HITLS_SUCCESS;
}
/* If the cookie calculation callback is not registered, the default calculation is used */
int32_t ret = HITLS_SUCCESS;
CookieInfo *cookieInfo = &ctx->negotiatedInfo.cookieInfo;
/* If the number of remaining usage times of the current algorithm is 0, update the algorithm */
if (cookieInfo->algRemainTime == 0) {
ret = UpdateMacKey(ctx, cookieInfo);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
/* Add cookie calculation materials */
ret = AddCookieCalcMaterial(ctx, clientHello, cookieInfo, cookie, cookieLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Updated the current HMAC algorithm usage times */
cookieInfo->algRemainTime--;
return HITLS_SUCCESS;
}
static int32_t CheckCookie(TLS_Ctx *ctx, const ClientHelloMsg *clientHello, bool *isCookieValid)
{
uint8_t cookie[TLS_HS_MAX_COOKIE_SIZE] = {0};
uint32_t cookieLen = sizeof(cookie);
*isCookieValid = false;
/* Calculating cookies will reduce the number of times the algorithm is used. In order to prevent algorithm
* switching after calculation, it is increased by itself and then calculated */
ctx->negotiatedInfo.cookieInfo.algRemainTime++;
int32_t ret = HS_CalcCookie(ctx, clientHello, cookie, &cookieLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16917, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CalcCookie fail", 0, 0, 0, 0);
return ret;
}
if ((cookieLen == clientHello->cookieLen) &&
(memcmp((char *)cookie, (char *)clientHello->cookie, cookieLen) == 0)) {
*isCookieValid = true;
}
(void)memset_s(cookie, TLS_HS_MAX_COOKIE_SIZE, 0, TLS_HS_MAX_COOKIE_SIZE);
return HITLS_SUCCESS;
}
static int32_t CheckCookieWithPreMacKey(TLS_Ctx *ctx, const ClientHelloMsg *clientHello, bool *isCookieValid)
{
uint8_t macKeyStore[MAC_KEY_LEN] = {0};
CookieInfo *cookieInfo = &ctx->negotiatedInfo.cookieInfo;
/* If the previous key does not exist, the system will not verify */
if (memcmp(cookieInfo->preMacKey, macKeyStore, MAC_KEY_LEN) == 0) {
return HITLS_SUCCESS;
}
/* Save the current mackey */
(void)memcpy_s(macKeyStore, MAC_KEY_LEN, cookieInfo->macKey, MAC_KEY_LEN);
/* Use the previous mackey */
(void)memcpy_s(cookieInfo->macKey, MAC_KEY_LEN, cookieInfo->preMacKey, MAC_KEY_LEN);
int32_t ret = CheckCookie(ctx, clientHello, isCookieValid);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16918, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CheckCookie fail", 0, 0, 0, 0);
(void)memset_s(macKeyStore, MAC_KEY_LEN, 0, MAC_KEY_LEN);
return ret;
}
/* Restore the current mackey */
(void)memcpy_s(cookieInfo->macKey, MAC_KEY_LEN, macKeyStore, MAC_KEY_LEN);
(void)memset_s(macKeyStore, MAC_KEY_LEN, 0, MAC_KEY_LEN);
return HITLS_SUCCESS;
}
static int32_t CheckCookieDuringRenegotiation(TLS_Ctx *ctx, const ClientHelloMsg *clientHello, bool *isCookieValid)
{
uint8_t *cookie = ctx->negotiatedInfo.cookie;
uint16_t cookieLen = (uint16_t)ctx->negotiatedInfo.cookieSize;
if ((cookieLen == clientHello->cookieLen) &&
(memcmp((char *)cookie, (char *)clientHello->cookie, cookieLen) == 0)) {
*isCookieValid = true;
}
return HITLS_SUCCESS;
}
int32_t HS_CheckCookie(TLS_Ctx *ctx, const ClientHelloMsg *clientHello, bool *isCookieValid)
{
/* The DTLS protocol determines whether cookie verification is required based on user setting */
if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask) &&
!ctx->config.tlsConfig.isSupportDtlsCookieExchange && !ctx->isDtlsListen) {
*isCookieValid = true;
return HITLS_SUCCESS;
}
*isCookieValid = false;
/* If the client does not send the cookie, the verification is not required */
if (clientHello->cookie == NULL) {
return HITLS_SUCCESS;
}
/* In the renegotiation scenario, the cookie stored in the negotiatedInfo is used for verification */
if (ctx->negotiatedInfo.isRenegotiation) {
return CheckCookieDuringRenegotiation(ctx, clientHello, isCookieValid);
}
/* If the user's cookie validation callback is registered, use the user's callback interface */
HITLS_AppVerifyCookieCb cookieCb = ctx->globalConfig->appVerifyCookieCb;
if (cookieCb != NULL) {
int32_t isValid = cookieCb(ctx, clientHello->cookie, clientHello->cookieLen);
/* If the return value is not zero, the cookie is valid, so the judgment here does not equal failure rather than
* success */
if (isValid != HITLS_COOKIE_VERIFY_ERROR) {
*isCookieValid = true;
}
return HITLS_SUCCESS;
}
/* If the cookie validation callback function of the user is not registered, use the default validation function */
int32_t ret = CheckCookie(ctx, clientHello, isCookieValid);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16919, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CheckCookie fail", 0, 0, 0, 0);
return ret;
}
/* If the cookie is successfully verified for the first time, it is returned. Otherwise, the previous MacKey is used
* to verify the cookie again */
if (*isCookieValid) {
return HITLS_SUCCESS;
}
return CheckCookieWithPreMacKey(ctx, clientHello, isCookieValid);
}
#endif /* HITLS_TLS_PROTO_DTLS12 && HITLS_BSL_UIO_UDP */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/cookie/src/hs_cookie.c | C | unknown | 13,909 |
/*
* 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 HS_H
#define HS_H
#include "tls.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Initialize the handshake context
*
* @param ctx [IN] TLS object
*
* @retval HITLS_SUCCESS succeeded
*/
int32_t HS_Init(TLS_Ctx *ctx);
/**
* @brief Release the handshake context
*
* @param ctx [IN] TLS object
*/
void HS_DeInit(TLS_Ctx *ctx);
/**
* @brief Establish a TLS connection
*
* @param ctx [IN] TLS object
*
* @retval HITLS_SUCCESS The connection is successfully established.
* @retval For details about other error codes, see hitls_error.h
*/
int32_t HS_DoHandshake(TLS_Ctx *ctx);
/**
* @brief Generate the session key
*
* @param ctx [IN] TLS context
* @param isClient [IN] Client or Not
*
* @retval HITLS_SUCCESS succeeded
* @retval For details about other error codes, see hitls_error.h
*/
int32_t HS_KeyEstablish(TLS_Ctx *ctx, bool isClient);
/**
* @brief Session recovery Generate a session key.
*
* @param ctx [IN] TLS context
*
* @retval HITLS_SUCCESS succeeded
* @retval For details about other error codes, see hitls_error.h
*/
int32_t HS_ResumeKeyEstablish(TLS_Ctx *ctx);
/**
* @brief Obtain the current handshake status
*
* @param ctx [IN] TLS context
*
* @retval Current handshake status
*/
uint32_t HS_GetState(const TLS_Ctx *ctx);
/**
* @brief Obtain the version number. If the version number is not negotiated, the latest version
* supported by the local is returned.
*
* @param ctx [IN] TLS context
*
* @return Return the version number.
*/
uint32_t HS_GetVersion(const TLS_Ctx *ctx);
/**
* @brief Obtain the handshake status character string.
*
* @param state [IN] Handshake status
*
* @return Character string corresponding to the handshake status
*/
const char *HS_GetStateStr(uint32_t state);
/**
* @brief Check whether the conditions for sending keyupdate are met
*
* @param ctx [IN] TLS context
* @param updateType [IN] keyupdate type
*
* @retval HITLS_SUCCESS succeeded.
* @retval For details about other error codes, see hitls_error.h
*/
int32_t HS_CheckKeyUpdateState(TLS_Ctx *ctx, uint32_t updateType);
/**
* @brief Obtain the server_name in the handshake TLS context.
*
* @param ctx [IN] TLS context
*
* @return string of server_name in the TLS context during the handshake
*/
const char *HS_GetServerName(const TLS_Ctx *ctx);
/**
* @brief Determine and handle the 2MSL timeout
*
* @param ctx [IN] TLS context
*
* @return string of server_name in the TLS context during the handshake
*/
#ifdef HITLS_TLS_PROTO_DTLS12
int32_t HS_CheckAndProcess2MslTimeout(TLS_Ctx *ctx);
/**
* @brief Send dtls fragment handshake message according to maxRecPayloadLen
*
* @param ctx [IN] TLS context
* @param maxRecPayloadLen [IN] the max plaintext size
* @param msgData [IN] the handshake message data need to be send
*
* @retval HITLS_SUCCESS succeeded.
* @retval For details about other error codes, see hitls_error.h
*/
int32_t HS_DtlsSendFragmentHsMsg(TLS_Ctx *ctx, uint32_t maxRecPayloadLen, const uint8_t *msgData);
#endif
/**
* @brief Get whether the hadshake state is a send state
*
* @param state [IN] handshake state
*
* @retval true or false
*/
bool IsHsSendState(HITLS_HandshakeState state);
int32_t HS_CheckPostHandshakeAuth(TLS_Ctx *ctx);
#define TLS_IS_FIRST_HANDSHAKE(ctx) ((ctx)->negotiatedInfo.clientVerifyDataSize == 0 \
|| (ctx)->negotiatedInfo.serverVerifyDataSize == 0)
#ifdef __cplusplus
}
#endif
#endif /* HS_H */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/include/hs.h | C | unknown | 4,081 |
/*
* 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 PACK_H
#define PACK_H
#include "tls.h"
#include "hs_msg.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Pack handshake messages
*
* @param ctx [IN] TLS context
* @param type [IN] Message type
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t HS_PackMsg(TLS_Ctx *ctx, HS_MsgType type);
/**
* @brief Pack uint8_t to buffer
*
* @param pkt [IN/OUT] Context for packing
* @param value [IN] packed data
*
* @retval HITLS_SUCCESS success
* @retval HITLS_MEMALLOC_FAIL Grow buffer failed
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH Buffer is not enough
*/
int32_t PackAppendUint8ToBuf(PackPacket *pkt, uint8_t value);
/**
* @brief Pack uint16_t to buffer
*
* @param pkt [IN/OUT] Context for packing
* @param value [IN] packed data
*
* @retval HITLS_SUCCESS success
* @retval HITLS_MEMALLOC_FAIL Grow buffer failed
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH Buffer is not enough
*/
int32_t PackAppendUint16ToBuf(PackPacket *pkt, uint16_t value);
/**
* @brief Pack uint24_t to buffer
*
* @param pkt [IN/OUT] Context for packing
* @param value [IN] packed data
*
* @retval HITLS_SUCCESS success
* @retval HITLS_MEMALLOC_FAIL Grow buffer failed
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH Buffer is not enough
*/
int32_t PackAppendUint24ToBuf(PackPacket *pkt, uint32_t value);
/**
* @brief Pack uint32_t to buffer
*
* @param pkt [IN/OUT] Context for packing
* @param value [IN] packed data
*
* @retval HITLS_SUCCESS success
* @retval HITLS_MEMALLOC_FAIL Grow buffer failed
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH Buffer is not enough
*/
int32_t PackAppendUint32ToBuf(PackPacket *pkt, uint32_t value);
/**
* @brief Pack uint64_t to buffer
*
* @param pkt [IN/OUT] Context for packing
* @param value [IN] packed data
*
* @retval HITLS_SUCCESS success
* @retval HITLS_MEMALLOC_FAIL Grow buffer failed
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH Buffer is not enough
*/
int32_t PackAppendUint64ToBuf(PackPacket *pkt, uint64_t value);
/**
* @brief Pack data to buffer
*
* @param pkt [IN/OUT] Context for packing
* @param data [IN] packed data
* @param size [IN] size of packed data
*
* @retval HITLS_SUCCESS success
* @retval HITLS_MEMALLOC_FAIL Grow buffer failed
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH Buffer is not enough
*/
int32_t PackAppendDataToBuf(PackPacket *pkt, const uint8_t *data, uint32_t size);
/**
* @brief Reserve bytes in the handshake buffer for packing, without increasing offset.
* The reservedBuf should be used immediately after this function is called. Since the buffer may be reallocated.
* If input reservedBuf == NULL, just prepare Handshake message buffer for handshake message packing.
*
* @param pkt [IN/OUT] Context for packing
* @param size [IN] reserved data size
* @param reservedBuf [OUT] reserved buffer pointer
*
* @retval HITLS_SUCCESS success
* @retval HITLS_MEMALLOC_FAIL Grow buffer failed
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH Buffer is not enough
*/
int32_t PackReserveBytes(PackPacket *pkt, uint32_t size, uint8_t **reservedBuf);
/**
* @brief It means a buffer with size bytes length is needed to be packed. It reserves bytes to be filled as length.
* After the bytes is reserved, the offset will increase, and return the position of the length value.
* After the following buffer has been packed, use the PackCloseUintXField fucntion with returned position before to
* calculate the length and fill the length value.
*
* @param pkt [IN/OUT] Context for packing
* @param size [IN] allocate data size
* @param allocatedPosition [OUT] allocated buffer offset
*
* @retval HITLS_SUCCESS success
* @retval HITLS_MEMALLOC_FAIL Grow buffer failed
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH Buffer is not enough
*/
int32_t PackStartLengthField(PackPacket *pkt, uint32_t size, uint32_t *allocatedPosition);
/**
* @brief Increasing offset in the handshake buffer, without allocating memory.
*
* @param pkt [IN/OUT] Context for packing
* @param size [IN] Offset size to skip
*
* @retval HITLS_SUCCESS success
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH Buffer is not enough
*/
int32_t PackSkipBytes(PackPacket *pkt, uint32_t size);
/**
* @brief After finish packing a buffer with a uint8_t length, pack the length field at the start of the buffer.
*
* @param pkt [IN/OUT] Context for packing
* @param position [IN] The start position of the field
*/
void PackCloseUint8Field(PackPacket *pkt, uint32_t position);
/**
* @brief After finish packing a buffer with a uint16_t length, pack the length field at the start of the buffer.
*
* @param pkt [IN/OUT] Context for packing
* @param position [IN] The start position of the field
*/
void PackCloseUint16Field(PackPacket *pkt, uint32_t position);
/**
* @brief After finish packing a buffer with a uint24_t length, pack the length field at the start of the buffer.
*
* @param pkt [IN/OUT] Context for packing
* @param position [IN] The start position of the field
*/
void PackCloseUint24Field(PackPacket *pkt, uint32_t position);
/**
* @brief Get a subbuffer from the handshake buffer, which starts from the start position,
* ends at the current offset, and length is the length of the sub-buffer.
*
* @attention The reservedBuf should be used immediately after this function is called.
* @param pkt [IN] Context for packing
* @param start [IN] The start position of the sub-buffer
* @param length [OUT] The length of the sub-buffer
* @param buf [OUT] The pointer of the sub-buffer
*
* @retval HITLS_SUCCESS success
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH Start exceeds the current offset
*/
int32_t PackGetSubBuffer(PackPacket *pkt, uint32_t start, uint32_t *length, uint8_t **buf);
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/include/pack.h | C | unknown | 6,479 |
/*
* 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.
*/
#include <stdlib.h>
#include <stdint.h>
#include "hitls_build.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "hitls_config.h"
#include "tls.h"
#include "hs_msg.h"
#include "hs_ctx.h"
#include "hs.h"
#include "pack_msg.h"
#include "pack_common.h"
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
static int32_t PackHsMsgBody(TLS_Ctx *ctx, HS_MsgType type, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
switch (type) {
#ifdef HITLS_TLS_HOST_SERVER
case SERVER_HELLO:
ret = PackServerHello(ctx, pkt);
break;
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
case HELLO_VERIFY_REQUEST:
ret = PackHelloVerifyRequest(ctx, pkt);
break;
#endif
case SERVER_KEY_EXCHANGE:
ret = PackServerKeyExchange(ctx, pkt);
break;
case CERTIFICATE_REQUEST:
ret = PackCertificateRequest(ctx, pkt);
break;
case HELLO_REQUEST:
case SERVER_HELLO_DONE:
return HITLS_SUCCESS;
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
case NEW_SESSION_TICKET:
ret = PackNewSessionTicket(ctx, pkt);
break;
#endif /* HITLS_TLS_FEATURE_SESSION_TICKET */
#endif /* HITLS_TLS_HOST_SERVER */
#ifdef HITLS_TLS_HOST_CLIENT
case CLIENT_HELLO:
ret = PackClientHello(ctx, pkt);
break;
case CLIENT_KEY_EXCHANGE:
ret = PackClientKeyExchange(ctx, pkt);
break;
case CERTIFICATE_VERIFY:
ret = PackCertificateVerify(ctx, pkt);
break;
#endif /* HITLS_TLS_HOST_CLIENT */
case CERTIFICATE:
ret = PackCertificate(ctx, pkt);
break;
case FINISHED:
ret = PackFinished(ctx, pkt);
break;
default:
ret = HITLS_PACK_UNSUPPORT_HANDSHAKE_MSG;
break;
}
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15812, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack handshake[%u] msg error.", type, 0, 0, 0);
}
return ret;
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#ifdef HITLS_TLS_PROTO_TLS13
static int32_t PackTls13HsMsgBody(TLS_Ctx *ctx, HS_MsgType type, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
switch (type) {
#ifdef HITLS_TLS_HOST_CLIENT
case CLIENT_HELLO:
ret = PackClientHello(ctx, pkt);
break;
#endif /* HITLS_TLS_HOST_CLIENT */
#ifdef HITLS_TLS_HOST_SERVER
case SERVER_HELLO:
ret = PackServerHello(ctx, pkt);
break;
case ENCRYPTED_EXTENSIONS:
ret = PackEncryptedExtensions(ctx, pkt);
break;
case CERTIFICATE_REQUEST:
ret = Tls13PackCertificateRequest(ctx, pkt);
break;
case NEW_SESSION_TICKET:
ret = Tls13PackNewSessionTicket(ctx, pkt);
break;
#endif /* HITLS_TLS_HOST_SERVER */
case CERTIFICATE:
ret = Tls13PackCertificate(ctx, pkt);
break;
case CERTIFICATE_VERIFY:
ret = PackCertificateVerify(ctx, pkt);
break;
case FINISHED:
ret = PackFinished(ctx, pkt);
break;
#ifdef HITLS_TLS_FEATURE_KEY_UPDATE
case KEY_UPDATE:
ret = PackKeyUpdate(ctx, pkt);
break;
#endif
default:
ret = HITLS_PACK_UNSUPPORT_HANDSHAKE_MSG;
break;
}
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15813, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack handshake[%u] msg error.", type, 0, 0, 0);
}
return ret;
}
#endif /* HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_PROTO_DTLS12
int32_t Dtls12PackMsg(TLS_Ctx *ctx, HS_MsgType type)
{
uint16_t sequence = 0;
int32_t ret = HITLS_SUCCESS;
HS_Ctx *hsCtx = ctx->hsCtx;
PackPacket pkt = {.buf = &hsCtx->msgBuf, .bufLen = &hsCtx->bufferLen, .bufOffset = &hsCtx->msgLen};
uint32_t headerPosition = 0;
ret = PackStartLengthField(&pkt, DTLS_HS_MSG_HEADER_SIZE, &headerPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackHsMsgBody(ctx, type, &pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
sequence = hsCtx->nextSendSeq;
uint8_t *dtlsHeaderBuf = NULL;
uint32_t totalLen = 0;
ret = PackGetSubBuffer(&pkt, headerPosition, &totalLen, &dtlsHeaderBuf);
if (ret != HITLS_SUCCESS) {
return ret;
}
PackDtlsMsgHeader(type, sequence, totalLen - DTLS_HS_MSG_HEADER_SIZE, dtlsHeaderBuf);
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_PROTO_TLS_BASIC
int32_t Tls12PackMsg(TLS_Ctx *ctx, HS_MsgType type)
{
int32_t ret = HITLS_SUCCESS;
if (type > HS_MSG_TYPE_END) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16943, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "type err", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_PACK_UNSUPPORT_HANDSHAKE_MSG);
return HITLS_PACK_UNSUPPORT_HANDSHAKE_MSG;
}
PackPacket pkt = {.buf = &ctx->hsCtx->msgBuf, .bufLen = &ctx->hsCtx->bufferLen,
.bufOffset = &ctx->hsCtx->msgLen};
ret = PackAppendUint8ToBuf(&pkt, (uint8_t)type & 0xffu); /* Fill handshake message type */
if (ret != HITLS_SUCCESS) {
return ret;
}
uint32_t msgLenPosition = 0u;
ret = PackStartLengthField(&pkt, UINT24_SIZE, &msgLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackHsMsgBody(ctx, type, &pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
PackCloseUint24Field(&pkt, msgLenPosition); /* Fill handshake message body length */
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC */
#ifdef HITLS_TLS_PROTO_TLS13
int32_t Tls13PackMsg(TLS_Ctx *ctx, HS_MsgType type)
{
int32_t ret = HITLS_SUCCESS;
int32_t enumBorder = HS_MSG_TYPE_END;
if ((int32_t)type > enumBorder) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16944, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "type err", 0, 0, 0, 0);
return HITLS_PACK_UNSUPPORT_HANDSHAKE_MSG;
}
HS_Ctx *hsCtx = ctx->hsCtx;
PackPacket pkt = {.buf = &hsCtx->msgBuf, .bufLen = &hsCtx->bufferLen, .bufOffset = &hsCtx->msgLen};
ret = PackAppendUint8ToBuf(&pkt, (uint8_t)type & 0xffu); /* Fill handshake message type */
if (ret != HITLS_SUCCESS) {
return ret;
}
uint32_t msgLenPosition = 0u;
ret = PackStartLengthField(&pkt, UINT24_SIZE, &msgLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackTls13HsMsgBody(ctx, type, &pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
PackCloseUint24Field(&pkt, msgLenPosition); /* Fill handshake message body length */
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS13 */
int32_t HS_PackMsg(TLS_Ctx *ctx, HS_MsgType type)
{
if (ctx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15814, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"the input parameter pointer is null.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t version = HS_GetVersion(ctx);
switch (version) {
#ifdef HITLS_TLS_PROTO_TLS_BASIC
case HITLS_VERSION_TLS12:
#ifdef HITLS_TLS_PROTO_TLCP11
case HITLS_VERSION_TLCP_DTLCP11:
#if defined(HITLS_TLS_PROTO_DTLCP11)
if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
return Dtls12PackMsg(ctx, type);
}
#endif
#endif
return Tls12PackMsg(ctx, type);
#endif /* HITLS_TLS_PROTO_TLS_BASIC */
#ifdef HITLS_TLS_PROTO_TLS13
case HITLS_VERSION_TLS13:
return Tls13PackMsg(ctx, type);
#endif /* HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_PROTO_DTLS12
case HITLS_VERSION_DTLS12:
return Dtls12PackMsg(ctx, type);
#endif
default:
break;
}
BSL_ERR_PUSH_ERROR(HITLS_PACK_UNSUPPORT_VERSION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15815, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack handshake msg error, unsupport version[0x%x].", version, 0, 0, 0);
return HITLS_PACK_UNSUPPORT_VERSION;
}
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack.c | C | unknown | 8,891 |
/*
* 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.
*/
#include <stdint.h>
#include "hitls_build.h"
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "cert.h"
#include "hitls_error.h"
#include "tls.h"
#include "hs_ctx.h"
#include "hs_common.h"
#include "hs_extensions.h"
#include "pack_common.h"
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
int32_t PackCertificate(TLS_Ctx *ctx, PackPacket *pkt)
{
/* Start packing certificate list length */
uint32_t certListLenPosition = 0u;
int32_t ret = PackStartLengthField(pkt, CERT_LEN_TAG_SIZE, &certListLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Certificate content using callback */
ret = SAL_CERT_EncodeCertChain(ctx, pkt);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15809, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode cert list fail.", 0, 0, 0, 0);
return ret;
}
/* Close certificate list length field */
PackCloseUint24Field(pkt, certListLenPosition);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#ifdef HITLS_TLS_PROTO_TLS13
int32_t Tls13PackCertificate(TLS_Ctx *ctx, PackPacket *pkt)
{
/* Pack the length of certificate_request_context */
int32_t ret = PackAppendUint8ToBuf(pkt, (uint8_t)ctx->certificateReqCtxSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack the content of certificate_request_context */
if (ctx->certificateReqCtxSize > 0) {
ret = PackAppendDataToBuf(pkt, ctx->certificateReqCtx, ctx->certificateReqCtxSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
/* Start packing certificate list length */
uint32_t certListLenPosition = 0u;
ret = PackStartLengthField(pkt, CERT_LEN_TAG_SIZE, &certListLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Certificate content using callback */
ret = SAL_CERT_EncodeCertChain(ctx, pkt);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15811, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode cert list fail when pack certificate msg.", 0, 0, 0, 0);
return ret;
}
/* Close certificate list length field */
PackCloseUint24Field(pkt, certListLenPosition);
return HITLS_SUCCESS;
}
#endif | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_certificate.c | C | unknown | 2,973 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_HOST_SERVER
#include <stdint.h>
#include <stdbool.h>
#include "securec.h"
#include "bsl_sal.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "tls.h"
#include "hs_common.h"
#include "hs_ctx.h"
#include "hs_extensions.h"
#include "pack_common.h"
#include "pack_extensions.h"
#include "cert_mgr_ctx.h"
#include "custom_extensions.h"
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
typedef struct {
uint8_t certType;
bool isSupported;
} PackCertTypesInfo;
static int32_t PackCertificateTypes(const TLS_Ctx *ctx, PackPacket *pkt)
{
const TLS_Config *config = &(ctx->config.tlsConfig);
if ((config->cipherSuites == NULL) || (config->cipherSuitesSize == 0)) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15682, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack certificate types error, invalid input parameter.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
PackCertTypesInfo certTypeLists[] = {
{CERT_TYPE_RSA_SIGN, false},
{CERT_TYPE_ECDSA_SIGN, false},
{CERT_TYPE_DSS_SIGN, false}
};
uint8_t certTypeListsSize = (uint8_t)(sizeof(certTypeLists) / sizeof(certTypeLists[0]));
uint8_t supportedCertTypesSize = 0;
uint32_t baseSignAlgorithmsSize = config->signAlgorithmsSize;
const uint16_t *baseSignAlgorithms = config->signAlgorithms;
for (uint32_t i = 0; i < baseSignAlgorithmsSize; i++) {
HITLS_CERT_KeyType keyType = SAL_CERT_SignScheme2CertKeyType(ctx, baseSignAlgorithms[i]);
CERT_Type certType = CertKeyType2CertType(keyType);
for (uint32_t j = 0; j < certTypeListsSize; j++) {
if ((certTypeLists[j].certType == certType) && (certTypeLists[j].isSupported == false)) {
certTypeLists[j].isSupported = true;
supportedCertTypesSize++;
break;
}
}
}
int32_t ret = PackAppendUint8ToBuf(pkt, supportedCertTypesSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
for (uint32_t i = 0; i < certTypeListsSize; i++) {
if (certTypeLists[i].isSupported == true) {
ret = PackAppendUint8ToBuf(pkt, certTypeLists[i].certType);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#if defined(HITLS_TLS_PROTO_TLS12) || defined(HITLS_TLS_PROTO_DTLS12)
static int32_t PackSignAlgorithms(const TLS_Ctx *ctx, PackPacket *pkt)
{
const TLS_Config *config = &(ctx->config.tlsConfig);
if ((config->signAlgorithms == NULL) || (config->signAlgorithmsSize == 0)) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15684, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack signature algorithms error, invalid input parameter.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
uint16_t signAlgorithmsSize = (uint16_t)config->signAlgorithmsSize * sizeof(uint16_t);
int32_t ret = PackAppendUint16ToBuf(pkt, signAlgorithmsSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
for (uint32_t index = 0; index < config->signAlgorithmsSize; index++) {
ret = PackAppendUint16ToBuf(pkt, config->signAlgorithms[index]);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS12 || HITLS_TLS_PROTO_DTLS12 */
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
static int32_t PackCALists(const TLS_Ctx *ctx, PackPacket *pkt)
{
const TLS_Config *config = &(ctx->config.tlsConfig);
if (config->caList == NULL) {
return PackAppendUint16ToBuf(pkt, 0);
}
#ifdef HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES
uint32_t caListLenPosition = 0u;
int32_t ret = PackStartLengthField(pkt, sizeof(uint16_t), &caListLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackTrustedCAList(config->caList, pkt);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17370, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack CA list error", 0, 0, 0, 0);
return ret;
}
PackCloseUint16Field(pkt, caListLenPosition);
#endif /* HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES */
return HITLS_SUCCESS;
}
int32_t PackCertificateRequest(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = PackCertificateTypes(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
#if defined(HITLS_TLS_PROTO_TLS12) || defined(HITLS_TLS_PROTO_DTLS12)
/* TLCP does not have the signature algorithm field */
if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP_DTLCP11) {
ret = PackSignAlgorithms(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif
ret = PackCALists(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#ifdef HITLS_TLS_PROTO_TLS13
static int32_t PackSignAlgorithmsExtension(const TLS_Ctx *ctx, PackPacket *pkt)
{
const TLS_Config *config = &(ctx->config.tlsConfig);
if ((config->signAlgorithms == NULL) || (config->signAlgorithmsSize == 0)) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15686, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack signature algorithms error, invalid input parameter.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t signAlgorithmsSize = 0;
uint16_t *signAlgorithms = CheckSupportSignAlgorithms(ctx, config->signAlgorithms,
config->signAlgorithmsSize, &signAlgorithmsSize);
if (signAlgorithms == NULL || signAlgorithmsSize == 0) {
BSL_SAL_FREE(signAlgorithms);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17310, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"no available signAlgo", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return HITLS_CERT_ERR_NO_SIGN_SCHEME_MATCH;
}
uint16_t exMsgHeaderLen = sizeof(uint16_t);
uint16_t exMsgDataLen = sizeof(uint16_t) * (uint16_t)signAlgorithmsSize;
int32_t ret = PackExtensionHeader(HS_EX_TYPE_SIGNATURE_ALGORITHMS, exMsgHeaderLen + exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(signAlgorithms);
return ret;
}
(void)PackAppendUint16ToBuf(pkt, exMsgDataLen);
for (uint32_t index = 0; index < signAlgorithmsSize; index++) {
(void)PackAppendUint16ToBuf(pkt, signAlgorithms[index]);
}
BSL_SAL_FREE(signAlgorithms);
return HITLS_SUCCESS;
}
static int32_t PackCertReqExtensions(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
const PackExtInfo extMsgList[] = {
{.exMsgType = HS_EX_TYPE_SIGNATURE_ALGORITHMS,
.needPack = true,
.packFunc = PackSignAlgorithmsExtension},
{.exMsgType = HS_EX_TYPE_SIGNATURE_ALGORITHMS_CERT,
.needPack = false,
.packFunc = NULL},
#ifdef HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES
{.exMsgType = HS_EX_TYPE_CERTIFICATE_AUTHORITIES,
.needPack = ctx->config.tlsConfig.caList != NULL,
.packFunc = PackClientCAList},
#endif /* HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES */
};
uint32_t listSize = sizeof(extMsgList) / sizeof(extMsgList[0]);
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
if (IsPackNeedCustomExtensions(CUSTOM_EXT_FROM_CTX(ctx), HITLS_EX_TYPE_TLS1_3_CERTIFICATE_REQUEST)) {
ret = PackCustomExtensions(ctx, pkt, HITLS_EX_TYPE_TLS1_3_CERTIFICATE_REQUEST, NULL, 0);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
for (uint32_t index = 0; index < listSize; index++) {
if (extMsgList[index].packFunc == NULL) {
ret = PackEmptyExtension(extMsgList[index].exMsgType, extMsgList[index].needPack, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
if (extMsgList[index].packFunc != NULL && extMsgList[index].needPack) {
ret = extMsgList[index].packFunc(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
}
return HITLS_SUCCESS;
}
int32_t Tls13PackCertReqExtensions(const TLS_Ctx *ctx, PackPacket *pkt)
{
/* Start packing extensions length */
uint32_t extensionsLenPosition = 0u;
int32_t ret = PackStartLengthField(pkt, sizeof(uint16_t), &extensionsLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack the extended content of the Tls1.3 Certificate Request */
ret = PackCertReqExtensions(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Close extensions length field */
PackCloseUint16Field(pkt, extensionsLenPosition);
return HITLS_SUCCESS;
}
int32_t Tls13PackCertificateRequest(const TLS_Ctx *ctx, PackPacket *pkt)
{
/* Pack certificate_request_context length */
int32_t ret = PackAppendUint8ToBuf(pkt, (uint8_t)ctx->certificateReqCtxSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack certificate_request_context content */
if (ctx->certificateReqCtxSize > 0) {
ret = PackAppendDataToBuf(pkt, ctx->certificateReqCtx, ctx->certificateReqCtxSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
ret = Tls13PackCertReqExtensions(ctx, pkt);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15690, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack tls1.3 certificate request msg extension content fail.", 0, 0, 0, 0);
return ret;
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS13 */
#endif /* HITLS_TLS_HOST_SERVER */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_certificate_request.c | C | unknown | 10,662 |
/*
* 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.
*/
#include "hitls_build.h"
#if defined(HITLS_TLS_HOST_CLIENT) || defined(HITLS_TLS_PROTO_TLS13)
#include <stdint.h>
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "pack_common.h"
#include "hitls_error.h"
#include "tls.h"
#include "hs_ctx.h"
int32_t PackCertificateVerify(const TLS_Ctx *ctx, PackPacket *pkt)
{
const HS_Ctx *hsCtx = (HS_Ctx *)ctx->hsCtx;
int32_t ret = HITLS_SUCCESS;
if (hsCtx->verifyCtx->verifyDataSize == 0u) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15824, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"the verify data is illegal.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
#if defined(HITLS_TLS_PROTO_TLS12) || defined(HITLS_TLS_PROTO_DTLS12) || defined(HITLS_TLS_PROTO_TLS13)
if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP_DTLCP11) {
ret = PackAppendUint16ToBuf(pkt, (uint16_t)ctx->negotiatedInfo.signScheme);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif
/* Pack signature data length */
ret = PackAppendUint16ToBuf(pkt, (uint16_t)hsCtx->verifyCtx->verifyDataSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack signature data */
return PackAppendDataToBuf(pkt, hsCtx->verifyCtx->verifyData, hsCtx->verifyCtx->verifyDataSize);
}
#endif /* HITLS_TLS_HOST_CLIENT || HITLS_TLS_PROTO_TLS13 */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_certificate_verify.c | C | unknown | 2,056 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_HOST_CLIENT
#include <stdint.h>
#include "securec.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "tls.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "hitls_security.h"
#ifdef HITLS_TLS_FEATURE_SECURITY
#include "security.h"
#endif
#include "cipher_suite.h"
#include "hs_ctx.h"
#include "pack_common.h"
#include "pack_extensions.h"
#include "hs_common.h"
#define CIPHER_SUITES_LEN_SIZE 2u
// Pack the version content of the client Hello message.
static int32_t PackClientVersion(const TLS_Ctx *ctx, uint16_t version, PackPacket *pkt)
{
(void)ctx;
#ifdef HITLS_TLS_FEATURE_SECURITY
const TLS_Config *tlsConfig = &ctx->config.tlsConfig;
int32_t ret = SECURITY_CfgCheck((const HITLS_Config *)tlsConfig, HITLS_SECURITY_SECOP_VERSION, 0, version, NULL);
if (ret != SECURITY_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16924, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CfgCheck fail, ret %d", ret, 0, 0, 0);
ctx->method.sendAlert((TLS_Ctx *)(uintptr_t)ctx, ALERT_LEVEL_FATAL, ALERT_INSUFFICIENT_SECURITY);
BSL_ERR_PUSH_ERROR(HITLS_PACK_UNSECURE_VERSION);
return HITLS_PACK_UNSECURE_VERSION;
}
#endif /* HITLS_TLS_FEATURE_SECURITY */
return PackAppendUint16ToBuf(pkt, version);
}
#ifdef HITLS_TLS_PROTO_DTLS12
// Pack the cookie content of the client Hello message.
static int32_t PackClientCookie(PackPacket *pkt, const uint8_t *cookie, uint8_t cookieLen)
{
int32_t ret = PackAppendUint8ToBuf(pkt, cookieLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (cookieLen == 0u) {
return HITLS_SUCCESS;
}
return PackAppendDataToBuf(pkt, cookie, cookieLen);
}
#endif /* HITLS_TLS_PROTO_DTLS12 */
static int32_t PackCipherSuites(const TLS_Ctx *ctx, PackPacket *pkt, bool isTls13)
{
uint16_t *cipherSuites = NULL;
uint32_t cipherSuitesSize = 0;
#ifdef HITLS_TLS_PROTO_TLS13
if (isTls13) {
cipherSuites = ctx->config.tlsConfig.tls13CipherSuites;
cipherSuitesSize = ctx->config.tlsConfig.tls13cipherSuitesSize;
} else {
cipherSuites = ctx->config.tlsConfig.cipherSuites;
cipherSuitesSize = ctx->config.tlsConfig.cipherSuitesSize;
}
#else
(void)isTls13;
cipherSuites = ctx->config.tlsConfig.cipherSuites;
cipherSuitesSize = ctx->config.tlsConfig.cipherSuitesSize;
#endif /* HITLS_TLS_PROTO_TLS13 */
int32_t ret = HITLS_SUCCESS;
for (uint32_t i = 0; i < cipherSuitesSize; i++) {
if (!IsCipherSuiteAllowed(ctx, cipherSuites[i])) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15845, BSL_LOG_LEVEL_WARN, BSL_LOG_BINLOG_TYPE_RUN,
"The cipher suite [0x%04x] is NOT supported, index=[%u].", cipherSuites[i], i, 0, 0);
continue;
}
ret = PackAppendUint16ToBuf(pkt, cipherSuites[i]);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
return HITLS_SUCCESS;
}
static int32_t PackScsvCipherSuites(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
/* If the local is not in the renegotiation state, the SCSV algorithm set needs to be packed. */
if (!ctx->negotiatedInfo.isRenegotiation) {
ret = PackAppendUint16ToBuf(pkt, TLS_EMPTY_RENEGOTIATION_INFO_SCSV);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#ifdef HITLS_TLS_FEATURE_MODE_FALL_BACK_SCSV
if ((ctx->config.tlsConfig.modeSupport & HITLS_MODE_SEND_FALLBACK_SCSV) != 0) {
ret = PackAppendUint16ToBuf(pkt, TLS_FALLBACK_SCSV);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif
return HITLS_SUCCESS;
}
// Pack the cipher suites content of the client hello message.
static int32_t PackClientCipherSuites(const TLS_Ctx *ctx, PackPacket *pkt)
{
uint32_t cipherLenPosition = 0u;
/* Finally fill in the length of the cipher suites */
int32_t ret = PackStartLengthField(pkt, CIPHER_SUITES_LEN_SIZE, &cipherLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
#ifdef HITLS_TLS_PROTO_TLS13
if (ctx->config.tlsConfig.maxVersion == HITLS_VERSION_TLS13) {
ret = PackCipherSuites(ctx, pkt, 1);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16925, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PackCipherSuites fail", 0, 0, 0, 0);
return ret;
}
}
#endif /* HITLS_TLS_PROTO_TLS13 */
if (ctx->config.tlsConfig.minVersion != HITLS_VERSION_TLS13) {
ret = PackCipherSuites(ctx, pkt, 0);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16926, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"PackCipherSuites fail", 0, 0, 0, 0);
return ret;
}
}
uint32_t suitesLength = 0;
ret = PackGetSubBuffer(pkt, cipherLenPosition, &suitesLength, NULL);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (suitesLength == CIPHER_SUITES_LEN_SIZE) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_CLIENT_CIPHER_SUITE_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15732, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack cipher suite error, no cipher suite.", 0, 0, 0, 0);
return HITLS_PACK_CLIENT_CIPHER_SUITE_ERR;
}
ret = PackScsvCipherSuites(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* The cipher suite has been filled. Each cipher suite takes two bytes, so the length of the filled cipher suite can
* be calculated according to offset */
PackCloseUint16Field(pkt, cipherLenPosition);
return HITLS_SUCCESS;
}
// Pack the content of the method for compressing the client Hello message.
static int32_t PackClientCompressionMethod(PackPacket *pkt)
{
int32_t ret = PackAppendUint8ToBuf(pkt, 1);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Compression methods Currently support uncompressed */
return PackAppendUint8ToBuf(pkt, 0);
}
// Pack the session and cookie content of the client hello message.
static int32_t PackSessionAndCookie(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
(void)ret;
(void)ctx;
#if defined(HITLS_TLS_FEATURE_SESSION_ID) || defined(HITLS_TLS_PROTO_TLS13)
HS_Ctx *hsCtx = (HS_Ctx *)ctx->hsCtx;
ret = PackSessionId(pkt, hsCtx->sessionId, hsCtx->sessionIdSize);
if (ret != HITLS_SUCCESS) {
(void)memset_s(hsCtx->sessionId, hsCtx->sessionIdSize, 0, hsCtx->sessionIdSize);
return ret;
}
#else // Session recovery is not supported.
/* SessionId (Session is not supported yet and the length field is initialized with a value of 0) */
ret = PackAppendUint8ToBuf(pkt, 0);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif
#ifdef HITLS_TLS_PROTO_DTLS12
const TLS_Config *tlsConfig = &ctx->config.tlsConfig;
if (IS_SUPPORT_DATAGRAM(tlsConfig->originVersionMask)) {
ret = PackClientCookie(pkt, ctx->negotiatedInfo.cookie, (uint8_t)ctx->negotiatedInfo.cookieSize);
if (ret != HITLS_SUCCESS) {
(void)memset_s(ctx->negotiatedInfo.cookie, ctx->negotiatedInfo.cookieSize,
0, ctx->negotiatedInfo.cookieSize);
return ret;
}
}
#endif
return HITLS_SUCCESS;
}
// Pack the mandatory content of the ClientHello message.
static int32_t PackClientHelloMandatoryField(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
const TLS_Config *tlsConfig = &ctx->config.tlsConfig;
if (ctx->hsCtx->clientRandom == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16927, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"clientRandom null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
uint16_t version =
#ifdef HITLS_TLS_PROTO_TLS13
(tlsConfig->maxVersion == HITLS_VERSION_TLS13) ? HITLS_VERSION_TLS12 :
#endif
tlsConfig->maxVersion;
ret = PackClientVersion(ctx, version, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackAppendDataToBuf(pkt, ctx->hsCtx->clientRandom, HS_RANDOM_SIZE);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackSessionAndCookie(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackClientCipherSuites(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
return PackClientCompressionMethod(pkt);
}
// Pack the ClientHello message to form the Handshake body.
int32_t PackClientHello(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = PackClientHelloMandatoryField(ctx, pkt);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15735, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack client hello mandatory content fail.", 0, 0, 0, 0);
return ret;
}
ret = PackClientExtension(ctx, pkt);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15736, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack client hello extension content fail.", 0, 0, 0, 0);
return ret;
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_HOST_CLIENT */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_client_hello.c | C | unknown | 9,781 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_HOST_CLIENT
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
#include <stdint.h>
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "bsl_sal.h"
#include "hitls_error.h"
#include "tls.h"
#include "crypt.h"
#include "cert_method.h"
#include "hs_ctx.h"
#include "hs_common.h"
#include "pack_common.h"
#ifdef HITLS_TLS_SUITE_KX_ECDHE
#ifdef HITLS_TLS_PROTO_TLCP11
static int32_t PackDtlcpbytes(const TLS_Ctx *ctx, PackPacket *pkt)
{
/* Compatible with OpenSSL. Three bytes are added to the client key exchange. */
int32_t ret = HITLS_SUCCESS;
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
ret = PackAppendUint8ToBuf(pkt, HITLS_EC_CURVE_TYPE_NAMED_CURVE);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackAppendUint16ToBuf(pkt, HITLS_EC_GROUP_SM2);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
return HITLS_SUCCESS;
}
#endif
static int32_t PackClientKxMsgNamedCurve(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint32_t pubKeyLen;
EcdhParam *ecdh = &(ctx->hsCtx->kxCtx->keyExchParam.ecdh);
HITLS_ECParameters *curveParams = &ecdh->curveParams;
KeyExchCtx *kxCtx = ctx->hsCtx->kxCtx;
pubKeyLen = SAL_CRYPT_GetCryptLength(ctx, HITLS_CRYPT_INFO_CMD_GET_PUBLIC_KEY_LEN, curveParams->param.namedcurve);
if (pubKeyLen == 0u) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_INVALID_KX_PUBKEY_LENGTH);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15673, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"invalid key exchange pubKey length.", 0, 0, 0, 0);
return HITLS_PACK_INVALID_KX_PUBKEY_LENGTH;
}
#ifdef HITLS_TLS_PROTO_TLCP11
ret = PackDtlcpbytes(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif
uint32_t pubKeyLenPosition = 0u;
ret = PackStartLengthField(pkt, sizeof(uint8_t), &pubKeyLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint8_t *reservedBuf = NULL;
ret = PackReserveBytes(pkt, pubKeyLen, &reservedBuf);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint32_t pubKeyUsedLen = 0;
ret = SAL_CRYPT_EncodeEcdhPubKey(kxCtx->key, reservedBuf, pubKeyLen, &pubKeyUsedLen);
if (ret != HITLS_SUCCESS || pubKeyLen != pubKeyUsedLen) {
BSL_ERR_PUSH_ERROR(HITLS_CRYPT_ERR_ENCODE_ECDH_KEY);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15675, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode ecdh key fail.", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_ENCODE_ECDH_KEY;
}
(void)PackSkipBytes(pkt, pubKeyUsedLen);
PackCloseUint8Field(pkt, pubKeyLenPosition);
return HITLS_SUCCESS;
}
static int32_t PackClientKxMsgEcdhe(const TLS_Ctx *ctx, PackPacket *pkt)
{
HITLS_ECCurveType type = ctx->hsCtx->kxCtx->keyExchParam.ecdh.curveParams.type;
switch (type) {
case HITLS_EC_CURVE_TYPE_NAMED_CURVE:
return PackClientKxMsgNamedCurve(ctx, pkt);
default:
break;
}
BSL_ERR_PUSH_ERROR(HITLS_PACK_UNSUPPORT_KX_CURVE_TYPE);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15676, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"unsupport key exchange curve type.", 0, 0, 0, 0);
return HITLS_PACK_UNSUPPORT_KX_CURVE_TYPE;
}
#endif /* HITLS_TLS_SUITE_KX_ECDHE */
#ifdef HITLS_TLS_SUITE_KX_DHE
static int32_t PackClientKxMsgDhe(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
DhParam *dh = &ctx->hsCtx->kxCtx->keyExchParam.dh;
KeyExchCtx *kxCtx = ctx->hsCtx->kxCtx;
uint32_t pubkeyLen = dh->plen;
if (pubkeyLen == 0u) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_INVALID_KX_PUBKEY_LENGTH);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15677, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"invalid key exchange pubKey length.", 0, 0, 0, 0);
return HITLS_PACK_INVALID_KX_PUBKEY_LENGTH;
}
uint32_t pubKeyLenPosition = 0u;
ret = PackStartLengthField(pkt, sizeof(uint16_t), &pubKeyLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint8_t *reservedBuf = NULL;
ret = PackReserveBytes(pkt, pubkeyLen, &reservedBuf);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* fill pubkey */
ret = SAL_CRYPT_EncodeDhPubKey(kxCtx->key, reservedBuf, pubkeyLen, &pubkeyLen);
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_CRYPT_ERR_ENCODE_DH_KEY);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15679, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode dh pub key fail.", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_ENCODE_DH_KEY;
}
ret = PackSkipBytes(pkt, pubkeyLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
PackCloseUint16Field(pkt, pubKeyLenPosition);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_SUITE_KX_DHE */
#ifdef HITLS_TLS_SUITE_KX_RSA
int32_t PackClientKxMsgRsa(TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
HS_Ctx *hsCtx = ctx->hsCtx;
KeyExchCtx *kxCtx = hsCtx->kxCtx;
uint8_t *preMasterSecret = kxCtx->keyExchParam.rsa.preMasterSecret;
uint32_t encLenPosition = 0u;
ret = PackStartLengthField(pkt, sizeof(uint16_t), &encLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
HITLS_Config *config = &ctx->config.tlsConfig;
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
HITLS_CERT_X509 *cert = SAL_CERT_PairGetX509(hsCtx->peerCert);
HITLS_CERT_Key *pubkey = NULL;
ret = SAL_CERT_X509Ctrl(config, cert, CERT_CTRL_GET_PUB_KEY, NULL, (void *)&pubkey);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16929, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CERT_CTRL_GET_PUB_KEY fail", 0, 0, 0, 0);
return ret;
}
/* Use CERT_KEY_CTRL_GET_SIGN_LEN to get encrypt length(Only by RSA and ECC) */
uint32_t encryptLen = MAX_SIGN_SIZE;
uint8_t *encBuf = NULL;
ret = PackReserveBytes(pkt, encryptLen, &encBuf);
if (ret != HITLS_SUCCESS) {
SAL_CERT_KeyFree(mgrCtx, pubkey);
return ret;
}
uint32_t encLen = encryptLen;
ret = SAL_CERT_KeyEncrypt(ctx, pubkey, preMasterSecret, MASTER_SECRET_LEN, encBuf, &encLen);
SAL_CERT_KeyFree(mgrCtx, pubkey);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16930, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"KeyEncrypt fail", 0, 0, 0, 0);
return ret;
}
ret = PackSkipBytes(pkt, encLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
PackCloseUint16Field(pkt, encLenPosition);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_SUITE_KX_RSA */
#ifdef HITLS_TLS_PROTO_TLCP11
static int32_t PackClientKxMsgEcc(TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
HS_Ctx *hsCtx = ctx->hsCtx;
KeyExchCtx *kxCtx = hsCtx->kxCtx;
uint8_t *preMasterSecret = kxCtx->keyExchParam.ecc.preMasterSecret;
uint32_t encLenPosition = 0u;
ret = PackStartLengthField(pkt, sizeof(uint16_t), &encLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Encrypt the PreMasterSecret using the public key of the server certificate */
HITLS_Config *config = &ctx->config.tlsConfig;
CERT_MgrCtx *certMgrCtx = config->certMgrCtx;
HITLS_CERT_X509 *certEnc = SAL_CERT_GetTlcpEncCert(hsCtx->peerCert);
HITLS_CERT_Key *pubkey = NULL;
ret = SAL_CERT_X509Ctrl(config, certEnc, CERT_CTRL_GET_PUB_KEY, NULL, (void *)&pubkey);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16218, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"get encrypt cert public key failed.", 0, 0, 0, 0);
return ret;
}
/* Use CERT_KEY_CTRL_GET_SIGN_LEN to get encrypt length(Only by RSA and ECC) */
uint32_t encryptLen = MAX_SIGN_SIZE;
uint8_t *encBuf = NULL;
ret = PackReserveBytes(pkt, encryptLen, &encBuf);
if (ret != HITLS_SUCCESS) {
SAL_CERT_KeyFree(certMgrCtx, pubkey);
return ret;
}
uint32_t encLen = encryptLen;
ret = SAL_CERT_KeyEncrypt(ctx, pubkey, preMasterSecret, MASTER_SECRET_LEN, encBuf, &encLen);
SAL_CERT_KeyFree(certMgrCtx, pubkey);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16932, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"KeyEncrypt fail", 0, 0, 0, 0);
return ret;
}
ret = PackSkipBytes(pkt, encLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
PackCloseUint16Field(pkt, encLenPosition);
return HITLS_SUCCESS;
}
#endif
#ifdef HITLS_TLS_FEATURE_PSK
static int32_t PackClientKxMsgIdentity(const TLS_Ctx *ctx, PackPacket *pkt)
{
uint8_t *pskIdentity = ctx->hsCtx->kxCtx->pskInfo->identity;
uint32_t pskIdentitySize = ctx->hsCtx->kxCtx->pskInfo->identityLen;
/* append identity */
int32_t ret = PackAppendUint16ToBuf(pkt, (uint16_t)pskIdentitySize);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (pskIdentitySize > 0) {
ret = PackAppendDataToBuf(pkt, pskIdentity, pskIdentitySize);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_PSK */
// Pack the ClientKeyExchange message.
int32_t PackClientKeyExchange(TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
#ifdef HITLS_TLS_FEATURE_PSK
/* PSK negotiation pre act: append identity */
if (IsPskNegotiation(ctx)) {
ret = PackClientKxMsgIdentity(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif /* HITLS_TLS_FEATURE_PSK */
/* Pack the key exchange message */
switch (ctx->negotiatedInfo.cipherSuiteInfo.kxAlg) {
#ifdef HITLS_TLS_SUITE_KX_ECDHE
case HITLS_KEY_EXCH_ECDHE: /* TLCP is also included */
case HITLS_KEY_EXCH_ECDHE_PSK:
ret = PackClientKxMsgEcdhe(ctx, pkt);
break;
#endif /* HITLS_TLS_SUITE_KX_ECDHE */
#ifdef HITLS_TLS_SUITE_KX_DHE
case HITLS_KEY_EXCH_DHE:
case HITLS_KEY_EXCH_DHE_PSK:
ret = PackClientKxMsgDhe(ctx, pkt);
break;
#endif /* HITLS_TLS_SUITE_KX_DHE */
#ifdef HITLS_TLS_SUITE_KX_RSA
case HITLS_KEY_EXCH_RSA:
case HITLS_KEY_EXCH_RSA_PSK:
ret = PackClientKxMsgRsa(ctx, pkt);
break;
#endif /* HITLS_TLS_SUITE_KX_RSA */
#ifdef HITLS_TLS_PROTO_TLCP11
case HITLS_KEY_EXCH_ECC:
ret = PackClientKxMsgEcc(ctx, pkt);
break;
#endif
case HITLS_KEY_EXCH_PSK:
ret = HITLS_SUCCESS;
break;
default:
BSL_ERR_PUSH_ERROR(HITLS_PACK_UNSUPPORT_KX_ALG);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15681, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"unsupport key exchange algorithm when pack client key exchange.", 0, 0, 0, 0);
return HITLS_PACK_UNSUPPORT_KX_ALG;
}
return ret;
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#endif /* HITLS_TLS_HOST_CLIENT */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_client_key_exchange.c | C | unknown | 11,712 |
/*
* 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.
*/
#include <stdint.h>
#include "hitls_build.h"
#include "securec.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "hs_msg.h"
#include "hs_ctx.h"
#include "hitls_cert_type.h"
#include "bsl_list.h"
#include "pack_common.h"
#define BUFFER_GROW_FACTOR 2u
#ifdef HITLS_TLS_PROTO_DTLS12
/**
* @brief Pack the packet header.
*
* @param type [IN] message type
* @param sequence [IN] Sequence number (dedicated for DTLS)
* @param length [IN] message body length
* @param buf [OUT] message header
*/
void PackDtlsMsgHeader(HS_MsgType type, uint16_t sequence, uint32_t length, uint8_t *buf)
{
buf[0] = (uint8_t)type & 0xffu; /** Type of the handshake message */
BSL_Uint24ToByte(length, &buf[DTLS_HS_MSGLEN_ADDR]); /** Fills the length of the handshake message */
BSL_Uint16ToByte(
sequence, &buf[DTLS_HS_MSGSEQ_ADDR]); /** The 2 bytes starting from the 4th byte are the sn of the message */
BSL_Uint24ToByte(
0, &buf[DTLS_HS_FRAGMENT_OFFSET_ADDR]); /** The 3 bytes starting from the 6th byte are the fragment offset. */
BSL_Uint24ToByte(
length, &buf[DTLS_HS_FRAGMENT_LEN_ADDR]); /** The 3 bytes starting from the 9th byte are the fragment length. */
}
#endif /* HITLS_TLS_PROTO_DTLS12 */
#if defined(HITLS_TLS_FEATURE_SESSION_ID) || defined(HITLS_TLS_PROTO_TLS13)
/**
* @brief Pack the message session ID.
*
* @param id [IN] Session ID
* @param idSize [IN] Session ID length
* @param buf [OUT] message buffer
* @param bufLen [IN] Maximum message length
* @param usedLen [OUT] Length of the packed message
*
* @retval HITLS_SUCCESS Assembly succeeded.
* @retval HITLS_PACK_SESSIONID_ERR Failed to pack the sessionId.
* @retval HITLS_MEMCPY_FAIL Memory Copy Failure
*/
int32_t PackSessionId(PackPacket *pkt, const uint8_t *id, uint32_t idSize)
{
/* If the sessionId length does not meet the requirement, an error code is returned */
if ((idSize != 0) && ((idSize > TLS_HS_MAX_SESSION_ID_SIZE) || (idSize < TLS_HS_MIN_SESSION_ID_SIZE))) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_SESSIONID_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15849, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"session id size is incorrect when pace session id.", 0, 0, 0, 0);
return HITLS_PACK_SESSIONID_ERR;
}
int32_t ret = PackAppendUint8ToBuf(pkt, (uint8_t)idSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* If the value of sessionId is 0, a success message is returned */
if (idSize == 0u) {
return HITLS_SUCCESS;
}
return PackAppendDataToBuf(pkt, id, idSize);
}
#endif /* #if HITLS_TLS_FEATURE_SESSION_ID || HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES
int32_t PackTrustedCAList(HITLS_TrustedCAList *caList, PackPacket *pkt)
{
if (caList == NULL) {
return HITLS_NULL_INPUT;
}
int32_t ret = HITLS_SUCCESS;
HITLS_TrustedCANode *node = (HITLS_TrustedCANode *)BSL_LIST_GET_FIRST(caList);
while (node != NULL) {
if (node->data != NULL && node->dataSize != 0) {
ret = PackAppendUint16ToBuf(pkt, (uint16_t)node->dataSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackAppendDataToBuf(pkt, node->data, node->dataSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
node = (HITLS_TrustedCANode *)BSL_LIST_GET_NEXT(caList);
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES */
static int32_t PackMsBufferGrow(PackPacket *pkt, uint32_t newSize)
{
uint32_t oldDataSize = *pkt->bufLen;
uint8_t *newAddr = BSL_SAL_Realloc(*pkt->buf, newSize, oldDataSize);
if (newAddr == NULL) {
return HITLS_MEMALLOC_FAIL;
}
*pkt->buf = newAddr;
*pkt->bufLen = newSize;
return HITLS_SUCCESS;
}
static int32_t PackMsBufferPrepare(PackPacket *pkt, uint32_t msgSize)
{
if (*pkt->bufLen - *pkt->bufOffset >= msgSize) {
return HITLS_SUCCESS;
}
if (HITLS_HS_BUFFER_SIZE_LIMIT - *pkt->bufOffset < msgSize) {
return HITLS_PACK_NOT_ENOUGH_BUF_LENGTH;
}
uint32_t oldBufSize = *pkt->bufLen;
uint32_t newBufSize = (msgSize > oldBufSize) ? msgSize : oldBufSize;
if (newBufSize >= HITLS_HS_BUFFER_SIZE_LIMIT / BUFFER_GROW_FACTOR) {
newBufSize = HITLS_HS_BUFFER_SIZE_LIMIT;
} else {
newBufSize = newBufSize * BUFFER_GROW_FACTOR;
}
return PackMsBufferGrow(pkt, newBufSize);
}
int32_t PackAppendUint8ToBuf(PackPacket *pkt, uint8_t value)
{
int32_t ret = PackMsBufferPrepare(pkt, sizeof(uint8_t));
if (ret != HITLS_SUCCESS) {
return ret;
}
(*pkt->buf)[*pkt->bufOffset] = value;
*pkt->bufOffset += sizeof(uint8_t);
return HITLS_SUCCESS;
}
int32_t PackAppendUint16ToBuf(PackPacket *pkt, uint16_t value)
{
int32_t ret = PackMsBufferPrepare(pkt, sizeof(uint16_t));
if (ret != HITLS_SUCCESS) {
return ret;
}
BSL_Uint16ToByte(value, &(*pkt->buf)[*pkt->bufOffset]);
*pkt->bufOffset += sizeof(uint16_t);
return HITLS_SUCCESS;
}
int32_t PackAppendUint24ToBuf(PackPacket *pkt, uint32_t value)
{
int32_t ret = PackMsBufferPrepare(pkt, UINT24_SIZE);
if (ret != HITLS_SUCCESS) {
return ret;
}
BSL_Uint24ToByte(value, &(*pkt->buf)[*pkt->bufOffset]);
*pkt->bufOffset += UINT24_SIZE;
return HITLS_SUCCESS;
}
int32_t PackAppendUint32ToBuf(PackPacket *pkt, uint32_t value)
{
int32_t ret = PackMsBufferPrepare(pkt, sizeof(uint32_t));
if (ret != HITLS_SUCCESS) {
return ret;
}
BSL_Uint32ToByte(value, &(*pkt->buf)[*pkt->bufOffset]);
*pkt->bufOffset += sizeof(uint32_t);
return HITLS_SUCCESS;
}
int32_t PackAppendUint64ToBuf(PackPacket *pkt, uint64_t value)
{
int32_t ret = PackMsBufferPrepare(pkt, sizeof(uint64_t));
if (ret != HITLS_SUCCESS) {
return ret;
}
BSL_Uint64ToByte(value, &(*pkt->buf)[*pkt->bufOffset]);
*pkt->bufOffset += sizeof(uint64_t);
return HITLS_SUCCESS;
}
int32_t PackAppendDataToBuf(PackPacket *pkt, const uint8_t *data, uint32_t size)
{
int32_t ret = PackMsBufferPrepare(pkt, size);
if (ret != HITLS_SUCCESS) {
return ret;
}
(void)memcpy_s(&(*pkt->buf)[*pkt->bufOffset], *pkt->bufLen - *pkt->bufOffset, data, size);
*pkt->bufOffset += size;
return HITLS_SUCCESS;
}
int32_t PackReserveBytes(PackPacket *pkt, uint32_t size, uint8_t **buf)
{
int32_t ret = PackMsBufferPrepare(pkt, size);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (buf != NULL) {
*buf = &(*pkt->buf)[*pkt->bufOffset];
}
return HITLS_SUCCESS;
}
int32_t PackStartLengthField(PackPacket *pkt, uint32_t size, uint32_t *allocatedPosition)
{
int32_t ret = PackMsBufferPrepare(pkt, size);
if (ret != HITLS_SUCCESS) {
return ret;
}
*allocatedPosition = *pkt->bufOffset;
*pkt->bufOffset += size;
return HITLS_SUCCESS;
}
int32_t PackSkipBytes(PackPacket *pkt, uint32_t size)
{
if (*pkt->bufLen - *pkt->bufOffset < size) {
return HITLS_PACK_NOT_ENOUGH_BUF_LENGTH;
}
*pkt->bufOffset += size;
return HITLS_SUCCESS;
}
void PackCloseUint8Field(PackPacket *pkt, uint32_t position)
{
(*pkt->buf)[position] = (uint8_t)(*pkt->bufOffset - position - sizeof(uint8_t));
return;
}
void PackCloseUint16Field(PackPacket *pkt, uint32_t position)
{
BSL_Uint16ToByte((uint16_t)(*pkt->bufOffset - position - sizeof(uint16_t)), &(*pkt->buf)[position]);
return;
}
void PackCloseUint24Field(PackPacket *pkt, uint32_t position)
{
BSL_Uint24ToByte((uint32_t)(*pkt->bufOffset - position - UINT24_SIZE), &(*pkt->buf)[position]);
return;
}
int32_t PackGetSubBuffer(PackPacket *pkt, uint32_t start, uint32_t *length, uint8_t **buf)
{
if (length == NULL) {
return HITLS_NULL_INPUT;
}
if (start > *pkt->bufOffset) {
return HITLS_PACK_NOT_ENOUGH_BUF_LENGTH;
}
*length = *pkt->bufOffset - start;
if (buf != NULL) {
*buf = &(*pkt->buf)[start];
}
return HITLS_SUCCESS;
} | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_common.c | C | unknown | 8,785 |
/*
* 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 PACK_COMMON_H
#define PACK_COMMON_H
#include <stdint.h>
#include "tls.h"
#include "pack.h"
#include "hs_msg.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Pack session ID
*
* @param pkt [IN/OUT] Context for packing
* @param id [IN] Session ID
* @param idSize [IN] Session ID length
*
* @retval HITLS_SUCCESS
* @retval HITLS_PACK_SESSIONID_ERR Failed to pack sessionId
* @retval HITLS_MEMALLOC_FAIL Grow buffer failed
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH Buffer is not enough
*/
int32_t PackSessionId(PackPacket *pkt, const uint8_t *id, uint32_t idSize);
/**
* @brief Pack DTLS message header
*
* @param type [IN] Message type
* @param sequence [IN] Sequence number (only in DTLS)
* @param length [IN] Length of message body
* @param buf [OUT] Message header
*/
void PackDtlsMsgHeader(HS_MsgType type, uint16_t sequence, uint32_t length, uint8_t *buf);
int32_t PackTrustedCAList(HITLS_TrustedCAList *caList, PackPacket *pkt);
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end PACK_COMMON_H */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_common.h | C | unknown | 1,617 |
/*
* 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.
*/
#include "hitls_build.h"
#if defined(HITLS_TLS_PROTO_TLS13) && defined(HITLS_TLS_HOST_SERVER)
#include <stdint.h>
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "tls.h"
#include "hs_ctx.h"
#include "hs_extensions.h"
#include "pack_common.h"
#include "pack_extensions.h"
#include "custom_extensions.h"
static int32_t PackEncryptedSupportedGroups(const TLS_Ctx *ctx, PackPacket *pkt)
{
const TLS_Config *config = &(ctx->config.tlsConfig);
if (config->groupsSize == 0 || config->groups == NULL) {
return HITLS_SUCCESS;
}
/* Calculate the extension length */
uint16_t exMsgHeaderLen = sizeof(uint16_t);
uint16_t exMsgDataLen = sizeof(uint16_t) * (uint16_t)config->groupsSize;
/* Pack the extension header */
int32_t ret = PackExtensionHeader(HS_EX_TYPE_SUPPORTED_GROUPS, exMsgHeaderLen + exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack the extended support group */
(void)PackAppendUint16ToBuf(pkt, exMsgDataLen);
for (uint32_t index = 0; index < config->groupsSize; index++) {
(void)PackAppendUint16ToBuf(pkt, config->groups[index]);
}
return HITLS_SUCCESS;
}
/**
* @brief Pack the Encrypted_extensions extension.
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS succeeded.
* @retval For other error codes, see hitls_error.h.
*/
static int32_t PackEncryptedExs(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint32_t listSize;
const PackExtInfo extMsgList[] = {
{.exMsgType = HS_EX_TYPE_SUPPORTED_GROUPS,
.needPack = true,
.packFunc = PackEncryptedSupportedGroups},
{.exMsgType = HS_EX_TYPE_EARLY_DATA, /* This field is available only in 0-rrt mode */
.needPack = false,
.packFunc = NULL},
#ifdef HITLS_TLS_FEATURE_SNI
{.exMsgType = HS_EX_TYPE_SERVER_NAME, /* During extension, only empty SNI extensions are encapsulated. */
.needPack = ctx->negotiatedInfo.isSniStateOK,
.packFunc = NULL},
#endif /* HITLS_TLS_FEATURE_SNI */
#ifdef HITLS_TLS_FEATURE_ALPN
{.exMsgType = HS_EX_TYPE_APP_LAYER_PROTOCOLS,
.needPack = (ctx->negotiatedInfo.alpnSelected != NULL),
.packFunc = PackServerSelectAlpnProto},
#endif /* HITLS_TLS_FEATURE_ALPN */
};
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
if (IsPackNeedCustomExtensions(CUSTOM_EXT_FROM_CTX(ctx), HITLS_EX_TYPE_ENCRYPTED_EXTENSIONS)) {
ret = PackCustomExtensions(ctx, pkt, HITLS_EX_TYPE_ENCRYPTED_EXTENSIONS, NULL, 0);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
/* Calculate the number of extended types */
listSize = sizeof(extMsgList) / sizeof(extMsgList[0]);
/* Pack the Server Hello extension */
for (uint32_t index = 0; index < listSize; index++) {
if (extMsgList[index].needPack == false) {
continue;
}
/* Empty extension */
if (extMsgList[index].packFunc == NULL) {
ret = PackEmptyExtension(extMsgList[index].exMsgType, extMsgList[index].needPack, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
/* Non-empty extension */
if (extMsgList[index].packFunc != NULL) {
ret = extMsgList[index].packFunc(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
}
return HITLS_SUCCESS;
}
/**
* @brief Pack the Encrypted_extensions message.
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH The message buffer length is insufficient.
*/
int32_t PackEncryptedExtensions(const TLS_Ctx *ctx, PackPacket *pkt)
{
uint32_t extensionsLenPosition = 0u;
/* Start packing extensions length field */
int32_t ret = PackStartLengthField(pkt, sizeof(uint16_t), &extensionsLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack the encrypted_extensions extension */
ret = PackEncryptedExs(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Close extensions length field */
PackCloseUint16Field(pkt, extensionsLenPosition);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS13 && HITLS_TLS_HOST_SERVER */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_encrypted_extensions.c | C | unknown | 5,100 |
/*
* 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.
*/
#include <stdint.h>
#include <stdbool.h>
#include "hitls_build.h"
#include "securec.h"
#include "cipher_suite.h"
#include "bsl_err_internal.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_bytes.h"
#include "bsl_list.h"
#include "hitls_error.h"
#include "hitls_sni.h"
#include "hitls_cert_type.h"
#include "hitls_crypt_type.h"
#include "hitls_session.h"
#include "tls.h"
#include "hs_ctx.h"
#include "hs_extensions.h"
#include "hs.h"
#include "hs_msg.h"
#include "hs_common.h"
#include "session.h"
#include "hs_verify.h"
#include "pack_common.h"
#include "custom_extensions.h"
#include "pack_extensions.h"
#include "config_type.h"
#define EXTENSION_MSG(exMsgT, needP, packF) \
.exMsgType = (exMsgT), \
.needPack = (needP), \
.packFunc = (packF), \
// Pack the extension header.
int32_t PackExtensionHeader(uint16_t exMsgType, uint16_t exMsgLen, PackPacket *pkt)
{
int32_t ret = PackAppendUint16ToBuf(pkt, exMsgType);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackAppendUint16ToBuf(pkt, exMsgLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackReserveBytes(pkt, exMsgLen, NULL);
if (ret != HITLS_SUCCESS) {
return ret;
}
return HITLS_SUCCESS;
}
static int32_t PackExtensions(const TLS_Ctx *ctx, PackPacket *pkt, PackExtInfo *extMsgList, uint32_t listSize)
{
int32_t ret = HITLS_SUCCESS;
for (uint32_t index = 0; index < listSize; index++) {
if (extMsgList[index].needPack == false) {
continue;
}
/* Empty expansion */
if (extMsgList[index].packFunc == NULL) {
ret = PackEmptyExtension(extMsgList[index].exMsgType, extMsgList[index].needPack, pkt);
} else { /* Non-empty expansion */
ret = extMsgList[index].packFunc(ctx, pkt);
}
if (ret != HITLS_SUCCESS) {
return ret;
}
}
return HITLS_SUCCESS;
}
static int32_t PackExtensionEnd(PackPacket *pkt, uint32_t extensionLenPosition)
{
uint32_t extensionLength = 0;
int32_t ret = PackGetSubBuffer(pkt, extensionLenPosition, &extensionLength, NULL);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Update the packet length */
if (extensionLength != sizeof(uint16_t)) {
PackCloseUint16Field(pkt, extensionLenPosition);
} else {
*pkt->bufOffset -= sizeof(uint16_t);
}
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_PROTO_TLS13
static bool IsNeedPreSharedKey(const TLS_Ctx *ctx)
{
if (ctx->config.tlsConfig.maxVersion != HITLS_VERSION_TLS13) {
return false;
}
if (ctx->hsCtx->state == TRY_SEND_HELLO_RETRY_REQUEST) {
/* hello retry request does not contain the psk */
return false;
}
return true;
}
bool Tls13NeedPack(const TLS_Ctx *ctx, uint32_t version)
{
bool tls13NeedPack = false;
if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
tls13NeedPack = false;
} else {
tls13NeedPack = (version >= HITLS_VERSION_TLS13) ? true : false;
}
return tls13NeedPack;
}
static int32_t PackCookie(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint32_t exMsgDataLen = 0u;
if (ctx->negotiatedInfo.cookie == NULL) {
return HITLS_SUCCESS;
}
/* Calculate the extension length */
exMsgDataLen = sizeof(uint16_t) + (ctx->negotiatedInfo.cookieSize);
uint32_t cookieLen = ctx->negotiatedInfo.cookieSize;
ret = PackExtensionHeader(HS_EX_TYPE_COOKIE, exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
(void)PackAppendUint16ToBuf(pkt, cookieLen);
/* Pack the cookie */
(void)PackAppendDataToBuf(pkt, ctx->negotiatedInfo.cookie, cookieLen);
ctx->hsCtx->extFlag.haveCookie = true;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS13 */
static int32_t PackPointFormats(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint16_t exMsgHeaderLen = 0u;
uint8_t exMsgDataLen = 0u;
const TLS_Config *config = &(ctx->config.tlsConfig);
if (config->pointFormatsSize == 0) {
return HITLS_SUCCESS;
}
if (config->pointFormats == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15415, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack point formats extension error, invalid input parameter.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
/* Calculate the extension length */
exMsgHeaderLen = sizeof(uint8_t);
exMsgDataLen = (uint8_t)config->pointFormatsSize;
ret = PackExtensionHeader(HS_EX_TYPE_POINT_FORMATS, exMsgHeaderLen + exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack the extension point format */
(void)PackAppendUint8ToBuf(pkt, exMsgDataLen);
for (uint32_t index = 0; index < config->pointFormatsSize; index++) {
(void)PackAppendUint8ToBuf(pkt, config->pointFormats[index]);
}
/* Set the extension flag */
ctx->hsCtx->extFlag.havePointFormats = true;
return HITLS_SUCCESS;
}
int32_t PackEmptyExtension(uint16_t exMsgType, bool needPack, PackPacket *pkt)
{
if (needPack) {
int32_t ret = PackExtensionHeader(exMsgType, 0u, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_HOST_CLIENT
#ifdef HITLS_TLS_FEATURE_SNI
static int32_t PackServerName(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint16_t exMsgDataLen = 0u;
uint8_t *hostName = NULL;
uint8_t *serverName = NULL;
uint32_t hostNameSize, serverNameSize = 0u;
const TLS_Config *config = &(ctx->config.tlsConfig);
bool isNotTls13 = (config->maxVersion < HITLS_VERSION_TLS13 || config->maxVersion == HITLS_VERSION_DTLS12);
(void)isNotTls13;
(void)hostNameSize;
(void)hostName;
#ifdef HITLS_TLS_FEATURE_SESSION
/* When a session whose protocol version is earlier than HITLS_VERSION_TLS13 is resumed, the servername extension
* field is the hostname in the session */
if (isNotTls13 && ctx->session != NULL) {
/* Obtain the hostname in the session */
SESS_GetHostName(ctx->session, &hostNameSize, &hostName);
serverName = hostName;
} else
#endif
{
/* Obtain the servername in the config */
serverName = config->serverName;
}
if (serverName == NULL) {
return HITLS_SUCCESS;
}
serverNameSize = (uint32_t)strlen((char *)serverName);
/* Calculate the extension length */
/* server Name list Length + server Name Type + Server Name Length + Server Name */
exMsgDataLen = sizeof(uint16_t) + sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint8_t) * serverNameSize;
ret = PackExtensionHeader(HS_EX_TYPE_SERVER_NAME, exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack the extension Server Name Indication extension */
/* server Name list Length */
(void)PackAppendUint16ToBuf(pkt, exMsgDataLen - sizeof(uint16_t));
/* server Name Type */
(void)PackAppendUint8ToBuf(pkt, HITLS_SNI_HOSTNAME_TYPE);
/* Server Name Length */
(void)PackAppendUint16ToBuf(pkt, (uint16_t)serverNameSize);
/* Server Name */
(void)PackAppendDataToBuf(pkt, serverName, serverNameSize);
/* Set the extension flag */
ctx->hsCtx->extFlag.haveServerName = true;
return HITLS_SUCCESS;
}
static bool IsNeedClientPackServerName(const TLS_Ctx *ctx)
{
const TLS_Config *config = &(ctx->config.tlsConfig);
/* not in session resumption */
if (ctx->session == NULL) {
if (config->serverName == NULL) {
return false;
}
}
/* The session is being resumed */
if (ctx->session != NULL) {
if (config->maxVersion == HITLS_VERSION_TLS13 && config->serverName == NULL) {
return false;
}
}
return true;
}
#endif /* HITLS_TLS_FEATURE_SNI */
static int32_t PackClientSignatureAlgorithms(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint16_t exMsgHeaderLen = 0u;
uint16_t exMsgDataLen = 0u;
const TLS_Config *config = &(ctx->config.tlsConfig);
if (config->signAlgorithmsSize == 0) {
return HITLS_SUCCESS;
}
if (config->signAlgorithms == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15413, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack signature algirithms extension error, invalid input parameter.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
uint32_t signAlgorithmsSize = 0;
uint16_t *signAlgorithms = CheckSupportSignAlgorithms(ctx, config->signAlgorithms,
config->signAlgorithmsSize, &signAlgorithmsSize);
if (signAlgorithms == NULL || signAlgorithmsSize == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17309, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"no available signAlgorithms", 0, 0, 0, 0);
BSL_SAL_FREE(signAlgorithms);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return HITLS_CERT_ERR_NO_SIGN_SCHEME_MATCH;
}
/* Calculate the extension length */
exMsgHeaderLen = sizeof(uint16_t);
exMsgDataLen = sizeof(uint16_t) * (uint16_t)signAlgorithmsSize;
/* Pack the extension header */
ret = PackExtensionHeader(HS_EX_TYPE_SIGNATURE_ALGORITHMS, exMsgHeaderLen + exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(signAlgorithms);
return ret;
}
/* Pack the extended signature algorithm. */
(void)PackAppendUint16ToBuf(pkt, exMsgDataLen);
for (uint32_t index = 0; index < signAlgorithmsSize; index++) {
(void)PackAppendUint16ToBuf(pkt, signAlgorithms[index]);
}
BSL_SAL_FREE(signAlgorithms);
/* Set the extension flag */
ctx->hsCtx->extFlag.haveSignatureAlgorithms = true;
return HITLS_SUCCESS;
}
static int32_t PackClientSupportedGroups(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint16_t exMsgHeaderLen = 0u;
uint16_t exMsgDataLen = 0u;
const TLS_Config *config = &(ctx->config.tlsConfig);
if (config->groupsSize == 0) {
return HITLS_SUCCESS;
}
if (config->groups == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15414, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack supported groups extension error, invalid input parameter.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
/* Calculate the extension length */
exMsgHeaderLen = sizeof(uint16_t);
exMsgDataLen = sizeof(uint16_t) * (uint16_t)config->groupsSize;
ret = PackExtensionHeader(HS_EX_TYPE_SUPPORTED_GROUPS, exMsgHeaderLen + exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack extended supported groups */
(void)PackAppendUint16ToBuf(pkt, exMsgDataLen);
for (uint32_t index = 0; index < config->groupsSize; index++) {
(void)PackAppendUint16ToBuf(pkt, config->groups[index]);
}
/* Set the extension flag */
ctx->hsCtx->extFlag.haveSupportedGroups = true;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_ALPN
static int32_t PackClientAlpnList(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint16_t exMsgHeaderLen = 0u;
uint8_t exMsgDataLen = 0u;
const TLS_Config *config = &(ctx->config.tlsConfig);
if (config->alpnListSize == 0) {
return HITLS_SUCCESS;
}
if (config->alpnList == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15416, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack alpn list extension error, invalid input parameter.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
/* Calculate the extension length */
exMsgHeaderLen = sizeof(uint16_t);
exMsgDataLen = (uint8_t)config->alpnListSize;
ret = PackExtensionHeader(HS_EX_TYPE_APP_LAYER_PROTOCOLS, exMsgHeaderLen + exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
(void)PackAppendUint16ToBuf(pkt, exMsgDataLen);
(void)PackAppendDataToBuf(pkt, config->alpnList, config->alpnListSize);
/* Set the extension flag */
ctx->hsCtx->extFlag.haveAlpn = true;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_ALPN */
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
static int32_t PackClientTicket(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint8_t *ticket = NULL;
uint32_t ticketSize = 0;
uint16_t sessVersion = HITLS_VERSION_TLS13;
if (ctx->session != NULL) {
HITLS_SESS_GetProtocolVersion(ctx->session, &sessVersion);
}
/* Whether the ticket belongs to tls1.3 needs to be determined */
if (sessVersion != HITLS_VERSION_TLS13) {
SESS_GetTicket(ctx->session, &ticket, &ticketSize);
}
ret = PackExtensionHeader(HS_EX_TYPE_SESSION_TICKET, (uint16_t)ticketSize, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
(void)PackAppendDataToBuf(pkt, ticket, ticketSize);
/* Set the extension flag. */
ctx->hsCtx->extFlag.haveTicket = true;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_SESSION_TICKET */
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
static int32_t PackClientSecRenegoInfo(const TLS_Ctx *ctx, PackPacket *pkt)
{
if (!ctx->negotiatedInfo.isRenegotiation) {
return HITLS_SUCCESS;
}
/* Calculate the extension length */
const uint8_t *clientData = ctx->negotiatedInfo.clientVerifyData;
uint32_t clientDataSize = ctx->negotiatedInfo.clientVerifyDataSize;
uint16_t exMsgHeaderLen = sizeof(uint8_t);
uint16_t exMsgDataLen = (uint16_t)clientDataSize;
/* Pack the extension header */
int32_t ret;
ret = PackExtensionHeader(HS_EX_TYPE_RENEGOTIATION_INFO, exMsgHeaderLen + exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack the length of secRenegoInfo */
(void)PackAppendUint8ToBuf(pkt, (uint8_t)clientDataSize);
/* Pack the secRenegoInfo content */
(void)PackAppendDataToBuf(pkt, clientData, clientDataSize);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_RENEGOTIATION */
static bool IsNeedPackEcExtension(const TLS_Ctx *ctx)
{
const TLS_Config *config = &(ctx->config.tlsConfig);
#ifdef HITLS_TLS_PROTO_TLS13
if ((config->maxVersion == HITLS_VERSION_TLS13)) {
uint32_t needKeyShareMode = TLS13_KE_MODE_PSK_WITH_DHE | TLS13_CERT_AUTH_WITH_DHE;
if ((ctx->negotiatedInfo.tls13BasicKeyExMode & needKeyShareMode) != 0) {
return true;
}
}
#endif /* HITLS_TLS_PROTO_TLS13 */
for (uint32_t index = 0; index < config->cipherSuitesSize; index++) {
CipherSuiteInfo cipherInfo = {0};
/* The returned value does not need to be checked. The validity of the cipher suite is checked when the cipher
* suite is configured */
(void)CFG_GetCipherSuiteInfo(config->cipherSuites[index], &cipherInfo);
/* The ECC algorithm suite exists */
if ((cipherInfo.authAlg == HITLS_AUTH_ECDSA) ||
(cipherInfo.kxAlg == HITLS_KEY_EXCH_ECDHE) ||
(cipherInfo.kxAlg == HITLS_KEY_EXCH_ECDH) ||
(cipherInfo.kxAlg == HITLS_KEY_EXCH_ECDHE_PSK)) {
return true;
}
}
return false;
}
#ifdef HITLS_TLS_PROTO_TLS13
static int32_t PackClientSupportedVersions(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint16_t exMsgHeaderLen = 0u;
uint8_t exMsgDataLen = 0u;
const TLS_Config *config = &(ctx->config.tlsConfig);
uint16_t minVersion = config->minVersion;
uint16_t maxVersion = config->maxVersion;
if (config->minVersion < HITLS_VERSION_SSL30 || config->maxVersion > HITLS_VERSION_TLS13) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15418, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack supported version extension error, invalid input parameter.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
/* Calculate the extension length */
exMsgHeaderLen = sizeof(uint8_t);
exMsgDataLen = sizeof(uint16_t) * (maxVersion - minVersion + 1);
ret = PackExtensionHeader(HS_EX_TYPE_SUPPORTED_VERSIONS, exMsgHeaderLen + exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack the TLS version supported by the extension */
(void)PackAppendUint8ToBuf(pkt, exMsgDataLen);
for (uint16_t version = maxVersion; version >= minVersion; version--) {
(void)PackAppendUint16ToBuf(pkt, version);
}
/* Set the extension flag */
ctx->hsCtx->extFlag.haveSupportedVers = true;
return HITLS_SUCCESS;
}
static int32_t PackClientPskKeyExModes(const TLS_Ctx *ctx, PackPacket *pkt)
{
bool allowOnly = false;
bool allowDhe = false;
const uint32_t configKxMode = ctx->config.tlsConfig.keyExchMode;
uint16_t exMsgHeaderLen = sizeof(uint8_t);
uint16_t exMsgDataLen = 0;
if ((bool)(configKxMode & TLS13_KE_MODE_PSK_WITH_DHE)) {
exMsgDataLen++;
allowDhe = true;
}
if ((bool)(configKxMode & TLS13_KE_MODE_PSK_ONLY)) {
exMsgDataLen++;
allowOnly = true;
}
int32_t ret = PackExtensionHeader(HS_EX_TYPE_PSK_KEY_EXCHANGE_MODES, exMsgHeaderLen + exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack the length of the key exchange pattern extension */
(void)PackAppendUint8ToBuf(pkt, (uint8_t)exMsgDataLen);
if (allowDhe) {
(void)PackAppendUint8ToBuf(pkt, PSK_DHE_KE);
}
if (allowOnly) {
(void)PackAppendUint8ToBuf(pkt, PSK_KE);
}
ctx->hsCtx->extFlag.havePskExMode = true;
return HITLS_SUCCESS;
}
static int32_t PackClientKeyShare(const TLS_Ctx *ctx, PackPacket *pkt)
{
uint32_t needKeyShareMode = TLS13_KE_MODE_PSK_WITH_DHE | TLS13_CERT_AUTH_WITH_DHE;
if ((ctx->negotiatedInfo.tls13BasicKeyExMode & needKeyShareMode) == 0) {
return HITLS_SUCCESS;
}
KeyExchCtx *kxCtx = ctx->hsCtx->kxCtx;
if (kxCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16939, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "kxCtx is null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
uint16_t keyShareLen = 0;
KeyShareParam *keyShare = &(kxCtx->keyExchParam.share);
uint32_t secondPubKeyLen = 0u;
uint32_t pubKeyLen = SAL_CRYPT_GetCryptLength(ctx, HITLS_CRYPT_INFO_CMD_GET_PUBLIC_KEY_LEN, keyShare->group);
if (pubKeyLen == 0u) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_INVALID_KX_PUBKEY_LENGTH);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15422, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"invalid keyShare length.", 0, 0, 0, 0);
return HITLS_PACK_INVALID_KX_PUBKEY_LENGTH;
}
keyShareLen += sizeof(uint16_t) + sizeof(uint16_t) + pubKeyLen;
if (keyShare->secondGroup != HITLS_NAMED_GROUP_BUTT) {
secondPubKeyLen = SAL_CRYPT_GetCryptLength(ctx, HITLS_CRYPT_INFO_CMD_GET_PUBLIC_KEY_LEN, keyShare->secondGroup);
if (secondPubKeyLen == 0u) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_INVALID_KX_PUBKEY_LENGTH);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15422, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"invalid keyShare length.", 0, 0, 0, 0);
return HITLS_PACK_INVALID_KX_PUBKEY_LENGTH;
}
keyShareLen += sizeof(uint16_t) + sizeof(uint16_t) + secondPubKeyLen;
}
int32_t ret = PackExtensionHeader(HS_EX_TYPE_KEY_SHARE, sizeof(uint16_t) + keyShareLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack the total length of client_keyShare */
(void)PackAppendUint16ToBuf(pkt, keyShareLen);
/* Pack a group */
(void)PackAppendUint16ToBuf(pkt, (uint16_t)keyShare->group);
/* Length of the Pack KeyExChange */
(void)PackAppendUint16ToBuf(pkt, (uint16_t)pubKeyLen);
uint32_t pubKeyUsedLen = 0;
uint8_t *pubKeyBuf = NULL;
(void)PackReserveBytes(pkt, pubKeyLen, &pubKeyBuf);
/* Pack KeyExChange */
ret = SAL_CRYPT_EncodeEcdhPubKey(kxCtx->key, pubKeyBuf, pubKeyLen, &pubKeyUsedLen);
if (ret != HITLS_SUCCESS || pubKeyUsedLen != pubKeyLen) {
BSL_ERR_PUSH_ERROR(HITLS_CRYPT_ERR_ENCODE_ECDH_KEY);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15423, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode client keyShare key fail.", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_ENCODE_ECDH_KEY;
}
(void)PackSkipBytes(pkt, pubKeyUsedLen);
if (keyShare->secondGroup != HITLS_NAMED_GROUP_BUTT) {
(void)PackAppendUint16ToBuf(pkt, (uint16_t)keyShare->secondGroup);
(void)PackAppendUint16ToBuf(pkt, (uint16_t)secondPubKeyLen);
uint8_t *secondPubKeyBuf = NULL;
(void)PackReserveBytes(pkt, secondPubKeyLen, &secondPubKeyBuf);
ret = SAL_CRYPT_EncodeEcdhPubKey(kxCtx->secondKey, secondPubKeyBuf, secondPubKeyLen, &pubKeyUsedLen);
if (ret != HITLS_SUCCESS || pubKeyUsedLen != secondPubKeyLen) {
BSL_ERR_PUSH_ERROR(HITLS_CRYPT_ERR_ENCODE_ECDH_KEY);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15423, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode client keyShare key fail.", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_ENCODE_ECDH_KEY;
}
(void)PackSkipBytes(pkt, pubKeyUsedLen);
}
ctx->hsCtx->extFlag.haveKeyShare = true;
return HITLS_SUCCESS;
}
static uint32_t GetPreSharedKeyExtLen(const PskInfo13 *pskInfo)
{
uint32_t extLen = HS_EX_HEADER_LEN;
uint32_t binderLen = 0;
if (pskInfo->resumeSession != NULL) {
HITLS_HashAlgo hashAlg = HITLS_HASH_BUTT;
binderLen = HS_GetBinderLen(pskInfo->resumeSession, &hashAlg);
if (binderLen == 0) {
return 0;
}
uint8_t *ticket = NULL;
uint32_t ticketSize = 0;
SESS_GetTicket(pskInfo->resumeSession, &ticket, &ticketSize);
extLen += sizeof(uint16_t) + ticketSize + sizeof(uint32_t) + sizeof(uint8_t) + binderLen;
}
if (pskInfo->userPskSess != NULL) {
HITLS_HashAlgo hashAlg = HITLS_HASH_BUTT;
binderLen = HS_GetBinderLen(pskInfo->userPskSess->pskSession, &hashAlg);
if (binderLen == 0) {
return 0;
}
extLen += sizeof(uint16_t) + pskInfo->userPskSess->identityLen + sizeof(uint32_t) + sizeof(uint8_t) + binderLen;
}
extLen += sizeof(uint16_t) + sizeof(uint16_t);
return extLen;
}
static void PackClientPreSharedKeyIdentity(const TLS_Ctx *ctx, uint8_t *buf, uint32_t bufLen)
{
PskInfo13 *pskInfo = &ctx->hsCtx->kxCtx->pskInfo13;
uint32_t offset = 0;
uint32_t offsetStamp = offset;
offset += sizeof(uint16_t); // skip identities len
if (pskInfo->resumeSession != NULL) {
uint8_t *ticket = NULL;
uint32_t ticketSize = 0;
SESS_GetTicket(pskInfo->resumeSession, &ticket, &ticketSize);
BSL_Uint16ToByte((uint16_t)ticketSize, &buf[offset]);
offset += sizeof(uint16_t);
// has passed the verification above, and it must be successful here.
(void)memcpy_s(&buf[offset], bufLen - offset, ticket, ticketSize);
offset += ticketSize;
uint32_t ageSec = (uint32_t)((uint64_t)BSL_SAL_CurrentSysTimeGet() - SESS_GetStartTime(pskInfo->resumeSession));
uint32_t agemSec = ageSec * 1000 + (uint32_t)SESS_GetTicketAgeAdd(pskInfo->resumeSession); /* unit: ms */
BSL_Uint32ToByte(agemSec, &buf[offset]);
offset += sizeof(uint32_t);
}
if (pskInfo->userPskSess != NULL) {
BSL_Uint16ToByte((uint16_t)pskInfo->userPskSess->identityLen, &buf[offset]);
offset += sizeof(uint16_t);
(void)memcpy_s(&buf[offset], bufLen - offset,
// has passed the verification above, and it must be successful here
pskInfo->userPskSess->identity, pskInfo->userPskSess->identityLen);
offset += pskInfo->userPskSess->identityLen;
BSL_Uint32ToByte(0, &buf[offset]);
offset += sizeof(uint32_t);
}
BSL_Uint16ToByte((uint16_t)(offset - offsetStamp - sizeof(uint16_t)), &buf[offsetStamp]);
}
// ClientPreSharedKey: pskid, binder, see rfc 8446 section 4.2.11, currently support one pskid and one binder
static int32_t PackClientPreSharedKey(const TLS_Ctx *ctx, PackPacket *pkt)
{
PskInfo13 *pskInfo = &ctx->hsCtx->kxCtx->pskInfo13;
if (pskInfo->resumeSession == NULL && pskInfo->userPskSess == NULL) {
return HITLS_SUCCESS;
}
uint32_t minLen = GetPreSharedKeyExtLen(pskInfo);
if (minLen == 0) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_PRE_SHARED_KEY_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15939, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Binder size is zero when PackClientPreSharedKey", 0, 0, 0, 0);
return HITLS_PACK_PRE_SHARED_KEY_ERR;
}
int32_t ret = PackExtensionHeader(HS_EX_TYPE_PRE_SHARED_KEY, (uint16_t)(minLen - HS_EX_HEADER_LEN), pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint8_t *pskBuf = NULL;
ret = PackReserveBytes(pkt, minLen - HS_EX_HEADER_LEN, &pskBuf);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackSkipBytes(pkt, minLen - HS_EX_HEADER_LEN);
if (ret != HITLS_SUCCESS) {
return ret;
}
PackClientPreSharedKeyIdentity(ctx, pskBuf, minLen - HS_EX_HEADER_LEN);
// pack binder after fills in the packet header and extension length. call PackClientPreSharedKeyBinders
ctx->hsCtx->extFlag.havePreShareKey = true;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES
int32_t PackClientCAList(const TLS_Ctx *ctx, PackPacket *pkt)
{
const TLS_Config *config = &(ctx->config.tlsConfig);
int32_t ret = PackAppendUint16ToBuf(pkt, HS_EX_TYPE_CERTIFICATE_AUTHORITIES);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint32_t extensionLenPosition = 0u;
ret = PackStartLengthField(pkt, sizeof(uint16_t), &extensionLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint32_t caLenPosition = 0u;
ret = PackStartLengthField(pkt, sizeof(uint16_t), &caLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackTrustedCAList(config->caList, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
PackCloseUint16Field(pkt, caLenPosition);
PackCloseUint16Field(pkt, extensionLenPosition);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES */
#ifdef HITLS_TLS_FEATURE_PHA
static bool IsNeedPackPha(const TLS_Ctx *ctx)
{
const TLS_Config *tlsConfig = &ctx->config.tlsConfig;
if (tlsConfig->maxVersion != HITLS_VERSION_TLS13) {
return false;
}
return tlsConfig->isSupportPostHandshakeAuth;
}
#endif /* HITLS_TLS_FEATURE_PHA */
#endif /* HITLS_TLS_PROTO_TLS13 */
static bool IsNeedEms(const TLS_Ctx *ctx)
{
if (ctx->config.tlsConfig.maxVersion == HITLS_VERSION_TLCP_DTLCP11) {
return false;
}
return true;
}
// Pack the non-null extension of client hello.
static int32_t PackClientExtensions(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
const TLS_Config *tlsConfig = &ctx->config.tlsConfig;
(void)tlsConfig;
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
const TLS_NegotiatedInfo *negoInfo = &ctx->negotiatedInfo;
#endif /* HITLS_TLS_FEATURE_RENEGOTIATION */
#ifdef HITLS_TLS_PROTO_TLS13
bool isTls13 = (tlsConfig->maxVersion == HITLS_VERSION_TLS13);
#endif /* HITLS_TLS_PROTO_TLS13 */
/* Check whether EC extensions need to be filled */
bool isEcNeed = IsNeedPackEcExtension(ctx);
/* If the version is earlier than tls1.2, the signature extension cannot be sent */
bool isSignAlgNeed = (ctx->config.tlsConfig.maxVersion >= HITLS_VERSION_TLS12);
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
/* Do not send the sessionticket in the PTO scenario */
bool isSessionTicketNeed = IsTicketSupport(ctx);
#endif /* HITLS_TLS_FEATURE_SESSION_TICKET */
#ifdef HITLS_TLS_FEATURE_PHA
bool isNeedPha = IsNeedPackPha(ctx);
#endif /* HITLS_TLS_FEATURE_PHA */
PackExtInfo extMsgList[] = {
#ifdef HITLS_TLS_FEATURE_SNI
{ EXTENSION_MSG(HS_EX_TYPE_SERVER_NAME, IsNeedClientPackServerName(ctx), PackServerName) },
#endif /* HITLS_TLS_FEATURE_SNI */
{ EXTENSION_MSG(HS_EX_TYPE_SIGNATURE_ALGORITHMS, isSignAlgNeed, PackClientSignatureAlgorithms) },
{ EXTENSION_MSG(HS_EX_TYPE_SUPPORTED_GROUPS, isEcNeed, PackClientSupportedGroups) },
{ EXTENSION_MSG(HS_EX_TYPE_POINT_FORMATS, isEcNeed, PackPointFormats) },
#ifdef HITLS_TLS_PROTO_TLS13
{ EXTENSION_MSG(HS_EX_TYPE_SUPPORTED_VERSIONS, isTls13, PackClientSupportedVersions) },
#endif /* HITLS_TLS_PROTO_TLS13 */
{ EXTENSION_MSG(HS_EX_TYPE_EARLY_DATA, false, NULL) },
#ifdef HITLS_TLS_PROTO_TLS13
{ EXTENSION_MSG(HS_EX_TYPE_COOKIE, isTls13, PackCookie) },
#ifdef HITLS_TLS_FEATURE_PHA
{ EXTENSION_MSG(HS_EX_TYPE_POST_HS_AUTH, isNeedPha, NULL) },
#endif /* HITLS_TLS_FEATURE_PHA */
#endif /* HITLS_TLS_PROTO_TLS13 */
{ EXTENSION_MSG(HS_EX_TYPE_EXTENDED_MASTER_SECRET, IsNeedEms(ctx), NULL) },
#ifdef HITLS_TLS_FEATURE_ALPN
{ EXTENSION_MSG(HS_EX_TYPE_APP_LAYER_PROTOCOLS, (tlsConfig->alpnList != NULL &&
ctx->state == CM_STATE_HANDSHAKING), PackClientAlpnList) },
#endif /* HITLS_TLS_FEATURE_ALPN */
#ifdef HITLS_TLS_PROTO_TLS13
{ EXTENSION_MSG(HS_EX_TYPE_PSK_KEY_EXCHANGE_MODES, isTls13, PackClientPskKeyExModes) },
{ EXTENSION_MSG(HS_EX_TYPE_KEY_SHARE, isTls13, PackClientKeyShare) },
#ifdef HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES
{ EXTENSION_MSG(HS_EX_TYPE_CERTIFICATE_AUTHORITIES, isTls13 && tlsConfig->caList != NULL, PackClientCAList) },
#endif /* HITLS_TLS_FEATURE_CERTIFICATE_AUTHORITIES */
#endif /* HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
{ EXTENSION_MSG(HS_EX_TYPE_RENEGOTIATION_INFO, negoInfo->isSecureRenegotiation, PackClientSecRenegoInfo) },
#endif /* HITLS_TLS_FEATURE_RENEGOTIATION */
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
{ EXTENSION_MSG(HS_EX_TYPE_SESSION_TICKET, isSessionTicketNeed, PackClientTicket) },
#endif /* HITLS_TLS_FEATURE_SESSION_TICKET */
#ifdef HITLS_TLS_FEATURE_ETM
{ EXTENSION_MSG(HS_EX_TYPE_ENCRYPT_THEN_MAC, tlsConfig->isEncryptThenMac, NULL) },
#endif /* HITLS_TLS_FEATURE_ETM */
#ifdef HITLS_TLS_PROTO_TLS13
{ EXTENSION_MSG(HS_EX_TYPE_PRE_SHARED_KEY, IsNeedPreSharedKey(ctx), PackClientPreSharedKey) },
#endif /* HITLS_TLS_PROTO_TLS13 */
};
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
if (IsPackNeedCustomExtensions(CUSTOM_EXT_FROM_CTX(ctx), HITLS_EX_TYPE_CLIENT_HELLO)) {
ret = PackCustomExtensions(ctx, pkt, HITLS_EX_TYPE_CLIENT_HELLO, NULL, 0);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
ret = PackExtensions(ctx, pkt, extMsgList, sizeof(extMsgList) / sizeof(extMsgList[0]));
if (ret != HITLS_SUCCESS) {
return ret;
}
#ifdef HITLS_TLS_FEATURE_PHA
ctx->hsCtx->extFlag.havePostHsAuth = isNeedPha;
#endif /* HITLS_TLS_FEATURE_PHA */
ctx->hsCtx->extFlag.haveExtendedMasterSecret = IsNeedEms(ctx);
#ifdef HITLS_TLS_FEATURE_ETM
ctx->hsCtx->extFlag.haveEncryptThenMac = ctx->config.tlsConfig.isEncryptThenMac;
#endif /* HITLS_TLS_FEATURE_ETM */
return HITLS_SUCCESS;
}
// Pack the Client Hello extension
int32_t PackClientExtension(const TLS_Ctx *ctx, PackPacket *pkt)
{
uint32_t extensionLenPosition = 0u;
int32_t ret = PackStartLengthField(pkt, sizeof(uint16_t), &extensionLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack the client hello extension content */
ret = PackClientExtensions(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
return PackExtensionEnd(pkt, extensionLenPosition);
}
#endif /* HITLS_TLS_HOST_CLIENT */
#ifdef HITLS_TLS_HOST_SERVER
static bool IsServerNeedPackEcExtension(const TLS_Ctx *ctx)
{
const TLS_NegotiatedInfo *negotiatedInfo = &(ctx->negotiatedInfo);
CipherSuiteInfo cipherInfo = negotiatedInfo->cipherSuiteInfo;
/* The negotiated algorithm suite is the ECC cipher suite */
if (((cipherInfo.authAlg == HITLS_AUTH_ECDSA) || (cipherInfo.kxAlg == HITLS_KEY_EXCH_ECDHE) ||
(cipherInfo.kxAlg == HITLS_KEY_EXCH_ECDH) || (cipherInfo.kxAlg == HITLS_KEY_EXCH_ECDHE_PSK)) &&
ctx->haveClientPointFormats == true) {
return true;
}
return false;
}
#ifdef HITLS_TLS_FEATURE_ALPN
int32_t PackServerSelectAlpnProto(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint16_t exMsgHeaderLen = 0u;
uint8_t exMsgDataLen = 0u;
if (ctx->negotiatedInfo.alpnSelectedSize == 0) {
return HITLS_SUCCESS;
}
/* Calculate the extension length */
exMsgHeaderLen = sizeof(uint16_t);
exMsgDataLen = (uint8_t)ctx->negotiatedInfo.alpnSelectedSize + sizeof(uint8_t);
/* Pack the extension header */
ret = PackExtensionHeader(HS_EX_TYPE_APP_LAYER_PROTOCOLS, exMsgHeaderLen + exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
(void)PackAppendUint16ToBuf(pkt, (uint16_t)exMsgDataLen);
(void)PackAppendUint8ToBuf(pkt, exMsgDataLen - sizeof(uint8_t));
(void)PackAppendDataToBuf(pkt, ctx->negotiatedInfo.alpnSelected, ctx->negotiatedInfo.alpnSelectedSize);
/* Set the extension flag */
ctx->hsCtx->extFlag.haveAlpn = true;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_ALPN */
#ifdef HITLS_TLS_PROTO_TLS13
static int32_t PackHrrKeyShare(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint16_t exMsgDataLen = 0u;
KeyShareParam *keyShare = &(ctx->hsCtx->kxCtx->keyExchParam.share);
/* Message length = group length */
exMsgDataLen = sizeof(uint16_t);
ret = PackExtensionHeader(HS_EX_TYPE_KEY_SHARE, exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack a group */
(void)PackAppendUint16ToBuf(pkt, (uint16_t)keyShare->group);
ctx->hsCtx->extFlag.haveKeyShare = true;
return HITLS_SUCCESS;
}
static int32_t PackServerKeyShare(const TLS_Ctx *ctx, PackPacket *pkt)
{
KeyShareParam *keyShare = &(ctx->hsCtx->kxCtx->keyExchParam.share);
KeyExchCtx *kxCtx = ctx->hsCtx->kxCtx;
/* If the peer public key does not exist, the psk_only mode is used. In this case, the key share does not need to be
* sent */
if (kxCtx->peerPubkey == NULL) {
return HITLS_SUCCESS;
}
const TLS_GroupInfo *groupInfo = ConfigGetGroupInfo(&ctx->config.tlsConfig, ctx->negotiatedInfo.negotiatedGroup);
if (groupInfo == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16246, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"group info not found", 0, 0, 0, 0);
return HITLS_INVALID_INPUT;
}
uint32_t pubKeyLen = groupInfo->isKem ? groupInfo->ciphertextLen : groupInfo->pubkeyLen;
if (pubKeyLen == 0u || (groupInfo->isKem && pubKeyLen != kxCtx->ciphertextLen)) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_INVALID_KX_PUBKEY_LENGTH);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15428, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"invalid keyShare length.", 0, 0, 0, 0);
return HITLS_PACK_INVALID_KX_PUBKEY_LENGTH;
}
/* Length of group + Length of KeyExChange + KeyExChange */
uint16_t exMsgDataLen = sizeof(uint16_t) + sizeof(uint16_t) + (uint16_t)pubKeyLen;
int32_t ret = PackReserveBytes(pkt, exMsgDataLen + HS_EX_HEADER_LEN, NULL);
if (ret != HITLS_SUCCESS) {
return ret;
}
(void)PackExtensionHeader(HS_EX_TYPE_KEY_SHARE, exMsgDataLen, pkt);
/* Pack a group */
(void)PackAppendUint16ToBuf(pkt, (uint16_t)keyShare->group);
/* Length of the paced KeyExChange */
(void)PackAppendUint16ToBuf(pkt, (uint16_t)pubKeyLen);
if (groupInfo->isKem) {
ret = PackAppendDataToBuf(pkt, kxCtx->ciphertext, kxCtx->ciphertextLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
} else {
uint8_t *pubKeyBuf = NULL;
uint32_t pubKeyUsedLen = 0;
(void)PackReserveBytes(pkt, pubKeyLen, &pubKeyBuf);
ret = SAL_CRYPT_EncodeEcdhPubKey(kxCtx->key, pubKeyBuf, pubKeyLen, &pubKeyUsedLen);
if (ret != HITLS_SUCCESS || pubKeyLen != pubKeyUsedLen) {
BSL_ERR_PUSH_ERROR(HITLS_CRYPT_ERR_ENCODE_ECDH_KEY);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15429, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode server keyShare key fail.", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_ENCODE_ECDH_KEY;
}
(void)PackSkipBytes(pkt, pubKeyUsedLen);
}
ctx->hsCtx->extFlag.haveKeyShare = true;
return HITLS_SUCCESS;
}
static int32_t PackServerSupportedVersion(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint16_t exMsgDataLen = 0u;
const uint16_t supportedVersion = ctx->negotiatedInfo.version;
if (supportedVersion <= 0) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15430, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack supported version extension error, invalid input parameter.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
/* Calculate the extension length */
exMsgDataLen = sizeof(uint16_t);
ret = PackExtensionHeader(HS_EX_TYPE_SUPPORTED_VERSIONS, exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
(void)PackAppendUint16ToBuf(pkt, supportedVersion);
ctx->hsCtx->extFlag.haveSupportedVers = true;
return HITLS_SUCCESS;
}
static int32_t IsHrrKeyShare(const TLS_Ctx *ctx)
{
bool haveHrr = ctx->hsCtx->haveHrr; /* Sent or in the process of sending hrr */
bool haveKeyShare = ctx->hsCtx->extFlag.haveKeyShare; /* has packed the keyshare */
if (haveHrr && !haveKeyShare) {
return true;
}
return false;
}
static int32_t PackServerPreSharedKey(const TLS_Ctx *ctx, PackPacket *pkt)
{
const PskInfo13 *pskInfo = &ctx->hsCtx->kxCtx->pskInfo13;
if (pskInfo->psk == NULL) {
return HITLS_SUCCESS;
}
int32_t ret = PackExtensionHeader(HS_EX_TYPE_PRE_SHARED_KEY, sizeof(uint16_t), pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
(void)PackAppendUint16ToBuf(pkt, (uint16_t)pskInfo->selectIndex);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS13 */
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
static int32_t PackServerSecRenegoInfo(const TLS_Ctx *ctx, PackPacket *pkt)
{
bool isRenegotiation = ctx->negotiatedInfo.isRenegotiation;
const uint8_t *clientData = ctx->negotiatedInfo.clientVerifyData;
uint32_t clientDataSize = ctx->negotiatedInfo.clientVerifyDataSize;
const uint8_t *serverData = ctx->negotiatedInfo.serverVerifyData;
uint32_t serverDataSize = ctx->negotiatedInfo.serverVerifyDataSize;
/* Calculate the extension length */
uint16_t exMsgHeaderLen = sizeof(uint8_t);
/* For renegotiation, the verify data (client data + server data) must be assembled */
uint16_t exMsgDataLen = (uint16_t)(isRenegotiation ? (clientDataSize + serverDataSize) : 0);
int32_t ret = PackExtensionHeader(HS_EX_TYPE_RENEGOTIATION_INFO, exMsgHeaderLen + exMsgDataLen, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (!isRenegotiation) {
(void)PackAppendUint8ToBuf(pkt, 0);
return HITLS_SUCCESS;
}
/* Pack the length of secRenegoInfo */
(void)PackAppendUint8ToBuf(pkt, (uint8_t)(clientDataSize + serverDataSize));
/* Pack the secRenegoInfo content */
(void)PackAppendDataToBuf(pkt, clientData, clientDataSize);
(void)PackAppendDataToBuf(pkt, serverData, serverDataSize);
return HITLS_SUCCESS;
}
#endif /* defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12) */
#ifdef HITLS_TLS_FEATURE_SNI
static bool IsNeedServerPackServerName(const TLS_Ctx *ctx)
{
const TLS_Config *config = &(ctx->config.tlsConfig);
const TLS_NegotiatedInfo *negoInfo = &ctx->negotiatedInfo;
/* The protocol version is earlier than tls1.3 and the server accepts the server name. The server hello message sent
* by the server contains an empty server name extension */
if (negoInfo->isSniStateOK &&
(config->maxVersion < HITLS_VERSION_TLS13 || config->maxVersion == HITLS_VERSION_DTLS12)) {
return true;
}
return false;
}
#endif /* HITLS_TLS_FEATURE_SNI */
#ifdef HITLS_TLS_FEATURE_ETM
static bool IsNeedServerPackEncryptThenMac(const TLS_Ctx *ctx)
{
const TLS_Config *config = &(ctx->config.tlsConfig);
const TLS_NegotiatedInfo *negoInfo = &ctx->negotiatedInfo;
if (config->isEncryptThenMac && negoInfo->isEncryptThenMac) {
return true;
}
return false;
}
#endif /* HITLS_TLS_FEATURE_ETM */
// Pack the empty extension of Server Hello
static int32_t PackServerExtensions(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
#ifdef HITLS_TLS_PROTO_TLS13
uint32_t version = HS_GetVersion(ctx);
bool isHrrKeyshare = IsHrrKeyShare(ctx);
bool isTls13 = Tls13NeedPack(ctx, version);
#endif /* HITLS_TLS_PROTO_TLS13 */
const TLS_NegotiatedInfo *negoInfo = &ctx->negotiatedInfo;
(void)negoInfo;
PackExtInfo extMsgList[] = {
#ifdef HITLS_TLS_FEATURE_SNI
{ EXTENSION_MSG(HS_EX_TYPE_SERVER_NAME, IsNeedServerPackServerName(ctx), NULL) },
#endif /* HITLS_TLS_FEATURE_SNI */
#ifdef HITLS_TLS_PROTO_TLS13
{ EXTENSION_MSG(HS_EX_TYPE_COOKIE, isTls13, PackCookie) },
#endif /* HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
{ EXTENSION_MSG(HS_EX_TYPE_SESSION_TICKET, negoInfo->isTicket, NULL) },
#endif /* HITLS_TLS_FEATURE_SESSION_TICKET */
{ EXTENSION_MSG(HS_EX_TYPE_POINT_FORMATS, IsServerNeedPackEcExtension(ctx), PackPointFormats) },
#ifdef HITLS_TLS_PROTO_TLS13
{ EXTENSION_MSG(HS_EX_TYPE_SUPPORTED_VERSIONS, isTls13, PackServerSupportedVersion) },
#endif /* HITLS_TLS_PROTO_TLS13 */
{ EXTENSION_MSG(HS_EX_TYPE_EXTENDED_MASTER_SECRET, negoInfo->isExtendedMasterSecret, NULL) },
#ifdef HITLS_TLS_FEATURE_ALPN
{ .exMsgType = HS_EX_TYPE_APP_LAYER_PROTOCOLS,
.needPack = (negoInfo->alpnSelected != NULL
#ifdef HITLS_TLS_PROTO_TLS13
&& !isTls13
#endif
),
.packFunc = PackServerSelectAlpnProto },
#endif /* HITLS_TLS_FEATURE_ALPN */
#ifdef HITLS_TLS_PROTO_TLS13
{ EXTENSION_MSG(HS_EX_TYPE_KEY_SHARE, (isTls13 && !isHrrKeyshare), PackServerKeyShare) },
{ EXTENSION_MSG(HS_EX_TYPE_KEY_SHARE, (isTls13 && isHrrKeyshare), PackHrrKeyShare) },
#endif /* HITLS_TLS_PROTO_TLS13 */
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
{ EXTENSION_MSG(HS_EX_TYPE_RENEGOTIATION_INFO, negoInfo->isSecureRenegotiation, PackServerSecRenegoInfo) },
#endif /* defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12) */
#ifdef HITLS_TLS_FEATURE_ETM
{ EXTENSION_MSG(HS_EX_TYPE_ENCRYPT_THEN_MAC, IsNeedServerPackEncryptThenMac(ctx), NULL) },
#endif /* HITLS_TLS_FEATURE_ETM */
#ifdef HITLS_TLS_PROTO_TLS13
/* The preshare key must be the last extension */
{ EXTENSION_MSG(HS_EX_TYPE_PRE_SHARED_KEY, IsNeedPreSharedKey(ctx), PackServerPreSharedKey) },
#endif /* HITLS_TLS_PROTO_TLS13 */
};
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
uint32_t context = 0;
#ifdef HITLS_TLS_PROTO_TLS13
if (isTls13) {
if (isHrrKeyshare) {
context = HITLS_EX_TYPE_HELLO_RETRY_REQUEST;
} else {
context = HITLS_EX_TYPE_TLS1_3_SERVER_HELLO;
}
} else
#endif
{
context = HITLS_EX_TYPE_TLS1_2_SERVER_HELLO;
}
if (IsPackNeedCustomExtensions(CUSTOM_EXT_FROM_CTX(ctx), context)) {
ret = PackCustomExtensions(ctx, pkt, context, NULL, 0);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
ret = PackExtensions(ctx, pkt, extMsgList, sizeof(extMsgList) / sizeof(extMsgList[0]));
if (ret != HITLS_SUCCESS) {
return ret;
}
return HITLS_SUCCESS;
}
// Pack the Server Hello extension
int32_t PackServerExtension(const TLS_Ctx *ctx, PackPacket *pkt)
{
/* Obtain the packet header length */
uint32_t extensionLenPosition = 0u;
int32_t ret = PackStartLengthField(pkt, sizeof(uint16_t), &extensionLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack the server hello extension content */
ret = PackServerExtensions(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
return PackExtensionEnd(pkt, extensionLenPosition);
}
#endif /* HITLS_TLS_HOST_SERVER */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_extensions.c | C | unknown | 45,587 |
/*
* 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 PACK_EXTENSIONS_H
#define PACK_EXTENSIONS_H
#include <stdint.h>
#include "tls.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* Hook function for packing extensions of client and server.
*/
typedef int32_t (*PACK_EXT_FUNC)(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* PackExtInfo structure, used to transfer extension information of ClientHello messages
*/
typedef struct {
uint16_t exMsgType; /**< Extension type of message*/
bool needPack; /**< Whether packing is needed */
PACK_EXT_FUNC packFunc; /**< Hook for packing extensions*/
} PackExtInfo;
typedef void (*GET_EXTSIZE_FUNC)(const TLS_Ctx *ctx, uint32_t *exSize);
typedef struct {
bool needCheck;
GET_EXTSIZE_FUNC getSizeFunc;
} GetExtFieldSize;
/**
* @brief Pack Client Hello extension
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH The message buffer length is insufficient
*/
int32_t PackClientExtension(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack Server Hello extension
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH The message buffer length is insufficient
*/
int32_t PackServerExtension(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack an empty extension
*
* @param exMsgType [IN] Extension type
* @param needPack [IN] Whether packing is needed
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval HITLS_PACK_NOT_ENOUGH_BUF_LENGTH The message buffer length is insufficient
*/
int32_t PackEmptyExtension(uint16_t exMsgType, bool needPack, PackPacket *pkt);
/**
* @brief Pack the header of an extension
*
* @param exMsgType [IN] Extension type
* @param exMsgLen [IN] Extension length
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackExtensionHeader(uint16_t exMsgType, uint16_t exMsgLen, PackPacket *pkt);
int32_t PackServerSelectAlpnProto(const TLS_Ctx *ctx, PackPacket *pkt);
int32_t PackClientCAList(const TLS_Ctx *ctx, PackPacket *pkt);
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end PACK_EXTENSIONS_H */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_extensions.h | C | unknown | 2,898 |
/*
* 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.
*/
#include <stdint.h>
#include "hitls_build.h"
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "tls.h"
#include "pack_common.h"
#include "hs_ctx.h"
// pack the Finished message.
int32_t PackFinished(const TLS_Ctx *ctx, PackPacket *pkt)
{
const HS_Ctx *hsCtx = (HS_Ctx *)ctx->hsCtx;
return PackAppendDataToBuf(pkt, hsCtx->verifyCtx->verifyData, hsCtx->verifyCtx->verifyDataSize);
} | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_finished.c | C | unknown | 1,074 |
/*
* 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.
*/
#include "hitls_build.h"
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP) && defined(HITLS_TLS_HOST_SERVER)
#include <stdint.h>
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "hitls_security.h"
#include "tls.h"
#ifdef HITLS_TLS_FEATURE_SECURITY
#include "security.h"
#endif
#include "hs_ctx.h"
#include "pack_common.h"
#include "pack_extensions.h"
// Pack the HelloVerifyRequest message.
int32_t PackHelloVerifyRequest(const TLS_Ctx *ctx, PackPacket *pkt)
{
const TLS_NegotiatedInfo *negotiatedInfo = &ctx->negotiatedInfo;
/* According to rfc6347 4.2.1, message with the cookie length of 0 can be sent,
but it is meaningless and will be trapped in an infinite loop.
Therefore, cannot sent cookies with the length of 0 here. */
if (negotiatedInfo->cookieSize == 0) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_COOKIE_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15828, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"cookieSize is 0.", 0, 0, 0, 0);
return HITLS_PACK_COOKIE_ERR;
}
uint16_t version = HITLS_VERSION_DTLS10;
if (IS_SUPPORT_TLCP(ctx->config.tlsConfig.originVersionMask)) {
version = HITLS_VERSION_TLCP_DTLCP11;
}
int32_t ret = PackReserveBytes(pkt, sizeof(uint16_t) + sizeof(uint8_t) + negotiatedInfo->cookieSize, NULL);
if (ret != HITLS_SUCCESS) {
return ret;
}
(void)PackAppendUint16ToBuf(pkt, version);
(void)PackAppendUint8ToBuf(pkt, (uint8_t)negotiatedInfo->cookieSize);
(void)PackAppendDataToBuf(pkt, negotiatedInfo->cookie, negotiatedInfo->cookieSize);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_DTLS12 && HITLS_BSL_UIO_UDP && HITLS_TLS_HOST_SERVER */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_hello_verify_request.c | C | unknown | 2,382 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_FEATURE_KEY_UPDATE
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "hitls_error.h"
#include "tls.h"
#include "hs_ctx.h"
#include "pack_common.h"
int32_t PackKeyUpdate(const TLS_Ctx *ctx, PackPacket *pkt)
{
uint8_t keyUpdateValue = (uint8_t)ctx->keyUpdateType;
return PackAppendUint8ToBuf(pkt, keyUpdateValue);
}
#endif /* HITLS_TLS_FEATURE_KEY_UPDATE */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_key_update.c | C | unknown | 1,021 |
/*
* 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 PACK_MSG_H
#define PACK_MSG_H
#include <stdint.h>
#include "tls.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Pack ClientHello message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackClientHello(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack HelloVerifyRequest message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackHelloVerifyRequest(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack ServertHello message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackServerHello(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack Encrypted Extensions message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackEncryptedExtensions(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack Tls1.3 Certificate message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t Tls13PackCertificate(TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack certificate message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackCertificate(TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack CertificateRequest message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackCertificateRequest(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack Tls1.3 CertificateRequest message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t Tls13PackCertificateRequest(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack CertificateVerify message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackCertificateVerify(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack new session ticket message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackNewSessionTicket(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack TLS1.3 new session ticket message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t Tls13PackNewSessionTicket(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack ServerKeyExchange message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackServerKeyExchange(TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack ClientKeyExchange message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackClientKeyExchange(TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack Finished message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackFinished(const TLS_Ctx *ctx, PackPacket *pkt);
/**
* @brief Pack KeyUpdate message
*
* @param ctx [IN] TLS context
* @param pkt [IN/OUT] Context for packing
*
* @retval HITLS_SUCCESS
* @retval For other error codes, see hitls_error.h
*/
int32_t PackKeyUpdate(const TLS_Ctx *ctx, PackPacket *pkt);
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end PACK_MSG_H */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_msg.h | C | unknown | 4,938 |
/*
* 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.
*/
#include "hitls_build.h"
#if defined(HITLS_TLS_HOST_SERVER) && defined(HITLS_TLS_FEATURE_SESSION_TICKET)
#include <stdint.h>
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "pack_common.h"
#include "tls.h"
#include "hs_ctx.h"
#include "custom_extensions.h"
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
int32_t PackNewSessionTicket(const TLS_Ctx *ctx, PackPacket *pkt)
{
HS_Ctx *hsCtx = ctx->hsCtx;
/* Pack ticket lifetime hint */
int32_t ret = PackAppendUint32ToBuf(pkt, hsCtx->ticketLifetimeHint);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack ticket length */
ret = PackAppendUint16ToBuf(pkt, (uint16_t)hsCtx->ticketSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* rfc5077 3.3. NewSessionTicket Handshake Message
If the server determines that it does not want to include a ticket after including the SessionTicket extension
in the ServerHello, it sends a zero-length ticket in the NewSessionTicket handshake message. */
if (hsCtx->ticketSize != 0) {
ret = PackAppendDataToBuf(pkt, hsCtx->ticket, hsCtx->ticketSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#ifdef HITLS_TLS_PROTO_TLS13
int32_t Tls13PackNewSessionTicket(const TLS_Ctx *ctx, PackPacket *pkt)
{
HS_Ctx *hsCtx = ctx->hsCtx;
/* Pack ticket lifetime */
int32_t ret = PackAppendUint32ToBuf(pkt, hsCtx->ticketLifetimeHint);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack ticket age add */
ret = PackAppendUint32ToBuf(pkt, hsCtx->ticketAgeAdd);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack ticket nonce length (1 byte) */
ret = PackAppendUint8ToBuf(pkt, sizeof(hsCtx->nextTicketNonce));
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack ticket nonce (8 bytes) */
ret = PackAppendUint64ToBuf(pkt, hsCtx->nextTicketNonce);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack ticket length */
ret = PackAppendUint16ToBuf(pkt, (uint16_t)hsCtx->ticketSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* In TLS1.3, no empty new session ticket is sent
because we ensure that hsCtx->ticketSize is not empty at the invoking point.
Therefore, you do not need to check whether hsCtx->ticketSize is empty. */
ret = PackAppendDataToBuf(pkt, hsCtx->ticket, hsCtx->ticketSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Pack extensions length field */
uint32_t extensionsLenPosition = 0u;
ret = PackStartLengthField(pkt, sizeof(uint16_t), &extensionsLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
if (IsPackNeedCustomExtensions(CUSTOM_EXT_FROM_CTX(ctx), HITLS_EX_TYPE_TLS1_3_NEW_SESSION_TICKET)) {
ret = PackCustomExtensions(ctx, pkt, HITLS_EX_TYPE_TLS1_3_NEW_SESSION_TICKET, NULL, 0);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
/* Close extensions length field */
PackCloseUint16Field(pkt, extensionsLenPosition);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS13 */
#endif /* HITLS_TLS_HOST_SERVER && HITLS_TLS_FEATURE_SESSION_TICKET */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_new_session_ticket.c | C | unknown | 4,087 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_HOST_SERVER
#include <stdint.h>
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "hitls_security.h"
#include "tls.h"
#ifdef HITLS_TLS_FEATURE_SECURITY
#include "security.h"
#endif
#include "hs_ctx.h"
#include "pack_common.h"
#include "pack_extensions.h"
// Pack the mandatory content of the ServerHello message
static int32_t PackServerHelloMandatoryField(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint16_t negotiatedVersion = ctx->negotiatedInfo.version;
uint16_t version =
#ifdef HITLS_TLS_PROTO_TLS13
(negotiatedVersion == HITLS_VERSION_TLS13) ? HITLS_VERSION_TLS12 :
#endif
negotiatedVersion;
#ifdef HITLS_TLS_FEATURE_SECURITY
ret = SECURITY_CfgCheck(&ctx->config.tlsConfig, HITLS_SECURITY_SECOP_VERSION, 0, version, NULL);
if (ret != SECURITY_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16940, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CfgCheck fail, ret %d", ret, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_PACK_UNSECURE_VERSION);
ctx->method.sendAlert((TLS_Ctx *)(uintptr_t)ctx, ALERT_LEVEL_FATAL, ALERT_INSUFFICIENT_SECURITY);
return HITLS_PACK_UNSECURE_VERSION;
}
#endif
ret = PackAppendUint16ToBuf(pkt, version);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackAppendDataToBuf(pkt, ctx->hsCtx->serverRandom, HS_RANDOM_SIZE);
if (ret != HITLS_SUCCESS) {
return ret;
}
#if defined(HITLS_TLS_FEATURE_SESSION_ID) || defined(HITLS_TLS_PROTO_TLS13)
HS_Ctx *hsCtx = (HS_Ctx *)ctx->hsCtx;
ret = PackSessionId(pkt, hsCtx->sessionId, hsCtx->sessionIdSize);
if (ret != HITLS_SUCCESS) {
(void)memset_s(hsCtx->sessionId, hsCtx->sessionIdSize, 0, hsCtx->sessionIdSize);
return ret;
}
#else // Session recovery is not supported.
ret = PackAppendUint8ToBuf(pkt, 0);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif
ret = PackAppendUint16ToBuf(pkt, ctx->negotiatedInfo.cipherSuiteInfo.cipherSuite); // cipher suite
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackAppendUint8ToBuf(pkt, 0); // Compression method, currently supports uncompression
if (ret != HITLS_SUCCESS) {
return ret;
}
return HITLS_SUCCESS;
}
// Pack the ServertHello message.
int32_t PackServerHello(const TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = PackServerHelloMandatoryField(ctx, pkt);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15863, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack server hello mandatory content fail.", 0, 0, 0, 0);
return ret;
}
ret = PackServerExtension(ctx, pkt);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15864, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack server hello extension content fail.", 0, 0, 0, 0);
return ret;
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_HOST_SERVER */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_server_hello.c | C | unknown | 3,673 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_HOST_SERVER
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
#include <stdint.h>
#include "securec.h"
#include "bsl_sal.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "tls.h"
#include "cipher_suite.h"
#include "crypt.h"
#include "cert.h"
#include "hs_ctx.h"
#include "hs_common.h"
#include "pack_common.h"
#if defined(HITLS_TLS_SUITE_KX_ECDHE) || defined(HITLS_TLS_SUITE_KX_DHE)
/* Determine whether additional parameter signatures are required. */
static bool IsNeedKeyExchParamSignature(const TLS_Ctx *ctx)
{
/* Add the parameter signature only when the authentication algorithm is not HITLS_AUTH_NULL for the DHE and ECDHE
* cipher suites */
return ((ctx->hsCtx->kxCtx->keyExchAlgo == HITLS_KEY_EXCH_ECDHE ||
ctx->hsCtx->kxCtx->keyExchAlgo == HITLS_KEY_EXCH_DHE) &&
ctx->negotiatedInfo.cipherSuiteInfo.authAlg != HITLS_AUTH_NULL);
}
#endif
#if defined(HITLS_TLS_SUITE_KX_ECDHE) || defined(HITLS_TLS_SUITE_KX_DHE)
static int32_t SignKeyExchParams(TLS_Ctx *ctx, uint8_t *kxData, uint32_t kxDataLen, uint8_t *signBuf, uint32_t *signLen)
{
uint32_t offset = 0u;
HITLS_SignHashAlgo signScheme = ctx->negotiatedInfo.signScheme;
HITLS_SignAlgo signAlgo;
HITLS_HashAlgo hashAlgo;
if (CFG_GetSignParamBySchemes(ctx, signScheme, &signAlgo, &hashAlgo) != true) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_SIGNATURE_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15496, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"get sign parm fail.", 0, 0, 0, 0);
return HITLS_PACK_SIGNATURE_ERR;
}
uint32_t dataLen;
/* Obtain all signature data (random number + server kx content) */
uint8_t *data = HS_PrepareSignData(ctx, kxData, kxDataLen, &dataLen);
if (data == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15495, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"prepare unsigned data fail.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
#ifdef HITLS_TLS_PROTO_TLCP11
if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP_DTLCP11)
#endif /* HITLS_TLS_PROTO_TLCP11 */
{
if (ctx->negotiatedInfo.version >= HITLS_VERSION_TLS12) {
/* TLS1.2 and later versions require explicit hash and signature algorithms to be specified in messages, and
* TLCP are not written */
BSL_Uint16ToByte(signScheme, signBuf);
offset += sizeof(uint16_t);
}
}
/* Temporarily record the position of the signature length in the packet and fill it later */
uint32_t signLenOffset = offset;
offset += sizeof(uint16_t);
/* Fill signature parameters */
CERT_SignParam signParam = {0};
signParam.signAlgo = signAlgo;
signParam.hashAlgo = hashAlgo;
signParam.data = data;
signParam.dataLen = dataLen;
signParam.sign = &signBuf[offset];
signParam.signLen = (uint16_t)(*signLen - offset);
/* Fill signature */
HITLS_CERT_Key *privateKey = SAL_CERT_GetCurrentPrivateKey(ctx->config.tlsConfig.certMgrCtx, false);
int32_t ret = SAL_CERT_CreateSign(ctx, privateKey, &signParam);
BSL_SAL_FREE(data);
if ((ret != HITLS_SUCCESS) || (offset + signParam.signLen > *signLen)) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_SIGNATURE_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15497, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"create signature fail.", 0, 0, 0, 0);
return HITLS_PACK_SIGNATURE_ERR;
}
offset += signParam.signLen;
BSL_Uint16ToByte((uint16_t)signParam.signLen, &signBuf[signLenOffset]);
*signLen = offset;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_SUITE_KX_ECDHE || HITLS_TLS_SUITE_KX_DHE */
#ifdef HITLS_TLS_SUITE_KX_ECDHE
static uint32_t GetNamedCurveMsgLen(TLS_Ctx *ctx, uint32_t pubKeyLen)
{
HITLS_Config *config = &(ctx->config.tlsConfig);
/* Message length = Curve type (1 byte) + Curve ID (2 byte) + Public key length (1 byte) + Public key + Signature
* length (2 byte) + Signature */
uint32_t dataLen = sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint8_t) + pubKeyLen;
/* ECDHE_PSK key exchange does not require signature */
if (IsNeedKeyExchParamSignature(ctx)) {
HITLS_CERT_Key *privateKey = SAL_CERT_GetCurrentPrivateKey(config->certMgrCtx, false);
uint32_t signatureLen = SAL_CERT_GetSignMaxLen(config, privateKey);
if ((signatureLen == 0u) || (signatureLen > MAX_SIGN_SIZE)) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_SIGNATURE_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15499, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack ske error: invalid signature length = %u.", signatureLen, 0, 0, 0);
return 0;
}
dataLen += sizeof(uint16_t) + signatureLen;
/* A signature type needs to be added to TLS1.2/DTLS. The signature type does not need to be transferred */
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLS12 || ctx->negotiatedInfo.version == HITLS_VERSION_DTLS12) {
dataLen += sizeof(uint16_t);
}
}
return dataLen;
}
static int32_t PackServerKxMsgNamedCurve(TLS_Ctx *ctx, PackPacket *pkt)
{
KeyExchCtx *kxCtx = ctx->hsCtx->kxCtx;
HITLS_ECParameters *ecParam = &(kxCtx->keyExchParam.ecdh.curveParams);
uint32_t pubKeyLen = SAL_CRYPT_GetCryptLength(ctx, HITLS_CRYPT_INFO_CMD_GET_PUBLIC_KEY_LEN, ecParam->param.namedcurve);
if (pubKeyLen == 0u) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_INVALID_KX_PUBKEY_LENGTH);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15498, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"pack ske error: unsupport named curve = %u.", ecParam->param.namedcurve, 0, 0, 0);
return HITLS_PACK_INVALID_KX_PUBKEY_LENGTH;
}
uint32_t dataLen = GetNamedCurveMsgLen(ctx, pubKeyLen);
if (dataLen == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16941, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GetNamedCurveMsgLen err", 0, 0, 0, 0);
return HITLS_PACK_SIGNATURE_ERR;
}
uint32_t dataOffset = 0;
int32_t ret = PackGetSubBuffer(pkt, 0, &dataOffset, NULL);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Curve type and curve ID. Although these parameters are ignored in the TLCP, they are
* filled in to ensure the uniform style. However, the client cannot depend on the value of this parameter */
ret = PackAppendUint8ToBuf(pkt, (uint8_t)(ecParam->type));
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackAppendUint16ToBuf(pkt, (uint16_t)(ecParam->param.namedcurve));
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Public key length and public key content */
uint32_t pubKeyLenOffset = 0;
ret = PackStartLengthField(pkt, sizeof(uint8_t), &pubKeyLenOffset);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint8_t *pubKeyBuf = NULL;
ret = PackReserveBytes(pkt, pubKeyLen, &pubKeyBuf);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint32_t pubKeyUsedLen = 0;
ret = SAL_CRYPT_EncodeEcdhPubKey(kxCtx->key, pubKeyBuf, pubKeyLen, &pubKeyUsedLen);
if (ret != HITLS_SUCCESS || pubKeyLen != pubKeyUsedLen) {
BSL_ERR_PUSH_ERROR(HITLS_CRYPT_ERR_ENCODE_ECDH_KEY);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15501, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode ecdh key fail.", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_ENCODE_ECDH_KEY;
}
(void)PackSkipBytes(pkt, pubKeyUsedLen);
PackCloseUint8Field(pkt, pubKeyLenOffset);
if (IsNeedKeyExchParamSignature(ctx)) {
uint32_t signDataLen = 0;
(void)PackGetSubBuffer(pkt, dataOffset, &signDataLen, NULL);
uint32_t signatureLen = dataLen - signDataLen;
uint8_t *signBuf = NULL;
ret = PackReserveBytes(pkt, signatureLen, &signBuf);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint8_t *signData = NULL;
(void)PackGetSubBuffer(pkt, dataOffset, &signDataLen, &signData);
ret = SignKeyExchParams(ctx, signData, signDataLen, signBuf, &signatureLen);
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_SIGNATURE_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15502, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"signature fail.", 0, 0, 0, 0);
return HITLS_PACK_SIGNATURE_ERR;
}
(void)PackSkipBytes(pkt, signatureLen);
}
return HITLS_SUCCESS;
}
static int32_t PackServerKxMsgEcdhe(TLS_Ctx *ctx, PackPacket *pkt)
{
HITLS_ECCurveType type = ctx->hsCtx->kxCtx->keyExchParam.ecdh.curveParams.type;
switch (type) {
case HITLS_EC_CURVE_TYPE_NAMED_CURVE:
return PackServerKxMsgNamedCurve(ctx, pkt);
default:
break;
}
BSL_ERR_PUSH_ERROR(HITLS_PACK_UNSUPPORT_KX_CURVE_TYPE);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15503, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"unsupport key exchange curve type.", 0, 0, 0, 0);
return HITLS_PACK_UNSUPPORT_KX_CURVE_TYPE;
}
#endif /* HITLS_TLS_SUITE_KX_ECDHE */
#ifdef HITLS_TLS_PROTO_TLCP11
static int32_t PackEccSignature(TLS_Ctx *ctx, PackPacket *pkt, HITLS_SignAlgo signAlgo,
HITLS_HashAlgo hashAlgo, uint8_t *data, uint32_t dataLen)
{
HITLS_CERT_Key *privateKey = SAL_CERT_GetCurrentPrivateKey(ctx->config.tlsConfig.certMgrCtx, false);
uint32_t signatureLen = SAL_CERT_GetSignMaxLen(&(ctx->config.tlsConfig), privateKey);
if ((signatureLen == 0u) || (signatureLen > MAX_SIGN_SIZE)) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_SIGNATURE_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15508, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"invalid signature length.", 0, 0, 0, 0);
return HITLS_PACK_SIGNATURE_ERR;
}
/* Fill signature parameters */
CERT_SignParam signParam = {0};
signParam.signAlgo = signAlgo;
signParam.hashAlgo = hashAlgo;
signParam.data = data;
signParam.dataLen = dataLen;
uint8_t *signBuf = NULL;
int32_t ret = PackReserveBytes(pkt, signatureLen, &signBuf);
if (ret != HITLS_SUCCESS) {
return ret;
}
signParam.sign = signBuf;
signParam.signLen = signatureLen;
ret = SAL_CERT_CreateSign(ctx, privateKey, &signParam);
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_SIGNATURE_ERR);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_PACK_SIGNATURE_ERR, BINLOG_ID16221, "create sm2 signature fail");
}
ret = PackSkipBytes(pkt, signParam.signLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
return HITLS_SUCCESS;
}
/* This function is invoked only by the TLCP */
static int32_t PackServerKxMsgEcc(TLS_Ctx *ctx, PackPacket *pkt)
{
uint8_t *data = NULL;
uint32_t dataLen, certLen;
uint8_t *encCert = SAL_CERT_SrvrGmEncodeEncCert(ctx, &certLen);
if (encCert == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_CERT_ERR_ENCODE);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_ENCODE, BINLOG_ID16942, "SAL_CERT_SrvrGmEncodeEncCert fail");
}
/* Obtain all signature data (random number + server kx content) */
data = HS_PrepareSignDataTlcp(ctx, encCert, certLen, &dataLen);
BSL_SAL_FREE(encCert);
if (data == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMALLOC_FAIL, BINLOG_ID16219, "prepare unsigned data fail");
}
HITLS_SignAlgo signAlgo;
HITLS_HashAlgo hashAlgo;
if (!CFG_GetSignParamBySchemes(ctx, ctx->negotiatedInfo.signScheme, &signAlgo, &hashAlgo)) {
BSL_SAL_FREE(data);
BSL_ERR_PUSH_ERROR(HITLS_PACK_SIGNATURE_ERR);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_PACK_SIGNATURE_ERR, BINLOG_ID16220, "get sign parm fail");
}
/* The hash and signature algorithms do not need to be explicitly specified in messages by TLCP. The hash algorithm
* obtained based on signScheme is used. */
uint32_t signLenPosition = 0u; /* The records the position of the signature length in the message temporarily, and
then fills the signature length in the message later */
int32_t ret = PackStartLengthField(pkt, sizeof(uint16_t), &signLenPosition);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(data);
return ret;
}
ret = PackEccSignature(ctx, pkt, signAlgo, hashAlgo, data, dataLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(data);
return ret;
}
PackCloseUint16Field(pkt, signLenPosition);
BSL_SAL_FREE(data);
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLCP11 */
#ifdef HITLS_TLS_SUITE_KX_DHE
static int32_t PackKxPrimaryData(const TLS_Ctx *ctx, PackPacket *pkt)
{
KeyExchCtx *kxCtx = ctx->hsCtx->kxCtx;
DhParam *dh = &ctx->hsCtx->kxCtx->keyExchParam.dh;
uint32_t pubkeyLen = dh->plen;
uint16_t plen = dh->plen;
uint16_t glen = dh->glen;
int32_t ret = PackAppendUint16ToBuf(pkt, plen);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackAppendDataToBuf(pkt, dh->p, plen);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackAppendUint16ToBuf(pkt, glen);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackAppendDataToBuf(pkt, dh->g, glen);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint32_t pubKeyLenPosition = 0u;
ret = PackStartLengthField(pkt, sizeof(uint16_t), &pubKeyLenPosition);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint8_t *reservedBuf = NULL;
ret = PackReserveBytes(pkt, pubkeyLen, &reservedBuf);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = SAL_CRYPT_EncodeDhPubKey(kxCtx->key, reservedBuf, pubkeyLen, &pubkeyLen);
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_CRYPT_ERR_ENCODE_DH_KEY);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15506, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode dhe key fail.", 0, 0, 0, 0);
return HITLS_CRYPT_ERR_ENCODE_DH_KEY;
}
ret = PackSkipBytes(pkt, pubkeyLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
PackCloseUint16Field(pkt, pubKeyLenPosition);
return HITLS_SUCCESS;
}
static int32_t PackServerKxMsgDhePre(TLS_Ctx *ctx, uint32_t *signatureLen)
{
if (IsNeedKeyExchParamSignature(ctx)) {
HITLS_CERT_Key *privateKey = SAL_CERT_GetCurrentPrivateKey(ctx->config.tlsConfig.certMgrCtx, false);
*signatureLen = SAL_CERT_GetSignMaxLen(&(ctx->config.tlsConfig), privateKey);
if ((*signatureLen == 0u) || (*signatureLen > MAX_SIGN_SIZE)) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_SIGNATURE_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15508, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"invalid signature length.", 0, 0, 0, 0);
return HITLS_PACK_SIGNATURE_ERR;
}
}
return HITLS_SUCCESS;
}
static int32_t GetDheParameterLen(TLS_Ctx *ctx, uint32_t *outLen)
{
int32_t ret = HITLS_SUCCESS;
uint32_t dataLen = 0;
DhParam *dh = &ctx->hsCtx->kxCtx->keyExchParam.dh;
uint32_t pubkeyLen = dh->plen;
uint16_t plen = dh->plen;
uint16_t glen = dh->glen;
if (pubkeyLen == 0u) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_INVALID_KX_PUBKEY_LENGTH);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15507, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"invalid key exchange pubKey length.", 0, 0, 0, 0);
return HITLS_PACK_INVALID_KX_PUBKEY_LENGTH;
}
/* DHE_PSK and ANON_DH do not need signatures */
uint32_t signatureLen = 0;
ret = PackServerKxMsgDhePre(ctx, &signatureLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
dataLen = sizeof(uint16_t) + plen + sizeof(uint16_t) + glen + sizeof(uint16_t) + pubkeyLen;
if (IsNeedKeyExchParamSignature(ctx)) {
dataLen += (sizeof(uint16_t) + signatureLen);
}
#if defined(HITLS_TLS_PROTO_TLS12) || defined(HITLS_TLS_PROTO_DTLS12)
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLS12 || ctx->negotiatedInfo.version == HITLS_VERSION_DTLS12) {
dataLen += sizeof(uint16_t); // TLS1.2/DTLS needs to add a signature type
}
#endif /* HITLS_TLS_PROTO_TLS12 || HITLS_TLS_PROTO_DTLS12 */
*outLen = dataLen;
return HITLS_SUCCESS;
}
static int32_t PackServerKxMsgDhe(TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
uint32_t dataLen = 0;
ret = GetDheParameterLen(ctx, &dataLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Fill the following values in sequence: plen, p, glen, g, pubkeylen, pubkey, signature len, and signature */
uint32_t dataOffset = 0;
ret = PackGetSubBuffer(pkt, 0, &dataOffset, NULL);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = PackKxPrimaryData(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (IsNeedKeyExchParamSignature(ctx)) {
uint32_t signDataLen = 0;
(void)PackGetSubBuffer(pkt, dataOffset, &signDataLen, NULL);
uint32_t signLen = dataLen - signDataLen;
uint8_t *signBuf = NULL;
ret = PackReserveBytes(pkt, signLen, &signBuf);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint8_t *signData = NULL;
(void)PackGetSubBuffer(pkt, dataOffset, &signDataLen, &signData);
ret = SignKeyExchParams(ctx, signData, signDataLen, signBuf, &signLen);
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_PACK_SIGNATURE_ERR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15510, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"kx msg signature fail. ret %d", ret, 0, 0, 0);
return HITLS_PACK_SIGNATURE_ERR;
}
ret = PackSkipBytes(pkt, signLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_SUITE_KX_DHE */
#ifdef HITLS_TLS_FEATURE_PSK
static int32_t PackServerKxMsgPskIdentityHint(const TLS_Ctx *ctx, PackPacket *pkt)
{
uint8_t *pskIdentityHint = ctx->config.tlsConfig.pskIdentityHint;
/* The length of hintSize <= HITLS_IDENTITY_HINT_MAX_SIZE is ensured during configuration. Therefore, the length of
* uint16_t can be forcibly converted to the length of uint16_t */
uint16_t pskIdentityHintSize = (uint16_t)ctx->config.tlsConfig.hintSize;
/* append identity hint */
/* for dhe_psk, ecdhe_psk, msg must contain the length of hint even if there is no hint to provide */
int32_t ret = PackAppendUint16ToBuf(pkt, pskIdentityHintSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (pskIdentityHint != NULL && pskIdentityHintSize > 0) {
ret = PackAppendDataToBuf(pkt, pskIdentityHint, pskIdentityHintSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_PSK */
// Pack the ServerKeyExchange message.
int32_t PackServerKeyExchange(TLS_Ctx *ctx, PackPacket *pkt)
{
int32_t ret = HITLS_SUCCESS;
#ifdef HITLS_TLS_FEATURE_PSK
/* pack psk identity hint before dynamic key */
if (IsPskNegotiation(ctx)) {
ret = PackServerKxMsgPskIdentityHint(ctx, pkt);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif /* HITLS_TLS_FEATURE_PSK */
/* Pack a key exchange message */
switch (ctx->negotiatedInfo.cipherSuiteInfo.kxAlg) {
#ifdef HITLS_TLS_SUITE_KX_ECDHE
case HITLS_KEY_EXCH_ECDHE:
case HITLS_KEY_EXCH_ECDHE_PSK:
ret = PackServerKxMsgEcdhe(ctx, pkt);
break;
#endif
#ifdef HITLS_TLS_SUITE_KX_DHE
case HITLS_KEY_EXCH_DHE:
case HITLS_KEY_EXCH_DHE_PSK:
ret = PackServerKxMsgDhe(ctx, pkt);
break;
#endif /* HITLS_TLS_SUITE_KX_DHE */
#ifdef HITLS_TLS_SUITE_KX_RSA
case HITLS_KEY_EXCH_RSA_PSK:
case HITLS_KEY_EXCH_PSK:
/* for psk and rsa_psk nego, ServerKeyExchange msg contains only identity hint */
ret = HITLS_SUCCESS;
break;
#endif /* HITLS_TLS_SUITE_KX_RSA */
#ifdef HITLS_TLS_PROTO_TLCP11
case HITLS_KEY_EXCH_ECC:
ret = PackServerKxMsgEcc(ctx, pkt);
break;
#endif
default:
BSL_ERR_PUSH_ERROR(HITLS_PACK_UNSUPPORT_KX_ALG);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15513, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"unsupport key exchange algorithm when pack server key exchange msg.", 0, 0, 0, 0);
return HITLS_PACK_UNSUPPORT_KX_ALG;
}
return ret;
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#endif /* HITLS_TLS_HOST_SERVER */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/pack/src/pack_server_key_exchange.c | C | unknown | 21,382 |
/*
* 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 PARSE_H
#define PARSE_H
#include "hs_msg.h"
#include "tls.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Parse handshake message header
*
* @param ctx [IN] TLS context
* @param data [IN] Handshake message
* @param len [IN] Message length
* @param hsMsgInfo [OUT] Parsed handshake message header
*
* @return HITLS_SUCCESS
* For other error codes, see hitls_error.h
*/
int32_t HS_ParseMsgHeader(TLS_Ctx *ctx, const uint8_t *data, uint32_t len, HS_MsgInfo *hsMsgInfo);
/**
* @brief Parse the whole handshake message
* Used in pairs with HS_CleanMsg. After parsing, the data needs to be cleaned.
*
* @param ctx [IN] TLS context
* @param hsMsgInfo [IN] Handshake message
* @param hsMsg [OUT] Parsed complete handshake message
*
* @return HITLS_SUCCESS
* For other error codes, see hitls_error.h
*/
int32_t HS_ParseMsg(TLS_Ctx *ctx, const HS_MsgInfo *hsMsgInfo, HS_Msg *hsMsg);
/**
* @brief Clean handshake messages
* Used in pairs with HS_ParseMsg to release the memory allocated in hsMsg
*
* @param hsMsg [IN] Handshake message
*/
void HS_CleanMsg(HS_Msg *hsMsg);
/**
* @brief Check whether the type of the handshake message is expected
*
* @param ctx [IN] TLS context
* @param msgType [IN] Handshake message type
*
* @return HITLS_SUCCESS
* For other error codes, see hitls_error.h
*/
int32_t CheckHsMsgType(TLS_Ctx *ctx, HS_MsgType msgType);
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end PARSE_H */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/parse/include/parse.h | C | unknown | 2,093 |
/*
* 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.
*/
#include "securec.h"
#include "hitls_build.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls.h"
#include "hitls_error.h"
#include "hitls_config.h"
#include "tls.h"
#include "hs.h"
#include "hs_common.h"
#include "parse_msg.h"
#include "parse_common.h"
#include "hs_extensions.h"
#include "parse_extensions.h"
#ifdef HITLS_TLS_FEATURE_INDICATOR
#include "indicator.h"
#endif /* HITLS_TLS_FEATURE_INDICATOR */
typedef int32_t (*CheckHsMsgTypeFunc)(TLS_Ctx *ctx, const HS_MsgType msgType);
typedef struct {
HS_MsgType msgType;
CheckHsMsgTypeFunc checkCb;
} HsMsgTypeCheck;
#ifdef HITLS_TLS_PROTO_DTLS12
static int32_t CheckHelloVerifyRequestType(TLS_Ctx *ctx, const HS_MsgType msgType)
{
if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask) && msgType == SERVER_HELLO) {
(void)HS_ChangeState(ctx, TRY_RECV_SERVER_HELLO);
return HITLS_SUCCESS;
}
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17022, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Check hvr Type fail", 0, 0, 0, 0);
return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE;
}
#endif
static int32_t CheckServerHelloType(TLS_Ctx *ctx, const HS_MsgType msgType)
{
/* In DTLS, When client try to receive ServerHello message, it doesn't know if server enables
* isSupportDtlsCookieExchange. If client receives HelloVerifyRequest message, also valid */
if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask) && msgType == HELLO_VERIFY_REQUEST) {
(void)HS_ChangeState(ctx, TRY_RECV_HELLO_VERIFY_REQUEST);
return HITLS_SUCCESS;
}
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17331, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CheckServerHelloType fail", 0, 0, 0, 0);
return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE;
}
static int32_t CheckServerKeyExchangeType(TLS_Ctx *ctx, const HS_MsgType msgType)
{
/* When the PSK and RSA_PSK are used, whether the ServerKeyExchange message is received depends on whether the
* server sends a PSK identity hint */
if (ctx->hsCtx->kxCtx->keyExchAlgo == HITLS_KEY_EXCH_PSK ||
ctx->hsCtx->kxCtx->keyExchAlgo == HITLS_KEY_EXCH_RSA_PSK) {
if (msgType == CERTIFICATE_REQUEST) {
(void)HS_ChangeState(ctx, TRY_RECV_CERTIFICATE_REQUEST);
return HITLS_SUCCESS;
} else if (msgType == SERVER_HELLO_DONE) {
(void)HS_ChangeState(ctx, TRY_RECV_SERVER_HELLO_DONE);
return HITLS_SUCCESS;
}
}
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17025, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CheckServerKeyExchangeType fail", 0, 0, 0, 0);
return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE;
}
static int32_t CheckCertificateRequestType(TLS_Ctx *ctx, const HS_MsgType msgType)
{
uint32_t version = HS_GetVersion(ctx);
if (version == HITLS_VERSION_TLS13) {
if (msgType == CERTIFICATE) {
(void)HS_ChangeState(ctx, TRY_RECV_CERTIFICATE);
return HITLS_SUCCESS;
}
} else {
if (msgType == SERVER_HELLO_DONE) {
(void)HS_ChangeState(ctx, TRY_RECV_SERVER_HELLO_DONE);
return HITLS_SUCCESS;
}
}
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17026, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Check cert reqType fail", 0, 0, 0, 0);
return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE;
}
static const HsMsgTypeCheck g_checkHsMsgTypeList[] = {
[TRY_RECV_CLIENT_HELLO] = {.msgType = CLIENT_HELLO,
.checkCb = NULL},
[TRY_RECV_SERVER_HELLO] = {.msgType = SERVER_HELLO, .checkCb = CheckServerHelloType},
#ifdef HITLS_TLS_PROTO_DTLS12
[TRY_RECV_HELLO_VERIFY_REQUEST] = {.msgType = HELLO_VERIFY_REQUEST, .checkCb = CheckHelloVerifyRequestType},
#endif
[TRY_RECV_ENCRYPTED_EXTENSIONS] = {.msgType = ENCRYPTED_EXTENSIONS, .checkCb = NULL},
[TRY_RECV_CERTIFICATE] = {.msgType = CERTIFICATE, .checkCb = NULL},
[TRY_RECV_SERVER_KEY_EXCHANGE] = {.msgType = SERVER_KEY_EXCHANGE, .checkCb = CheckServerKeyExchangeType},
[TRY_RECV_CERTIFICATE_REQUEST] = {.msgType = CERTIFICATE_REQUEST, .checkCb = CheckCertificateRequestType},
[TRY_RECV_SERVER_HELLO_DONE] = {.msgType = SERVER_HELLO_DONE, .checkCb = NULL},
[TRY_RECV_CLIENT_KEY_EXCHANGE] = {.msgType = CLIENT_KEY_EXCHANGE, .checkCb = NULL},
[TRY_RECV_CERTIFICATE_VERIFY] = {.msgType = CERTIFICATE_VERIFY, .checkCb = NULL},
[TRY_RECV_NEW_SESSION_TICKET] = {.msgType = NEW_SESSION_TICKET, .checkCb = NULL},
[TRY_RECV_FINISH] = {.msgType = FINISHED, .checkCb = NULL},
[TRY_RECV_KEY_UPDATE] = {.msgType = KEY_UPDATE, .checkCb = NULL},
[TRY_RECV_HELLO_REQUEST] = {.msgType = HELLO_REQUEST, .checkCb = NULL},
};
int32_t CheckHsMsgType(TLS_Ctx *ctx, HS_MsgType msgType)
{
if (ctx->state != CM_STATE_HANDSHAKING && ctx->state != CM_STATE_RENEGOTIATION) {
return HITLS_SUCCESS;
}
if ((msgType == HELLO_REQUEST) && (ctx->isClient)) {
/* The HelloRequest message may appear at any time during the handshake.
The client should ignore this message */
return HITLS_SUCCESS;
}
HS_Ctx *hsCtx = ctx->hsCtx;
const char *expectedMsg = NULL;
if (msgType != g_checkHsMsgTypeList[hsCtx->state].msgType) {
if (g_checkHsMsgTypeList[hsCtx->state].checkCb == NULL ||
g_checkHsMsgTypeList[hsCtx->state].checkCb(ctx, msgType) != HITLS_SUCCESS) {
expectedMsg = HS_GetMsgTypeStr(g_checkHsMsgTypeList[hsCtx->state].msgType);
}
}
if (msgType == FINISHED && HS_GetVersion(ctx) != HITLS_VERSION_TLS13 &&
!(ctx->state == CM_STATE_HANDSHAKING && ctx->preState == CM_STATE_TRANSPORTING)) {
bool isCcsRecv = ctx->method.isRecvCCS(ctx);
if (isCcsRecv != true) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15349, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"recv finish but haven't recv ccs", 0, 0, 0, 0);
expectedMsg = HS_GetMsgTypeStr(FINISHED);
}
}
if (expectedMsg != NULL) {
BSL_LOG_BINLOG_VARLEN(BINLOG_ID16148, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Handshake state expect %s", expectedMsg);
BSL_LOG_BINLOG_VARLEN(BINLOG_ID16149, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
", but got %s.", HS_GetMsgTypeStr(msgType));
return ParseErrorProcess(ctx, HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE, 0,
NULL, ALERT_UNEXPECTED_MESSAGE);
}
return HITLS_SUCCESS;
}
static int32_t CheckHsMsgLen(TLS_Ctx *ctx, HS_MsgInfo *hsMsgInfo)
{
int32_t ret = HITLS_SUCCESS;
uint32_t headerLen = IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask) ?
DTLS_HS_MSG_HEADER_SIZE : HS_MSG_HEADER_SIZE;
uint32_t hsMsgOfSpecificTypeMaxSize = HS_MaxMessageSize(ctx, hsMsgInfo->type);
hsMsgOfSpecificTypeMaxSize = hsMsgOfSpecificTypeMaxSize > HITLS_HS_BUFFER_SIZE_LIMIT - headerLen ?
HITLS_HS_BUFFER_SIZE_LIMIT - headerLen : hsMsgOfSpecificTypeMaxSize;
if (hsMsgInfo->length > hsMsgOfSpecificTypeMaxSize) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16161, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"(D)TLS HS msg type: %d, parsed length: %u, max length: %u.", (int)hsMsgInfo->type, hsMsgInfo->length,
hsMsgOfSpecificTypeMaxSize, 0);
return ParseErrorProcess(ctx, HITLS_PARSE_EXCESSIVE_MESSAGE_SIZE, 0,
NULL, ALERT_ILLEGAL_PARAMETER);
}
ret = HS_GrowMsgBuf(ctx, headerLen + hsMsgInfo->length, true);
if (ret != HITLS_SUCCESS) {
return ret;
}
hsMsgInfo->rawMsg = ctx->hsCtx->msgBuf;
hsMsgInfo->headerAndBodyLen = headerLen + hsMsgInfo->length;
return ret;
}
#ifdef HITLS_TLS_PROTO_DTLS12
static int32_t DtlsParseHsMsgHeader(TLS_Ctx *ctx, const uint8_t *data, uint32_t len, HS_MsgInfo *hsMsgInfo)
{
const char *logStr = BINGLOG_STR("parse DTLS handshake msg header failed.");
if (len < DTLS_HS_MSG_HEADER_SIZE) {
return ParseErrorProcess(ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15599,
logStr, ALERT_DECODE_ERROR);
}
hsMsgInfo->type = data[0]; /* The 0 byte is the handshake message type */
if (hsMsgInfo->type >= HS_MSG_TYPE_END) {
BSL_ERR_PUSH_ERROR(HITLS_PARSE_UNSUPPORT_HANDSHAKE_MSG);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16123, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"DTLS invalid message type: %d.", hsMsgInfo->type, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
return HITLS_PARSE_UNSUPPORT_HANDSHAKE_MSG;
}
hsMsgInfo->length = BSL_ByteToUint24(&data[DTLS_HS_MSGLEN_ADDR]);
hsMsgInfo->sequence = BSL_ByteToUint16(&data[DTLS_HS_MSGSEQ_ADDR]);
hsMsgInfo->fragmentOffset = BSL_ByteToUint24(&data[DTLS_HS_FRAGMENT_OFFSET_ADDR]);
hsMsgInfo->fragmentLength = BSL_ByteToUint24(&data[DTLS_HS_FRAGMENT_LEN_ADDR]);
if (((hsMsgInfo->fragmentLength + hsMsgInfo->fragmentOffset) > hsMsgInfo->length) ||
((hsMsgInfo->length != 0) && (hsMsgInfo->fragmentLength == 0))) {
return ParseErrorProcess(ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15600,
logStr, ALERT_DECODE_ERROR);
}
return CheckHsMsgLen(ctx, hsMsgInfo);
}
#endif /* HITLS_TLS_PROTO_DTLS12 */
#ifdef HITLS_TLS_PROTO_TLS
static int32_t TlsParseHsMsgHeader(TLS_Ctx *ctx, const uint8_t *data, uint32_t len, HS_MsgInfo *hsMsgInfo)
{
const char *logStr = BINGLOG_STR("parse TLS handshake msg header failed.");
if (len < HS_MSG_HEADER_SIZE) {
return ParseErrorProcess(ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15601,
logStr, ALERT_DECODE_ERROR);
}
hsMsgInfo->type = data[0];
if (hsMsgInfo->type >= HS_MSG_TYPE_END) {
return ParseErrorProcess(ctx, HITLS_PARSE_UNSUPPORT_HANDSHAKE_MSG, BINLOG_ID16160,
logStr, ALERT_UNEXPECTED_MESSAGE);
}
int32_t ret = CheckHsMsgType(ctx, hsMsgInfo->type);
if (ret != HITLS_SUCCESS) {
return ret;
}
hsMsgInfo->length = BSL_ByteToUint24(data + sizeof(uint8_t)); /* Parse handshake body length */
hsMsgInfo->sequence = 0; /* TLS does not have this field */
hsMsgInfo->fragmentOffset = 0; /* TLS does not have this field */
hsMsgInfo->fragmentLength = 0; /* TLS does not have this field */
return CheckHsMsgLen(ctx, hsMsgInfo);
}
#endif /* HITLS_TLS_PROTO_TLS */
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
static int32_t ParseHandShakeMsg(TLS_Ctx *ctx, const uint8_t *data, uint32_t len, HS_Msg *hsMsg)
{
switch (hsMsg->type) {
case CLIENT_HELLO:
return ParseClientHello(ctx, data, len, hsMsg);
case SERVER_HELLO:
return ParseServerHello(ctx, data, len, hsMsg);
case HELLO_VERIFY_REQUEST:
return ParseHelloVerifyRequest(ctx, data, len, hsMsg);
case CERTIFICATE:
return ParseCertificate(ctx, data, len, hsMsg);
case SERVER_KEY_EXCHANGE:
return ParseServerKeyExchange(ctx, data, len, hsMsg);
case CERTIFICATE_REQUEST:
return ParseCertificateRequest(ctx, data, len, hsMsg);
case CLIENT_KEY_EXCHANGE:
return ParseClientKeyExchange(ctx, data, len, hsMsg);
case CERTIFICATE_VERIFY:
return ParseCertificateVerify(ctx, data, len, hsMsg);
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
case NEW_SESSION_TICKET:
return ParseNewSessionTicket(ctx, data, len, hsMsg);
#endif /* HITLS_TLS_FEATURE_SESSION_TICKET */
case FINISHED:
return ParseFinished(ctx, data, len, hsMsg);
case HELLO_REQUEST:
case SERVER_HELLO_DONE:
if (len != 0u) {
BSL_LOG_BINLOG_VARLEN(BINLOG_ID15603, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"msg %s", HS_GetMsgTypeStr(hsMsg->type));
return ParseErrorProcess(ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15611,
BINGLOG_STR("length is not zero"), ALERT_ILLEGAL_PARAMETER);
}
return HITLS_SUCCESS;
default:
break;
}
BSL_ERR_PUSH_ERROR(HITLS_PARSE_UNSUPPORT_HANDSHAKE_MSG);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15604, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"dtls parse handshake msg error, unsupport type[%d].", hsMsg->type, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
return HITLS_PARSE_UNSUPPORT_HANDSHAKE_MSG;
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#ifdef HITLS_TLS_PROTO_TLS13
int32_t Tls13ParseHandShakeMsg(TLS_Ctx *ctx, const uint8_t *hsBodyData, uint32_t hsBodyLen, HS_Msg *hsMsg)
{
switch (hsMsg->type) {
#ifdef HITLS_TLS_HOST_SERVER
case CLIENT_HELLO:
return ParseClientHello(ctx, hsBodyData, hsBodyLen, hsMsg);
#endif /* HITLS_TLS_HOST_SERVER */
#ifdef HITLS_TLS_HOST_CLIENT
case SERVER_HELLO:
return ParseServerHello(ctx, hsBodyData, hsBodyLen, hsMsg);
case ENCRYPTED_EXTENSIONS:
return ParseEncryptedExtensions(ctx, hsBodyData, hsBodyLen, hsMsg);
case CERTIFICATE_REQUEST:
return Tls13ParseCertificateRequest(ctx, hsBodyData, hsBodyLen, hsMsg);
case NEW_SESSION_TICKET:
return ParseNewSessionTicket(ctx, hsBodyData, hsBodyLen, hsMsg);
#endif /* HITLS_TLS_HOST_CLIENT */
case CERTIFICATE:
return Tls13ParseCertificate(ctx, hsBodyData, hsBodyLen, hsMsg);
case CERTIFICATE_VERIFY:
return ParseCertificateVerify(ctx, hsBodyData, hsBodyLen, hsMsg);
case FINISHED:
return ParseFinished(ctx, hsBodyData, hsBodyLen, hsMsg);
#ifdef HITLS_TLS_FEATURE_KEY_UPDATE
case KEY_UPDATE:
return ParseKeyUpdate(ctx, hsBodyData, hsBodyLen, hsMsg);
#endif /* HITLS_TLS_FEATURE_KEY_UPDATE */
case HELLO_REQUEST:
if (hsBodyLen != 0u) {
return ParseErrorProcess(ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15611,
BINGLOG_STR("hello request length is not zero"), ALERT_DECODE_ERROR);
}
return HITLS_SUCCESS;
default:
break;
}
BSL_ERR_PUSH_ERROR(HITLS_PARSE_UNSUPPORT_HANDSHAKE_MSG);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15605, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"recv unsupport handshake msg type[%d].", hsMsg->type, 0, 0, 0);
return HITLS_PARSE_UNSUPPORT_HANDSHAKE_MSG;
}
#endif /* HITLS_TLS_PROTO_TLS13 */
int32_t HS_ParseMsgHeader(TLS_Ctx *ctx, const uint8_t *data, uint32_t len, HS_MsgInfo *hsMsgInfo)
{
if ((ctx == NULL) || (ctx->method.sendAlert == NULL) || (data == NULL) || (hsMsgInfo == NULL)) {
return ParseErrorProcess(ctx, HITLS_INTERNAL_EXCEPTION, BINLOG_ID15606,
BINGLOG_STR("null input parameter"), ALERT_UNKNOWN);
}
uint32_t version = HS_GetVersion(ctx);
switch (version) {
#ifdef HITLS_TLS_PROTO_TLS
case HITLS_VERSION_TLS12:
case HITLS_VERSION_TLS13:
#ifdef HITLS_TLS_PROTO_TLCP11
case HITLS_VERSION_TLCP_DTLCP11:
#if defined(HITLS_TLS_PROTO_DTLCP11)
if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
return DtlsParseHsMsgHeader(ctx, data, len, hsMsgInfo);
}
#endif
#endif
return TlsParseHsMsgHeader(ctx, data, len, hsMsgInfo);
#endif /* HITLS_TLS_PROTO_TLS */
#ifdef HITLS_TLS_PROTO_DTLS12
case HITLS_VERSION_DTLS12:
return DtlsParseHsMsgHeader(ctx, data, len, hsMsgInfo);
#endif
default:
break;
}
BSL_ERR_PUSH_ERROR(HITLS_PARSE_UNSUPPORT_VERSION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15607, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"unsupport msg header version[0x%x].", version, 0, 0, 0);
return HITLS_PARSE_UNSUPPORT_VERSION;
}
int32_t HS_ParseMsg(TLS_Ctx *ctx, const HS_MsgInfo *hsMsgInfo, HS_Msg *hsMsg)
{
if ((ctx == NULL) || (ctx->method.sendAlert == NULL) || (hsMsgInfo == NULL) || (hsMsgInfo->rawMsg == NULL) ||
(hsMsg == NULL)) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15608, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"the input parameter pointer is null.", 0, 0, 0, 0);
return HITLS_INTERNAL_EXCEPTION;
}
hsMsg->type = hsMsgInfo->type;
hsMsg->length = hsMsgInfo->length;
hsMsg->sequence = hsMsgInfo->sequence;
hsMsg->fragmentOffset = hsMsgInfo->fragmentOffset;
hsMsg->fragmentLength = hsMsgInfo->fragmentLength;
uint32_t version = HS_GetVersion(ctx);
switch (version) {
#ifdef HITLS_TLS_PROTO_TLS_BASIC
case HITLS_VERSION_TLS12:
#ifdef HITLS_TLS_PROTO_TLCP11
case HITLS_VERSION_TLCP_DTLCP11:
#if defined(HITLS_TLS_PROTO_DTLCP11)
if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
return ParseHandShakeMsg(ctx, &hsMsgInfo->rawMsg[DTLS_HS_MSG_HEADER_SIZE], hsMsgInfo->length, hsMsg);
}
#endif
#endif
return ParseHandShakeMsg(ctx, &hsMsgInfo->rawMsg[HS_MSG_HEADER_SIZE], hsMsgInfo->length, hsMsg);
#endif /* HITLS_TLS_PROTO_TLS_BASIC */
#ifdef HITLS_TLS_PROTO_TLS13
case HITLS_VERSION_TLS13:
return Tls13ParseHandShakeMsg(ctx, &hsMsgInfo->rawMsg[HS_MSG_HEADER_SIZE], hsMsgInfo->length, hsMsg);
#endif /* HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_PROTO_DTLS12
case HITLS_VERSION_DTLS12:
return ParseHandShakeMsg(ctx, &hsMsgInfo->rawMsg[DTLS_HS_MSG_HEADER_SIZE], hsMsgInfo->length, hsMsg);
#endif
default:
break;
}
BSL_ERR_PUSH_ERROR(HITLS_PARSE_UNSUPPORT_VERSION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15609, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"unsupport handshake msg version[0x%x].", version, 0, 0, 0);
return HITLS_PARSE_UNSUPPORT_VERSION;
}
void HS_CleanMsg(HS_Msg *hsMsg)
{
if (hsMsg == NULL) {
return;
}
switch (hsMsg->type) {
#ifdef HITLS_TLS_HOST_SERVER
case CLIENT_HELLO:
return CleanClientHello(&hsMsg->body.clientHello);
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
case CLIENT_KEY_EXCHANGE:
return CleanClientKeyExchange(&hsMsg->body.clientKeyExchange);
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#endif /* HITLS_TLS_HOST_SERVER */
#ifdef HITLS_TLS_HOST_CLIENT
case SERVER_HELLO:
return CleanServerHello(&hsMsg->body.serverHello);
case HELLO_VERIFY_REQUEST:
return CleanHelloVerifyRequest(&hsMsg->body.helloVerifyReq);
case CERTIFICATE_REQUEST:
return CleanCertificateRequest(&hsMsg->body.certificateReq);
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
case SERVER_KEY_EXCHANGE:
return CleanServerKeyExchange(&hsMsg->body.serverKeyExchange);
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#ifdef HITLS_TLS_PROTO_TLS13
case ENCRYPTED_EXTENSIONS:
return CleanEncryptedExtensions(&hsMsg->body.encryptedExtensions);
#endif /* HITLS_TLS_PROTO_TLS13 */
#ifdef HITLS_TLS_FEATURE_SESSION_TICKET
case NEW_SESSION_TICKET:
return CleanNewSessionTicket(&hsMsg->body.newSessionTicket);
#endif /* HITLS_TLS_FEATURE_SESSION_TICKET */
#endif /* HITLS_TLS_HOST_CLIENT */
case CERTIFICATE:
return CleanCertificate(&hsMsg->body.certificate);
case CERTIFICATE_VERIFY:
return CleanCertificateVerify(&hsMsg->body.certificateVerify);
case FINISHED:
return CleanFinished(&hsMsg->body.finished);
case KEY_UPDATE:
case HELLO_REQUEST:
case SERVER_HELLO_DONE:
return;
default:
break;
}
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15610, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"clean unsupport handshake msg type[%d].", hsMsg->type, 0, 0, 0);
return;
}
#ifdef HITLS_TLS_FEATURE_CLIENT_HELLO_CB
int32_t HITLS_ClientHelloGetLegacyVersion(HITLS_Ctx *ctx, uint16_t *version)
{
if (ctx == NULL || version == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->hsCtx == NULL || ctx->hsCtx->hsMsg == NULL || ctx->hsCtx->hsMsg->type != CLIENT_HELLO) {
return HITLS_CALLBACK_CLIENT_HELLO_INVALID_CALL;
}
*version = ctx->hsCtx->hsMsg->body.clientHello.version;
return HITLS_SUCCESS;
}
int32_t HITLS_ClientHelloGetRandom(HITLS_Ctx *ctx, uint8_t **out, uint8_t *outlen)
{
if (ctx == NULL || out == NULL || outlen == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->hsCtx == NULL || ctx->hsCtx->hsMsg == NULL || ctx->hsCtx->hsMsg->type != CLIENT_HELLO) {
return HITLS_CALLBACK_CLIENT_HELLO_INVALID_CALL;
}
*out = ctx->hsCtx->hsMsg->body.clientHello.randomValue;
*outlen = RANDOM_SIZE;
return HITLS_SUCCESS;
}
int32_t HITLS_ClientHelloGetSessionID(HITLS_Ctx *ctx, uint8_t **out, uint8_t *outlen)
{
if (ctx == NULL || out == NULL || outlen == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->hsCtx == NULL || ctx->hsCtx->hsMsg == NULL || ctx->hsCtx->hsMsg->type != CLIENT_HELLO) {
return HITLS_CALLBACK_CLIENT_HELLO_INVALID_CALL;
}
*out = ctx->hsCtx->hsMsg->body.clientHello.sessionId;
*outlen = ctx->hsCtx->hsMsg->body.clientHello.sessionIdSize;
return HITLS_SUCCESS;
}
int32_t HITLS_ClientHelloGetCiphers(HITLS_Ctx *ctx, uint16_t **out, uint16_t *outlen)
{
if (ctx == NULL || out == NULL || outlen == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->hsCtx == NULL || ctx->hsCtx->hsMsg == NULL || ctx->hsCtx->hsMsg->type != CLIENT_HELLO) {
return HITLS_CALLBACK_CLIENT_HELLO_INVALID_CALL;
}
*out = ctx->hsCtx->hsMsg->body.clientHello.cipherSuites;
*outlen = ctx->hsCtx->hsMsg->body.clientHello.cipherSuitesSize;
return HITLS_SUCCESS;
}
int32_t HITLS_ClientHelloGetExtensionsPresent(HITLS_Ctx *ctx, uint16_t **out, uint8_t *outlen)
{
if (ctx == NULL || out == NULL || outlen == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->hsCtx == NULL || ctx->hsCtx->hsMsg == NULL || ctx->hsCtx->hsMsg->type != CLIENT_HELLO) {
return HITLS_CALLBACK_CLIENT_HELLO_INVALID_CALL;
}
uint32_t bufOffset = 0u;
uint8_t *buf = ctx->hsCtx->hsMsg->body.clientHello.extensionBuff;
uint32_t bufLen = ctx->hsCtx->hsMsg->body.clientHello.extensionBuffLen;
uint16_t *extPresent = BSL_SAL_Malloc(ctx->hsCtx->hsMsg->body.clientHello.extensionCount * sizeof(uint16_t));
if (extPresent == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17355, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"malloc extPresent fail.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
int32_t ret;
uint32_t extPresentCount = 0;
while (bufOffset < bufLen) {
uint16_t extMsgType = HS_EX_TYPE_END;
uint32_t extMsgLen = 0u;
ret = ParseExHeader(ctx, &buf[bufOffset], bufLen - bufOffset, &extMsgType, &extMsgLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(extPresent);
return ret;
}
bufOffset += HS_EX_HEADER_LEN;
extPresent[extPresentCount++] = extMsgType;
bufOffset += extMsgLen;
}
*out = extPresent;
*outlen = ctx->hsCtx->hsMsg->body.clientHello.extensionCount;
return HITLS_SUCCESS;
}
int32_t HITLS_ClientHelloGetExtension(HITLS_Ctx *ctx, uint16_t type, uint8_t **out, uint32_t *outlen)
{
if (ctx == NULL || out == NULL || outlen == NULL) {
return HITLS_NULL_INPUT;
}
if (ctx->hsCtx == NULL || ctx->hsCtx->hsMsg == NULL || ctx->hsCtx->hsMsg->type != CLIENT_HELLO) {
return HITLS_CALLBACK_CLIENT_HELLO_INVALID_CALL;
}
uint32_t bufOffset = 0u;
uint8_t *buf = ctx->hsCtx->hsMsg->body.clientHello.extensionBuff;
uint32_t bufLen = ctx->hsCtx->hsMsg->body.clientHello.extensionBuffLen;
int32_t ret;
while (bufOffset < bufLen) {
uint16_t extMsgType = HS_EX_TYPE_END;
uint32_t extMsgLen = 0u;
ret = ParseExHeader(ctx, &buf[bufOffset], bufLen - bufOffset, &extMsgType, &extMsgLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
bufOffset += HS_EX_HEADER_LEN;
if (extMsgType != type) {
/* If the extension type is not the one we are looking for, skip it */
bufOffset += extMsgLen;
continue;
}
*out = &buf[bufOffset];
*outlen = extMsgLen;
return HITLS_SUCCESS;
}
return HITLS_CALLBACK_CLIENT_HELLO_EXTENSION_NOT_FOUND;
}
#endif /* HITLS_TLS_FEATURE_CLIENT_HELLO_CB */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/parse/src/parse.c | C | unknown | 25,330 |
/*
* 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.
*/
#include "hitls_build.h"
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "hs_msg.h"
#include "hs_common.h"
#include "parse_msg.h"
#include "parse_common.h"
#include "hs_extensions.h"
#include "parse_extensions.h"
#include "custom_extensions.h"
/**
* @brief Parse the certificate signature
*
* @param ctx [IN] TLS context
* @param buf [IN] message to be parsed
* @param bufLen [IN] buffer length
* @param readLen [OUT] Parsed length
*
* @return Return the memory of the applied certificate. If NULL is returned, the parsing fails.
*/
int32_t ParseSingleCert(ParsePacket *pkt, CERT_Item **certItem)
{
uint32_t certLen = 0;
/* Obtain the certificate length */
int32_t ret = ParseBytesToUint24(pkt, &certLen);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15586,
BINGLOG_STR("Parse cert data len error."), ALERT_DECODE_ERROR);
}
if ((certLen == 0) || (certLen > (pkt->bufLen - *pkt->bufOffset))) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15587, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Parse cert data error: data len= %u, cert len= %u.", pkt->bufLen, certLen, 0, 0);
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, 0, NULL, ALERT_DECODE_ERROR);
}
CERT_Item *item = (CERT_Item*)BSL_SAL_Calloc(1u, sizeof(CERT_Item));
if (item == NULL) {
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15588,
BINGLOG_STR("CERT_Item malloc fail."), ALERT_UNKNOWN);
}
item->next = NULL;
item->dataSize = certLen; /* Update the length of the certificate message */
/* Extract the contents of the certificate message */
item->data = BSL_SAL_Malloc(item->dataSize);
if (item->data == NULL) {
BSL_SAL_FREE(item);
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15589,
BINGLOG_STR("item->data malloc fail."), ALERT_UNKNOWN);
}
(void)memcpy_s(item->data, item->dataSize, &pkt->buf[*pkt->bufOffset], item->dataSize);
*pkt->bufOffset += certLen;
*certItem = item;
return HITLS_SUCCESS;
}
static int32_t ParseCertExtension(ParsePacket *pkt, CertificateMsg *msg, CERT_Item *item, uint32_t certIndex)
{
(void)item;
(void)certIndex;
if (pkt->ctx->negotiatedInfo.version != HITLS_VERSION_TLS13) {
return HITLS_SUCCESS;
}
uint16_t certExLen = 0;
const char *logStr = BINGLOG_STR("length of certificate extension is incorrect.");
int32_t ret = ParseBytesToUint16(pkt, &certExLen);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15590, logStr, ALERT_DECODE_ERROR);
}
if (*pkt->bufOffset + certExLen > pkt->bufLen) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16235, logStr, ALERT_DECODE_ERROR);
}
uint32_t offset = 0;
while (offset < certExLen) {
uint16_t extMsgType = HS_EX_TYPE_END;
uint32_t extMsgLen = 0u;
ret = ParseExHeader(pkt->ctx, &pkt->buf[*pkt->bufOffset],
pkt->bufLen - *pkt->bufOffset, &extMsgType, &extMsgLen);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, ret, BINLOG_ID15330, logStr, ALERT_DECODE_ERROR);
}
*pkt->bufOffset += HS_EX_HEADER_LEN;
offset += HS_EX_HEADER_LEN;
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
if (IsParseNeedCustomExtensions(CUSTOM_EXT_FROM_CTX(pkt->ctx), extMsgType, HITLS_EX_TYPE_TLS1_3_CERTIFICATE)) {
HITLS_CERT_X509 *cert = SAL_CERT_X509Parse(LIBCTX_FROM_CTX(pkt->ctx),
ATTRIBUTE_FROM_CTX(pkt->ctx), &pkt->ctx->config.tlsConfig, item->data, item->dataSize,
TLS_PARSE_TYPE_BUFF, TLS_PARSE_FORMAT_ASN1);
if (cert == NULL) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15331,
"X509Parse fail", ALERT_DECODE_ERROR);
}
ret = ParseCustomExtensions(pkt->ctx, &pkt->buf[*pkt->bufOffset], extMsgType, extMsgLen,
HITLS_EX_TYPE_TLS1_3_CERTIFICATE, cert, certIndex);
SAL_CERT_X509Free(cert);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, ret, BINLOG_ID15332, "ParseCustomExtensions fail",
ALERT_DECODE_ERROR);
}
} else
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
{
msg->extensionTypeMask |= 1ULL << HS_GetExtensionTypeId(extMsgType);
}
*pkt->bufOffset += extMsgLen;
offset += extMsgLen;
}
if (offset != certExLen) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15463,
BINGLOG_STR("extension len error"), ALERT_DECODE_ERROR);
}
return HITLS_SUCCESS;
}
int32_t ParseCerts(ParsePacket *pkt, HS_Msg *hsMsg)
{
int32_t ret;
CertificateMsg *msg = &hsMsg->body.certificate;
CERT_Item *cur = msg->cert;
/* Parse the certificate message and save the certificate chain to the structure */
while (*pkt->bufOffset < pkt->bufLen) {
CERT_Item *item = NULL;
ret = ParseSingleCert(pkt, &item);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_CERT_ERR, BINLOG_ID15591,
BINGLOG_STR("parse certificate item fail."), ALERT_UNKNOWN);
}
/* Add the parsed certificate to the last node in the linked list */
if (msg->cert == NULL) {
msg->cert = item;
} else if (cur != NULL) {
cur->next = item;
}
cur = item;
ret = ParseCertExtension(pkt, msg, item, msg->certCount);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15592, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"parse certificate extension fail.", 0, 0, 0, 0);
return ret;
}
msg->certCount++;
}
return HITLS_SUCCESS;
}
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
/**
* @brief Parse the certificate message.
*
* @param ctx [IN] TLS context
* @param buf [IN] message buffer
* @param bufLen [IN] Maximum message length
* @param hsMsg [OUT] message structure
*
* @retval HITLS_SUCCESS parsed successfully.
* @retval HITLS_PARSE_CERT_ERR Failed to parse the certificate.
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect
*/
int32_t ParseCertificate(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HS_Msg *hsMsg)
{
uint32_t offset = 0;
uint32_t allCertsLen = 0;
ParsePacket pkt = {.ctx = ctx, .buf = buf, .bufLen = bufLen, .bufOffset = &offset};
const char *logStr = BINGLOG_STR("length of all certificates is incorrect.");
/* Obtain the lengths of all certificates */
int32_t ret = ParseBytesToUint24(&pkt, &allCertsLen);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt.ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15593, logStr, ALERT_DECODE_ERROR);
}
if (allCertsLen != (pkt.bufLen - CERT_LEN_TAG_SIZE)) {
return ParseErrorProcess(pkt.ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15594, logStr, ALERT_DECODE_ERROR);
}
/*
* The client can send a certificate message without a certificate, so if the total length of the certificate is 0,
* it directly returns success; If the client receives a certificate message of length 0, it is determined by the
* processing layer, which is only responsible for parsing
*/
if (allCertsLen == 0) {
return HITLS_SUCCESS;
}
ret = ParseCerts(&pkt, hsMsg);
if ((ret != HITLS_SUCCESS) || (*pkt.bufOffset != (allCertsLen + CERT_LEN_TAG_SIZE))) {
return ParseErrorProcess(pkt.ctx, HITLS_PARSE_CERT_ERR, BINLOG_ID15595,
BINGLOG_STR("Certificate msg parse failed."), ALERT_UNKNOWN);
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#ifdef HITLS_TLS_PROTO_TLS13
int32_t Tls13ParseCertificateReqCtx(ParsePacket *pkt, HS_Msg *hsMsg)
{
CertificateMsg *certMsg = &hsMsg->body.certificate;
/* Obtain the certificates_request_context_length */
uint8_t len = 0;
int32_t ret = ParseBytesToUint8(pkt, &len);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16971,
BINGLOG_STR("ParseBytesToUint8 fail"), ALERT_DECODE_ERROR);
}
uint16_t certReqCtxLen = (uint16_t)len;
certMsg->certificateReqCtxSize = (uint32_t)certReqCtxLen;
/* At least the length and content of the total certificate length of 3 bytes + certificateReqCtx can be parsed */
if (pkt->bufLen < CERT_LEN_TAG_SIZE + certReqCtxLen + sizeof(uint8_t)) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16129,
BINGLOG_STR("the length of tls13 certificate message is incorrect"), ALERT_DECODE_ERROR);
}
/* Obtain the certificate_request_context value */
if (certReqCtxLen > 0) {
certMsg->certificateReqCtx = BSL_SAL_Calloc(certReqCtxLen, sizeof(uint8_t));
if (certMsg->certificateReqCtx == NULL) {
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15596,
BINGLOG_STR("certificateReqCtx malloc fail."), ALERT_UNKNOWN);
}
(void)memcpy_s(certMsg->certificateReqCtx, certReqCtxLen, &pkt->buf[*pkt->bufOffset], certReqCtxLen);
*pkt->bufOffset += certReqCtxLen;
}
return HITLS_SUCCESS;
}
/**
* @brief Parse the certificate message.
*
* @param ctx [IN] TLS context
* @param buf [IN] message buffer
* @param bufLen [IN] Maximum message length
* @param hsMsg [OUT] message structure
*
* @retval HITLS_SUCCESS parsed successfully.
* @retval HITLS_PARSE_CERT_ERR Failed to parse the certificate.
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect.
*/
int32_t Tls13ParseCertificate(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HS_Msg *hsMsg)
{
CertificateMsg *certMsg = &hsMsg->body.certificate;
uint32_t offset = 0;
ParsePacket pkt = {.ctx = ctx, .buf = buf, .bufLen = bufLen, .bufOffset = &offset};
int32_t ret = Tls13ParseCertificateReqCtx(&pkt, hsMsg);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint32_t allCertsLen = 0;
ret = ParseBytesToUint24(&pkt, &allCertsLen);
if (ret != HITLS_SUCCESS || (allCertsLen != (pkt.bufLen - *pkt.bufOffset))) {
CleanCertificate(&hsMsg->body.certificate);
return ParseErrorProcess(pkt.ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15597,
BINGLOG_STR("length of all tls1.3 certificates is incorrect."), ALERT_DECODE_ERROR);
}
/*
* The client can send a certificate message without a certificate, so if the total length of the certificate is 0,
* it directly returns success; If the client receives a certificate message of length 0, it is determined by the
* processing layer, which is only responsible for parsing
*/
if (allCertsLen == 0) {
return HITLS_SUCCESS;
}
ret = ParseCerts(&pkt, hsMsg);
if ((ret != HITLS_SUCCESS) ||
(*pkt.bufOffset != (sizeof(uint8_t) + certMsg->certificateReqCtxSize + CERT_LEN_TAG_SIZE + allCertsLen))) {
CleanCertificate(&hsMsg->body.certificate);
return ParseErrorProcess(pkt.ctx, HITLS_PARSE_CERT_ERR, BINLOG_ID15598,
BINGLOG_STR("Certificate msg parse failed."), ALERT_UNKNOWN);
}
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS13 */
// Clear the memory applied for in the certificate message structure.
void CleanCertificate(CertificateMsg *msg)
{
if (msg == NULL) {
return;
}
#ifdef HITLS_TLS_PROTO_TLS13
BSL_SAL_FREE(msg->certificateReqCtx);
#endif
CERT_Item *next = msg->cert;
while (next != NULL) {
CERT_Item *temp = next->next;
BSL_SAL_FREE(next->data);
BSL_SAL_FREE(next);
next = temp;
}
msg->cert = NULL;
return;
}
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/parse/src/parse_certificate.c | C | unknown | 12,746 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_HOST_CLIENT
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "bsl_sal.h"
#include "bsl_list.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "hs_ctx.h"
#include "hs_msg.h"
#include "hs_common.h"
#include "parse_msg.h"
#include "hs_extensions.h"
#include "parse_extensions.h"
#include "parse_common.h"
#include "custom_extensions.h"
#if defined(HITLS_TLS_PROTO_TLS12) || defined(HITLS_TLS_PROTO_DTLS12) || defined(HITLS_TLS_PROTO_TLS13)
#define SINGLE_SIG_HASH_ALG_SIZE 2u
// Parse the signature algorithm field in the certificate request message.
static int32_t ParseSignatureAndHashAlgo(ParsePacket *pkt, CertificateRequestMsg *msg)
{
/* An extension of the same type has already been parsed */
if (msg->haveSignatureAndHashAlgo == true) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_DUPLICATE_EXTENDED_MSG, BINLOG_ID16945,
BINGLOG_STR("SignatureAndHashAlgo repeated"), ALERT_ILLEGAL_PARAMETER);
}
/* Obtain the length of the signature hash algorithm */
uint16_t signatureAndHashAlgLen = 0;
const char *logStr = BINGLOG_STR("parse signatureAndHashAlgLen fail.");
int32_t ret = ParseBytesToUint16(pkt, &signatureAndHashAlgLen);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15458, logStr, ALERT_DECODE_ERROR);
}
if (((uint32_t)signatureAndHashAlgLen > (pkt->bufLen - *pkt->bufOffset)) ||
((signatureAndHashAlgLen % SINGLE_SIG_HASH_ALG_SIZE) != 0u) || (signatureAndHashAlgLen == 0u)) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15459, logStr, ALERT_DECODE_ERROR);
}
/* Parse the length of the signature algorithm */
pkt->ctx->peerInfo.signatureAlgorithmsSize = signatureAndHashAlgLen / SINGLE_SIG_HASH_ALG_SIZE;
BSL_SAL_FREE(pkt->ctx->peerInfo.signatureAlgorithms);
pkt->ctx->peerInfo.signatureAlgorithms = (uint16_t *)BSL_SAL_Malloc(signatureAndHashAlgLen);
if (pkt->ctx->peerInfo.signatureAlgorithms == NULL) {
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15460,
BINGLOG_STR("signatureAlgorithms malloc fail"), ALERT_UNKNOWN);
}
/* Extract the signature algorithm */
for (uint16_t index = 0u; index < pkt->ctx->peerInfo.signatureAlgorithmsSize; index++) {
pkt->ctx->peerInfo.signatureAlgorithms[index] = BSL_ByteToUint16(&pkt->buf[*pkt->bufOffset]);
*pkt->bufOffset += sizeof(uint16_t);
}
msg->signatureAlgorithms = pkt->ctx->peerInfo.signatureAlgorithms;
msg->signatureAlgorithmsSize = pkt->ctx->peerInfo.signatureAlgorithmsSize;
msg->haveSignatureAndHashAlgo = true;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_PROTO_TLS12 || HITLS_TLS_PROTO_DTLS12 || HITLS_TLS_PROTO_TLS13 */
static void CaListNodeInnerDestroy(void *data)
{
HITLS_TrustedCANode *tmpData = (HITLS_TrustedCANode *)data;
BSL_SAL_FREE(tmpData->data);
BSL_SAL_FREE(tmpData);
return;
}
void FreeDNList(HITLS_TrustedCAList *caList)
{
BslList *tmpCaList = (BslList *)caList;
BSL_LIST_FREE(tmpCaList, CaListNodeInnerDestroy);
return;
}
HITLS_TrustedCANode *ParseDN(const uint8_t *data, uint32_t len)
{
HITLS_TrustedCANode *dnNode = (HITLS_TrustedCANode *)BSL_SAL_Calloc(1u, sizeof(HITLS_TrustedCANode));
if (dnNode == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15461, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"parse CA RDN error, out of memory.", 0, 0, 0, 0);
return NULL;
}
dnNode->caType = HITLS_TRUSTED_CA_X509_NAME;
dnNode->data = BSL_SAL_Dump(data, len);
if (dnNode->data == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15462, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"parse CA RDN error, dump %u bytes data fail.", len, 0, 0, 0);
BSL_SAL_FREE(dnNode);
return NULL;
}
dnNode->dataSize = len;
return dnNode;
}
HITLS_TrustedCAList *ParseDNList(const uint8_t *data, uint32_t len)
{
int32_t ret;
uint32_t dnLen;
uint32_t offset = 0u;
uint32_t distinguishedNamesLen = len;
HITLS_TrustedCANode *tmpNode = NULL;
HITLS_TrustedCAList *newCaList = BSL_LIST_New(sizeof(HITLS_TrustedCANode *));
if (newCaList == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15547, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"malloc CA List fail.", 0, 0, 0, 0);
return NULL;
}
while (distinguishedNamesLen > sizeof(uint16_t)) {
/* Parse the DN length */
dnLen = BSL_ByteToUint16(&data[offset]);
offset += sizeof(uint16_t);
/* Check whether the DN length is valid. */
if ((dnLen == 0) || dnLen > (len - offset)) {
BSL_ERR_PUSH_ERROR(HITLS_PARSE_INVALID_MSG_LEN);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15464, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"parse CA list error, distinguished name Length = %u, left len = %u.", dnLen, len - offset, 0, 0);
goto ERR;
}
tmpNode = ParseDN(&data[offset], dnLen);
if (tmpNode == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16947, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ParseDN fail", 0, 0, 0, 0);
goto ERR;
}
ret = BSL_LIST_AddElement(newCaList, tmpNode, BSL_LIST_POS_END);
if (ret != 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16948, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"AddElement fail", 0, 0, 0, 0);
BSL_SAL_FREE(tmpNode->data);
BSL_SAL_FREE(tmpNode);
goto ERR;
}
/* Offset to the next DN data block */
offset += dnLen;
distinguishedNamesLen = len - offset;
}
if (distinguishedNamesLen != 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16949, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"distinguishedNamesLen != 0", 0, 0, 0, 0);
goto ERR;
}
return newCaList;
ERR:
FreeDNList(newCaList);
return NULL;
}
// Parse the identification name field in the certificate request packet.
static int32_t ParseDistinguishedName(ParsePacket *pkt, CertificateRequestMsg *msg)
{
/* An extension of the same type has already been resolved */
if (msg->haveDistinguishedName == true) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_DUPLICATE_EXTENDED_MSG, BINLOG_ID16950,
BINGLOG_STR("DistinguishedName repeated"), ALERT_ILLEGAL_PARAMETER);
}
/* Obtain the DN list length */
uint16_t distinguishedNamesLen = 0;
const char *logStr = BINGLOG_STR("parse distinguishedNamesLen fail.");
int32_t ret = ParseBytesToUint16(pkt, &distinguishedNamesLen);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15465, logStr, ALERT_DECODE_ERROR);
}
if (distinguishedNamesLen != (pkt->bufLen - *pkt->bufOffset)) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15466, logStr, ALERT_DECODE_ERROR);
}
if (distinguishedNamesLen > 0u) {
if (pkt->ctx->peerInfo.caList != NULL) {
FreeDNList(pkt->ctx->peerInfo.caList);
pkt->ctx->peerInfo.caList = NULL;
}
pkt->ctx->peerInfo.caList = ParseDNList(&pkt->buf[*pkt->bufOffset], distinguishedNamesLen);
if (pkt->ctx->peerInfo.caList == NULL) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_CA_LIST_ERR, BINLOG_ID16951,
BINGLOG_STR("ParseDNList fail"), ALERT_DECODE_ERROR);
}
*pkt->bufOffset += distinguishedNamesLen;
}
msg->haveDistinguishedName = true;
return HITLS_SUCCESS;
}
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
// Parse the certificate type field in the certificate request message.
static int32_t ParseClientCertificateType(ParsePacket *pkt, CertificateRequestMsg *msg)
{
const char *logStr = BINGLOG_STR("parse certTypesSize fail.");
/* Obtain the certificate type length */
int32_t ret = ParseBytesToUint8(pkt, &msg->certTypesSize);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15455, logStr, ALERT_DECODE_ERROR);
}
if (((uint32_t)msg->certTypesSize > (pkt->bufLen - *pkt->bufOffset)) || (msg->certTypesSize == 0u)) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15456, logStr, ALERT_DECODE_ERROR);
}
/* Obtain the certificate type */
BSL_SAL_FREE(msg->certTypes);
msg->certTypes = BSL_SAL_Dump(&pkt->buf[*pkt->bufOffset], msg->certTypesSize);
if (msg->certTypes == NULL) {
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15457,
BINGLOG_STR("certTypes malloc fail"), ALERT_UNKNOWN);
}
*pkt->bufOffset += msg->certTypesSize;
return HITLS_SUCCESS;
}
int32_t ParseCertificateRequest(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HS_Msg *hsMsg)
{
uint32_t bufOffset = 0;
CertificateRequestMsg *msg = &hsMsg->body.certificateReq;
ParsePacket pkt = {.ctx = ctx, .buf = buf, .bufLen = bufLen, .bufOffset = &bufOffset};
int32_t ret = ParseClientCertificateType(&pkt, msg);
if (ret != HITLS_SUCCESS) {
return ret;
}
#if defined(HITLS_TLS_PROTO_TLS12) || defined(HITLS_TLS_PROTO_DTLS12)
if (pkt.ctx->negotiatedInfo.version >= HITLS_VERSION_TLS12) {
ret = ParseSignatureAndHashAlgo(&pkt, msg);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif /* HITLS_TLS_PROTO_TLS12 || HITLS_TLS_PROTO_DTLS12 */
return ParseDistinguishedName(&pkt, msg);
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#ifdef HITLS_TLS_PROTO_TLS13
static int32_t ParseCertificateRequestExBody(TLS_Ctx *ctx, uint16_t extMsgType, const uint8_t *buf, uint32_t extMsgLen,
CertificateRequestMsg *msg)
{
uint32_t bufOffset = 0u;
ParsePacket pkt = {.ctx = ctx, .buf = buf, .bufLen = extMsgLen, .bufOffset = &bufOffset};
switch (extMsgType) {
case HS_EX_TYPE_SIGNATURE_ALGORITHMS:
return ParseSignatureAndHashAlgo(&pkt, msg);
case HS_EX_TYPE_CERTIFICATE_AUTHORITIES:
return ParseDistinguishedName(&pkt, msg);
default:
break;
}
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
if (IsParseNeedCustomExtensions(CUSTOM_EXT_FROM_CTX(ctx), extMsgType, HITLS_EX_TYPE_TLS1_3_CERTIFICATE_REQUEST)) {
return ParseCustomExtensions(pkt.ctx, pkt.buf + *pkt.bufOffset, extMsgType, extMsgLen,
HITLS_EX_TYPE_TLS1_3_CERTIFICATE_REQUEST, NULL, 0);
}
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
return HITLS_SUCCESS;
}
int32_t ParseTls13CertificateRequestExtensions(ParsePacket *pkt, CertificateRequestMsg *msg)
{
if (pkt->bufLen - *pkt->bufOffset == 0u) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15472,
BINGLOG_STR("the extension len of tls1.3 can not be 0"), ALERT_DECODE_ERROR);
}
/* Parse the extended packet on the server */
while (*pkt->bufOffset < pkt->bufLen) {
uint16_t extMsgType = HS_EX_TYPE_END;
uint32_t extMsgLen = 0u;
int32_t ret =
ParseExHeader(pkt->ctx, &pkt->buf[*pkt->bufOffset], pkt->bufLen - *pkt->bufOffset, &extMsgType, &extMsgLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
*pkt->bufOffset += HS_EX_HEADER_LEN;
uint32_t extensionId = HS_GetExtensionTypeId(extMsgType);
ret = CheckForDuplicateExtension(msg->extensionTypeMask, extensionId, pkt->ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
msg->extensionTypeMask |= 1ULL << extensionId;
ret = ParseCertificateRequestExBody(pkt->ctx, extMsgType, &pkt->buf[*pkt->bufOffset], extMsgLen, msg);
if (ret != HITLS_SUCCESS) {
return ret;
}
*pkt->bufOffset += extMsgLen;
}
/* The extended content is the last field in the CertificateRequest packet. No further data should be displayed. If
* the parsed length is inconsistent with the cache length, an error code is returned */
if (*pkt->bufOffset != pkt->bufLen) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15473,
BINGLOG_STR("extension len error"), ALERT_DECODE_ERROR);
}
return HITLS_SUCCESS;
}
int32_t Tls13ParseCertificateRequest(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HS_Msg *hsMsg)
{
uint32_t bufOffset = 0;
CertificateRequestMsg *msg = &hsMsg->body.certificateReq;
ParsePacket pkt = {.ctx = ctx, .buf = buf, .bufLen = bufLen, .bufOffset = &bufOffset};
/* Obtain the certificate_request_context_length */
uint8_t certReqCtxLen = 0;
int32_t ret = ParseBytesToUint8(&pkt, &certReqCtxLen);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt.ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16130,
BINGLOG_STR("tls13 certReq length error"), ALERT_DECODE_ERROR);
}
msg->certificateReqCtxSize = (uint32_t)certReqCtxLen;
/* If the message length is incorrect, an error code is returned. */
if (*pkt.bufOffset + certReqCtxLen + sizeof(uint16_t) > pkt.bufLen) {
return ParseErrorProcess(pkt.ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16962,
BINGLOG_STR("certReq length err"), ALERT_DECODE_ERROR);
}
/* Obtain the certificate_request_context value */
if (certReqCtxLen > 0) {
msg->certificateReqCtx = BSL_SAL_Calloc(certReqCtxLen, sizeof(uint8_t));
if (msg->certificateReqCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16963, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc err", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
(void)memcpy_s(msg->certificateReqCtx, certReqCtxLen, &pkt.buf[*pkt.bufOffset], certReqCtxLen);
*pkt.bufOffset += certReqCtxLen;
}
/* Obtain the extended message length */
uint16_t exMsgLen = BSL_ByteToUint16(&pkt.buf[*pkt.bufOffset]);
*pkt.bufOffset += sizeof(uint16_t);
/* If the buffer length does not match the extended length, an error code is returned */
if (exMsgLen != (pkt.bufLen - *pkt.bufOffset)) {
BSL_SAL_FREE(msg->certificateReqCtx);
msg->certificateReqCtxSize = 0;
return ParseErrorProcess(pkt.ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15474,
BINGLOG_STR("tls13 external message length error"), ALERT_DECODE_ERROR);
}
ret = ParseTls13CertificateRequestExtensions(&pkt, msg);
if (ret != HITLS_SUCCESS) {
CleanCertificateRequest(msg);
}
return ret;
}
#endif /* HITLS_TLS_PROTO_TLS13 */
void CleanCertificateRequest(CertificateRequestMsg *msg)
{
if (msg == NULL) {
return;
}
BSL_SAL_FREE(msg->certTypes);
#ifdef HITLS_TLS_PROTO_TLS13
BSL_SAL_FREE(msg->certificateReqCtx);
BSL_SAL_FREE(msg->signatureAlgorithmsCert);
#endif /* HITLS_TLS_PROTO_TLS13 */
return;
}
#endif /* HITLS_TLS_HOST_CLIENT */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/parse/src/parse_certificate_request.c | C | unknown | 15,841 |
/*
* 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.
*/
#include "hitls_build.h"
#if defined(HITLS_TLS_HOST_SERVER) || defined(HITLS_TLS_PROTO_TLS13)
#include "tls_binlog_id.h"
#include "bsl_log.h"
#include "bsl_log_internal.h"
#include "bsl_err_internal.h"
#include "bsl_sal.h"
#include "bsl_bytes.h"
#include "crypt_algid.h"
#include "hitls_error.h"
#include "cert_method.h"
#include "hs_msg.h"
#include "hs_ctx.h"
#include "hs_verify.h"
#include "parse_msg.h"
#include "parse_common.h"
#include "config_type.h"
static int32_t CheckSignHashAlg(TLS_Ctx *ctx, uint16_t signHashAlg)
{
int32_t ret = CheckPeerSignScheme(ctx, ctx->hsCtx->peerCert, signHashAlg);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(ctx, ret, 0, NULL, ALERT_ILLEGAL_PARAMETER);
}
TLS_Config *config = &ctx->config.tlsConfig;
#ifdef HITLS_TLS_PROTO_TLS13
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLS13) {
const TLS_SigSchemeInfo *schemeInfo = ConfigGetSignatureSchemeInfo(config, signHashAlg);
if (schemeInfo == NULL || ((schemeInfo->certVersionBits & TLS13_VERSION_BIT) == 0)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16195, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"not allowed to use 0x%X signAlg tls1.3.", signHashAlg, 0, 0, 0);
return ParseErrorProcess(ctx, HITLS_PARSE_UNSUPPORT_SIGN_ALG, 0, NULL, ALERT_HANDSHAKE_FAILURE);
}
}
#endif /* HITLS_TLS_PROTO_TLS13 */
uint32_t i = 0;
for (i = 0; i < config->signAlgorithmsSize; i++) {
if (signHashAlg == config->signAlgorithms[i]) {
break;
}
}
if (i == config->signAlgorithmsSize) {
return ParseErrorProcess(ctx, HITLS_PARSE_UNSUPPORT_SIGN_ALG, BINLOG_ID15865,
BINGLOG_STR("the signHashAlg match failed"), ALERT_HANDSHAKE_FAILURE);
}
#ifdef HITLS_TLS_FEATURE_SECURITY
if (SECURITY_SslCheck(ctx, HITLS_SECURITY_SECOP_SIGALG_CHECK, 0, signHashAlg, NULL) != SECURITY_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17159, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"signHashAlg 0x%x SslCheck fail", signHashAlg, 0, 0, 0);
return ParseErrorProcess(ctx, HITLS_PARSE_UNSUPPORT_SIGN_ALG, 0, NULL, ALERT_HANDSHAKE_FAILURE);
}
#endif
return HITLS_SUCCESS;
}
static int32_t ParseCertificateVerifyPre(ParsePacket *pkt, uint16_t *signHashAlg)
{
const char *logStr = BINGLOG_STR("parse cert verifypre fail");
/* 2-byte signature hash algorithm + 2-byte signature data length.
If the message length is less than 4 bytes, a failure message is returned. */
if (pkt->bufLen < 4u) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16964, logStr, ALERT_DECODE_ERROR);
}
if (pkt->ctx->negotiatedInfo.version >= HITLS_VERSION_TLS12) {
int32_t ret = ParseBytesToUint16(pkt, signHashAlg);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16965, logStr, ALERT_DECODE_ERROR);
}
if (CheckSignHashAlg(pkt->ctx, *signHashAlg) != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(HITLS_PARSE_UNSUPPORT_SIGN_ALG);
return HITLS_PARSE_UNSUPPORT_SIGN_ALG;
}
}
return HITLS_SUCCESS;
}
static int32_t KeyMatchSignAlg(TLS_Ctx *ctx, HITLS_SignHashAlgo signScheme, HITLS_CERT_KeyType keyType,
HITLS_CERT_Key *key)
{
(void)key;
HITLS_CERT_KeyType certKeyType = SAL_CERT_SignScheme2CertKeyType(ctx, signScheme);
if (certKeyType != keyType) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16197, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"signScheme not matche key, signScheme is 0x%X, certKeyType is %u, keyType is %u", signScheme, certKeyType,
keyType, 0);
return ParseErrorProcess(ctx, HITLS_PARSE_UNSUPPORT_SIGN_ALG, 0, NULL, ALERT_ILLEGAL_PARAMETER);
}
/* check curve matches signature algorithm, only check ec key for tls1.3 */
if (ctx->negotiatedInfo.version != HITLS_VERSION_TLS13) {
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_PROTO_TLS13
HITLS_Config *config = &ctx->config.tlsConfig;
const TLS_SigSchemeInfo *schemeInfo = ConfigGetSignatureSchemeInfo(config, signScheme);
if (schemeInfo == NULL) {
return ParseErrorProcess(ctx, HITLS_PARSE_UNSUPPORT_SIGN_ALG, 0, NULL, ALERT_ILLEGAL_PARAMETER);
}
if (schemeInfo->paraId == CRYPT_PKEY_PARAID_MAX) {
return HITLS_SUCCESS;
}
int32_t paramId = CRYPT_PKEY_PARAID_MAX;
int32_t ret = SAL_CERT_KeyCtrl(config, key, CERT_KEY_CTRL_GET_PARAM_ID, NULL, (void *)¶mId);
if (ret != HITLS_SUCCESS || paramId != schemeInfo->paraId) {
return ParseErrorProcess(ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16198,
BINGLOG_STR("paramId mismatch sigScheme"), ALERT_INTERNAL_ERROR);
}
#endif /* HITLS_TLS_PROTO_TLS13 */
return HITLS_SUCCESS;
}
static int VerifySignData(TLS_Ctx *ctx, uint16_t signHashAlg, const uint8_t *sign, uint16_t signSize)
{
CERT_MgrCtx *mgrCtx = ctx->config.tlsConfig.certMgrCtx;
if (ctx->hsCtx == NULL || ctx->hsCtx->peerCert == NULL) {
return ParseErrorProcess(ctx, HITLS_PARSE_VERIFY_SIGN_FAIL, BINLOG_ID15866,
BINGLOG_STR("no peer certificate"), ALERT_CERTIFICATE_REQUIRED);
}
HITLS_CERT_X509 *cert = SAL_CERT_PairGetX509(ctx->hsCtx->peerCert);
HITLS_CERT_Key *pubkey = NULL;
int32_t ret = SAL_CERT_X509Ctrl(&ctx->config.tlsConfig, cert, CERT_CTRL_GET_PUB_KEY, NULL, (void *)&pubkey);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16966, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"GET_PUB_KEY fail", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return ret;
}
HITLS_SignHashAlgo signScheme = signHashAlg;
HITLS_CERT_KeyType keyType = TLS_CERT_KEY_TYPE_UNKNOWN;
ret = SAL_CERT_KeyCtrl(&ctx->config.tlsConfig, pubkey, CERT_KEY_CTRL_GET_TYPE, NULL, (void *)&keyType);
if (ret != HITLS_SUCCESS) {
SAL_CERT_KeyFree(mgrCtx, pubkey);
return ParseErrorProcess(ctx, ret, BINLOG_ID16072,
BINGLOG_STR("SAL_CERT_KeyCtrl fails"), ALERT_INTERNAL_ERROR);
}
if (signScheme == 0) {
/** If the value of the signature hash algorithm is 0, the peer does not send the signature algorithm.
In this case, we need to obtain the default signature algorithm through the certificate. */
signScheme = SAL_CERT_GetDefaultSignHashAlgo(keyType);
if (signScheme == CERT_SIG_SCHEME_UNKNOWN) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16073, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"no available signature scheme, key type = %u.", keyType, 0, 0, 0);
SAL_CERT_KeyFree(mgrCtx, pubkey);
return ParseErrorProcess(ctx, HITLS_PARSE_VERIFY_SIGN_FAIL, 0, NULL, ALERT_INTERNAL_ERROR);
}
}
/* check whether the signature scheme matches the certificate key */
if (KeyMatchSignAlg(ctx, signScheme, keyType, pubkey) != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16967, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"KeyMatchSignAlg fail", 0, 0, 0, 0);
SAL_CERT_KeyFree(mgrCtx, pubkey);
return HITLS_PARSE_VERIFY_SIGN_FAIL;
}
/** verifying certificate data */
ret = VERIFY_VerifySignData(ctx, pubkey, signScheme, sign, signSize);
SAL_CERT_KeyFree(mgrCtx, pubkey);
return ret;
}
int32_t ParseCertificateVerify(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HS_Msg *hsMsg)
{
uint16_t signHashAlg = 0;
uint32_t offset = 0;
ParsePacket pkt = {.ctx = ctx, .buf = buf, .bufLen = bufLen, .bufOffset = &offset};
int32_t ret = ParseCertificateVerifyPre(&pkt, &signHashAlg);
if (ret != HITLS_SUCCESS) {
return ret;
}
const char *logStr = BINGLOG_STR("parse cert verify fail");
uint16_t signSize = 0;
ret = ParseBytesToUint16(&pkt, &signSize);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt.ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16968, logStr, ALERT_DECODE_ERROR);
}
if ((signSize != (pkt.bufLen - *pkt.bufOffset)) || (signSize == 0)) {
return ParseErrorProcess(pkt.ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16969, logStr, ALERT_DECODE_ERROR);
}
const uint8_t *sign = &pkt.buf[*pkt.bufOffset];
ret = VerifySignData(pkt.ctx, signHashAlg, sign, signSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
CertificateVerifyMsg *msg = &hsMsg->body.certificateVerify;
msg->signHashAlg = signHashAlg;
msg->signSize = signSize;
BSL_SAL_FREE(msg->sign);
msg->sign = BSL_SAL_Dump(sign, signSize);
if (msg->sign == NULL) {
return ParseErrorProcess(pkt.ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID16970,
BINGLOG_STR("Dump fail"), ALERT_INTERNAL_ERROR);
}
pkt.ctx->peerInfo.peerSignHashAlg = signHashAlg;
return HITLS_SUCCESS;
}
void CleanCertificateVerify(CertificateVerifyMsg *msg)
{
if (msg == NULL) {
return;
}
BSL_SAL_FREE(msg->sign);
return;
}
#endif /* HITLS_TLS_HOST_CLIENT || HITLS_TLS_PROTO_TLS13 */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/parse/src/parse_certificate_verify.c | C | unknown | 9,669 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_HOST_SERVER
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "hitls_config.h"
#include "hs_msg.h"
#include "hs.h"
#include "parse_common.h"
#include "parse_extensions.h"
#include "parse_msg.h"
#define SINGLE_CIPHER_SUITE_SIZE 2u /* Length of the signature cipher suite */
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
static int32_t StoreClientCipherSuites(TLS_Ctx *ctx, ClientHelloMsg *msg)
{
uint32_t scsvCount = 0;
scsvCount += msg->haveEmptyRenegoScsvCipher ? 1 : 0;
scsvCount += msg->haveFallBackScsvCipher ? 1 : 0;
if (scsvCount == msg->cipherSuitesSize) {
BSL_SAL_FREE(ctx->peerInfo.cipherSuites);
ctx->peerInfo.cipherSuitesSize = 0;
return HITLS_SUCCESS;
}
uint32_t tmpSize = 0;
BSL_SAL_FREE(ctx->peerInfo.cipherSuites);
uint32_t peerCipherSuitesSize = ((uint32_t)msg->cipherSuitesSize - scsvCount) * sizeof(uint16_t);
ctx->peerInfo.cipherSuites = (uint16_t *)BSL_SAL_Malloc(peerCipherSuitesSize);
if (ctx->peerInfo.cipherSuites == NULL) {
BSL_SAL_FREE(msg->cipherSuites);
ctx->peerInfo.cipherSuitesSize = 0;
return ParseErrorProcess(ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID16237,
BINGLOG_STR("peer cipherSuites dump fail"), ALERT_UNKNOWN);
}
for (uint16_t index = 0u; index < msg->cipherSuitesSize; index++) {
if (msg->cipherSuites[index] == TLS_EMPTY_RENEGOTIATION_INFO_SCSV ||
msg->cipherSuites[index] == TLS_FALLBACK_SCSV) {
continue;
}
ctx->peerInfo.cipherSuites[tmpSize] = msg->cipherSuites[index];
tmpSize += 1;
}
ctx->peerInfo.cipherSuitesSize = (uint16_t)tmpSize;
return HITLS_SUCCESS;
}
#endif
/**
* @brief Parse the cipher suite list of Client Hello messages.
*
* @param pkt [IN] parse context
* @param msg [OUT] Client Hello Structure
*
* @retval HITLS_SUCCESS parsed successfully.
* @retval HITLS_MEMALLOC_FAIL Memory application failed.
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect.
*/
static int32_t ParseClientHelloCipherSuites(ParsePacket *pkt, ClientHelloMsg *msg)
{
uint16_t cipherSuitesLen = 0;
int32_t ret = ParseBytesToUint16(pkt, &cipherSuitesLen);
const char *logStr = BINGLOG_STR("parse cipherSuites failed.");
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15700,
logStr, ALERT_DECODE_ERROR);
}
if (((uint32_t)cipherSuitesLen > (pkt->bufLen - *pkt->bufOffset)) ||
(cipherSuitesLen % SINGLE_CIPHER_SUITE_SIZE) != 0u) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15342,
logStr, ALERT_DECODE_ERROR);
}
if (cipherSuitesLen == 0u) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15701,
logStr, ALERT_ILLEGAL_PARAMETER);
}
msg->cipherSuitesSize = cipherSuitesLen / SINGLE_CIPHER_SUITE_SIZE;
BSL_SAL_FREE(msg->cipherSuites);
msg->cipherSuites = (uint16_t *)BSL_SAL_Malloc(((uint32_t)msg->cipherSuitesSize) * sizeof(uint16_t));
if (msg->cipherSuites == NULL) {
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15702,
BINGLOG_STR("cipherSuites malloc fail"), ALERT_UNKNOWN);
}
/* Parse the cipher suite */
for (uint16_t index = 0u; index < msg->cipherSuitesSize; index++) {
msg->cipherSuites[index] = BSL_ByteToUint16(&pkt->buf[*pkt->bufOffset]);
*pkt->bufOffset += sizeof(uint16_t);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15703, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"got cipher suite from client:0x%x.", msg->cipherSuites[index], 0, 0, 0);
if (msg->cipherSuites[index] == TLS_EMPTY_RENEGOTIATION_INFO_SCSV) {
msg->haveEmptyRenegoScsvCipher = true;
}
if (msg->cipherSuites[index] == TLS_FALLBACK_SCSV) {
msg->haveFallBackScsvCipher = true;
}
}
#ifdef HITLS_TLS_CONNECTION_INFO_NEGOTIATION
ret = StoreClientCipherSuites(pkt->ctx, msg);
#endif
return ret;
}
/**
* @brief List of compression methods for parsing Client Hello messages
*
* @param pkt [IN] parse context
* @param msg [OUT] Client Hello Structure
*
* @retval HITLS_SUCCESS parsed successfully.
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect.
* @retval HITLS_MEMALLOC_FAIL Memory application failed.
*/
static int32_t ParseClientHelloCompressionMethods(ParsePacket *pkt, ClientHelloMsg *msg)
{
uint8_t compressionMethodsLen = 0;
const char *logStr = BINGLOG_STR("parse compressionMethod failed.");
int32_t ret = ParseBytesToUint8(pkt, &compressionMethodsLen);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15704,
logStr, ALERT_DECODE_ERROR);
}
if ((compressionMethodsLen > (pkt->bufLen - *pkt->bufOffset)) || (compressionMethodsLen == 0u)) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15705,
logStr, ALERT_DECODE_ERROR);
}
ret = ParseBytesToArray(pkt, &msg->compressionMethods, compressionMethodsLen);
if (ret == HITLS_MEMALLOC_FAIL) {
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID16146,
BINGLOG_STR("compressionMethods malloc fail."), ALERT_UNKNOWN);
}
msg->compressionMethodsSize = compressionMethodsLen;
for (uint32_t i = 0; i < compressionMethodsLen; i++) {
if (msg->compressionMethods[i] == 0u) {
return HITLS_SUCCESS;
}
}
return ParseErrorProcess(pkt->ctx, HITLS_MSG_HANDLE_INVALID_COMPRESSION_METHOD, BINLOG_ID16238,
logStr, ALERT_DECODE_ERROR);
}
/**
* @brief Parse the Client Hello extension messages.
*
* @param pkt [IN] parse context
* @param msg [OUT] Client Hello Structure
*
* @retval HITLS_SUCCESS parsed successfully.
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect.
* @retval HITLS_PARSE_DUPLICATE_EXTENSIVE_MSG Extended message
*/
static int32_t ParseClientHelloExtensions(ParsePacket *pkt, ClientHelloMsg *msg)
{
uint16_t exMsgLen = 0;
const char *logStr = BINGLOG_STR("parse extension length failed.");
int32_t ret = ParseBytesToUint16(pkt, &exMsgLen);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15707,
logStr, ALERT_DECODE_ERROR);
}
if (exMsgLen != (pkt->bufLen - *pkt->bufOffset)) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15708,
logStr, ALERT_DECODE_ERROR);
}
if (exMsgLen == 0u) {
return HITLS_SUCCESS;
}
return ParseClientExtension(pkt->ctx, &pkt->buf[*pkt->bufOffset], exMsgLen, msg);
}
int32_t ParseClientHello(TLS_Ctx *ctx, const uint8_t *data, uint32_t len, HS_Msg *hsMsg)
{
ClientHelloMsg *msg = &hsMsg->body.clientHello;
uint32_t bufOffset = 0;
ParsePacket pkt = {.ctx = ctx, .buf = data, .bufLen = len, .bufOffset = &bufOffset};
/* Parse the version number. The version number occupies two bytes */
int32_t ret = ParseVersion(&pkt, &msg->version);
if (ret != HITLS_SUCCESS) {
return ret;
}
ctx->negotiatedInfo.clientVersion = msg->version;
/* Parse the random number. The random number occupies 32 bytes */
ret = ParseRandom(&pkt, msg->randomValue, HS_RANDOM_SIZE);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = ParseSessionId(&pkt, &msg->sessionIdSize, &msg->sessionId);
if (ret != HITLS_SUCCESS) {
return ret;
}
#ifdef HITLS_TLS_PROTO_DTLS12
if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
/* Cookies need to be parsed in DTLS */
ret = ParseCookie(&pkt, &msg->cookieLen, &msg->cookie);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif
/* Parse the cipher suite. After the parsing is complete, update the msg->cipherSuitesSize and msg->cipherSuites */
ret = ParseClientHelloCipherSuites(&pkt, msg);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Parse compression method */
ret = ParseClientHelloCompressionMethods(&pkt, msg);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (len == bufOffset) {
return HITLS_SUCCESS;
}
return ParseClientHelloExtensions(&pkt, msg);
}
void CleanClientHello(ClientHelloMsg *msg)
{
// The value of msg->refCnt is not 0, indicating that the ClientHelloMsg resource is hosted in the hrr scenario
if (msg == NULL || msg->refCnt != 0) {
return;
}
BSL_SAL_FREE(msg->sessionId);
BSL_SAL_FREE(msg->cookie);
BSL_SAL_FREE(msg->cipherSuites);
BSL_SAL_FREE(msg->compressionMethods);
BSL_SAL_FREE(msg->extensionBuff);
CleanClientHelloExtension(msg);
return;
}
#endif /* HITLS_TLS_HOST_SERVER */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/parse/src/parse_client_hello.c | C | unknown | 9,663 |
/*
* 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.
*/
#include "hitls_build.h"
#ifdef HITLS_TLS_HOST_SERVER
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_bytes.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "hitls_error.h"
#include "hitls_crypt_type.h"
#include "hs_ctx.h"
#include "hs_msg.h"
#include "hs_common.h"
#include "parse_msg.h"
#include "parse_common.h"
#ifdef HITLS_TLS_SUITE_KX_ECDHE
/**
* @brief Parse the client ecdh message.
*
* @param ctx [IN] TLS context
* @param data [IN] message buffer
* @param len [IN] message buffer length
* @param hsMsg [OUT] Parsed message structure
*
* @retval HITLS_SUCCESS parsed successfully.
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect.
*/
static int32_t ParseClientKxMsgEcdhe(ParsePacket *pkt, ClientKeyExchangeMsg *msg)
{
const char *logStr = BINGLOG_STR("clientKeyEx length error.");
/* Compatible with OpenSSL, add 3 bytes to the client key exchange */
#ifdef HITLS_TLS_PROTO_TLCP11
if (pkt->ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
// Curve type + Curve ID + Public key length
uint8_t minLen = sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint8_t);
if (pkt->bufLen - *pkt->bufOffset < minLen) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16222,
logStr, ALERT_DECODE_ERROR);
}
// Ignore the three bytes
*pkt->bufOffset += sizeof(uint8_t) + sizeof(uint16_t);
}
#endif
uint8_t pubKeySize = 0;
int32_t ret = ParseOneByteLengthField(pkt, &pubKeySize, &msg->data);
if (ret == HITLS_PARSE_INVALID_MSG_LEN) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15635,
logStr, ALERT_DECODE_ERROR);
} else if (ret == HITLS_MEMALLOC_FAIL) {
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15637,
BINGLOG_STR("pubKey malloc fail."), ALERT_UNKNOWN);
}
if ((pkt->bufLen != *pkt->bufOffset) || (pubKeySize == 0)) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15636,
BINGLOG_STR("length of client ecdh pubKeySize is incorrect."), ALERT_DECODE_ERROR);
}
msg->dataSize = pubKeySize;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_SUITE_KX_ECDHE */
#ifdef HITLS_TLS_SUITE_KX_DHE
/**
* @brief Parse the Client Dhe message.
*
* @param ctx [IN] TLS context
* @param data [IN] message buffer
* @param len [IN] message buffer length
* @param hsMsg [OUT] Parsed message structure
*
* @retval HITLS_SUCCESS parsed successfully.
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect.
*/
static int32_t ParseClientKxMsgDhe(ParsePacket *pkt, ClientKeyExchangeMsg *msg)
{
uint16_t pubKeySize = 0;
int32_t ret = ParseTwoByteLengthField(pkt, &pubKeySize, &msg->data);
if (ret == HITLS_PARSE_INVALID_MSG_LEN) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15638,
BINGLOG_STR("clientKeyEx length error."), ALERT_DECODE_ERROR);
} else if (ret == HITLS_MEMALLOC_FAIL) {
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15640,
BINGLOG_STR("pubKey malloc fail."), ALERT_UNKNOWN);
}
if ((pkt->bufLen != *pkt->bufOffset) || (pubKeySize == 0)) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15639,
BINGLOG_STR("length of client dh pubKeySize is incorrect."), ALERT_DECODE_ERROR);
}
msg->dataSize = (uint32_t)pubKeySize;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_SUITE_KX_DHE */
#if defined(HITLS_TLS_SUITE_KX_RSA) || defined(HITLS_TLS_PROTO_TLCP11)
static int32_t ParseClientKxMsgRsa(ParsePacket *pkt, ClientKeyExchangeMsg *msg)
{
uint32_t encLen = pkt->bufLen - *pkt->bufOffset;
const char *logStr = BINGLOG_STR("Parse RSA Premaster Secret error.");
int32_t ret = 0;
uint16_t parsedEncLen = 0;
ret = ParseBytesToUint16(pkt, &parsedEncLen);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15641,
logStr, ALERT_DECODE_ERROR);
}
encLen = parsedEncLen;
if ((encLen != (pkt->bufLen - *pkt->bufOffset)) || (encLen == 0)) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15642,
logStr, ALERT_DECODE_ERROR);
}
ret = ParseBytesToArray(pkt, &msg->data, encLen);
if (ret == HITLS_MEMALLOC_FAIL) {
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15643,
BINGLOG_STR("pubKey malloc fail."), ALERT_UNKNOWN);
}
msg->dataSize = encLen;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_SUITE_KX_RSA || HITLS_TLS_PROTO_TLCP11 */
#ifdef HITLS_TLS_FEATURE_PSK
static int32_t ParseClientKxMsgIdentity(ParsePacket *pkt, ClientKeyExchangeMsg *msg)
{
uint16_t identityLen = 0;
int32_t ret = ParseBytesToUint16(pkt, &identityLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16972, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ParseBytesToUint16 fail, ret %d", ret, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_LENGTH);
return HITLS_CONFIG_INVALID_LENGTH;
}
if ((identityLen > pkt->bufLen - *pkt->bufOffset) || (identityLen > HS_PSK_IDENTITY_MAX_LEN)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16973, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"identityLen err", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_LENGTH);
return HITLS_CONFIG_INVALID_LENGTH;
}
uint8_t *identity = NULL;
if (identityLen != 0) {
identity = (uint8_t *)BSL_SAL_Calloc(1u, (identityLen + 1) * sizeof(uint8_t));
if (identity == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16974, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Calloc fail", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
(void)memcpy_s(identity, identityLen + 1, &pkt->buf[*pkt->bufOffset], identityLen);
}
msg->pskIdentity = identity;
msg->pskIdentitySize = identityLen;
*pkt->bufOffset += identityLen;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_PSK */
int32_t ParseClientKeyExchange(TLS_Ctx *ctx, const uint8_t *data, uint32_t len, HS_Msg *hsMsg)
{
int32_t ret;
uint32_t offset = 0u;
HS_Ctx *hsCtx = (HS_Ctx *)ctx->hsCtx;
ClientKeyExchangeMsg *msg = &hsMsg->body.clientKeyExchange;
ParsePacket pkt = {.ctx = ctx, .buf = data, .bufLen = len, .bufOffset = &offset};
#ifdef HITLS_TLS_FEATURE_PSK
if (IsPskNegotiation(ctx)) {
ret = ParseClientKxMsgIdentity(&pkt, msg);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif /* HITLS_TLS_FEATURE_PSK */
switch (hsCtx->kxCtx->keyExchAlgo) {
#ifdef HITLS_TLS_SUITE_KX_ECDHE
case HITLS_KEY_EXCH_ECDHE:
case HITLS_KEY_EXCH_ECDHE_PSK:
ret = ParseClientKxMsgEcdhe(&pkt, msg);
break;
#endif /* HITLS_TLS_SUITE_KX_ECDHE */
#ifdef HITLS_TLS_SUITE_KX_DHE
case HITLS_KEY_EXCH_DHE:
case HITLS_KEY_EXCH_DHE_PSK:
ret = ParseClientKxMsgDhe(&pkt, msg);
break;
#endif /* HITLS_TLS_SUITE_KX_DHE */
#if defined(HITLS_TLS_SUITE_KX_RSA) || defined(HITLS_TLS_PROTO_TLCP11)
case HITLS_KEY_EXCH_RSA:
case HITLS_KEY_EXCH_RSA_PSK:
case HITLS_KEY_EXCH_ECC:
ret = ParseClientKxMsgRsa(&pkt, msg);
break;
#endif /* HITLS_TLS_SUITE_KX_RSA || HITLS_TLS_PROTO_TLCP11 */
case HITLS_KEY_EXCH_PSK:
return HITLS_SUCCESS;
default:
ret = HITLS_PARSE_UNSUPPORT_KX_ALG;
break;
}
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15644, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"parse client key exchange msg fail.", 0, 0, 0, 0);
CleanClientKeyExchange(msg);
}
return ret;
}
void CleanClientKeyExchange(ClientKeyExchangeMsg *msg)
{
if (msg == NULL) {
return;
}
#ifdef HITLS_TLS_FEATURE_PSK
BSL_SAL_FREE(msg->pskIdentity);
#endif /* HITLS_TLS_FEATURE_PSK */
BSL_SAL_FREE(msg->data);
return;
}
#endif /* HITLS_TLS_PROTO_TLS_BASIC || HITLS_TLS_PROTO_DTLS12 */
#endif /* HITLS_TLS_HOST_SERVER */ | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/parse/src/parse_client_key_exchange.c | C | unknown | 9,004 |
/*
* 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.
*/
#include "hitls_build.h"
#include "securec.h"
#include "bsl_bytes.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "hitls_error.h"
#include "hs_ctx.h"
#include "parse_common.h"
int32_t ParseVersion(ParsePacket *pkt, uint16_t *version)
{
int32_t ret = ParseBytesToUint16(pkt, version);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15645,
BINGLOG_STR("parse version failed"), ALERT_DECODE_ERROR);
}
return HITLS_SUCCESS;
}
int32_t ParseRandom(ParsePacket *pkt, uint8_t *random, uint32_t randomSize)
{
int32_t ret = ParseCopyBytesToArray(pkt, random, randomSize);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15646,
BINGLOG_STR("parse random failed."), ALERT_DECODE_ERROR);
}
return HITLS_SUCCESS;
}
int32_t ParseSessionId(ParsePacket *pkt, uint8_t *idSize, uint8_t **id)
{
int32_t ret = ParseOneByteLengthField(pkt, idSize, id);
if (ret == HITLS_PARSE_INVALID_MSG_LEN) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15647,
BINGLOG_STR("parse sessionId failed."), ALERT_DECODE_ERROR);
} else if (ret == HITLS_MEMALLOC_FAIL) {
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15651,
BINGLOG_STR("sessionId malloc fail."), ALERT_UNKNOWN);
}
if (*idSize == 0u) {
return HITLS_SUCCESS;
}
/* According to RFC 5246, the length of sessionId cannot exceed 32 bytes */
if (*idSize > TLS_HS_MAX_SESSION_ID_SIZE) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15649,
BINGLOG_STR("sessionId length over 32."), ALERT_DECODE_ERROR);
}
/* The session ID length must be greater than or equal to 24 bytes according to the company security redline */
if (*idSize < TLS_HS_MIN_SESSION_ID_SIZE) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15650,
BINGLOG_STR("sessionId length less than 24."), ALERT_DECODE_ERROR);
}
return HITLS_SUCCESS;
}
int32_t ParseCookie(ParsePacket *pkt, uint8_t *cookieLen, uint8_t **cookie)
{
int32_t ret = ParseOneByteLengthField(pkt, cookieLen, cookie);
if (ret == HITLS_PARSE_INVALID_MSG_LEN) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15652,
BINGLOG_STR("parse cookie failed."), ALERT_DECODE_ERROR);
} else if (ret == HITLS_MEMALLOC_FAIL) {
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15654,
BINGLOG_STR("cookie malloc failed."), ALERT_UNKNOWN);
}
return HITLS_SUCCESS;
}
int32_t ParseBytesToUint8(ParsePacket *pkt, uint8_t *object)
{
if (pkt->bufLen - *pkt->bufOffset < sizeof(uint8_t)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16975, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "bufLen err", 0, 0, 0, 0);
return HITLS_PARSE_INVALID_MSG_LEN;
}
*object = (uint8_t)pkt->buf[*pkt->bufOffset];
*pkt->bufOffset += sizeof(uint8_t);
return HITLS_SUCCESS;
}
int32_t ParseBytesToUint16(ParsePacket *pkt, uint16_t *object)
{
if (pkt->bufLen - *pkt->bufOffset < sizeof(uint16_t)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16976, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "bufLen err", 0, 0, 0, 0);
return HITLS_PARSE_INVALID_MSG_LEN;
}
*object = BSL_ByteToUint16(&pkt->buf[*pkt->bufOffset]);
*pkt->bufOffset += sizeof(uint16_t);
return HITLS_SUCCESS;
}
int32_t ParseBytesToUint24(ParsePacket *pkt, uint32_t *object)
{
if (pkt->bufLen - *pkt->bufOffset < UINT24_SIZE) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16977, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "bufLen err", 0, 0, 0, 0);
return HITLS_PARSE_INVALID_MSG_LEN;
}
*object = BSL_ByteToUint24(&pkt->buf[*pkt->bufOffset]);
*pkt->bufOffset += UINT24_SIZE;
return HITLS_SUCCESS;
}
int32_t ParseBytesToUint32(ParsePacket *pkt, uint32_t *object)
{
if (pkt->bufLen - *pkt->bufOffset < sizeof(uint32_t)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16978, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "bufLen err", 0, 0, 0, 0);
return HITLS_PARSE_INVALID_MSG_LEN;
}
*object = BSL_ByteToUint32(&pkt->buf[*pkt->bufOffset]);
*pkt->bufOffset += sizeof(uint32_t);
return HITLS_SUCCESS;
}
int32_t ParseOneByteLengthField(ParsePacket *pkt, uint8_t *objectSize, uint8_t **object)
{
int32_t ret = ParseBytesToUint8(pkt, objectSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
return ParseBytesToArray(pkt, object, *objectSize);
}
int32_t ParseTwoByteLengthField(ParsePacket *pkt, uint16_t *objectSize, uint8_t **object)
{
int32_t ret = ParseBytesToUint16(pkt, objectSize);
if (ret != HITLS_SUCCESS) {
return ret;
}
return ParseBytesToArray(pkt, object, *objectSize);
}
int32_t ParseBytesToArray(ParsePacket *pkt, uint8_t **object, uint32_t length)
{
BSL_SAL_FREE(*object);
if (pkt->bufLen - *pkt->bufOffset < length) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16979, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "bufLen err", 0, 0, 0, 0);
return HITLS_PARSE_INVALID_MSG_LEN;
}
if (length == 0) {
return HITLS_SUCCESS;
}
*object = (uint8_t *)BSL_SAL_Malloc(length);
if (*object == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16980, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Malloc fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
(void)memcpy_s(*object, length, &pkt->buf[*pkt->bufOffset], length);
*pkt->bufOffset += length;
return HITLS_SUCCESS;
}
int32_t ParseCopyBytesToArray(ParsePacket *pkt, uint8_t *object, uint32_t length)
{
if (pkt->bufLen - *pkt->bufOffset < length) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16981, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "bufLen err", 0, 0, 0, 0);
return HITLS_PARSE_INVALID_MSG_LEN;
}
(void)memcpy_s(object, length, &pkt->buf[*pkt->bufOffset], length);
*pkt->bufOffset += length;
return HITLS_SUCCESS;
}
int32_t ParseErrorProcess(TLS_Ctx *ctx, int32_t err, uint32_t logId, const void *format,
ALERT_Description description)
{
BSL_ERR_PUSH_ERROR(err);
if (format != NULL) {
BSL_LOG_BINLOG_FIXLEN(logId, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, format, 0, 0, 0, 0);
}
if (description != ALERT_UNKNOWN) {
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, description);
}
return err;
}
int32_t CheckPeerSignScheme(HITLS_Ctx *ctx, CERT_Pair *peerCert, uint16_t signScheme)
{
if (peerCert == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_PARSE_UNSUPPORT_SIGN_ALG, BINLOG_ID17160, "peerCert null");
}
HITLS_Config *config = &ctx->config.tlsConfig;
HITLS_CERT_Key *pubkey = NULL;
int32_t ret = SAL_CERT_X509Ctrl(config, peerCert->cert, CERT_CTRL_GET_PUB_KEY, NULL, (void *)&pubkey);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID17140, "get pubkey fail");
}
uint32_t keyType = TLS_CERT_KEY_TYPE_UNKNOWN;
ret = SAL_CERT_KeyCtrl(config, pubkey, CERT_KEY_CTRL_GET_TYPE, NULL, (void *)&keyType);
SAL_CERT_KeyFree(config->certMgrCtx, pubkey);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID17099, "get pubkey type fail");
}
if (keyType != SAL_CERT_SignScheme2CertKeyType(ctx, signScheme)) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_PARSE_UNSUPPORT_SIGN_ALG, BINLOG_ID17156, "signScheme err");
}
return HITLS_SUCCESS;
}
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/parse/src/parse_common.c | C | unknown | 8,245 |
/*
* 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 PARSER_COMMON_H
#define PARSER_COMMON_H
#include <stdint.h>
#include "tls.h"
#include "hs_msg.h"
#include "cert_method.h"
#include "cert_mgr_ctx.h"
#include "security.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
TLS_Ctx *ctx;
const uint8_t *buf;
uint32_t bufLen;
uint32_t *bufOffset;
} ParsePacket;
/**
* @brief Parse the version of the message
*
* @param pkt [IN] Context for parsing
* @param version [OUT] Parsed version
*
* @retval HITLS_SUCCESS
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect
*/
int32_t ParseVersion(ParsePacket *pkt, uint16_t *version);
/**
* @brief Parse random number in message
*
* @param pkt [IN] Context for parsing
* @param random [OUT] Parsed random number
* @param randomSize [IN] Random number length
*
* @retval HITLS_SUCCESS
* @retval HITLS_MEMCPY_FAIL Memory Copy Failed
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect
*/
int32_t ParseRandom(ParsePacket *pkt, uint8_t *random, uint32_t randomSize);
/**
* @brief Parse SessionId in message
*
* @param pkt [IN] Context for parsing
* @param id [OUT] Parsed session ID
* @param idSize [OUT] Parsed session ID length
*
* @retval HITLS_SUCCESS
* @retval HITLS_MEMALLOC_FAIL Memory allocation failed
* @retval HITLS_MEMCPY_FAIL Memory Copy Failed
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect
*/
int32_t ParseSessionId(ParsePacket *pkt, uint8_t *idSize, uint8_t **id);
/**
* @brief Parse Cookie in message
*
* @param pkt [IN] Context for parsing
* @param cookie [OUT] Parsed cookie
* @param cookieLen [OUT] Parsed cookie length
*
* @retval HITLS_SUCCESS
* @retval HITLS_MEMALLOC_FAIL Memory allocation failed
* @retval HITLS_MEMCPY_FAIL Memory Copy Failed
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect
*/
int32_t ParseCookie(ParsePacket *pkt, uint8_t *cookieLen, uint8_t **cookie);
/**
* @brief Parse TrustCA list in message
*
* @param data [IN] TrustCAList message buffer
* @param buf [IN] TrustCAList message buffer length
*
* @retval HITLS_TrustedCAList * Pointer to the CAList header
*/
HITLS_TrustedCAList *ParseDNList(const uint8_t *data, uint32_t len);
/**
* @brief Free the buffer of TrustCAList
*
* @param listHead [IN] Pointer to the CAList header
*
* @retval void
*/
void FreeDNList(HITLS_TrustedCAList *caList);
/**
* @brief Parse uint8_t data
*
* @param pkt [IN] Context for parsing
* @param object [OUT] Parsed data
*
* @retval HITLS_SUCCESS success
* @retval HITLS_PARSE_INVALID_MSG_LEN bufLen is not enough
*/
int32_t ParseBytesToUint8(ParsePacket *pkt, uint8_t *object);
/**
* @brief Parse uint16_t data
*
* @param pkt [IN] Context for parsing
* @param object [OUT] Parsed data
*
* @retval HITLS_SUCCESS success
* @retval HITLS_PARSE_INVALID_MSG_LEN bufLen is not enough
*/
int32_t ParseBytesToUint16(ParsePacket *pkt, uint16_t *object);
/**
* @brief Parse 3 bytes data
*
* @param pkt [IN] Context for parsing
* @param object [OUT] Parsed data
*
* @retval HITLS_SUCCESS success
* @retval HITLS_PARSE_INVALID_MSG_LEN bufLen is not enough
*/
int32_t ParseBytesToUint24(ParsePacket *pkt, uint32_t *object);
/**
* @brief Parse uint32_t data
*
* @param pkt [IN] Context for parsing
* @param object [OUT] Parsed data
*
* @retval HITLS_SUCCESS success
* @retval HITLS_PARSE_INVALID_MSG_LEN bufLen is not enough
*/
int32_t ParseBytesToUint32(ParsePacket *pkt, uint32_t *object);
/**
* @brief Parse one byte length field, then parse the following content
*
* @param pkt [IN] Context for parsing
* @param objectSize [OUT] Parsed one byte data length
* @param object [OUT] Parsed data
*
* @retval HITLS_SUCCESS success
* @retval HITLS_PARSE_INVALID_MSG_LEN bufLen is not enough
*/
int32_t ParseOneByteLengthField(ParsePacket *pkt, uint8_t *objectSize, uint8_t **object);
/**
* @brief Parse two byte length field, then parse the following content
*
* @param pkt [IN] Context for parsing
* @param objectSize [OUT] Parsed one byte data length
* @param object [OUT] Parsed data
*
* @retval HITLS_SUCCESS success
* @retval HITLS_PARSE_INVALID_MSG_LEN bufLen is not enough
*/
int32_t ParseTwoByteLengthField(ParsePacket *pkt, uint16_t *objectSize, uint8_t **object);
/**
* @brief Parse data by length
*
* @param pkt [IN] Context for parsing
* @param object [OUT] Parsed data, need memory allocation
* @param length [IN] Length of data need be parsed
*
* @retval HITLS_SUCCESS success
* @retval HITLS_PARSE_INVALID_MSG_LEN bufLen is not enough
*/
int32_t ParseBytesToArray(ParsePacket *pkt, uint8_t **object, uint32_t length);
/**
* @brief Parse data by length
*
* @param pkt [IN] Context for parsing
* @param object [OUT] Parsed data, do not need memory allocation
* @param length [IN] Length of data need be parsed
*
* @retval HITLS_SUCCESS success
* @retval HITLS_PARSE_INVALID_MSG_LEN bufLen is not enough
*/
int32_t ParseCopyBytesToArray(ParsePacket *pkt, uint8_t *object, uint32_t length);
/**
* @brief Error processing function in parse module
*
* @param ctx [IN] TLS context
* @param err [IN] Error code need to be pushed and returned
* @param logId [IN] binlogid
* @param format [IN] Message for log function
* @param description [IN] Alert description
* @retval error code
*/
int32_t ParseErrorProcess(TLS_Ctx *ctx, int32_t err, uint32_t logId, const void *format, ALERT_Description description);
/**
* @brief Check whether the peer certificate matches the peer signature algorithm.
*
* @param ctx [IN] TLS context
* @param peerCert [IN] peerCert
* @param signScheme [IN] peer signScheme
* @retval error code
*/
int32_t CheckPeerSignScheme(HITLS_Ctx *ctx, CERT_Pair *peerCert, uint16_t signScheme);
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end PARSER_COMMON_H */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/parse/src/parse_common.h | C | unknown | 6,553 |
/*
* 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.
*/
#include "hitls_build.h"
#if defined(HITLS_TLS_HOST_CLIENT) && defined(HITLS_TLS_PROTO_TLS13)
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "tls.h"
#include "rec.h"
#include "hs.h"
#include "hs_extensions.h"
#include "hs_common.h"
#include "parse_extensions.h"
#include "parse_common.h"
#include "custom_extensions.h"
/**
* @brief Release the memory in the message structure.
*
* @param msg [IN] message structure
*/
void CleanEncryptedExtensions(EncryptedExtensions *msg)
{
if (msg == NULL) {
return;
}
BSL_SAL_FREE(msg->supportedGroups);
#ifdef HITLS_TLS_FEATURE_ALPN
BSL_SAL_FREE(msg->alpnSelected);
#endif /* HITLS_TLS_FEATURE_ALPN */
return;
}
static int32_t ParseEncryptedSupportGroups(ParsePacket *pkt, EncryptedExtensions *msg)
{
/* Has parsed extensions of the same type */
if (msg->haveSupportedGroups == true) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_DUPLICATE_EXTENDED_MSG, BINLOG_ID15709,
BINGLOG_STR("ClientSupportGroups repeated"), ALERT_ILLEGAL_PARAMETER);
}
uint16_t groupLen = 0;
const char *logStr = BINGLOG_STR("parse supported groups len fail.");
int32_t ret = ParseBytesToUint16(pkt, &groupLen);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15710, logStr, ALERT_DECODE_ERROR);
}
groupLen /= sizeof(uint16_t);
/* If the length of the message does not match the extended length, or the length is 0,
the handshake message error is returned */
if (((groupLen * sizeof(uint16_t)) != (pkt->bufLen - sizeof(uint16_t))) || (groupLen == 0)) {
return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15711, logStr, ALERT_DECODE_ERROR);
}
BSL_SAL_FREE(msg->supportedGroups);
msg->supportedGroups = (uint16_t *)BSL_SAL_Malloc(groupLen * sizeof(uint16_t));
if (msg->supportedGroups == NULL) {
return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15712,
BINGLOG_STR("supportedGroups malloc fail"), ALERT_UNKNOWN);
}
for (uint32_t i = 0; i < groupLen; i++) {
msg->supportedGroups[i] = BSL_ByteToUint16(&pkt->buf[*pkt->bufOffset]);
*pkt->bufOffset += sizeof(uint16_t);
}
msg->supportedGroupsSize = groupLen;
msg->haveSupportedGroups = true;
return HITLS_SUCCESS;
}
static int32_t ParseEncryptedExBody(TLS_Ctx *ctx, uint16_t extMsgType, const uint8_t *buf, uint32_t extMsgLen,
EncryptedExtensions *msg)
{
uint32_t bufOffset = 0u;
ParsePacket pkt = {.ctx = ctx, .buf = buf, .bufLen = extMsgLen, .bufOffset = &bufOffset};
switch (extMsgType) {
case HS_EX_TYPE_SUPPORTED_GROUPS:
return ParseEncryptedSupportGroups(&pkt, msg);
case HS_EX_TYPE_EARLY_DATA:
return ParseEmptyExtension(ctx, HS_EX_TYPE_EARLY_DATA, extMsgLen, &msg->haveEarlyData);
case HS_EX_TYPE_SERVER_NAME:
return ParseEmptyExtension(ctx, HS_EX_TYPE_SERVER_NAME, extMsgLen, &msg->haveServerName);
case HS_EX_TYPE_SIGNATURE_ALGORITHMS:
case HS_EX_TYPE_KEY_SHARE:
case HS_EX_TYPE_PRE_SHARED_KEY:
case HS_EX_TYPE_STATUS_REQUEST:
case HS_EX_TYPE_STATUS_REQUEST_V2:
case HS_EX_TYPE_PSK_KEY_EXCHANGE_MODES:
case HS_EX_TYPE_COOKIE:
case HS_EX_TYPE_SUPPORTED_VERSIONS:
case HS_EX_TYPE_CERTIFICATE_AUTHORITIES:
case HS_EX_TYPE_POST_HS_AUTH:
case HS_EX_TYPE_SIGNATURE_ALGORITHMS_CERT:
return ParseErrorProcess(ctx, HITLS_PARSE_UNSUPPORTED_EXTENSION, BINLOG_ID16239,
BINGLOG_STR("Illegal extension received"), ALERT_ILLEGAL_PARAMETER);
#ifdef HITLS_TLS_FEATURE_ALPN
case HS_EX_TYPE_APP_LAYER_PROTOCOLS:
return ParseServerSelectedAlpnProtocol(
&pkt, &msg->haveSelectedAlpn, &msg->alpnSelected, &msg->alpnSelectedSize);
#endif /* HITLS_TLS_FEATURE_ALPN */
default:
break;
}
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
if (IsParseNeedCustomExtensions(CUSTOM_EXT_FROM_CTX(ctx), extMsgType, HITLS_EX_TYPE_ENCRYPTED_EXTENSIONS)) {
return ParseCustomExtensions(pkt.ctx, pkt.buf + *pkt.bufOffset, extMsgType, extMsgLen,
HITLS_EX_TYPE_ENCRYPTED_EXTENSIONS, NULL, 0);
}
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
return ParseErrorProcess(ctx, HITLS_PARSE_UNSUPPORTED_EXTENSION, BINLOG_ID16982,
"unknow extension received", ALERT_UNSUPPORTED_EXTENSION);
}
// Parse the EncryptedExtensions extension message
int32_t ParseEncryptedEx(TLS_Ctx *ctx, EncryptedExtensions *msg, const uint8_t *buf, uint32_t bufLen)
{
uint32_t bufOffset = 0u;
int32_t ret;
while (bufOffset < bufLen) {
uint32_t extMsgLen = 0u;
uint16_t extMsgType = HS_EX_TYPE_END;
ret = ParseExHeader(ctx, &buf[bufOffset], bufLen - bufOffset, &extMsgType, &extMsgLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
bufOffset += HS_EX_HEADER_LEN;
uint32_t extensionId = HS_GetExtensionTypeId(extMsgType);
ret = CheckForDuplicateExtension(msg->extensionTypeMask, extensionId, ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (extensionId != HS_EX_TYPE_ID_UNRECOGNIZED
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
|| !IsParseNeedCustomExtensions(CUSTOM_EXT_FROM_CTX(ctx), extMsgType, HITLS_EX_TYPE_ENCRYPTED_EXTENSIONS)
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
) {
msg->extensionTypeMask |= 1ULL << extensionId;
/* check whether the extension that is not sent is received. */
if (!GetExtensionFlagValue(ctx, extensionId)) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_EXTENSION_TYPE);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17329, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"client did not send but get extension type %u.", extensionId, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNSUPPORTED_EXTENSION);
return HITLS_MSG_HANDLE_UNSUPPORT_EXTENSION_TYPE;
}
}
ret = ParseEncryptedExBody(ctx, extMsgType, &buf[bufOffset], extMsgLen, msg);
if (ret != HITLS_SUCCESS) {
return ret;
}
bufOffset += extMsgLen;
}
if (bufOffset != bufLen) {
return ParseErrorProcess(ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16239,
BINGLOG_STR("encrypted extensions len incorrect"), ALERT_DECODE_ERROR);
}
return HITLS_SUCCESS;
}
// Parse the EncryptedExtensions message.
int32_t ParseEncryptedExtensions(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HS_Msg *hsMsg)
{
if ((buf == NULL) || (hsMsg == NULL)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16983, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
/* Parse the EncryptedExtensions extension message */
EncryptedExtensions *msg = &hsMsg->body.encryptedExtensions;
uint32_t bufOffset = 0u;
ParsePacket pkt = {.ctx = ctx, .buf = buf, .bufLen = bufLen, .bufOffset = &bufOffset};
/* Obtain the extended message length */
uint16_t exMsgLen = 0;
const char *logStr = BINGLOG_STR("parse encrypted Extensions len fail.");
int32_t ret = ParseBytesToUint16(&pkt, &exMsgLen);
if (ret != HITLS_SUCCESS) {
return ParseErrorProcess(pkt.ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16128, logStr, ALERT_DECODE_ERROR);
}
if (pkt.bufLen - *pkt.bufOffset != exMsgLen) {
return ParseErrorProcess(pkt.ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15715, logStr, ALERT_DECODE_ERROR);
}
return ParseEncryptedEx(pkt.ctx, msg, &pkt.buf[*pkt.bufOffset], exMsgLen);
}
#endif /* HITLS_TLS_HOST_CLIENT && HITLS_TLS_PROTO_TLS13 */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/parse/src/parse_encrypted_extensions.c | C | unknown | 8,601 |
/*
* 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.
*/
#include "hitls_build.h"
#include "securec.h"
#include "tls_binlog_id.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_sal.h"
#include "bsl_err_internal.h"
#include "bsl_bytes.h"
#include "hitls_error.h"
#include "tls.h"
#include "hs.h"
#include "hs_ctx.h"
#include "hs_extensions.h"
#include "parse_common.h"
#include "parse_extensions.h"
// Parse an empty extended message.
int32_t ParseEmptyExtension(TLS_Ctx *ctx, uint16_t extMsgType, uint32_t extMsgLen, bool *haveExtension)
{
/* Parsed extensions of the same type */
if (*haveExtension) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15120, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"extension message type:%d len:%lu in hello message is repeated.", extMsgType, extMsgLen, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_ILLEGAL_PARAMETER);
BSL_ERR_PUSH_ERROR(HITLS_PARSE_DUPLICATE_EXTENDED_MSG);
return HITLS_PARSE_DUPLICATE_EXTENDED_MSG;
}
/* Parse the empty extended message */
if (extMsgLen != 0u) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15121, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"extension message type:%d len:%lu in hello message is nonzero.", extMsgType, extMsgLen, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_DECODE_ERROR);
BSL_ERR_PUSH_ERROR(HITLS_PARSE_INVALID_MSG_LEN);
return HITLS_PARSE_INVALID_MSG_LEN;
}
*haveExtension = true;
return HITLS_SUCCESS;
}
int32_t ParseExCookie(const uint8_t *buf, uint32_t bufLen, uint8_t **cookie, uint16_t *cookieLen)
{
*cookie = NULL; // Initialize the function entry to prevent wild pointers
uint32_t bufOffset = 0;
if (bufLen < sizeof(uint16_t)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17007, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "bufLen error", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_PARSE_INVALID_MSG_LEN);
return HITLS_PARSE_INVALID_MSG_LEN;
}
/* Extract the cookie length */
uint32_t tmpCookieLen = BSL_ByteToUint16(&buf[bufOffset]);
bufOffset += sizeof(uint16_t);
/* If the cookie length is incorrect, an error code is returned */
if (tmpCookieLen != (bufLen - bufOffset) || tmpCookieLen == 0u) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17008, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "bufLen error", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_PARSE_INVALID_MSG_LEN);
return HITLS_PARSE_INVALID_MSG_LEN;
}
/* Obtain the cookie */
uint8_t *tmpCookie = BSL_SAL_Dump(&buf[bufOffset], tmpCookieLen);
if (tmpCookie == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15161, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "cookie malloc fail.", 0, 0,
0, 0);
return HITLS_MEMALLOC_FAIL;
}
*cookie = tmpCookie;
*cookieLen = (uint16_t)tmpCookieLen;
return HITLS_SUCCESS;
}
#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
int32_t ParseSecRenegoInfo(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, uint8_t **secRenegoInfo,
uint8_t *secRenegoInfoSize)
{
/* The message length is not enough to parse secRenegoInfo */
if (bufLen < sizeof(uint8_t)) {
BSL_ERR_PUSH_ERROR(HITLS_PARSE_INVALID_MSG_LEN);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15184, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"extension message length (renegotiation info) in client hello message is incorrect.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_DECODE_ERROR);
return HITLS_PARSE_INVALID_MSG_LEN;
}
/* Parse the length of secRenegoInfo */
uint32_t bufOffset = 0;
uint8_t tmpSize = buf[bufOffset];
bufOffset++;
if (tmpSize != (bufLen - bufOffset)) {
BSL_ERR_PUSH_ERROR(HITLS_PARSE_INVALID_MSG_LEN);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15185, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"the renegotiation info size in the hello messag is incorrect.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_DECODE_ERROR);
return HITLS_PARSE_INVALID_MSG_LEN;
}
if (tmpSize == 0) {
return HITLS_SUCCESS;
}
/* Parse secRenegoInfo */
uint8_t *tmpInfo = (uint8_t *)BSL_SAL_Dump(&buf[bufOffset], tmpSize);
if (tmpInfo == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15186, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"secRenegoInfo malloc fail when parse renegotiation info.", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return HITLS_MEMALLOC_FAIL;
}
*secRenegoInfo = tmpInfo;
*secRenegoInfoSize = tmpSize;
return HITLS_SUCCESS;
}
#endif /* defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12) */
/**
* @brief Parse the extended message type and length.
*
* @param ctx [IN] TLS context
* @param buf [IN] message buffer, starting from the extension type.
* @param bufLen [IN] Packet length
* @param extMsgType [OUT] Extended message type
* @param extMsgLen [OUT] Extended message length
*
* @retval HITLS_SUCCESS parsed successfully.
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect.
* @retval HITLS_MEMALLOC_FAIL Memory application failed.
* @retval HITLS_PARSE_DUPLICATE_EXTENSIVE_MSG Extended message
*/
int32_t ParseExHeader(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, uint16_t *extMsgType, uint32_t *extMsgLen)
{
if (bufLen < HS_EX_HEADER_LEN) {
BSL_ERR_PUSH_ERROR(HITLS_PARSE_INVALID_MSG_LEN);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15189, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"the extension len of client hello msg is incorrect", 0, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_DECODE_ERROR);
return HITLS_PARSE_INVALID_MSG_LEN;
}
uint32_t bufOffset = 0u;
uint16_t type = 0u;
uint32_t len = 0u;
/* Obtain the message type */
type = BSL_ByteToUint16(&buf[bufOffset]);
bufOffset += sizeof(uint16_t);
/* Obtain the message length */
len = BSL_ByteToUint16(&buf[bufOffset]);
bufOffset += sizeof(uint16_t);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15190, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"get extension message in hello, type:%d len:%lu.", type, len, 0, 0);
if (len > (bufLen - bufOffset)) {
BSL_ERR_PUSH_ERROR(HITLS_PARSE_INVALID_MSG_LEN);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15191, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"extension message type:%d len:%lu in hello message is incorrect.", type, len, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_DECODE_ERROR);
return HITLS_PARSE_INVALID_MSG_LEN;
}
/* Update the extended message type and length */
*extMsgType = type;
*extMsgLen = len;
return HITLS_SUCCESS;
}
int32_t ParseDupExtProcess(TLS_Ctx *ctx, uint32_t logId, const void *format)
{
BSL_ERR_PUSH_ERROR(HITLS_PARSE_DUPLICATE_EXTENDED_MSG);
if (format != NULL) {
BSL_LOG_BINLOG_VARLEN(logId, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "extension type %s is repeated.",
format);
}
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_ILLEGAL_PARAMETER);
return HITLS_PARSE_DUPLICATE_EXTENDED_MSG;
}
int32_t ParseErrorExtLengthProcess(TLS_Ctx *ctx, uint32_t logId, const void *format)
{
BSL_ERR_PUSH_ERROR(HITLS_PARSE_INVALID_MSG_LEN);
if (format != NULL) {
BSL_LOG_BINLOG_VARLEN(logId, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"%s extension message length is incorrect", format);
}
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_DECODE_ERROR);
return HITLS_PARSE_INVALID_MSG_LEN;
}
bool GetExtensionFlagValue(TLS_Ctx *ctx, uint32_t hsExTypeId)
{
switch (hsExTypeId) {
case HS_EX_TYPE_ID_SERVER_NAME: return ctx->hsCtx->extFlag.haveServerName;
case HS_EX_TYPE_ID_SUPPORTED_GROUPS: return ctx->hsCtx->extFlag.haveSupportedGroups;
case HS_EX_TYPE_ID_POINT_FORMATS: return ctx->hsCtx->extFlag.havePointFormats;
case HS_EX_TYPE_ID_SIGNATURE_ALGORITHMS: return ctx->hsCtx->extFlag.haveSignatureAlgorithms;
case HS_EX_TYPE_ID_EXTENDED_MASTER_SECRET: return ctx->hsCtx->extFlag.haveExtendedMasterSecret;
case HS_EX_TYPE_ID_SUPPORTED_VERSIONS: return ctx->hsCtx->extFlag.haveSupportedVers;
case HS_EX_TYPE_ID_CERTIFICATE_AUTHORITIES: return ctx->hsCtx->extFlag.haveCA;
case HS_EX_TYPE_ID_POST_HS_AUTH: return ctx->hsCtx->extFlag.havePostHsAuth;
case HS_EX_TYPE_ID_KEY_SHARE: return ctx->hsCtx->extFlag.haveKeyShare;
case HS_EX_TYPE_ID_EARLY_DATA: return ctx->hsCtx->extFlag.haveEarlyData;
case HS_EX_TYPE_ID_PSK_KEY_EXCHANGE_MODES: return ctx->hsCtx->extFlag.havePskExMode;
case HS_EX_TYPE_ID_PRE_SHARED_KEY: return ctx->hsCtx->extFlag.havePreShareKey;
case HS_EX_TYPE_ID_APP_LAYER_PROTOCOLS: return ctx->hsCtx->extFlag.haveAlpn;
case HS_EX_TYPE_ID_SESSION_TICKET: return ctx->hsCtx->extFlag.haveTicket;
case HS_EX_TYPE_ID_ENCRYPT_THEN_MAC: return ctx->hsCtx->extFlag.haveEncryptThenMac;
case HS_EX_TYPE_ID_SIGNATURE_ALGORITHMS_CERT: return ctx->hsCtx->extFlag.haveSignatureAlgorithmsCert;
case HS_EX_TYPE_ID_COOKIE:
case HS_EX_TYPE_ID_RENEGOTIATION_INFO:
default:
break;
}
return true;
}
int32_t CheckForDuplicateExtension(uint64_t extensionTypeMask, uint32_t extensionId, TLS_Ctx *ctx)
{
// can not process duplication unknown ext, unknown ext is verified elsewhere
if (((extensionTypeMask & (1ULL << extensionId)) != 0) && extensionId != HS_EX_TYPE_ID_UNRECOGNIZED) {
BSL_ERR_PUSH_ERROR(HITLS_PARSE_DUPLICATE_EXTENDED_MSG);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17328, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"extension type %u is repeated.", extensionId, 0, 0, 0);
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_ILLEGAL_PARAMETER);
return HITLS_PARSE_DUPLICATE_EXTENDED_MSG;
}
return HITLS_SUCCESS;
} | 2302_82127028/openHiTLS-examples_1508 | tls/handshake/parse/src/parse_extensions.c | C | unknown | 10,840 |
/*
* 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 PARSE_EXTENSIONS_H
#define PARSE_EXTENSIONS_H
#include <stdint.h>
#include "tls.h"
#include "hs_msg.h"
#include "parse_common.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Parse Client Hello extension
*
* @attention The input parameter pointer can't be NULL
* If parsing fails, the invoker releases the allocated memory
*
* @param ctx [IN] TLS context
* @param buf [IN] Message buffer, starting from the extension type
* @param bufLen [IN] Message length
* @param msg [OUT] Parsed message
*
* @retval HITLS_SUCCESS
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect
* @retval HITLS_MEMALLOC_FAIL Memory allocation failed
* @retval HITLS_PARSE_DUPLICATE_EXTENDED_MSG Extension duplicated
*/
int32_t ParseClientExtension(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, ClientHelloMsg *msg);
/**
* @brief Release the buffer in the Client Hello extension structure
*
* @param msg [IN] Message structure
*/
void CleanClientHelloExtension(ClientHelloMsg *msg);
/**
* @brief Parse server hello extension
*
* @attention The input parameter pointer can't be NULL
* If the parsing fails, the invoker releases the allocated memory
*
* @param ctx [IN] TLS context
* @param buf [IN] Message buffer, starting from the extension type
* @param bufLen [IN] Message length
* @param msg [OUT] Parsed message
*
* @retval HITLS_SUCCESS
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect
* @retval HITLS_MEMALLOC_FAIL Memory allocation failed
* @retval HITLS_PARSE_DUPLICATE_EXTENDED_MSG Extension duplicated
* @retval HITLS_PARSE_UNSUPPORTED_EXTENSION Unsupported extension
*/
int32_t ParseServerExtension(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, ServerHelloMsg *msg);
/**
* @brief Parse extension type and length
*
* @param ctx [IN] TLS context
* @param buf [IN] Message buffer, starting from the extension type
* @param bufLen [IN] Message length
* @param extMsgType [OUT] Extension type
* @param extMsgLen [OUT] Extension length
*
* @retval HITLS_SUCCESS
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect
* @retval HITLS_MEMALLOC_FAIL Memory allocation failed
* @retval HITLS_PARSE_DUPLICATE_EXTENDED_MSG Extension duplicated
*/
int32_t ParseExHeader(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, uint16_t *extMsgType, uint32_t *extMsgLen);
/**
* @brief Release the buffer in the Server Hello extension structure
*
* @param msg [IN] Message structure
*/
void CleanServerHelloExtension(ServerHelloMsg *msg);
/**
* @brief Parse empty extension
*
* @param ctx [IN] TLS context
* @param extMsgType [IN] Extension type
* @param extMsgLen [IN] Extension length
* @param haveExtension [OUT] Indicates whether there are extensions
*
* @retval HITLS_SUCCESS
* @retval HITLS_PARSE_INVALID_MSG_LEN The message length is incorrect
* @retval HITLS_PARSE_DUPLICATE_EXTENDED_MSG Extension duplicated
*/
int32_t ParseEmptyExtension(TLS_Ctx *ctx, uint16_t extMsgType, uint32_t extMsgLen, bool *haveExtension);
int32_t ParseExCookie(const uint8_t *buf, uint32_t bufLen, uint8_t **cookie, uint16_t *cookieLen);
int32_t ParseSecRenegoInfo(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, uint8_t **secRenegoInfo,
uint8_t *secRenegoInfoSize);
int32_t ParseServerSelectedAlpnProtocol(
ParsePacket *pkt, bool *haveSelectedAlpn, uint8_t **alpnSelected, uint16_t *alpnSelectedSize);
/**
* @brief Error process in duplicated extension
*
* @param ctx [IN] TLS context
* @param logId [IN] binlogid
* @param format [IN] Message for log function
* @retval HITLS_PARSE_DUPLICATE_EXTENDED_MSG
*/
int32_t ParseDupExtProcess(TLS_Ctx *ctx, uint32_t logId, const void *format);
/**
* @brief Parse extension length error
*
* @param ctx [IN] TLS context
* @param logId [IN] binlogid
* @param format [IN] Message for log function
* @retval HITLS_PARSE_INVALID_MSG_LEN
*/
int32_t ParseErrorExtLengthProcess(TLS_Ctx *ctx, uint32_t logId, const void *format);
bool GetExtensionFlagValue(TLS_Ctx *ctx, uint32_t hsExTypeId);
int32_t CheckForDuplicateExtension(uint64_t extensionTypeMask, uint32_t extensionId, TLS_Ctx *ctx);
#ifdef __cplusplus
}
#endif /* end __cplusplus */
#endif /* end PARSE_EXTENSIONS_H */
| 2302_82127028/openHiTLS-examples_1508 | tls/handshake/parse/src/parse_extensions.h | C | unknown | 4,895 |