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.
*/
/* BEGIN_HEADER */
/* INCLUDE_BASE test_suite_tls13_consistency_rfc8446 */
#include <stdio.h>
#include "stub_replace.h"
#include "hitls.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_uio.h"
#include "tls.h"
#include "hs_ctx.h"
#include "pack.h"
#include "send_process.h"
#include "frame_link.h"
#include "frame_tls.h"
#include "frame_io.h"
#include "simulate_io.h"
#include "parser_frame_msg.h"
#include "rec_wrapper.h"
#include "cert.h"
#include "securec.h"
#include "process.h"
#include "conn_init.h"
#include "hitls_crypt_init.h"
#include "hitls_psk.h"
#include "common_func.h"
#include "alert.h"
#include "bsl_sal.h"
#include "hs_extensions.h"
/* END_HEADER */
#define MAX_BUF 16384
typedef struct {
uint16_t version;
BSL_UIO_TransportType uioType;
HITLS_Config *config;
HITLS_Config *s_config;
HITLS_Config *c_config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_Session *clientSession;
} ResumeTestInfo;
static int32_t DoHandshake(ResumeTestInfo *testInfo)
{
HITLS_CFG_SetCheckKeyUsage(testInfo->config, false);
testInfo->client = FRAME_CreateLink(testInfo->config, testInfo->uioType);
if (testInfo->client == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
if (testInfo->clientSession != NULL) {
int32_t ret = HITLS_SetSession(testInfo->client->ssl, testInfo->clientSession);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
testInfo->server = FRAME_CreateLink(testInfo->config, testInfo->uioType);
if (testInfo->server == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
return FRAME_CreateConnection(testInfo->client, testInfo->server, true, HS_STATE_BUTT);
}
typedef enum {
WITHOUT_PSK,
PRE_CONFIG_PSK,
SESSION_RESUME_PSK
} PskStatus;
static void Test_PskConnect(uint32_t serverMode, PskStatus pskStatus)
{
FRAME_Init();
ResumeTestInfo testInfo = {0};
testInfo.uioType = BSL_UIO_TCP;
testInfo.config = HITLS_CFG_NewTLS13Config();
HITLS_CFG_SetKeyExchMode(testInfo.config, TLS13_KE_MODE_PSK_ONLY | TLS13_KE_MODE_PSK_WITH_DHE);
if (pskStatus == SESSION_RESUME_PSK) {
testInfo.client = FRAME_CreateLink(testInfo.config, testInfo.uioType);
testInfo.server = FRAME_CreateLink(testInfo.config, testInfo.uioType);
ASSERT_EQ(FRAME_CreateConnection(testInfo.client, testInfo.server, true, HS_STATE_BUTT), HITLS_SUCCESS);
testInfo.clientSession = HITLS_GetDupSession(testInfo.client->ssl);
ASSERT_TRUE(testInfo.clientSession != NULL);
FRAME_FreeLink(testInfo.client);
testInfo.client = NULL;
FRAME_FreeLink(testInfo.server);
testInfo.server = NULL;
testInfo.client = FRAME_CreateLink(testInfo.config, testInfo.uioType);
HITLS_SetSession(testInfo.client->ssl, testInfo.clientSession);
} else if (pskStatus == PRE_CONFIG_PSK) {
uint16_t cipherSuite = HITLS_AES_128_GCM_SHA256;
HITLS_CFG_SetCipherSuites(testInfo.config, &cipherSuite, 1);
HITLS_CFG_SetPskClientCallback(testInfo.config, (HITLS_PskClientCb)ExampleClientCb);
HITLS_CFG_SetPskServerCallback(testInfo.config, (HITLS_PskServerCb)ExampleServerCb);
testInfo.client = FRAME_CreateLink(testInfo.config, testInfo.uioType);
} else {
testInfo.client = FRAME_CreateLink(testInfo.config, testInfo.uioType);
}
HITLS_CFG_SetKeyExchMode(testInfo.config, serverMode);
testInfo.server = FRAME_CreateLink(testInfo.config, testInfo.uioType);
ASSERT_EQ(FRAME_CreateConnection(testInfo.client, testInfo.server, false, HS_STATE_BUTT), HITLS_SUCCESS);
uint8_t isReused = 0;
ASSERT_EQ(HITLS_IsSessionReused(testInfo.client->ssl, &isReused), HITLS_SUCCESS);
ASSERT_EQ(isReused, pskStatus == SESSION_RESUME_PSK ? 1 : 0);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(testInfo.config);
FRAME_FreeLink(testInfo.client);
FRAME_FreeLink(testInfo.server);
HITLS_SESS_Free(testInfo.clientSession);
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_PSK_MODES_FUNC_TC001
* @spec -
* @title 1. Set key_exchange_mode to 3 on the client and server to establish a connection for the first time.
* The expected result indicates that the connection is successfully established.
* @precon nan
* @brief psk Supplement the test case line 269.
* @expect 1. Expected connection establishment failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_PSK_MODES_FUNC_TC001()
{
Test_PskConnect(TLS13_KE_MODE_PSK_ONLY | TLS13_KE_MODE_PSK_WITH_DHE, WITHOUT_PSK);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_PSK_MODES_FUNC_TC002
* @spec -
* @title 1. Set key_exchange_mode to 3 on the client and server to establish a connection for the first time.
* The expected result indicates that the connection is successfully established.
* @precon nan
* @brief psk Supplement the test case line 269.
* @expect 1. Expected connection establishment failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_PSK_MODES_FUNC_TC002()
{
Test_PskConnect(TLS13_KE_MODE_PSK_ONLY | TLS13_KE_MODE_PSK_WITH_DHE, PRE_CONFIG_PSK);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_PSK_MODES_FUNC_TC003
* @spec -
* @title 1. Restore the session. Set key_exchange_mode to 3 on the client and server. The client carries key_share and
* connection. The expected result indicates that the connection is successfully established.
* @precon nan
* @brief psk Supplement the test case line 269.
* @expect 1. Expected connection establishment failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_PSK_MODES_FUNC_TC003()
{
Test_PskConnect(TLS13_KE_MODE_PSK_ONLY | TLS13_KE_MODE_PSK_WITH_DHE, SESSION_RESUME_PSK);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_PSK_MODES_FUNC_TC004
* @spec -
* @title 1. Preset the PSK, set the key_exchange_mode of the client and server to 3 and set the key_exchange_mode of the
* server to psk_only, and establish a connection. The expected result indicates that the connection is
* successfully established.
* @precon nan
* @brief psk Supplement the test case line 269.
* @expect 1. Expected connection establishment failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_PSK_MODES_FUNC_TC004()
{
Test_PskConnect(TLS13_KE_MODE_PSK_ONLY, PRE_CONFIG_PSK);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_PSK_MODES_FUNC_TC005
* @spec -
* @title 1. Restore the session. Set the key_exchange_mode of the client and server to 3. Set the key_share extended by
* the client to establish a connection and enable the server to reject the PSK. Expected result:
* The session fails and certificate authentication is rejected.
* @precon nan
* @brief psk Supplement the test case line 269.
* @expect 1. Expected connection establishment failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_PSK_MODES_FUNC_TC005()
{
FRAME_Init();
ResumeTestInfo testInfo = {0};
testInfo.uioType = BSL_UIO_TCP;
testInfo.config = HITLS_CFG_NewTLS13Config();
HITLS_CFG_SetKeyExchMode(testInfo.config, TLS13_KE_MODE_PSK_ONLY | TLS13_KE_MODE_PSK_WITH_DHE);
testInfo.client = FRAME_CreateLink(testInfo.config, testInfo.uioType);
testInfo.server = FRAME_CreateLink(testInfo.config, testInfo.uioType);
ASSERT_EQ(FRAME_CreateConnection(testInfo.client, testInfo.server, true, HS_STATE_BUTT), HITLS_SUCCESS);
testInfo.clientSession = HITLS_GetDupSession(testInfo.client->ssl);
ASSERT_TRUE(testInfo.clientSession != NULL);
FRAME_FreeLink(testInfo.client);
testInfo.client = NULL;
FRAME_FreeLink(testInfo.server);
testInfo.server = NULL;
testInfo.client = FRAME_CreateLink(testInfo.config, testInfo.uioType);
HITLS_CFG_FreeConfig(testInfo.config);
testInfo.config = HITLS_CFG_NewTLS13Config();
HITLS_SetSession(testInfo.client->ssl, testInfo.clientSession);
testInfo.server = FRAME_CreateLink(testInfo.config, testInfo.uioType);
ASSERT_EQ(FRAME_CreateConnection(testInfo.client, testInfo.server, false, HS_STATE_BUTT), HITLS_SUCCESS);
uint8_t isReused = 0;
ASSERT_EQ(HITLS_IsSessionReused(testInfo.client->ssl, &isReused), HITLS_SUCCESS);
ASSERT_EQ(isReused, 0);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(testInfo.config);
FRAME_FreeLink(testInfo.client);
FRAME_FreeLink(testInfo.server);
HITLS_SESS_Free(testInfo.clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_PSK_MODES_FUNC_TC006
* @spec -
* @title 1. Preset the PSK and set the key_exchange_mode on the client server to 3. The key_share extension on the
* client is lost and a connection is established. Expected result: The server sends an alert message and
* the connection is disconnected.
* @precon nan
* @brief psk Added the test case line 269.
* @expect 1. Expected connection establishment failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_PSK_MODES_FUNC_TC006()
{
FRAME_Init();
RecWrapper wrapper = {
TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
&((FRAME_Msg *)0)->body.hsMsg.body.clientHello.keyshares.exState,
Test_MisClientHelloExtension
};
RegisterWrapper(wrapper);
ResumeTestInfo testInfo = {0};
testInfo.uioType = BSL_UIO_TCP;
testInfo.config = HITLS_CFG_NewTLS13Config();
uint16_t cipherSuite = HITLS_AES_128_GCM_SHA256;
HITLS_CFG_SetCipherSuites(testInfo.config, &cipherSuite, 1);
HITLS_CFG_SetPskClientCallback(testInfo.config, (HITLS_PskClientCb)ExampleClientCb);
HITLS_CFG_SetPskServerCallback(testInfo.config, (HITLS_PskServerCb)ExampleServerCb);
HITLS_CFG_SetKeyExchMode(testInfo.config, TLS13_KE_MODE_PSK_ONLY | TLS13_KE_MODE_PSK_WITH_DHE);
testInfo.client = FRAME_CreateLink(testInfo.config, testInfo.uioType);
testInfo.server = FRAME_CreateLink(testInfo.config, testInfo.uioType);
ASSERT_NE(FRAME_CreateConnection(testInfo.client, testInfo.server, true, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(testInfo.config);
FRAME_FreeLink(testInfo.client);
FRAME_FreeLink(testInfo.server);
HITLS_SESS_Free(testInfo.clientSession);
}
/* END_CASE */
/**
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_CERTICATE_VERIFY_FAIL_FUNC_TC001
* @brief 6.3. Error Alerts row 216
* The client does not support extended master keys and performs negotiation. After receiving the server hello
* message with the extended master keys, the client sends an alert message. Check whether the two parties enter the
* alerted state, and the read and write operations fail.
*
*/
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_CERTICATE_VERIFY_FAIL_FUNC_TC001()
{
FRAME_Init();
ResumeTestInfo testInfo = {0};
testInfo.version = HITLS_VERSION_TLS13;
testInfo.uioType = BSL_UIO_TCP;
testInfo.s_config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(testInfo.s_config != NULL);
testInfo.c_config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(testInfo.c_config != NULL);
HITLS_CFG_SetExtenedMasterSecretSupport(testInfo.c_config, false);
testInfo.client = FRAME_CreateLink(testInfo.c_config, testInfo.uioType);
ASSERT_TRUE(testInfo.client != NULL);
testInfo.server = FRAME_CreateLink(testInfo.s_config, testInfo.uioType);
ASSERT_TRUE(testInfo.server != NULL);
ASSERT_EQ(HITLS_SetSession(testInfo.client->ssl, testInfo.clientSession), HITLS_SUCCESS);
ASSERT_EQ(FRAME_CreateConnection(testInfo.client, testInfo.server, true, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(testInfo.c_config);
HITLS_CFG_FreeConfig(testInfo.s_config);
FRAME_FreeLink(testInfo.client);
FRAME_FreeLink(testInfo.server);
}
/* END_CASE */
static void Test_Client_Mode(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
frameMsg.body.hsMsg.body.clientHello.pskModes.exData.state = ASSIGNED_FIELD;
BSL_SAL_FREE(frameMsg.body.hsMsg.body.clientHello.pskModes.exData.data);
uint16_t version[] = { 0x03, };
frameMsg.body.hsMsg.body.clientHello.pskModes.exData.data =
BSL_SAL_Calloc(sizeof(version) / sizeof(uint8_t), sizeof(uint8_t));
ASSERT_EQ(memcpy_s(frameMsg.body.hsMsg.body.clientHello.pskModes.exData.data,
sizeof(version), version, sizeof(version)), EOK);
frameMsg.body.hsMsg.body.clientHello.keyshares.exState = MISSING_FIELD;
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.state = MISSING_FIELD;
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_PSKMODEZERO_FUNC_TC001
* @spec -
* @title Initialize the client and server to tls1.3. Construct a scenario where the psk is carried but key_share is not
* carried. Construct a scenario where the psk_mode carried in the clienthello message is 3. It is expected
* that the handshake fails.
* @precon nan
* @brief 4.1.1. Cryptographic Negotiation line 11
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_PSKMODEZERO_FUNC_TC001()
{
FRAME_Init();
RecWrapper wrapper = {
TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_Client_Mode
};
RegisterWrapper(wrapper);
ResumeTestInfo testInfo = {0};
testInfo.version = HITLS_VERSION_TLS13;
testInfo.uioType = BSL_UIO_TCP;
testInfo.config = HITLS_CFG_NewTLS13Config();
uint16_t cipherSuite = HITLS_AES_128_GCM_SHA256;
HITLS_CFG_SetCipherSuites(testInfo.config, &cipherSuite, 1);
HITLS_CFG_SetKeyExchMode(testInfo.config, TLS13_KE_MODE_PSK_ONLY);
HITLS_CFG_SetPskServerCallback(testInfo.config, (HITLS_PskServerCb)ExampleServerCb);
HITLS_CFG_SetPskClientCallback(testInfo.config, (HITLS_PskClientCb)ExampleClientCb);
testInfo.client = FRAME_CreateLink(testInfo.config, testInfo.uioType);
testInfo.server = FRAME_CreateLink(testInfo.config, testInfo.uioType);
ASSERT_EQ(FRAME_CreateConnection(testInfo.client, testInfo.server, true, HS_STATE_BUTT),
HITLS_MSG_HANDLE_MISSING_EXTENSION);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(testInfo.config);
FRAME_FreeLink(testInfo.client);
FRAME_FreeLink(testInfo.server);
HITLS_SESS_Free(testInfo.clientSession);
}
/* END_CASE */
static void Test_Server_Keyshare(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);
frameMsg.body.hsMsg.body.serverHello.keyShare.data.state = ASSIGNED_FIELD;
frameMsg.body.hsMsg.body.serverHello.keyShare.data.group.data = *(uint64_t *)user;
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_KEYSHAREGROUP_FUNC_TC001
* @spec -
* @title Initialize the client server to tls1.3 and construct the selected_group carried in the key_share extension in
* the sent serverhello message. If the group is not the keyshareentry group carried in the client hello message
* but the group provided in the client hello message, the connection fails to be established.
* @precon nan
* @brief 4.2.8. Key Share line 72
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_KEYSHAREGROUP_FUNC_TC001()
{
FRAME_Init();
uint64_t groupreturn[] = {HITLS_EC_GROUP_SECP384R1, };
RecWrapper wrapper = {
TRY_SEND_SERVER_HELLO,
REC_TYPE_HANDSHAKE,
false,
&groupreturn,
Test_Server_Keyshare
};
RegisterWrapper(wrapper);
ResumeTestInfo testInfo = {0};
testInfo.version = HITLS_VERSION_TLS13;
testInfo.uioType = BSL_UIO_TCP;
testInfo.config = HITLS_CFG_NewTLS13Config();
uint16_t group[] = {HITLS_EC_GROUP_SECP256R1, HITLS_EC_GROUP_SECP384R1};
HITLS_CFG_SetGroups(testInfo.config, group, 2);
testInfo.client = FRAME_CreateLink(testInfo.config, testInfo.uioType);
testInfo.server = FRAME_CreateLink(testInfo.config, testInfo.uioType);
ASSERT_EQ(FRAME_CreateConnection(testInfo.client, testInfo.server, true, HS_STATE_BUTT), HITLS_MSG_HANDLE_ILLEGAL_SELECTED_GROUP);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(testInfo.config);
FRAME_FreeLink(testInfo.client);
FRAME_FreeLink(testInfo.server);
HITLS_SESS_Free(testInfo.clientSession);
}
/* END_CASE */
static void Test_Server_Keyshare3(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);
ASSERT_TRUE(frameMsg.body.hsMsg.body.serverHello.keyShare.exState == MISSING_FIELD);
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_PSKKEYSHARE_FUNC_TC001
* @spec -
* @title 1. Initialize the client and server to tls1.3 and construct a scenario where psk_ke is used. The expected
* serverhello message sent does not carry the key_share extension.
* @precon nan
* @brief 4.2.8. Key Share line 73
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_PSKKEYSHARE_FUNC_TC001()
{
FRAME_Init();
RecWrapper wrapper = {
TRY_SEND_SERVER_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_Server_Keyshare3
};
RegisterWrapper(wrapper);
ResumeTestInfo testInfo = {0};
testInfo.version = HITLS_VERSION_TLS13;
testInfo.uioType = BSL_UIO_TCP;
testInfo.config = HITLS_CFG_NewTLS13Config();
uint16_t cipherSuite = HITLS_AES_128_GCM_SHA256;
HITLS_CFG_SetCipherSuites(testInfo.config, &cipherSuite, 1);
HITLS_CFG_SetKeyExchMode(testInfo.config, TLS13_KE_MODE_PSK_ONLY);
HITLS_CFG_SetPskServerCallback(testInfo.config, (HITLS_PskServerCb)ExampleServerCb);
HITLS_CFG_SetPskClientCallback(testInfo.config, (HITLS_PskClientCb)ExampleClientCb);
testInfo.client = FRAME_CreateLink(testInfo.config, testInfo.uioType);
HITLS_CFG_SetKeyExchMode(testInfo.config, TLS13_KE_MODE_PSK_ONLY);
testInfo.server = FRAME_CreateLink(testInfo.config, testInfo.uioType);
ASSERT_EQ(FRAME_CreateConnection(testInfo.client, testInfo.server, true, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(testInfo.config);
FRAME_FreeLink(testInfo.client);
FRAME_FreeLink(testInfo.server);
HITLS_SESS_Free(testInfo.clientSession);
}
/* END_CASE */
static void Test_Server_Keyshare4(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);
frameMsg.body.hsMsg.body.serverHello.keyShare.exState = INITIAL_FIELD;
frameMsg.body.hsMsg.body.serverHello.keyShare.exLen.state = INITIAL_FIELD;
frameMsg.body.hsMsg.body.serverHello.keyShare.data.state = INITIAL_FIELD;
frameMsg.body.hsMsg.body.serverHello.keyShare.data.group.state = ASSIGNED_FIELD;
frameMsg.body.hsMsg.body.serverHello.keyShare.data.group.data = HITLS_EC_GROUP_CURVE25519;
FRAME_ModifyMsgInteger(HS_EX_TYPE_KEY_SHARE, &frameMsg.body.hsMsg.body.serverHello.keyShare.exType);
uint8_t uu[] = {0x3b, 0xb5, 0xe4, 0x3c, 0xf6, 0xc4, 0x70, 0x0f, 0x3c, 0x7f, 0x05, 0x0b, 0xd4, 0xfb, 0x24, 0x39,
0xc8, 0xb6, 0x13, 0x50, 0xc6, 0xee, 0xde, 0x69, 0xc5, 0x09, 0xef, 0x2e, 0x21, 0x4d, 0xd8, 0x1e};
FRAME_ModifyMsgArray8(uu, sizeof(uu), &frameMsg.body.hsMsg.body.serverHello.keyShare.data.keyExchange,
&frameMsg.body.hsMsg.body.serverHello.keyShare.data.keyExchangeLen);
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_PSKKEYSHARE_FUNC_TC002
* @spec -
* @title 1. Initialize the client and server to tls1.3, construct the psk_ke scenario, and construct the sent
* serverhello message carrying the key_share extension. It is expected that the connection fails to be
* established.
* @precon nan
* @brief 4.2.8. Key Share line 73
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_PSKKEYSHARE_FUNC_TC002()
{
FRAME_Init();
RecWrapper wrapper = {TRY_SEND_SERVER_HELLO, REC_TYPE_HANDSHAKE, false, NULL, Test_Server_Keyshare4};
RegisterWrapper(wrapper);
ResumeTestInfo testInfo = {0};
testInfo.version = HITLS_VERSION_TLS13;
testInfo.uioType = BSL_UIO_TCP;
testInfo.config = HITLS_CFG_NewTLS13Config();
uint16_t cipherSuite = HITLS_AES_128_GCM_SHA256;
HITLS_CFG_SetCipherSuites(testInfo.config, &cipherSuite, 1);
HITLS_CFG_SetKeyExchMode(testInfo.config, TLS13_KE_MODE_PSK_ONLY);
HITLS_CFG_SetPskServerCallback(testInfo.config, (HITLS_PskServerCb)ExampleServerCb);
HITLS_CFG_SetPskClientCallback(testInfo.config, (HITLS_PskClientCb)ExampleClientCb);
testInfo.client = FRAME_CreateLink(testInfo.config, testInfo.uioType);
HITLS_CFG_SetKeyExchMode(testInfo.config, TLS13_KE_MODE_PSK_ONLY);
testInfo.server = FRAME_CreateLink(testInfo.config, testInfo.uioType);
ASSERT_EQ(FRAME_CreateConnection(testInfo.client, testInfo.server, true, HS_STATE_BUTT),
HITLS_MSG_HANDLE_HANDSHAKE_FAILURE);
ALERT_Info info = {0};
ALERT_GetInfo(testInfo.client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(testInfo.config);
FRAME_FreeLink(testInfo.client);
FRAME_FreeLink(testInfo.server);
HITLS_SESS_Free(testInfo.clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC001
* @spec -
* @title The supported_versions in the clientHello is extended to 0x0304 (TLS 1.3). If the server supports only 1.2, the
* server returns a "protocol_version" warning and the handshake fails.
* @precon nan
* @brief Appendix D. Backward Compatibility line 247
* @expect
* 1. The setting is successful.
* 2. The setting is successful.
* 3. The connection is set up successfully.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *config_c = NULL;
HITLS_Config *config_s = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config_c = HITLS_CFG_NewTLS13Config();
config_s = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
clientMsg->cipherSuites.data[0] = 0xC02F;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(serverTlsCtx->hsCtx->state, TRY_SEND_CERTIFICATE);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_PROTOCOL_VERSION);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC004
* @spec -
* @title clientHello version is 0x0303 and the server supports only 1.3. The server returns "protocol_version" and the
* handshake fails.
* @precon nan
* @brief Appendix D. Backward Compatibility line 247
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC004()
{
FRAME_Init();
HITLS_Config *config_c = NULL;
HITLS_Config *config_s = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config_c = HITLS_CFG_NewTLS12Config();
config_s = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ALERT_Info info = { 0 };
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_PROTOCOL_VERSION);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC005
* @spec -
* @titleSet that the server supports only TLS 1.2 and the client supports TLS 1.3. ClientHello legacy_version contains
0x0303 (TLS 1.2). The supported_versions field is extended to 0x0304 and 0x0303. The server responds with
serverHello and ServerHello.version is 0x0303, The client agrees to use this version, and the handshake
negotiation is successful.
* @precon nan
* @brief Appendix D. Backward Compatibility line 245
* @expect 1. The handshake negotiation is successful.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC005()
{
FRAME_Init();
HITLS_Config *config_c = NULL;
HITLS_Config *config_s = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config_c = HITLS_CFG_NewTLSConfig();
config_s = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(HITLS_CFG_SetVersionSupport(config_c, TLS12_VERSION_BIT|TLS13_VERSION_BIT) == HITLS_SUCCESS);
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC006
* @spec -
* @title: The server supports only TLS 1.2, and the client supports TLS 1.3. ClientHello legacy_version contains 0x0303
* (TLS 1.2). The supported_versions field is extended to 0x0304 and 0x0303. The server responds with
* serverHello and ServerHello.version is 0x0303, The client agrees to use this version. The connection
* establishment is interrupted, and the session is restored. The restoration is successful.
* @precon nan
* @brief Appendix D. Backward Compatibility line 245
* @expect 1. The handshake negotiation is successful.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC006()
{
FRAME_Init();
HITLS_Config *config_c = NULL;
HITLS_Config *config_s = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config_c = HITLS_CFG_NewTLSConfig();
config_s = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(HITLS_CFG_SetVersionSupport(config_c, TLS12_VERSION_BIT|TLS13_VERSION_BIT) == HITLS_SUCCESS);
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
HITLS_Session *clientSession = NULL;
clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
uint8_t isReused = 0;
ASSERT_EQ(HITLS_IsSessionReused(client->ssl, &isReused), HITLS_SUCCESS);
ASSERT_EQ(isReused, 1);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
static void Test_SERVERHELLO_VERSION(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS12;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS12;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);
frameMsg.body.hsMsg.body.serverHello.version.data = 0x0301;
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC007
* @spec -
* @titleSet that the server supports only TLS 1.2 and the client supports TLS 1.3. ClientHello legacy_version contains
* 0x0303 (TLS 1.2), and supported_versions is extended to 0x0304, 0x0303, and 0x0301: The server responds with
* serverHello. The value of ServerHello.version is 0x0303. The client agrees to use this version. The
* connection establishment is interrupted and the session is restored, Before the client receives the
* ServerHello message, the session fails to be resumed after Server.version is changed to 0x0301.
* @precon nan
* @brief Appendix D. Backward Compatibility line 245
* @expect 1. Failed to restore the session.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC007()
{
FRAME_Init();
HITLS_Config *config_c = NULL;
HITLS_Config *config_s = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config_c = HITLS_CFG_NewTLSConfig();
config_s = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(HITLS_CFG_SetVersionSupport(config_c, TLS12_VERSION_BIT | TLS13_VERSION_BIT) ==
HITLS_SUCCESS);
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
HITLS_Session *clientSession = NULL;
clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
RecWrapper wrapper = {TRY_SEND_SERVER_HELLO, REC_TYPE_HANDSHAKE, false, NULL, Test_SERVERHELLO_VERSION};
RegisterWrapper(wrapper);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_PROTOCOL_VERSION);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_PSKTICKETLIFETIME_FUNC_TC001
* @spec -
* @title Set the life cycle of ticket_lifetime to 10s. After the first connection is established, send the session using the
* ticket through the client to resume, The server processes the message 10 seconds after receiving the ticket. The
* server determines that the ticket has expired and the session fails to be restored.
* @precon nan
* @brief 4.6.1. New Session Ticket Message line 164
* @expect 1. Expected handshake failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_PSKTICKETLIFETIME_FUNC_TC001()
{
FRAME_Init();
ResumeTestInfo testInfo = {0};
testInfo.version = HITLS_VERSION_TLS13;
testInfo.uioType = BSL_UIO_TCP;
testInfo.config = HITLS_CFG_NewTLS13Config();
HITLS_CFG_SetSessionTimeout(testInfo.config, 10);
ASSERT_EQ(DoHandshake(&testInfo), HITLS_SUCCESS);
testInfo.clientSession = HITLS_GetDupSession(testInfo.client->ssl);
ASSERT_TRUE(testInfo.clientSession != NULL);
FRAME_FreeLink(testInfo.client);
testInfo.client = NULL;
FRAME_FreeLink(testInfo.server);
testInfo.server = NULL;
HITLS_CFG_FreeConfig(testInfo.config);
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, testInfo.clientSession), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(client->ssl), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
sleep(11);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
uint8_t isReused = 0;
ASSERT_EQ(HITLS_IsSessionReused(client->ssl, &isReused), HITLS_SUCCESS);
ASSERT_EQ(isReused, 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(testInfo.clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_CERT_SIGNATURE_FUNC_TC001
* @spec -
* @title Certificate chain: ecdsa_secp256r1_sha256. If the signature algorithm is ecdsa_secp256r1_sha256, the certificate
* and certificate chain are successfully verified.
* @precon nan
* @brief 9.1. Mandatory-to-Implement Cipher Suites line 229
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_CERT_SIGNATURE_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256, CERT_SIG_SCHEME_RSA_PKCS1_SHA256};
ASSERT_TRUE(HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t))== HITLS_SUCCESS);
FRAME_CertInfo certInfo = {
"rsa_sha/ca-3072.der:rsa_sha/inter-3072.der",
NULL, NULL, NULL, NULL, NULL,};
client = FRAME_CreateLinkWithCert(config, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_CERT_SIGNATURE_FUNC_TC002
* @spec -
* @title Certificate chain: ecdsa_secp256r1_sha256. If the signature algorithm is ecdsa_secp256r1_sha256, the
* certificate and certificate chain are successfully verified.
* @precon nan
* @brief 9.1. Mandatory-to-Implement Cipher Suites line 229
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_CERT_SIGNATURE_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256 };
ASSERT_TRUE(HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t))== HITLS_SUCCESS);
FRAME_CertInfo certInfo1 = {
"rsa_pss_rsae/rsa_root.der:rsa_pss_rsae/rsa_intCa.der",
NULL, NULL, NULL, NULL, NULL,};
FRAME_CertInfo certInfo2 = {
"rsa_pss_rsae/rsa_root.der:rsa_pss_rsae/rsa_intCa.der",
"rsa_pss_rsae/rsa_intCa.der", "rsa_pss_rsae/rsa_dev.der", NULL, "rsa_pss_rsae/rsa_dev.key.der", NULL,};
client = FRAME_CreateLinkWithCert(config, BSL_UIO_TCP, &certInfo1);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLinkWithCert(config, BSL_UIO_TCP, &certInfo2);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_CERT_SIGNATURE_FUNC_TC003
* @spec -
* @title Certificate chain: ecdsa_secp256r1_sha256. If the signature algorithm is ecdsa_secp256r1_sha256, the
* certificate and certificate chain are successfully verified.
* @precon nan
* @brief 9.1. Mandatory-to-Implement Cipher Suites line 229
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_CERT_SIGNATURE_FUNC_TC003()
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
ASSERT_TRUE(HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t))== HITLS_SUCCESS);
FRAME_CertInfo certInfo = {
"ecdsa/ca-nist521.der:ecdsa/inter-nist521.der",
NULL, NULL, NULL, NULL, NULL,};
client = FRAME_CreateLinkWithCert(config, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECVERSION_FUNC_TC001
* @spec -
* @title After the server negotiates the version number for the first time, the serverHello, Certificate, Server Key
* Exchange, Certificate Request, Server Hello Done, Certificate, Certificate Key Exchange, The
* legacy_record_version of all record messages, such as Certificate Verify, Change Cipher Spec, and Finished,
* is the negotiated version.
* @precon nan
* @brief Appendix D. Backward Compatibility line 242
* @expect 1. The expected version number is the negotiated version.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECVERSION_FUNC_TC001(int flag, int type)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
FrameUioUserData *ioUserData = NULL;
config = HITLS_CFG_NewTLS12Config();
HITLS_CFG_SetClientVerifySupport(config, true);
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, flag, type) == HITLS_SUCCESS);
if (flag == 1) {
HITLS_Connect(client->ssl);
ioUserData = BSL_UIO_GetUserData(client->io);
} else {
HITLS_Accept(server->ssl);
ioUserData = BSL_UIO_GetUserData(server->io);
}
uint8_t *recvBuf = ioUserData->sndMsg.msg;
uint32_t recvLen = ioUserData->sndMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS12, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsgHeader(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
ASSERT_EQ(frameMsg.recVersion.data, 0x0303);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECVERSION_FUNC_TC002
* @spec -
* @title Renegotiation. After the server negotiates the version number, the serverHello, Certificate, Server Key
* Exchange, Certificate Request, Server Hello Done, Certificate, Certificate Key Exchange, Certificate Verify,
* Change Cipher Spec, Finished, and other record messages legacy_record_version indicates the renegotiation
version.
* @precon nan
* @brief Appendix D. Backward Compatibility line 242
* @expect 1. The expected version number is the negotiated version.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECVERSION_FUNC_TC002(int flag, int type)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
FrameUioUserData *ioUserData = NULL;
config = HITLS_CFG_NewTLS12Config();
HITLS_CFG_SetClientVerifySupport(config, true);
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
HITLS_SetRenegotiationSupport(server->ssl, true);
HITLS_SetRenegotiationSupport(client->ssl, true);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(client->ssl) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(server->ssl) == HITLS_SUCCESS);
ASSERT_EQ(FRAME_CreateRenegotiationState(client, server, flag, type), HITLS_SUCCESS);
if (flag == 1) {
HITLS_Connect(client->ssl);
ioUserData = BSL_UIO_GetUserData(client->io);
} else {
HITLS_Accept(server->ssl);
ioUserData = BSL_UIO_GetUserData(server->io);
}
uint8_t *recvBuf = ioUserData->sndMsg.msg;
uint32_t recvLen = ioUserData->sndMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS12, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsgHeader(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
ASSERT_EQ(frameMsg.recVersion.data, 0x0303);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_PARSE_CA_LIST_TC001
* @spec -
* @title The CA list is parsed correctly.
* @precon nan
* @brief 1. Use the default configuration items to configure the client and server. stop the server in the TRY_RECV_CLIENT_HELLO
* state. Expected result 1 is obtained.
* 2. Get the client hello message from the server. Expected result 2 is obtained.
* 3. Add the CA list to the client hello message. Expected result 3 is obtained.
* 4. Reconnect the client. Expected result 4 is obtained.
* @expect 1. The initialization is successful.
* 2. The recvLen is not 0.
* 3. The CA list is packed correctly.
* 4. The client hello message is parsed correctly.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_PARSE_CA_LIST_TC001()
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
FrameUioUserData *ioUserData = NULL;
config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO), HITLS_SUCCESS);
ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
frameType.versionType = HITLS_VERSION_TLS13;
frameType.recordType = REC_TYPE_HANDSHAKE;
frameType.handshakeType = CLIENT_HELLO;
frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
ASSERT_TRUE(FRAME_ParseMsgHeader(&frameType, recvBuf, recvLen, &frameMsg, &recvLen) == HITLS_SUCCESS);
uint8_t caList[] = {0x00, 0x06, 0x00, 0x04, 0x4a, 0x4b, 0x4c, 0x4d};
frameMsg.body.hsMsg.body.clientHello.caList.exState = ASSIGNED_FIELD;
frameMsg.body.hsMsg.body.clientHello.caList.exType.data = HS_EX_TYPE_CERTIFICATE_AUTHORITIES;
frameMsg.body.hsMsg.body.clientHello.caList.exType.state = ASSIGNED_FIELD;
FRAME_ModifyMsgArray8(caList, sizeof(caList), &frameMsg.body.hsMsg.body.clientHello.caList.list,
&frameMsg.body.hsMsg.body.clientHello.caList.listSize);
frameMsg.body.hsMsg.body.clientHello.caList.exLen.state = ASSIGNED_FIELD;
frameMsg.body.hsMsg.body.clientHello.caList.exLen.data = sizeof(caList) + sizeof(uint16_t);
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
memset_s(&frameMsg, sizeof(frameMsg), 0, sizeof(frameMsg));
ASSERT_NE(FRAME_CreateConnection(server, client, false, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/consistency/tls13/test_suite_sdv_frame_tls13_consistency_rfc8446_extensions_2.c
|
C
|
unknown
| 50,229
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include "hitls_error.h"
#include "tls.h"
#include "change_cipher_spec.h"
#include "frame_tls.h"
#include "parser_frame_msg.h"
#include "pack_frame_msg.h"
#include "frame_link.h"
#include "frame_io.h"
#include "frame_msg.h"
#include "simulate_io.h"
#include "stub_replace.h"
#include "hs.h"
#include "alert.h"
#include "bsl_sal.h"
#include "securec.h"
#include "app.h"
#include "hs_kx.h"
#include "hs_msg.h"
#include "rec.h"
#include "conn_init.h"
#include "parse.h"
#include "hs_common.h"
#include "common_func.h"
#include "hlt.h"
#include "process.h"
#include "hitls_crypt_init.h"
#include "rec_wrapper.h"
#define REC_TLS_RECORD_HEADER_LEN 5
#define ALERT_BODY_LEN 2u
#define READ_BUF_SIZE 18432
#define ERROR_VERSION_BIT 0x00000000U
#define READ_BUF_LEN_18K (18 * 1024)
#define BUF_SIZE_DTO_TEST (18 * 1024)
#define ROOT_DER "%s/ca.der:%s/inter.der"
#define INTCA_DER "%s/inter.der"
#define SERVER_DER "%s/server.der"
#define SERVER_KEY_DER "%s/server.key.der"
#define CLIENT_DER "%s/client.der"
#define CLIENT_KEY_DER "%s/client.key.der"
static char *g_serverName = "testServer";
uint32_t g_uiPort = 18890;
/* END_HEADER */
int32_t RecParseInnerPlaintext(TLS_Ctx *ctx, uint8_t *text, uint32_t *textLen, uint8_t *recType);
int32_t STUB_RecParseInnerPlaintext(TLS_Ctx *ctx, uint8_t *text, uint32_t *textLen, uint8_t *recType)
{
(void)ctx;
(void)text;
(void)textLen;
*recType = (uint8_t)REC_TYPE_APP;
return HITLS_SUCCESS;
}
void SetFrameType(FRAME_Type *frametype, uint16_t versionType, REC_Type recordType, HS_MsgType handshakeType,
HITLS_KeyExchAlgo keyExType)
{
frametype->versionType = versionType;
frametype->recordType = recordType;
frametype->handshakeType = handshakeType;
frametype->keyExType = keyExType;
frametype->transportType = BSL_UIO_TCP;
}
void TestSetCertPath(HLT_Ctx_Config *ctxConfig, char *SignatureType)
{
if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA1", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA1")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA1_EE_PATH, RSA_SHA1_PRIV_PATH, "NULL", "NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA256", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA256")) ==
0 ||
strncmp(SignatureType,
"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256",
strlen("CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA256_EE_PATH3, RSA_SHA256_PRIV_PATH3, "NULL", "NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA384", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA384")) ==
0 ||
strncmp(SignatureType,
"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384",
strlen("CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA384_EE_PATH, RSA_SHA384_PRIV_PATH, "NULL", "NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA512", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA512")) ==
0 ||
strncmp(SignatureType,
"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512",
strlen("CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA512_EE_PATH, RSA_SHA512_PRIV_PATH, "NULL", "NULL");
} else if (strncmp(SignatureType,
"CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256",
strlen("CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA_CA_PATH,
ECDSA_SHA_CHAIN_PATH,
ECDSA_SHA256_EE_PATH,
ECDSA_SHA256_PRIV_PATH,
"NULL",
"NULL");
} else if (strncmp(SignatureType,
"CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384",
strlen("CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA_CA_PATH,
ECDSA_SHA_CHAIN_PATH,
ECDSA_SHA384_EE_PATH,
ECDSA_SHA384_PRIV_PATH,
"NULL",
"NULL");
} else if (strncmp(SignatureType,
"CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512",
strlen("CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA_CA_PATH,
ECDSA_SHA_CHAIN_PATH,
ECDSA_SHA512_EE_PATH,
ECDSA_SHA512_PRIV_PATH,
"NULL",
"NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_ECDSA_SHA1", strlen("CERT_SIG_SCHEME_ECDSA_SHA1")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA1_CA_PATH,
ECDSA_SHA1_CHAIN_PATH,
ECDSA_SHA1_EE_PATH,
ECDSA_SHA1_PRIV_PATH,
"NULL",
"NULL");
}
}
static int SetCertPath(HLT_Ctx_Config *ctxConfig, const char *certStr, bool isServer)
{
char caCertPath[50];
char chainCertPath[30];
char eeCertPath[30];
char privKeyPath[30];
int32_t ret = sprintf_s(caCertPath, sizeof(caCertPath), ROOT_DER, certStr, certStr);
ASSERT_TRUE(ret > 0);
ret = sprintf_s(chainCertPath, sizeof(chainCertPath), INTCA_DER, certStr);
ASSERT_TRUE(ret > 0);
ret = sprintf_s(eeCertPath, sizeof(eeCertPath), isServer ? SERVER_DER : CLIENT_DER, certStr);
ASSERT_TRUE(ret > 0);
ret = sprintf_s(privKeyPath, sizeof(privKeyPath), isServer ? SERVER_KEY_DER : CLIENT_KEY_DER, certStr);
ASSERT_TRUE(ret > 0);
HLT_SetCaCertPath(ctxConfig, (char *)caCertPath);
HLT_SetChainCertPath(ctxConfig, (char *)chainCertPath);
HLT_SetEeCertPath(ctxConfig, (char *)eeCertPath);
HLT_SetPrivKeyPath(ctxConfig, (char *)privKeyPath);
return 0;
EXIT:
return -1;
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVE_RENEGOTIATION_REQUEST_FUNC_TC001
* @spec Because TLS 1.3 forbids renegotiation, if a server has negotiated
* TLS 1.3 and receives a ClientHello at any other time, it MUST
* terminate the connection with an "unexpected_message" alert.
* @title Initialize the client server to tls1.3. After the connection is established, the client sends a client hello message.
* The expected server sends an alarm after receiving the message and disconnects the connection.
* @precon nan
* @brief 4.1.1. ryptographic Negotiation row15
* Initialize the client server to tls1.3. After the connection is established, the client sends a client hello
* message.
* The expected server sends an alarm after receiving the message and disconnects the connection.
* @expect 1. The server sends an alarm and the connection is disconnected.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVE_RENEGOTIATION_REQUEST_FUNC_TC001()
{
FRAME_Init();
/* Initialize the client server to tls1.3. */
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportRenegotiation = true;
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
/* After the connection is established, the client sends a client hello message. */
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
FrameMsg recMsg = {0};
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
ASSERT_TRUE(memcpy_s(recMsg.msg, MAX_RECORD_LENTH, ioServerData->recMsg.msg + REC_TLS_RECORD_HEADER_LEN,
ioServerData->recMsg.len - REC_TLS_RECORD_HEADER_LEN) == EOK);
recMsg.len = ioServerData->recMsg.len - 5;
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->negotiatedInfo.version == HITLS_VERSION_TLS13);
ASSERT_TRUE(clientTlsCtx->negotiatedInfo.version == HITLS_VERSION_TLS13);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(REC_Write(clientTlsCtx, REC_TYPE_HANDSHAKE, recMsg.msg, recMsg.len), HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(client, server) == HITLS_SUCCESS);
ASSERT_EQ(HITLS_Read(serverTlsCtx, readBuf, READ_BUF_SIZE, &readLen), HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
static void Test_ModifyClientHello(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *userData)
{
(void)ctx;
(void)userData;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
clientMsg->supportedVersion.exState = MISSING_FIELD;
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_DOWN_GRADE_FUNC_TC001
* @spec random: 32 bytes generated by a secure random number generator. See
* Appendix C for additional information. The last 8 bytes MUST be
* overwritten as described below if negotiating TLS 1.2 or TLS 1.1,
* but the remaining bytes MUST be random. This structure is
* generated by the server and MUST be generated independently of the ClientHello.random.
* @title Initialize the client and server to tls1.3. Delete the supportversion extension when sending clienthello
* messages.
* After receiving the message, the server negotiates with the TLS1.2 and returns the serverhello after the random
* number is overwrritened.
* After receiving the serverhello message, the client checks the random number and sends the
ALERT_ELLEGAL_PARAMETER alarm.
* @precon nan
* @brief 4.1.3. Server Hello row24
* Initialize the client server to tls1.3 and delete the supportversion extension when sending client hello
* messages.
* After receiving the message, the server negotiates TLS1.2 and returns the serverhello after the random number is
* overwrritened.
* After receiving the serverhello message, the client checks the random number and sends the
ALERT_LOCKGAL_PARAMETER a larm.
* @expect 1. The client sends the ALERT_AIRGAL_PARAMETER alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_DOWN_GRADE_FUNC_TC001()
{
FRAME_Init();
/* Initialize the client and server to tls1.3. Delete the supportversion extension when sending clienthello
* messages. */
HITLS_Config *tlsConfig = HITLS_CFG_NewTLSConfig();
uint16_t cipherSuites[] = {
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,
};
ASSERT_TRUE(
HITLS_CFG_SetCipherSuites(tlsConfig, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t)) == HITLS_SUCCESS);
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
HITLS_CFG_SetVersionSupport(tlsConfig, 0x00000030U);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
RecWrapper wrapper = {TRY_SEND_CLIENT_HELLO, REC_TYPE_HANDSHAKE, false, NULL, Test_ModifyClientHello};
RegisterWrapper(wrapper);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(client, server) == HITLS_SUCCESS);
/* After receiving the message, the server negotiates with the TLS1.2 and returns the serverhello after the random
* number is overwrritened. */
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(serverTlsCtx->negotiatedInfo.version == HITLS_VERSION_TLS12);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(server, client) == HITLS_SUCCESS);
/* After receiving the serverhello message, the client checks the random number and sends the
* ALERT_ELLEGAL_PARAMETER alarm. */
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = {0};
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC001
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title Client. The certificate is received after the clienthello message is sent.
* @precon nan
* @brief 4.Handshake Protocol row9
* Client, receiving the certificate after sending the clienthello message.
* @expect 1. Return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = false;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FRAME_LinkObj *client2 = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server2 = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client2 != NULL);
ASSERT_TRUE(server2 != NULL);
HITLS_Ctx *clientTlsCtx2 = FRAME_GetTlsCtx(client2);
HITLS_Ctx *serverTlsCtx2 = FRAME_GetTlsCtx(server2);
ASSERT_TRUE(FRAME_CreateConnection(client2, server2, true, TRY_RECV_CERTIFICATE_REQUEST) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx2->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx2->state == CM_STATE_HANDSHAKING);
char *buffer = BSL_SAL_Calloc(1u, MAX_RECORD_LENTH);
FrameUioUserData *ioUserData2 = BSL_UIO_GetUserData(client2->io);
uint8_t *recvBuf2 = ioUserData2->recMsg.msg;
uint32_t recvLen2 = ioUserData2->recMsg.len;
memcpy_s(buffer, MAX_RECORD_LENTH, recvBuf2, recvLen2);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
ioUserData->recMsg.len = 0;
ASSERT_EQ(FRAME_TransportRecMsg(client->io, buffer, recvLen2), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
FRAME_FreeLink(client2);
FRAME_FreeLink(server2);
BSL_SAL_FREE(buffer);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC002
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title Client, unidirectional authentication, certificateverify received after receiving the serverhello message
* @precon nan
* @brief 4.Handshake Protocol row9
* Client, unidirectional authentication, certificateverify received after receiving the server hello message
* @expect 1. Return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = false;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_CERTIFICATE_VERIFY) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
client->ssl->hsCtx->state = TRY_RECV_ENCRYPTED_EXTENSIONS;
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC003
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title Client, two-way authentication, certificate received after receiving the serverhello message
* @precon nan
* @brief 4.Handshake Protocol row9
* Client, two-way authentication, certificate received after receiving the serverhello message
* @expect 1. Return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC003()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_CERTIFICATE) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
client->ssl->hsCtx->state = TRY_RECV_ENCRYPTED_EXTENSIONS;
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC004
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title Client, two-way authentication, receiving certificateverify after receiving certificaterequest
* @precon nan
* @brief 4.Handshake Protocol row9
* Client, two-way authentication, receiving certificateverify after receiving certificaterequest
* @expect 1. Return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC004()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_CERTIFICATE_VERIFY) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
client->ssl->hsCtx->state = TRY_RECV_CERTIFICATE;
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC005
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title Client, unidirectional authentication. After receiving the certificate, the client receives the finished message.
* @precon nan
* @brief 4.Handshake Protocol row9
* Client, unidirectional authentication. After receiving the certificate, the client receives the finished message.
* @expect 1. Return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC005()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = false;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_FINISH) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
client->ssl->hsCtx->state = TRY_RECV_CERTIFICATE_VERIFY;
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC006
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title Client, unidirectional authentication, receiving appdata after receiving certificateverify
* @precon nan
* @brief 4.Handshake Protocol row9
* Client, unidirectional authentication, receiving appdata after receiving certificateverify
* @expect 1. Return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC006()
{
FRAME_Init();
STUB_Init();
FuncStubInfo tmpRpInfo = { 0 };
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = false;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_FINISH) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
STUB_Replace(&tmpRpInfo, RecParseInnerPlaintext, STUB_RecParseInnerPlaintext);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
STUB_Reset(&tmpRpInfo);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC007
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title Client, unidirectional authentication, certificateverify received after receiving encryptedextensions
* @precon nan
* @brief 4.Handshake Protocol row9
* Client, unidirectional authentication, certificateverify received after receiving encryptedextensions
* @expect 1. Return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC007()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = false;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_CERTIFICATE_VERIFY) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
client->ssl->hsCtx->state = TRY_RECV_CERTIFICATE_REQUEST;
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC008
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title The server receives the certificate message in idle state.
* @precon nan
* @brief 4.Handshake Protocol row9
* The server receives a certificate message in idle state.
* @expect 1. Return HITLS_CM_LINK_UNESTABLICED
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC008()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FRAME_LinkObj *client2 = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server2 = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client2 != NULL);
ASSERT_TRUE(server2 != NULL);
HITLS_Ctx *clientTlsCtx2 = FRAME_GetTlsCtx(client2);
HITLS_Ctx *serverTlsCtx2 = FRAME_GetTlsCtx(server2);
ASSERT_TRUE(FRAME_CreateConnection(client2, server2, false, TRY_RECV_CERTIFICATE) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx2->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx2->state == CM_STATE_HANDSHAKING);
char *buffer = BSL_SAL_Calloc(1u, MAX_RECORD_LENTH);
FrameUioUserData *ioUserData2 = BSL_UIO_GetUserData(server2->io);
uint8_t *recvBuf2 = ioUserData2->recMsg.msg;
uint32_t recvLen2 = ioUserData2->recMsg.len;
memcpy_s(buffer, MAX_RECORD_LENTH, recvBuf2, recvLen2);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
ioUserData->recMsg.len = 0;
ASSERT_EQ(FRAME_TransportRecMsg(server->io, buffer, recvLen2), HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(serverTlsCtx, readBuf, READ_BUF_SIZE, &readLen), HITLS_CM_LINK_UNESTABLISHED);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
FRAME_FreeLink(client2);
FRAME_FreeLink(server2);
BSL_SAL_FREE(buffer);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC009
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title The server uses unidirectional authentication. The certificate message is received after the client hello message is received.
* @precon nan
* @brief 4.Handshake Protocol row9
* Server, unidirectional authentication, certificate message received after receiving client hello messages.
* @expect 1. Return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC009()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CERTIFICATE) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
server->ssl->hsCtx->state = TRY_RECV_FINISH;
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC010
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title server, unidirectional authentication, receiving the app message after receiving the client hello message
* @precon nan
* @brief 4.Handshake Protocol row9
* Server, unidirectional authentication, receiving the app message after receiving the client hello message
* @expect 1. Return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC010()
{
FRAME_Init();
STUB_Init();
FuncStubInfo tmpRpInfo = { 0 };
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = false;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_FINISH) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
STUB_Replace(&tmpRpInfo, RecParseInnerPlaintext, STUB_RecParseInnerPlaintext);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
STUB_Reset(&tmpRpInfo);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC011
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title server, two-way authentication, certificateverify message received after client hello is received
* @precon nan
* @brief 4.Handshake Protocol row9
* The server, two-way authentication, receives the certificateverify message after receiving the client hello
* message.
* @expect 1. Return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC011()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CERTIFICATE_VERIFY) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
server->ssl->hsCtx->state = TRY_RECV_CERTIFICATE;
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC012
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title server, two-way authentication, receiving the finish message after receiving the certificate message
* @precon nan
* @brief 4.Handshake Protocol row9
* The server, two-way authentication, receives the finish message after receiving the certificate message.
* @expect 1. Return HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC012()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = false;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_FINISH) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
server->ssl->hsCtx->state = TRY_RECV_CERTIFICATE_VERIFY;
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC013
* @spec Protocol messages MUST be sent in the order defined in Section 4.4.1
* and shown in the diagrams in Section 2. A peer which receives a
* handshake message in an unexpected order MUST abort the handshake
* with an "unexpected_message" alert.
* @title server, two-way authentication, receiving the app message after receiving the certificateverify message
* @precon nan
* @brief 4.Handshake Protocol row9
* The server, two-way authentication, receives the app message after receiving the certificateverify message.
* @expect 1. Return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_UNEXPECTMSG_FUNC_TC013()
{
FRAME_Init();
STUB_Init();
FuncStubInfo tmpRpInfo = { 0 };
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_FINISH) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
STUB_Replace(&tmpRpInfo, RecParseInnerPlaintext, STUB_RecParseInnerPlaintext);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
STUB_Reset(&tmpRpInfo);
}
/* END_CASE */
static void Test_ModifyClientHelloNullKeyshare(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *userData)
{
(void)ctx;
(void)userData;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
clientMsg->keyshares.exLen.data = 2;
clientMsg->keyshares.exKeyShareLen.data = 0;
clientMsg->keyshares.exKeyShares.state = MISSING_FIELD;
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_NULL_KEYSHARE_FUNC_TC001
* @spec If the server selects an (EC)DHE group and the client did not offer a
* compatible "key_share" extension in the initial ClientHello, the
* server MUST respond with a HelloRetryRequest (Section 4.1.4) message.
* @title Construct the clienthello message sent by the client. The key_share extension is empty and the psk extension is
not carried. The server is expected to send a hellorequest message.
* @precon nan
* @brief 4.Handshake Protocol row9
* Construct the client hello message sent by the client. The key_share extension is empty and the psk extension is
not carried. The server is expected to send a hellorequest message.
* @expect 1. The server sends hrr and waits for receiving the second client hello.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_NULL_KEYSHARE_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
RecWrapper wrapper = {TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_ModifyClientHelloNullKeyshare};
RegisterWrapper(wrapper);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ClearWrapper();
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SECOND_GROUP_SUPPORT_FUNC_TC001
* @spec When a client first connects to a server, it is REQUIRED to send the
* ClientHello as its first TLS message. The client will also send a
* ClientHello when the server has responded to its ClientHello with a
* HelloRetryRequest. In that case, the client MUST send the same
* ClientHello without modification, except as follows:
* @title 1. Set the client server to tls1.3. Set the first group server not to support the client, but the second group
* server to support the client,
* The server is expected to send a helloretryrequest message. The client hello message is sent after the client
* hello message is updated. The group in the keyshare of the client hello message is changed. The connection is
* expected to be successfully set up.
* @precon nan
* @brief 4.1.2. Client Hello row14
* 1. Set the client server to tls1.3. Set the first group server to not support the client server, and set the
* second group server to support the client server.
* The server is expected to send a helloretryrequest message. The client hello message is sent after the client
* hello message is updated. The group in the keyshare of the client hello message is changed. The connection is
* expected to be successfully established.
* @expect 1. The server sends hrr and the connection is successfully established.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SECOND_GROUP_SUPPORT_FUNC_TC001()
{
FRAME_Init();
/* Set the client server to tls1.3. Set the first group server not to support the client, but the second group
* server to support the client */
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SECOND_GROUP_SUPPORT_FUNC_TC002
* @spec When a client first connects to a server, it is REQUIRED to send the
* ClientHello as its first TLS message. The client will also send a
* ClientHello when the server has responded to its ClientHello with a
* HelloRetryRequest. In that case, the client MUST send the same
* ClientHello without modification, except as follows:
* @title 1. Set the client server to tls1.3. Set the first group server not to support the client, but the second group
* server to support the client,
* The server is expected to send a helloretryrequest message, construct the same client hello message sent by the
* client, and the server is expected to reject connection establishment.
* @precon nan
* @brief 4.1.2. Client Hello row14
* 1. Set the client server to tls1.3. Set the first group server not to support the client, and the second group
* server to support the client.
* The server is expected to send a helloretryrequest message, construct the same client hello message sent by the
* client, and the server is expected to reject connection establishment.
* @expect 1. Link establishment fails.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SECOND_GROUP_SUPPORT_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
char *buffer = BSL_SAL_Calloc(1u, MAX_RECORD_LENTH);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
memcpy_s(buffer, MAX_RECORD_LENTH, recvBuf, recvLen);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, recvBuf, recvLen) == HITLS_SUCCESS);
ioUserData->sndMsg.len = 0;
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_INVALID_PROTOCOL_VERSION);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
BSL_SAL_FREE(buffer);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SECOND_GROUP_SUPPORT_FUNC_TC003
* @spec When a client first connects to a server, it is REQUIRED to send the
* ClientHello as its first TLS message. The client will also send a
* ClientHello when the server has responded to its ClientHello with a
* HelloRetryRequest. In that case, the client MUST send the same
* ClientHello without modification, except as follows:
* @titleSet the client server to tls1.3, and set the first group server not to support the client, and the second group
* server to support the client,
* The hash of the cipher suite on the server does not match the hash corresponding to the psk set on the
* client. The server is expected to send a helloretryrequest message,
* The client resends the client hello message and removes the psk extension.
* @precon nan
* @brief 4.1.2. Client Hello row14
* Set the client server to tls1.3. Set the first group server not to support the client, but the second group
* server to support the client,
* The hash of the cipher suite on the server does not match the hash corresponding to the psk set on the
* client. The server is expected to send a helloretryrequest message,
* The client resends the client hello message and removes the psk extension.
* @expect 1. The second clienthello does not contain the psk.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SECOND_GROUP_SUPPORT_FUNC_TC003()
{
FRAME_Init();
HITLS_Session *Session = {0};
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT) == HITLS_SUCCESS);
Session = HITLS_GetDupSession(client->ssl);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(HITLS_SetSession(client->ssl, Session) == HITLS_SUCCESS);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
ASSERT_TRUE(clientMsg->psks.exState == INITIAL_FIELD);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ioUserData = BSL_UIO_GetUserData(client->io);
recvBuf = ioUserData->recMsg.msg;
recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
serverMsg->cipherSuite.data = HITLS_AES_128_GCM_SHA256;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ioUserData = BSL_UIO_GetUserData(server->io);
recvBuf = ioUserData->recMsg.msg;
recvLen = ioUserData->recMsg.len;
parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
clientMsg = &frameMsg.body.hsMsg.body.clientHello;
ASSERT_TRUE(clientMsg->psks.exState == MISSING_FIELD);
FRAME_CleanMsg(&frameType, &frameMsg);
EXIT:
HITLS_SESS_Free(Session);
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RENEGOTIATION_OLD_VERSION_FUNC_TC001
* @spec If a server established a TLS connection with a previous version of
* TLS and receives a TLS 1.3 ClientHello in a renegotiation, it MUST
* retain the previous protocol version. In particular, it MUST NOT
* negotiate TLS 1.3.
* @title 1. On the server end of 1.3, after the connection between 1.2 and 1.2 is successfully established, initiate
renegotiation and change the client version to 1.3. The supported version includes tls1.2. The expected version
is tls1.2.
* @precon nan
* @brief 4.1.1. Cryptographic Negotiation row16
* 1. On the 1.3 server, after the 1.2 connection is successfully established, initiate renegotiation and change the
client version to 1.3. The supported version includes tls1.2. The tls1.2 version is expected to be negotiated.
* @expect 1. The TLS1.2 version is expected to be negotiated.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RENEGOTIATION_OLD_VERSION_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig_s = HITLS_CFG_NewTLSConfig();
tlsConfig_s->isSupportClientVerify = true;
tlsConfig_s->isSupportRenegotiation = true;
HITLS_CFG_SetKeyExchMode(tlsConfig_s, TLS13_KE_MODE_PSK_WITH_DHE);
HITLS_CFG_SetVersionSupport(tlsConfig_s, 0x00000030U);
uint16_t cipherSuites[] = {
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,
};
ASSERT_TRUE(
HITLS_CFG_SetCipherSuites(tlsConfig_s, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t)) == HITLS_SUCCESS);
ASSERT_TRUE(tlsConfig_s != NULL);
HITLS_Config *tlsConfig_c = HITLS_CFG_NewTLSConfig();
HITLS_CFG_SetVersionForbid(tlsConfig_c, 0x00000020U);
tlsConfig_c->isSupportClientVerify = true;
ASSERT_TRUE(tlsConfig_c != NULL);
tlsConfig_c->isSupportRenegotiation = true;
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig_c, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig_s, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
HITLS_SetClientRenegotiateSupport(server->ssl, true);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->negotiatedInfo.version == HITLS_VERSION_TLS12);
ASSERT_TRUE(clientTlsCtx->negotiatedInfo.version == HITLS_VERSION_TLS12);
HITLS_CFG_SetVersionSupport(&(clientTlsCtx->config.tlsConfig), 0x00000030U);
ASSERT_EQ(HITLS_Renegotiate(clientTlsCtx), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(serverTlsCtx, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_RENEGOTIATION);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->negotiatedInfo.version == HITLS_VERSION_TLS12);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig_s);
HITLS_CFG_FreeConfig(tlsConfig_c);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RENEGOTIATION_OLD_VERSION_FUNC_TC002
* @spec If a server established a TLS connection with a previous version of
* TLS and receives a TLS 1.3 ClientHello in a renegotiation, it MUST
* retain the previous protocol version. In particular, it MUST NOT
* negotiate TLS 1.3.
* @title 1. On the server end of 1.2, after the connection is successfully established, the client version is changed to 1.3
* and the minimum supported version is tls1.3. The renegotiation fails.
* @precon nan
* @brief 4.1.1. Cryptographic Negotiation row16
* 1. After the connection between the client and the client is set up successfully, the client version is changed
* to 1.3 and the minimum supported version is tls1.3. The renegotiation fails.
* @expect 1. Expected renegotiation failure
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RENEGOTIATION_OLD_VERSION_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig_s = HITLS_CFG_NewTLSConfig();
tlsConfig_s->isSupportClientVerify = true;
tlsConfig_s->isSupportRenegotiation = true;
HITLS_CFG_SetKeyExchMode(tlsConfig_s, TLS13_KE_MODE_PSK_WITH_DHE);
uint16_t cipherSuites[] = {
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,
};
ASSERT_TRUE(HITLS_CFG_SetCipherSuites(tlsConfig_s, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t)) == HITLS_SUCCESS);
ASSERT_TRUE(tlsConfig_s != NULL);
HITLS_Config *tlsConfig_c = HITLS_CFG_NewTLSConfig();
HITLS_CFG_SetVersionForbid(tlsConfig_c, 0x00000020U);
tlsConfig_c->isSupportClientVerify = true;
ASSERT_TRUE(tlsConfig_c != NULL);
tlsConfig_c->isSupportRenegotiation = true;
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig_c, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig_s, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
HITLS_SetClientRenegotiateSupport(server->ssl, true);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->negotiatedInfo.version == HITLS_VERSION_TLS12);
ASSERT_TRUE(clientTlsCtx->negotiatedInfo.version == HITLS_VERSION_TLS12);
ASSERT_EQ(HITLS_Renegotiate(clientTlsCtx), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(serverTlsCtx, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_RENEGOTIATION);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
HITLS_CFG_SetVersionForbid(&(clientTlsCtx->config.tlsConfig), 0x00000010U);
HITLS_CFG_SetVersionSupport(&(clientTlsCtx->config.tlsConfig), 0x00000020U);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig_s);
HITLS_CFG_FreeConfig(tlsConfig_c);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_VERSION_FUNC_TC001
* @spec In TLS 1.3, the client indicates its version preferences in the
* "supported_versions" extension (Section 4.2.1) and the
* legacy_version field MUST be set to 0x0303, which is the version
* number for TLS 1.2. TLS 1.3 ClientHellos are identified as having a legacy_version of 0x0303 and a
* supported_versions extension
* present with 0x0304 as the highest version indicated therein.
* @title The client server is initialized to the tls1.3 version, and the legacy_version in the sent clienthello
* message is changed to 0x0302. The server is expected to return an alert.
* @precon nan
* @brief 4.1.2. Client Hello row17
* The client server is initialized to the tls1.3 version, and the legacy_version in the sent clienthello message
* is changed to 0x0302. The server is expected to return an alert.
* @expect 1. The server sends an alert message.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_VERSION_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
/* The client server is initialized to the tls1.3 version, and the legacy_version in the sent clienthello
* message is changed to 0x0302 */
clientMsg->version.data = 0x0302;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_ALERTED);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_VERSION_FUNC_TC002
* @spec In TLS 1.3, the client indicates its version preferences in the
* "supported_versions" extension (Section 4.2.1) and the
* legacy_version field MUST be set to 0x0303, which is the version
* number for TLS 1.2. TLS 1.3 ClientHellos are identified as having a legacy_version of 0x0303 and a
* supported_versions extension present with 0x0304 as the highest version indicated therein.
* @title The client server is initialized to the tls1.3 version, and the legacy_version in the sent clienthello
* message is changed to 0x0304. The server is expected to return an alert.
* @precon nan
* @brief 4.1.2. Client Hello row17
* The client server is initialized to the tls1.3 version, and the legacy_version in the sent clienthello message
* is changed to 0x0304. The server is expected to return an alert.
* @expect 1. The server sends an alert message.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_VERSION_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
/* The client server is initialized to the tls1.3 version, and the legacy_version in the sent clienthello
* message is changed to 0x0304. */
clientMsg->version.data = 0x0304;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_ALERTED);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SESSION_ID_FUNC_TC001
* @spec A client which has a cached session ID set by a pre-TLS 1.3 server SHOULD set this field to that value.
* In compatibility mode (see Appendix D.4),this field MUST be non-empty, so a client not offering a
* pre-TLS 1.3 session MUST generate a new 32-byte value. This value need not be random but SHOULD be
unpredictable to avoid
* implementations fixating on a specific value (also known as
* ossification). Otherwise, it MUST be set as a zero-length vector
* (i.e., a zero-valued single byte length field).
* @title Set the client server to tls1.3 and check the legacy_session_id of the sent clienthello message. The value
is a 32-byte value.
* @precon nan
* @brief 4.1.2. Client Hello row18
* Set the client server to tls1.3 and check the legacy_session_id of the sent clienthello to a 32-byte value.
* @expect 1. Check the session ID.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SESSION_ID_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
/* Set the client server to tls1.3 and check the legacy_session_id of the sent clienthello message. The value
* is a 32-byte value. */
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
ASSERT_EQ(clientMsg->sessionIdSize.data, 32);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
static void Test_ModifyClientHello_Sessionid_002(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *userData)
{
(void)ctx;
(void)userData;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
clientMsg->sessionIdSize.data = 0;
clientMsg->sessionId.size = 0;
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/* @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SESSION_ID_FUNC_TC002
* @spec A client which has a cached session ID set by a pre-TLS 1.3 server SHOULD set this field to that value.
* In compatibility mode (see Appendix D.4),this field MUST be non-empty, so a client not offering a
* pre-TLS 1.3 session MUST generate a new 32-byte value. This value need not be random but SHOULD be
unpredictable to avoid implementations fixating on a specific value (also known as
* ossification). Otherwise, it MUST be set as a zero-length vector
* (i.e., a zero-valued single byte length field).
* @title Set the client server to tls1.3 and construct the value of legacy_session_id in the sent clienthello message
to a single byte 0. The expected connection establishment is successful.
* @precon nan
* @brief 4.1.2. Client Hello row18
* Set the client server to tls1.3 and construct the value of legacy_session_id in the sent clienthello message
to a single byte 0. The expected connection establishment is successful.
* @expect 1. The connection is set up successfully.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SESSION_ID_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
/* Set the client server to tls1.3 and construct the value of legacy_session_id in the sent clienthello message
* to a single byte 0 */
RecWrapper wrapper = {TRY_SEND_CLIENT_HELLO, REC_TYPE_HANDSHAKE, false, NULL, Test_ModifyClientHello_Sessionid_002};
RegisterWrapper(wrapper);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO), HITLS_SUCCESS);
clientTlsCtx->hsCtx->sessionIdSize = 0;
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SESSION_ID_FUNC_TC003
* @spec A client which has a cached session ID set by a pre-TLS 1.3 server SHOULD set this field to that value.
* In compatibility mode (see Appendix D.4),this field MUST be non-empty, so a client not offering a
* pre-TLS 1.3 session MUST generate a new 32-byte value. This value need not be random but SHOULD be
* unpredictable to avoid implementations fixating on a specific value (also known as
* ossification). Otherwise, it MUST be set as a zero-length vector
* (i.e., a zero-valued single byte length field).
* @title Set the client server to tls1.3 and construct the value of legacy_session_id in the sent clienthello message to
* 2-byte 0. The expected connection establishment failure
* @precon nan
* @brief 4.1.2. Client Hello row18
* Set the client server to tls1.3 and construct the value of legacy_session_id in the sent clienthello message to
* two bytes 0. The expected connection establishment fails.
* @expect 1. Link establishment fails.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SESSION_ID_FUNC_TC003()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
clientMsg->sessionIdSize.data = 0;
/* Set the client server to tls1.3 and construct the value of legacy_session_id in the sent clienthello message to
* 2-byte 0. */
clientMsg->sessionId.size = 2;
clientMsg->sessionId.data[0] = 0x00;
clientMsg->sessionId.data[1] = 0x00;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_PARSE_INVALID_MSG_LEN);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SESSION_ID_FUNC_TC004
* @spec A client which has a cached session ID set by a pre-TLS 1.3 server SHOULD set this field to that value.
* In compatibility mode (see Appendix D.4),this field MUST be non-empty, so a client not offering a
* pre-TLS 1.3 session MUST generate a new 32-byte value. This value need not be random but SHOULD be unpredictable
to avoid implementations fixating on a specific value (also known as ossification). Otherwise, it MUST be set as
a zero-length vector
* (i.e., a zero-valued single byte length field).
* @title Set the client server to tls1.3 and construct the value of legacy_session_id in the sent clienthello message to
1 byte 1. The expected connection establishment fails.
* @precon nan
* @brief 4.1.2. Client Hello row18
* Set the client server to tls1.3 and construct the value of legacy_session_id in the clienthello message to 1
byte 1. The expected connection establishment fails.
* @expect 1. Connect establishment fails.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SESSION_ID_FUNC_TC004()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
/* Set the client server to tls1.3 and construct the value of legacy_session_id in the sent clienthello message to
* 1 byte 1. */
clientMsg->sessionIdSize.data = 1;
clientMsg->sessionId.size = 1;
clientMsg->sessionId.data[0] = 0x01;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_PARSE_INVALID_MSG_LEN);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
static void Test_ModifyClientHello_Sessionid_005(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *userData)
{
(void)ctx;
(void)userData;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
clientMsg->sessionIdSize.data = 26;
clientMsg->sessionId.size = 26;
const uint8_t sessionId_temp[26] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
ASSERT_TRUE(memcpy_s(clientMsg->sessionId.data, sizeof(sessionId_temp) / sizeof(uint8_t),
sessionId_temp, sizeof(sessionId_temp) / sizeof(uint8_t)) == 0);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SESSION_ID_FUNC_TC005
* @spec A client which has a cached session ID set by a pre-TLS 1.3 server SHOULD set this field to that value.
* In compatibility mode (see Appendix D.4),this field MUST be non-empty, so a client not offering a
* pre-TLS 1.3 session MUST generate a new 32-byte value. This value need not be random but SHOULD be unpredictable
to avoid implementations fixating on a specific value (also known as ossification). Otherwise, it MUST be set as
a zero-length vector (i.e., a zero-valued single byte length field).
* @title Set the client server to tls1.3 and construct the value of legacy_session_id in the sent clienthello message to
26 bytes 0. The expected connection is successfully established..
* @precon nan
* @brief 4.1.2. Client Hello row18
* Set the client server to tls1.3 and construct the value of legacy_session_id in the sent clienthello message to
26 bytes 0. The expected link establishment success.
* @expect 1. Link establishment success.
* @expect 1. Link establishment fails.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SESSION_ID_FUNC_TC005()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
/* Set the client server to tls1.3 and construct the value of legacy_session_id in the sent clienthello message to
* 26 bytes 0. */
RecWrapper wrapper = {TRY_SEND_CLIENT_HELLO, REC_TYPE_HANDSHAKE, false, NULL, Test_ModifyClientHello_Sessionid_005};
RegisterWrapper(wrapper);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO), HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_CH_CIPHERSUITES_FUNC_TC001
* @spec cipher_suites: A list of the symmetric cipher options supported by
* the client, specifically the record protection algorithm
* (including secret key length) and a hash to be used with HKDF, in
* descending order of client preference. Values are defined in
* Appendix B.4. If the list contains cipher suites that the server
* does not recognize, support, or wish to use, the server MUST
* ignore those cipher suites and process the remaining ones as
* usual. If the client is attempting a PSK key establishment, it SHOULD advertise at least one cipher suite
* indicating a Hash associated with the PSK.
* @title clienthello The first three cipher suites are abnormal values, tls1.2 cipher suites, and tls1.3 cipher suites
* that are not configured on the server, The fourth cipher suite is supported by the server. It is expected that
* the server selects the fourth cipher suite to establish a connection.
* @precon nan
* @brief 4.1.2. Client Hello row19
* The first three cipher suites of client hello are abnormal values, tls1.2 cipher suites, and tls1.3 cipher
* suites that are not configured on the server,
* The fourth cipher suite is supported by the server. It is expected that the server selects the fourth cipher
* suite to establish a connection.
* @expect 1. The connection is set up successfully.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_CH_CIPHERSUITES_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *config_c = HITLS_CFG_NewTLS13Config();
HITLS_Config *config_s = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
config_c->isSupportClientVerify = true;
config_s->isSupportClientVerify = true;
/* clienthello The first three cipher suites are abnormal values, tls1.2 cipher suites, and tls1.3 cipher suites
* that are not configured on the server, The fourth cipher suite is supported by the server. */
uint16_t cipherSuits_c[] = {
0x0041, HITLS_DHE_RSA_WITH_AES_256_CBC_SHA256, HITLS_CHACHA20_POLY1305_SHA256, HITLS_AES_256_GCM_SHA384};
HITLS_CFG_SetCipherSuites(config_c, cipherSuits_c, sizeof(cipherSuits_c) / sizeof(uint16_t));
uint16_t cipherSuits_s[] = {HITLS_AES_256_GCM_SHA384};
HITLS_CFG_SetCipherSuites(config_s, cipherSuits_s, sizeof(cipherSuits_s) / sizeof(uint16_t));
FRAME_LinkObj *client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
int32_t ret = FRAME_CreateConnection(client, server, true, HS_STATE_BUTT);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_TRUE(server->ssl->negotiatedInfo.cipherSuiteInfo.cipherSuite == HITLS_AES_256_GCM_SHA384);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_CH_CIPHERSUITES_FUNC_TC002
* @spec cipher_suites: A list of the symmetric cipher options supported by
* the client, specifically the record protection algorithm
* (including secret key length) and a hash to be used with HKDF, in
* descending order of client preference. Values are defined in
* Appendix B.4. If the list contains cipher suites that the server
* does not recognize, support, or wish to use, the server MUST
* ignore those cipher suites and process the remaining ones as
* usual. If the client is attempting a PSK key establishment, it SHOULD advertise at least one cipher suite
* indicating a Hash associated with the PSK.
* @title The hash of the configured psk does not match the specified cipher suite when tls1.3 is set on the client
* server. The expected psk does not exist in the client hello.
* @precon nan
* @brief 4.1.2. Client Hello row19
* When tls1.3 is set on the client and server, the hash of the psk does not match the specified cipher suite. It
* is expected that the psk does not exist in the client hello.
* @expect 1. No psk is expected in the clienthello.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_CH_CIPHERSUITES_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
HITLS_CFG_SetPskServerCallback(tlsConfig, (HITLS_PskServerCb)ExampleServerCb);
HITLS_CFG_SetPskClientCallback(tlsConfig, (HITLS_PskClientCb)ExampleClientCb);
/* The hash of the configured psk does not match the specified cipher suite when tls1.3 is set on the client
* server. */
uint16_t cipherSuite = HITLS_AES_256_GCM_SHA384;
HITLS_CFG_SetCipherSuites(tlsConfig, &cipherSuite, 1);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
ASSERT_TRUE(clientMsg->psks.exState == MISSING_FIELD);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_COMPRESSION_METHOD_FUNC_TC001
* @spec legacy_compression_methods: Versions of TLS before 1.3 supported
* compression with the list of supported compression methods being
* sent in this field. For every TLS 1.3 ClientHello, this vector
* MUST contain exactly one byte, set to zero, which corresponds to
* the "null" compression method in prior versions of TLS. If a
* TLS 1.3 ClientHello is received with any other value in this
* field, the server MUST abort the handshake with an
* "illegal_parameter" alert. Note that TLS 1.3 servers might
* receive TLS 1.2 or prior ClientHellos which contain other
* compression methods and (if negotiating such a prior version) MUST follow the procedures for the appropriate
* prior version of TLS.
* @title Construct clienthello compression algorithm. The value is 0. The server is expected to return a decode
* error alert.
* @precon nan
* @brief 4.1.2. Client Hello row20
* Construct the clienthello compression algorithm with a two-byte value and the value 0. The server is
* expected to return a decode error alert.
* @expect 1. Return the decode error alert.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_COMPRESSION_METHOD_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
/* Construct clienthello compression algorithm. The value is 0. */
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
clientMsg->compressionMethodsLen.data = 2;
clientMsg->compressionMethods.data = realloc(clientMsg->compressionMethods.data, 2 * sizeof(uint8_t));
clientMsg->compressionMethods.size = 2;
clientMsg->compressionMethods.data[0] = 0x00;
clientMsg->compressionMethods.data[1] = 0x00;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_MSG_HANDLE_INVALID_COMPRESSION_METHOD);
ALERT_Info info = { 0 };
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_COMPRESSION_METHOD_FUNC_TC002
* @spec legacy_compression_methods: Versions of TLS before 1.3 supported
* compression with the list of supported compression methods being
* sent in this field. For every TLS 1.3 ClientHello, this vector
* MUST contain exactly one byte, set to zero, which corresponds to
* the "null" compression method in prior versions of TLS. If a
* TLS 1.3 ClientHello is received with any other value in this
* field, the server MUST abort the handshake with an
* "illegal_parameter" alert. Note that TLS 1.3 servers might
* receive TLS 1.2 or prior ClientHellos which contain other
* compression methods and (if negotiating such a prior version) MUST follow the procedures for the appropriate
* prior version of TLS.
* @title Constructs clienthello compression algorithm. The value is 1, indicating that the server returns
* illegal_parameter alert.
* @precon nan
* @brief 4.1.2. Client Hello row20
* Construct the clienthello compression algorithm with a bit of one byte and the value is 1. The server is
* expected to return illegal_parameter alert.
* @expect 1. Return ALERT_ELLEGAL_PARAMETER
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_COMPRESSION_METHOD_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
/* Construct the clienthello compression algorithm with a bit of one byte and the value is 1. */
clientMsg->compressionMethodsLen.data = 1;
clientMsg->compressionMethods.size = 1;
clientMsg->compressionMethods.data[0] = 0x01;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_MSG_HANDLE_INVALID_COMPRESSION_METHOD);
ALERT_Info info = { 0 };
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_DECODE_ERROR);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_COMPRESSION_METHOD_FUNC_TC003
* @spec legacy_compression_methods: Versions of TLS before 1.3 supported
* compression with the list of supported compression methods being
* sent in this field. For every TLS 1.3 ClientHello, this vector
* MUST contain exactly one byte, set to zero, which corresponds to
* the "null" compression method in prior versions of TLS. If a
* TLS 1.3 ClientHello is received with any other value in this
* field, the server MUST abort the handshake with an
* "illegal_parameter" alert. Note that TLS 1.3 servers might
* receive TLS 1.2 or prior ClientHellos which contain other
* compression methods and (if negotiating such a prior version) MUST follow the procedures for the appropriate
* prior version of TLS.
* @title Construct that the client version is TLS1.2 and the server version is TLS1.3. It is expected that the connection
* can be set up normally.
* @precon nan
* @brief 4.1.2. Client Hello row20
* Construct the scenario where the client version is TLS1.2 and the server version is TLS1.3 and the expected
* connection establishment is normal.
* @expect The connection is set up normally.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_COMPRESSION_METHOD_FUNC_TC003()
{
FRAME_Init();
HITLS_Config *tlsConfig_s = HITLS_CFG_NewTLSConfig();
tlsConfig_s->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig_s, TLS13_KE_MODE_PSK_WITH_DHE);
HITLS_CFG_SetVersionSupport(tlsConfig_s, 0x00000030U);
uint16_t cipherSuites[] = {
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,
};
ASSERT_TRUE(HITLS_CFG_SetCipherSuites(tlsConfig_s, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t)) == HITLS_SUCCESS);
ASSERT_TRUE(tlsConfig_s != NULL);
HITLS_Config *tlsConfig_c = HITLS_CFG_NewTLS12Config();
tlsConfig_c->isSupportClientVerify = true;
ASSERT_TRUE(tlsConfig_c != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig_c, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig_s, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->negotiatedInfo.version == HITLS_VERSION_TLS12);
ASSERT_TRUE(clientTlsCtx->negotiatedInfo.version == HITLS_VERSION_TLS12);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig_s);
HITLS_CFG_FreeConfig(tlsConfig_c);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_UNKNOWN_EXTENSION_FUNC_TC001
* @spec extensions: Clients request extended functionality from servers by
* sending data in the extensions field. The actual "Extension"
* format is defined in Section 4.2. In TLS 1.3, the use of certain extensions is mandatory, as functionality has
* moved into extensions to preserve ClientHello compatibility with previous
* versions of TLS. Servers MUST ignore unrecognized extensions
* @title Set the client server to tls1.3, construct a client hello message that carries the sni extension, and change
* the sni extension type to 55 (unknown extension). It is expected that the server can establish a connection normally.
* @precon nan
* @brief 4.1.2. Client Hello row21
* Set the client server to tls1.3, construct a client hello message that carries the SNI extension, and change the
* SNI extension type to 55 (unknown extension). The server is expected to establish a connection normally.
* @expect The connection is set up normally.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_UNKNOWN_EXTENSION_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
HITLS_CFG_SetServerName(tlsConfig, (uint8_t *)g_serverName, (uint32_t)strlen(g_serverName));
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = {0};
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
/** Set the client server to tls1.3, construct a client hello message that carries the sni extension, and change
* the sni extension type to 55 (unknown extension). */
clientMsg->serverName.exType.data = 55;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(clientTlsCtx->hsCtx->state, TRY_RECV_ENCRYPTED_EXTENSIONS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_DATA_AFTER_COMPRESSION_FUNC_TC001
* @spec TLS 1.3 servers will need to perform this check first and
* only attempt to negotiate TLS 1.3 if the "supported_versions"
* extension is present. If negotiating a version of TLS prior to 1.3,
* a server MUST check that the message either contains no data after
* legacy_compression_methods or that it contains a valid extensions
* block with no data following. If not, then it MUST abort the
* handshake with a "decode_error" alert.
* @title: Set tls1.2 on the client and tls1.3 on the server. Construct the clienthello compression algorithm without
* any extension. It is expected that the server can establish a connection.
* @precon nan
* @brief 4.1.2. Client Hello row22
* Set TLS 1.2 on the client and TLS 1.3 on the server. Construct the clienthello compression algorithm without
* any extension. It is expected that the server can establish a connection.
* @expect The connection is set up normally.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_DATA_AFTER_COMPRESSION_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig_s = HITLS_CFG_NewTLSConfig();
tlsConfig_s->isSupportExtendMasterSecret = false;
tlsConfig_s->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig_s, TLS13_KE_MODE_PSK_WITH_DHE);
HITLS_CFG_SetVersionSupport(tlsConfig_s, 0x00000030U);
uint16_t cipherSuites[] = {
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_CBC_SHA384,
HITLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
};
ASSERT_TRUE(
HITLS_CFG_SetCipherSuites(tlsConfig_s, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t)) == HITLS_SUCCESS);
ASSERT_TRUE(tlsConfig_s != NULL);
/* Set tls1.2 on the client and tls1.3 on the server. Construct the clienthello compression algorithm without
* any extension. */
HITLS_Config *tlsConfig_c = HITLS_CFG_NewTLS12Config();
tlsConfig_c->isSupportExtendMasterSecret = false;
tlsConfig_c->isSupportClientVerify = true;
ASSERT_TRUE(tlsConfig_c != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig_c, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig_s, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
clientMsg->extensionState = MISSING_FIELD;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(clientTlsCtx->hsCtx->state == TRY_RECV_CERTIFICATE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig_c);
HITLS_CFG_FreeConfig(tlsConfig_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_DATA_AFTER_COMPRESSION_FUNC_TC002
* @spec TLS 1.3 servers will need to perform this check first and
* only attempt to negotiate TLS 1.3 if the "supported_versions"
* extension is present. If negotiating a version of TLS prior to 1.3,
* a server MUST check that the message either contains no data after
* legacy_compression_methods or that it contains a valid extensions
* block with no data following. If not, then it MUST abort the
* handshake with a "decode_error" alert.
* @title: Set the client TLS 1.2 and server TLS 1.3. Construct the clienthello compression algorithm and carry the
* extension and 3-byte data after the extension. The expected connection establishment fails and the decode_error
* alert is returned.
* @precon nan
* @brief 4.1.2. Client Hello row22
* Set TLS 1.2 on the client and TLS 1.3 on the server. Construct the compression algorithm of the clienthello
* message and carry the extension. After the extension, carry the 3-byte data. In this case, the connection
* establishment fails and the decode_error alert is returned.
* @expect The connection is set up normally.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_DATA_AFTER_COMPRESSION_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig_s = HITLS_CFG_NewTLSConfig();
tlsConfig_s->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig_s, TLS13_KE_MODE_PSK_WITH_DHE);
HITLS_CFG_SetVersionSupport(tlsConfig_s, 0x00000030U);
uint16_t cipherSuites[] = {
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,
};
ASSERT_TRUE(
HITLS_CFG_SetCipherSuites(tlsConfig_s, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t)) == HITLS_SUCCESS);
ASSERT_TRUE(tlsConfig_s != NULL);
HITLS_Config *tlsConfig_c = HITLS_CFG_NewTLSConfig();
HITLS_CFG_SetVersionSupport(tlsConfig_c, 0x00000010U);
tlsConfig_c->isSupportClientVerify = true;
ASSERT_TRUE(tlsConfig_c != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig_c, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig_s, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint32_t *recvLen = &ioUserData->recMsg.len;
uint8_t *recvBuf = ioUserData->recMsg.msg;
ASSERT_TRUE(recvLen != 0);
recvBuf[4] += 3;
recvBuf[8] += 3;
recvBuf[*recvLen] = 0x01;
recvBuf[(*recvLen)+1] = 0x01;
recvBuf[(*recvLen)+2] = 0x01;
*recvLen += 3;
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_PARSE_INVALID_MSG_LEN);
ALERT_Info info = { 0 };
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_DECODE_ERROR);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig_c);
HITLS_CFG_FreeConfig(tlsConfig_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_DATA_AFTER_COMPRESSION_FUNC_TC003
* @spec TLS 1.3 servers will need to perform this check first and
* only attempt to negotiate TLS 1.3 if the "supported_versions"
* extension is present. If negotiating a version of TLS prior to 1.3,
* a server MUST check that the message either contains no data after
* legacy_compression_methods or that it contains a valid extensions
* block with no data following. If not, then it MUST abort the
* handshake with a "decode_error" alert.
* @title: Set the client TLS 1.2 and server TLS 1.3. Construct the clienthello compression algorithm and carry 3-byte
* data without extension. Expected connection establishment failure and return decode_error alert.
* @precon nan
* @brief 4.1.2. Client Hello row22
* Set TLS 1.2 on the client and TLS 1.3 on the server. Construct the compression algorithm of the clienthello
* message without extension and carry 3-byte data. Expectedly, connection establishment fails and decode_error
* alert is returned.
* @expect The connection is set up normally.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_DATA_AFTER_COMPRESSION_FUNC_TC003()
{
FRAME_Init();
HITLS_Config *tlsConfig_s = HITLS_CFG_NewTLS13Config();
tlsConfig_s->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig_s, TLS13_KE_MODE_PSK_WITH_DHE);
HITLS_CFG_SetVersionSupport(tlsConfig_s, 0x00000030U);
uint16_t cipherSuites[] = {
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,
};
ASSERT_TRUE(HITLS_CFG_SetCipherSuites(tlsConfig_s, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t)) == HITLS_SUCCESS);
ASSERT_TRUE(tlsConfig_s != NULL);
HITLS_Config *tlsConfig_c = HITLS_CFG_NewTLS12Config();
tlsConfig_c->isSupportClientVerify = true;
ASSERT_TRUE(tlsConfig_c != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig_c, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig_s, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
clientMsg->extensionState = MISSING_FIELD;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
/* Set the client TLS 1.2 and server TLS 1.3. Construct the clienthello compression algorithm and carry 3-byte
* data without extension. */
sendBuf[4] += 3;
sendBuf[8] += 3;
sendBuf[sendLen] = 0x01;
sendBuf[sendLen + 1] = 0x01;
sendBuf[sendLen + 2] = 0x01;
sendLen += 3;
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_PARSE_INVALID_MSG_LEN);
ALERT_Info info = { 0 };
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_DECODE_ERROR);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig_c);
HITLS_CFG_FreeConfig(tlsConfig_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_DATA_AFTER_COMPRESSION_FUNC_TC004
* @spec TLS 1.3 servers will need to perform this check first and
* only attempt to negotiate TLS 1.3 if the "supported_versions"
* extension is present. If negotiating a version of TLS prior to 1.3,
* a server MUST check that the message either contains no data after
* legacy_compression_methods or that it contains a valid extensions
* block with no data following. If not, then it MUST abort the
* handshake with a "decode_error" alert.
* @title 4. Set tls1.2 on the client and tls1.3 on the server. Construct the clienthello message that carries the SNI
* extension. The SNI length is too large and does not match the content. As a result, the expected connection
* establishment fails and a decode_error alert message is returned.
* @precon nan
* @brief 4.1.2. Client Hello row22
* 4. Set tls1.2 on the client and tls1.3 on the server. Construct a clienthello message that carries the SNI
* extension. The SNI length is too large and does not match the content. As a result, the expected connection
* establishment fails and a decode_error alert message is returned.
* @expect The connection is set up normally.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_DATA_AFTER_COMPRESSION_FUNC_TC004()
{
FRAME_Init();
HITLS_Config *tlsConfig_s = HITLS_CFG_NewTLS13Config();
tlsConfig_s->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig_s, TLS13_KE_MODE_PSK_WITH_DHE);
HITLS_CFG_SetVersionSupport(tlsConfig_s, 0x00000030U);
uint16_t cipherSuites[] = {
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,
};
ASSERT_TRUE(
HITLS_CFG_SetCipherSuites(tlsConfig_s, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t)) == HITLS_SUCCESS);
ASSERT_TRUE(tlsConfig_s != NULL);
HITLS_Config *tlsConfig_c = HITLS_CFG_NewTLS12Config();
HITLS_CFG_SetServerName(tlsConfig_c, (uint8_t *)g_serverName, (uint32_t)strlen(g_serverName));
tlsConfig_c->isSupportClientVerify = true;
ASSERT_TRUE(tlsConfig_c != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig_c, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig_s, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
clientMsg->serverName.exDataLen.data += 1;
/* Set tls1.2 on the client and tls1.3 on the server. Construct the clienthello message that carries the SNI
* extension. */
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_PARSE_INVALID_MSG_LEN);
ALERT_Info info = { 0 };
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_DECODE_ERROR);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig_c);
HITLS_CFG_FreeConfig(tlsConfig_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_LEGACY_VERSION_FUNC_TC001
* @spec legacy_version: In previous versions of TLS, this field was used for version negotiation and represented the
* selected version number
* for the connection. In TLS 1.3, the TLS server indicates
* its version using the "supported_versions" extension
* (Section 4.2.1), and the legacy_version field MUST be set to
* 0x0303, which is the version number for TLS 1.2. (See Appendix D
* for details about backward compatibility.)
* @title The client server is initialized to the tls1.3 version. The legacy_version in the sent serverhello message
* is changed to 0x0304. The client is expected to return illegal_parameter alert.
* @precon nan
* @brief 4.1.3. Server Hello row23
* The client and server are initialized to the tls1.3 version, and the legacy_version in the sent serverhello
* message is changed to 0x0304. The client is expected to return illegal_parameter alert.
* @expect 1. The server sends an alert message.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_LEGACY_VERSION_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
/* The client server is initialized to the tls1.3 version. The legacy_version in the sent serverhello message
* is changed to 0x0304. */
serverMsg->version.data = 0x0304;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_PROTOCOL_VERSION);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_LEGACY_VERSION_FUNC_TC002
* @spec legacy_version: In previous versions of TLS, this field was used for version negotiation and represented the
* selected version number for the connection. In TLS 1.3, the TLS server indicates
* its version using the "supported_versions" extension
* (Section 4.2.1), and the legacy_version field MUST be set to
* 0x0303, which is the version number for TLS 1.2. (See Appendix D
* for details about backward compatibility.)
* @title The client server is initialized to the tls1.3 version, and the legacy_version in the sent serverhello
* message is changed to 0x0302. The client is expected to return illegal_parameter alert.
* @precon nan
* @brief 4.1.3. Server Hello row23
* The client and server are initialized to tls1.3 and the legacy_version in the sent serverhello message is
* changed to 0x0302. The client is expected to return illegal_parameter alert.
* @expect 1. The server sends an alert message.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_LEGACY_VERSION_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
/* The client server is initialized to the tls1.3 version, and the legacy_version in the sent serverhello
* message is changed to 0x0302. */
serverMsg->version.data = 0x0302;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_PROTOCOL_VERSION);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_COMPRESSION_METHOD_FUNC_TC001
* @spec legacy_compression_method: A single byte which MUST have the
* value 0.
* @title Construct serverhello compression algorithm. The value is 1, indicating that the server returns
* illegal_parameter alert.
* @precon nan
* @brief 4.1.3. Server Hello row27
* Construct the serverhello compression algorithm with a one-byte value. The server returns the
* illegal_parameter alert message.
* @expect 1. The server sends an alert message.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_COMPRESSION_METHOD_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
/* Construct serverhello compression algorithm. The value is 1 */
serverMsg->compressionMethod.data = 0x01;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_PARSE_COMPRESSION_METHOD_ERR);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_EXTENSION_FUNC_TC001
* @spec extensions: A list of extensions. The ServerHello MUST only include
* extensions which are required to establish the cryptographic
* context and negotiate the protocol version. All TLS 1.3
* ServerHello messages MUST contain the "supported_versions"
* extension. Current ServerHello messages additionally contain
* either the "pre_shared_key" extension or the "key_share"
* extension, or both (when using a PSK with (EC)DHE key
* establishment). Other extensions (see Section 4.2) are sent
* separately in the EncryptedExtensions message.
* @title Initialize the client and server as tls1.3. Construct a serverhello message that carries the SNI extension. It
* is expected that the connection fails to be established.
* @precon nan
* @brief 4.1.3. Server Hello row28
* Initialize the client server to tls1.3 and construct a serverhello message that carries the SNI extension.
* The expected connection establishment fails.
* @expect 1. The client sends an alert message.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_EXTENSION_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
serverMsg->serverName.exState = INITIAL_FIELD;
serverMsg->serverName.exType.state = INITIAL_FIELD;
serverMsg->serverName.exLen.state = INITIAL_FIELD;
serverMsg->serverName.exLen.data = 0x00;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_EXTENSION_TYPE);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNSUPPORTED_EXTENSION);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_EXTENSION_FUNC_TC002
* @spec extensions: A list of extensions. The ServerHello MUST only include
* extensions which are required to establish the cryptographic
* context and negotiate the protocol version. All TLS 1.3
* ServerHello messages MUST contain the "supported_versions"
* extension. Current ServerHello messages additionally contain
* either the "pre_shared_key" extension or the "key_share"
* extension, or both (when using a PSK with (EC)DHE key
* establishment). Other extensions (see Section 4.2) are sent
* separately in the EncryptedExtensions message.
* @title Initialize the client and server to tls1.3 and construct the serverhello message that does not carry the
* supportedversion extension, client send illegal parameter after receive serverhello
* @precon nan
* @brief 4.1.3. Server Hello row28
* Initialize the client server to tls1.3 and construct the serverhello message without the supportedversion
* extension, client send illegal parameter because server send a tls13 ciphersuite without supportedversion
* extension
* @expect 1. The client receives an alert response from the CCS.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_EXTENSION_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLSConfig();
tlsConfig->isSupportExtendMasterSecret = false;
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
/* Initialize the client and server to tls1.3 and construct the serverhello message that does not carry the
* supportedversion extension */
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
serverMsg->supportedVersion.exState = MISSING_FIELD;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_CIPHER_SUITE_ERR);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_RANDOM_FUNC_TC001
* @spec For reasons of backward compatibility with middleboxes (see
* Appendix D.4), the HelloRetryRequest message uses the same structure
* as the ServerHello, but with Random set to the special value of the
* SHA-256 of "HelloRetryRequest":
*
* CF 21 AD 74 E5 9A 61 11 BE 1D 8C 02 1E 65 B8 91
* C2 A2 11 16 7A BB 8C 5E 07 9E 09 E2 C8 A8 33 9C
*
* Upon receiving a message with type server_hello, implementations MUST first examine the Random value and,
* if it matches this value, process it as described in Section 4.1.4).
* @title The client and server are initialized to the TLS1.3 version and construct the scenario of sending hrr
* messages. After receiving hrr messages, The next packet sent by the client is expected to be a client hello
* message, and the random value of the expected received hrr packet is the specified value.
* @precon nan
* @brief 4.1.3. Server Hello row29
* The client and server are initialized to the TLS1.3 version, construct the scenario of sending hrr messages.
* After receiving hrr messages,
* The next packet sent by the client is expected to be a client hello packet, and the random value of the
* expected received hrr packet is the specified value.
* @expect 1. Proofreading succeeded.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_RANDOM_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* The client and server are initialized to the TLS1.3 version and construct the scenario of sending hrr
* messages. */
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
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
};
ASSERT_TRUE(memcmp(serverMsg->randomValue.data, g_hrrRandom, sizeof(g_hrrRandom) / sizeof(uint8_t)) == 0);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_RANDOM_FUNC_TC002
* @spec For reasons of backward compatibility with middleboxes (see
* Appendix D.4), the HelloRetryRequest message uses the same structure
* as the ServerHello, but with Random set to the special value of the
* SHA-256 of "HelloRetryRequest":
*
* CF 21 AD 74 E5 9A 61 11 BE 1D 8C 02 1E 65 B8 91
* C2 A2 11 16 7A BB 8C 5E 07 9E 09 E2 C8 A8 33 9C
*
* Upon receiving a message with type server_hello, implementations MUST first examine the Random value and,
* if it matches this value, process it as described in Section 4.1.4).
* @title The client and server are initialized to the TLS1.3 version and construct the scenario of sending hrr
* messages. After receiving hrr messages,
* The next packet sent by the client is expected to be client hello, and the random value of the expected
* received hrr is the specified value.
* @precon nan
* @brief 4.1.3. Server Hello row29
* The client and server are initialized to the TLS1.3 version. The connection is established normally. The
* client and server directly send the server hello packet without sending the hrr message. The random value of
* the server hello packet is changed to the value specified by hrr,
* The client is expected to send a client hello packet after receiving the packet.
* @expect 1. It is expected that the client sends a client hello packet after receiving the packet.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_RANDOM_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
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
};
ASSERT_TRUE(memcpy_s(serverMsg->randomValue.data, sizeof(g_hrrRandom) / sizeof(uint8_t),
g_hrrRandom, sizeof(g_hrrRandom) / sizeof(uint8_t)) == 0);
serverMsg->keyShare.data.keyExchangeLen.state = MISSING_FIELD;
serverMsg->keyShare.data.keyExchange.state = MISSING_FIELD;
serverMsg->keyShare.data.group.data = HITLS_EC_GROUP_SECP521R1;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(clientTlsCtx->hsCtx->state, TRY_SEND_CLIENT_HELLO);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_DOWN_GRADE_RANDOM_FUNC_TC001
* @spec TLS 1.3 clients receiving a ServerHello indicating TLS 1.2 or below
* MUST check that the last 8 bytes are not equal to either of these values.
* TLS 1.2 clients SHOULD also check that the last 8 bytes are not equal to the second value if the ServerHello
* indicates TLS 1.1 or below.
* If a match is found, the client MUST abort the handshake with an "illegal_parameter" alert.
* Note: This is a change from [RFC5246], so in practice many TLS 1.2
* clients and servers will not behave as specified above.
* @title The client is tls1.3, and the server is tls1.2. Construct a scenario where the last eight random bytes of
* the server hello packet received by the client are equal to the specified value. The expected result is that
* the connection fails to be established and the client returns the illegal_parameter alarm.
* @precon nan
* @brief 4.1.3. Server Hello row31
* When the client is tls1.3 and the server is tls1.2, construct the last eight random bytes of the server hello
* packet received by the client equal to the specified value. In this case, the connection fails to be established
* and the client returns the illegal_parameter alarm.
* @expect The connection is set up normally.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_DOWN_GRADE_RANDOM_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig_c = HITLS_CFG_NewTLSConfig();
tlsConfig_c->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig_c, TLS13_KE_MODE_PSK_WITH_DHE);
HITLS_CFG_SetVersionSupport(tlsConfig_c, 0x00000030U);
uint16_t cipherSuites[] = {
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,
};
ASSERT_TRUE(
HITLS_CFG_SetCipherSuites(tlsConfig_c, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t)) == HITLS_SUCCESS);
ASSERT_TRUE(tlsConfig_c != NULL);
HITLS_Config *tlsConfig_s = HITLS_CFG_NewTLS12Config();
tlsConfig_s->isSupportClientVerify = true;
ASSERT_TRUE(tlsConfig_s != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig_c, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig_s, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
/* The client is tls1.3, and the server is tls1.2. Construct a scenario where the last eight random bytes of
* the server hello packet received by the client are equal to the specified value. */
const uint8_t g_tls12Downgrade[HS_DOWNGRADE_RANDOM_SIZE] = {0x44, 0x4f, 0x57, 0x4e, 0x47, 0x52, 0x44, 0x01};
ASSERT_TRUE(memcpy_s(serverMsg->randomValue.data + (HS_RANDOM_SIZE - HS_DOWNGRADE_RANDOM_SIZE), sizeof(g_tls12Downgrade) / sizeof(uint8_t),
g_tls12Downgrade, sizeof(g_tls12Downgrade) / sizeof(uint8_t)) == 0);
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig_s);
HITLS_CFG_FreeConfig(tlsConfig_c);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
static void Test_ModifyServerHello(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *userData)
{
(void)ctx;
(void)userData;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS12;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS12;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
serverMsg->keyShare.exState = INITIAL_FIELD;
serverMsg->keyShare.exType.state = INITIAL_FIELD;
serverMsg->keyShare.exLen.state = INITIAL_FIELD;
serverMsg->keyShare.exLen.data = 0x00;
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_RENEGOTIATION_VERSION_FUNC_TC001
* @spec A legacy TLS client performing renegotiation with TLS 1.2 or prior
* and which receives a TLS 1.3 ServerHello during renegotiation MUST
* abort the handshake with a "protocol_version" alert. Note that
* renegotiation is not possible when TLS 1.3 has been negotiated.
* @title Construct the TLS1.2 serverhello message received by the TLS1.3 serverhello message during renegotiation.
* @precon nan
* @brief 4.1.3. Server Hello row32
* Construct the scenario where the TLS1.2 server hello message of the TLS1.3 version is received during
* renegotiation.
* @expect 1. The client sends an alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SERVER_RENEGOTIATION_VERSION_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS12Config();
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportRenegotiation = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
HITLS_SetClientRenegotiateSupport(server->ssl, true);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_EQ(HITLS_Renegotiate(clientTlsCtx), HITLS_SUCCESS);
/* Construct the TLS1.2 serverhello message received by the TLS1.3 serverhello message during renegotiation. */
RecWrapper wrapper = {TRY_SEND_SERVER_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_ModifyServerHello};
RegisterWrapper(wrapper);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(serverTlsCtx, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_RENEGOTIATION);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_EXTENSION_TYPE);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNSUPPORTED_EXTENSION);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_EXTENSION_FUNC_TC001
* @spec The server's extensions must contain "supported_versions".
* Additionally, it SHOULD contain the minimal set of extensions
* necessary for the client to generate a correct ClientHello pair. As
* with the ServerHello, a HelloRetryRequest MUST NOT contain any
* extensions that were not first offered by the client in its
* ClientHello, with the exception of optionally the "cookie" (see
* Section 4.2.2) extension.
* @title Initialize the client and server to tls1.3. Construct the scenario where the HRR message is sent and the HRR
* message does not carry the supportedversion extension,
* The client is expected to perform the 1.2 handshake process and the status is TRY_RECV_CERTIFICATIONATE.
* @precon nan
* @brief 4.1.4. Hello Retry Request row33
* Initialize the client and server to tls1.3, construct the scenario where the HRR message is sent, and construct
* the HRR message that does not carry the supportedversion extension,
* The client is expected to perform the 1.2 handshake process and the status is TRY_RECV_CERTIFICATIONATE.
* @expect 1. The client is in the TRY_RECV_CERTIFICATIONATE state.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_EXTENSION_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportExtendMasterSecret = false;
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
serverMsg->supportedVersion.exState = MISSING_FIELD;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(clientTlsCtx->hsCtx->state, TRY_RECV_CERTIFICATE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_EXTENSION_FUNC_TC002
* @spec The server's extensions must contain "supported_versions".
* Additionally, it SHOULD contain the minimal set of extensions
* necessary for the client to generate a correct ClientHello pair. As
* with the ServerHello, a HelloRetryRequest MUST NOT contain any
* extensions that were not first offered by the client in its
* ClientHello, with the exception of optionally the "cookie" (see
* Section 4.2.2) extension.
* @title Initialize the client server to tls1.3, construct the scenario where the hrr message is sent, and construct the
* hrr message carrying the sni extension. The client is expected to return the illegal_parameter alarm.
* @precon nan
* @brief 4.1.4. Hello Retry Request row33
* Initialize the client server to tls1.3, construct the scenario where the hrr message is sent, and construct the
* hrr message carrying the sni extension. The client is expected to return the illegal_parameter alarm.
* @expect 1. The client returns the illegal_parameter alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_EXTENSION_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
serverMsg->serverName.exState = INITIAL_FIELD;
serverMsg->serverName.exType.state = INITIAL_FIELD;
serverMsg->serverName.exLen.state = INITIAL_FIELD;
serverMsg->serverName.exLen.data = 0x00;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_EXTENSION_TYPE);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_EXTENSION_FUNC_TC003
* @spec The server's extensions must contain "supported_versions".
* Additionally, it SHOULD contain the minimal set of extensions
* necessary for the client to generate a correct ClientHello pair. As
* with the ServerHello, a HelloRetryRequest MUST NOT contain any
* extensions that were not first offered by the client in its
* ClientHello, with the exception of optionally the "cookie" (see
* Section 4.2.2) extension.
* @title Initialize the client and server to tls1.3, construct the scenario where the hrr message is sent and the hrr
* message does not carry the key_share extension, and the client is expected to return the illegal_parameter alarm.
* @precon nan
* @brief 4.1.4. Hello Retry Request row33
* Initialize the client server to tls1.3, construct the scenario where the hrr message is sent, and construct the hrr
* message that does not carry the key_share extension. The client is expected to return the illegal_parameter alarm.
* @expect 1. The client returns the illegal_parameter alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_EXTENSION_FUNC_TC003()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
/* Initialize the client and server to tls1.3, construct the scenario where the hrr message is sent and the hrr
* message does not carry the key_share extension */
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
serverMsg->keyShare.exState = MISSING_FIELD;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_MISSING_EXTENSION);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_FORMAT_FUNC_TC001
* @spec Upon receipt of a HelloRetryRequest, the client MUST check the
* legacy_version, legacy_session_id_echo, cipher_suite, and
* legacy_compression_method as specified in Section 4.1.3 and then
* process the extensions, starting with determining the version using
* "supported_versions". Clients MUST abort the handshake with an
* "illegal_parameter" alert if the HelloRetryRequest would not result
* in any change in the ClientHello. If a client receives a second
* HelloRetryRequest in the same connection (i.e., where the ClientHello was itself in response to a
* HelloRetryRequest),
* it MUST abort the handshake with an "unexpected_message" alert.
* Otherwise, the client MUST process all extensions in the HelloRetryRequest and send a second updated
* ClientHello.
* @title Initialize the client and server as tls1.3. Construct the scenario where two hrr messages are sent. The
* client is expected to stop handshake and send unexpected_message alarms.
* @precon nan
* @brief 4.1.4. Hello Retry Request row34
* Initialize the client and server as tls1.3, construct the scenario where two hrr messages are sent, and the
* client is expected to stop handshake and send the unexpected_message alarm.
* @expect 1. The client sends the unexpected_message alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_FORMAT_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
/* Initialize the client and server as tls1.3. Construct the scenario where two hrr messages are sent. */
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(clientTlsCtx->hsCtx->state == TRY_SEND_CLIENT_HELLO);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(clientTlsCtx->hsCtx->state == TRY_RECV_SERVER_HELLO);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_SERVER_HELLO);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_ENCRYPTED_EXTENSIONS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
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
};
ASSERT_TRUE(memcpy_s(serverMsg->randomValue.data, sizeof(g_hrrRandom) / sizeof(uint8_t),
g_hrrRandom, sizeof(g_hrrRandom) / sizeof(uint8_t)) == 0);
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_DUPLICATE_HELLO_RETYR_REQUEST);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_FORMAT_FUNC_TC002
* @spec Upon receipt of a HelloRetryRequest, the client MUST check the
* legacy_version, legacy_session_id_echo, cipher_suite, and
* legacy_compression_method as specified in Section 4.1.3 and then
* process the extensions, starting with determining the version using
* "supported_versions". Clients MUST abort the handshake with an
* "illegal_parameter" alert if the HelloRetryRequest would not result
* in any change in the ClientHello. If a client receives a second
* HelloRetryRequest in the same connection (i.e., where the ClientHello was itself in response to a
* HelloRetryRequest),
* it MUST abort the handshake with an "unexpected_message" alert.
* Otherwise, the client MUST process all extensions in the HelloRetryRequest and send a second updated
* ClientHello.
* @title The client server is initialized to the tls1.3 version, and the legacy_version in the hrr message is changed
* to 0x0304. The client is expected to return illegal_parameter alert.
* @precon nan
* @brief 4.1.4. Hello Retry Request row34
* The client and server are initialized to tls1.3 and the legacy_version in the hrr message is changed to
* 0x0304. The client is expected to return illegal_parameter alert.
* @expect 1. The client sends the unexpected_message alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_FORMAT_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
serverMsg->version.data = 0x0304;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_PROTOCOL_VERSION);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_FORMAT_FUNC_TC003
* @spec Upon receipt of a HelloRetryRequest, the client MUST check the
* legacy_version, legacy_session_id_echo, cipher_suite, and
* legacy_compression_method as specified in Section 4.1.3 and then
* process the extensions, starting with determining the version using
* "supported_versions". Clients MUST abort the handshake with an
* "illegal_parameter" alert if the HelloRetryRequest would not result
* in any change in the ClientHello. If a client receives a second
* HelloRetryRequest in the same connection (i.e., where the ClientHello was itself in response to a
* HelloRetryRequest), it MUST abort the handshake with an "unexpected_message" alert.
* Otherwise, the client MUST process all extensions in the HelloRetryRequest and send a second updated
* ClientHello.
* @title The client and server are initialized to tls1.3. Change the legacy_version in the hrr message to 0x0302. The
* client is expected to return illegal_parameter alert.
* @precon nan
* @brief 4.1.4. Hello Retry Request row34
* The client and server are initialized to tls1.3 and the legacy_version in the hrr message is changed to
* 0x0302. The client is expected to return illegal_parameter alert.
* @expect 1. The client sends the unexpected_message alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_FORMAT_FUNC_TC003()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
/* The client and server are initialized to tls1.3. Change the legacy_version in the hrr message to 0x0302. */
serverMsg->version.data = 0x0302;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_PROTOCOL_VERSION);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_FORMAT_FUNC_TC004
* @spec Upon receipt of a HelloRetryRequest, the client MUST check the
* legacy_version, legacy_session_id_echo, cipher_suite, and
* legacy_compression_method as specified in Section 4.1.3 and then
* process the extensions, starting with determining the version using
* "supported_versions". Clients MUST abort the handshake with an
* "illegal_parameter" alert if the HelloRetryRequest would not result
* in any change in the ClientHello. If a client receives a second
* HelloRetryRequest in the same connection (i.e., where the ClientHello was itself in response to a
* HelloRetryRequest),
* it MUST abort the handshake with an "unexpected_message" alert.
* Otherwise, the client MUST process all extensions in the HelloRetryRequest and send a second updated
* ClientHello.
* @title Initialize the client and server to TLS1.3. Construct the scenario where the session_id field in the hrr is
* modified. The client is expected to send an illegal parameter alarm after receiving the modification.
* @precon nan
* @brief 4.1.4. Hello Retry Request row34
* Initialize the client and server to TLS1.3 and construct the scenario where the hrr session_id field is
* modified. The client is expected to send an illegal parameter alarm after receiving the modification.
* @expect 1. The client sends an illegal parameter alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_FORMAT_FUNC_TC004()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg parsedSH = {0};
uint32_t parseLen = 0;
FRAME_Type frameType = {0};
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &parsedSH, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *shMsg = &parsedSH.body.hsMsg.body.serverHello;
memset_s((shMsg->sessionId.data), shMsg->sessionId.size, 1, shMsg->sessionId.size);
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &parsedSH, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(client->ssl), HITLS_MSG_HANDLE_ILLEGAL_SESSION_ID);
EXIT:
FRAME_CleanMsg(&frameType, &parsedSH);
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_FORMAT_FUNC_TC005
* @spec Upon receipt of a HelloRetryRequest, the client MUST check the
* legacy_version, legacy_session_id_echo, cipher_suite, and
* legacy_compression_method as specified in Section 4.1.3 and then
* process the extensions, starting with determining the version using
* "supported_versions". Clients MUST abort the handshake with an
* "illegal_parameter" alert if the HelloRetryRequest would not result
* in any change in the ClientHello. If a client receives a second
* HelloRetryRequest in the same connection (i.e., where the ClientHello was itself in response to a
* HelloRetryRequest),
* it MUST abort the handshake with an "unexpected_message" alert.
* Otherwise, the client MUST process all extensions in the HelloRetryRequest and send a second updated
* ClientHello.
* @title The client server is initialized to the TLS1.3 version, and the value of cipher_suite in the hrr message is
* changed to a value other than the value provided by the client. The client is expected to return
* illegal_parameter alert.
* @precon nan
* @brief 4.1.4. Hello Retry Request row34
* The client and server are initialized to the TLS1.3 version, and the value of cipher_suite in the hrr
* message is changed to a value that is not provided by the client. The client is expected to return
* illegal_parameter alert.
* @expect 1. The client sends an illegal parameter alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_FORMAT_FUNC_TC005()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg parsedSH = {0};
uint32_t parseLen = 0;
FRAME_Type frameType;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &parsedSH, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *shMsg = &parsedSH.body.hsMsg.body.serverHello;
shMsg->cipherSuite.data = HITLS_AES_128_CCM_SHA256;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &parsedSH, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(client->ssl), HITLS_MSG_HANDLE_CIPHER_SUITE_ERR);
FrameUioUserData *userData = BSL_UIO_GetUserData(client->io);
uint8_t *alertBuf = userData->sndMsg.msg;
uint32_t alertLen = userData->sndMsg.len;
FRAME_Msg parsedAlert = {0};
uint32_t parsedAlertLen = 0;
ASSERT_TRUE(FRAME_ParseTLSNonHsRecord(alertBuf, alertLen, &parsedAlert, &parsedAlertLen) == HITLS_SUCCESS);
ASSERT_TRUE(parsedAlert.recType.data == REC_TYPE_ALERT);
FRAME_AlertMsg *alertMsg = &parsedAlert.body.alertMsg;
ASSERT_TRUE(alertMsg->alertLevel.data == ALERT_LEVEL_FATAL);
ASSERT_EQ(alertMsg->alertDescription.data, ALERT_ILLEGAL_PARAMETER);
EXIT:
FRAME_CleanMsg(&frameType, &parsedSH);
FRAME_CleanNonHsRecord(REC_TYPE_ALERT, &parsedAlert);
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_FORMAT_FUNC_TC006
* @spec Upon receipt of a HelloRetryRequest, the client MUST check the
* legacy_version, legacy_session_id_echo, cipher_suite, and
* legacy_compression_method as specified in Section 4.1.3 and then
* process the extensions, starting with determining the version using
* "supported_versions". Clients MUST abort the handshake with an
* "illegal_parameter" alert if the HelloRetryRequest would not result
* in any change in the ClientHello. If a client receives a second
* HelloRetryRequest in the same connection (i.e., where the ClientHello was itself in response to a
* HelloRetryRequest),
* it MUST abort the handshake with an "unexpected_message" alert.
* Otherwise, the client MUST process all extensions in the HelloRetryRequest and send a second updated
* ClientHello.
* @title Construct hrr compression algorithm. The value is 1. The server is expected to return illegal_parameter
* alert.
* @precon nan
* @brief 4.1.4. Hello Retry Request row34
* Construct the hrr compression algorithm byte and set the value to 1. The server is expected to return
* illegal_parameter alert.
* @expect 1. The client sends an illegal parameter alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_FORMAT_FUNC_TC006()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
serverMsg->compressionMethod.data = 0x01;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_PARSE_COMPRESSION_METHOD_ERR);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_EXTENSION_CONTENT_FUNC_TC001
* @spec The HelloRetryRequest extensions defined in this specification are:
* - supported_versions (see Section 4.2.1)
* - cookie (see Section 4.2.2)
* - key_share (see Section 4.2.8)
* A client which receives a cipher suite that was not offered MUST
* abort the handshake. Servers MUST ensure that they negotiate the
* same cipher suite when receiving a conformant updated ClientHello.
* Upon receiving the ServerHello,
* clients MUST check that the cipher suite supplied in the ServerHello is the same as that in the
* HelloRetryRequest and otherwise abort the handshake with an "illegal_parameter" alert.
* @title The client and server are initialized to the TLS1.3 version. In the scenario where the hrr message is sent,
* the hrr cipher suite is changed to an algorithm that is not provided by the client. The expected connection
* establishment fails and the illegal_parameter alarm is returned.
* @precon nan
* @brief 4.1.4. Hello Retry Request row35
* The client and server are initialized to the TLS1.3 version, construct the scenario where the hrr message is
* sent, and modify the hrr algorithm suite to an algorithm that is not provided by the client. In this case,
* the expected connection establishment fails and the illegal_parameter alarm is returned.
* @expect 1. The client returns the illegal_parameter alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_EXTENSION_CONTENT_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
serverMsg->cipherSuite.data = HITLS_RSA_WITH_AES_128_CBC_SHA;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_CIPHER_SUITE_ERR);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_EXTENSION_CONTENT_FUNC_TC002
* @spec The HelloRetryRequest extensions defined in this specification are:
* - supported_versions (see Section 4.2.1)
* - cookie (see Section 4.2.2)
* - key_share (see Section 4.2.8)
* A client which receives a cipher suite that was not offered MUST
* abort the handshake. Servers MUST ensure that they negotiate the
* same cipher suite when receiving a conformant updated ClientHello.
* Upon receiving the ServerHello,
* clients MUST check that the cipher suite supplied in the ServerHello is the same as that in the
* HelloRetryRequest and otherwise abort the handshake with an "illegal_parameter" alert.
* @title 2. Initialize the client and server to TLS1.3, construct the scenario where the hrr message is sent, and
* change the algorithm suite for the client hello message to be sent again to the new algorithm suite. It is
* expected that the connection fails to be established and the illegal_parameter alarm is returned.
* @precon nan
* @brief 4.1.4. Hello Retry Request row35
* 2. Initialize the client and server to TLS1.3, construct the scenario of sending hrr messages, and change
* the cipher suite of the client hello message to be sent again to the new cipher suite. It is expected that
* the connection fails to be established and the illegal_parameter alarm is returned.
* @expect 1. The server returns the illegal_parameter alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_EXTENSION_CONTENT_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(clientTlsCtx->hsCtx->state == TRY_SEND_CLIENT_HELLO);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(clientTlsCtx->hsCtx->state == TRY_RECV_SERVER_HELLO);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, CLIENT_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
/* Initialize the client and server to TLS1.3, construct the scenario where the hrr message is sent, and
* change the algorithm suite for the client hello message to be sent again to the new algorithm suite. */
FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
clientMsg->cipherSuites.data[0] = HITLS_AES_128_GCM_SHA256;
clientMsg->cipherSuites.data[1] = HITLS_AES_256_GCM_SHA384;
clientMsg->cipherSuites.data[2] = HITLS_CHACHA20_POLY1305_SHA256;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(server->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ioUserData->sndMsg.len = 0;
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_MSG_HANDLE_ILLEGAL_CIPHER_SUITE);
ALERT_Info info = { 0 };
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_EXTENSION_CONTENT_FUNC_TC003
* @spec The HelloRetryRequest extensions defined in this specification are:
* - supported_versions (see Section 4.2.1)
* - cookie (see Section 4.2.2)
* - key_share (see Section 4.2.8)
* A client which receives a cipher suite that was not offered MUST
* abort the handshake. Servers MUST ensure that they negotiate the
* same cipher suite when receiving a conformant updated ClientHello.
* Upon receiving the ServerHello,
* clients MUST check that the cipher suite supplied in the ServerHello is the same as that in the
* HelloRetryRequest and otherwise abort the handshake with an "illegal_parameter" alert.
* @title 3. Initialize the client and server to TLS1.3. Construct the scenario where the HRR message is sent. Modify
* the cipher suite in the serverhello message to be different from that in the HRR message. As a result, the
* expected connection establishment fails and the illegal_parameter alarm is returned.
* @precon nan
* @brief 4.1.4. Hello Retry Request row35
* 3. The client and server are initialized to TLS1.3, construct the scenario where hrr is sent, modify the
* cipher suite in serverhello and hrr to be different, and the expected connection setup fails and the
* illegal_parameter alarm is returned.
* @expect 1. The client returns the illegal_parameter alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_EXTENSION_CONTENT_FUNC_TC003()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(clientTlsCtx->hsCtx->state == TRY_SEND_CLIENT_HELLO);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(clientTlsCtx->hsCtx->state == TRY_RECV_SERVER_HELLO);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_SERVER_HELLO);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_ENCRYPTED_EXTENSIONS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
serverMsg->cipherSuite.data = HITLS_AES_128_GCM_SHA256;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_ILLEGAL_CIPHER_SUITE);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_SUPPORT_VERSION_FUNC_TC001
* @spec The value of selected_version in the HelloRetryRequest
* "supported_versions" extension MUST be retained in the ServerHello,
* and a client MUST abort the handshake with an "illegal_parameter"
* alert if the value changes.
* @title 1. Initialize the client and server as tls1.3, construct a scenario where the supportedversion values
* carried by serverhello and hrr are different,
* The client is expected to return the illegal_parameter alarm.
* @precon nan
* @brief 4.1.4. Hello Retry Request row37
* 1. Initialize the client and server to tls1.3, construct the scenario where the supportedversion values carried
* by serverhello and hrr are different,
* The client is expected to return the illegal_parameter alarm.
* @expect 1. The client returns the illegal_parameter alarm.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_SUPPORT_VERSION_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_CFG_SetVersionSupport(&client->ssl->config.tlsConfig, 0x00000030U);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
/* 1. Initialize the client and server to tls1.3, construct the scenario where the supportedversion values carried
by serverhello and hrr are different, */
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(clientTlsCtx->hsCtx->state == TRY_SEND_CLIENT_HELLO);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(clientTlsCtx->hsCtx->state == TRY_RECV_SERVER_HELLO);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_SERVER_HELLO);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_ENCRYPTED_EXTENSIONS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
uint8_t *recvBuf = ioUserData->recMsg.msg;
uint32_t recvLen = ioUserData->recMsg.len;
ASSERT_TRUE(recvLen != 0);
FRAME_Msg frameMsg = { 0 };
FRAME_Type frameType = { 0 };
uint32_t parseLen = 0;
SetFrameType(&frameType, HITLS_VERSION_TLS13, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
serverMsg->supportedVersion.data.data = 0x0303;
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ioUserData->recMsg.len = 0;
ASSERT_TRUE(FRAME_TransportRecMsg(client->io, sendBuf, sendLen) == HITLS_SUCCESS);
FRAME_CleanMsg(&frameType, &frameMsg);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_PROTOCOL_VERSION);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* If the client curve is HITLS_EC_GROUP_CURVE25519 and the certificate is SECP256R1, the connection is successfully
* established, indicating that the curve in tls1.3 is not associated with the certificate. */
/* BEGIN_CASE */
void SDV_TLS13_RFC8446_KeyShareGroup_TC003(int version, int connType)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
const char *writeBuf = "Hello world";
uint8_t readBuf[BUF_SIZE_DTO_TEST] = {0};
uint32_t readLen;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
SetCertPath(serverCtxConfig, "ecdsa_sha256", true);
HLT_SetTls13CipherSuites(serverCtxConfig, "HITLS_AES_128_GCM_SHA256");
serverRes = HLT_ProcessTlsAccept(localProcess, version, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
SetCertPath(clientCtxConfig, "ecdsa_sha256", false);
HLT_SetGroups(clientCtxConfig, "HITLS_EC_GROUP_CURVE25519");
HLT_SetTls13CipherSuites(clientCtxConfig, "HITLS_AES_128_GCM_SHA256");
clientRes = HLT_ProcessTlsInit(remoteProcess, version, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_RpcTlsConnect(remoteProcess, clientRes->sslId), HITLS_SUCCESS);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, clientRes->sslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, BUF_SIZE_DTO_TEST, 0, BUF_SIZE_DTO_TEST) == EOK);
ASSERT_TRUE(HLT_TlsRead(serverRes->ssl, readBuf, BUF_SIZE_DTO_TEST, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
EXIT:
HLT_CleanFrameHandle();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HRR_SUPPORT_VERSION_FUNC_TC001
* @title During the TLS1.3 HRR handshaking, application messages can not be received
* @precon nan
* @brief
* 1. Initialize the client and server to tls1.3, construct the scenario where the supportedversion values carried
* by serverhello and hrr are different, expect result 1.
* 2. Send a app data message the server, expect reslut 2.
* @expect 1. The client send secend client hello message.
8 2. The server send unexpected message alert.
@ */
/* BEGIN_CASE */
void UT_TLS13_RFC8446_HRR_APP_RECV_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLSConfig();
tlsConfig->isSupportClientVerify = true;
HITLS_CFG_SetKeyExchMode(tlsConfig, TLS13_KE_MODE_PSK_WITH_DHE);
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(&(serverTlsCtx->config.tlsConfig), groups, groupsSize);
/* 1. Initialize the client and server to tls1.3, construct the scenario where the supportedversion values carried
by serverhello and hrr are different, */
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
CONN_Deinit(serverTlsCtx);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_CHANGE_CIPHER_SPEC);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_RECV_CLIENT_HELLO);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(clientTlsCtx->hsCtx->state == TRY_SEND_CLIENT_HELLO);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
uint32_t sendLenapp = 7;
uint8_t sendBufapp[7] = {0x17, 0x03, 0x03, 0x00, 0x02, 0x05, 0x05};
uint32_t writeLen;
BSL_UIO_Write(clientTlsCtx->uio, sendBufapp, sendLenapp, &writeLen);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* IN TLS1.3, mutiple ccs can be received*/
/* BEGIN_CASE */
void UT_TLS13_RFC8446_RECV_MUTI_CCS_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_CERTIFICATE_VERIFY) == HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
uint32_t sendLenccs = 6;
uint8_t sendBufccs[6] = {0x14, 0x03, 0x03, 0x00, 0x01, 0x01};
uint32_t writeLen;
for (int i = 0; i < 5; i++) {
BSL_UIO_Write(serverTlsCtx->uio, sendBufccs, sendLenccs, &writeLen);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
}
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/consistency/tls13/test_suite_sdv_frame_tls13_consistency_rfc8446_kex.c
|
C
|
unknown
| 229,586
|
/*
* 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.
*/
/* BEGIN_HEADER */
/* INCLUDE_BASE test_suite_tls13_consistency_rfc8446 */
#include <stdio.h>
#include "stub_replace.h"
#include "hitls.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_uio.h"
#include "tls.h"
#include "hs_ctx.h"
#include "pack.h"
#include "send_process.h"
#include "frame_link.h"
#include "frame_tls.h"
#include "frame_io.h"
#include "simulate_io.h"
#include "parser_frame_msg.h"
#include "rec_wrapper.h"
#include "cert.h"
#include "securec.h"
#include "conn_init.h"
#include "hitls_crypt_init.h"
#include "hitls_psk.h"
#include "common_func.h"
#include "alert.h"
#include "process.h"
#include "bsl_sal.h"
/* END_HEADER */
#define MAX_BUF 16384
int32_t STUB_RecConnDecrypt(
TLS_Ctx *ctx, RecConnState *state, const REC_TextInput *cryptMsg, uint8_t *data, uint32_t *dataLen)
{
(void)ctx;
(void)state;
memcpy_s(data, cryptMsg->textLen, cryptMsg->text, cryptMsg->textLen);
(void)data;
*dataLen = cryptMsg->textLen;
return HITLS_SUCCESS;
}
int32_t STUB_REC_Write(TLS_Ctx *ctx, REC_Type recordType, const uint8_t *data, uint32_t num)
{
(void)ctx;
(void)recordType;
(void)data;
(void)num;
return HITLS_SUCCESS;
}
extern int32_t __real_REC_Write(TLS_Ctx *ctx, REC_Type recordType, const uint8_t *data, uint32_t num);
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC001
* @spec -
* @title The client does not support posthandshake, but receives a server certificate request
* message after the connection establishment is completed.
* @precon nan
* @brief
* 1. Apply and initialize config
* 2. Set the client not to support post-handshake extension
* 3. After the connection establishment is completed, the construction server sends a certificate request message to the
* client
* 4. Observe client behavior
* @expect
* 1. Initialization successful
* 2. Setup successful
* 3. Send successfully.
* 4. The client returns alert ALERT_UNEXPECTED_MESSAGE.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC001(void)
{
FRAME_Init();
// Apply and initialize config
HITLS_Config *c_config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(c_config != NULL);
HITLS_Config *s_config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(s_config != NULL);
// Set the client not to support post-handshake extension
HITLS_CFG_SetPostHandshakeAuthSupport(c_config, false);
HITLS_CFG_SetPostHandshakeAuthSupport(s_config, false);
FRAME_LinkObj *client = FRAME_CreateLink(c_config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
FRAME_LinkObj *server = FRAME_CreateLink(s_config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_GetTls13DisorderHsMsg(CERTIFICATE_REQUEST, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ASSERT_EQ(REC_Write(server->ssl, REC_TYPE_HANDSHAKE, sendBuf, sendLen), HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(server, client) == HITLS_SUCCESS);
uint8_t readbuff[READ_BUF_SIZE];
uint32_t readLen;
ASSERT_TRUE(client->ssl != NULL);
// The client returns alert ALERT_UNEXPECTED_MESSAGE
ASSERT_EQ(HITLS_Read(client->ssl, readbuff, READ_BUF_SIZE, &readLen), HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(c_config);
HITLS_CFG_FreeConfig(s_config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC010
* @spec -
* @title The server receives out-of-order messages during authentication after handshake.
* @precon nan
* @brief
* 1. Apply and initialize config
* 2. Set the client support post-handshake extension
* 3. After the connection is established, the server receives the CertificateVerify message.
* @expect
* 1. Initialization succeeded.
* 2. Set succeeded.
* 3. The server sends an alert message, and the connection is interrupted.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC010(void)
{
FRAME_Init();
// Apply and initialize config
HITLS_Config *c_config = HITLS_CFG_NewTLS13Config();
HITLS_Config *s_config = HITLS_CFG_NewTLS13Config();
// Set the client support post-handshake extension
HITLS_CFG_SetPostHandshakeAuthSupport(c_config, true);
HITLS_CFG_SetPostHandshakeAuthSupport(s_config, true);
HITLS_CFG_SetClientVerifySupport(c_config, true);
HITLS_CFG_SetClientVerifySupport(s_config, true);
FRAME_LinkObj *client = FRAME_CreateLink(c_config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
FRAME_LinkObj *server = FRAME_CreateLink(s_config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
ASSERT_EQ(HITLS_VerifyClientPostHandshake(server->ssl), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
uint32_t sendLen = MAX_RECORD_LENTH;
uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
ASSERT_TRUE(FRAME_GetTls13DisorderHsMsg(CERTIFICATE_VERIFY, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
ASSERT_EQ(REC_Write(client->ssl, REC_TYPE_HANDSHAKE, sendBuf, sendLen), HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(client, server) == HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
ASSERT_EQ(HITLS_Read(server->ssl, readBuf, READ_BUF_SIZE, &readLen), HITLS_MSG_HANDLE_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(c_config);
HITLS_CFG_FreeConfig(s_config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC018
* @spec -
* @title Invoke the HITLS_VerifyClientPostHandshake interface during connection establishment.
* @precon nan
* @brief
* 1. Apply for and initialize the configuration file. Expected result 1 is obtained.
* 2. Configure the client and server to support post-handshake extension. Expected result 3 is obtained.
* 3. When a connection is established, the server is in the Try_RECV_CLIENT_HELLO state, and the
* HITLS_VerifyClientPostHandshake interface is invoked.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The interface fails to be invoked.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC018(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
// Apply for and initialize the configuration file
config = HITLS_CFG_NewTLS13Config();
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
// Configure the client and server to support post-handshake extension
client->ssl->config.tlsConfig.isSupportPostHandshakeAuth = true;
server->ssl->config.tlsConfig.isSupportPostHandshakeAuth = true;
ASSERT_TRUE(client->ssl->config.tlsConfig.isSupportPostHandshakeAuth == true);
ASSERT_TRUE(server->ssl->config.tlsConfig.isSupportPostHandshakeAuth == true);
// he server is in the Try_RECV_CLIENT_HELLO state
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(server->ssl->hsCtx->state == TRY_RECV_CLIENT_HELLO);
// the HITLS_VerifyClientPostHandshake interface is invoked
ASSERT_EQ(HITLS_VerifyClientPostHandshake(client->ssl), HITLS_INVALID_INPUT);
ASSERT_EQ(HITLS_VerifyClientPostHandshake(server->ssl), HITLS_MSG_HANDLE_STATE_ILLEGAL);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC019
* @spec -
* @title The server does not support invoking the HITLS_VerifyClientPostHandshake interface after handshake
* authentication.
* @precon nan
* @brief
* 1. Apply for and initialize the configuration file. Expected result 1 is obtained.
* 2. Configure the client to support the post-handshake extension. The server does not support the post-handshake
* extension.
* 3. Establish a connection. The server invokes the HITLS_VerifyClientPostHandshake interface to initiate
* authentication.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The interface fails to be invoked.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC019(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
// Apply for and initialize the configuration file
config = HITLS_CFG_NewTLS13Config();
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
// Configure the client to support the post-handshake extension
client->ssl->config.tlsConfig.isSupportPostHandshakeAuth = true;
server->ssl->config.tlsConfig.isSupportPostHandshakeAuth = false;
ASSERT_TRUE(client->ssl->config.tlsConfig.isSupportPostHandshakeAuth == true);
ASSERT_TRUE(server->ssl->config.tlsConfig.isSupportPostHandshakeAuth == false);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT) == HITLS_SUCCESS);
// The server invokes the HITLS_VerifyClientPostHandshake interface to initiate authentication
ASSERT_EQ(HITLS_VerifyClientPostHandshake(client->ssl), HITLS_INVALID_INPUT);
ASSERT_EQ(HITLS_VerifyClientPostHandshake(server->ssl), HITLS_MSG_HANDLE_STATE_ILLEGAL);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/consistency/tls13/test_suite_sdv_frame_tls13_consistency_rfc8446_pha.c
|
C
|
unknown
| 10,630
|
/*
* 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.
*/
/* BEGIN_HEADER */
/* INCLUDE_BASE test_suite_tls13_consistency_rfc8446 */
#include "stub_replace.h"
#include "hitls.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_uio.h"
#include "tls.h"
#include "hs_ctx.h"
#include "pack.h"
#include "send_process.h"
#include "frame_link.h"
#include "frame_tls.h"
#include "frame_io.h"
#include "simulate_io.h"
#include "parser_frame_msg.h"
#include "cert.h"
#include "securec.h"
#include "conn_init.h"
#include "alert.h"
#include "hs_kx.h"
/* END_HEADER */
#define MAX_RECORD_LENTH (20 * 1024)
#define ALERT_BODY_LEN 2u
const uint8_t ccsMessage[] = {0x14, 0x03, 0x03, 0x00, 0x01, 0x01};
static int32_t SendCcs(HITLS_Ctx *ctx, uint8_t *data, uint8_t len)
{
/** Write records. */
int32_t ret = REC_Write(ctx, REC_TYPE_CHANGE_CIPHER_SPEC, data, len);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* If isFlightTransmitEnable is enabled, the stored handshake information needs to be sent. */
uint8_t isFlightTransmitEnable;
(void)HITLS_GetFlightTransmitSwitch(ctx, &isFlightTransmitEnable);
if (isFlightTransmitEnable == 1) {
ret = BSL_UIO_Ctrl(ctx->uio, BSL_UIO_FLUSH, 0, NULL);
if (ret == BSL_UIO_IO_BUSY) {
return HITLS_REC_NORMAL_IO_BUSY;
}
if (ret != BSL_SUCCESS) {
return HITLS_REC_ERR_IO_EXCEPTION;
}
}
return HITLS_SUCCESS;
}
static int32_t SendAlert(HITLS_Ctx *ctx, ALERT_Level level, ALERT_Description description)
{
uint8_t data[ALERT_BODY_LEN];
/** Obtain the alert level. */
data[0] = level;
data[1] = description;
/** Write records. */
int32_t ret = REC_Write(ctx, REC_TYPE_ALERT, data, ALERT_BODY_LEN);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* If isFlightTransmitEnable is enabled, the stored handshake information needs to be sent. */
uint8_t isFlightTransmitEnable;
(void)HITLS_GetFlightTransmitSwitch(ctx, &isFlightTransmitEnable);
if (isFlightTransmitEnable == 1) {
ret = BSL_UIO_Ctrl(ctx->uio, BSL_UIO_FLUSH, 0, NULL);
if (ret == BSL_UIO_IO_BUSY) {
return HITLS_REC_NORMAL_IO_BUSY;
}
if (ret != BSL_SUCCESS) {
return HITLS_REC_ERR_IO_EXCEPTION;
}
}
return HITLS_SUCCESS;
}
static int32_t SendErrorAlert(HITLS_Ctx *ctx, ALERT_Level level, ALERT_Description description)
{
uint8_t data[2 * ALERT_BODY_LEN] = {level, description, level, description};
/** Write records. */
int32_t ret = REC_Write(ctx, REC_TYPE_ALERT, data, 2 * ALERT_BODY_LEN);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* If isFlightTransmitEnable is enabled, the stored handshake information needs to be sent. */
uint8_t isFlightTransmitEnable;
(void)HITLS_GetFlightTransmitSwitch(ctx, &isFlightTransmitEnable);
if (isFlightTransmitEnable == 1) {
ret = BSL_UIO_Ctrl(ctx->uio, BSL_UIO_FLUSH, 0, NULL);
if (ret == BSL_UIO_IO_BUSY) {
return HITLS_REC_NORMAL_IO_BUSY;
}
if (ret != BSL_SUCCESS) {
return HITLS_REC_ERR_IO_EXCEPTION;
}
}
return HITLS_SUCCESS;
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_IGNORE_CCS_FUNC_TC001
* @spec An implementation may receive an unencrypted record of
* type change_cipher_spec consisting of the single byte
* value 0x01 at any time after the first ClientHello message
* has been sent or received and before the peer's Finished message
* has been received and MUST simply drop it without further processing.
* @title When receiving an unencrypted CCS message, the system discards the message.
* @precon nan
* @brief 5 Record Protocol line 181
* 1. After the client sends a client hello message, the CCS message received by the client is not encrypted
* (value: 0x01).
* Discard the message and do not process the message. If the CCS message that is not encrypted is received
* again (value: 0x01), the system discards the message.
* 3. Before the client receives the finished message, the client receives the CCS message that is not
* encrypted (value: 0x01) and discards the message.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_IGNORE_CCS_FUNC_TC001(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_SEND_SERVER_HELLO) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FrameMsg sndMsg;
ASSERT_TRUE(memcpy_s(sndMsg.msg, MAX_RECORD_LENTH, ioServerData->sndMsg.msg, ioServerData->sndMsg.len) == EOK);
sndMsg.len = ioServerData->sndMsg.len;
ioServerData->sndMsg.len = 0;
uint8_t data = 1;
ASSERT_EQ(SendCcs(server->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* 1. After the client sends a client hello message, the CCS message received by the client is not encrypted */
/* 3. Before the client receives the finished message, the client receives the CCS message that is not
* encrypted */
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(SendCcs(server->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_NORMAL_RECV_BUF_EMPTY);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_IGNORE_CCS_FUNC_TC002
* @spec An implementation may receive an unencrypted record of
* type change_cipher_spec consisting of the single byte
* value 0x01 at any time after the first ClientHello message
* has been sent or received and before the peer's Finished message
* has been received and MUST simply drop it without further processing.
* @title When receiving an unencrypted CCS message, the system discards the message.
* @precon nan
* @brief 5 Record Protocol line 181
* 2. After the first connection is established, the server receives the client hello message and receives the
* CCS message that is not encrypted (value: 0x01). The server discards the message and does not process
* the message.
* 4. If the server receives the CCS message that is not encrypted (value: 0x01) before the finished message is
* received during the first connection setup, Discard the message and do not process the message. If the
* CCS message that is not encrypted is received again (value: 0x01), the system sends the
* unexpected_message alarm to terminate the handshake.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_IGNORE_CCS_FUNC_TC002(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_SEND_CERTIFICATE) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FrameMsg recMsg;
ASSERT_TRUE(memcpy_s(recMsg.msg, MAX_RECORD_LENTH, ioServerData->recMsg.msg, ioServerData->recMsg.len) == EOK);
recMsg.len = ioServerData->recMsg.len;
ioServerData->recMsg.len = 0;
uint8_t data = 1;
ASSERT_EQ(SendCcs(client->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* 2. After the first connection is established, the server receives the client hello message and receives the
* CCS message that is not encrypted (value: 0x01). The server discards the message and does not process
* the message.
* 4. If the server receives the CCS message that is not encrypted (value: 0x01) before the finished message is
* received during the first connection setup, Discard the message and do not process the message. If the
* CCS message that is not encrypted is received again (value: 0x01) */
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(SendCcs(client->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* The server generates the unexpected_message alarm after receiving the CCS message for the second time. */
ASSERT_TRUE(HITLS_Accept(server->ssl) == HITLS_REC_NORMAL_RECV_BUF_EMPTY);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_IGNORE_CCS_FUNC_TC003
* @spec An implementation may receive an unencrypted record of
* type change_cipher_spec consisting of the single byte
* value 0x01 at any time after the first ClientHello message
* has been sent or received and before the peer's Finished message
* has been received and MUST simply drop it without further processing.
* @title When receiving an unencrypted CCS message, the system discards the message.
* @precon nan
* @brief 5 Record Protocol line 181
* 5. After the session is recovered, the clien sends the clienthello message, receives the CCS message that is
* not encrypted (value: 0x01), and discards the message.
* 7. The session is resumed. Before the finished message is received, the client receives a CCS message that
* is not encrypted (value: 0x01). The client discards the message and does not process the message.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_IGNORE_CCS_FUNC_TC003(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_SEND_SERVER_HELLO) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FrameMsg sndMsg;
ASSERT_TRUE(memcpy_s(sndMsg.msg, MAX_RECORD_LENTH, ioServerData->sndMsg.msg, ioServerData->sndMsg.len) == EOK);
sndMsg.len = ioServerData->sndMsg.len;
ioServerData->sndMsg.len = 0;
uint8_t data = 1;
ASSERT_EQ(SendCcs(server->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* 5. After the session is recovered, the clien sends the clienthello message, receives the CCS message that is
* not encrypted (value: 0x01), and discards the message.
* 7. The session is resumed. Before the finished message is received, the client receives a CCS message
* that is not encrypted (value: 0x01). */
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_NORMAL_RECV_BUF_EMPTY);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_IGNORE_CCS_FUNC_TC004
* @spec An implementation may receive an unencrypted record of
* type change_cipher_spec consisting of the single byte
* value 0x01 at any time after the first ClientHello message
* has been sent or received and before the peer's Finished message
* has been received and MUST simply drop it without further processing.
* @title When receiving an unencrypted CCS message, the system discards the message.
* @precon nan
* @brief 5 Record Protocol line 181
* 6. After the session is resumed, the server receives a CCS message that is not encrypted (value: 0x01) after
* receiving the client hello message,
* The message is discarded and not processed. If the CCS message is received again and the unencrypted record
* (value: 0x01) is not encrypted, the alarm "unexpected_message" is sent to terminate the handshake.
* 8. The session is recovered. Before the server receives the finished message, the CCS message is not
* encrypted and the value is 0x01, and the message is discarded.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_IGNORE_CCS_FUNC_TC004(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_FINISH) == HITLS_SUCCESS);
ASSERT_EQ(server->ssl->hsCtx->state, TRY_RECV_FINISH);
uint8_t isReused = 0;
ASSERT_EQ(HITLS_IsSessionReused(client->ssl, &isReused), HITLS_SUCCESS);
ASSERT_EQ(isReused, 1);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FrameMsg recMsg;
ASSERT_TRUE(memcpy_s(recMsg.msg, MAX_RECORD_LENTH, ioServerData->recMsg.msg, ioServerData->recMsg.len) == EOK);
recMsg.len = ioServerData->recMsg.len;
ioServerData->recMsg.len = 0;
uint8_t data = 1;
ASSERT_EQ(SendCcs(client->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* 6.After the session is resumed, the server receives a CCS message that is not encrypted (value: 0x01) after
* receiving the client hello message,
* 8.The session is recovered. Before the server receives the finished message, the CCS message is not
* encrypted and the value is 0x01 */
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(SendCcs(client->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* The server generates the unexpected_message alarm after receiving the CCS message for the second time. */
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_IGNORE_CCS_FUNC_TC005
* @spec An implementation may receive an unencrypted record of
* type change_cipher_spec consisting of the single byte
* value 0x01 at any time after the first ClientHello message
* has been sent or received and before the peer's Finished message
* has been received and MUST simply drop it without further processing.
* @title When receiving unencrypted CCS messages, the system discards the messages.
* @precon nan
* @brief 5 Record Protocol line 181
* 9. After receiving the helloretry request, the client sends the client hello message for the second time.
* The received CCS message is not encrypted (value: 0x01).
* Discard the message and do not process the message. If the CCS message is received again,
* discard the messages.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_IGNORE_CCS_FUNC_TC005(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
/* Configure the server to support only the non-default curve. The server sends the HRR message. */
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(tlsConfig, groups, groupsSize);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, TRY_SEND_HELLO_RETRY_REQUEST), HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FrameMsg sndMsg;
ASSERT_TRUE(memcpy_s(sndMsg.msg, MAX_RECORD_LENTH, ioServerData->sndMsg.msg, ioServerData->sndMsg.len) == EOK);
sndMsg.len = ioServerData->sndMsg.len;
ioServerData->sndMsg.len = 0;
uint8_t data = 1;
ASSERT_EQ(SendCcs(server->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* 9.After receiving the helloretry request, the client sends the client hello message for the second time.
* The received CCS message is not encrypted (value: 0x01).
* Discard the message and do not process the message. If the CCS message is received again and the
* unencrypted record (value: 0x01) is received, the unexpected_message alarm is sent to terminate the handshake. */
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(SendCcs(server->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* client will discard the ccs */
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_NORMAL_RECV_BUF_EMPTY);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_IGNORE_CCS_FUNC_TC006
* @spec An implementation may receive an unencrypted record of
* type change_cipher_spec consisting of the single byte
* value 0x01 at any time after the first ClientHello message
* has been sent or received and before the peer's Finished message
* has been received and MUST simply drop it without further processing.
* @title When receiving an unencrypted CCS message, the system discards the message.
* @precon nan
* @brief 5 Record Protocol line 181
* 10. After the server sends a helloretry request, the client hello message is received for the second time,
* Send the unexpected_message alarm to terminate the handshake if the received CCS message is not encrypted
* (value: 0x01).
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_IGNORE_CCS_FUNC_TC006(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
const uint16_t groups[] = {HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
HITLS_CFG_SetGroups(tlsConfig, groups, groupsSize);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_FINISH) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FrameMsg recMsg;
ASSERT_TRUE(memcpy_s(recMsg.msg, MAX_RECORD_LENTH, ioServerData->recMsg.msg, ioServerData->recMsg.len) == EOK);
recMsg.len = ioServerData->recMsg.len;
ioServerData->recMsg.len = 0;
uint8_t data = 1;
ASSERT_EQ(SendCcs(client->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* 10. After the server sends a helloretry request, the client hello message is received for the second time,
* Send the unexpected_message alarm to terminate the handshake if the received CCS message is not
* encrypted (value: 0x01). */
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_REC_ERR_RECV_UNEXPECTED_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC001
* @spec An implementation which receives any other change_cipher_spec value or
* which receives a protected change_cipher_spec record MUST
* abort the handshake with an "unexpected_message" alert.
* @title Send the unexpected_message alarm when receiving other CCS messages.
* @precon nan
* @brief 5 Record Protocol line 182
* 1. After the client sends a client hello message to the client, the client sends an unexpected_message alarm
* to terminate the handshake because the client receives a CCS whose value is not 0x01.
* 7. Before the client receives the finised message, the client sends the unexpected_message alarm to
* terminate the handshake because the client receives a CCS whose value is not 0x01.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC001(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_SEND_SERVER_HELLO) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FrameMsg sndMsg;
ASSERT_TRUE(memcpy_s(sndMsg.msg, MAX_RECORD_LENTH, ioServerData->sndMsg.msg, ioServerData->sndMsg.len) == EOK);
sndMsg.len = ioServerData->sndMsg.len;
ioServerData->sndMsg.len = 0;
uint8_t data = 2;
ASSERT_EQ(SendCcs(server->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* The client receives an unencrypted CCS message (value: 0x01) and sends an unexpected_message alarm to terminate
* the handshake before the client receives the finished message. */
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC002
* @spec An implementation which receives any other change_cipher_spec value or
* which receives a protected change_cipher_spec record MUST
* abort the handshake with an "unexpected_message" alert.
* @title Send the unexpected_message alarm when receiving other CCS messages.
* @precon nan
* @brief 5 Record Protocol line 182
* 2. After the client sends the client hello message to the first connection setup, the client sends the
* unexpected_message alarm to terminate the handshake because the encrypted CCS is received.
* 9. Before the client receives the finised message, the client sends the unexpected_message alarm to
* terminate the handshake because the client receives the encrypted CCS.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC002(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
serverTlsCtx->recCtx->outBuf->end = 0;
uint32_t hashLen = SAL_CRYPT_DigestSize(serverTlsCtx->negotiatedInfo.cipherSuiteInfo.hashAlg);
ASSERT_EQ(
HS_SwitchTrafficKey(serverTlsCtx, serverTlsCtx->hsCtx->serverHsTrafficSecret, hashLen, true), HITLS_SUCCESS);
uint8_t data = 1;
ASSERT_EQ(SendCcs(server->ssl, &data, sizeof(data)), HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
ioServerData->sndMsg.msg[0] = REC_TYPE_CHANGE_CIPHER_SPEC;
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
ioClientData->recMsg.len = 0;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* 2. After the client sends the client hello message to the first connection setup, the client sends the
* unexpected_message alarm to terminate the handshake because the encrypted CCS is received.
* 9. Before the client receives the finised message, the client sends the unexpected_message alarm to
* terminate the handshake because the client receives the encrypted CCS. */
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC003
* @spec An implementation which receives any other change_cipher_spec value or
* which receives a protected change_cipher_spec record MUST
* abort the handshake with an "unexpected_message" alert.
* @title Send the unexpected_message alarm when receiving other CCS messages.
* @precon nan
* @brief 5 Record Protocol line 182
* 3. Before the server receives the client hello message, the server sends the unexpected_message alarm to terminate
* the handshake because it receives a CCS with a value other than 0x01.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC003(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
uint8_t data = 2;
ASSERT_EQ(SendCcs(client->ssl, &data, sizeof(data)), HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
ioServerData->recMsg.len = 0;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* Before the server receives the client hello message, the server sends the unexpected_message alarm to terminate
* the handshake because the server receives a CCS with a value other than 0x01. */
ASSERT_TRUE(HITLS_Accept(server->ssl) == HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC004
* @spec An implementation may receive an unencrypted record of
* type change_cipher_spec consisting of the single byte
* value 0x01 at any time after the first ClientHello message
* has been sent or received and before the peer's finished message
* has been received and MUST simply drop it without further processing.
* @title When receiving an unencrypted CCS message, the system discards the message.
* @precon nan
* @brief 5 Record Protocol line 181
* 4. After the first connection is established, the server receives the client hello message and receives the
* CCS whose value is not 0x01. Therefore, the server sends the unexpected_message alarm to terminate the
* handshake.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC004(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_SEND_CERTIFICATE) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FrameMsg recMsg;
ASSERT_TRUE(memcpy_s(recMsg.msg, MAX_RECORD_LENTH, ioServerData->recMsg.msg, ioServerData->recMsg.len) == EOK);
recMsg.len = ioServerData->recMsg.len;
ioServerData->recMsg.len = 0;
uint8_t data = 2;
ASSERT_EQ(SendCcs(client->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* 4.After the first connection is established, the server receives the client hello message and receives the
* CCS whose value is not 0x01. Therefore, the server sends the unexpected_message alarm to terminate the
* handshake. */
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC005
* @spec An implementation may receive an unencrypted record of
* type change_cipher_spec consisting of the single byte
* value 0x01 at any time after the first ClientHello message
* has been sent or received and before the peer's Finished message
* has been received and MUST simply drop it without further processing.
* @title When receiving an unencrypted CCS message, the system discards the message.
* @precon nan
* @brief 5 Record Protocol line 181
* 5. After the first connection is established, the server receives the client hello message and receives the
* encrypted CCS. Therefore, the server sends the unexpected_message alarm to terminate the handshake.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC005(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CERTIFICATE) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FrameMsg recMsg;
ASSERT_TRUE(memcpy_s(recMsg.msg, MAX_RECORD_LENTH, ioServerData->recMsg.msg, ioServerData->recMsg.len) == EOK);
recMsg.len = ioServerData->recMsg.len;
ioServerData->recMsg.len = 0;
clientTlsCtx->recCtx->outBuf->end = 0;
uint32_t hashLen = SAL_CRYPT_DigestSize(clientTlsCtx->negotiatedInfo.cipherSuiteInfo.hashAlg);
ASSERT_EQ(
HS_SwitchTrafficKey(clientTlsCtx, clientTlsCtx->hsCtx->serverHsTrafficSecret, hashLen, true), HITLS_SUCCESS);
/* Construct a non-0x1 CCS packet. */
uint8_t data = 1;
ASSERT_EQ(SendCcs(client->ssl, &data, sizeof(data)), HITLS_SUCCESS);
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
ioClientData->sndMsg.msg[0] = REC_TYPE_CHANGE_CIPHER_SPEC;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* After the first connection is established, the server receives the client hello message and receives the
* encrypted CCS. Therefore, the server sends the unexpected_message alarm to terminate the handshake. */
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC006
* @spec An implementation which receives any other change_cipher_spec value or
* which receives a protected change_cipher_spec record MUST
* abort the handshake with an "unexpected_message" alert.
* @title Send the unexpected_message alarm when receiving other CCS messages.
* @precon nan
* @brief 5 Record Protocol line 182
* 8. After the client receives the finised message, the client sends the unexpected_message alarm to terminate
* the handshake because it receives a CCS whose value is not 0x01.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC006(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
ioServerData->sndMsg.len = sizeof(ccsMessage);
memcpy_s(ioServerData->sndMsg.msg, ioServerData->sndMsg.len, ccsMessage, sizeof(ccsMessage));
ioServerData->sndMsg.msg[5] = 0x2;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* 8. After the client receives the finised message, the client sends the unexpected_message alarm to terminate
* the handshake because it receives a CCS whose value is not 0x01. */
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(clientTlsCtx, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_ERR_RECV_UNEXPECTED_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC007
* @spec An implementation which receives any other change_cipher_spec value or
* which receives a protected change_cipher_spec record MUST
* abort the handshake with an "unexpected_message" alert.
* @title Send the unexpected_message alarm when receiving other CCS messages.
* @precon nan
* @brief 5 Record Protocol line 182
* 9. After the client receives the finised message, the client sends the unexpected_message alarm to terminate
* the handshake because the client receives the encrypted CCS.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC007(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
uint8_t data = 1;
ASSERT_EQ(SendCcs(server->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ioServerData->sndMsg.msg[0] = REC_TYPE_CHANGE_CIPHER_SPEC;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* 9. After the client receives the finised message, the client sends the unexpected_message alarm to terminate
* the handshake because the client receives the encrypted CCS */
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(clientTlsCtx, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_ERR_RECV_UNEXPECTED_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC008
* @spec An implementation which receives any other change_cipher_spec value or
* which receives a protected change_cipher_spec record MUST
* abort the handshake with an "unexpected_message" alert.
* @title Send the unexpected_message alarm when receiving other CCS messages.
* @precon nan
* @brief 5 Record Protocol line 182
* 10. After the session is resumed, the client sends the unexpected_message alarm to terminate the handshake
* because the client receives a CCS with a value other than 0x01.
* 15. Before the session is recovered, the client receives a CCS whose value is not 0x01. Therefore, the
* client sends the unexpected_message alarm to terminate the handshake.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC008(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_SEND_SERVER_HELLO) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FrameMsg sndMsg;
ASSERT_TRUE(memcpy_s(sndMsg.msg, MAX_RECORD_LENTH, ioServerData->sndMsg.msg, ioServerData->sndMsg.len) == EOK);
sndMsg.len = ioServerData->sndMsg.len;
ioServerData->sndMsg.len = 0;
uint8_t data = 2;
ASSERT_EQ(SendCcs(server->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* 10. After the session is resumed, the client sends the unexpected_message alarm to terminate the handshake
* because the client receives a CCS with a value other than 0x01.
* 15. Before the session is recovered, the client receives a CCS whose value is not 0x01. Therefore, the
* client sends the unexpected_message alarm to terminate the handshake. */
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC009
* @spec An implementation which receives any other change_cipher_spec value or
* which receives a protected change_cipher_spec record MUST
* abort the handshake with an "unexpected_message" alert.
* @title Send the unexpected_message alarm when receiving other CCS messages.
* @precon nan
* @brief 5 Record Protocol line 182
* 11. After the session is recovered, the client sends the "unexpected_message" alarm to terminate the
* handshake because the client receives the encrypted CCS.
* 16. The session is recovered. Before the client receives the finised message, the client sends the
* "unexpected_message" alarm to terminate the handshake because the client receives the encrypted CCS.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC009(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
clientTlsCtx = FRAME_GetTlsCtx(client);
serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
serverTlsCtx->recCtx->outBuf->end = 0;
uint32_t hashLen = SAL_CRYPT_DigestSize(serverTlsCtx->negotiatedInfo.cipherSuiteInfo.hashAlg);
ASSERT_EQ(
HS_SwitchTrafficKey(serverTlsCtx, serverTlsCtx->hsCtx->serverHsTrafficSecret, hashLen, true), HITLS_SUCCESS);
uint8_t data = 1;
ASSERT_EQ(SendCcs(server->ssl, &data, sizeof(data)), HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
ioServerData->sndMsg.msg[0] = REC_TYPE_CHANGE_CIPHER_SPEC;
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
ioClientData->recMsg.len = 0;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* 11. After the session is recovered, the client sends the "unexpected_message" alarm to terminate the
* handshake because the client receives the encrypted CCS.
* 16. The session is recovered. Before the client receives the finised message, the client sends the
* "unexpected_message" alarm to terminate the handshake because the client receives the encrypted CCS. */
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC010
* @spec An implementation which receives any other change_cipher_spec value or
* which receives a protected change_cipher_spec record MUST
* abort the handshake with an "unexpected_message" alert.
* @title Send the unexpected_message alarm when receiving other CCS messages.
* @precon nan
* @brief 5 Record Protocol line 182
* 12. Before the session is recovered, the server receives a CCS with a value other than 0x01 before receiving
* the client hello message. Therefore, the server sends the unexpected_message alarm to terminate the
* handshake.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC010(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
clientTlsCtx = FRAME_GetTlsCtx(client);
serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
uint8_t data = 2;
ASSERT_EQ(SendCcs(client->ssl, &data, sizeof(data)), HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
ioServerData->recMsg.len = 0;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* 12. Before the session is recovered, the server receives a CCS with a value other than 0x01 before receiving
* the client hello message. Therefore, the server sends the unexpected_message alarm to terminate the
* handshake. */
ASSERT_TRUE(HITLS_Accept(server->ssl) == HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC011
* @spec An implementation may receive an unencrypted record of
* type change_cipher_spec consisting of the single byte
* value 0x01 at any time after the first ClientHello message
* has been sent or received and before the peer's Finished message
* has been received and MUST simply drop it without further processing.
* @title When receiving an unencrypted CCS message, the system discards the message.
* @precon nan
* @brief 5 Record Protocol line 181
* 13. After receiving the client hello message, the server sends the unexpected_message alarm to terminate the
* handshake because the server receives a CCS with a value other than 0x01.
* 19. Before the session is recovered, the server sends the unexpected_message alarm to terminate the
* handshake because the server receives a CCS whose value is not 0x01.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC011(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
clientTlsCtx = FRAME_GetTlsCtx(client);
serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_FINISH) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FrameMsg recMsg;
ASSERT_TRUE(memcpy_s(recMsg.msg, MAX_RECORD_LENTH, ioServerData->recMsg.msg, ioServerData->recMsg.len) == EOK);
recMsg.len = ioServerData->recMsg.len;
ioServerData->recMsg.len = 0;
clientTlsCtx->recCtx->outBuf->end = 0;
uint8_t data = 2;
ASSERT_EQ(SendCcs(client->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* 13. After receiving the client hello message, the server sends the unexpected_message alarm to terminate the
* handshake because the server receives a CCS with a value other than 0x01.
* 19. Before the session is recovered, the server sends the unexpected_message alarm to terminate the
* handshake because the server receives a CCS whose value is not 0x01. */
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC012
* @spec An implementation may receive an unencrypted record of
* type change_cipher_spec consisting of the single byte
* value 0x01 at any time after the first ClientHello message
* has been sent or received and before the peer's Finished message
* has been received and MUST simply drop it without further processing.
* @title When receiving an unencrypted CCS message, the system discards the message.
* @precon nan
* @brief 5 Record Protocol line 181
* 14. After the session is recovered, the server sends the unexpected_message alarm to terminate the handshake
* because the server receives the encrypted CCS.
* 20. The session is recovered. Before the server receives the finised message, it receives the encrypted CCS.
* Therefore, the server sends the "unexpected_message" alarm to terminate the handshake.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC012(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
clientTlsCtx = FRAME_GetTlsCtx(client);
serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_FINISH) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FrameMsg recMsg;
ASSERT_TRUE(memcpy_s(recMsg.msg, MAX_RECORD_LENTH, ioServerData->recMsg.msg, ioServerData->recMsg.len) == EOK);
recMsg.len = ioServerData->recMsg.len;
ioServerData->recMsg.len = 0;
clientTlsCtx->recCtx->outBuf->end = 0;
uint32_t hashLen = SAL_CRYPT_DigestSize(clientTlsCtx->negotiatedInfo.cipherSuiteInfo.hashAlg);
ASSERT_EQ(
HS_SwitchTrafficKey(clientTlsCtx, clientTlsCtx->hsCtx->serverHsTrafficSecret, hashLen, true), HITLS_SUCCESS);
uint8_t data = 1;
ASSERT_EQ(SendCcs(client->ssl, &data, sizeof(data)), HITLS_SUCCESS);
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
ioClientData->sndMsg.msg[0] = REC_TYPE_CHANGE_CIPHER_SPEC;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* 14. After the session is recovered, the server sends the unexpected_message alarm to terminate the handshake
* because the server receives the encrypted CCS.
* 20. The session is recovered. Before the server receives the finised message, it receives the encrypted
* CCS. Therefore, the server sends the "unexpected_message" alarm to terminate the handshake. */
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC013
* @spec An implementation which receives any other change_cipher_spec value or
* which receives a protected change_cipher_spec record MUST
* abort the handshake with an "unexpected_message" alert.
* @title Send the unexpected_message alarm when receiving other CCS messages.
* @precon nan
* @brief 5 Record Protocol line 182
* 17. After the session is recovered, the client receives a CCS whose value is not 0x01 and sends the
* unexpected_message alarm to terminate the handshake.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC013(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
clientTlsCtx = FRAME_GetTlsCtx(client);
serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
ioServerData->sndMsg.len = sizeof(ccsMessage);
memcpy_s(ioServerData->sndMsg.msg, ioServerData->sndMsg.len, ccsMessage, sizeof(ccsMessage));
ioServerData->sndMsg.msg[5] = 0x2;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* 17. After the session is recovered, the client receives a CCS whose value is not 0x01 and sends the
* unexpected_message alarm to terminate the handshake. */
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(clientTlsCtx, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_ERR_RECV_UNEXPECTED_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC014
* @spec An implementation which receives any other change_cipher_spec value or
* which receives a protected change_cipher_spec record MUST
* abort the handshake with an "unexpected_message" alert.
* @title Send the unexpected_message alarm when receiving other CCS messages.
* @precon nan
* @brief 5 Record Protocol line 182
* 18. After the session is recovered, the client receives the finised message and receives the encrypted CCS.
* Therefore, the client sends the unexpected_message alarm to terminate the handshake.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC014(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
clientTlsCtx = FRAME_GetTlsCtx(client);
serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
uint8_t data = 1;
ASSERT_EQ(SendCcs(server->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ioServerData->sndMsg.msg[0] = REC_TYPE_CHANGE_CIPHER_SPEC;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
/* 18. After the session is recovered, the client receives the finised message and receives the encrypted CCS.
* Therefore, the client sends the unexpected_message alarm to terminate the handshake. */
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(clientTlsCtx, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_ERR_RECV_UNEXPECTED_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC015
* @spec An implementation which receives any other change_cipher_spec value or
* which receives a protected change_cipher_spec record MUST
* abort the handshake with an "unexpected_message" alert.
* @title Send the unexpected_message alarm when receiving other CCS messages.
* @precon nan
* @brief 5 Record Protocol line 182
* 21. After the session is recovered, the server sends the unexpected_message alarm to terminate the handshake
* because the server receives a CCS whose value is not 0x01.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC015(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
clientTlsCtx = FRAME_GetTlsCtx(client);
serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
ioClientData->sndMsg.len = sizeof(ccsMessage);
memcpy_s(ioClientData->sndMsg.msg, ioClientData->sndMsg.len, ccsMessage, sizeof(ccsMessage));
ioClientData->sndMsg.msg[5] = 0x2;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* 21. After the session is recovered, the server sends the unexpected_message alarm to terminate the handshake
* because the server receives a CCS whose value is not 0x01. */
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(serverTlsCtx, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_ERR_RECV_UNEXPECTED_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC016
* @spec An implementation which receives any other change_cipher_spec value or
* which receives a protected change_cipher_spec record MUST
* abort the handshake with an "unexpected_message" alert.
* @title Send the unexpected_message alarm when receiving other CCS messages.
* @precon nan
* @brief 5 Record Protocol line 182
* 22. After the session is recovered, the server sends the "unexpected_message" alarm to terminate the
* handshake because the server receives the encrypted CCS.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_RECEIVES_OTHER_CCS_FUNC_TC016(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
clientTlsCtx = FRAME_GetTlsCtx(client);
serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
uint8_t data = 1;
ASSERT_EQ(SendCcs(client->ssl, &data, sizeof(data)), HITLS_SUCCESS);
ioClientData->sndMsg.msg[0] = REC_TYPE_CHANGE_CIPHER_SPEC;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
/* 22. After the session is recovered, the server sends the "unexpected_message" alarm to terminate the
* handshake because the server receives the encrypted CCS. */
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(serverTlsCtx, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_ERR_RECV_UNEXPECTED_MSG);
ALERT_Info info = {0};
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_RECORD_TYPE_FUNC_TC001
* @spec Handshake messages MUST NOT be interleaved with other record types.
* That is, if a handshake message is split over two or more records,
* there MUST NOT be any other records between them.
* @title Handshake messages must not be interleaved with other record types.
* @precon nan
* @brief 5.1. Record Layer line 186
* 1. Handshake messages are sent to multiple records. Check whether records of other types exist between
* the records.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_RECORD_TYPE_FUNC_TC001(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
int32_t RecParseInnerPlaintext(TLS_Ctx *ctx, uint8_t *text, uint32_t *textLen, uint8_t *recType);
int32_t STUB_RecParseInnerPlaintext(TLS_Ctx *ctx, uint8_t *text, uint32_t *textLen, uint8_t *recType)
{
(void)ctx;
(void)text;
(void)textLen;
*recType = (uint8_t)REC_TYPE_APP;
return HITLS_SUCCESS;
}
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_RECORD_TYPE_FUNC_TC002
* @spec Handshake messages MUST NOT be interleaved with other record types.
* That is, if a handshake message is split over two or more records,
* there MUST NOT be any other records between them.
* @title Handshake messages must not be interleaved with other record types.
* @precon nan
* @brief 5.1. Record Layer line 186
* 2. If multiple handshake messages are interspersed with other record (app) messages, the handshake fails.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_HANDSHAKE_RECORD_TYPE_FUNC_TC002(void)
{
FRAME_Init();
STUB_Init();
FuncStubInfo tmpRpInfo;
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_SEND_FINISH) == HITLS_SUCCESS);
STUB_Replace(&tmpRpInfo, RecParseInnerPlaintext, STUB_RecParseInnerPlaintext);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
EXIT:
STUB_Reset(&tmpRpInfo);
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SINGLE_ALERT_FUNC_TC001
* @spec A record with an Alert type MUST contain exactly one message.
* @title A record with the Alert type must contain only one message.
* @precon nan
* @brief 5.1. Record Layer line 186
* 1. The client sends multiple alarm messages, and the server handshake fails.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SINGLE_ALERT_FUNC_TC001(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_FINISH) == HITLS_SUCCESS);
clientTlsCtx->recCtx->outBuf->end = 0;
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
ioServerData->recMsg.len = 0;
ASSERT_TRUE(SendErrorAlert(client->ssl, ALERT_LEVEL_WARNING, ALERT_NO_CERTIFICATE_RESERVED) == HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SINGLE_ALERT_FUNC_TC002
* @spec A record with an Alert type MUST contain exactly one message.
* @title A record with the Alert type must contain only one message.
* @precon nan
* @brief 5.1. Record Layer line 186
* 2. When the server sends multiple alarm messages, the client handshake fails.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SINGLE_ALERT_FUNC_TC002(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
/* Stop the client receiving the TRY_RECV_SERVER_HELLO state, and the server sending the TRY_SEND_SERVER_HELLO
* state. */
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
serverTlsCtx->recCtx->outBuf->end = 0;
ASSERT_TRUE(SendErrorAlert(server->ssl, ALERT_LEVEL_WARNING, ALERT_NO_CERTIFICATE_RESERVED) == HITLS_SUCCESS);
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
ioClientData->recMsg.len = 0;
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Connect(client->ssl), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC001
* @spec legacy_record_version: MUST be set to 0x0303
* for all records generated by a TLS 1.3 implementation
* other than an initial ClientHello (i.e., one not generated
* after a HelloRetryRequest), where it MAY also be 0x0301
* for compatibility purposes. This field is deprecated
* and MUST be ignored for all purposes. Previous versions of
* TLS would use other values in this field under some circumstances.
* @title For all records generated by the TLS 1.3 implementation, it must be set to 0x0303,
* where the initial ClientHello (i.e., records not generated after HelloRetryRequest) For compatibility
* purposes, it may be 0x0301.
* @precon nan
* @brief 5.1. Record Layer line 190
* 1. In TLS1.3, legacy_record_version is 0x0303 in the record message of the CCS.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC001(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
/* The client stops receiving the TRY_RECV_ENCRYPTED_EXTENSIONS. The server sends the EE message, but the EE message
* is cached because the CCS message is sent first. */
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_ENCRYPTED_EXTENSIONS) == HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_ENCRYPTED_EXTENSIONS);
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
FRAME_Msg frameMsg = {0};
uint8_t *buffer = ioClientData->recMsg.msg;
uint32_t readLen = ioClientData->recMsg.len;
uint32_t parseLen = 0;
ASSERT_TRUE(ParserRecordHeader(&frameMsg, buffer, readLen, &parseLen) == HITLS_SUCCESS);
ASSERT_EQ(frameMsg.type, REC_TYPE_CHANGE_CIPHER_SPEC);
ASSERT_TRUE(frameMsg.version == HITLS_VERSION_TLS12);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC002
* @spec legacy_record_version: MUST be set to 0x0303
* for all records generated by a TLS 1.3 implementation
* other than an initial ClientHello (i.e., one not generated
* after a HelloRetryRequest), where it MAY also be 0x0301
* for compatibility purposes. This field is deprecated
* and MUST be ignored for all purposes. Previous versions of
* TLS would use other values in this field under some circumstances.
* @title For all records generated by the TLS 1.3 implementation, it must be set to 0x0303,
* where the initial ClientHello (i.e., records not generated after HelloRetryRequest) For compatibility
* purposes, it may be 0x0301.
* @precon nan
* @brief 5.1. Record Layer line 190
* 2. In TLS1.3, legacy_record_version is 0x0303 in the alert record message.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC002(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_SEND_SERVER_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(SendAlert(server->ssl, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(server, client) == HITLS_SUCCESS);
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
FRAME_Msg frameMsg = {0};
uint8_t *buffer = ioClientData->recMsg.msg;
uint32_t readLen = ioClientData->recMsg.len;
uint32_t parseLen = 0;
ASSERT_TRUE(ParserRecordHeader(&frameMsg, buffer, readLen, &parseLen) == HITLS_SUCCESS);
ASSERT_EQ(frameMsg.type, REC_TYPE_ALERT);
ASSERT_TRUE(frameMsg.version == HITLS_VERSION_TLS12);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC003
* @spec legacy_record_version: MUST be set to 0x0303
* for all records generated by a TLS 1.3 implementation
* other than an initial ClientHello (i.e., one not generated
* after a HelloRetryRequest), where it MAY also be 0x0301
* for compatibility purposes. This field is deprecated
* and MUST be ignored for all purposes. Previous versions of
* TLS would use other values in this field under some circumstances.
* @title For all records generated by the TLS 1.3 implementation, it must be set to 0x0303,
* where the initial ClientHello (i.e., records not generated after HelloRetryRequest) For compatibility
* purposes, it may be 0x0301.
* @precon nan
* @brief 5.1. Record Layer line 190
* In 5. TLS1.3, legacy_record_version is set to 0x0301 in the record message of the init clienthello.
* In 3.TLS1.3, legacy_record_version is 0x0303 in the session recovery clienthello message.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC003(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
FRAME_Msg frameMsg = {0};
uint8_t *buffer = ioServerData->recMsg.msg;
uint32_t readLen = ioServerData->recMsg.len;
uint32_t parseLen = 0;
ASSERT_TRUE(ParserRecordHeader(&frameMsg, buffer, readLen, &parseLen) == HITLS_SUCCESS);
ASSERT_EQ(frameMsg.type, REC_TYPE_HANDSHAKE);
/* For all records generated by the TLS 1.3 implementation, it must be set to 0x0303,
* where the initial ClientHello (i.e., records not generated after HelloRetryRequest) For compatibility
* purposes, it may be 0x0301. */
ASSERT_TRUE(frameMsg.version == HITLS_VERSION_TLS10);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ioServerData = BSL_UIO_GetUserData(server->io);
buffer = ioServerData->recMsg.msg;
readLen = ioServerData->recMsg.len;
parseLen = 0;
ASSERT_TRUE(ParserRecordHeader(&frameMsg, buffer, readLen, &parseLen) == HITLS_SUCCESS);
ASSERT_EQ(frameMsg.type, REC_TYPE_HANDSHAKE);
ASSERT_TRUE(frameMsg.version == HITLS_VERSION_TLS10);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC004
* @spec legacy_record_version: MUST be set to 0x0303
* for all records generated by a TLS 1.3 implementation
* other than an initial ClientHello (i.e., one not generated
* after a HelloRetryRequest), where it MAY also be 0x0301
* for compatibility purposes. This field is deprecated
* and MUST be ignored for all purposes. Previous versions of
* TLS would use other values in this field under some circumstances.
* @title For all records generated by the TLS 1.3 implementation, it must be set to 0x0303,
* where the initial ClientHello (i.e., records not generated after HelloRetryRequest) For compatibility
* purposes, it may be 0x0301.
* @precon nan
* @brief 5.1. Record Layer line 190
* In TLS1.3, the value of legacy_record_version in the serverhello message is changed to 0xffff when the
* session is recovered,
* After the client receives the message, the client ignores this field and the session is successfully
* restored.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC004(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
uint32_t bufOffset = 1;
ioClientData->recMsg.msg[bufOffset] = 0x03;
bufOffset++;
ioClientData->recMsg.msg[bufOffset] = 0xff;
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
uint8_t isReused = 0;
ASSERT_EQ(HITLS_IsSessionReused(client->ssl, &isReused), HITLS_SUCCESS);
ASSERT_EQ(isReused, 1);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC005
* @spec legacy_record_version: MUST be set to 0x0303
* for all records generated by a TLS 1.3 implementation
* other than an initial ClientHello (i.e., one not generated
* after a HelloRetryRequest), where it MAY also be 0x0301
* for compatibility purposes. This field is deprecated
* and MUST be ignored for all purposes. Previous versions of
* TLS would use other values in this field under some circumstances.
* @title For all records generated by the TLS 1.3 implementation, it must be set to 0x0303,
* where the initial ClientHello (i.e., records not generated after HelloRetryRequest) For compatibility
* purposes, it may be 0x0301.
* @precon nan
* @brief 5.1. Record Layer line 190
* In TLS 7.1.3, the legacy_record_version field in the record message of the client hello message is changed to
* 0x0300. After the server receives the message, the server ignores the field and the handshake is still
* successful.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC005(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
uint32_t bufOffset = 1;
ioClientData->recMsg.msg[bufOffset] = 0x03;
bufOffset++;
ioClientData->recMsg.msg[bufOffset] = 0xff;
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
uint8_t isReused = 0;
ASSERT_EQ(HITLS_IsSessionReused(client->ssl, &isReused), HITLS_SUCCESS);
ASSERT_EQ(isReused, 1);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC006
* @spec legacy_record_version: MUST be set to 0x0303
* for all records generated by a TLS 1.3 implementation
* other than an initial ClientHello (i.e., one not generated
* after a HelloRetryRequest), where it MAY also be 0x0301
* for compatibility purposes. This field is deprecated
* and MUST be ignored for all purposes. Previous versions of
* TLS would use other values in this field under some circumstances.
* @title For all records generated by the TLS 1.3 implementation, it must be set to 0x0303,
* where the initial ClientHello (i.e., records not generated after HelloRetryRequest) For compatibility
* purposes, it may be 0x0301.
* @precon nan
* @brief 5.1. Record Layer line 190
* 8. The server uses TLS1.2 and the value of legacy_record_version in the record message is 0x0303,
* The client uses TLS 1.3 and the value of legacy_record_version in the record message is 0x0303. The
* handshake is still successful.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC006(void)
{
FRAME_Init();
HITLS_Config *clientConfig = HITLS_CFG_NewTLSConfig();
HITLS_Config *serverConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(clientConfig != NULL);
ASSERT_TRUE(serverConfig != NULL);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(clientConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(serverConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(clientConfig);
HITLS_CFG_FreeConfig(serverConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC007
* @spec legacy_record_version: MUST be set to 0x0303
* for all records generated by a TLS 1.3 implementation
* other than an initial ClientHello (i.e., one not generated
* after a HelloRetryRequest), where it MAY also be 0x0301
* for compatibility purposes. This field is deprecated
* and MUST be ignored for all purposes. Previous versions of
* TLS would use other values in this field under some circumstances.
* @title For all records generated by the TLS 1.3 implementation, it must be set to 0x0303,
* where the initial ClientHello (i.e., records not generated after HelloRetryRequest) For compatibility
* purposes, it may be 0x0301.
* @precon nan
* @brief 5.1. Record Layer line 190
* 9. Change TLSCiphertext.legacy_record_version in the encryption record of the app to 0xffff,
* After the client receives the message, the client ignores this field and the session is still successful.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_RECORD_VERSION_FUNC_TC007(void)
{
FRAME_Init();
HITLS_Config *clientConfig = HITLS_CFG_NewTLSConfig();
HITLS_Config *serverConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(clientConfig != NULL);
ASSERT_TRUE(serverConfig != NULL);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(clientConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(serverConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(clientConfig);
HITLS_CFG_FreeConfig(serverConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_CIPHERTEXT_LENGTH_FUNC_TC001
* @spec length: The length (in bytes) of the following TLSCiphertext.
* encrypted_record, which is the sum of the lengths of the content and the padding,
* plus one for the inner content type, plus any expansion added by the AEAD algorithm.
* The length MUST NOT exceed 2^14 + 256 bytes. An endpoint that receives a record that
* exceeds this length MUST terminate the connection with a "record_overflow" alert.
* @title For TLS 1.3, the length of the ciphertext cannot exceed 2 ^ 14 + 256 bytes.
* @precon nan
* @brief 5.2. Record Payload Protection line 194
* 1. A connection is established. During the connection establishment, the server receives a message whose
* ciphertext length is 2 ^ 14 + 257. The server is expected to send a record_overflow alarm to
* terminate the connection.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_CIPHERTEXT_LENGTH_FUNC_TC001(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
/* The client stops receiving the TRY_RECV_ENCRYPTED_EXTENSIONS. The server sends the EE message. However, the EE
* message is cached because the CCS message is sent first. */
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CERTIFICATE) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
ioServerData->recMsg.msg[3] = 0x41u;
ioServerData->recMsg.msg[4] = 0x01u;
/* For TLS 1.3, the length of the ciphertext cannot exceed 2 ^ 14 + 256 bytes. */
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_REC_RECORD_OVERFLOW);
ALERT_Info info = {0};
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_RECORD_OVERFLOW);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_CIPHERTEXT_LENGTH_FUNC_TC002
* @spec length: The length (in bytes) of the following TLSCiphertext.
* encrypted_record, which is the sum of the lengths of the content and the padding,
* plus one for the inner content type, plus any expansion added by the AEAD algorithm.
* The length MUST NOT exceed 2^14 + 256 bytes. An endpoint that receives a record that
* exceeds this length MUST terminate the connection with a "record_overflow" alert.
* @title For TLS 1.3, the length of the ciphertext cannot exceed 2 ^ 14 + 256 bytes.
* @precon nan
* @brief 5.2. Record Payload Protection line 194
* 2. A connection is established. During the connection establishment, the client receives a message whose ciphertext
* length is 2 ^ 14 + 257. The server is expected to send a record_overflow alarm to terminate the connection.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_CIPHERTEXT_LENGTH_FUNC_TC002(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_ENCRYPTED_EXTENSIONS) == HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->hsCtx->state == TRY_SEND_ENCRYPTED_EXTENSIONS);
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(HITLS_Accept(server->ssl) == HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(server, client) == HITLS_SUCCESS);
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
ioClientData->recMsg.msg[3] = 0x41u;
ioClientData->recMsg.msg[4] = 0x01u;
ASSERT_EQ(HITLS_Connect(client->ssl), HITLS_REC_RECORD_OVERFLOW);
ALERT_Info info = {0};
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_RECORD_OVERFLOW);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SEQUENCE_NUMBER_FUNC_TC001
* @spec Each sequence number is set to zero at the beginning of a connection and whenever the key is changed;
* the first record transmitted under a particular traffic key MUST use sequence number 0.
* @title The sequence number is 0 when the connection starts or the key changes.
* @precon nan
* @brief 5.3. Per-Record Nonce line 197
* 1. The client sends a finish packet and an app packet. After the seq number is not 0, the key is changed
* successfully and the seq number is reset to 0.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SEQUENCE_NUMBER_FUNC_TC001(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
uint32_t writeLen;
ASSERT_TRUE(HITLS_Write(client->ssl, (uint8_t *)"Hello World", sizeof("Hello World"), &writeLen) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(client, server) == HITLS_SUCCESS);
REC_Ctx *recCtx = (REC_Ctx *)client->ssl->recCtx;
ASSERT_TRUE(recCtx->writeStates.currentState->seq != 0);
ASSERT_TRUE(HITLS_KeyUpdate(client->ssl, HITLS_UPDATE_REQUESTED) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_SUCCESS);
ASSERT_TRUE(recCtx->writeStates.currentState->seq == 0);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SEQUENCE_NUMBER_FUNC_TC002
* @spec Each sequence number is set to zero at the beginning of a connection and whenever the key is changed;
* the first record transmitted under a particular traffic key MUST use sequence number 0.
* @title The sequence number is 0 when the connection starts or the key changes.
* @precon nan
* @brief 5.3. Per-Record Nonce line 197
* 2. The client sends a finish packet and an app packet. After the seq number is not 0, the key fails to be
* changed and the key is updated,
* The seq number is not reset to 0. (It is to be confirmed whether the seq number is updated at both ends.)
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SEQUENCE_NUMBER_FUNC_TC002(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
uint32_t writeLen;
ASSERT_TRUE(HITLS_Write(client->ssl, (uint8_t *)"Hello World", sizeof("Hello World"), &writeLen) == HITLS_SUCCESS);
REC_Ctx *recCtx = (REC_Ctx *)client->ssl->recCtx;
ASSERT_TRUE(recCtx->writeStates.currentState->seq != 0);
FrameUioUserData *ioClientData = BSL_UIO_GetUserData(client->io);
ioClientData->sndMsg.len = 1;
ASSERT_TRUE(HITLS_KeyUpdate(client->ssl, HITLS_UPDATE_REQUESTED) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_NORMAL_IO_BUSY);
ASSERT_TRUE(recCtx->writeStates.currentState->seq != 0);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RFC8446_CONSISTENCY_SEQUENCE_NUMBER_FUNC_TC003
* @spec Each sequence number is set to zero at the beginning of a connection and whenever the key is changed;
* the first record transmitted under a particular traffic key MUST use sequence number 0.
* @title The sequence number is 0 when the connection starts or the key changes.
* @precon nan
* @brief 5.3. Per-Record Nonce line 197
* 1. The client sends a finish packet and an app packet. After the seq number is not 0, the key is changed
* successfully and the seq number is reset to 0.
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RFC8446_CONSISTENCY_SEQUENCE_NUMBER_FUNC_TC003(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportExtendMasterSecret = true;
tlsConfig->isSupportClientVerify = true;
tlsConfig->isSupportNoClientCert = true;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
REC_Ctx *recCtx = (REC_Ctx *)server->ssl->recCtx;
ASSERT_TRUE(recCtx->writeStates.currentState->seq != 0);
ASSERT_TRUE(HITLS_KeyUpdate(server->ssl, HITLS_UPDATE_REQUESTED) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Accept(server->ssl) == HITLS_SUCCESS);
ASSERT_TRUE(recCtx->writeStates.currentState->seq == 0);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(server, client) == HITLS_SUCCESS);
uint32_t writeLen;
ASSERT_TRUE(HITLS_Write(server->ssl, (uint8_t *)"Hello World", sizeof("Hello World"), &writeLen) == HITLS_SUCCESS);
ASSERT_TRUE(recCtx->writeStates.currentState->seq == 1);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/consistency/tls13/test_suite_sdv_frame_tls13_consistency_rfc8446_record.c
|
C
|
unknown
| 115,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.
*/
/* BEGIN_HEADER */
/* INCLUDE_BASE test_suite_tls13_consistency_rfc8446 */
#include <stdio.h>
#include "stub_replace.h"
#include "hitls.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_uio.h"
#include "bsl_sal.h"
#include "tls.h"
#include "hs_ctx.h"
#include "pack.h"
#include "send_process.h"
#include "frame_link.h"
#include "frame_tls.h"
#include "frame_io.h"
#include "simulate_io.h"
#include "parser_frame_msg.h"
#include "cert.h"
#include "securec.h"
#include "rec_wrapper.h"
#include "conn_init.h"
#include "rec.h"
#include "parse.h"
#include "hs_msg.h"
#include "hs.h"
#include "alert.h"
#include "hitls_type.h"
#include "session_type.h"
#include "hitls_crypt_init.h"
#include "common_func.h"
#include "hlt.h"
#include "process.h"
#include "rec_read.h"
/* END_HEADER */
#define g_uiPort 6543
// REC_Read calls TlsRecordRead calls RecParseInnerPlaintext
int32_t RecParseInnerPlaintext(TLS_Ctx *ctx, const uint8_t *text, uint32_t *textLen, uint8_t *recType);
int32_t STUB_RecParseInnerPlaintext(TLS_Ctx *ctx, const uint8_t *text, uint32_t *textLen, uint8_t *recType)
{
(void)ctx;
(void)text;
(void)textLen;
*recType = (uint8_t)REC_TYPE_APP;
return HITLS_SUCCESS;
}
typedef struct {
uint16_t version;
BSL_UIO_TransportType uioType;
HITLS_Config *config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_Session *clientSession;
} ResumeTestInfo;
static void TestFrameChangeCerts(void *msg, void *data)
{
(void)data;
FRAME_Msg *frameMsg = (FRAME_Msg *)msg;
FRAME_CertificateMsg *certicate = &frameMsg->body.hsMsg.body.certificate;
FrameCertItem *cert = certicate->certItem->next->next; // 1 ->2 ->3 ->0
cert->next = certicate->certItem->next; // 3->2
certicate->certItem->next = cert; // 1->3
cert->next->next = NULL; // 2-> 0
}
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_TWO_DISOEDER_CHAIN_CERT_FUNC_TC001
* @spec -
* @title The certificate chain sent by the server contains two intermediate certificates, which are out of order
* (excluding the device certificate).
* @precon nan
* @brief The sender' s certificate MUST come in the first CertificateEntry in the list.
* 1. The certificate chain sent by the server contains two intermediate certificates, and the two intermediate
* certificates are out of order. Expected result 1 is displayed.
* @expect 1. The connection fails to be established. The error code is ALERT_BAD_CERTIFICATIONATE.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_TWO_DISOEDER_CHAIN_CERT_FUNC_TC001(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverCtxConfig = NULL;
HLT_Ctx_Config *clientCtxConfig = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
HLT_SetCertPath(serverCtxConfig,
"rsa_sha512/otherRoot.der",
"rsa_sha512/otherInter.der:rsa_sha512/otherInter2.der",
"rsa_sha512/otherEnd.der",
"rsa_sha512/otherEnd.key.der",
"NULL",
"NULL");
HLT_SetClientVerifySupport(serverCtxConfig, true);
clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_SetCertPath(clientCtxConfig,
"rsa_sha512/otherRoot.der",
"rsa_sha512/otherInter.der:rsa_sha512/otherInter2.der",
"rsa_sha512/otherEnd.der",
"rsa_sha512/otherEnd.key.der",
"NULL",
"NULL");
HLT_SetClientVerifySupport(clientCtxConfig, true);
HLT_SetCipherSuites(clientCtxConfig, "HITLS_RSA_WITH_AES_256_CBC_SHA");
HLT_SetSignature(clientCtxConfig, "CERT_SIG_SCHEME_RSA_PKCS1_SHA256");
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_3, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_FrameHandle frameHandle = {
.ctx = serverRes->ssl,
/* 1. The certificate chain sent by the server contains two intermediate certificates, and the two intermediate
* certificates are out of order. */
.frameCallBack = TestFrameChangeCerts,
.userData = NULL,
.expectHsType = CERTIFICATE,
.expectReType = REC_TYPE_HANDSHAKE,
.ioState = EXP_NONE,
.pointType = POINT_SEND,
};
ASSERT_TRUE(HLT_SetFrameHandle(&frameHandle) == HITLS_SUCCESS);
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_3, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes == NULL);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) != 0);
EXIT:
HLT_FreeAllProcess();
HLT_CleanFrameHandle();
return;
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_MIDDLE_BOX_COMPAT_FUNC_TC001
* @spec -
* @title Test TLS 1.3 connection and data transfer when middlebox compatibility mode is enabled or disabled
* @precon nan
* @brief
* 1. The server and client are configured with middlebox compatibility mode controlled by the input parameter isMiddleBoxCompat.
* 2. Establish a TLS 1.3 connection between server and client.
* 3. Verify bidirectional data transmission integrity.
* @expect 1. The TLS 1.3 connection is successfully established.
* 2. Data sent by the server is correctly received by the client (length and content match).
* 3. Data sent by the client is correctly received by the server (length and content match).
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_MIDDLE_BOX_COMPAT_FUNC_TC001(int isMiddleBoxCompat)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverCtxConfig = NULL;
HLT_Ctx_Config *clientCtxConfig = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
HLT_SetClientVerifySupport(serverCtxConfig, true);
HLT_SetMiddleBoxCompat(serverCtxConfig, isMiddleBoxCompat);
clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_SetClientVerifySupport(clientCtxConfig, true);
HLT_SetMiddleBoxCompat(clientCtxConfig, isMiddleBoxCompat);
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_3, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_3, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
uint8_t writeData[REC_MAX_PLAIN_LENGTH] = {1};
uint32_t writeLen = REC_MAX_PLAIN_LENGTH;
uint8_t readData[REC_MAX_PLAIN_LENGTH] = {0};
uint32_t readLen = REC_MAX_PLAIN_LENGTH;
ASSERT_EQ(HLT_ProcessTlsWrite(localProcess, serverRes, writeData, writeLen), 0);
ASSERT_EQ(HLT_ProcessTlsRead(remoteProcess, clientRes, readData, readLen, &readLen), 0);
ASSERT_EQ(readLen, REC_MAX_PLAIN_LENGTH);
ASSERT_EQ(memcmp(writeData, readData, readLen), 0);
ASSERT_EQ(HLT_ProcessTlsWrite(remoteProcess, clientRes, writeData, writeLen), 0);
ASSERT_EQ(HLT_ProcessTlsRead(localProcess, serverRes, readData, readLen, &readLen), 0);
ASSERT_EQ(readLen, REC_MAX_PLAIN_LENGTH);
ASSERT_EQ(memcmp(writeData, readData, readLen), 0);
EXIT:
HLT_FreeAllProcess();
HLT_CleanFrameHandle();
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/consistency/tls13/test_suite_sdv_hlt_tls13_consistency_rfc8446_1.c
|
C
|
unknown
| 8,318
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include "stub_replace.h"
#include "hitls.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_uio.h"
#include "bsl_sal.h"
#include "tls.h"
#include "hlt.h"
#include "hlt_type.h"
#include "hs_ctx.h"
#include "pack.h"
#include "send_process.h"
#include "frame_link.h"
#include "frame_tls.h"
#include "frame_io.h"
#include "simulate_io.h"
#include "parser_frame_msg.h"
#include "cert.h"
#include "process.h"
#include "securec.h"
#include "session_type.h"
#include "rec_wrapper.h"
#include "common_func.h"
#include "conn_init.h"
#include "hs_extensions.h"
#include "hitls_crypt_init.h"
#include "crypt_util_rand.h"
#include "alert.h"
/* END_HEADER */
#define PORT 23456
#define READ_BUF_SIZE (18 * 1024)
typedef struct {
uint16_t version;
BSL_UIO_TransportType uioType;
HITLS_Config *s_config;
HITLS_Config *c_config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_Session *clientSession; // Set the session to the client for session recovery.
HITLS_TicketKeyCb serverKeyCb;
} ResumeTestInfo;
typedef struct{
char *ClientCipherSuite;
char *ServerCipherSuite;
char *ClientGroup;
char *ServerGroup;
uint8_t ClientKeyExchangeMode;
uint8_t ServerKeyExchangeMode;
uint8_t psk[PSK_MAX_LEN];
bool SetNothing;
bool SuccessOrFail;
} SetInfo;
void SetConfig(HLT_Ctx_Config *clientconfig, HLT_Ctx_Config *serverconfig, SetInfo setInfo)
{
if ( !setInfo.SetNothing ) {
// Configure the server configuration.
if (setInfo.ServerCipherSuite != NULL) {
HLT_SetCipherSuites(serverconfig, setInfo.ServerCipherSuite);
}
if (setInfo.ServerGroup != NULL) {
HLT_SetGroups(serverconfig, setInfo.ServerGroup);
}
memcpy_s(serverconfig->psk, PSK_MAX_LEN, setInfo.psk, sizeof(setInfo.psk));
if ( (setInfo.ClientKeyExchangeMode & (TLS13_KE_MODE_PSK_WITH_DHE | TLS13_KE_MODE_PSK_ONLY)) != 0) {
clientconfig->keyExchMode = setInfo.ClientKeyExchangeMode;
}
// Configure the client configuration.
if (setInfo.ClientCipherSuite != NULL) {
HLT_SetCipherSuites(clientconfig, setInfo.ClientCipherSuite);
}
if (setInfo.ClientGroup != NULL) {
HLT_SetGroups(clientconfig, setInfo.ClientGroup);
}
memcpy_s(clientconfig->psk, PSK_MAX_LEN, setInfo.psk, sizeof(setInfo.psk));
if ( (setInfo.ServerKeyExchangeMode & (TLS13_KE_MODE_PSK_WITH_DHE | TLS13_KE_MODE_PSK_ONLY)) != 0) {
serverconfig->keyExchMode = setInfo.ServerKeyExchangeMode;
}
}
}
void ClientCreatConnectWithPara(HLT_FrameHandle *handle, SetInfo setInfo)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
// Create a process.
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, PORT, false);
ASSERT_TRUE(remoteProcess != NULL);
// The local client and remote server listen on the TLS connection.
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Configure the config file.
SetConfig(clientConfig, serverConfig, setInfo);
// Listening connection.
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsInit(localProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
// Configure the interface for constructing abnormal messages.
handle->ctx = clientRes->ssl;
ASSERT_TRUE(HLT_SetFrameHandle(handle) == 0);
// Establish a connection.
if ( setInfo.SuccessOrFail ) {
ASSERT_TRUE(HLT_TlsConnect(clientRes->ssl) == 0);
}else {
ASSERT_TRUE(HLT_TlsConnect(clientRes->ssl) != 0);
}
EXIT:
HLT_CleanFrameHandle();
HLT_FreeAllProcess();
return;
}
void ServerCreatConnectWithPara(HLT_FrameHandle *handle, SetInfo setInfo)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
// Create a process.
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, PORT, false);
ASSERT_TRUE(remoteProcess != NULL);
// The local client and remote server listen on the TLS connection.
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Configure the config file.
SetConfig(clientConfig, serverConfig, setInfo);
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
// Insert abnormal message callback.
handle->ctx = serverRes->ssl;
ASSERT_TRUE(HLT_SetFrameHandle(handle) == 0);
// Client listening connection.
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_3, clientConfig, NULL);
if ( setInfo.SuccessOrFail ) {
ASSERT_TRUE(clientRes != NULL);
}else {
ASSERT_TRUE(clientRes == NULL);
}
EXIT:
HLT_CleanFrameHandle();
HLT_FreeAllProcess();
return;
}
void ResumeConnectWithPara(HLT_FrameHandle *handle, SetInfo setInfo)
{
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
int32_t serverConfigId = 0;
HITLS_Session *session = NULL;
const char *writeBuf = "Hello world";
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
int32_t cnt = 1;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
// Apply for the config context.
void *clientConfig = HLT_TlsNewCtx(TLS1_3);
ASSERT_TRUE(clientConfig != NULL);
// Configure the session restoration function.
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, TLS1_3, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, TLS1_3, false);
#endif
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
do {
if (cnt == 2) {
SetConfig(clientCtxConfig, serverCtxConfig, setInfo);
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
}
DataChannelParam channelParam;
channelParam.port = PORT;
channelParam.type = TCP;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = TCP;
localProcess->connType = TCP;
// The server applies for the context.
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = TCP;
// Set the FD.
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
// Client, applying for context
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = TCP;
// Set the FD.
HLT_TlsSetSsl(clientSsl, clientSslConfig);
if (session != NULL) {
handle->ctx = clientSsl;
ASSERT_TRUE(HLT_SetFrameHandle(handle) == 0);
ASSERT_TRUE(HITLS_SetSession(clientSsl, session) == HITLS_SUCCESS);
if(!setInfo.SuccessOrFail){
ASSERT_TRUE(HLT_TlsConnect(clientSsl) != 0);
}else {
ASSERT_TRUE(HLT_TlsConnect(clientSsl) == 0);
}
}
else {
// Negotiation
ASSERT_TRUE(HLT_TlsConnect(clientSsl) == 0);
// Data read/write
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
// Disable the connection.
ASSERT_TRUE(HLT_RpcTlsClose(remoteProcess, serverSslId) == 0);
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen);
HLT_RpcTlsRead(remoteProcess, serverSslId, readBuf, READ_BUF_SIZE, &readLen);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
session = HITLS_GetDupSession(clientSsl);
ASSERT_TRUE(session != NULL);
ASSERT_TRUE(HITLS_SESS_HasTicket(session) == true);
ASSERT_TRUE(HITLS_SESS_IsResumable(session) == true);
}cnt++;
} while (cnt < 3); // Perform the connection twice.
EXIT:
HITLS_SESS_Free(session);
HLT_CleanFrameHandle();
HLT_FreeAllProcess();
return;
}
static void FrameCallBack_ClientHello_PskBinder_Miss(void *msg, void *userData)
{
// ClientHello exception: The Binder field in the ClientHello message is lost.
HLT_FrameHandle *handle = (HLT_FrameHandle *)userData;
FRAME_Msg *frameMsg = (FRAME_Msg *)msg;
ASSERT_EQ(frameMsg->body.hsMsg.type.data, handle->expectHsType);
FRAME_ClientHelloMsg *clienthello = &frameMsg->body.hsMsg.body.clientHello;
clienthello->psks.binders.state = MISSING_FIELD;
clienthello->psks.binderSize.state = ASSIGNED_FIELD;
clienthello->psks.binderSize.data = 0;
clienthello->psks.exLen.state = INITIAL_FIELD;
EXIT:
return;
}
static void FrameCallBack_ClientHello_LegacyVersion_Unsafe(void *msg, void *userData)
{
// ClientHello exception: The sent ClientHello message has its LegacyVersion set to SSL3.0.
HLT_FrameHandle *handle = (HLT_FrameHandle *)userData;
FRAME_Msg *frameMsg = (FRAME_Msg *)msg;
ASSERT_EQ(frameMsg->body.hsMsg.type.data, handle->expectHsType);
FRAME_ClientHelloMsg *clienthello = &frameMsg->body.hsMsg.body.clientHello;
clienthello->version.state = ASSIGNED_FIELD;
clienthello->version.data = HITLS_VERSION_SSL30;
EXIT:
return;
}
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_PSKBINDER_FUNC_TC002
* @brief 4.2.11-Pre-Shared Key Extension-97
* @spec the server MUST validate the corresponding binder value (see Section 4.2.11.2 below).
* If this value is not present or does not validate, the server MUST abort the handshake.
* @title Modify the binder of client hello so that it is lost.
* @precon nan
* @brief
* 1. The connection is established and the session is restored.
* 2. Modify the binder in the psk extension of the client hello message sent by the client so that the binder is lost.
* Observe the behavior of the server.
* @expect
* 1. The setting is successful.
* 2. The server terminates the handshake.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_PSKBINDER_FUNC_TC002()
{
// The connection is established and the session is restored.
SetInfo setInfo = {0};
setInfo.SetNothing = 1;
setInfo.SuccessOrFail = 0;
HLT_FrameHandle handle = {0};
handle.pointType = POINT_SEND;
handle.userData = (void *)&handle;
handle.expectReType = REC_TYPE_HANDSHAKE;
handle.expectHsType = CLIENT_HELLO;
// Modify the binder in the psk extension of the client hello message sent by the client so that the binder is lost.
// Observe the behavior of the server.
handle.frameCallBack = FrameCallBack_ClientHello_PskBinder_Miss;
ResumeConnectWithPara(&handle, setInfo);
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_VERSION_FUNC_TC001
* @brief 4.2.11-Pre-Shared Key Extension-97
* @spec Implementations MUST NOT send a ClientHello.legacy_version or ServerHello.legacy_version set to 0x0300 or less.
* Any endpoint receiving a Hello message with ClientHello.legacy_version or ServerHello.legacy_version set to
* 0x0300 MUST abort the handshake with a "protocol_version" alert.
* @title The server receives a client hello message whose legacy_version is 0x0300.
* @precon nan
* @brief
* 1. Change the value of legacy_version in the client Hello message to 0x0300.
* 2. Observe the server behavior.
* @expect
* 1. The setting is successful.
* 2. The server terminates the handshake.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_LEGACY_VERSION_FUNC_TC001()
{
// Change the value of legacy_version in the client Hello message to 0x0300.
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, PORT, false);
ASSERT_TRUE(remoteProcess != NULL);
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Observe the server behavior.
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsInit(localProcess, TLS1_2, clientConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
HLT_FrameHandle handle = {0};
handle.pointType = POINT_SEND;
handle.userData = (void *)&handle;
handle.expectReType = REC_TYPE_HANDSHAKE;
handle.expectHsType = CLIENT_HELLO;
handle.frameCallBack = FrameCallBack_ClientHello_LegacyVersion_Unsafe;
handle.ctx = clientRes->ssl;
ASSERT_TRUE(HLT_SetFrameHandle(&handle) == 0);
ASSERT_TRUE(HLT_TlsConnect(clientRes->ssl) != 0);
EXIT:
HLT_CleanFrameHandle();
HLT_FreeAllProcess();
}
/* END_CASE */
static void TEST_Server13_33_Err(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len,
uint32_t bufSize, void *user)
{
(void)ctx;
(void)data;
(void)len;
(void)bufSize;
uint32_t writeLen;
uint32_t sendLen = 5;
if (ctx->isClient==false){
uint8_t sendBuf[5] = {*(int *)user, 0x03, 0x03, 0x00, 0x00};
for (int i = 0; i < 33; i++) {
ASSERT_EQ(BSL_UIO_Write(ctx->uio, sendBuf, sendLen, &writeLen),0);
}
return;
}
EXIT:
return;
}
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_EMPTY_RECORDS_FUNC_TC001
* @title 0-length CCS or handshake is received during tls13 handshake proccess.
* @precon nan
* @brief 1. Start a handshake with tls13 config, Expected result 1
* 2. Modify the server hello message. Expected result 2
* @expect 1. Return success
* 2. Handshake fails
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_EMPTY_RECORDS_FUNC_TC001(int rec_type)
{
CRYPT_RandRegist(TestSimpleRand);
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, 8889, true);
ASSERT_TRUE(remoteProcess != NULL);
// Configure link information on the server.
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
serverCtxConfig->needCheckKeyUsage = true;
RecWrapper wrapper = {
TRY_SEND_SERVER_HELLO,
REC_TYPE_HANDSHAKE,
false,
&rec_type,
TEST_Server13_33_Err
};
RegisterWrapper(wrapper);
// The server listens on the TLS link.
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_3, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
// Configure link information on the client.
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
clientRes = HLT_ProcessTlsInit(remoteProcess, TLS1_3, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_RpcTlsConnect(remoteProcess, clientRes->sslId), HITLS_REC_ERR_RECV_UNEXPECTED_MSG);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) != 0);
ASSERT_EQ(HLT_RpcTlsGetAlertFlag(remoteProcess, clientRes->sslId), ALERT_FLAG_SEND);
ASSERT_EQ(
(ALERT_Description)HLT_RpcTlsGetAlertDescription(remoteProcess, clientRes->sslId),ALERT_UNEXPECTED_MESSAGE);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/* @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_APPDATA_MAX_LENGTH
* @spec -
* @title In the TLS1.3 scenario, after the link is established, the app data with the maximum length is sent.
It is expected that the app data can be properly processed.
* @precon nan
* @brief 1.Configuring TLS1.3 Link Establishment. Expected result 1 is displayed.
2.Sending large packets. Expected result 2 is obtained.
* @expect 1.Return success
2.Return success
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_APPDATA_MAX_LENGTH(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, 8888, false);
ASSERT_TRUE(remoteProcess != NULL);
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(localProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), 0);
uint8_t writeData[REC_MAX_PLAIN_LENGTH] = {1};
uint32_t writeLen = REC_MAX_PLAIN_LENGTH;
uint8_t readData[REC_MAX_PLAIN_LENGTH] = {0};
uint32_t readLen = REC_MAX_PLAIN_LENGTH;
ASSERT_EQ(HLT_ProcessTlsWrite(localProcess, clientRes, writeData, writeLen) , 0);
ASSERT_EQ(HLT_ProcessTlsRead(remoteProcess, serverRes, readData, readLen, &readLen) , 0);
ASSERT_EQ(readLen , REC_MAX_PLAIN_LENGTH);
ASSERT_EQ(memcmp(writeData, readData, readLen) , 0);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/consistency/tls13/test_suite_sdv_hlt_tls13_consistency_rfc8446_2.c
|
C
|
unknown
| 20,527
|
/*
* 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.
*/
/* BEGIN_HEADER */
/* INCLUDE_BASE test_suite_tls13_consistency_rfc8446 */
#include <stdio.h>
#include "stub_replace.h"
#include "hitls.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_uio.h"
#include "tls.h"
#include "hs_ctx.h"
#include "pack.h"
#include "send_process.h"
#include "frame_link.h"
#include "frame_tls.h"
#include "frame_io.h"
#include "simulate_io.h"
#include "parser_frame_msg.h"
#include "rec_wrapper.h"
#include "cert.h"
#include "securec.h"
#include "process.h"
#include "conn_init.h"
#include "hitls_crypt_init.h"
#include "hitls_psk.h"
#include "common_func.h"
#include "alert.h"
#include "bsl_sal.h"
/* END_HEADER */
#define MAX_BUF 16384
typedef struct {
uint16_t version;
BSL_UIO_TransportType uioType;
HITLS_Config *config;
HITLS_Config *s_config;
HITLS_Config *c_config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_Session *clientSession;
} ResumeTestInfo;
static void Test_Client_Mode(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
frameMsg.body.hsMsg.body.clientHello.pskModes.exData.state = ASSIGNED_FIELD;
BSL_SAL_FREE(frameMsg.body.hsMsg.body.clientHello.pskModes.exData.data);
uint16_t version[] = { 0x03, };
frameMsg.body.hsMsg.body.clientHello.pskModes.exData.data =
BSL_SAL_Calloc(sizeof(version) / sizeof(uint8_t), sizeof(uint8_t));
ASSERT_EQ(memcpy_s(frameMsg.body.hsMsg.body.clientHello.pskModes.exData.data,
sizeof(version), version, sizeof(version)), EOK);
frameMsg.body.hsMsg.body.clientHello.keyshares.exState = MISSING_FIELD;
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.state = MISSING_FIELD;
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
static void Test_Server_Keyshare(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);
frameMsg.body.hsMsg.body.serverHello.keyShare.data.state = ASSIGNED_FIELD;
frameMsg.body.hsMsg.body.serverHello.keyShare.data.group.data = *(uint64_t *)user;
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
#define TEST_SERVERNAME_LENGTH 20
#define BUF_SIZE_DTO_TEST 18432
#define ROOT_DER "%s/ca.der:%s/inter.der"
#define INTCA_DER "%s/inter.der"
#define SERVER_DER "%s/server.der"
#define SERVER_KEY_DER "%s/server.key.der"
#define CLIENT_DER "%s/client.der"
#define CLIENT_KEY_DER "%s/client.key.der"
#define IP_ADDR_MAX_LEN 16
#define BYTE_SIZE 8
#define SNI_TYPE 2
#define LARGE_SIZE 1025
static int SetCertPath(HLT_Ctx_Config *ctxConfig, const char *certStr, bool isServer)
{
int ret;
char caCertPath[50];
char chainCertPath[30];
char eeCertPath[30];
char privKeyPath[30];
ret = sprintf_s(caCertPath, sizeof(caCertPath), ROOT_DER, certStr, certStr);
ASSERT_TRUE(ret > 0);
ret = sprintf_s(chainCertPath, sizeof(chainCertPath), INTCA_DER, certStr);
ASSERT_TRUE(ret > 0);
ret = sprintf_s(eeCertPath, sizeof(eeCertPath), isServer ? SERVER_DER : CLIENT_DER, certStr);
ASSERT_TRUE(ret > 0);
ret = sprintf_s(privKeyPath, sizeof(privKeyPath), isServer ? SERVER_KEY_DER : CLIENT_KEY_DER, certStr);
ASSERT_TRUE(ret > 0);
HLT_SetCaCertPath(ctxConfig, (char *)caCertPath);
HLT_SetChainCertPath(ctxConfig, (char *)chainCertPath);
HLT_SetEeCertPath(ctxConfig, (char *)eeCertPath);
HLT_SetPrivKeyPath(ctxConfig, (char *)privKeyPath);
return 0;
EXIT:
return -1;
}
static void Test_Server_SVersion2(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);
frameMsg.body.hsMsg.body.serverHello.supportedVersion.data.data = *(uint64_t *)user;
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/* BEGIN_CASE */
void HITLS_TLS1_2_Config_SDV_23_0_5_0430(int version, int connType)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
RecWrapper wrapper = {
TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_Client_Mode
};
RegisterWrapper(wrapper);
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
SetCertPath(serverCtxConfig, "ecdsa_sha256", true);
serverRes = HLT_ProcessTlsAccept(remoteProcess, version, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_SetCertPath(clientCtxConfig, "ecdsa_sha256/ca.der", "NULL", "NULL", "NULL", "NULL", "NULL");
clientRes = HLT_ProcessTlsInit(localProcess, version, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_TlsConnect(clientRes->ssl), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_KEYSHAREGROUP_FUNC_TC001
* @spec -
* @title Initialize the client server to tls1.3 and construct the selected_group carried in the key_share extension in
* the sent serverhello message. It is not the group of the keyshareentry carried in the clienthello message or
* the group provided in the clienthello message. As a result, the connection setup fails.
* @precon nan
* @brief 4.2.8. Key Share line 72
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_KEYSHAREGROUP_FUNC_TC001(int version, int connType)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
uint64_t groupreturn[] = {HITLS_EC_GROUP_SM2, };
RecWrapper wrapper = {
TRY_SEND_SERVER_HELLO,
REC_TYPE_HANDSHAKE,
false,
&groupreturn,
Test_Server_Keyshare
};
RegisterWrapper(wrapper);
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
SetCertPath(serverCtxConfig, "ecdsa_sha256", true);
HLT_SetTls13CipherSuites(serverCtxConfig, "HITLS_AES_128_GCM_SHA256");
serverRes = HLT_ProcessTlsAccept(localProcess, version, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
SetCertPath(clientCtxConfig, "ecdsa_sha256", false);
HLT_SetGroups(clientCtxConfig, "HITLS_EC_GROUP_SECP256R1:HITLS_EC_GROUP_SECP384R1");
HLT_SetTls13CipherSuites(clientCtxConfig, "HITLS_AES_128_GCM_SHA256");
clientRes = HLT_ProcessTlsInit(remoteProcess, version, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_RpcTlsConnect(remoteProcess, clientRes->sslId), HITLS_MSG_HANDLE_ILLEGAL_SELECTED_GROUP);
ASSERT_EQ(HLT_RpcTlsGetAlertFlag(remoteProcess, clientRes->sslId), ALERT_FLAG_SEND);
ASSERT_EQ(HLT_RpcTlsGetAlertLevel(remoteProcess, clientRes->sslId), ALERT_LEVEL_FATAL);
ASSERT_EQ(HLT_RpcTlsGetAlertDescription(remoteProcess, clientRes->sslId), ALERT_ILLEGAL_PARAMETER);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
static void Test_Server_Keyshare1(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);
ASSERT_TRUE(frameMsg.body.hsMsg.body.serverHello.keyShare.data.group.data == *(uint64_t *)user);
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_KEYSHAREGROUP_FUNC_TC002
* @spec -
* @title clientHello's supported_groups is set to secp256r1. The handshake is successful.
* @precon nan
* @brief 9.1. Mandatory-to-Implement Cipher Suites line 230
* @expect 1. Expected connection setup success
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_KEYSHAREGROUP_FUNC_TC002(int version, int connType)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
const char *writeBuf = "Hello world";
uint8_t readBuf[BUF_SIZE_DTO_TEST] = {0};
uint32_t readLen;
uint64_t groupreturn[] = {HITLS_EC_GROUP_SECP256R1, };
RecWrapper wrapper = {
TRY_SEND_SERVER_HELLO,
REC_TYPE_HANDSHAKE,
false,
&groupreturn,
Test_Server_Keyshare1
};
RegisterWrapper(wrapper);
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
SetCertPath(serverCtxConfig, "ecdsa_sha256", true);
HLT_SetTls13CipherSuites(serverCtxConfig, "HITLS_AES_128_GCM_SHA256");
serverRes = HLT_ProcessTlsAccept(localProcess, version, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
SetCertPath(clientCtxConfig, "ecdsa_sha256", false);
HLT_SetGroups(clientCtxConfig, "HITLS_EC_GROUP_SECP256R1");
HLT_SetTls13CipherSuites(clientCtxConfig, "HITLS_AES_128_GCM_SHA256");
clientRes = HLT_ProcessTlsInit(remoteProcess, version, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_RpcTlsConnect(remoteProcess, clientRes->sslId), HITLS_SUCCESS);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, clientRes->sslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, BUF_SIZE_DTO_TEST, 0, BUF_SIZE_DTO_TEST) == EOK);
ASSERT_TRUE(HLT_TlsRead(serverRes->ssl, readBuf, BUF_SIZE_DTO_TEST, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_KEYSHAREGROUP_FUNC_TC003
* @spec -
* @title clientHello's supported_groups is set to X25519. The handshake succeeds.
* @precon nan
* @brief 9.1. Mandatory-to-Implement Cipher Suites line 230
* @expect 1. Expected connection setup success
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_KEYSHAREGROUP_FUNC_TC003(int version, int connType)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
const char *writeBuf = "Hello world";
uint8_t readBuf[BUF_SIZE_DTO_TEST] = {0};
uint32_t readLen;
uint64_t groupreturn[] = {HITLS_EC_GROUP_CURVE25519, };
RecWrapper wrapper = {
TRY_SEND_SERVER_HELLO,
REC_TYPE_HANDSHAKE,
false,
&groupreturn,
Test_Server_Keyshare1
};
RegisterWrapper(wrapper);
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
SetCertPath(serverCtxConfig, "ecdsa_sha256", true);
HLT_SetTls13CipherSuites(serverCtxConfig, "HITLS_AES_128_GCM_SHA256");
serverRes = HLT_ProcessTlsAccept(localProcess, version, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
SetCertPath(clientCtxConfig, "ecdsa_sha256", false);
HLT_SetGroups(clientCtxConfig, "HITLS_EC_GROUP_CURVE25519");
HLT_SetTls13CipherSuites(clientCtxConfig, "HITLS_AES_128_GCM_SHA256");
clientRes = HLT_ProcessTlsInit(remoteProcess, version, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_RpcTlsConnect(remoteProcess, clientRes->sslId), HITLS_SUCCESS);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, clientRes->sslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, BUF_SIZE_DTO_TEST, 0, BUF_SIZE_DTO_TEST) == EOK);
ASSERT_TRUE(HLT_TlsRead(serverRes->ssl, readBuf, BUF_SIZE_DTO_TEST, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
#define HS_RANDOM_SIZE 32u
static 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
};
static void Test_Server_Keyshare2(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);
if (memcmp(frameMsg.body.hsMsg.body.serverHello.randomValue.data, g_hrrRandom, HS_RANDOM_SIZE) != 0) {
frameMsg.body.hsMsg.body.serverHello.keyShare.data.state = ASSIGNED_FIELD;
frameMsg.body.hsMsg.body.serverHello.keyShare.data.group.data = *(uint64_t *)user;
}
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_NAMEDGROUP_FUNC_TC001
* @spec -
* @title 1. Initialize the client and server to tls1.3, construct the scenario where ecdhe is used, construct the
* scenario where hrr is sent, and construct the sent serverhello. The named group of the is different from
* that in the hrr. It is expected that the client terminates the handshake and sends the illegal_parameter
* alarm.
* @precon nan
* @brief 4.2.8. Key Share line 74
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_NAMEDGROUP_FUNC_TC001(int version, int connType)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
uint64_t groupreturn[] = {HITLS_EC_GROUP_SM2, };
RecWrapper wrapper = {
TRY_SEND_SERVER_HELLO,
REC_TYPE_HANDSHAKE,
false,
&groupreturn,
Test_Server_Keyshare2
};
RegisterWrapper(wrapper);
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
SetCertPath(serverCtxConfig, "ecdsa_sha256", true);
HLT_SetGroups(serverCtxConfig, "HITLS_EC_GROUP_CURVE25519:HITLS_EC_GROUP_SECP384R1");
HLT_SetTls13CipherSuites(serverCtxConfig, "HITLS_AES_128_GCM_SHA256");
serverRes = HLT_ProcessTlsAccept(localProcess, version, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
SetCertPath(clientCtxConfig, "ecdsa_sha256", false);
HLT_SetGroups(clientCtxConfig, "HITLS_EC_GROUP_SECP256R1:HITLS_EC_GROUP_SECP384R1");
HLT_SetTls13CipherSuites(clientCtxConfig, "HITLS_AES_128_GCM_SHA256");
clientRes = HLT_ProcessTlsInit(remoteProcess, version, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_RpcTlsConnect(remoteProcess, clientRes->sslId), HITLS_MSG_HANDLE_ILLEGAL_SELECTED_GROUP);
ASSERT_EQ(HLT_RpcTlsGetAlertFlag(remoteProcess, clientRes->sslId), ALERT_FLAG_SEND);
ASSERT_EQ(HLT_RpcTlsGetAlertLevel(remoteProcess, clientRes->sslId), ALERT_LEVEL_FATAL);
ASSERT_EQ(HLT_RpcTlsGetAlertDescription(remoteProcess, clientRes->sslId), ALERT_ILLEGAL_PARAMETER);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
static void Test_Server_SVersion(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
BSL_SAL_FREE(frameMsg.body.hsMsg.body.clientHello.cipherSuites.data);
uint16_t ciphers[3] = { 0xC02C, 0x1302, 0x1303};
frameMsg.body.hsMsg.body.clientHello.cipherSuites.data =
BSL_SAL_Calloc(sizeof(ciphers) / sizeof(uint16_t) + 1, sizeof(uint16_t));
ASSERT_EQ(memcpy_s(frameMsg.body.hsMsg.body.clientHello.cipherSuites.data,
sizeof(ciphers), ciphers, sizeof(ciphers)), EOK);
frameMsg.body.hsMsg.body.clientHello.cipherSuites.state = ASSIGNED_FIELD;
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC001
* @spec -
* @title The supported_versions in the clientHello is extended to 0x0304 (TLS 1.3). If the server supports only 1.2, the
* server returns a "protocol_version" warning and the handshake fails.
* @precon nan
* @brief Appendix D. Backward Compatibility line 247
* @expect
* 1. The setting is successful.
* 2. The setting is successful.
* 3. The connection is set up successfully.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC001( )
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
RecWrapper wrapper = {
TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_Server_SVersion
};
RegisterWrapper(wrapper);
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
SetCertPath(serverCtxConfig, "ecdsa_sha256", true);
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_2, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
SetCertPath(clientCtxConfig, "ecdsa_sha256", false);
clientRes = HLT_ProcessTlsInit(localProcess, TLS1_3, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_TlsConnect(clientRes->ssl), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ALERT_Info info = { 0 };
ALERT_GetInfo(clientRes->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_PROTOCOL_VERSION);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC002
* @spec -
* @title The supported_versions field in clientHello is extended to 0x0304 (TLS 1.3). If the server supports TLS 1.3,
* the server returns serverHello, If the value of upported_versions is changed to 0x0300, the client returns the
* warning "ALERT_ELLEGAL_PARAMETER" and the handshake fails.
* @precon nan
* @brief Appendix D. Backward Compatibility line 247
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC002(int version, int connType)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
uint64_t versions[] = {0x0300, };
RecWrapper wrapper = {
TRY_SEND_SERVER_HELLO,
REC_TYPE_HANDSHAKE,
false,
&versions,
Test_Server_SVersion2
};
RegisterWrapper(wrapper);
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
SetCertPath(serverCtxConfig, "ecdsa_sha256", true);
HLT_SetTls13CipherSuites(serverCtxConfig, "HITLS_AES_128_GCM_SHA256");
serverRes = HLT_ProcessTlsAccept(localProcess, version, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
SetCertPath(clientCtxConfig, "ecdsa_sha256", false);
HLT_SetGroups(clientCtxConfig, "HITLS_EC_GROUP_SECP256R1:HITLS_EC_GROUP_SECP384R1");
HLT_SetTls13CipherSuites(clientCtxConfig, "HITLS_AES_128_GCM_SHA256");
clientRes = HLT_ProcessTlsInit(remoteProcess, version, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_RpcTlsConnect(remoteProcess, clientRes->sslId), HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
ASSERT_EQ(HLT_RpcTlsGetAlertFlag(remoteProcess, clientRes->sslId), ALERT_FLAG_SEND);
ASSERT_EQ(HLT_RpcTlsGetAlertLevel(remoteProcess, clientRes->sslId), ALERT_LEVEL_FATAL);
ASSERT_EQ(HLT_RpcTlsGetAlertDescription(remoteProcess, clientRes->sslId), ALERT_ILLEGAL_PARAMETER);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
static void Test_Server_SVersion3(void *msg, void *userData)
{
HLT_FrameHandle *handle = (HLT_FrameHandle *)userData;
FRAME_Msg *frameMsg = (FRAME_Msg *)msg;
ASSERT_EQ(frameMsg->body.hsMsg.type.data, handle->expectHsType);
FRAME_ServerHelloMsg *serverhello = &frameMsg->body.hsMsg.body.serverHello;
serverhello->supportedVersion.exState = INITIAL_FIELD;
serverhello->supportedVersion.exLen.state = INITIAL_FIELD;
serverhello->supportedVersion.data.state = INITIAL_FIELD;
serverhello->supportedVersion.data.data = 0x0304;
FRAME_ModifyMsgInteger(HS_EX_TYPE_SUPPORTED_VERSIONS, &serverhello->supportedVersion.exType);
EXIT:
return;
}
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC003
* @spec -
* @title clientHello version is 0x0303 and the server supports 1.3 and 1.2. In this case, the server returns
* serverHello and selects version 1.2, If supported_versions is set to 0x0304, the client returns a
* "ALERT_UNSUPPORTED_EXTENSION" warning and the handshake fails.
* @precon nan
* @brief Appendix D. Backward Compatibility line 247
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC003()
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL,"SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
HLT_SetVersion(serverCtxConfig, HITLS_VERSION_TLS12, HITLS_VERSION_TLS13);
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_2, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL,"CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_CleanFrameHandle();
HLT_FrameHandle handle = {0};
handle.pointType = POINT_SEND;
handle.userData = (void *)&handle;
handle.expectReType = REC_TYPE_HANDSHAKE;
handle.expectHsType = SERVER_HELLO;
handle.frameCallBack = Test_Server_SVersion3;
handle.ctx = serverRes->ssl;
ASSERT_TRUE(HLT_SetFrameHandle(&handle) == 0);
clientRes = HLT_ProcessTlsInit(remoteProcess, TLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_RpcTlsConnect(remoteProcess, clientRes->sslId), HITLS_MSG_HANDLE_UNSUPPORT_EXTENSION_TYPE);
ASSERT_EQ(HLT_RpcTlsGetAlertFlag(remoteProcess, clientRes->sslId), ALERT_FLAG_SEND);
ASSERT_EQ(HLT_RpcTlsGetAlertLevel(remoteProcess, clientRes->sslId), ALERT_LEVEL_FATAL);
ASSERT_EQ(HLT_RpcTlsGetAlertDescription(remoteProcess, clientRes->sslId), ALERT_UNSUPPORTED_EXTENSION);
EXIT:
HLT_CleanFrameHandle();
HLT_FreeAllProcess();
}
/* END_CASE */
static void Test_Server_SVersion6(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
frameMsg.body.hsMsg.body.clientHello.version.data = 0x0304;
frameMsg.body.hsMsg.body.clientHello.supportedVersion.exState = MISSING_FIELD;
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC010
* @spec -
* @title ClientHello "supported_versions" extension does not exist, and ClientHello.legacy_version is TLS 1.3,
* The server supports TLS 1.3. Check that the server aborts the handshake with the "protocol_version" alert.
* @precon nan
* @brief Appendix D. Backward Compatibility line 248
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC010()
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
RecWrapper wrapper = {
TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_Server_SVersion6
};
RegisterWrapper(wrapper);
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL,"SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL,"CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
clientRes = HLT_ProcessTlsInit(localProcess, TLS1_3, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_TlsConnect(clientRes->ssl), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ALERT_Info info = { 0 };
ALERT_GetInfo(clientRes->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_RECV);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_PROTOCOL_VERSION);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC012
* @spec -
* @title ClientHello "supported_versions" extension does not exist, and ClientHello.legacy_version is TLS 1.2,
* The server only supports TLS 1.3. Check that the server aborts the handshake with the "protocol_version"
* alert.
* @precon nan
* @brief Appendix D. Backward Compatibility line 248
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_SVERSION_FUNC_TC012()
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL,"SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
HLT_SetVersion(serverCtxConfig, HITLS_VERSION_TLS13, HITLS_VERSION_TLS13);
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL,"CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
clientRes = HLT_ProcessTlsInit(localProcess, TLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_TlsConnect(clientRes->ssl), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ALERT_Info info = { 0 };
ALERT_GetInfo(clientRes->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_RECV);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_PROTOCOL_VERSION);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
static void Test_Server_MasterExtKey(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS12;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS12;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);
ASSERT_TRUE(frameMsg.body.hsMsg.body.serverHello.extendedMasterSecret.exState == INITIAL_FIELD);
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_MASTEREXTKEY_FUNC_TC001
* @spec -
* @title tls1.2 and tls1.3 carry the extended master key (overwrite the old and new versions). The handshake is
* successful.
* @precon nan
* @brief Appendix D. Backward Compatibility line 244
* @expect 1. Expected connection setup failure
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_MASTEREXTKEY_FUNC_TC001()
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
const char *writeBuf = "Hello world";
uint8_t readBuf[BUF_SIZE_DTO_TEST] = {0};
uint32_t readLen;
RecWrapper wrapper = {
TRY_SEND_SERVER_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_Server_MasterExtKey
};
RegisterWrapper(wrapper);
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL,"SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
HLT_SetVersion(serverCtxConfig, HITLS_VERSION_TLS12, HITLS_VERSION_TLS13);
HLT_SetCipherSuites(serverCtxConfig, "HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384");
serverRes = HLT_ProcessTlsAccept(localProcess, TLS_ALL, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL,"CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
clientRes = HLT_ProcessTlsInit(remoteProcess, TLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_RpcTlsConnect(remoteProcess, clientRes->sslId), HITLS_SUCCESS);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, clientRes->sslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, BUF_SIZE_DTO_TEST, 0, BUF_SIZE_DTO_TEST) == EOK);
ASSERT_TRUE(HLT_TlsRead(serverRes->ssl, readBuf, BUF_SIZE_DTO_TEST, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
static void Test_Client_PskTicket(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
frameMsg.body.hsMsg.body.clientHello.psks.identities.data->identity.data[0] += 0x01;
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_PSKTICKET_FUNC_TC001
* @spec -
* @title After the first connection is established, the ticket value is changed during session recovery. The session
* recovery is expected to fail.
* @precon nan
* @brief 4.6.1. New Session Ticket Message line 158
* @expect 1. Failed to restore the expected session.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_PSKTICKET_FUNC_TC001(int version, int connType)
{
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
int32_t serverConfigId = 0;
HITLS_Session *session = NULL;
const char *writeBuf = "Hello world";
uint8_t readBuf[BUF_SIZE_DTO_TEST] = {0};
uint32_t readLen;
int32_t cnt = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
void *clientConfig = HLT_TlsNewCtx(version);
ASSERT_TRUE(clientConfig != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
clientCtxConfig->isSupportRenegotiation = false;
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
serverCtxConfig->isSupportRenegotiation = false;
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, version, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
#endif
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
do {
DataChannelParam channelParam;
channelParam.port = g_uiPort;
channelParam.type = connType;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = connType;
localProcess->connType = connType;
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = connType;
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = connType;
HLT_TlsSetSsl(clientSsl, clientSslConfig);
if (session != NULL) {
ASSERT_TRUE(HITLS_SetSession(clientSsl, session) == HITLS_SUCCESS);
}
if (cnt != 0) {
RecWrapper wrapper = {
TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_Client_PskTicket
};
RegisterWrapper(wrapper);
}
ASSERT_TRUE(HLT_TlsConnect(clientSsl) == 0);
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, BUF_SIZE_DTO_TEST, 0, BUF_SIZE_DTO_TEST) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientSsl, readBuf, BUF_SIZE_DTO_TEST, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
ASSERT_TRUE(HLT_RpcTlsClose(remoteProcess, serverSslId) == 0);
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
if (cnt != 0) {
HITLS_SESS_Free(session);
session = NULL;
uint8_t isReused = 0;
ASSERT_TRUE(HITLS_IsSessionReused(clientSsl, &isReused) == HITLS_SUCCESS);
ASSERT_TRUE(isReused == 0);
}
session = HITLS_GetDupSession(clientSsl);
ASSERT_TRUE(session != NULL);
cnt++;
} while (cnt < 2);
EXIT:
ClearWrapper();
HITLS_SESS_Free(session);
HLT_FreeAllProcess();
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/consistency/tls13/test_suite_sdv_hlt_tls13_consistency_rfc8446_extensions.c
|
C
|
unknown
| 41,498
|
/*
* 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.
*/
/* BEGIN_HEADER */
/* INCLUDE_BASE test_suite_tls13_consistency_rfc8446 */
#include <stdio.h>
#include "stub_replace.h"
#include "hitls.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_uio.h"
#include "tls.h"
#include "hs_ctx.h"
#include "pack.h"
#include "send_process.h"
#include "frame_link.h"
#include "frame_tls.h"
#include "frame_io.h"
#include "simulate_io.h"
#include "parser_frame_msg.h"
#include "rec_wrapper.h"
#include "cert.h"
#include "securec.h"
#include "conn_init.h"
#include "hitls_crypt_init.h"
#include "hitls_psk.h"
#include "common_func.h"
#include "alert.h"
#include "process.h"
#include "bsl_sal.h"
/* END_HEADER */
#define PORT 6666
#define MAX_BUF_SIZE 18432
void GetStrGroup(int ConnType, int group, char** strgroup)
{
if (ConnType == HITLS) {
switch (group) {
case HITLS_FF_DHE_2048:
*strgroup = "HITLS_FF_DHE_2048";break;
case HITLS_FF_DHE_3072:
*strgroup = "HITLS_FF_DHE_3072";break;
case HITLS_FF_DHE_4096:
*strgroup = "HITLS_FF_DHE_4096";break;
case HITLS_FF_DHE_6144:
*strgroup = "HITLS_FF_DHE_6144";break;
case HITLS_FF_DHE_8192:
*strgroup = "HITLS_FF_DHE_8192";break;
default:
break;
}
} else {
switch (group) {
case HITLS_FF_DHE_2048:
*strgroup = "ffdhe2048";break;
case HITLS_FF_DHE_3072:
*strgroup = "ffdhe3072";break;
case HITLS_FF_DHE_4096:
*strgroup = "ffdhe4096";break;
case HITLS_FF_DHE_6144:
*strgroup = "ffdhe6144";break;
case HITLS_FF_DHE_8192:
*strgroup = "ffdhe8192";break;
default:
break;
}
}
}
void HRR_ClientGroupSetInfo(int ClientType, int group, char** clientgroup)
{
if (ClientType == HITLS) {
switch (group) {
case HITLS_FF_DHE_2048:
*clientgroup = "HITLS_EC_GROUP_SECP256R1:HITLS_FF_DHE_2048";break;
case HITLS_FF_DHE_3072:
*clientgroup = "HITLS_EC_GROUP_SECP256R1:HITLS_FF_DHE_3072";break;
case HITLS_FF_DHE_4096:
*clientgroup = "HITLS_EC_GROUP_SECP256R1:HITLS_FF_DHE_4096";break;
case HITLS_FF_DHE_6144:
*clientgroup = "HITLS_EC_GROUP_SECP256R1:HITLS_FF_DHE_6144";break;
case HITLS_FF_DHE_8192:
*clientgroup = "HITLS_EC_GROUP_SECP256R1:HITLS_FF_DHE_8192";break;
default:
break;
}
} else {
switch (group) {
case HITLS_FF_DHE_2048:
*clientgroup = "P-256:ffdhe2048";break;
case HITLS_FF_DHE_3072:
*clientgroup = "P-256:ffdhe3072";break;
case HITLS_FF_DHE_4096:
*clientgroup = "P-256:ffdhe4096";break;
case HITLS_FF_DHE_6144:
*clientgroup = "P-256:ffdhe6144";break;
case HITLS_FF_DHE_8192:
*clientgroup = "P-256:ffdhe8192";break;
default:
break;
}
}
}
static void Test_FFDHE_Key_ERROR(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len,
uint32_t bufSize, void *user)
{
(void)ctx;
(void)bufSize;
(void)user;
FRAME_Type frameType = { 0 };
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = { 0 };
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchange.state = ASSIGNED_FIELD;
memset_s(frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchange.data,
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchangeLen.data, 255,
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchangeLen.data );
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
static void Test_FFDHE_Key_Client_DecodeError(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len,
uint32_t bufSize, void *user)
{
(void)ctx;
(void)bufSize;
(void)user;
FRAME_Type frameType = { 0 };
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = { 0 };
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchange.state = ASSIGNED_FIELD;
memset_s(frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchange.data,
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchangeLen.data, 8, 10);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
static void Test_FFDHE_KeyLen_LessThenStandard(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len,
uint32_t bufSize, void *user)
{
(void)ctx;
(void)bufSize;
(void)user;
FRAME_Type frameType = { 0 };
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = { 0 };
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
frameMsg.body.hsMsg.body.clientHello.keyshares.exLen.state = INITIAL_FIELD;
frameMsg.body.hsMsg.body.clientHello.keyshares.exLen.data += (120 - 256);
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShareLen.state = INITIAL_FIELD;
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShareLen.data += (120 - 256);
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchangeLen.state = ASSIGNED_FIELD;
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchangeLen.data = 120;
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchange.state = ASSIGNED_FIELD;
BSL_SAL_FREE(frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchange.data);
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchange.data = BSL_SAL_Malloc(120);
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchange.size = 120;
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
static void Test_FFDHE_KeyLen_MoreThenStandard(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len,
uint32_t bufSize, void *user)
{
(void)ctx;
(void)bufSize;
(void)user;
FRAME_Type frameType = { 0 };
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = { 0 };
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
frameMsg.body.hsMsg.body.clientHello.keyshares.exLen.state = INITIAL_FIELD;
frameMsg.body.hsMsg.body.clientHello.keyshares.exLen.data += (1100 - 256);
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShareLen.state = INITIAL_FIELD;
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShareLen.data += (1100 - 256);
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchangeLen.state = ASSIGNED_FIELD;
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchangeLen.data = 1100;
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchange.state = ASSIGNED_FIELD;
BSL_SAL_FREE(frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchange.data);
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchange.data = BSL_SAL_Malloc(1100);
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchange.size = 1100;
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
static void Test_FFDHE_KeyLen_Error(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len,
uint32_t bufSize, void *user)
{
(void)ctx;
(void)bufSize;
(void)user;
FRAME_Type frameType = { 0 };
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = { 0 };
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchangeLen.state = ASSIGNED_FIELD;
frameMsg.body.hsMsg.body.clientHello.keyshares.exKeyShares.data->keyExchangeLen.data = 128;
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/**
* @brief tls1.3 ffdhe base testcase
* base test case
*/
/* BEGIN_CASE */
void UT_TLS13_RFC8446_FFDHE_TC001()
{
int version = TLS1_3;
int connType = TCP;
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
int32_t serverConfigId = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
void *clientConfig = HLT_TlsNewCtx(version);
ASSERT_TRUE(clientConfig != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
clientCtxConfig->isSupportClientVerify = true;
clientCtxConfig->isSupportPostHandshakeAuth = true;
HLT_SetGroups(clientCtxConfig, "HITLS_FF_DHE_4096");
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, version, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
#endif
serverCtxConfig->isSupportClientVerify = true;
serverCtxConfig->isSupportPostHandshakeAuth = true;
serverCtxConfig->securitylevel = 0;
HLT_SetGroups(serverCtxConfig, "HITLS_FF_DHE_4096");
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
DataChannelParam channelParam;
channelParam.port = 18889;
channelParam.type = connType;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = connType;
localProcess->connType = connType;
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = connType;
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = connType;
HLT_TlsSetSsl(clientSsl, clientSslConfig);
int ret = HLT_TlsConnect(clientSsl);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_RpcTlsClose(remoteProcess, serverSslId);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC001
* @spec -
* @title Verifying the HRR Link Setup Function When the FFDHE Group Is Used
* @precon nan
* @brief
* 1. Apply for and initialize the TLS1.3 configuration file.
* 2. Configure the client and server to support ffdhe2048, and set the client to ffdhe2048 as the second supported
& group.
* 3. Establish a connection and read and write data.
* 4. Switch the group to ffdhe3072, ffdhe4096, ffdhe6144, and ffdhe8192.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The connection is set up successfully, and data is read and written successfully.
* 4. The connection is set up successfully and data is read and written successfully.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC001(int group)
{
FRAME_Init();
int32_t ret;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
HITLS_Config *c_config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(c_config != NULL);
HITLS_Config *s_config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(s_config != NULL);
uint16_t groups = group;
uint16_t clientGroups[2] = {HITLS_EC_GROUP_SECP256R1};
clientGroups[1] = group;
HITLS_CFG_SetGroups(c_config, clientGroups, 2);
HITLS_CFG_SetGroups(s_config, &groups, 1);
client = FRAME_CreateLink(c_config, BSL_UIO_TCP);
server = FRAME_CreateLink(s_config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ret = FRAME_CreateConnection(client, server, false, HS_STATE_BUTT);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(client->ssl->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(server->ssl->state == CM_STATE_TRANSPORTING);
ASSERT_EQ(client->ssl->negotiatedInfo.negotiatedGroup, group);
uint8_t data[] = "Hello World";
uint32_t writeLen;
ASSERT_TRUE(HITLS_Write(client->ssl, data, strlen("Hello World"), &writeLen) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(client, server) == HITLS_SUCCESS);
uint8_t readBuf[MAX_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_TRUE(HITLS_Read(server->ssl, readBuf, MAX_BUF_SIZE, &readLen) == HITLS_SUCCESS);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
EXIT:
HITLS_CFG_FreeConfig(c_config);
HITLS_CFG_FreeConfig(s_config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC002
* @spec -
* @title Verifying the FFDHE Curve Function in PSK Link Establishment
* @precon nan
* @brief
* 1. Apply for and initialize the TLS1.3 configuration file.
* 2. Set the PSK mode to psk_with_dhe.
* 3. Configure the client and server to support FFDHE2048.
* 4. Establish a connection and read and write data.
* 5. Switch the group to ffdhe3072, ffdhe4096, ffdhe6144, and ffdhe8192.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The setting is successful.
* 4. The connection is set up successfully and data is read and written successfully.
* 5. The connection is successfully set up, and data is successfully read and written.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC002(int group)
{
FRAME_Init();
int32_t ret;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
HITLS_Config *c_config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(c_config != NULL);
HITLS_Config *s_config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(s_config != NULL);
uint16_t cipherSuite = HITLS_AES_128_GCM_SHA256;
HITLS_CFG_SetCipherSuites(c_config, &cipherSuite, 1);
HITLS_CFG_SetCipherSuites(s_config, &cipherSuite, 1);
HITLS_CFG_SetKeyExchMode(c_config, TLS13_KE_MODE_PSK_WITH_DHE);
HITLS_CFG_SetKeyExchMode(s_config, TLS13_KE_MODE_PSK_WITH_DHE);
uint16_t groups = group;
HITLS_CFG_SetGroups(c_config, &groups, 1);
HITLS_CFG_SetGroups(s_config, &groups, 1);
HITLS_CFG_SetPskClientCallback(c_config, ExampleClientCb);
HITLS_CFG_SetPskServerCallback(s_config, ExampleServerCb);
client = FRAME_CreateLink(c_config, BSL_UIO_TCP);
server = FRAME_CreateLink(s_config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ret = FRAME_CreateConnection(client, server, false, HS_STATE_BUTT);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_TRUE(client->ssl->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(server->ssl->state == CM_STATE_TRANSPORTING);
ASSERT_EQ(client->ssl->negotiatedInfo.negotiatedGroup, group);
ASSERT_EQ(client->ssl->negotiatedInfo.tls13BasicKeyExMode , TLS13_KE_MODE_PSK_WITH_DHE);
uint8_t data[] = "Hello World";
uint32_t writeLen;
ASSERT_TRUE(HITLS_Write(client->ssl, data, strlen("Hello World"), &writeLen) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(client, server) == HITLS_SUCCESS);
uint8_t readBuf[MAX_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_TRUE(HITLS_Read(server->ssl, readBuf, MAX_BUF_SIZE, &readLen) == HITLS_SUCCESS);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
EXIT:
HITLS_CFG_FreeConfig(c_config);
HITLS_CFG_FreeConfig(s_config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC003
* @spec -
* @title Verifying the Function of Using the FFDHE Curve for Certificate Rejection Authentication in psk_only Mode
* @precon nan
* @brief
* 1. Apply for and initialize the TLS1.3 configuration file.
* 2. Set the PSK only on the client.
* 3. Set the PSK mode of the client and server to psk_with_only.
* 4. Set the client and server to ffdhe2048.
* 5. Establish a connection and read and write data.
* 6. Switch the group to ffdhe3072, ffdhe4096, ffdhe6144, and ffdhe8192.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The setting is successful.
* 4. The setting is successful.
* 5. The connection is successfully set up, and data is successfully read and written.
* 6. The connection is successfully set up, and data is successfully read and written.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC003(int group)
{
FRAME_Init();
int32_t ret;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
HITLS_Config *c_config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(c_config != NULL);
HITLS_Config *s_config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(s_config != NULL);
uint16_t cipherSuite = HITLS_AES_128_GCM_SHA256;
HITLS_CFG_SetCipherSuites(c_config, &cipherSuite, 1);
HITLS_CFG_SetCipherSuites(s_config, &cipherSuite, 1);
HITLS_CFG_SetKeyExchMode(c_config, TLS13_KE_MODE_PSK_ONLY);
HITLS_CFG_SetKeyExchMode(s_config, TLS13_KE_MODE_PSK_ONLY);
uint16_t groups = group;
HITLS_CFG_SetGroups(c_config, &groups, 1);
HITLS_CFG_SetGroups(s_config, &groups, 1);
ExampleSetPsk("12121212121212");
HITLS_CFG_SetPskClientCallback(c_config, ExampleClientCb);
client = FRAME_CreateLink(c_config, BSL_UIO_TCP);
server = FRAME_CreateLink(s_config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ret = FRAME_CreateConnection(client, server, false, HS_STATE_BUTT);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(client->ssl->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(server->ssl->state == CM_STATE_TRANSPORTING);
ASSERT_EQ(client->ssl->negotiatedInfo.negotiatedGroup, group);
ASSERT_EQ(client->ssl->negotiatedInfo.tls13BasicKeyExMode , TLS13_CERT_AUTH_WITH_DHE);
uint8_t data[] = "Hello World";
uint32_t writeLen;
ASSERT_TRUE(HITLS_Write(client->ssl, data, strlen("Hello World"), &writeLen) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(client, server) == HITLS_SUCCESS);
uint8_t readBuf[MAX_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_TRUE(HITLS_Read(server->ssl, readBuf, MAX_BUF_SIZE, &readLen) == HITLS_SUCCESS);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
EXIT:
HITLS_CFG_FreeConfig(c_config);
HITLS_CFG_FreeConfig(s_config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC004
* @spec -
* @title The key length in the keyshare file is less than the length required by the RFC.
* @precon nan
* @brief
* 1. Apply for and initialize the TLS1.3 configuration file.
* 2. Configure the client and server to support ffdhe2048.
* 3. Change the value of Key Exchange Length in the keyshare field in the client hello packet to 120.
* 4. Establish a connection and observe the server behavior.
* 5. Switch the group to ffdhe3072, ffdhe4096, ffdhe6144, and ffdhe8192, and repeat the preceding operations.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The modification is successful.
* 4. The server sends an alert message to disconnect the connection.
* 5. The server sends an alert message to disconnect the connection.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC004(int ClientType, int ServerType, int group)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
char *servergroup;
char *clientgroup;
localProcess = HLT_InitLocalProcess(ClientType);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(ServerType, TCP, PORT, false);
ASSERT_TRUE(remoteProcess != NULL);
// Apply for and initialize the TLS1.3 configuration file.
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Configure the client and server to support ffdhe2048.
GetStrGroup(ClientType, group, &clientgroup);
GetStrGroup(ServerType, group, &servergroup);
HLT_SetGroups(serverConfig, servergroup);
HLT_SetGroups(clientConfig, clientgroup);
// Change the value of Key Exchange Length in the keyshare field in the client hello packet to 120.
RecWrapper wrapper = {
TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_FFDHE_KeyLen_LessThenStandard
};
RegisterWrapper(wrapper);
// Establish a connection and observe the server behavior.
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(localProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes == NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), HITLS_MSG_HANDLE_ILLEGAL_SELECTED_GROUP);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC005
* @spec -
* @title The key length in the keyshare file is greater than the length required by the RFC.
* @precon nan
* @brief
* 1. Apply for and initialize the TLS1.3 configuration file.
* 2. Configure the client and server to support FFDHE2048.
* 3. Change the value of Key Exchange Length in the keyshare message sent by the client to 8800.
* 4. Establish a connection and observe the server behavior.
* 5. Switch groups ffdhe3072, ffdhe4096, ffdhe6144, and ffdhe8192. Repeat the preceding operations.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The setting is successful.
* 4. The modification is successful.
* 5. The server sends an alert message to disconnect the connection.
* 6. The server sends an alert message to disconnect the connection.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC005(int ClientType, int ServerType, int group)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
char *servergroup;
char *clientgroup;
localProcess = HLT_InitLocalProcess(ClientType);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(ServerType, TCP, PORT, false);
ASSERT_TRUE(remoteProcess != NULL);
// Apply for and initialize the TLS1.3 configuration file.
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Configure the client and server to support FFDHE2048.
GetStrGroup(ClientType, group, &clientgroup);
GetStrGroup(ServerType, group, &servergroup);
HLT_SetGroups(serverConfig, servergroup);
HLT_SetGroups(clientConfig, clientgroup);
// Change the value of Key Exchange Length in the keyshare message sent by the client to 8800.
RecWrapper wrapper = {
TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_FFDHE_KeyLen_MoreThenStandard
};
RegisterWrapper(wrapper);
// Establish a connection and observe the server behavior.
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(localProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes == NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), HITLS_MSG_HANDLE_ILLEGAL_SELECTED_GROUP);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC006
* @spec -
* @title The server fails to parse the key in the keyshare file.
* @precon nan
* @brief
* 1. Apply for and initialize the TLS1.3 configuration file.
* 2. Configure the client and server to support FFDHE2048.
* 3. Change the values of all bits of the key in the keyshare of the client hello packet to 0xff.
* 4. Establish a connection and observe the server behavior.
* 5. Switch groups ffdhe3072, ffdhe4096, ffdhe6144, and ffdhe8192. Repeat the preceding operations.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The modification is successful.
* 4. The server sends an alert message to disconnect the connection.
* 5. The server sends an alert message to disconnect the connection.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC006(int ClientType, int ServerType, int group)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
char *servergroup;
char *clientgroup;
localProcess = HLT_InitLocalProcess(ClientType);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(ServerType, TCP, PORT, false);
ASSERT_TRUE(remoteProcess != NULL);
// Apply for and initialize the TLS1.3 configuration file.
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Configure the client and server to support FFDHE2048.
GetStrGroup(ClientType, group, &clientgroup);
GetStrGroup(ServerType, group, &servergroup);
HLT_SetGroups(serverConfig, servergroup);
HLT_SetGroups(clientConfig, clientgroup);
// Change the values of all bits of the key in the keyshare of the client hello packet to 0xff.
RecWrapper wrapper = {
TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_FFDHE_Key_ERROR
};
RegisterWrapper(wrapper);
// Establish a connection and observe the server behavior.
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(localProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes == NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), HITLS_CRYPT_ERR_CALC_SHARED_KEY);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC007
* @spec -
* @title The server successfully parses the incorrect key in keyshare.
* @precon nan
* @brief
* 1. Apply for and initialize the TLS1.3 configuration file.
* 2. Configure the client and server to support the elliptic curve ffdhe2048.
* 3. Change the value of the first 10 bits of the key in the keyshare of the client hello packet to 8.
* 4. Establish a connection and observe the client.
* 5. Switch the elliptic curve and repeat the preceding operations.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The modification is successful.
* 4. The client is disconnected due to decryption failure.
* 5. Client decryption fails.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC007(int ClientType, int ServerType, int group)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
char *servergroup;
char *clientgroup;
localProcess = HLT_InitLocalProcess(ClientType);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(ServerType, TCP, PORT, false);
ASSERT_TRUE(remoteProcess != NULL);
// Apply for and initialize the TLS1.3 configuration file.
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Configure the client and server to support the elliptic curve ffdhe2048.
GetStrGroup(ClientType, group, &clientgroup);
GetStrGroup(ServerType, group, &servergroup);
HLT_SetGroups(serverConfig, servergroup);
HLT_SetGroups(clientConfig, clientgroup);
// Change the value of the first 10 bits of the key in the keyshare of the client hello packet to 8.
RecWrapper wrapper = {
TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_FFDHE_Key_Client_DecodeError
};
RegisterWrapper(wrapper);
// Establish a connection and observe the client.
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(localProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes == NULL);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC008
* @spec -
* @title The key value in keyshare does not match the Key Exchange Length value. Parsing failed.
* @precon nan
* @brief
* 1. Apply for and initialize the TLS1.3 configuration file.
* 2. Configure the client and server to support FFDHE2048.
* 3. Change the length of the key in the keyshare of the client hello packet to 1024 bits.
* 4. Establish a connection and observe the server behavior.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The modification is successful.
* 4. The server sends an alert message to disconnect the connection.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_DHE_GROUP_FUNC_TC008(int ClientType, int ServerType, int group)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
char *servergroup;
char *clientgroup;
localProcess = HLT_InitLocalProcess(ClientType);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(ServerType, TCP, PORT, false);
ASSERT_TRUE(remoteProcess != NULL);
// Apply for and initialize the TLS1.3 configuration file.
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Configure the client and server to support FFDHE2048.
GetStrGroup(ClientType, group, &clientgroup);
GetStrGroup(ServerType, group, &servergroup);
HLT_SetGroups(serverConfig, servergroup);
HLT_SetGroups(clientConfig, clientgroup);
// Change the length of the key in the keyshare of the client hello packet to 1024 bits.
RecWrapper wrapper = {
TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_FFDHE_KeyLen_Error
};
RegisterWrapper(wrapper);
// Establish a connection and observe the server behavior.
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(localProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes == NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), HITLS_PARSE_INVALID_MSG_LEN);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/consistency/tls13/test_suite_sdv_hlt_tls13_consistency_rfc8446_ffdhe.c
|
C
|
unknown
| 34,822
|
/*
* 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.
*/
/* BEGIN_HEADER */
/* INCLUDE_BASE test_suite_tls13_consistency_rfc8446 */
#include <stdio.h>
#include "stub_replace.h"
#include "hitls.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_uio.h"
#include "tls.h"
#include "hs_ctx.h"
#include "pack.h"
#include "send_process.h"
#include "frame_link.h"
#include "frame_tls.h"
#include "frame_io.h"
#include "simulate_io.h"
#include "parser_frame_msg.h"
#include "rec_wrapper.h"
#include "cert.h"
#include "securec.h"
#include "conn_init.h"
#include "hitls_crypt_init.h"
#include "hitls_psk.h"
#include "common_func.h"
#include "alert.h"
#include "process.h"
#include "bsl_sal.h"
/* END_HEADER */
#define MAX_BUF 16384
int32_t STUB_RecConnDecrypt(
TLS_Ctx *ctx, RecConnState *state, const REC_TextInput *cryptMsg, uint8_t *data, uint32_t *dataLen)
{
(void)ctx;
(void)state;
memcpy_s(data, cryptMsg->textLen, cryptMsg->text, cryptMsg->textLen);
(void)data;
*dataLen = cryptMsg->textLen;
return HITLS_SUCCESS;
}
int32_t STUB_REC_Write(TLS_Ctx *ctx, REC_Type recordType, const uint8_t *data, uint32_t num)
{
(void)ctx;
(void)recordType;
(void)data;
(void)num;
return HITLS_SUCCESS;
}
extern int32_t __real_REC_Write(TLS_Ctx *ctx, REC_Type recordType, const uint8_t *data, uint32_t num);
static void Test_FinishToAPP(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, FINISHED);
STUB_Replace(user, __real_REC_Write, STUB_REC_Write);
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
static void Test_ServerHello_Add_PhaExtensions(
HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)bufSize;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);
uint8_t posthandshake[] = {0x00, 0x31, 0x00, 0x00};
frameMsg.body.hsMsg.length.state = ASSIGNED_FIELD;
frameMsg.body.hsMsg.length.data += sizeof(posthandshake);
frameMsg.body.hsMsg.body.serverHello.extensionLen.state = ASSIGNED_FIELD;
frameMsg.body.hsMsg.body.serverHello.extensionLen.data =
frameMsg.body.hsMsg.body.serverHello.extensionLen.data + sizeof(posthandshake);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
ASSERT_EQ(memcpy_s(&data[*len], bufSize - *len, &posthandshake, sizeof(posthandshake)), EOK);
*len += sizeof(posthandshake);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
static void Test_CertificateRequest_Ctx_Zero(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)bufSize;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CERTIFICATE_REQUEST);
frameMsg.body.hsMsg.body.certificateReq.certificateReqCtx.state = MISSING_FIELD;
frameMsg.body.hsMsg.body.certificateReq.certificateReqCtxSize.state = ASSIGNED_FIELD;
frameMsg.body.hsMsg.body.certificateReq.certificateReqCtxSize.data = 0;
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
static void Test_Certificate_Ctx_Zero(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)bufSize;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CERTIFICATE);
frameMsg.body.hsMsg.body.certificate.certificateReqCtx.state = MISSING_FIELD;
frameMsg.body.hsMsg.body.certificate.certificateReqCtxSize.state = ASSIGNED_FIELD;
frameMsg.body.hsMsg.body.certificate.certificateReqCtxSize.data = 0;
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
static void Test_Certificate_Ctx_NotSame(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)bufSize;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CERTIFICATE);
frameMsg.body.hsMsg.body.certificate.certificateReqCtx.state = ASSIGNED_FIELD;
*(frameMsg.body.hsMsg.body.certificate.certificateReqCtx.data) += 1;
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
static void Test_Finish_Error(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)bufSize;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, FINISHED);
frameMsg.body.hsMsg.body.finished.verifyData.state = ASSIGNED_FIELD;
*(frameMsg.body.hsMsg.body.finished.verifyData.data) += 1;
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
/**
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_PHA_FUNC_TC001
* @brief tls1.3 post-handshake auth
* base test case
*/
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_PHA_FUNC_TC001()
{
HLT_Process *localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
bool isBlock = true;
HLT_Process *remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, 18889, isBlock);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *config_s = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(config_s != NULL);
HLT_SetPostHandshakeAuth(config_s, true);
HLT_SetClientVerifySupport(config_s, true);
HLT_Ctx_Config *config_c = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(config_c != NULL);
HLT_SetPostHandshakeAuth(config_c, true);
HLT_SetClientVerifySupport(config_c, true);
HLT_Tls_Res *serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, config_s, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Tls_Res *clientRes = HLT_ProcessTlsConnect(localProcess, TLS1_3, config_c, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), 0);
uint8_t src[] = "Hello world!";
uint32_t readbytes = 0;
uint8_t dest[READ_BUF_SIZE] = {0};
ASSERT_EQ(HLT_ProcessTlsWrite(localProcess, clientRes, src, sizeof(src)), 0);
ASSERT_EQ(HLT_ProcessTlsRead(remoteProcess, serverRes, dest, READ_BUF_SIZE, &readbytes), 0);
ASSERT_TRUE(readbytes == sizeof(src));
ASSERT_TRUE(memcmp(src, dest, readbytes) == 0);
memset_s(dest, READ_BUF_SIZE, 0, READ_BUF_SIZE);
EXIT:
HLT_FreeAllProcess();
return;
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC002
* @spec -
* @title The client does not support post-handshake authentication, but receives the server hello message that carries
* the extension.
* @precon nan
* @brief
* 1. Apply and initialize config
* 2. Set the client not to support post-handshake extension
* 3. Set up a connection and modify the server hello message to carry the post-handshake extension.
* 4. Observe client behavior
* @expect
* 1. Initialization succeeded.
* 2. Set succeeded.
* 3. Modification succeeded.
* 4. The client returns alert
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC002(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, 18889, false);
ASSERT_TRUE(remoteProcess != NULL);
// Apply and initialize config
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Set the client not to support post-handshake extension
HLT_SetPostHandshakeAuth(serverConfig, true);
HLT_SetClientVerifySupport(serverConfig, true);
HLT_SetPostHandshakeAuth(clientConfig, false);
HLT_SetClientVerifySupport(clientConfig, true);
// Set up a connection and modify the server hello message to carry the post-handshake extension.
RecWrapper wrapper = {TRY_SEND_SERVER_HELLO, REC_TYPE_HANDSHAKE, false, NULL, Test_ServerHello_Add_PhaExtensions};
RegisterWrapper(wrapper);
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
// The client returns alert
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes == NULL);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) != 0);
EXIT:
HLT_FreeAllProcess();
ClearWrapper();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC003
* @spec -
* @title The client supports authentication after handshake, but receives the server hello message that carries the
* extension.
* @precon nan
* @brief
* 1. Apply and initialize config
* 2. Set the client support post-handshake extension
* 3. Set up a connection and modify the server hello message to carry the post-handshake extension.
* 4. Observe client behavior
* @expect
* 1. Initialization succeeded.
* 2. Set succeeded.
* 3. Modification succeeded.
* 4. The client returns alert
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC003(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, 18889, false);
ASSERT_TRUE(remoteProcess != NULL);
// Apply and initialize config
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Set the client support post-handshake extension
HLT_SetPostHandshakeAuth(serverConfig, true);
HLT_SetClientVerifySupport(serverConfig, true);
HLT_SetPostHandshakeAuth(clientConfig, true);
HLT_SetClientVerifySupport(clientConfig, true);
// Set up a connection and modify the server hello message to carry the post-handshake extension.
RecWrapper wrapper = {TRY_SEND_SERVER_HELLO, REC_TYPE_HANDSHAKE, false, NULL, Test_ServerHello_Add_PhaExtensions};
RegisterWrapper(wrapper);
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
// The client returns alert
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes == NULL);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) != 0);
EXIT:
HLT_FreeAllProcess();
ClearWrapper();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC004
* @spec -
* @title When the value of certificate_request_context in the certificate request message
* after handshake authentication is 0, the client reports an error.
* @precon nan
* @brief
* 1. Apply and initialize config
* 2. Set the client support post-handshake extension
* 3. After the connection establishment is completed, modify the certificate_request_context of the
* certificate request message sent by the server to 0.
* 4. Observe client behavior
* @expect
* 1. Initialization succeeded.
* 2. Set succeeded.
* 3. Modification succeeded.
* 4. The client returns alert
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC004(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, 18889, false);
ASSERT_TRUE(remoteProcess != NULL);
// Apply and initialize config
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Set the client support post-handshake extension
HLT_SetPostHandshakeAuth(serverConfig, true);
HLT_SetClientVerifySupport(serverConfig, true);
HLT_SetPostHandshakeAuth(clientConfig, true);
HLT_SetClientVerifySupport(clientConfig, true);
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), 0);
ASSERT_EQ(HITLS_VerifyClientPostHandshake(serverRes->ssl), HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
// modify the certificate_request_context of the certificate request message sent by the server to 0.
ClearWrapper();
RecWrapper wrapper = {
TRY_SEND_CERTIFICATE_REQUEST, REC_TYPE_HANDSHAKE, false, NULL, Test_CertificateRequest_Ctx_Zero};
RegisterWrapper(wrapper);
ASSERT_TRUE(HLT_TlsWrite(serverRes->ssl, (uint8_t *)writeBuf, strlen(writeBuf)) == HITLS_SUCCESS);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
// The client returns alert
ASSERT_TRUE(HLT_RpcTlsRead(remoteProcess, clientRes->sslId, readBuf, READ_BUF_SIZE, &readLen) ==
HITLS_MSG_HANDLE_INVALID_CERT_REQ_CTX);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC005
* @spec -
* @title The server reports an error when the value of certificate_request_context of the
* client certificate is 0 during authentication after handshake.
* @precon nan
* @brief
* 1. Apply and initialize config
* 2. Set the client support post-handshake extension
* 3. After the connection is established, the server initiates a certificate request and changes the value of
* certificate_request_context in the certificate request message from the client to 0
* 4. Observe the server behavior
* @expect
* 1. Initialization succeeded.
* 2. Set succeeded.
* 3. Modification succeeded.
* 4. The server returns alert
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC005(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, 18889, false);
ASSERT_TRUE(remoteProcess != NULL);
// Apply and initialize config
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Set the client support post-handshake extension
HLT_SetPostHandshakeAuth(serverConfig, true);
HLT_SetClientVerifySupport(serverConfig, true);
HLT_SetPostHandshakeAuth(clientConfig, true);
HLT_SetClientVerifySupport(clientConfig, true);
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(localProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), 0);
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverRes->sslId) == HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
// changes the value of certificate_request_context in the certificate request message from the client to 0
ClearWrapper();
RecWrapper wrapper = {TRY_SEND_CERTIFICATE, REC_TYPE_HANDSHAKE, false, NULL, Test_Certificate_Ctx_Zero};
RegisterWrapper(wrapper);
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverRes->sslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientRes->ssl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
ASSERT_TRUE(HLT_TlsWrite(clientRes->ssl, (uint8_t *)writeBuf, strlen(writeBuf)) == HITLS_SUCCESS);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
// The server returns alert
ASSERT_EQ(HLT_RpcTlsRead(remoteProcess, serverRes->sslId, readBuf, READ_BUF_SIZE, &readLen),
HITLS_MSG_HANDLE_INVALID_CERT_REQ_CTX);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC006
* @spec -
* @title During post-handshake authentication, the certificate_request_context sent by the client is inconsistent with
* that sent by the server. As a result, the server reports an error.
* @precon nan
* @brief
* 1. Apply and initialize config
* 2. Set the client support post-handshake extension
* 3. After the connection is established, the server initiates a certificate request and changes the value of
* certificate_request_context in the certificate request message from the client
* 4. Observe the server behavior
* @expect
* 1. Initialization succeeded.
* 2. Set succeeded.
* 3. Modification succeeded.
4. The server returns alert
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC006(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, 18889, false);
ASSERT_TRUE(remoteProcess != NULL);
// Apply and initialize config
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Set the client support post-handshake extension
HLT_SetPostHandshakeAuth(serverConfig, true);
HLT_SetClientVerifySupport(serverConfig, true);
HLT_SetPostHandshakeAuth(clientConfig, true);
HLT_SetClientVerifySupport(clientConfig, true);
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(localProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), 0);
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverRes->sslId) == HITLS_SUCCESS);
;
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
// changes the value of certificate_request_context in the certificate request message from the client
ClearWrapper();
RecWrapper wrapper = {TRY_SEND_CERTIFICATE, REC_TYPE_HANDSHAKE, false, NULL, Test_Certificate_Ctx_NotSame};
RegisterWrapper(wrapper);
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverRes->sslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientRes->ssl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
ASSERT_TRUE(HLT_TlsWrite(clientRes->ssl, (uint8_t *)writeBuf, strlen(writeBuf)) == HITLS_SUCCESS);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
// The server returns alert
ASSERT_EQ(HLT_RpcTlsRead(remoteProcess, serverRes->sslId, readBuf, READ_BUF_SIZE, &readLen),
HITLS_MSG_HANDLE_INVALID_CERT_REQ_CTX);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC007
* @spec -
* @title After the PSK connection is established, the certificate is authenticated after handshake. The authentication is
* successful.
* @precon nan
* @brief
* 1. Apply for and initialize the configuration file
* 2. Setting the PSK on the Client and Server
* 3. Configure the client and server to support post-handshake extension
* 4. After the connection is established, the server sends a certificate request message for backhandshake authentication.
* @expect
* 1. Initialization succeeded.
* 2. Setting succeeded.
* 3. Setting succeeded.
* 4. Authentication succeeded.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC007(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, 18889, false);
ASSERT_TRUE(remoteProcess != NULL);
// Apply for and initialize the configuration file
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Configure the client and server to support post-handshake extension
HLT_SetPostHandshakeAuth(serverConfig, true);
HLT_SetClientVerifySupport(serverConfig, true);
HLT_SetPostHandshakeAuth(clientConfig, true);
HLT_SetClientVerifySupport(clientConfig, true);
// Setting the PSK on the Client and Server
memcpy_s(clientConfig->psk, PSK_MAX_LEN, "12121212121212", sizeof("12121212121212"));
memcpy_s(serverConfig->psk, PSK_MAX_LEN, "12121212121212", sizeof("12121212121212"));
HLT_SetCipherSuites(clientConfig, "HITLS_AES_128_GCM_SHA256");
HLT_SetCipherSuites(serverConfig, "HITLS_AES_128_GCM_SHA256");
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), 0);
// the server sends a certificate request message for backhandshake authentication.
ASSERT_EQ(HITLS_VerifyClientPostHandshake(serverRes->ssl), HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
ASSERT_TRUE(HLT_TlsWrite(serverRes->ssl, (uint8_t *)writeBuf, strlen(writeBuf)) == HITLS_SUCCESS);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_EQ(HLT_RpcTlsRead(remoteProcess, clientRes->sslId, readBuf, READ_BUF_SIZE, &readLen), HITLS_SUCCESS);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, clientRes->sslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(serverRes->ssl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC008
* @spec -
* @title The server fails to verify the finish during post-authentication.
* @precon nan
* @brief
* 1. Apply and initialize config
* 2. Set the client support post-handshake extension
* 3. After the connection is established, the server initiates a certificate request and Modify the finish message sent
* by the client.
* 4. Observe the server behavior
* @expect
* 1. Initialization succeeded.
* 2. Set succeeded.
* 3. Modification succeeded.
* 4. The server returns alert
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC008(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, 18889, false);
ASSERT_TRUE(remoteProcess != NULL);
// Apply and initialize config
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverConfig != NULL);
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientConfig != NULL);
// Set the client support post-handshake extension
HLT_SetPostHandshakeAuth(serverConfig, true);
HLT_SetClientVerifySupport(serverConfig, true);
HLT_SetPostHandshakeAuth(clientConfig, true);
HLT_SetClientVerifySupport(clientConfig, true);
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(localProcess, TLS1_3, clientConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), 0);
// the server initiates a certificate request
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverRes->sslId) == HITLS_SUCCESS);
;
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
// Modify the finish message sent by the client.
ClearWrapper();
RecWrapper wrapper = {TRY_SEND_FINISH, REC_TYPE_HANDSHAKE, false, NULL, Test_Finish_Error};
RegisterWrapper(wrapper);
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverRes->sslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientRes->ssl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
ASSERT_TRUE(HLT_TlsWrite(clientRes->ssl, (uint8_t *)writeBuf, strlen(writeBuf)) == HITLS_SUCCESS);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
// The server returns alert
ASSERT_EQ(HLT_RpcTlsRead(remoteProcess, serverRes->sslId, readBuf, READ_BUF_SIZE, &readLen),
HITLS_MSG_HANDLE_VERIFY_FINISHED_FAIL);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC009
* @spec -
* @title Two certificates request messages are sent for backhandshake authentication,
and the required certificate_request_context is inconsistent.
* @precon nan
* @brief
1. Apply and initialize config
2. Set the client support post-handshake extension
3. After the connection is established, the server continuously sends certificate request messages for backhandshake
authentication
4. Check whether the certificate_request_context sent by the server is the same.
* @expect
1. Initialization succeeded.
2. Set succeeded.
3. Constructed successfully.
4. Inconsistent certificate_request_context
* @prior Level 1
* @auto TRUE+
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC009()
{
int version = TLS1_3;
int connType = TCP;
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
int32_t serverConfigId = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
void *clientConfig = HLT_TlsNewCtx(version);
ASSERT_TRUE(clientConfig != NULL);
// Apply and initialize config
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(clientCtxConfig != NULL);
ASSERT_TRUE(serverCtxConfig != NULL);
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, version, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
#endif
// Set the client support post-handshake extension
clientCtxConfig->isSupportClientVerify = true;
clientCtxConfig->isSupportPostHandshakeAuth = true;
serverCtxConfig->isSupportClientVerify = true;
serverCtxConfig->isSupportPostHandshakeAuth = true;
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
DataChannelParam channelParam;
channelParam.port = 18889;
channelParam.type = connType;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = connType;
localProcess->connType = connType;
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = connType;
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = connType;
HLT_TlsSetSsl(clientSsl, clientSslConfig);
int ret = HLT_TlsConnect(clientSsl);
ASSERT_EQ(ret, HITLS_SUCCESS);
// the server continuously sends certificate request messages
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverSslId) == HITLS_SUCCESS);
;
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
HITLS_Ctx *ctx = clientSsl;
uint8_t ReqCtx1[1 * 1024] = {0};
memcpy_s(ReqCtx1, ctx->certificateReqCtxSize, ctx->certificateReqCtx, ctx->certificateReqCtxSize);
HLT_TlsWrite(clientSsl, (uint8_t *)writeBuf, strlen(writeBuf));
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
HLT_RpcTlsRead(remoteProcess, serverSslId, readBuf, READ_BUF_SIZE, &readLen);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
// the server continuously sends certificate request messages
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverSslId) == HITLS_SUCCESS);
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
// Inconsistent certificate_request_context
ASSERT_TRUE(memcmp(ReqCtx1, ctx->certificateReqCtx, ctx->certificateReqCtxSize) != 0);
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_RpcTlsClose(remoteProcess, serverSslId);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC011
* @spec -
* @title The server does not allow the client to send an empty certificate. During authentication after handshake,
* the server receives an empty certificate from the client.
* @precon nan
* @brief
* 1. Apply for and initialize the config file. Expected result 1 is obtained.
* 2. Configure the server not to allow the client to send an empty certificate. Expected result 2 is obtained.
* 3. Configure the client to send an empty certificate. Expected result 3 is obtained.
* 4. Configure the client and server to support post-handshake extension. Expected result 4 is obtained.
* 5. Perform authentication after the connection is established. Expected result 5 is obtained.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The setting is successful.
* 4. The setting is successful.
* 5. The connection is set up successfully. After receiving the client certificate, the server sends an alert message.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC011()
{
int version = TLS1_3;
int connType = TCP;
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
int32_t serverConfigId = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
void *clientConfig = HLT_TlsNewCtx(version);
ASSERT_TRUE(clientConfig != NULL);
// Apply for and initialize the config file
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(clientCtxConfig != NULL);
ASSERT_TRUE(serverCtxConfig != NULL);
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, version, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
#endif
// Configure the server not to allow the client to send an empty certificate
// Configure the client and server to support post-handshake extension
clientCtxConfig->isSupportClientVerify = true;
clientCtxConfig->isSupportPostHandshakeAuth = true;
serverCtxConfig->isSupportClientVerify = true;
serverCtxConfig->isSupportNoClientCert = false;
serverCtxConfig->isSupportPostHandshakeAuth = true;
// Configure the client to send an empty certificate
HLT_SetCertPath(
clientCtxConfig, "rsa_sha256/ca.der:rsa_sha256/inter.der", "NULL", "NULL", "NULL", "NULL", "NULL");
HLT_SetCertPath(serverCtxConfig,
"rsa_sha256/ca.der:rsa_sha256/inter.der",
"rsa_sha256/inter.der",
"rsa_sha256/server.der",
"rsa_sha256/server.key.der",
"NULL",
"NULL");
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
DataChannelParam channelParam;
channelParam.port = 18889;
channelParam.type = connType;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = connType;
localProcess->connType = connType;
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = connType;
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = connType;
HLT_TlsSetSsl(clientSsl, clientSslConfig);
int ret = HLT_TlsConnect(clientSsl);
ASSERT_EQ(ret, HITLS_SUCCESS);
// Perform authentication after the connection is established
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverSslId) == HITLS_SUCCESS);
;
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
HLT_TlsWrite(clientSsl, (uint8_t *)writeBuf, strlen(writeBuf));
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ret = HLT_RpcTlsRead(remoteProcess, serverSslId, readBuf, READ_BUF_SIZE, &readLen);
// the server sends an alert message.
ASSERT_EQ(ret, HITLS_MSG_HANDLE_NO_PEER_CERTIFIACATE);
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_RpcTlsClose(remoteProcess, serverSslId);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC012
* @spec -
* @title The server allows the client to send an empty certificate. During authentication after handshake,
* the server receives an empty certificate from the client.
* @precon nan
* @brief
* 1. Apply for and initialize the config file. Expected result 1 is obtained.
* 2. Configure the server to allow the client to send an empty certificate. Expected result 2 is obtained.
* 3. Configure the client to send an empty certificate. Expected result 3 is obtained.
* 4. Configure the client and server to support post-handshake extension. Expected result 4 is obtained.
* 5. Perform authentication after the connection is established. Expected result 5 is obtained.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The setting is successful.
* 4. The setting is successful.
* 5. The connection is successfully set up, and the server initiates authentication.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC012()
{
int version = TLS1_3;
int connType = TCP;
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
int32_t serverConfigId = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
void *clientConfig = HLT_TlsNewCtx(version);
ASSERT_TRUE(clientConfig != NULL);
// Apply for and initialize the config file
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(clientCtxConfig != NULL);
ASSERT_TRUE(serverCtxConfig != NULL);
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, version, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
#endif
// Configure the server to allow the client to send an empty certificate.
// Configure the client and server to support post-handshake extension
clientCtxConfig->isSupportClientVerify = true;
clientCtxConfig->isSupportPostHandshakeAuth = true;
serverCtxConfig->isSupportClientVerify = true;
serverCtxConfig->isSupportNoClientCert = true;
serverCtxConfig->isSupportPostHandshakeAuth = true;
// Configure the client to send an empty certificate
HLT_SetCertPath(
clientCtxConfig, "rsa_sha256/ca.der:rsa_sha256/inter.der", "NULL", "NULL", "NULL", "NULL", "NULL");
HLT_SetCertPath(serverCtxConfig,
"rsa_sha256/ca.der:rsa_sha256/inter.der",
"rsa_sha256/inter.der",
"rsa_sha256/server.der",
"rsa_sha256/server.key.der",
"NULL",
"NULL");
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
DataChannelParam channelParam;
channelParam.port = 18889;
channelParam.type = connType;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = connType;
localProcess->connType = connType;
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = connType;
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = connType;
HLT_TlsSetSsl(clientSsl, clientSslConfig);
int ret = HLT_TlsConnect(clientSsl);
ASSERT_EQ(ret, HITLS_SUCCESS);
// Perform authentication after the connection is established
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverSslId) == HITLS_SUCCESS);
;
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
// The connection is successfully set up, and the server initiates authentication.
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
HLT_TlsWrite(clientSsl, (uint8_t *)writeBuf, strlen(writeBuf));
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
HLT_RpcTlsRead(remoteProcess, serverSslId, readBuf, READ_BUF_SIZE, &readLen);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_RpcTlsClose(remoteProcess, serverSslId);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC013
* @spec -
* @title The server does not set the verification failure to continue the handshake. As a result, the server
* verification fails during the post-handshake authentication.
* @precon nan
* @brief
* 1. Apply for and initialize the configuration file. Expected result 1 is obtained.
* 2. Configure the client and server to support post-handshake extension. Expected result 2 is obtained.
* 3. Set the server certificate to the RSA certificate and the client certificate to the ECDSA certificate. Expected
* result 3 is obtained.
* 4. After the connection is established, authentication is performed. Expected result 4 is obtained.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The setting is successful.
* 4. The connection is successfully established, but the server fails to authenticate the certificate.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC013()
{
int version = TLS1_3;
int connType = TCP;
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
int32_t serverConfigId = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
void *clientConfig = HLT_TlsNewCtx(version);
ASSERT_TRUE(clientConfig != NULL);
// Apply for and initialize the configuration file
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(clientCtxConfig != NULL);
ASSERT_TRUE(serverCtxConfig != NULL);
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, version, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
#endif
// Configure the client and server to support post-handshake extension
clientCtxConfig->isSupportClientVerify = true;
clientCtxConfig->isSupportPostHandshakeAuth = true;
clientCtxConfig->isSupportVerifyNone = false;
serverCtxConfig->isSupportClientVerify = true;
serverCtxConfig->isSupportPostHandshakeAuth = true;
serverCtxConfig->isSupportVerifyNone = false;
// Set the server certificate to the RSA certificate and the client certificate to the ECDSA certificate.
HLT_SetCertPath(clientCtxConfig,
"rsa_sha256/ca.der:rsa_sha256/inter.der",
"ecdsa/inter-nist521.der",
"ecdsa/end256-sha256.der",
"ecdsa/end256-sha256.key.der",
"NULL",
"NULL");
HLT_SetCertPath(serverCtxConfig,
"rsa_sha256/ca.der:rsa_sha256/inter.der",
"rsa_sha256/inter.der",
"rsa_sha256/server.der",
"rsa_sha256/server.key.der",
"NULL",
"NULL");
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
DataChannelParam channelParam;
channelParam.port = 18889;
channelParam.type = connType;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = connType;
localProcess->connType = connType;
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = connType;
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = connType;
HLT_TlsSetSsl(clientSsl, clientSslConfig);
int ret = HLT_TlsConnect(clientSsl);
ASSERT_EQ(ret, HITLS_SUCCESS);
// After the connection is established, authentication is performed
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverSslId) == HITLS_SUCCESS);
;
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
HLT_TlsWrite(clientSsl, (uint8_t *)writeBuf, strlen(writeBuf));
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_EQ(
HLT_RpcTlsRead(remoteProcess, serverSslId, readBuf, READ_BUF_SIZE, &readLen), HITLS_CERT_ERR_VERIFY_CERT_CHAIN);
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_RpcTlsClose(remoteProcess, serverSslId);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC014
* @spec -
* @title The server continues the handshake if the verification fails. After the handshake,
* the server continues the handshake if the verification fails.
* @precon nan
* @brief
* 1. Apply for and initialize the configuration file. Expected result 1 is obtained.
* 2. Configure the server not to verify the peer certificate. Expected result 2 is obtained.
* 3. Configure the client and server to support post-handshake extension. Expected result 3 is obtained.
* 4. Set the client server certificate to RSA certificate, and set the client terminal certificate to ECDSA certificate.
* Expected result 4 is obtained.
* 5. After the connection is established, authentication is performed. Expected result 5 is obtained.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The setting is successful.
* 4. The setting is successful.
* 5. The connection is successfully established and the authentication is successful.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC014()
{
int version = TLS1_3;
int connType = TCP;
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
int32_t serverConfigId = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
// Apply for and initialize the configuration file
void *clientConfig = HLT_TlsNewCtx(version);
ASSERT_TRUE(clientConfig != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(clientCtxConfig != NULL);
ASSERT_TRUE(serverCtxConfig != NULL);
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, version, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
#endif
// Configure the server not to verify the peer certificate.
// Configure the client and server to support post-handshake extension
clientCtxConfig->isSupportClientVerify = true;
clientCtxConfig->isSupportPostHandshakeAuth = true;
serverCtxConfig->isSupportClientVerify = true;
serverCtxConfig->isSupportPostHandshakeAuth = true;
serverCtxConfig->isSupportVerifyNone = true;
// Set the client server certificate to RSA certificate, and set the client terminal certificate to ECDSA
// certificate.
HLT_SetCertPath(clientCtxConfig,
"rsa_sha256/ca.der:rsa_sha256/inter.der",
"ecdsa/inter-nist521.der",
"ecdsa/end256-sha256.der",
"ecdsa/end256-sha256.key.der",
"NULL",
"NULL");
HLT_SetCertPath(serverCtxConfig,
"rsa_sha256/ca.der:rsa_sha256/inter.der",
"rsa_sha256/inter.der",
"rsa_sha256/server.der",
"rsa_sha256/server.key.der",
"NULL",
"NULL");
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
DataChannelParam channelParam;
channelParam.port = 18889;
channelParam.type = connType;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = connType;
localProcess->connType = connType;
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = connType;
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = connType;
HLT_TlsSetSsl(clientSsl, clientSslConfig);
int ret = HLT_TlsConnect(clientSsl);
ASSERT_EQ(ret, HITLS_SUCCESS);
// authentication is performed
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverSslId) == HITLS_SUCCESS);
;
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
HLT_TlsWrite(clientSsl, (uint8_t *)writeBuf, strlen(writeBuf));
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
HLT_RpcTlsRead(remoteProcess, serverSslId, readBuf, READ_BUF_SIZE, &readLen);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_EQ(memcmp(writeBuf, readBuf, readLen), 0);
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_RpcTlsClose(remoteProcess, serverSslId);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC015
* @spec -
* @title During the authentication after the handshake on the client, the server is
* disconnected because app messages are mixed in the sent messages.
* @precon nan
* @brief
* 1. Apply for and initialize the configuration file. Expected result 1 is obtained.
* 2. Configure the client and server to support post-handshake extension. Expected result 2 is obtained.
* 3. Establish a connection. The server initiates a handshake for authentication. Expected result 3 is displayed.
* 4. Modify the client to send messages. Enable the client to send an app message before sending the finish message.
* Expected result 4 is obtained.
* 5. Observe the server behavior. Expected result 5 is obtained.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The connection is successfully set up and the server initiates authentication.
* 4. The client sends the message successfully.
* 5. The server sends an alert message to disconnect the connection.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC015()
{
STUB_Init();
FuncStubInfo tmpStubInfo;
int version = TLS1_3;
int connType = TCP;
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
int32_t serverConfigId = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
void *clientConfig = HLT_TlsNewCtx(version);
ASSERT_TRUE(clientConfig != NULL);
// Apply for and initialize the configuration file
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(clientCtxConfig != NULL);
ASSERT_TRUE(serverCtxConfig != NULL);
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, version, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
#endif
// Configure the client and server to support post-handshake extension
clientCtxConfig->isSupportClientVerify = true;
clientCtxConfig->isSupportPostHandshakeAuth = true;
serverCtxConfig->isSupportClientVerify = true;
serverCtxConfig->isSupportPostHandshakeAuth = true;
HLT_SetCertPath(clientCtxConfig,
"rsa_sha256/ca.der:rsa_sha256/inter.der",
"rsa_sha256/inter.der",
"rsa_sha256/server.der",
"rsa_sha256/server.key.der",
"NULL",
"NULL");
HLT_SetCertPath(serverCtxConfig,
"rsa_sha256/ca.der:rsa_sha256/inter.der",
"rsa_sha256/inter.der",
"rsa_sha256/server.der",
"rsa_sha256/server.key.der",
"NULL",
"NULL");
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
DataChannelParam channelParam;
channelParam.port = 18889;
channelParam.type = connType;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = connType;
localProcess->connType = connType;
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = connType;
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = connType;
HLT_TlsSetSsl(clientSsl, clientSslConfig);
int ret = HLT_TlsConnect(clientSsl);
ASSERT_EQ(ret, HITLS_SUCCESS);
// he server initiates a handshake for authentication
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverSslId) == HITLS_SUCCESS);
;
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
// Enable the client to send an app message before sending the finish message.
RecWrapper wrapper = {TRY_SEND_FINISH, REC_TYPE_HANDSHAKE, false, &tmpStubInfo, Test_FinishToAPP};
RegisterWrapper(wrapper);
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
HLT_TlsWrite(clientSsl, (uint8_t *)writeBuf, strlen(writeBuf));
STUB_Reset(&tmpStubInfo);
HLT_TlsWrite(clientSsl, (uint8_t *)writeBuf, strlen(writeBuf));
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_EQ(HLT_RpcTlsRead(remoteProcess, serverSslId, readBuf, READ_BUF_SIZE, &readLen),
HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_RpcTlsClose(remoteProcess, serverSslId);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
EXIT:
ClearWrapper();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC016
* @spec -
* @title During authentication after handshake, the server receives multiple app messages after
* sending the certificate request, and the processing is normal.
* @precon nan
* @brief
* 1. Apply for and initialize the configuration file. Expected result 1 is obtained.
* 2. Configure the client and server to support post-handshake extension. Expected result 2 is obtained.
* 3. Establish a connection. The server initiates a handshake for authentication. Expected result 3 is obtained.
* 4. Send an app message to the server. After the server processes the message, check the server status.
* Expected result 4 is obtained.
* 5. Send an app message to the server. After the server processes the message, check the server status.
* Expected result 5 is obtained.
* 6. Continue the authentication. Expected result 6 is obtained.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The connection is set up successfully, and the server sends a certificate request message.
* 4. The server is in try_recv_certifiacates state.
* 5. The server is in try_recv_certifiacates state.
* 6. The authentication is successful.
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC016()
{
int version = TLS1_3;
int connType = TCP;
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
int32_t serverConfigId = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
void *clientConfig = HLT_TlsNewCtx(version);
ASSERT_TRUE(clientConfig != NULL);
// Apply for and initialize the configuration file
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(clientCtxConfig != NULL);
ASSERT_TRUE(serverCtxConfig != NULL);
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, version, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
#endif
// Configure the client and server to support post-handshake extension.
clientCtxConfig->isSupportClientVerify = true;
clientCtxConfig->isSupportPostHandshakeAuth = true;
serverCtxConfig->isSupportClientVerify = true;
serverCtxConfig->isSupportPostHandshakeAuth = true;
HLT_SetCertPath(clientCtxConfig,
"rsa_sha256/ca.der:rsa_sha256/inter.der",
"rsa_sha256/inter.der",
"rsa_sha256/server.der",
"rsa_sha256/server.key.der",
"NULL",
"NULL");
HLT_SetCertPath(serverCtxConfig,
"rsa_sha256/ca.der:rsa_sha256/inter.der",
"rsa_sha256/inter.der",
"rsa_sha256/server.der",
"rsa_sha256/server.key.der",
"NULL",
"NULL");
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
DataChannelParam channelParam;
channelParam.port = 18889;
channelParam.type = connType;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = connType;
localProcess->connType = connType;
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = connType;
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = connType;
HLT_TlsSetSsl(clientSsl, clientSslConfig);
int ret = HLT_TlsConnect(clientSsl);
ASSERT_EQ(ret, HITLS_SUCCESS);
// The server initiates a handshake for authentication
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverSslId) == HITLS_SUCCESS);
;
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
// Send an app message to the server
HLT_TlsWrite(clientSsl, (uint8_t *)writeBuf, strlen(writeBuf));
// Send an app message to the server
HLT_TlsWrite(clientSsl, (uint8_t *)writeBuf, strlen(writeBuf));
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
// The authentication is successful.
HLT_TlsWrite(clientSsl, (uint8_t *)writeBuf, strlen(writeBuf));
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
HLT_RpcTlsRead(remoteProcess, serverSslId, readBuf, READ_BUF_SIZE, &readLen);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_RpcTlsClose(remoteProcess, serverSslId);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC017
* @spec -
* @title During post-handshake authentication, the server sends the app message after sending the certificate request
* message.
* @precon nan
* @brief
* 1. Apply for and initialize the configuration file. Expected result 1 is obtained.
* 2. Configure the client and server to support post-handshake extension. Expected result 2 is obtained.
* 3. Establish a connection. The server initiates a handshake for authentication. Expected result 3 is displayed.
* 4. The server sends an app message. Expected result 4 is obtained.
* 5. Send an app message from the server. Expected result 5 is obtained.
* 6. Continue the authentication. Expected result 6 is obtained.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The connection is set up successfully, and the server sends a certificate request message.
* 4. The message is sent successfully.
* 5. The message is sent successfully.
* 6. The authentication is successful.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_TLS_TLS13_RFC8446_CONSISTENCY_POSTHANDSHAKE_FUNC_TC017()
{
int version = TLS1_3;
int connType = TCP;
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
int32_t serverConfigId = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
void *clientConfig = HLT_TlsNewCtx(version);
ASSERT_TRUE(clientConfig != NULL);
// Apply for and initialize the configuration file
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(clientCtxConfig != NULL);
ASSERT_TRUE(serverCtxConfig != NULL);
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, version, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
#endif
// Configure the client and server to support post-handshake extension.
clientCtxConfig->isSupportClientVerify = true;
clientCtxConfig->isSupportPostHandshakeAuth = true;
serverCtxConfig->isSupportClientVerify = true;
serverCtxConfig->isSupportPostHandshakeAuth = true;
HLT_SetCertPath(clientCtxConfig,
"rsa_sha256/ca.der:rsa_sha256/inter.der",
"rsa_sha256/inter.der",
"rsa_sha256/server.der",
"rsa_sha256/server.key.der",
"NULL",
"NULL");
HLT_SetCertPath(serverCtxConfig,
"rsa_sha256/ca.der:rsa_sha256/inter.der",
"rsa_sha256/inter.der",
"rsa_sha256/server.der",
"rsa_sha256/server.key.der",
"NULL",
"NULL");
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
DataChannelParam channelParam;
channelParam.port = 18889;
channelParam.type = connType;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = connType;
localProcess->connType = connType;
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = connType;
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = connType;
HLT_TlsSetSsl(clientSsl, clientSslConfig);
int ret = HLT_TlsConnect(clientSsl);
ASSERT_EQ(ret, HITLS_SUCCESS);
// The server initiates a handshake for authentication
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverSslId) == HITLS_SUCCESS);
;
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
const char *writeBuf = "Hello world";
// The server sends an app message
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
// The server sends an app message
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
// Continue the authentication.
HLT_TlsWrite(clientSsl, (uint8_t *)writeBuf, strlen(writeBuf));
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
HLT_RpcTlsRead(remoteProcess, serverSslId, readBuf, READ_BUF_SIZE, &readLen);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_RpcTlsClose(remoteProcess, serverSslId);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/consistency/tls13/test_suite_sdv_hlt_tls13_consistency_rfc8446_pha.c
|
C
|
unknown
| 75,885
|
/*
* 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 <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
#include <stddef.h>
#include <unistd.h>
#include "securec.h"
#include "bsl_sal.h"
#include "hitls.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "hitls_cert_reg.h"
#include "hitls_crypt_type.h"
#include "tls.h"
#include "hs.h"
#include "hs_ctx.h"
#include "hs_state_recv.h"
#include "conn_init.h"
#include "app.h"
#include "record.h"
#include "rec_conn.h"
#include "session.h"
#include "recv_process.h"
#include "stub_replace.h"
#include "frame_tls.h"
#include "frame_msg.h"
#include "simulate_io.h"
#include "parser_frame_msg.h"
#include "pack_frame_msg.h"
#include "frame_io.h"
#include "frame_link.h"
#include "cert.h"
#include "cert_mgr.h"
#include "hs_extensions.h"
#include "hlt_type.h"
#include "hlt.h"
#include "sctp_channel.h"
#include "logger.h"
#include "stub_crypt.h"
#define SIGNATURE_ALGORITHMS 0x04, 0x03 /* Fields added to the SERVER_HELLOW message */
#define READ_BUF_SIZE (18 * 1024) /* Maximum length of the read message buffer */
#define TEMP_DATA_LEN 2048 /* Length of a single message */
#define ALERT_BODY_LEN 2u /* Alert data length */
typedef struct {
HITLS_Config *config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_HandshakeState state;
bool isClient;
bool isSupportExtendMasterSecret;
bool isSupportClientVerify;
bool isSupportNoClientCert;
bool isServerExtendMasterSecret;
bool isSupportRenegotiation; /* Renegotiation support flag */
bool needStopBeforeRecvCCS; /* CCS test, so that the TRY_RECV_FINISH stops before the CCS message is received */
} HandshakeTestInfo;
int32_t StatusPark(HandshakeTestInfo *testInfo)
{
/** Construct connection */
testInfo->client = FRAME_CreateLink(testInfo->config, BSL_UIO_TCP);
if (testInfo->client == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
testInfo->server = FRAME_CreateLink(testInfo->config, BSL_UIO_TCP);
if (testInfo->server == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
/* Perform the CCS test so that the TRY_RECV_FINISH is stopped before the CCS message is received.
* The default value is False, which does not affect the original test.
*/
testInfo->client->needStopBeforeRecvCCS = testInfo->isClient ? testInfo->needStopBeforeRecvCCS : false;
testInfo->server->needStopBeforeRecvCCS = testInfo->isClient ? false : testInfo->needStopBeforeRecvCCS;
/** Establish a connection and stop in a certain state. */
if (FRAME_CreateConnection(testInfo->client, testInfo->server, testInfo->isClient, testInfo->state) !=
HITLS_SUCCESS) {
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
int32_t DefaultCfgStatusPark(HandshakeTestInfo *testInfo)
{
FRAME_Init();
/** Construct configuration. */
testInfo->config = HITLS_CFG_NewTLS12Config();
if (testInfo->config == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
HITLS_CFG_SetCheckKeyUsage(testInfo->config, false);
testInfo->config->isSupportExtendMasterSecret = testInfo->isSupportExtendMasterSecret;
testInfo->config->isSupportClientVerify = testInfo->isSupportClientVerify;
testInfo->config->isSupportNoClientCert = testInfo->isSupportNoClientCert;
testInfo->config->isSupportRenegotiation = testInfo->isSupportRenegotiation;
return StatusPark(testInfo);
}
int32_t DefaultCfgStatusParkWithSuite(HandshakeTestInfo *testInfo)
{
FRAME_Init();
/** Construct configuration. */
testInfo->config = HITLS_CFG_NewTLS12Config();
if (testInfo->config == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
HITLS_CFG_SetCheckKeyUsage(testInfo->config, false);
uint16_t cipherSuits[] = {HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256};
HITLS_CFG_SetCipherSuites(testInfo->config, cipherSuits, sizeof(cipherSuits) / sizeof(uint16_t));
testInfo->config->isSupportExtendMasterSecret = testInfo->isSupportExtendMasterSecret;
testInfo->config->isSupportClientVerify = testInfo->isSupportClientVerify;
testInfo->config->isSupportNoClientCert = testInfo->isSupportNoClientCert;
return StatusPark(testInfo);
}
#define TEST_CLIENT_SEND_FAIL 1
uint32_t g_uiPort = 8889;
void TestSetCertPath(HLT_Ctx_Config *ctxConfig, char *SignatureType)
{
if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA1", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA1")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA1_EE_PATH, RSA_SHA1_PRIV_PATH, "NULL", "NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA256", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA256")) ==
0 ||
strncmp(SignatureType,
"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256",
strlen("CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA256_EE_PATH3, RSA_SHA256_PRIV_PATH3, "NULL", "NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA384", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA384")) ==
0 ||
strncmp(SignatureType,
"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384",
strlen("CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA384_EE_PATH, RSA_SHA384_PRIV_PATH, "NULL", "NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA512", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA512")) ==
0 ||
strncmp(SignatureType,
"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512",
strlen("CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA512_EE_PATH, RSA_SHA512_PRIV_PATH, "NULL", "NULL");
} else if (strncmp(SignatureType,
"CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256",
strlen("CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA_CA_PATH,
ECDSA_SHA_CHAIN_PATH,
ECDSA_SHA256_EE_PATH,
ECDSA_SHA256_PRIV_PATH,
"NULL",
"NULL");
} else if (strncmp(SignatureType,
"CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384",
strlen("CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA_CA_PATH,
ECDSA_SHA_CHAIN_PATH,
ECDSA_SHA384_EE_PATH,
ECDSA_SHA384_PRIV_PATH,
"NULL",
"NULL");
} else if (strncmp(SignatureType,
"CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512",
strlen("CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA_CA_PATH,
ECDSA_SHA_CHAIN_PATH,
ECDSA_SHA512_EE_PATH,
ECDSA_SHA512_PRIV_PATH,
"NULL",
"NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_ECDSA_SHA1", strlen("CERT_SIG_SCHEME_ECDSA_SHA1")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA1_CA_PATH,
ECDSA_SHA1_CHAIN_PATH,
ECDSA_SHA1_EE_PATH,
ECDSA_SHA1_PRIV_PATH,
"NULL",
"NULL");
}
}
void SetFrameType(FRAME_Type *frametype, uint16_t versionType, REC_Type recordType, HS_MsgType handshakeType,
HITLS_KeyExchAlgo keyExType)
{
frametype->versionType = versionType;
frametype->recordType = recordType;
frametype->handshakeType = handshakeType;
frametype->keyExType = keyExType;
frametype->transportType = BSL_UIO_TCP;
}
FieldState *GetDataAddress(FRAME_Msg *data, void *member)
{
return (FieldState *)((size_t)data + (size_t)member);
}
void Test_MisClientHelloExtension(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len, uint32_t bufSize, void *user)
{
(void)ctx;
(void)bufSize;
(void)user;
FRAME_Type frameType = {0};
frameType.versionType = HITLS_VERSION_TLS13;
FRAME_Msg frameMsg = {0};
frameMsg.recType.data = REC_TYPE_HANDSHAKE;
frameMsg.length.data = *len;
frameMsg.recVersion.data = HITLS_VERSION_TLS13;
uint32_t parseLen = 0;
FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
ASSERT_EQ(parseLen, *len);
ASSERT_EQ(frameMsg.body.hsMsg.type.data, CLIENT_HELLO);
FieldState *extensionState = GetDataAddress(&frameMsg, user);
*extensionState = MISSING_FIELD;
memset_s(data, bufSize, 0, bufSize);
FRAME_PackRecordBody(&frameType, &frameMsg, data, bufSize, len);
ASSERT_NE(parseLen, *len);
EXIT:
FRAME_CleanMsg(&frameType, &frameMsg);
return;
}
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/consistency/tls13/test_suite_tls13_consistency_rfc8446.base.c
|
C
|
unknown
| 9,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.
*/
/* BEGIN_HEADER */
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <errno.h>
#include "securec.h"
#include "bsl_sal.h"
#include "frame_tls.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_errno.h"
#include "bsl_uio.h"
#include "frame_io.h"
#include "uio_abstraction.h"
#include "tls.h"
#include "tls_config.h"
#include "hitls_type.h"
#include "hitls_func.h"
#include "hitls.h"
#include "pack.h"
#include "bsl_err.h"
#include "bsl_bytes.h"
#include "custom_extensions.h"
#include "frame_tls.h"
#include "alert.h"
#include "frame_link.h"
#define CUSTOM_EXTENTIONS_TYPE_1 0x00001
#define CUSTOM_EXTENTIONS_TYPE_2 0x00002
// Simple add_cb function, allocates buffer with 1 byte length and 1 byte data
int SimpleAddCb(const struct TlsCtx *ctx, uint16_t extType, uint32_t context, uint8_t **out, uint32_t *outLen,
HITLS_CERT_X509 *cert, uint32_t certId, uint32_t *alert, void *addArg)
{
(void)ctx;
(void)extType;
(void)context;
(void)cert;
(void)certId;
(void)alert;
(void)addArg;
*out = malloc(sizeof(uint16_t));
if (*out == NULL) {
return -1;
}
uint32_t bufOffset = 0;
(*out)[bufOffset] = 0xAA;
bufOffset++;
*outLen = bufOffset;
return HITLS_ADD_CUSTOM_EXTENSION_RET_PACK;
}
// Simple free_cb function, frees the allocated data
void SimpleFreeCb(const struct TlsCtx *ctx, uint16_t extType, uint32_t context, uint8_t *out, void *addArg)
{
(void)ctx;
(void)extType;
(void)context;
(void)addArg;
BSL_SAL_Free(out);
}
// Simple parse_cb function, reads the length and data, checks the data
int SimpleParseCb(const struct TlsCtx *ctx, uint16_t extType, uint32_t context, const uint8_t **in, uint32_t *inLen,
HITLS_CERT_X509 *cert, uint32_t certId, uint32_t *alert, void *parseArg)
{
(void)ctx;
(void)extType;
(void)context;
(void)cert;
(void)certId;
(void)alert;
(void)parseArg;
if (*inLen <= 0) {
return 0;
}
// Pass the data pointer to BSL_SAL_Dump
uint8_t *dumpedData = BSL_SAL_Dump(*in, *inLen);
if (dumpedData == NULL) {
return 1; // Processing failed
}
// Check the first byte of the returned data
if (dumpedData[0] != 0xAA) {
BSL_SAL_Free(dumpedData); // Free memory
return 1;
}
BSL_SAL_Free(dumpedData); // Free memory
return 0;
}
/* END_HEADER */
/** @
* @test SDV_TLS_PACK_CUSTOM_EXTENSIONS_API_TC001
* @title Test the single extension packing function of the PackCustomExtensions interface
* @precon None
* @brief
* 1. Initialize the TLS context and configure a single custom extension (no callback). Expected result 1.
* 2. Call the PackCustomExtensions interface and verify the packing result. Expected result 2.
* @expect
* 1. Initialization successful.
* 2. Returns HITLS_SUCCESS, packing length is 0 (no data without callback).
@ */
/* BEGIN_CASE */
void SDV_TLS_PACK_CUSTOM_EXTENSIONS_API_TC001(void)
{
FRAME_Init(); // Initialize the test framework
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_NE(tlsConfig, NULL);
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
ASSERT_NE(ctx, NULL);
uint8_t buf[1024] = {0};
uint32_t bufLen = sizeof(buf);
uint32_t len = 0;
uint16_t extType = CUSTOM_EXTENTIONS_TYPE_1;
uint32_t context = 1;
// Configure a single custom extension
CustomExtMethods exts = {0};
CustomExtMethod meth = {0};
meth.extType = extType;
meth.context = context;
meth.addCb = NULL; // No callback
meth.freeCb = NULL; // No callback
exts.meths = &meth;
exts.methsCount = 1;
ctx->config.tlsConfig.customExts = &exts;
uint32_t bufOffset = 0;
uint8_t *buffAddr = &buf[0];
PackPacket pkt = {.buf = &buffAddr, .bufLen = &bufLen, .bufOffset = &bufOffset};
// Call the interface under test
// Verify the return value is success
ASSERT_EQ(PackCustomExtensions(ctx, &pkt, context, NULL, 0), HITLS_SUCCESS);
ctx->config.tlsConfig.customExts = NULL;
ASSERT_EQ(len, 0); // No data packed without add_cb
EXIT:
HITLS_Free(ctx);
HITLS_CFG_FreeConfig(tlsConfig);
return;
}
/* END_CASE */
/** @
* @test SDV_TLS_PARSE_CUSTOM_EXTENSIONS_API_TC001
* @title Test the single extension parsing function of the ParseCustomExtensions interface
* @precon None
* @brief
* 1. Initialize the TLS context and configure a single custom extension (no callback). Expected result 1.
* 2. Prepare a buffer containing a single extension and call the ParseCustomExtensions interface. Expected result 2.
* @expect
* 1. Initialization successful.
* 2. Returns HITLS_SUCCESS, buffer offset is updated correctly.
@ */
/* BEGIN_CASE */
void SDV_TLS_PARSE_CUSTOM_EXTENSIONS_API_TC001(void)
{
FRAME_Init(); // Initialize the test framework
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_NE(tlsConfig, NULL);
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
ASSERT_NE(ctx, NULL);
uint8_t buf[1024] = {0xAA}; // ext_type=1, len=0
uint32_t bufOffset = 0;
uint16_t extType = CUSTOM_EXTENTIONS_TYPE_1;
uint32_t context = 1;
uint32_t extLen = 1;
// Configure a single custom extension
CustomExtMethods exts = {0};
CustomExtMethod meth = {0};
meth.extType = extType;
meth.parseCb = NULL; // No callback
exts.meths = &meth;
exts.methsCount = 1;
ctx->config.tlsConfig.customExts = &exts;
// Call the interface under test
int32_t ret = ParseCustomExtensions(ctx, buf + bufOffset, extType, extLen, context, NULL, 0);
ctx->config.tlsConfig.customExts = NULL;
ASSERT_EQ(ret, HITLS_SUCCESS); // Verify the return value is success
// Note: Current implementation doesn't update bufOffset without parse_cb, adjust expectation if needed
EXIT:
HITLS_Free(ctx);
HITLS_CFG_FreeConfig(tlsConfig);
return;
}
/* END_CASE */
/** @
* @test SDV_TLS_PACK_CUSTOM_EXTENSIONS_MULTIPLE_API_TC001
* @title Test the multiple extensions packing function of the PackCustomExtensions interface
* @precon None
* @brief
* 1. Initialize the TLS context and configure two custom extensions. Expected result 1.
* 2. Call the PackCustomExtensions interface and verify the packing result. Expected result 2.
* @expect
* 1. Initialization successful.
* 2. Returns HITLS_SUCCESS, packing length is 0 (no data without callbacks).
@ */
/* BEGIN_CASE */
void SDV_TLS_PACK_CUSTOM_EXTENSIONS_MULTIPLE_API_TC001(void)
{
FRAME_Init(); // Initialize the test framework
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_NE(tlsConfig, NULL);
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
ASSERT_NE(ctx, NULL);
uint8_t buf[1024] = {0};
uint32_t bufLen = sizeof(buf);
uint32_t len = 0;
uint32_t context = 1;
uint32_t methsCount = 1;
// Configure multiple custom extensions
CustomExtMethods exts = {0};
CustomExtMethod meths[2] = {{0}, {0}};
meths[0].extType = CUSTOM_EXTENTIONS_TYPE_1;
meths[0].context = context;
meths[0].addCb = NULL; // No callback
meths[0].freeCb = NULL;
meths[1].extType = CUSTOM_EXTENTIONS_TYPE_2;
meths[1].context = context;
meths[1].addCb = NULL; // No callback
meths[1].freeCb = NULL;
exts.meths = meths;
exts.methsCount = methsCount;
ctx->config.tlsConfig.customExts = &exts;
uint32_t bufOffset = 0;
uint8_t *buffAddr = &buf[0];
PackPacket pkt = {.buf = &buffAddr, .bufLen = &bufLen, .bufOffset = &bufOffset};
// Call the interface under test
int32_t ret = PackCustomExtensions(ctx, &pkt, context, NULL, 0);
ctx->config.tlsConfig.customExts = NULL;
ASSERT_EQ(ret, HITLS_SUCCESS); // Verify the return value is success
ASSERT_EQ(len, 0); // No data packed without add_cb
EXIT:
HITLS_Free(ctx);
HITLS_CFG_FreeConfig(tlsConfig);
return;
}
/* END_CASE */
/** @
* @test SDV_TLS_PACK_CUSTOM_EXTENSIONS_EMPTY_API_TC001
* @title Test the behavior of the PackCustomExtensions interface when there are no extensions
* @precon None
* @brief
* 1. Initialize the TLS context without configuring any custom extensions. Expected result 1.
* 2. Call the PackCustomExtensions interface and verify the packing result. Expected result 2.
* @expect
* 1. Initialization successful.
* 2. Returns HITLS_SUCCESS, packing length is 0.
@ */
/* BEGIN_CASE */
void SDV_TLS_PACK_CUSTOM_EXTENSIONS_EMPTY_API_TC001(void)
{
FRAME_Init(); // Initialize the test framework
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_NE(tlsConfig, NULL);
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
ASSERT_NE(ctx, NULL);
uint8_t buf[1024] = {0};
uint32_t bufLen = sizeof(buf);
uint32_t len = 0;
uint32_t context = 1;
ctx->config.tlsConfig.customExts = NULL; // No extensions
uint32_t bufOffset = 0;
uint8_t *buffAddr = &buf[0];
PackPacket pkt = {.buf = &buffAddr, .bufLen = &bufLen, .bufOffset = &bufOffset};
// Call the interface under test
int32_t ret = PackCustomExtensions(ctx, &pkt, context, NULL, 0);
ASSERT_EQ(ret, HITLS_SUCCESS); // Verify the return value is success
ASSERT_EQ(len, 0); // Verify the packing length is 0
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
return;
}
/* END_CASE */
/** @
* @test SDV_TLS_PACK_CUSTOM_EXTENSIONS_CALLBACK_API_TC001
* @title Test the PackCustomExtensions interface with callbacks
* @precon None
* @brief
* 1. Initialize the TLS context and configure a single custom extension with add_cb and free_cb. Expected result 1.
* 2. Call the PackCustomExtensions interface and verify the packing result. Expected result 2.
* @expect
* 1. Initialization successful.
* 2. Returns HITLS_SUCCESS, packing length is 3 (ext_type + data), buffer content is correct.
@ */
/* BEGIN_CASE */
void SDV_TLS_PACK_CUSTOM_EXTENSIONS_CALLBACK_API_TC001(void)
{
FRAME_Init(); // Initialize the test framework
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
ASSERT_NE(ctx, NULL);
uint8_t buf[1024] = {0};
uint32_t bufLen = sizeof(buf);
uint32_t len = 0;
uint16_t extType = CUSTOM_EXTENTIONS_TYPE_1;
uint32_t context = 1;
uint32_t dataLen = 1;
// Configure a single custom extension with callbacks
CustomExtMethods exts = {0};
CustomExtMethod meth = {0};
meth.extType = extType;
meth.context = context;
meth.addCb = SimpleAddCb;
meth.freeCb = SimpleFreeCb;
exts.meths = &meth;
exts.methsCount = 1;
ctx->config.tlsConfig.customExts = &exts;
uint32_t bufOffset = 0;
uint8_t *buffAddr = &buf[0];
PackPacket pkt = {.buf = &buffAddr, .bufLen = &bufLen, .bufOffset = &bufOffset};
// Call the interface under test
int32_t ret = PackCustomExtensions(ctx, &pkt, context, NULL, 0);
ctx->config.tlsConfig.customExts = NULL;
ASSERT_EQ(ret, HITLS_SUCCESS); // Verify the return value is success
len += bufOffset;
ASSERT_EQ(len, sizeof(uint16_t) + sizeof(uint16_t) + dataLen); // ext_type (2 byte) + len (2 byte) + data (1 byte)
// Verify the extension type
uint16_t packedType = BSL_ByteToUint16(buf);
ASSERT_EQ(packedType, extType);
uint16_t packedLen = BSL_ByteToUint16(&buf[sizeof(uint16_t)]);
ASSERT_EQ(packedLen, 1); // Verify the len
ASSERT_EQ(buf[len - 1], 0xAA); // Verify the data
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
return;
}
/* END_CASE */
/** @
* @test SDV_TLS_PARSE_CUSTOM_EXTENSIONS_CALLBACK_API_TC001
* @title Test the ParseCustomExtensions interface with parse_cb
* @precon None
* @brief
* 1. Initialize the TLS context and configure a single custom extension with parse_cb. Expected result 1.
* 2. Prepare a buffer containing a single extension and call the ParseCustomExtensions interface. Expected result 2.
* @expect
* 1. Initialization successful.
* 2. Returns HITLS_SUCCESS, buffer offset is updated correctly.
@ */
/* BEGIN_CASE */
void SDV_TLS_PARSE_CUSTOM_EXTENSIONS_CALLBACK_API_TC001(void)
{
FRAME_Init(); // Initialize the test framework
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_NE(tlsConfig, NULL);
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
ASSERT_NE(ctx, NULL);
uint8_t buf[1024] = {0xAA}; // ext_type=1 (big-endian), len=1, data=0xAA
uint32_t bufOffset = 0;
uint16_t extType = CUSTOM_EXTENTIONS_TYPE_1;
uint32_t context = 1;
uint32_t extLen = 1;
// Configure a single custom extension with parse callback
CustomExtMethods exts = {0};
CustomExtMethod meth = {0};
meth.extType = extType;
meth.context = context;
meth.parseCb = SimpleParseCb;
exts.meths = &meth;
exts.methsCount = 1;
ctx->config.tlsConfig.customExts = &exts;
// Call the interface under test
int32_t ret = ParseCustomExtensions(ctx, buf + bufOffset, extType, extLen, context, NULL, 0);
ctx->config.tlsConfig.customExts = NULL;
ASSERT_EQ(ret, HITLS_SUCCESS); // Verify the return value is success
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
return;
}
/* END_CASE */
/** @
* @test SDV_TLS_SSLCTX_ADD_CUSTOM_EXTENSION_API_TC002
* @title Test the custom extension addition functionality of the HITLS_AddCustomExtension function
* @precon None
* @brief
* 1. Initialize the TLS context and add a valid custom extension, verify if the addition is successful.
* Expected result 1.
* 2. Attempt to add a duplicate custom extension, verify if the function rejects the duplicate addition.
* Expected result 2.
* 3. Call the function with invalid parameters (add_cb is NULL, free_cb is not NULL), verify if the function correctly
* handles the error. Expected result 3.
* @expect
* 1. Returns HITLS_SUCCESS, the custom extension is correctly added to the context.
* 2. Returns 0, the number of extensions does not increase.
* 3. Returns 0, the number of extensions does not increase.
@ */
/* BEGIN_CASE */
void SDV_HITLS_ADD_CUSTOM_EXTENSION_API_TC001(void)
{
FRAME_Init(); // Initialize the test framework
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS13Config();
ASSERT_NE(tlsConfig, NULL);
uint16_t extType = CUSTOM_EXTENTIONS_TYPE_1;
uint16_t invalidExtType = CUSTOM_EXTENTIONS_TYPE_2;
uint32_t context = 1;
HITLS_AddCustomExtCallback addCb = SimpleAddCb;
HITLS_FreeCustomExtCallback freeCb = SimpleFreeCb;
void *addArg = NULL;
HITLS_ParseCustomExtCallback parseCb = SimpleParseCb;
void *parseArg = NULL;
// Test normal case: Add a custom extension
HITLS_CustomExtParams params = {
.extType = extType,
.context = context,
.addCb = addCb,
.freeCb = freeCb,
.addArg = addArg,
.parseCb = parseCb,
.parseArg = parseArg
};
uint32_t ret = HITLS_CFG_AddCustomExtension(tlsConfig, ¶ms);
ASSERT_EQ(ret, HITLS_SUCCESS); // Verify the return value is success
ASSERT_EQ(tlsConfig->customExts->methsCount, 1); // Verify the number of extensions is 1
CustomExtMethod *meth = &tlsConfig->customExts->meths[0];
ASSERT_EQ(meth->extType, extType); // Verify the extension type
ASSERT_EQ(meth->context, context); // Verify the context
ASSERT_EQ(meth->addCb, addCb); // Verify add_cb
ASSERT_EQ(meth->freeCb, freeCb); // Verify free_cb
ASSERT_EQ(meth->addArg, addArg); // Verify add_arg
ASSERT_EQ(meth->parseCb, parseCb); // Verify parse_cb
ASSERT_EQ(meth->parseArg, parseArg); // Verify parse_arg
// Test boundary case: Attempt to add a duplicate extension
HITLS_CustomExtParams duplicateParams = {
.extType = extType,
.context = context,
.addCb = addCb,
.freeCb = freeCb,
.addArg = addArg,
.parseCb = parseCb,
.parseArg = parseArg
};
ret = HITLS_CFG_AddCustomExtension(tlsConfig, &duplicateParams);
ASSERT_EQ(ret, HITLS_CONFIG_DUP_CUSTOM_EXT); // Verify the return value is failure
ASSERT_EQ(tlsConfig->customExts->methsCount, 1); // Verify the number of extensions does not increase
// Test invalid parameters: add_cb is NULL, free_cb is not NULL
HITLS_CustomExtParams invalidParams = {
.extType = invalidExtType,
.context = context,
.addCb = NULL,
.freeCb = freeCb,
.addArg = addArg,
.parseCb = parseCb,
.parseArg = parseArg
};
ret = HITLS_CFG_AddCustomExtension(tlsConfig, &invalidParams);
ASSERT_EQ(ret, HITLS_INVALID_INPUT); // Verify the return value is failure
ASSERT_EQ(tlsConfig->customExts->methsCount, 1); // Verify the number of extensions does not increase
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
return;
}
/* END_CASE */
typedef struct {
uint32_t parsedContext[10];
uint32_t parsedContextCount;
uint32_t addedContext[10];
uint32_t addedContextCount;
uint32_t alertContext;
uint32_t alert;
bool addEmptyExt;
bool parseEmptyExt;
bool passExt;
} CustomExtensionArg;
int CustomExtensionAddCb(const struct TlsCtx *ctx, uint16_t extType, uint32_t context, uint8_t **out, uint32_t *outLen,
HITLS_CERT_X509 *cert, uint32_t certId, uint32_t *alert, void *addArg)
{
(void)ctx;
(void)extType;
(void)cert;
(void)certId;
(void)alert;
CustomExtensionArg *arg = (CustomExtensionArg *)addArg;
arg->addedContext[arg->addedContextCount++] = context;
if ((arg->alertContext & context) != 0) {
*alert = arg->alert;
return -1;
}
if (arg->passExt) {
*out = NULL;
*outLen = 0;
return HITLS_ADD_CUSTOM_EXTENSION_RET_PASS;
}
if (arg->addEmptyExt) {
*out = NULL;
*outLen = 0;
return HITLS_ADD_CUSTOM_EXTENSION_RET_PACK;
}
*out = malloc(1);
if (*out == NULL) {
return -1;
}
*outLen = 1;
(*out)[0] = 0xAA;
return HITLS_ADD_CUSTOM_EXTENSION_RET_PACK;
}
// Simple free_cb function, frees the allocated data
void CustomExtensionFreeCb(const struct TlsCtx *ctx, uint16_t extType, uint32_t context, uint8_t *out, void *addArg)
{
(void)ctx;
(void)extType;
(void)context;
(void)addArg;
BSL_SAL_Free(out);
}
// Simple parse_cb function, reads the length and data, checks the data
int CustomExtensionParseCb(const struct TlsCtx *ctx, uint16_t extType, uint32_t context, const uint8_t **in, uint32_t *inLen,
HITLS_CERT_X509 *cert, uint32_t certId, uint32_t *alert, void *parseArg)
{
(void)ctx;
(void)extType;
(void)context;
(void)cert;
(void)certId;
(void)alert;
CustomExtensionArg *arg = (CustomExtensionArg *)parseArg;
arg->parsedContext[arg->parsedContextCount++] = context;
if ((arg->alertContext & context) != 0) {
*alert = arg->alert;
return -1;
}
if (arg->parseEmptyExt) {
if (*inLen > 0) {
return -1;
}
return 0;
}
if (arg->passExt) {
return -1;
}
if (*inLen != 1 || (*in)[0] != 0xAA) {
return -1;
}
return 0;
}
/**
* @test SDV_HITLS_CUSTOM_EXTENSION_FUNCTION_TC001
* @title Basic Functionality Test for Custom Extensions
*/
/* BEGIN_CASE */
void SDV_HITLS_CUSTOM_EXTENSION_FUNCTION_TC001(void)
{
FRAME_Init(); // Initialize the test framework
HITLS_Config *clientConfig = HITLS_CFG_NewTLS13Config();
HITLS_Config *serverConfig = HITLS_CFG_NewTLS13Config();
HITLS_CFG_SetClientVerifySupport(serverConfig, true);
CustomExtensionArg serverArg = {0};
CustomExtensionArg clientArg = {0};
HITLS_CustomExtParams params = {
.extType = CUSTOM_EXTENTIONS_TYPE_2,
.context = HITLS_EX_TYPE_CLIENT_HELLO | HITLS_EX_TYPE_TLS1_3_SERVER_HELLO | HITLS_EX_TYPE_ENCRYPTED_EXTENSIONS | HITLS_EX_TYPE_TLS1_3_CERTIFICATE | HITLS_EX_TYPE_TLS1_3_CERTIFICATE_REQUEST | HITLS_EX_TYPE_TLS1_3_NEW_SESSION_TICKET,
.addCb = CustomExtensionAddCb,
.freeCb = CustomExtensionFreeCb,
.addArg = &clientArg,
.parseCb = CustomExtensionParseCb,
.parseArg = &clientArg
};
HITLS_CFG_AddCustomExtension(clientConfig, ¶ms);
params.addArg = &serverArg;
params.parseArg = &serverArg;
HITLS_CFG_AddCustomExtension(serverConfig, ¶ms);
FRAME_LinkObj *client = FRAME_CreateLink(clientConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(serverConfig, BSL_UIO_TCP);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
ASSERT_EQ(clientArg.addedContextCount, 3);
ASSERT_EQ(clientArg.parsedContextCount, 7);
ASSERT_EQ(clientArg.addedContext[0], HITLS_EX_TYPE_CLIENT_HELLO);
ASSERT_EQ(clientArg.addedContext[1], HITLS_EX_TYPE_TLS1_3_CERTIFICATE);
ASSERT_EQ(clientArg.addedContext[2], HITLS_EX_TYPE_TLS1_3_CERTIFICATE);
ASSERT_EQ(clientArg.parsedContext[0], HITLS_EX_TYPE_TLS1_2_SERVER_HELLO | HITLS_EX_TYPE_TLS1_3_SERVER_HELLO | HITLS_EX_TYPE_HELLO_RETRY_REQUEST);
ASSERT_EQ(clientArg.parsedContext[1], HITLS_EX_TYPE_ENCRYPTED_EXTENSIONS);
ASSERT_EQ(clientArg.parsedContext[2], HITLS_EX_TYPE_TLS1_3_CERTIFICATE_REQUEST);
ASSERT_EQ(clientArg.parsedContext[3], HITLS_EX_TYPE_TLS1_3_CERTIFICATE);
ASSERT_EQ(clientArg.parsedContext[4], HITLS_EX_TYPE_TLS1_3_CERTIFICATE);
ASSERT_EQ(clientArg.parsedContext[5], HITLS_EX_TYPE_TLS1_3_NEW_SESSION_TICKET);
ASSERT_EQ(clientArg.parsedContext[6], HITLS_EX_TYPE_TLS1_3_NEW_SESSION_TICKET);
ASSERT_EQ(serverArg.addedContextCount, 7);
ASSERT_EQ(serverArg.parsedContextCount, 3);
ASSERT_EQ(serverArg.parsedContext[0], HITLS_EX_TYPE_CLIENT_HELLO);
ASSERT_EQ(serverArg.parsedContext[1], HITLS_EX_TYPE_TLS1_3_CERTIFICATE);
ASSERT_EQ(serverArg.parsedContext[2], HITLS_EX_TYPE_TLS1_3_CERTIFICATE);
ASSERT_EQ(serverArg.addedContext[0], HITLS_EX_TYPE_TLS1_3_SERVER_HELLO);
ASSERT_EQ(serverArg.addedContext[1], HITLS_EX_TYPE_ENCRYPTED_EXTENSIONS);
ASSERT_EQ(serverArg.addedContext[2], HITLS_EX_TYPE_TLS1_3_CERTIFICATE_REQUEST);
ASSERT_EQ(serverArg.addedContext[3], HITLS_EX_TYPE_TLS1_3_CERTIFICATE);
ASSERT_EQ(serverArg.addedContext[4], HITLS_EX_TYPE_TLS1_3_CERTIFICATE);
ASSERT_EQ(serverArg.addedContext[5], HITLS_EX_TYPE_TLS1_3_NEW_SESSION_TICKET);
ASSERT_EQ(serverArg.addedContext[5], HITLS_EX_TYPE_TLS1_3_NEW_SESSION_TICKET);
EXIT:
HITLS_CFG_FreeConfig(clientConfig);
HITLS_CFG_FreeConfig(serverConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test SDV_HITLS_CUSTOM_EXTENSION_FUNCTION_TC002
* @title Alert Scenario Test for Custom Extensions
*/
/* BEGIN_CASE */
void SDV_HITLS_CUSTOM_EXTENSION_FUNCTION_TC002()
{
FRAME_Init(); // Initialize the test framework
HITLS_Config *clientConfig = HITLS_CFG_NewTLS13Config();
HITLS_Config *serverConfig = HITLS_CFG_NewTLS13Config();
CustomExtensionArg serverArg = {0};
CustomExtensionArg clientArg = {0};
clientArg.alert = ALERT_ILLEGAL_PARAMETER;
clientArg.alertContext = HITLS_EX_TYPE_TLS1_3_SERVER_HELLO;
HITLS_CustomExtParams params = {
.extType = CUSTOM_EXTENTIONS_TYPE_2,
.context = HITLS_EX_TYPE_CLIENT_HELLO | HITLS_EX_TYPE_TLS1_3_SERVER_HELLO,
.addCb = CustomExtensionAddCb,
.freeCb = CustomExtensionFreeCb,
.addArg = &clientArg,
.parseCb = CustomExtensionParseCb,
.parseArg = &clientArg
};
HITLS_CFG_AddCustomExtension(clientConfig, ¶ms);
params.addArg = &serverArg;
params.parseArg = &serverArg;
HITLS_CFG_AddCustomExtension(serverConfig, ¶ms);
FRAME_LinkObj *client = FRAME_CreateLink(clientConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(serverConfig, BSL_UIO_TCP);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), -1);
ALERT_Info info = {0};
ALERT_GetInfo(client->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_ILLEGAL_PARAMETER);
EXIT:
HITLS_CFG_FreeConfig(clientConfig);
HITLS_CFG_FreeConfig(serverConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test SDV_HITLS_CUSTOM_EXTENSION_FUNCTION_TC003
* @title Empty Extension Capability Test
*/
/* BEGIN_CASE */
void SDV_HITLS_CUSTOM_EXTENSION_FUNCTION_TC003()
{
FRAME_Init(); // Initialize the test framework
HITLS_Config *clientConfig = HITLS_CFG_NewTLS13Config();
HITLS_Config *serverConfig = HITLS_CFG_NewTLS13Config();
CustomExtensionArg serverArg = {0};
CustomExtensionArg clientArg = {0};
clientArg.addEmptyExt = true;
clientArg.parseEmptyExt = false;
serverArg.addEmptyExt = false;
serverArg.parseEmptyExt = true;
HITLS_CustomExtParams params = {
.extType = CUSTOM_EXTENTIONS_TYPE_2,
.context = HITLS_EX_TYPE_CLIENT_HELLO | HITLS_EX_TYPE_TLS1_3_SERVER_HELLO,
.addCb = CustomExtensionAddCb,
.freeCb = CustomExtensionFreeCb,
.addArg = &clientArg,
.parseCb = CustomExtensionParseCb,
.parseArg = &clientArg
};
HITLS_CFG_AddCustomExtension(clientConfig, ¶ms);
params.addArg = &serverArg;
params.parseArg = &serverArg;
HITLS_CFG_AddCustomExtension(serverConfig, ¶ms);
FRAME_LinkObj *client = FRAME_CreateLink(clientConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(serverConfig, BSL_UIO_TCP);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), 0);
ASSERT_EQ(clientArg.addedContextCount, 1);
ASSERT_EQ(clientArg.parsedContextCount, 1);
ASSERT_EQ(clientArg.addedContext[0], HITLS_EX_TYPE_CLIENT_HELLO);
ASSERT_EQ(clientArg.parsedContext[0], HITLS_EX_TYPE_TLS1_2_SERVER_HELLO | HITLS_EX_TYPE_TLS1_3_SERVER_HELLO | HITLS_EX_TYPE_HELLO_RETRY_REQUEST);
ASSERT_EQ(serverArg.addedContextCount, 1);
ASSERT_EQ(serverArg.parsedContextCount, 1);
ASSERT_EQ(serverArg.addedContext[0], HITLS_EX_TYPE_TLS1_3_SERVER_HELLO);
ASSERT_EQ(serverArg.parsedContext[0], HITLS_EX_TYPE_CLIENT_HELLO);
EXIT:
HITLS_CFG_FreeConfig(clientConfig);
HITLS_CFG_FreeConfig(serverConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test SDV_HITLS_CUSTOM_EXTENSION_FUNCTION_TC004
* @title Pass Extension Capability Test
*/
/* BEGIN_CASE */
void SDV_HITLS_CUSTOM_EXTENSION_FUNCTION_TC004()
{
FRAME_Init(); // Initialize the test framework
HITLS_Config *clientConfig = HITLS_CFG_NewTLS13Config();
HITLS_Config *serverConfig = HITLS_CFG_NewTLS13Config();
CustomExtensionArg serverArg = {0};
CustomExtensionArg clientArg = {0};
clientArg.passExt = true;
serverArg.passExt = true;
HITLS_CustomExtParams params = {
.extType = CUSTOM_EXTENTIONS_TYPE_2,
.context = HITLS_EX_TYPE_CLIENT_HELLO | HITLS_EX_TYPE_TLS1_3_SERVER_HELLO,
.addCb = CustomExtensionAddCb,
.freeCb = CustomExtensionFreeCb,
.addArg = &clientArg,
.parseCb = CustomExtensionParseCb,
.parseArg = &clientArg
};
HITLS_CFG_AddCustomExtension(clientConfig, ¶ms);
params.addArg = &serverArg;
params.parseArg = &serverArg;
HITLS_CFG_AddCustomExtension(serverConfig, ¶ms);
FRAME_LinkObj *client = FRAME_CreateLink(clientConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(serverConfig, BSL_UIO_TCP);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), 0);
ASSERT_EQ(clientArg.addedContextCount, 1);
ASSERT_EQ(clientArg.parsedContextCount, 0);
ASSERT_EQ(serverArg.addedContextCount, 1);
ASSERT_EQ(serverArg.parsedContextCount, 0);
EXIT:
HITLS_CFG_FreeConfig(clientConfig);
HITLS_CFG_FreeConfig(serverConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/custom/test_suite_sdv_custom_extensions.c
|
C
|
unknown
| 28,516
|
/*
* 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_BASE ../consistency/tls12/test_suite_tls12_consistency_rfc5246_malformed_msg */
/* BEGIN_HEADER */
#include "securec.h"
#include "bsl_bytes.h"
#include "bsl_sal.h"
#include "stub_replace.h"
#include "hitls_error.h"
#include "tls.h"
#include "bsl_uio.h"
#include "rec.h"
#include "crypt.h"
#include "rec_conn.h"
#include "record.h"
#include "bsl_uio.h"
#include "hitls.h"
#include "frame_tls.h"
#include "cert_callback.h"
/* END_HEADER */
/* UserData structure transferred from the server to the alpnCb callback */
static uint8_t S_parsedList[100];
static uint32_t S_parsedListLen;
static TlsAlpnExtCtx alpnServerCtx = {0};
static uint8_t C_parsedList[100];
static uint32_t C_parsedListLen;
static int32_t ConfigAlpn(HITLS_Config *tlsConfig, char *AlpnList, bool isCient)
{
int32_t ret;
char defaultAlpnList[] = "http/1.1,spdy/1,spdy/2,spdy/3";
char *pAlpnList = NULL;
uint32_t AlpnListLen = 0;
if (AlpnList != NULL){
pAlpnList = AlpnList;
AlpnListLen = strlen(pAlpnList);
} else {
pAlpnList = defaultAlpnList;
AlpnListLen = strlen(pAlpnList);
}
/* client set alpn */
if (isCient) {
ret = ExampleAlpnParseProtocolList(C_parsedList, &C_parsedListLen, (uint8_t *)pAlpnList, AlpnListLen);
ASSERT_EQ(ret, HITLS_SUCCESS);
ret = HITLS_CFG_SetAlpnProtos(tlsConfig, C_parsedList, C_parsedListLen);
ASSERT_EQ(ret, HITLS_SUCCESS);
/* server set alpn and alpnSelectCb */
} else {
ret = ExampleAlpnParseProtocolList(S_parsedList, &S_parsedListLen, (uint8_t *)pAlpnList, AlpnListLen);
ASSERT_EQ(ret, HITLS_SUCCESS);
alpnServerCtx = (TlsAlpnExtCtx){ S_parsedList, S_parsedListLen };
ret = HITLS_CFG_SetAlpnProtosSelectCb(tlsConfig, ExampleAlpnCbForLlt, &alpnServerCtx);
ASSERT_EQ(ret, HITLS_SUCCESS);
}
EXIT:
return ret;
}
/**
* @test UT_TLS_ALPN_PARSE_PROTO_FUNC_TC001
* @title ALPN function test
* @precon nan
* @brief server set alpn and alpn callback，client set alpn. The server supports the protocol configured on
the client .Expect result 1
* @expect 1. server returns the protocol supported by the client
*/
/* BEGIN_CASE */
void UT_TLS_ALPN_PARSE_PROTO_FUNC_TC001(int version)
{
FRAME_Init();
RegDefaultMemCallback();
HITLS_Config *s_config = NULL;
HITLS_Config *c_config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
if (version == HITLS_VERSION_TLS12) {
c_config = HITLS_CFG_NewTLS12Config();
s_config = HITLS_CFG_NewTLS12Config();
} else if (version == HITLS_VERSION_TLS13) {
c_config = HITLS_CFG_NewTLS13Config();
s_config = HITLS_CFG_NewTLS13Config();
}
ASSERT_TRUE(c_config != NULL);
ASSERT_TRUE(s_config != NULL);
uint16_t groups[] = {HITLS_EC_GROUP_SECP256R1};
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetGroups(c_config, groups, sizeof(groups) / sizeof(uint16_t));
HITLS_CFG_SetSignature(c_config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
HITLS_CFG_SetGroups(s_config, groups, sizeof(groups) / sizeof(uint16_t));
HITLS_CFG_SetSignature(s_config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
ConfigAlpn(s_config, NULL, false);
ConfigAlpn(c_config, NULL, true);
client = FRAME_CreateLink(c_config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(s_config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
int32_t ret;
ret = FRAME_CreateConnection(client, server, true, HS_STATE_BUTT);
ASSERT_EQ(ret, HITLS_SUCCESS);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(memcmp(clientTlsCtx->negotiatedInfo.alpnSelected, "http/1.1", 8) == 0);
ASSERT_TRUE(clientTlsCtx->negotiatedInfo.alpnSelectedSize == 8);
ASSERT_TRUE(memcmp(serverTlsCtx->negotiatedInfo.alpnSelected, "http/1.1", 8) == 0);
ASSERT_TRUE(serverTlsCtx->negotiatedInfo.alpnSelectedSize == 8);
EXIT:
HITLS_CFG_FreeConfig(s_config);
HITLS_CFG_FreeConfig(c_config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_frame_alpn_interface.c
|
C
|
unknown
| 4,793
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
#include <stddef.h>
#include <sys/types.h>
#include <regex.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/time.h>
#include <linux/ioctl.h>
#include "securec.h"
#include "bsl_sal.h"
#include "sal_net.h"
#include "frame_tls.h"
#include "cert_callback.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_errno.h"
#include "bsl_uio.h"
#include "frame_io.h"
#include "uio_abstraction.h"
#include "tls.h"
#include "tls_config.h"
#include "logger.h"
#include "process.h"
#include "hs_ctx.h"
#include "hlt.h"
#include "stub_replace.h"
#include "hitls_type.h"
#include "frame_link.h"
#include "session_type.h"
#include "common_func.h"
#include "hitls_func.h"
#include "hitls_cert_type.h"
#include "cert_mgr_ctx.h"
#include "parser_frame_msg.h"
#include "recv_process.h"
#include "simulate_io.h"
#include "rec_wrapper.h"
#include "cipher_suite.h"
#include "alert.h"
#include "conn_init.h"
#include "pack.h"
#include "send_process.h"
#include "cert.h"
#include "hitls_cert_reg.h"
#include "hitls_crypt_type.h"
#include "hs.h"
#include "hs_state_recv.h"
#include "app.h"
#include "record.h"
#include "rec_conn.h"
#include "session.h"
#include "frame_msg.h"
#include "pack_frame_msg.h"
#include "cert_mgr.h"
#include "hs_extensions.h"
#include "hlt_type.h"
#include "sctp_channel.h"
#include "hitls_crypt_init.h"
#include "hitls_session.h"
#include "bsl_log.h"
#include "bsl_err.h"
#include "hitls_crypt_reg.h"
#include "crypt_errno.h"
#include "bsl_list.h"
#include "hitls_cert.h"
#include "parse_extensions_client.c"
#include "parse_extensions_server.c"
#include "parse_server_hello.c"
#include "parse_client_hello.c"
#include "uio_udp.c"
/* END_HEADER */
/** @
* @test UT_TLS_CFG_SET_GET_REC_INBUFFER_SIZE_API_TC001
* @title Test the HITLS_CFG_SetRecInbufferSize and HITLS_CFG_GetRecInbufferSize.
* @precon nan
* @brief HITLS_CFG_SetRecInbufferSize
* 1. Input an empty TLS connection handle. Expected result 1.
* 2. Transfer a non-empty TLS connection handle and set recInbufferSize to an invalid value. Expected result 2.
* 3. Transfer a non-empty TLS connection handle information and set recInbufferSize to a valid value. Expected result 3
* HITLS_CFG_GetRecInbufferSize
* 1. Input an empty TLS connection handle or NULL recInbufferSize pointer. Expected result 1.
* 2. Transfer a non-empty TLS connection handle and recInbufferSize pointer.Expected result 3.
* @expect 1. Returns HITLS_NULL_INPUT
* 2. HITLS_CONFIG_INVALID_LENGTH is returned
* 3. Returns HITLS_SUCCES.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_REC_INBUFFER_SIZE_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
config = HITLS_CFG_NewTLS12Config();
uint32_t recInbufferSize = 18433;
ASSERT_TRUE(HITLS_CFG_SetRecInbufferSize(NULL, recInbufferSize) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetRecInbufferSize(config, recInbufferSize) == HITLS_CONFIG_INVALID_LENGTH);
/* value < 512 */
recInbufferSize = 511;
ASSERT_TRUE(HITLS_CFG_SetRecInbufferSize(config, recInbufferSize) == HITLS_CONFIG_INVALID_LENGTH);
/* 18432 > value > 512 */
recInbufferSize = 1000;
ASSERT_TRUE(HITLS_CFG_SetRecInbufferSize(config, recInbufferSize) == HITLS_SUCCESS);
uint32_t recInbufferSize2 = 0;
ASSERT_TRUE(HITLS_CFG_GetRecInbufferSize(NULL, &recInbufferSize2) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetRecInbufferSize(config, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetRecInbufferSize(config, &recInbufferSize2) == HITLS_SUCCESS);
ASSERT_EQ(recInbufferSize2, 1000);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SET_GET_REC_INBUFFER_SIZE_API_TC001
* @title Test the HITLS_SetRecInbufferSize and HITLS_GetRecInbufferSize.
* @precon nan
* @brief HITLS_SetRecInbufferSize
* 1. Input an empty TLS connection handle. Expected result 1.
* 2. Transfer a non-empty TLS connection handle and set recInbufferSize to an invalid value. Expected result 2.
* 3. Transfer a non-empty TLS connection handle information and set recInbufferSize to a valid value. Expected result 3
* HITLS_GetRecInbufferSize
* 1. Input an empty TLS connection handle or NULL recInbufferSize pointer. Expected result 1.
* 2. Transfer a non-empty TLS connection handle and recInbufferSize pointer.Expected result 3.
* @expect 1. Returns HITLS_NULL_INPUT
* 2. HITLS_CONFIG_INVALID_LENGTH is returned
* 3. Returns HITLS_SUCCES.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_GET_REC_INBUFFER_SIZE_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
config = HITLS_CFG_NewDTLS12Config();
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
/* value > 18432 */
uint32_t recInbufferSize = 18433;
ASSERT_TRUE(HITLS_SetRecInbufferSize(NULL, recInbufferSize) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetRecInbufferSize(ctx, recInbufferSize) == HITLS_CONFIG_INVALID_LENGTH);
/* value < 512 */
recInbufferSize = 511;
ASSERT_TRUE(HITLS_SetRecInbufferSize(ctx, recInbufferSize) == HITLS_CONFIG_INVALID_LENGTH);
/* 18432 > value > 512 */
recInbufferSize = 1000;
ASSERT_TRUE(HITLS_SetRecInbufferSize(ctx, recInbufferSize) == HITLS_SUCCESS);
uint32_t recInbufferSize2 = 0;
ASSERT_TRUE(HITLS_GetRecInbufferSize(NULL, &recInbufferSize2) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetRecInbufferSize(ctx, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetRecInbufferSize(ctx, &recInbufferSize2) == HITLS_SUCCESS);
ASSERT_EQ(recInbufferSize2, 1000);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_frame_buffer_minimization.c
|
C
|
unknown
| 6,441
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <unistd.h>
#include <stdbool.h>
#include <semaphore.h>
#include "securec.h"
#include "hlt.h"
#include "logger.h"
#include "hitls_config.h"
#include "hitls_cert_type.h"
#include "crypt_util_rand.h"
#include "helper.h"
#include "hitls.h"
#include "frame_tls.h"
#include "frame_link.h"
#include "hitls_type.h"
#include "rec_wrapper.h"
#include "hs_ctx.h"
#include "tls.h"
#include "hitls_config.h"
#include "alert.h"
#include "hitls_func.h"
/* END_HEADER */
static void CaListNodeInnerDestroy(void *data)
{
HITLS_TrustedCANode *tmpData = (HITLS_TrustedCANode *)data;
BSL_SAL_FREE(tmpData->data);
BSL_SAL_FREE(tmpData);
return;
}
/**
* @test UT_TLS_TLS13_RECV_CA_LIST_TC001
* @brief 1. Use the default configuration items to configure the client and server, Expect result 1.
* 2. Load the CA file into the configuration, Expect result 1.
* 3. Set the CA list in the configuration, Expect result 1.
* 4. Create the client and server links, Expect result 2.
* @expect 1. HITLS_SUCCESS
* 2. caList->count == 1
*/
/* BEGIN_CASE */
void UT_TLS_CERT_CFG_LoadCAFile_API_TC001(int version, char *certFile, char *userdata)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
HITLS_TrustedCAList *caList = NULL;
ASSERT_TRUE(HITLS_CFG_SetDefaultPasswordCbUserdata(tlsConfig, userdata) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetDefaultPasswordCbUserdata(tlsConfig) == userdata);
ASSERT_TRUE(HITLS_CFG_ParseCAList(tlsConfig, certFile, (uint32_t)strlen(certFile), TLS_PARSE_TYPE_FILE,
TLS_PARSE_FORMAT_ASN1, &caList) == HITLS_SUCCESS);
ASSERT_TRUE(caList != NULL);
ASSERT_TRUE(caList->count == 1);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
BSL_LIST_FREE(caList, CaListNodeInnerDestroy);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS13_RECV_CA_LIST_TC001
* @spec -
* @title The CA list is parsed correctly.
* @precon nan
* @brief 1. Use the default configuration items to configure the client and server, Expect result 1.
* 2. Load the CA file into the configuration, Expect result 1.
* 3. Set the CA list in the configuration, Expect result 1.
* 4. Create the client and server links, Expect result 1.
* 5. Create the connection between the client and server, Expect result 2.
* 6. Get the peer CA list from the server, Expect result 1.
* 7. Verify that the peer CA list is not NULL and contains one CA, Expect result 3.
* @expect 1. HITLS_SUCCESS
* 2. link established successfully
* 3. peerList != NULL
@ */
/* BEGIN_CASE */
void UT_TLS_TLS13_RECV_CA_LIST_TC001(char *certFile)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
HITLS_TrustedCAList *caList = NULL;
ASSERT_TRUE(HITLS_CFG_ParseCAList(config, certFile, (uint32_t)strlen(certFile), TLS_PARSE_TYPE_FILE,
TLS_PARSE_FORMAT_ASN1, &caList) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_SetCAList(config, caList) == HITLS_SUCCESS);
ASSERT_TRUE(caList != NULL);
ASSERT_TRUE(caList->count == 1);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
HITLS_TrustedCAList *peerList = HITLS_GetPeerCAList(server->ssl);
ASSERT_TRUE(peerList != NULL);
ASSERT_TRUE(peerList->count == 1);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_TLS12_RECV_CA_LIST_TC001
* @spec -
* @title The CA list is parsed correctly.
* @precon nan
* @brief 1. Use the default configuration items to configure the client and server, Expect result 1.
* 2. Load the CA file into the configuration, Expect result 1.
* 3. Set the CA list in the configuration, Expect result 1.
* 4. set ClientVerifySupport, Expect result 1.
* 4. Create the client and server links, Expect result 1.
* 5. Create the connection between the client and server, Expect result 2.
* 6. Get the peer CA list from the server, Expect result 1.
* 7. Verify that the peer CA list is not NULL and contains one CA, Expect result 3.
* @expect 1. HITLS_SUCCESS
* 2. link established successfully
* 3. peerList != NULL
@ */
/* BEGIN_CASE */
void UT_TLS_TLS12_RECV_CA_LIST_TC001(char *certFile)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
HITLS_TrustedCAList *caList = NULL;
ASSERT_TRUE(HITLS_CFG_ParseCAList(config, certFile, (uint32_t)strlen(certFile), TLS_PARSE_TYPE_FILE,
TLS_PARSE_FORMAT_ASN1, &caList) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_SetCAList(config, caList) == HITLS_SUCCESS);
HITLS_CFG_SetClientVerifySupport(config, true);
ASSERT_TRUE(caList != NULL);
ASSERT_TRUE(caList->count == 1);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
HITLS_TrustedCAList *peerList = HITLS_GetPeerCAList(client->ssl);
ASSERT_TRUE(peerList != NULL);
ASSERT_TRUE(peerList->count == 1);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_frame_ca_list.c
|
C
|
unknown
| 6,453
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
#include <stddef.h>
#include <sys/types.h>
#include <regex.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/time.h>
#include <linux/ioctl.h>
#include "securec.h"
#include "bsl_sal.h"
#include "sal_net.h"
#include "frame_tls.h"
#include "cert_callback.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_errno.h"
#include "bsl_uio.h"
#include "frame_io.h"
#include "uio_abstraction.h"
#include "tls.h"
#include "tls_config.h"
#include "logger.h"
#include "process.h"
#include "hs_ctx.h"
#include "hlt.h"
#include "stub_replace.h"
#include "hitls_type.h"
#include "frame_link.h"
#include "session_type.h"
#include "common_func.h"
#include "hitls_func.h"
#include "hitls_cert_type.h"
#include "cert_mgr_ctx.h"
#include "parser_frame_msg.h"
#include "recv_process.h"
#include "simulate_io.h"
#include "rec_wrapper.h"
#include "cipher_suite.h"
#include "alert.h"
#include "conn_init.h"
#include "pack.h"
#include "send_process.h"
#include "cert.h"
#include "hitls_cert_reg.h"
#include "hitls_crypt_type.h"
#include "hs.h"
#include "hs_state_recv.h"
#include "app.h"
#include "record.h"
#include "rec_conn.h"
#include "session.h"
#include "frame_msg.h"
#include "pack_frame_msg.h"
#include "cert_mgr.h"
#include "hs_extensions.h"
#include "hlt_type.h"
#include "sctp_channel.h"
#include "hitls_crypt_init.h"
#include "hitls_session.h"
#include "bsl_log.h"
#include "bsl_err.h"
#include "hitls_crypt_reg.h"
#include "crypt_errno.h"
#include "bsl_list.h"
#include "hitls_cert.h"
#include "parse_extensions_client.c"
#include "parse_extensions_server.c"
#include "parse_server_hello.c"
#include "parse_client_hello.c"
#include "uio_udp.c"
/* END_HEADER */
/** @
* @test UT_TLS_CFG_SET_GET_MAX_SEND_FRAGMENT_API_TC001
* @title Test the HITLS_CFG_SetMaxSendFragment and HITLS_CFG_GetMaxSendFragment.
* @precon nan
* @brief HITLS_CFG_SetMaxSendFragment
* 1. Input an empty TLS connection handle. Expected result 1.
* 2. Transfer a non-empty TLS connection handle and set maxSendFragment to an invalid value. Expected result 2.
* 3. Transfer a non-empty TLS connection handle information and set maxSendFragment to a valid value. Expected result 3
* HITLS_CFG_GetMaxSendFragment
* 1. Input an empty TLS connection handle or NULL maxSendFragment pointer. Expected result 1.
* 2. Transfer a non-empty TLS connection handle and maxSendFragment pointer.Expected result 3.
* @expect 1. Returns HITLS_NULL_INPUT
* 2. HITLS_CONFIG_INVALID_LENGTH is returned
* 3. Returns HITLS_SUCCES.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_MAX_SEND_FRAGMENT_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
config = HITLS_CFG_NewDTLS12Config();
uint16_t maxSendFragment = 16385;
ASSERT_TRUE(HITLS_CFG_SetMaxSendFragment(NULL, maxSendFragment) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetMaxSendFragment(config, maxSendFragment) == HITLS_CONFIG_INVALID_LENGTH);
/* value < 512 */
maxSendFragment = 511;
ASSERT_TRUE(HITLS_CFG_SetMaxSendFragment(config, maxSendFragment) == HITLS_CONFIG_INVALID_LENGTH);
/* 16384 > value > 512 */
maxSendFragment = 1000;
ASSERT_TRUE(HITLS_CFG_SetMaxSendFragment(config, maxSendFragment) == HITLS_SUCCESS);
uint16_t maxSendFragment2 = 0;
ASSERT_TRUE(HITLS_CFG_GetMaxSendFragment(NULL, &maxSendFragment2) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetMaxSendFragment(config, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetMaxSendFragment(config, &maxSendFragment2) == HITLS_SUCCESS);
ASSERT_EQ(maxSendFragment2, 1000);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SET_GET_MAX_SEND_FRAGMENT_API_TC001
* @title Test the HITLS_SetMaxSendFragment and HITLS_GetMaxSendFragment.
* @precon nan
* @brief HITLS_SetMaxSendFragment
* 1. Input an empty TLS connection handle. Expected result 1.
* 2. Transfer a non-empty TLS connection handle and set maxSendFragment to an invalid value. Expected result 2.
* 3. Transfer a non-empty TLS connection handle information and set maxSendFragment to a valid value. Expected result 3
* HITLS_GetMaxSendFragment
* 1. Input an empty TLS connection handle or NULL maxSendFragment pointer. Expected result 1.
* 2. Transfer a non-empty TLS connection handle and maxSendFragment pointer.Expected result 3.
* @expect 1. Returns HITLS_NULL_INPUT
* 2. HITLS_CONFIG_INVALID_LENGTH is returned
* 3. Returns HITLS_SUCCES.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_GET_MAX_SEND_FRAGMENT_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
config = HITLS_CFG_NewDTLS12Config();
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
/* value > 16384 */
uint16_t maxSendFragment = 16385;
ASSERT_TRUE(HITLS_SetMaxSendFragment(NULL, maxSendFragment) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetMaxSendFragment(ctx, maxSendFragment) == HITLS_CONFIG_INVALID_LENGTH);
/* value < 512 */
maxSendFragment = 511;
ASSERT_TRUE(HITLS_SetMaxSendFragment(ctx, maxSendFragment) == HITLS_CONFIG_INVALID_LENGTH);
/* 16384 > value > 512 */
maxSendFragment = 1000;
ASSERT_TRUE(HITLS_SetMaxSendFragment(ctx, maxSendFragment) == HITLS_SUCCESS);
uint16_t maxSendFragment2 = 0;
ASSERT_TRUE(HITLS_GetMaxSendFragment(NULL, &maxSendFragment2) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetMaxSendFragment(ctx, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetMaxSendFragment(ctx, &maxSendFragment2) == HITLS_SUCCESS);
ASSERT_EQ(maxSendFragment2, 1000);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SET_MAX_SEND_FRAGMENT_TC001
* @title Test the HITLS_SetMaxSendFragment
* @precon nan
* @brief HITLS_SetMaxSendFragment
* 1. Create connection. Expected result 1.
* 2. set maxSendFragment to 1000 bytes. Expected result 1.
* 3. Invoke hitls_write to write 1200 bytes. Expected result 2.
* @expect 1. Returns HITLS_SUCCES
* 2. Only 1000 bytes of data is sent
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_MAX_SEND_FRAGMENT_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
// Apply for and initialize the configuration file
config = HITLS_CFG_NewDTLS12Config();
client = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(server != NULL);
/* value > 512 */
uint16_t maxSendFragment = 1000;
ASSERT_TRUE(HITLS_SetMaxSendFragment(client->ssl, maxSendFragment) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT) == HITLS_SUCCESS);
const uint8_t sndBuf[1200] = {0};
uint32_t writeLen = 0;
ASSERT_EQ(HITLS_Write(client->ssl, sndBuf, sizeof(sndBuf), &writeLen), HITLS_SUCCESS);
ASSERT_EQ(writeLen, 1000);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_frame_max_send_fragment.c
|
C
|
unknown
| 7,831
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
#include <stddef.h>
#include <sys/types.h>
#include <regex.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/time.h>
#include <linux/ioctl.h>
#include "securec.h"
#include "bsl_sal.h"
#include "sal_net.h"
#include "frame_tls.h"
#include "cert_callback.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_errno.h"
#include "bsl_uio.h"
#include "frame_io.h"
#include "uio_abstraction.h"
#include "tls.h"
#include "tls_config.h"
#include "logger.h"
#include "process.h"
#include "hs_ctx.h"
#include "hlt.h"
#include "stub_replace.h"
#include "hitls_type.h"
#include "frame_link.h"
#include "session_type.h"
#include "common_func.h"
#include "hitls_func.h"
#include "hitls_cert_type.h"
#include "cert_mgr_ctx.h"
#include "parser_frame_msg.h"
#include "recv_process.h"
#include "simulate_io.h"
#include "rec_wrapper.h"
#include "cipher_suite.h"
#include "alert.h"
#include "conn_init.h"
#include "pack.h"
#include "send_process.h"
#include "cert.h"
#include "hitls_cert_reg.h"
#include "hitls_crypt_type.h"
#include "hs.h"
#include "hs_state_recv.h"
#include "app.h"
#include "record.h"
#include "rec_conn.h"
#include "session.h"
#include "frame_msg.h"
#include "pack_frame_msg.h"
#include "cert_mgr.h"
#include "hs_extensions.h"
#include "hlt_type.h"
#include "sctp_channel.h"
#include "hitls_crypt_init.h"
#include "hitls_session.h"
#include "bsl_log.h"
#include "bsl_err.h"
#include "hitls_crypt_reg.h"
#include "crypt_errno.h"
#include "bsl_list.h"
#include "hitls_cert.h"
#include "parse_extensions_client.c"
#include "parse_extensions_server.c"
#include "parse_server_hello.c"
#include "parse_client_hello.c"
#include "uio_udp.c"
/* END_HEADER */
/* @
* @test UT_TLS_CFG_SET_DTLS_LINK_MTU_API_TC001
* @title Test HITLS_SetLinkMtu interface
* @brief 1. Create the TLS configuration object config.Expect result 1.
* 2. Use config to create the client and server.Expect result 2.
* 3. Invoke HITLS_SetLinkMtu, Expect result 3.
* @expect 1. The config object is successfully created.
* 2. The client and server are successfully created.
* 3. mtu >= 256, Return HITLS_SUCCESS. mtu < 256, Return HITLS_CONFIG_INVALID_LENGTH.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_DTLS_LINK_MTU_API_TC001(void)
{
FRAME_Init();
uint32_t mtu = 1500;
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(HITLS_SetLinkMtu(client->ssl, mtu) == HITLS_SUCCESS);
server = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(HITLS_SetLinkMtu(server->ssl, mtu) == HITLS_SUCCESS);
/* value < 256 */
mtu = 200;
ASSERT_TRUE(HITLS_SetLinkMtu(server->ssl, mtu) == HITLS_CONFIG_INVALID_LENGTH);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SET_NO_QUERY_MTU_API_TC001
* @title Test the HITLS_SetNoQueryMtu interfaces.
* @precon nan
* @brief HITLS_SetNoQueryMtu
* 1. Input an empty TLS connection handle. Expected result 1.
* 2. Transfer a non-empty TLS connection handle and set noQueryMtu to an invalid value. Expected result 2.
* @expect 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_NO_QUERY_MTU_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
// Apply for and initialize the configuration file
config = HITLS_CFG_NewDTLS12Config();
client = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(server != NULL);
bool noQueryMtu = false;
ASSERT_TRUE(HITLS_SetNoQueryMtu(NULL, noQueryMtu) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetNoQueryMtu(client->ssl, noQueryMtu) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_SetNoQueryMtu(server->ssl, noQueryMtu) == HITLS_SUCCESS);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_GET_NEED_QUERY_MTU_API_TC001
* @title Test the HITLS_GetNeedQueryMtu interfaces.
* @precon nan
* @brief HITLS_GetNeedQueryMtu
* 1. Input an empty TLS connection handle or NULL needQueryMtu pointer. Expected result 1.
* 2. Input non empty ssl ctx and non empty needQueryMtu pointer. Expected result 2.
* @expect 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_NEED_QUERY_MTU_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
// Apply for and initialize the configuration file
config = HITLS_CFG_NewDTLS12Config();
client = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(server != NULL);
bool needQueryMtu = true;
ASSERT_TRUE(HITLS_GetNeedQueryMtu(NULL, &needQueryMtu) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetNeedQueryMtu(NULL, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetNeedQueryMtu(client->ssl, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetNeedQueryMtu(client->ssl, &needQueryMtu) == HITLS_SUCCESS);
ASSERT_EQ(needQueryMtu, false);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
int32_t STUB_REC_Write(TLS_Ctx *ctx, REC_Type recordType, const uint8_t *data, uint32_t num)
{
if ((ctx == NULL) || (ctx->recCtx == NULL) ||
(num != 0 && data == NULL) ||
(num == 0 && recordType != REC_TYPE_APP)) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15537, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Record write: input null pointer.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
int32_t ret = HITLS_REC_NORMAL_IO_BUSY;
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
if (ret != HITLS_SUCCESS) {
if (!BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_UDP)) {
return ret;
}
bool exceeded = false;
(void)BSL_UIO_Ctrl(ctx->uio, BSL_UIO_UDP_MTU_EXCEEDED, sizeof(bool), &exceeded);
if (exceeded) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17362, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"Record write: get EMSGSIZE error.", 0, 0, 0, 0);
ctx->needQueryMtu = true;
}
}
#endif /* HITLS_TLS_PROTO_DTLS12 && HITLS_BSL_UIO_UDP */
return ret;
}
int32_t STUB_UdpSocketCtrl(BSL_UIO *uio, int32_t cmd, int32_t larg, void *parg)
{
(void)uio;
(void)cmd;
(void)larg;
*(bool *)parg = true;
return BSL_SUCCESS;
}
/** @
* @test UT_TLS_CM_MTU_EMSGSIZE_TC001
* @title Test the HITLS_SetMaxSendFragment
* @precon nan
* @brief HITLS_SetMaxSendFragment
* 1. Create connection. Expected result 1.
* 2. set maxSendFragment to 1000 bytes. Expected result 1.
* 3. Invoke hitls_write to write 1200 bytes. Expected result 2.
* @expect 1. Returns HITLS_SUCCES
* 2. Only 1000 bytes of data is sent
@ */
/* BEGIN_CASE */
void UT_TLS_CM_MTU_EMSGSIZE_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
// Apply for and initialize the configuration file
config = HITLS_CFG_NewDTLS12Config();
client = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT) == HITLS_SUCCESS);
STUB_Init();
FuncStubInfo tmpStubInfo = {0};
FuncStubInfo tmpStubInfo2 = {0};
STUB_Replace(&tmpStubInfo, REC_Write, STUB_REC_Write);
STUB_Replace(&tmpStubInfo2, FRAME_Ctrl, STUB_UdpSocketCtrl);
ASSERT_TRUE(HITLS_SetMtu(client->ssl, 500) == HITLS_SUCCESS);
ASSERT_EQ(client->ssl->config.pmtu, 500);
const uint8_t sndBuf[1200] = {0};
uint32_t writeLen = 0;
ASSERT_EQ(HITLS_Write(client->ssl, sndBuf, sizeof(sndBuf), &writeLen), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(writeLen, 0);
STUB_Reset(&tmpStubInfo);
STUB_Reset(&tmpStubInfo2);
bool needQueryMtu = false;
ASSERT_TRUE(HITLS_GetNeedQueryMtu(client->ssl, &needQueryMtu) == HITLS_SUCCESS);
ASSERT_EQ(needQueryMtu, true);
ASSERT_EQ(HITLS_Write(client->ssl, sndBuf, sizeof(sndBuf), &writeLen), HITLS_SUCCESS);
/* use min mtu 256, and the encrypt cost is need to be reduced */
ASSERT_TRUE(writeLen < 256);
ASSERT_TRUE(writeLen > 0);
EXIT:
STUB_Reset(&tmpStubInfo);
STUB_Reset(&tmpStubInfo2);
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_frame_mtu.c
|
C
|
unknown
| 10,035
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include "frame_tls.h"
#include "frame_link.h"
#include "session.h"
#include "hitls_config.h"
#include "hitls_crypt_init.h"
#include "crypt_provider_local.h"
#include "crypt_eal_implprovider.h"
#include "crypt_provider.h"
#include "crypt_errno.h"
#include "cert_callback.h"
#include "test.h"
#include "crypt_eal_rand.h"
/* END_HEADER */
/* BEGIN_CASE */
void UT_TLS13_LOADPROVIDER_GROUP_TC001(char *path, char *get_cap_test1, int cmd)
{
#ifndef HITLS_TLS_FEATURE_PROVIDER
(void)path;
(void)get_cap_test1;
(void)cmd;
SKIP_TEST();
#else
FRAME_Init();
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_ProvMgrCtx *providerMgr = NULL;
HITLS_Config *config = NULL;
int32_t ret = CRYPT_SUCCESS;
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
ret = CRYPT_EAL_ProviderLoad(libCtx, BSL_SAL_LIB_FMT_OFF, "default", NULL, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_ProviderLoad(libCtx, cmd, get_cap_test1, NULL, &providerMgr);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_TRUE(providerMgr != NULL);
// Random Unloading Test Case
ASSERT_EQ(CRYPT_EAL_ProviderRandInitCtx(libCtx, GetAvailableRandAlgId(),
"provider=provider_get_cap_test1", NULL, 0, NULL), CRYPT_SUCCESS);
config = HITLS_CFG_ProviderNewTLS13Config(libCtx, NULL);
ASSERT_TRUE(config != NULL);
uint16_t group = 477;
HITLS_CFG_SetGroups(config, &group, 1);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
if (libCtx != NULL) {
CRYPT_EAL_LibCtxFree(libCtx);
}
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void UT_TLS13_LOADPROVIDER_SIGNSCHEME_TC001(char *path, char *get_cap_test1, int cmd)
{
#ifndef HITLS_TLS_FEATURE_PROVIDER
(void)path;
(void)get_cap_test1;
(void)cmd;
SKIP_TEST();
#else
FRAME_Init();
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_ProvMgrCtx *providerMgr = NULL;
HITLS_Config *config = NULL;
int32_t ret = CRYPT_SUCCESS;
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
ret = CRYPT_EAL_ProviderLoad(libCtx, cmd, get_cap_test1, NULL, &providerMgr);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_ProviderLoad(libCtx, BSL_SAL_LIB_FMT_OFF, "default", NULL, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_TRUE(providerMgr != NULL);
// Random Unloading Test Case
ASSERT_EQ(CRYPT_EAL_ProviderRandInitCtx(libCtx, GetAvailableRandAlgId(),
"provider=provider_get_cap_test1", NULL, 0, NULL), CRYPT_SUCCESS);
config = HITLS_CFG_ProviderNewTLS13Config(libCtx, NULL);
ASSERT_TRUE(config != NULL);
uint16_t signScheme = 23333;
HITLS_CFG_SetSignature(config, &signScheme, 1);
FRAME_CertInfo certInfo = {
"new_signAlg/ca.der",
"new_signAlg/inter.der",
"new_signAlg/client.der",
NULL,
"new_signAlg/client.key.der",
NULL
};
client = FRAME_CreateLinkWithCert(config, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLinkWithCert(config, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
if (libCtx != NULL) {
CRYPT_EAL_LibCtxFree(libCtx);
}
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void UT_TLS13_LOADPROVIDER_NEWKEYTYPE_TC001(char *path, char *provider_new_alg_test, int cmd)
{
#ifndef HITLS_TLS_FEATURE_PROVIDER
(void)path;
(void)provider_new_alg_test;
(void)cmd;
SKIP_TEST();
#else
FRAME_Init();
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
CRYPT_EAL_LibCtx *libCtx = NULL;
CRYPT_EAL_ProvMgrCtx *providerMgr = NULL;
HITLS_Config *config = NULL;
int32_t ret = CRYPT_SUCCESS;
libCtx = CRYPT_EAL_LibCtxNew();
ASSERT_TRUE(libCtx != NULL);
ASSERT_EQ(CRYPT_EAL_ProviderSetLoadPath(libCtx, path), CRYPT_SUCCESS);
ret = CRYPT_EAL_ProviderLoad(libCtx, cmd, provider_new_alg_test, NULL, &providerMgr);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ret = CRYPT_EAL_ProviderLoad(libCtx, BSL_SAL_LIB_FMT_OFF, "default", NULL, NULL);
ASSERT_EQ(ret, CRYPT_SUCCESS);
ASSERT_TRUE(providerMgr != NULL);
// Random Unloading Test Case
ASSERT_EQ(CRYPT_EAL_ProviderRandInitCtx(libCtx, GetAvailableRandAlgId(),
"provider=default", NULL, 0, NULL), CRYPT_SUCCESS);
config = HITLS_CFG_ProviderNewTLS13Config(libCtx, NULL);
ASSERT_TRUE(config != NULL);
uint16_t signScheme = 24444;
HITLS_CFG_SetSignature(config, &signScheme, 1);
FRAME_CertInfo certInfo = {
"new_keyAlg/ca.der",
"new_keyAlg/inter.der",
"new_keyAlg/client.der",
NULL,
"new_keyAlg/client.key.der",
NULL
};
client = FRAME_CreateLinkWithCert(config, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLinkWithCert(config, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
if (libCtx != NULL) {
CRYPT_EAL_LibCtxFree(libCtx);
}
#endif
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_frame_provider.c
|
C
|
unknown
| 6,469
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stddef.h>
#include "securec.h"
#include "tls_config.h"
#include "tls.h"
#include "hitls_type.h"
#include "bsl_sal.h"
#include "hitls.h"
#include "frame_tls.h"
#include "hitls_error.h"
#include "hitls_config.h"
#include "hitls_cert_reg.h"
#include "hitls_crypt_type.h"
#include "hs.h"
#include "hs_ctx.h"
#include "hs_state_recv.h"
#include "transcript_hash.h"
#include "conn_init.h"
#include "recv_process.h"
#include "stub_replace.h"
#include "simulate_io.h"
#include "parser_frame_msg.h"
#include "pack_frame_msg.h"
#include "frame_io.h"
#include "frame_link.h"
#include "common_func.h"
#include "hitls_crypt_init.h"
#include "alert.h"
#define TEST_SERVERNAME_LENGTH 20
#define READ_BUF_SIZE 18432
/* END_HEADER */
typedef struct {
uint16_t version;
BSL_UIO_TransportType uioType;
HITLS_Config *s_config;
HITLS_Config *c_config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_Session *clientSession;
HITLS_TicketKeyCb serverKeyCb;
} SniTestInfo;
typedef struct {
char servername[TEST_SERVERNAME_LENGTH + 1];
int32_t alert;
} SNI_Arg;
static SNI_Arg *sniArg = NULL;
static char *g_serverName = "huawei.com";
static char *g_serverNameErr = "www.huawei.com";
static uint8_t *g_sessionId;
static uint32_t g_sessionIdSize;
int32_t ServernameCbErrOK(HITLS_Ctx *ctx, int *alert, void *arg)
{
(void)ctx;
(void)alert;
(void)arg;
return HITLS_ACCEPT_SNI_ERR_OK;
}
void STUB_SendAlert(const TLS_Ctx *ctx, ALERT_Level level, ALERT_Description description)
{
(void)ctx;
(void)level;
(void)description;
return;
}
typedef struct TEST_SNI_DEAL_CB {
uint32_t sniState;
HITLS_SniDealCb sniDealCb;
} TEST_SNI_DEAL_CB;
typedef struct {
HITLS_Config *clientConfig;
HITLS_Config *serverConfig;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_HandshakeState state;
HITLS_SniDealCb sniDealCb;
HITLS_Session *clientSession;
uint16_t version;
BSL_UIO_TransportType type;
} HandshakeTestInfo;
int32_t TestCreateConfig(HITLS_Config **cfg, uint16_t version)
{
switch (version) {
case HITLS_VERSION_DTLS12:
*cfg = HITLS_CFG_NewDTLS12Config();
break;
case HITLS_VERSION_TLS13:
*cfg = HITLS_CFG_NewTLS13Config();
break;
case HITLS_VERSION_TLS12:
*cfg = HITLS_CFG_NewTLS12Config();
break;
default:
break;
}
if (*cfg == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
void FreeSNIArg(SNI_Arg *sniArg)
{
if (sniArg != NULL) {
BSL_SAL_FREE(sniArg);
}
}
void SetCommonConfig(HITLS_Config **config)
{
uint16_t groups[] = {HITLS_EC_GROUP_SECP256R1};
HITLS_CFG_SetGroups(*config, groups, sizeof(groups) / sizeof(uint16_t));
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(*config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
const uint16_t cipherSuites[] = {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_CFG_SetCipherSuites(*config, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t));
HITLS_CFG_SetClientVerifySupport(*config, true);
HITLS_CFG_SetExtenedMasterSecretSupport(*config, true);
HITLS_CFG_SetNoClientCertSupport(*config, true);
HITLS_CFG_SetRenegotiationSupport(*config, true);
HITLS_CFG_SetPskServerCallback(*config, (HITLS_PskServerCb)ExampleServerCb);
HITLS_CFG_SetPskClientCallback(*config, (HITLS_PskClientCb)ExampleClientCb);
HITLS_CFG_SetSessionTicketSupport(*config, false);
HITLS_CFG_SetCheckKeyUsage(*config, false);
}
static int32_t CreateLink(HandshakeTestInfo *testInfo)
{
testInfo->client = FRAME_CreateLink(testInfo->clientConfig, testInfo->type);
if (testInfo->client == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
if (testInfo->clientSession != NULL) {
int32_t ret = HITLS_SetSession(testInfo->client->ssl, testInfo->clientSession);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
testInfo->server = FRAME_CreateLink(testInfo->serverConfig, testInfo->type);
if (testInfo->server == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
return HITLS_SUCCESS;
}
static int32_t DefaultCfgAndLink(HandshakeTestInfo *testInfo)
{
FRAME_Init();
TestCreateConfig(&(testInfo->clientConfig), testInfo->version);
if (testInfo->clientConfig == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
SetCommonConfig(&(testInfo->clientConfig));
HITLS_CFG_SetServerName(testInfo->clientConfig, (uint8_t *)g_serverName, (uint32_t)strlen(g_serverName));
TestCreateConfig(&(testInfo->serverConfig), testInfo->version);
if (testInfo->serverConfig == NULL) {
return HITLS_INTERNAL_EXCEPTION;
}
SetCommonConfig(&(testInfo->serverConfig));
HITLS_CFG_SetServerNameCb(testInfo->serverConfig, testInfo->sniDealCb);
sniArg = (SNI_Arg *)BSL_SAL_Calloc(1, sizeof(SNI_Arg));
snprintf_s(sniArg->servername, sizeof(sniArg->servername), strlen(g_serverName), "%s", g_serverName);
if (HITLS_CFG_SetServerNameArg(testInfo->serverConfig, sniArg) != HITLS_SUCCESS) {
return HITLS_INTERNAL_EXCEPTION;
}
return CreateLink(testInfo);
}
int32_t GetSessionId(HandshakeTestInfo *testInfo)
{
FRAME_Type frameType = {0};
FRAME_Msg recvframeMsg = {0};
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(testInfo->client->io);
uint8_t *recMsg = ioUserData->recMsg.msg;
uint32_t recMsgLen = ioUserData->recMsg.len;
frameType.handshakeType = SERVER_HELLO;
frameType.recordType = REC_TYPE_HANDSHAKE;
frameType.versionType = testInfo->version;
uint32_t parseLen = 0;
int32_t ret = FRAME_ParseMsg(&frameType, recMsg, recMsgLen, &recvframeMsg, &parseLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
FRAME_ServerHelloMsg *serverHello = &recvframeMsg.body.hsMsg.body.serverHello;
g_sessionIdSize = serverHello->sessionIdSize.data;
BSL_SAL_FREE(g_sessionId);
g_sessionId = BSL_SAL_Dump(serverHello->sessionId.data, g_sessionIdSize);
FRAME_CleanMsg(&frameType, &recvframeMsg);
return HITLS_SUCCESS;
}
int32_t FirstHandshake(HandshakeTestInfo *testInfo)
{
int32_t ret = FRAME_CreateConnection(testInfo->client, testInfo->server, true, TRY_RECV_SERVER_HELLO);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = GetSessionId(testInfo);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = FRAME_CreateConnection(testInfo->client, testInfo->server, true, HS_STATE_BUTT);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint8_t data[] = "Hello World";
uint32_t writeLen;
ret = HITLS_Write(testInfo->server->ssl, data, sizeof(data), &writeLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ret = FRAME_TrasferMsgBetweenLink(testInfo->server, testInfo->client);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = HITLS_Read(testInfo->client->ssl, readBuf, READ_BUF_SIZE, &readLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
testInfo->clientSession = HITLS_GetDupSession(testInfo->client->ssl);
FRAME_FreeLink(testInfo->client);
testInfo->client = NULL;
FRAME_FreeLink(testInfo->server);
testInfo->server = NULL;
return HITLS_SUCCESS;
}
/* @
* @test UT_TLS_SNI_RESUME_SERVERNAME_FUNC_TC001
* @title During session resumption, the serverName extension of clientHello
is different from that in first handshake
* @precon nan
* @brief 1. For the first handshake, set serverName to huawei.com in the clientHello.
Expected result 1
2. During session resumption, changed serverName of clientHello to www.sss.com. Expected result 2
3. process the client hello. Expected result 2
* @expect 1. The serverName extension is set successfully and the handshake succeeds
2. return success
@ */
/* BEGIN_CASE */
void UT_TLS_SNI_RESUME_SERVERNAME_FUNC_TC001(int version, int type)
{
g_sessionId = NULL;
g_sessionIdSize = 0;
HandshakeTestInfo testInfo = {0};
testInfo.version = (uint16_t)version;
testInfo.type = (BSL_UIO_TransportType)type;
testInfo.sniDealCb = ServernameCbErrOK;
ASSERT_EQ(DefaultCfgAndLink(&testInfo), HITLS_SUCCESS);
ASSERT_EQ(FirstHandshake(&testInfo), HITLS_SUCCESS);
ASSERT_TRUE(testInfo.clientSession != NULL);
ASSERT_TRUE(CreateLink(&testInfo) == HITLS_SUCCESS);
ASSERT_TRUE(
FRAME_CreateConnection(testInfo.client, testInfo.server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(testInfo.server->ssl->hsCtx->state == TRY_RECV_CLIENT_HELLO);
CONN_Deinit(testInfo.server->ssl);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(testInfo.server->io);
uint8_t *buffer = ioUserData->recMsg.msg;
uint32_t len = ioUserData->recMsg.len;
ASSERT_TRUE(len != 0);
FRAME_Msg frameMsg = {0};
uint32_t parseLen = 0;
HS_Init(testInfo.server->ssl);
ASSERT_TRUE(ParserTotalRecord(testInfo.server, &frameMsg, buffer, len, &parseLen) == HITLS_SUCCESS);
ASSERT_TRUE(frameMsg.body.handshakeMsg.type == CLIENT_HELLO);
char *hostName = "www.sss.com";
uint8_t *serverName = frameMsg.body.handshakeMsg.body.clientHello.extension.content.serverName;
uint16_t serverNameSize = frameMsg.body.handshakeMsg.body.clientHello.extension.content.serverNameSize;
frameMsg.body.handshakeMsg.body.clientHello.extension.content.serverNameSize = strlen(hostName) + 1;
frameMsg.body.handshakeMsg.body.clientHello.extension.content.serverName = (uint8_t *)hostName;
testInfo.server->ssl->method.sendAlert = STUB_SendAlert;
CONN_Init(testInfo.server->ssl);
if (testInfo.type == BSL_UIO_TCP) {
ASSERT_TRUE(Tls12ServerRecvClientHelloProcess(testInfo.server->ssl, &frameMsg.body.handshakeMsg, true) ==
HITLS_SUCCESS);
} else {
ASSERT_TRUE(DtlsServerRecvClientHelloProcess(testInfo.server->ssl, &frameMsg.body.handshakeMsg) ==
HITLS_SUCCESS);
}
frameMsg.body.handshakeMsg.body.clientHello.extension.content.serverName = serverName;
frameMsg.body.handshakeMsg.body.clientHello.extension.content.serverNameSize = serverNameSize;
EXIT:
BSL_SAL_FREE(g_sessionId);
CleanRecordBody(&frameMsg);
HITLS_CFG_FreeConfig(testInfo.clientConfig);
HITLS_CFG_FreeConfig(testInfo.serverConfig);
FRAME_FreeLink(testInfo.client);
FRAME_FreeLink(testInfo.server);
HITLS_SESS_Free(testInfo.clientSession);
FreeSNIArg(sniArg);
}
/* END_CASE */
void *ExampleServerNameArg1(void)
{
return sniArg;
}
int32_t ExampleServerNameCb1(HITLS_Ctx *ctx, int *alert, void *arg)
{
(void)arg;
(void)alert;
const char *server_servername = "huawei.com";
const char *client_servername = HITLS_GetServerName(ctx, HITLS_SNI_HOSTNAME_TYPE);
if (client_servername != NULL && server_servername != NULL) {
if (strcmp(client_servername, server_servername) == 0){
printf("\nHiTLS ServerNameCb return HITLS_ACCEPT_SNI_ERR_OK\n");
return HITLS_ACCEPT_SNI_ERR_OK;
}
else {
printf("\nHiTLS ServerNameCb return HITLS_ACCEPT_SNI_ERR_ALERT_FATAL\n");
return HITLS_ACCEPT_SNI_ERR_ALERT_FATAL;
}
} else{
if (client_servername == NULL)
{
printf("\nHiTLS Server get client_servername is NULL!\n");
} else if (server_servername == NULL){
printf("\nHiTLS Server get server_servername is NULL!\n");
}
}
printf("\nHiTLS ServerNameCb return HITLS_ACCEPT_SNI_ERR_NOACK\n");
return HITLS_ACCEPT_SNI_ERR_NOACK;
}
/* @
* @test UT_TLS_SNI_RESUME_SERVERNAME_FUNC_TC002
* @title The TLS13 session is resumed. The client hello message carries the SNI, and the SNI value is different from
that of the first connection setup.
* @precon nan
* @brief 1. For the first handshake, set serverName to huawei.com in the clientHello. Expected result 1
2. During session resumption, changed serverName of clientHello to www.huawei.com. Expected result 2
3. process the client hello. Expected result 2
* @expect 1. The serverName extension is set successfully and the handshake succeeds
2. return success
@ */
/* BEGIN_CASE */
void UT_TLS_SNI_RESUME_SERVERNAME_FUNC_TC002()
{
FRAME_Init();
HITLS_Config *clientconfig = HITLS_CFG_NewTLS13Config();
HITLS_Config *serverconfig = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(serverconfig != NULL);
ASSERT_TRUE(clientconfig != NULL);
HITLS_CFG_SetServerNameCb(serverconfig, ExampleServerNameCb1);
HITLS_CFG_SetServerNameArg(serverconfig, ExampleServerNameArg1);
HITLS_CFG_SetServerName(clientconfig, (uint8_t *)g_serverName, strlen(g_serverName));
FRAME_LinkObj *client = FRAME_CreateLink(clientconfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
FRAME_LinkObj *server = FRAME_CreateLink(serverconfig, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
HITLS_Session *Session = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(Session != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(clientconfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(serverconfig, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, Session), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_SetServerName(client->ssl, (uint8_t *)g_serverNameErr, strlen(g_serverNameErr)) == HITLS_SUCCESS);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_MSG_HANDLE_SNI_UNRECOGNIZED_NAME);
ALERT_Info alertInfo = { 0 };
ALERT_GetInfo(server->ssl, &alertInfo);
ASSERT_EQ(alertInfo.flag, ALERT_FLAG_SEND);
ASSERT_EQ(alertInfo.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(alertInfo.description, ALERT_UNRECOGNIZED_NAME);
EXIT:
HITLS_CFG_FreeConfig(clientconfig);
HITLS_CFG_FreeConfig(serverconfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(Session);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_frame_servername_function.c
|
C
|
unknown
| 15,487
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdint.h>
#include "config.h"
#include "hitls.h"
#include "hitls_func.h"
#include "hitls_error.h"
/* END_HEADER */
static char *g_serverName = "www.example.com";
int32_t ServernameCbErrOK(HITLS_Ctx *ctx, int *alert, void *arg)
{
(void)ctx;
(void)alert;
(void)arg;
return HITLS_ACCEPT_SNI_ERR_OK;
}
#define HITLS_CFG_MAX_SIZE 1024
/** @
* @test UT_TLS_CFG_UPREF_FUNC_TC001
* @title test HITLS_CFG_SetServerName/HITLS_CFG_SetServerNameCb/HITLS_CFG_SetServerNameArg/HITLS_GetServernameType
* interface
*
* @brief 1. Apply for and initialize config.Expect result 1
2. Invoke the HITLS_CFG_NewTLS12Config interface and transfer the config parameter.Expect result 2.
3. Set serverNameStrlen HITLS_CFG_MAX_SIZE + 1;Invoke the HITLS_CFG_SetServerName interface Expect result 3.
4. Invoke the HITLS_CFG_NewTLS12Config interface.Expect result 4.
5. input parameters is NULL,Invoke the HITLS_CFG_NewTLS12Config interface and .Expect result 2.
6. Invoke the HITLS_CFG_SetServerNameCb interface ,Expect result 2.
7. Invoke the HITLS_CFG_SetServerNameArg interface ,Expect result 2.
8. Invoke the HITLS_CFG_GetServerNameCb interface ,Expect result 2.
9. Invoke the HITLS_CFG_GetServerNameArg interface ,Expect result 2.
10. Invoke the HITLS_SetServerName interface ,Expect result 2.
11. Invoke the HITLS_SetServerName interface ,Expect result 2.
12. Invoke the HITLS_SetServerName interface ,Expect result 6.
13. Invoke the HITLS_SetServerName interface ,Expect result 6.
14. Invoke the HITLS_GetServernameType interface ,Expect result 1.
* @expect 1. return Not NULL
2. return HITLS_NULL_INPUT
3. return HITLS_CONFIG_INVALID_LENGTH
4. return SUCCESS
5. return HITLS_NULL_INPUT
6. return NULL
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_SERVERNAME_API_TC001()
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
ASSERT_TRUE(HITLS_CFG_SetServerName(NULL, (uint8_t *)g_serverName, (uint32_t)strlen(g_serverName)) ==
HITLS_NULL_INPUT);
uint32_t errLen = HITLS_CFG_MAX_SIZE + 1;
ASSERT_TRUE(HITLS_CFG_SetServerName(config, (uint8_t *)g_serverName, errLen) == HITLS_CONFIG_INVALID_LENGTH);
ASSERT_TRUE(HITLS_CFG_SetServerName(config, (uint8_t *)g_serverName, (uint32_t)strlen(g_serverName)) ==
HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetServerName(NULL, NULL, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetServerNameCb(NULL, ServernameCbErrOK) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetServerNameArg(NULL, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetServerNameCb(NULL, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetServerNameArg(NULL, NULL) == HITLS_NULL_INPUT);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetServerName(ctx, NULL, 0) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetServerName(NULL, (uint8_t *)g_serverName, 0) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetServerName(ctx, HITLS_SNI_BUTT) == NULL);
ASSERT_TRUE(HITLS_GetServerName(NULL, HITLS_SNI_HOSTNAME_TYPE) == NULL);
ASSERT_TRUE(HITLS_GetServernameType(ctx) != 0);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_frame_servername_interface.c
|
C
|
unknown
| 4,055
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include "frame_tls.h"
#include "frame_link.h"
#include "session.h"
#include "hitls_config.h"
#include "hitls_crypt_init.h"
/* END_HEADER */
static int32_t ServernameCbErrOK(HITLS_Ctx *ctx, int *alert, void *arg)
{
(void)ctx;
(void)alert;
(void)arg;
return HITLS_ACCEPT_SNI_ERR_OK;
}
/** @
* @test UT_TLS12_RESUME_FUNC_TC001
* @title Test the session resume of tls12.
*
* @brief 1. at first handshake, config serverName, and sessionidCtx. Expect result 1
2. at second handshake, Expect result 2
* @expect 1. connect success
2. resume success
@ */
/* BEGIN_CASE */
void UT_TLS12_RESUME_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
HITLS_CFG_SetServerName(config, (uint8_t *)"www.test.com", (uint32_t)strlen((char *)"www.test.com"));
HITLS_CFG_SetServerNameCb(config, ServernameCbErrOK);
char *sessionIdCtx1 = "123456789";
ASSERT_EQ(HITLS_CFG_SetSessionIdCtx(config, (const uint8_t *)sessionIdCtx1, strlen(sessionIdCtx1)), HITLS_SUCCESS);
FRAME_LinkObj *client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
FRAME_LinkObj *server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
HITLS_Session *clientSession = HITLS_GetDupSession(client->ssl);
ASSERT_TRUE(clientSession != NULL);
FRAME_FreeLink(client);
client = NULL;
FRAME_FreeLink(server);
server = NULL;
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetSession(client->ssl, clientSession), HITLS_SUCCESS);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
uint8_t isReused = 0;
ASSERT_EQ(HITLS_IsSessionReused(client->ssl, &isReused), HITLS_SUCCESS);
ASSERT_EQ(isReused, 1);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
HITLS_SESS_Free(clientSession);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_frame_session_ticket.c
|
C
|
unknown
| 2,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.
*/
/* BEGIN_HEADER */
#include "securec.h"
#include "hlt.h"
#include "hitls_error.h"
#include "hitls_func.h"
#include "conn_init.h"
#include "frame_tls.h"
#include "frame_link.h"
#include "alert.h"
#include "stub_replace.h"
#include "hs_common.h"
#include "change_cipher_spec.h"
#include "hs.h"
#include "simulate_io.h"
#include "rec_header.h"
#include "rec_wrapper.h"
#include "record.h"
#include "app.c"
/* END_HEADER */
#define READ_BUF_SIZE 18432
#define MAX_DIGEST_SIZE 64UL /* The longest known is SHA512 */
uint32_t g_uiPort = 8890;
static uint32_t g_time = 0;
int32_t STUB_APP_Read(TLS_Ctx *ctx, uint8_t *buf, uint32_t num, uint32_t *readLen)
{
int32_t ret;
uint32_t readbytes;
g_time++;
if(g_time == 2) {
return HITLS_REC_ERR_IO_EXCEPTION;
}
if (ctx == NULL || buf == NULL || num == 0) {
return HITLS_APP_ERR_ZERO_READ_BUF_LEN;
}
// read data to the buffer in non-blocking mode
do {
ret = ReadAppData(ctx, buf, num, &readbytes);
if (ret != HITLS_SUCCESS) {
return ret;
}
} while (readbytes == 0); // do not exit the loop until data is read
*readLen = readbytes;
return HITLS_SUCCESS;
}
/** @
* @test UT_TLS_CM_SSL_MODE_AUTO_RETRY_TC001
* @title UT_TLS_CM_SSL_MODE_AUTO_RETRY_TC001
* @brief
* 1. Create connection. Expected result 1 is obtained.
* 2. Unset the auto retry mode, get keyupdate message. Expected result 2 is obtained.
* @expect
* 1. Successfully created connection.
* 2. After receive keyupdate message, the link will not try to read another app message
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SSL_MODE_AUTO_RETRY_TC001()
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
config->isSupportRenegotiation = true;
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config, 1), HITLS_SUCCESS);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
uint32_t len = 0;
ASSERT_TRUE(HITLS_Write(client->ssl, (uint8_t *)"Hello World", strlen("Hello World"), &len) == HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(server->ssl, readBuf, READ_BUF_SIZE, &readLen), HITLS_SUCCESS);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
ret = HITLS_KeyUpdate(client->ssl, HITLS_UPDATE_NOT_REQUESTED);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_ClearModeSupport(server->ssl, HITLS_MODE_AUTO_RETRY) == HITLS_SUCCESS);
g_time = 0;
FuncStubInfo tmpRpInfo = {0};
STUB_Replace(&tmpRpInfo, APP_Read, STUB_APP_Read);
ASSERT_EQ(HITLS_Read(server->ssl, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
STUB_Reset(&tmpRpInfo);
g_time = 0;
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SSL_MODE_AUTO_RETRY_TC002
* @title UT_TLS_CM_SSL_MODE_AUTO_RETRY_TC002
* @brief
* 1. Create connection. Expected result 1 is obtained.
* 2. Unset the auto retry mode, Send Hello request. Expected result 2 is obtained.
* @expect
* 1. Successfully created connection.
* 2. After receive Hello request and send no_renegotiation alert, the link will not try to read another app message
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SSL_MODE_AUTO_RETRY_TC002()
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
config->isSupportRenegotiation = true;
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
uint32_t len = 0;
ASSERT_TRUE(HITLS_Write(client->ssl, (uint8_t *)"Hello World", strlen("Hello World"), &len) == HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(server->ssl, readBuf, READ_BUF_SIZE, &readLen), HITLS_SUCCESS);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
ASSERT_EQ(HITLS_SetRenegotiationSupport(client->ssl, false), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Renegotiate(server->ssl), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Accept(server->ssl) == HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_ClearModeSupport(client->ssl, HITLS_MODE_AUTO_RETRY) == HITLS_SUCCESS);
g_time = 0;
FuncStubInfo tmpRpInfo = {0};
STUB_Replace(&tmpRpInfo, APP_Read, STUB_APP_Read);
ASSERT_EQ(HITLS_Read(client->ssl, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
STUB_Reset(&tmpRpInfo);
g_time = 0;
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SSL_MODE_MOVE_BUFFER_TC001
* @title UT_TLS_CM_SSL_MODE_MOVE_BUFFER_TC001
* @brief
* 1. Create connection. Expected result 1 is obtained.
* 2. Set moving buffer mode, when io busy, using different buffer retry. Expected result 2 is obtained.
* @expect
* 1. Successfully created connection.
* 2. Retry success.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SSL_MODE_MOVE_BUFFER_TC001()
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
config->isSupportRenegotiation = true;
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config, 1), HITLS_SUCCESS);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_SetModeSupport(client->ssl, HITLS_MODE_ACCEPT_MOVING_WRITE_BUFFER) == HITLS_SUCCESS);
uint8_t data[] = "hello world";
uint8_t data2[] = "hello world";
uint32_t len = 0;
ASSERT_TRUE(HITLS_Write(client->ssl, data, sizeof(data), &len) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Write(client->ssl, data, sizeof(data), &len) == HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Write(client->ssl, data2, sizeof(data2), &len), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SSL_MODE_MOVE_BUFFER_TC002
* @title UT_TLS_CM_SSL_MODE_MOVE_BUFFER_TC002
* @brief
* 1. Create connection. Expected result 1 is obtained.
* 2. Set moving buffer mode, when io busy, using shorter buffer retry. Expected result 2 is obtained.
* @expect
* 1. Successfully created connection.
* 2. Send alert. Before send alert, flush the out buffer first.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SSL_MODE_MOVE_BUFFER_TC002()
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
config->isSupportRenegotiation = true;
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config, 1), HITLS_SUCCESS);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_SetModeSupport(client->ssl, HITLS_MODE_ACCEPT_MOVING_WRITE_BUFFER) == HITLS_SUCCESS);
uint8_t data[] = "hello world";
uint32_t len = 0;
ASSERT_TRUE(HITLS_Write(client->ssl, data, sizeof(data), &len) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Write(client->ssl, data, sizeof(data), &len) == HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(server->ssl, readBuf, READ_BUF_SIZE, &readLen), HITLS_SUCCESS);
ASSERT_TRUE(readLen == sizeof(data));
ASSERT_TRUE(memcmp("hello world", readBuf, readLen) == 0);
ASSERT_EQ(HITLS_Write(client->ssl, data, 1, &len), HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(client->ssl->state, CM_STATE_ALERTING);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Read(server->ssl, readBuf, READ_BUF_SIZE, &readLen), HITLS_SUCCESS);
ASSERT_EQ(server->ssl->state, CM_STATE_TRANSPORTING);
ASSERT_EQ(HITLS_Write(client->ssl, data, 1, &len), HITLS_CM_LINK_FATAL_ALERTED);
ASSERT_EQ(client->ssl->state, CM_STATE_ALERTED);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Read(server->ssl, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ASSERT_EQ(server->ssl->state, CM_STATE_ALERTED);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SSL_MODE_RELEASE_BUFFER_TC001
* @title UT_TLS_CM_SSL_MODE_RELEASE_BUFFER_TC001
* @brief
* 1. Set release buffer mode. Create connection. Expected result 1 is obtained.
* @expect
* 1. Successfully created connection.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SSL_MODE_RELEASE_BUFFER_TC001()
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
config->isSupportRenegotiation = true;
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config, 1), HITLS_SUCCESS);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(HITLS_SetModeSupport(client->ssl, HITLS_MODE_RELEASE_BUFFERS) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_SetModeSupport(server->ssl, HITLS_MODE_RELEASE_BUFFERS) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
uint32_t len = 0;
ASSERT_TRUE(HITLS_Write(client->ssl, (uint8_t *)"Hello World", strlen("Hello World"), &len) == HITLS_SUCCESS);
ASSERT_EQ(FRAME_TrasferMsgBetweenLink(client, server), HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Read(server->ssl, readBuf, READ_BUF_SIZE, &readLen), HITLS_SUCCESS);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_frame_ssl_mode.c
|
C
|
unknown
| 13,843
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <unistd.h>
#include <stdbool.h>
#include <semaphore.h>
#include "securec.h"
#include "hlt.h"
#include "logger.h"
#include "hitls_config.h"
#include "hitls_cert_type.h"
#include "crypt_util_rand.h"
#include "helper.h"
#include "hitls.h"
#include "alert.h"
#include "hitls_type.h"
#include "frame_tls.h"
#include "frame_link.h"
#include "frame_io.h"
#include "parser_frame_msg.h"
#include "pack_frame_msg.h"
#include "rec_wrapper.h"
#include "common_func.h"
#include "stub_crypt.h"
/* END_HEADER */
/* @
* @test SDV_TLS_CFG_SET_TLS_FALLBACK_SCSV_TC001
* @title Test the behavior of the server when it receives the TLS_FALLBACK_SCSV algorithm suite carried by the lower version of clienthello.
* @brief 1. the client creates the config of tls12, and the server creates the config of tls13.Expect result 1.
* 2. the client sets HITLS_MODE_SEND_FALLBACK_SCSV.expect result 2.
* 3. connection establishment, Expect result 3.
* @expect 1. The config object is successfully created.
* 2. return HITLS_SUCCES.
* 3. Failed to establish connection, send alert ALERT_INAPPROPRIATE_FALLBACK.
@ */
/* BEGIN_CASE */
void SDV_TLS_CFG_SET_TLS_FALLBACK_SCSV_TC001(int isSetMode)
{
#ifdef HITLS_TLS_FEATURE_MODE
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, 18256, false);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS_ALL, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
if (isSetMode) {
HLT_SetModeSupport(clientCtxConfig, HITLS_MODE_SEND_FALLBACK_SCSV);
}
clientRes = HLT_ProcessTlsInit(localProcess, TLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
HLT_TlsConnect(clientRes->ssl);
// Wait the remote.
int ret = HLT_GetTlsAcceptResult(serverRes);
if (isSetMode) {
ASSERT_EQ(ret, HITLS_MSG_HANDLE_ERR_INAPPROPRIATE_FALLBACK);
ALERT_Info alertInfo = { 0 };
ALERT_GetInfo(clientRes->ssl, &alertInfo);
ASSERT_EQ(alertInfo.flag, ALERT_FLAG_RECV);
ASSERT_EQ(alertInfo.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(alertInfo.description, ALERT_INAPPROPRIATE_FALLBACK);
} else {
ASSERT_EQ(ret, HITLS_SUCCESS);
}
EXIT:
HLT_FreeAllProcess();
#endif
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_SET_TLS_FALLBACK_SCSV_TC001
* @title Test the behavior of the server when it receives the TLS_FALLBACK_SCSV algorithm suite carried by the
* lower version of clienthello.
* @brief 1. the client creates the config of tls12, and the server creates the config of tls13.Expect result 1.
* 2. the client sets HITLS_MODE_SEND_FALLBACK_SCSV.expect result 2.
* 3. connection establishment, Expect result 3.
* @expect 1. The config object is successfully created.
* 2. return HITLS_SUCCES.
* 3. Failed to establish connection, send alert ALERT_INAPPROPRIATE_FALLBACK.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_TLS_FALLBACK_SCSV_TC001(int isSetMode)
{
#ifdef HITLS_TLS_FEATURE_MODE
FRAME_Init();
HITLS_Config *c_config = NULL;
HITLS_Config *s_config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
c_config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(c_config != NULL);
if (isSetMode) {
HITLS_CFG_SetModeSupport(c_config, HITLS_MODE_SEND_FALLBACK_SCSV);
}
s_config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(s_config != NULL);
client = FRAME_CreateLink(c_config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(s_config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
int32_t ret = FRAME_CreateConnection(client, server, true, HS_STATE_BUTT);
if (isSetMode) {
ASSERT_EQ(ret, HITLS_MSG_HANDLE_ERR_INAPPROPRIATE_FALLBACK);
ALERT_Info info = { 0 };
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_INAPPROPRIATE_FALLBACK);
} else {
ASSERT_EQ(ret, HITLS_SUCCESS);
}
EXIT:
HITLS_CFG_FreeConfig(c_config);
HITLS_CFG_FreeConfig(s_config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
#endif
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_SET_TLS_FALLBACK_SCSV_TC002
* @title Test the behavior of the server when it disables tls13 and receives the TLS_FALLBACK_SCSV algorithm suite
* carried by the lower version of clienthello.
* @brief 1. the client creates the config of tls12, and the server creates the config of tlsall.Expect result 1.
* 2. the client sets HITLS_MODE_SEND_FALLBACK_SCSV. The server disables tls13. expect result 2.
* 3. connection establishment, Expect result 3.
* @expect 1. The config object is successfully created.
* 2. return HITLS_SUCCES.
* 3. return HITLS_SUCCES.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_TLS_FALLBACK_SCSV_TC002()
{
#ifdef HITLS_TLS_FEATURE_MODE
FRAME_Init();
HITLS_Config *c_config = NULL;
HITLS_Config *s_config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
c_config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(c_config != NULL);
HITLS_CFG_SetModeSupport(c_config, HITLS_MODE_SEND_FALLBACK_SCSV);
s_config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(s_config != NULL);
ASSERT_TRUE(HITLS_CFG_SetVersionForbid(s_config, TLS13_VERSION_BIT) == HITLS_SUCCESS);
client = FRAME_CreateLink(c_config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(s_config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
int32_t ret = FRAME_CreateConnection(client, server, true, HS_STATE_BUTT);
ASSERT_EQ(ret, HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(c_config);
HITLS_CFG_FreeConfig(s_config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
#endif
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_frame_tls_fallback_scsv_rfc7507.c
|
C
|
unknown
| 6,901
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <unistd.h>
#include <stdbool.h>
#include <semaphore.h>
#include "securec.h"
#include "hlt.h"
#include "logger.h"
#include "hitls_config.h"
#include "hitls_cert_type.h"
#include "crypt_util_rand.h"
#include "helper.h"
#include "hitls.h"
#include "frame_tls.h"
#include "hitls_type.h"
#include "rec_wrapper.h"
#include "hs_ctx.h"
#include "tls.h"
#include "hitls_config.h"
#include "alert.h"
#define READ_BUF_LEN_18K (18 * 1024)
/* END_HEADER */
static uint32_t g_uiPort = 16888;
static uint32_t retry_count = 0;
int32_t cert_callback(HITLS_Ctx *ctx, void *arg)
{
(void)ctx;
uint32_t *num = arg;
if (*num == 3) {
return HITLS_CERT_CALLBACK_FAILED;
}
if ((*num)++ == 0) {
return HITLS_CERT_CALLBACK_RETRY;
}
return HITLS_CERT_CALLBACK_SUCCESS;
}
/**
* @test SDV_TLS_CERT_CALLBACK_FUNC_TC01
* @title cert Callback Function Test Case 1
* @precon nan
* @brief Server sets the cert callback function, and the cert callback function return HITLS_CERT_CALLBACK_FAILED.
* establish a TLS connection between the client and server, expect result 1.
* @expect 1. The server returns HITLS_CALLBACK_CERT_ERROR.
*/
/* BEGIN_CASE */
void SDV_TLS_CERT_CALLBACK_FUNC_TC01(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
int32_t flag = 3;
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
HLT_SetCertCb(serverCtxConfig, cert_callback, &flag);
ASSERT_TRUE(serverCtxConfig != NULL);
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_2, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes == NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), HITLS_CALLBACK_CERT_ERROR);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/**
* @test SDV_TLS_CERT_CALLBACK_FUNC_TC02
* @title cert Callback Function Test Case 2
* @precon nan
* @brief Server sets the cert callback function, and the cert callback function return HITLS_CERT_CALLBACK_RETRY.
* The cert callback function is called twice, and the second time it returns HITLS_CERT_CALLBACK_SUCCESS.
* establish a TLS connection between the client and server, expect result 1.
* @expect 1. The server returns HITLS_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_TLS_CERT_CALLBACK_FUNC_TC02(int version)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
HLT_SetCertCb(serverCtxConfig, cert_callback, &retry_count);
ASSERT_TRUE(serverCtxConfig != NULL);
serverRes = HLT_ProcessTlsAccept(localProcess, version, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
clientRes = HLT_ProcessTlsConnect(remoteProcess, version, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), HITLS_SUCCESS);
ASSERT_EQ(retry_count, 2);
EXIT:
HLT_FreeAllProcess();
retry_count = 0;
}
/* END_CASE */
/**
* @test SDV_TLS_CERT_CALLBACK_FUNC_TC03
* @title cert Callback Function Test Case 3
* @precon nan
* @brief Client sets the cert callback function, and the cert callback function return HITLS_CERT_CALLBACK_RETRY.
* Server set client verify support, The cert callback function is called twice,
* and the second time it returns HITLS_CERT_CALLBACK_SUCCESS.
* establish a TLS connection between the client and server, expect result 1.
* @expect 1. The link establishment is successful and cert callback function is called twice.
*/
/* BEGIN_CASE */
void SDV_TLS_CERT_CALLBACK_FUNC_TC03(int version)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(localProcess != NULL);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
HLT_SetClientVerifySupport(serverCtxConfig, true);
serverRes = HLT_ProcessTlsAccept(remoteProcess, version, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_SetClientVerifySupport(clientCtxConfig, true);
HLT_SetCertCb(clientCtxConfig, cert_callback, &retry_count);
clientRes = HLT_ProcessTlsConnect(localProcess, version, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(retry_count, 2);
EXIT:
HLT_FreeAllProcess();
retry_count = 0;
}
/* END_CASE */
/**
* @test SDV_TLS_CERT_CALLBACK_FUNC_TC04
* @title cert Callback Function Test Case 4
* @precon nan
* @brief Client sets the cert callback function, and the cert callback function return HITLS_CERT_CALLBACK_RETRY.
* Server set client verify support and post handshake auth, The cert callback function is called twice,
* and the second time it returns HITLS_CERT_CALLBACK_SUCCESS.
* establish a TLS connection between the client and server, expect result 1.
* @expect 1. The link establishment is successful and cert callback function is called twice.
*/
/* BEGIN_CASE */
void SDV_TLS_CERT_CALLBACK_FUNC_TC04(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(localProcess != NULL);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
HLT_SetClientVerifySupport(serverCtxConfig, true);
HLT_SetPostHandshakeAuth(serverCtxConfig, true);
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_SetClientVerifySupport(clientCtxConfig, true);
HLT_SetPostHandshakeAuth(clientCtxConfig, true);
HLT_SetCertCb(clientCtxConfig, cert_callback, &retry_count);
clientRes = HLT_ProcessTlsConnect(localProcess, TLS1_3, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(retry_count, 0);
ASSERT_TRUE(HLT_RpcTlsVerifyClientPostHandshake(remoteProcess, serverRes->sslId) == HITLS_SUCCESS);
uint8_t readBuf[READ_BUF_LEN_18K] = {0};
uint32_t readLen;
ASSERT_TRUE(HLT_ProcessTlsWrite(remoteProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")) == 0);
ASSERT_EQ(HLT_ProcessTlsRead(localProcess, clientRes, readBuf, READ_BUF_LEN_18K, &readLen), 0);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
ASSERT_EQ(retry_count, 2);
EXIT:
HLT_FreeAllProcess();
retry_count = 0;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_hlt_cert_cb.c
|
C
|
unknown
| 8,648
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <unistd.h>
#include <stdbool.h>
#include <semaphore.h>
#include "securec.h"
#include "hlt.h"
#include "logger.h"
#include "hitls_config.h"
#include "hitls_cert_type.h"
#include "crypt_util_rand.h"
#include "helper.h"
#include "hitls.h"
#include "frame_tls.h"
#include "hitls_type.h"
#include "rec_wrapper.h"
#include "hs_ctx.h"
#include "tls.h"
#include "hitls_config.h"
#include "alert.h"
#define READ_BUF_LEN_18K (18 * 1024)
/* END_HEADER */
static uint32_t g_uiPort = 16888;
static uint32_t retry_count = 0;
int32_t client_hello_test_renegotiation_callback(HITLS_Ctx *ctx, int32_t *alert, void *arg)
{
(void)arg;
uint8_t verifyData[MAX_DIGEST_SIZE] = {0};
uint32_t verifyDataSize = 0;
HITLS_GetFinishVerifyData(ctx, verifyData, sizeof(verifyData), &verifyDataSize);
if (verifyDataSize != 0) {
*alert = ALERT_NO_RENEGOTIATION;
return HITLS_CLIENT_HELLO_FAILED;
}
HITLS_GetPeerFinishVerifyData(ctx, verifyData, sizeof(verifyData), &verifyDataSize);
if (verifyDataSize != 0) {
*alert = ALERT_NO_RENEGOTIATION;
return HITLS_CLIENT_HELLO_FAILED;
}
return HITLS_CLIENT_HELLO_SUCCESS;
}
int32_t client_hello_callback(HITLS_Ctx *ctx, int32_t *alert, void *arg)
{
(void)ctx;
uint32_t *num = arg;
*alert = ALERT_INTERNAL_ERROR;
if ((*num)++ == 0) {
return HITLS_CLIENT_HELLO_RETRY;
}
return HITLS_CLIENT_HELLO_SUCCESS;
}
int32_t full_client_hello_callback(HITLS_Ctx *ctx, int32_t *alert, void *arg)
{
uint16_t *cipher;
uint16_t cipherLen;
uint16_t *exts;
uint8_t extLen;
uint8_t *random;
uint8_t randomLen;
uint8_t *extBuff;
uint32_t extBuffLen;
uint32_t *num = arg;
const uint16_t expected_ciphers[] = {0xc02c, 0x00ff};
const uint16_t expected_extensions[] = {13, 10, 11, 23, 22};
*alert = ALERT_INTERNAL_ERROR;
if (*num == 0) {
return HITLS_CLIENT_HELLO_RETRY;
}
if (*num == 1) {
return HITLS_CLIENT_HELLO_FAILED;
}
/* Make sure we can defer processing and get called back. */
ASSERT_TRUE(HITLS_ClientHelloGetRandom(ctx, &random, &randomLen) == HITLS_SUCCESS);
ASSERT_TRUE(random != NULL);
ASSERT_TRUE(randomLen == 32);
ASSERT_TRUE(HITLS_ClientHelloGetCiphers(ctx, &cipher, &cipherLen) == HITLS_SUCCESS);
ASSERT_TRUE(cipher != NULL);
ASSERT_TRUE(cipherLen != 0);
// Compare expected_ciphers and cipher
ASSERT_TRUE(cipherLen == sizeof(expected_ciphers) / sizeof(expected_ciphers[0]));
ASSERT_EQ(memcmp(cipher, expected_ciphers, cipherLen * sizeof(uint16_t)), 0);
ASSERT_TRUE(HITLS_ClientHelloGetExtensionsPresent(ctx, &exts, &extLen) == HITLS_SUCCESS);
ASSERT_TRUE(exts != NULL);
ASSERT_TRUE(extLen != 0);
// Compare expected_extensions and exts
ASSERT_TRUE(extLen == sizeof(expected_extensions) / sizeof(expected_extensions[0]));
for (uint16_t i = 0; i < extLen; ++i) {
ASSERT_TRUE(exts[i] == expected_extensions[i]);
}
BSL_SAL_FREE(exts);
ASSERT_TRUE(HITLS_ClientHelloGetExtension(ctx, 13, &extBuff, &extBuffLen) == HITLS_SUCCESS);
ASSERT_TRUE(extBuff != NULL);
ASSERT_TRUE(extBuffLen != 0);
return HITLS_CLIENT_HELLO_SUCCESS;
EXIT:
return HITLS_CLIENT_HELLO_FAILED;
}
/**
* @test SDV_TLS_CLIENT_HELLO_CALLBACK_FUNC_TC01
* @title Client Hello Callback Function Test Case 1
* @precon nan
* @brief Server sets the client hello callback function, and the client hello callback function
* return HITLS_CLIENT_HELLO_FAILED.
* establish a TLS connection between the client and server, expect result 1.
* @expect 1. The server returns HITLS_CALLBACK_CLIENT_HELLO_ERROR.
*/
/* BEGIN_CASE */
void SDV_TLS_CLIENT_HELLO_CALLBACK_FUNC_TC01(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
int32_t flag = 1;
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
;
HLT_SetClientHelloCb(serverCtxConfig, full_client_hello_callback, &flag);
ASSERT_TRUE(serverCtxConfig != NULL);
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_2, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes == NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), HITLS_CALLBACK_CLIENT_HELLO_ERROR);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/**
* @test SDV_TLS_CLIENT_HELLO_CALLBACK_FUNC_TC02
* @title Client Hello Callback Function Test Case 2
* @precon nan
* @brief Server sets the client hello callback function, and the client hello callback function
* return HITLS_CLIENT_HELLO_SUCCESS.
* establish a TLS connection between the client and server, expect result 1.
* @expect 1. The server returns HITLS_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_TLS_CLIENT_HELLO_CALLBACK_FUNC_TC02(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
int32_t flag = 2;
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
HLT_SetClientHelloCb(serverCtxConfig, full_client_hello_callback, &flag);
ASSERT_TRUE(serverCtxConfig != NULL);
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_2, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_SetCipherSuites(clientCtxConfig, "HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384");
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), HITLS_SUCCESS);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/**
* @test SDV_TLS_CLIENT_HELLO_CALLBACK_FUNC_TC03
* @title Client Hello Callback Function Test Case 3
* @precon nan
* @brief Server sets the client hello callback function, and the client hello callback function
* return HITLS_CLIENT_HELLO_RETRY. The client hello callback function is called twice,
* and the second time it returns HITLS_CLIENT_HELLO_SUCCESS.
* establish a TLS connection between the client and server, expect result 1.
* @expect 1. The server returns HITLS_SUCCESS.
*/
/* BEGIN_CASE */
void SDV_TLS_CLIENT_HELLO_CALLBACK_FUNC_TC03(int version)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
;
HLT_SetClientHelloCb(serverCtxConfig, client_hello_callback, &retry_count);
ASSERT_TRUE(serverCtxConfig != NULL);
serverRes = HLT_ProcessTlsAccept(localProcess, version, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
clientRes = HLT_ProcessTlsConnect(remoteProcess, version, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), HITLS_SUCCESS);
ASSERT_EQ(retry_count, 2);
EXIT:
HLT_FreeAllProcess();
retry_count = 0;
}
/* END_CASE */
/**
* @test SDV_TLS_CLIENT_HELLO_CALLBACK_FUNC_TC04
* @title Client Hello Callback Function Test Case 4
* @precon nan
* @brief Server sets the client hello callback function, and the client hello callback function
* return HITLS_CLIENT_HELLO_SUCCESS.
* On renegotiation, the client hello callback returns HITLS_CLIENT_HELLO_FAILED.
* The server supports renegotiation, and the client does not support renegotiation.
* establish a TLS connection between the client and server, expect result 1.
* server starts renegotiation, and the client hello callback function returns HITLS_CLIENT_HELLO_FAILED.
* expect result 2.
* @expect 1. The link establishment is successful.
* 2. The server returns ALERT_NO_RENEGOTIATION.
*/
/* BEGIN_CASE */
void SDV_TLS_CLIENT_HELLO_CALLBACK_FUNC_TC04(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
;
HLT_SetClientHelloCb(serverCtxConfig, client_hello_test_renegotiation_callback, &retry_count);
ASSERT_TRUE(serverCtxConfig != NULL);
HLT_SetRenegotiationSupport(serverCtxConfig, true);
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_2, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_SetRenegotiationSupport(clientCtxConfig, true);
HLT_SetLegacyRenegotiateSupport(clientCtxConfig, true);
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
uint8_t readBuf[READ_BUF_LEN_18K] = {0};
uint32_t readLen;
ASSERT_TRUE(HLT_ProcessTlsWrite(localProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")) == 0);
ASSERT_TRUE(HLT_ProcessTlsRead(remoteProcess, clientRes, readBuf, READ_BUF_LEN_18K, &readLen) == 0);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
ASSERT_EQ(HITLS_Renegotiate(serverRes->ssl), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(serverRes->ssl), HITLS_SUCCESS);
ASSERT_EQ(HLT_ProcessTlsRead(remoteProcess, clientRes, readBuf, READ_BUF_LEN_18K, &readLen),
HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(HLT_ProcessTlsRead(localProcess, serverRes, readBuf, READ_BUF_LEN_18K, &readLen),
HITLS_CALLBACK_CLIENT_HELLO_ERROR);
ALERT_Info info = {0};
ALERT_GetInfo(serverRes->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_NO_RENEGOTIATION);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/**
* @test SDV_TLS_CLIENT_HELLO_CALLBACK_FUNC_TC05
* @title Client Hello Callback Function Test Case 5
* @precon nan
* @brief Server sets the client hello callback function, and the client hello callback function return
* HITLS_CLIENT_HELLO_RETRY.
* The client hello callback function is called three times, and the third time it returns
* HITLS_CLIENT_HELLO_SUCCESS.
* establish a TLS connection between the client and server, expect result 1.
* @expect 1. The server returns HITLS_SUCCESS.
* 2. The client hello callback function is called three times.
* 3. The retry_count is 3.
*/
/* BEGIN_CASE */
void SDV_TLS_CLIENT_HELLO_CALLBACK_FUNC_TC05(void)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
HLT_SetClientHelloCb(serverCtxConfig, client_hello_callback, &retry_count);
HLT_SetGroups(serverCtxConfig, "HITLS_EC_GROUP_SECP256R1");
ASSERT_TRUE(serverCtxConfig != NULL);
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_3, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
HLT_SetGroups(clientCtxConfig, "HITLS_EC_GROUP_CURVE25519:HITLS_EC_GROUP_SECP256R1:HITLS_EC_GROUP_SECP384R1");
ASSERT_TRUE(clientCtxConfig != NULL);
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_3, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_GetTlsAcceptResult(serverRes), HITLS_SUCCESS);
ASSERT_EQ(retry_count, 3);
EXIT:
HLT_FreeAllProcess();
retry_count = 0;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_hlt_clienthello_cb.c
|
C
|
unknown
| 13,698
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <unistd.h>
#include <stdbool.h>
#include <semaphore.h>
#include "securec.h"
#include "hlt.h"
#include "logger.h"
#include "hitls_config.h"
#include "hitls_cert_type.h"
#include "crypt_util_rand.h"
#include "helper.h"
#include "hitls.h"
#include "frame_tls.h"
#include "hitls_type.h"
#include "rec_wrapper.h"
#include "hs_ctx.h"
#include "tls.h"
/* END_HEADER */
#define READ_BUF_LEN_18K (18 * 1024)
#define PORT 10087
static void Test_MultiKeyShare(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len,
uint32_t bufSize, void *user)
{
(void)bufSize;
(void)user;
(void)data;
(void)*len;
if (ctx->hsCtx->haveHrr) {
*(bool *)user = true;
} else {
*(bool *)user = false;
}
return;
}
/* BEGIN_CASE */
void SDV_TLS13_MULTI_KEYSHARE_TC001()
{
bool haveHrr = false;
HLT_Process *localProcess = HLT_InitLocalProcess(HITLS);
HLT_Process *remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, PORT, true);
ASSERT_TRUE(localProcess != NULL);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(serverCtxConfig != NULL);
ASSERT_TRUE(clientCtxConfig != NULL);
bool testHrr = true;
RecWrapper wrapper = {
TRY_SEND_FINISH,
REC_TYPE_HANDSHAKE,
false,
&testHrr,
Test_MultiKeyShare
};
RegisterWrapper(wrapper);
HLT_SetGroups(serverCtxConfig, "HITLS_EC_GROUP_SECP256R1");
HLT_SetGroups(clientCtxConfig, "X25519MLKEM768:HITLS_EC_GROUP_SECP256R1");
HLT_Tls_Res *serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_3, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Tls_Res *clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_3, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_EQ(testHrr, haveHrr);
ASSERT_TRUE(HLT_ProcessTlsWrite(localProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")) == 0);
uint8_t readBuf[READ_BUF_LEN_18K] = {0};
uint32_t readLen;
ASSERT_TRUE(HLT_ProcessTlsRead(remoteProcess, clientRes, readBuf, READ_BUF_LEN_18K, &readLen) == 0);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
EXIT:
HLT_FreeAllProcess();
ClearWrapper();
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_hlt_multi_keyshare.c
|
C
|
unknown
| 3,027
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <unistd.h>
#include <stdbool.h>
#include <semaphore.h>
#include "securec.h"
#include "hlt.h"
#include "logger.h"
#include "hitls_config.h"
#include "hitls_cert_type.h"
#include "crypt_util_rand.h"
#include "helper.h"
#include "hitls.h"
#include "frame_tls.h"
#include "hitls_type.h"
/* END_HEADER */
#define READ_BUF_LEN_18K (18 * 1024)
#define PORT 10087
/* BEGIN_CASE */
void SDV_TLS13_PROVIDER_NEW_GROUP_SIGNALG_TC001(char *path, char *providerName, int providerLibFmt, char *group,
char *signAlg, char *rootCa, char *interCa, char *serverCert, char *serverKey, char *clientCert, char *clientKey)
{
#ifndef HITLS_TLS_FEATURE_PROVIDER
(void)path;
(void)providerName;
(void)providerLibFmt;
(void)group;
(void)signAlg;
(void)rootCa;
(void)interCa;
(void)serverCert;
(void)serverKey;
(void)clientCert;
(void)clientKey;
SKIP_TEST();
#else
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Ctx_Config *serverCtxConfig = NULL;
HLT_Ctx_Config *clientCtxConfig = NULL;
HLT_Process *localProcess = HLT_InitLocalProcess(HITLS);
HLT_Process *remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, PORT, true);
ASSERT_TRUE(localProcess != NULL);
ASSERT_TRUE(remoteProcess != NULL);
serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(serverCtxConfig != NULL);
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_SetProviderPath(serverCtxConfig, path);
HLT_SetProviderAttrName(serverCtxConfig, NULL);
HLT_SetProviderPath(clientCtxConfig, path);
HLT_SetProviderAttrName(clientCtxConfig, NULL);
HLT_AddProviderInfo(serverCtxConfig, providerName, providerLibFmt);
HLT_AddProviderInfo(serverCtxConfig, "default", BSL_SAL_LIB_FMT_OFF);
HLT_AddProviderInfo(clientCtxConfig, providerName, providerLibFmt);
HLT_AddProviderInfo(clientCtxConfig, "default", BSL_SAL_LIB_FMT_OFF);
/* Set Cert */
HLT_SetCertPath(serverCtxConfig, rootCa, interCa, serverCert, serverKey, "NULL", "NULL");
HLT_SetCertPath(clientCtxConfig, rootCa, interCa, clientCert, clientKey, "NULL", "NULL");
HLT_SetGroups(serverCtxConfig, group); // For kex or kem group
HLT_SetGroups(clientCtxConfig, group); // For kex or kem group
HLT_SetSignature(serverCtxConfig, signAlg);
HLT_SetSignature(clientCtxConfig, signAlg);
HLT_SetCipherSuites(serverCtxConfig, "HITLS_AES_128_GCM_SHA256");
HLT_SetCipherSuites(clientCtxConfig, "HITLS_AES_128_GCM_SHA256");
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_3, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_3, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_TRUE(HLT_ProcessTlsWrite(localProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")) == 0);
uint8_t readBuf[READ_BUF_LEN_18K] = {0};
uint32_t readLen;
ASSERT_TRUE(HLT_ProcessTlsRead(remoteProcess, clientRes, readBuf, READ_BUF_LEN_18K, &readLen) == 0);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
EXIT:
HLT_FreeAllProcess();
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_TLS13_PROVIDER_KEM_TC001(char *group)
{
#ifndef HITLS_TLS_FEATURE_PROVIDER
(void)group;
SKIP_TEST();
#else
HLT_Ctx_Config *serverCtxConfig = NULL;
HLT_Ctx_Config *clientCtxConfig = NULL;
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = HLT_InitLocalProcess(HITLS);
HLT_Process *remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, PORT, true);
ASSERT_TRUE(localProcess != NULL);
ASSERT_TRUE(remoteProcess != NULL);
serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(serverCtxConfig != NULL);
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_SetGroups(clientCtxConfig, group); // For kex or kem group
HLT_SetGroups(serverCtxConfig, group); // For kex or kem group
serverRes = HLT_ProcessTlsAccept(remoteProcess, TLS1_3, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(localProcess, TLS1_3, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_TRUE(HLT_ProcessTlsWrite(remoteProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")) == 0);
uint8_t readBuf[READ_BUF_LEN_18K] = {0};
uint32_t readLen;
ASSERT_TRUE(HLT_ProcessTlsRead(localProcess, clientRes, readBuf, READ_BUF_LEN_18K, &readLen) == 0);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
EXIT:
HLT_FreeAllProcess();
#endif
}
/* END_CASE */
/* BEGIN_CASE */
void SDV_TLS13_MULTI_PROVIDER_TC001(char *path, char *providerName, char *attrName, int providerLibFmt)
{
#ifndef HITLS_TLS_FEATURE_PROVIDER
(void)path;
(void)providerName;
(void)attrName;
(void)providerLibFmt;
SKIP_TEST();
#else
(void)path;
(void)providerName;
(void)attrName;
(void)providerLibFmt;
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Ctx_Config *serverCtxConfig = NULL;
HLT_Ctx_Config *clientCtxConfig = NULL;
HLT_Process *localProcess = HLT_InitLocalProcess(HITLS);
HLT_Process *remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, PORT, true);
ASSERT_TRUE(localProcess != NULL);
ASSERT_TRUE(remoteProcess != NULL);
serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(serverCtxConfig != NULL);
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_SetProviderPath(serverCtxConfig, path);
HLT_SetProviderAttrName(serverCtxConfig, attrName);
HLT_AddProviderInfo(serverCtxConfig, providerName, providerLibFmt);
HLT_AddProviderInfo(serverCtxConfig, "default", BSL_SAL_LIB_FMT_OFF);
HLT_SetCipherSuites(serverCtxConfig, "HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256");
HLT_SetCipherSuites(clientCtxConfig, "HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256");
serverRes = HLT_ProcessTlsAccept(localProcess, TLS1_2, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
clientRes = HLT_ProcessTlsConnect(remoteProcess, TLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_TRUE(HLT_ProcessTlsWrite(localProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")) == 0);
uint8_t readBuf[READ_BUF_LEN_18K] = {0};
uint32_t readLen;
ASSERT_TRUE(HLT_ProcessTlsRead(remoteProcess, clientRes, readBuf, READ_BUF_LEN_18K, &readLen) == 0);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
EXIT:
HLT_FreeAllProcess();
#endif
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_hlt_provider.c
|
C
|
unknown
| 7,616
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include "hlt.h"
#include "securec.h"
#include "process.h"
#include "session.h"
#include "hitls_config.h"
#include "hitls_crypt_init.h"
/* END_HEADER */
#define READ_BUF_SIZE (18 * 1024)
/** @
* @test SDV_TLS12_RESUME_FUNC_TC001
* @title Test the PSK-based session resume of tls12.
*
* @brief 1. at first handshake, config the client does not support tickets,
but the server supports tickets. Expect result 1
2. after first handshake, config the client support tickets, Expect result 2
* @expect 1. connect success
2. resume success
@ */
/* BEGIN_CASE */
void SDV_TLS12_RESUME_FUNC_TC001()
{
int version = TLS1_2;
int connType = TCP;
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
HITLS_Session *session = NULL;
int32_t cnt = 0;
int32_t serverConfigId = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
void *clientConfig = HLT_TlsNewCtx(version);
ASSERT_TRUE(clientConfig != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
clientCtxConfig->isSupportSessionTicket = false;
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
serverCtxConfig->isSupportSessionTicket = true;
HLT_SetPsk(clientCtxConfig, "123456789");
HLT_SetPsk(serverCtxConfig, "123456789");
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, version, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
#endif
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
do {
DataChannelParam channelParam;
channelParam.port = 18889;
channelParam.type = connType;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = connType;
localProcess->connType = connType;
if (cnt > 0) {
clientCtxConfig->isSupportSessionTicket = true;
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
}
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = connType;
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = connType;
HLT_TlsSetSsl(clientSsl, clientSslConfig);
if (session != NULL) {
ASSERT_TRUE(HITLS_SetSession(clientSsl, session) == HITLS_SUCCESS);
}
if (cnt == 0) {
ASSERT_TRUE(HLT_TlsConnect(clientSsl) == 0);
} else {
int ret = HLT_TlsConnect(clientSsl);
ASSERT_EQ(ret, HITLS_SUCCESS);
uint8_t isReused = 0;
ASSERT_TRUE(HITLS_IsSessionReused(clientSsl, &isReused) == HITLS_SUCCESS);
ASSERT_EQ(isReused, 1);
}
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_RpcTlsClose(remoteProcess, serverSslId);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
HITLS_SESS_Free(session);
session = HITLS_GetDupSession(clientSsl);
ASSERT_TRUE(session != NULL);
cnt++;
} while (cnt < 3);
EXIT:
HITLS_SESS_Free(session);
HLT_FreeAllProcess();
}
/* END_CASE */
/* @
* @test SDV_HITLS_TICKET_KEY_CALLBACK_RESUME_FUNC_TC001
* @spec -
* @title Verifying the session resumption scenario after the session ticket key callback function is configured
* @precon nan
* @brief
1. The bottom-layer connection is established.
2. Register the session ticket key callback on the server.
3. After the first handshake is complete, obtain and store the session.
4. Configure the session in the SSL, resume the session, and obtain the session again.
5. Repeat step 4. Expected result 5 is obtained.
* @expect
1. Return success
2. The registration is successful.
3. The handshake has completed and the session is obtained successfully.
4. The session is successfully configured, resumed, and obtained.
5. The session is successfully configured, resumed, and obtained.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void SDV_HITLS_TICKET_KEY_CALLBACK_RESUME_FUNC_TC001(int version, int connType, char *ticketKeyCb)
{
Process *localProcess = NULL;
Process *remoteProcess = NULL;
HLT_FD sockFd = {0};
int32_t serverConfigId = 0;
HITLS_Session *session = NULL;
const char *writeBuf = "Hello world";
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
int32_t cnt = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_CreateRemoteProcess(HITLS);
ASSERT_TRUE(remoteProcess != NULL);
void *clientConfig = HLT_TlsNewCtx(version);
ASSERT_TRUE(clientConfig != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
clientCtxConfig->isSupportSessionTicket = true;
clientCtxConfig->isSupportRenegotiation = false;
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
serverCtxConfig->isSupportSessionTicket = true;
serverCtxConfig->isSupportRenegotiation = false;
#ifdef HITLS_TLS_FEATURE_PROVIDER
serverConfigId = HLT_RpcProviderTlsNewCtx(remoteProcess, version, false, NULL, NULL, NULL, 0, NULL);
#else
serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
#endif
memcpy_s(clientCtxConfig->psk, PSK_MAX_LEN, "12121212121212", sizeof("12121212121212"));
memcpy_s(serverCtxConfig->psk, PSK_MAX_LEN, "12121212121212", sizeof("12121212121212"));
// Register the session ticket key callback on the server.
HLT_SetTicketKeyCb(serverCtxConfig, ticketKeyCb);
ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
HLT_SetCipherSuites(clientCtxConfig, "HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA");
HLT_SetCipherSuites(serverCtxConfig, "HITLS_ECDHE_PSK_WITH_AES_128_CBC_SHA");
do {
DataChannelParam channelParam;
channelParam.port = 18899;
channelParam.type = connType;
channelParam.isBlock = true;
sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
remoteProcess->connFd = sockFd.peerFd;
localProcess->connFd = sockFd.srcFd;
remoteProcess->connType = connType;
localProcess->connType = connType;
int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
HLT_Ssl_Config *serverSslConfig;
serverSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(serverSslConfig != NULL);
serverSslConfig->sockFd = remoteProcess->connFd;
serverSslConfig->connType = connType;
ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
HLT_RpcTlsAccept(remoteProcess, serverSslId);
void *clientSsl = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientSsl != NULL);
HLT_Ssl_Config *clientSslConfig;
clientSslConfig = HLT_NewSslConfig(NULL);
ASSERT_TRUE(clientSslConfig != NULL);
clientSslConfig->sockFd = localProcess->connFd;
clientSslConfig->connType = connType;
// The bottom-layer connection is established.
HLT_TlsSetSsl(clientSsl, clientSslConfig);
if (session != NULL) {
// Configure the session in the SSL, resume the session, and obtain the session again.
ASSERT_TRUE(HITLS_SetSession(clientSsl, session) == HITLS_SUCCESS);
}
ASSERT_TRUE(HLT_TlsConnect(clientSsl) == 0);
ASSERT_TRUE(HLT_RpcTlsWrite(remoteProcess, serverSslId, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(memset_s(readBuf, READ_BUF_SIZE, 0, READ_BUF_SIZE) == EOK);
ASSERT_TRUE(HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen) == 0);
ASSERT_TRUE(readLen == strlen(writeBuf));
ASSERT_TRUE(memcmp(writeBuf, readBuf, strlen(writeBuf)) == 0);
ASSERT_TRUE(HLT_RpcTlsClose(remoteProcess, serverSslId) == 0);
ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
HLT_TlsRead(clientSsl, readBuf, READ_BUF_SIZE, &readLen);
HLT_RpcTlsRead(remoteProcess, serverSslId, readBuf, READ_BUF_SIZE, &readLen);
HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
HLT_CloseFd(sockFd.srcFd, localProcess->connType);
if (cnt != 0) {
if (strcmp(ticketKeyCb, "ExampleTicketKeyRenewCb") == 0) {
SESS_Disable(session);
}
HITLS_SESS_Free(session);
session = NULL;
uint8_t isReused = 0;
ASSERT_TRUE(HITLS_IsSessionReused(clientSsl, &isReused) == HITLS_SUCCESS);
ASSERT_TRUE(isReused == 1);
}
// After the first handshake is complete, obtain and store the session.
session = HITLS_GetDupSession(clientSsl);
ASSERT_TRUE(session != NULL);
ASSERT_TRUE(HITLS_SESS_HasTicket(session) == true);
ASSERT_TRUE(HITLS_SESS_IsResumable(session) == true);
cnt++;
} while (cnt < 3);
EXIT:
HITLS_SESS_Free(session);
HLT_FreeAllProcess();
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/feature/test_suite_sdv_hlt_session_ticket.c
|
C
|
unknown
| 10,854
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
#include <stddef.h>
#include <sys/types.h>
#include <regex.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/time.h>
#include <linux/ioctl.h>
#include "securec.h"
#include "bsl_sal.h"
#include "sal_net.h"
#include "frame_tls.h"
#include "cert_callback.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_errno.h"
#include "bsl_uio.h"
#include "frame_io.h"
#include "uio_abstraction.h"
#include "tls.h"
#include "tls_config.h"
#include "logger.h"
#include "process.h"
#include "hs_ctx.h"
#include "hlt.h"
#include "stub_replace.h"
#include "hitls_type.h"
#include "frame_link.h"
#include "session_type.h"
#include "common_func.h"
#include "hitls_func.h"
#include "hitls_cert_type.h"
#include "cert_mgr_ctx.h"
#include "parser_frame_msg.h"
#include "recv_process.h"
#include "simulate_io.h"
#include "rec_wrapper.h"
#include "cipher_suite.h"
#include "alert.h"
#include "conn_init.h"
#include "pack.h"
#include "send_process.h"
#include "cert.h"
#include "hitls_cert_reg.h"
#include "hitls_crypt_type.h"
#include "hs.h"
#include "hs_state_recv.h"
#include "app.h"
#include "record.h"
#include "rec_conn.h"
#include "session.h"
#include "frame_msg.h"
#include "pack_frame_msg.h"
#include "cert_mgr.h"
#include "hs_extensions.h"
#include "hlt_type.h"
#include "sctp_channel.h"
#include "hitls_crypt_init.h"
#include "hitls_session.h"
#include "bsl_log.h"
#include "bsl_err.h"
#include "hitls_crypt_reg.h"
#include "crypt_errno.h"
#include "bsl_list.h"
#include "hitls_cert.h"
#include "parse_extensions_client.c"
#include "parse_extensions_server.c"
#include "parse_server_hello.c"
#include "parse_client_hello.c"
/* END_HEADER */
static char *g_serverName = "testServer";
uint32_t g_uiPort = 18888;
#define DEFAULT_DESCRIPTION_LEN 128
#define TLS_DHE_PARAM_MAX_LEN 1024
#define GET_GROUPS_CNT (-1)
#define READ_BUF_SIZE (18 * 1024)
#define ALERT_BODY_LEN 2u
typedef struct {
uint16_t version;
BSL_UIO_TransportType uioType;
HITLS_Config *s_config;
HITLS_Config *c_config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_Session *clientSession;
HITLS_TicketKeyCb serverKeyCb;
} ResumeTestInfo;
int32_t HITLS_RemoveCertAndKey(HITLS_Ctx *ctx);
HITLS_CRYPT_Key *cert_key = NULL;
HITLS_CRYPT_Key *DH_CB(HITLS_Ctx *ctx, int32_t isExport, uint32_t keyLen)
{
(void)ctx;
(void)isExport;
(void)keyLen;
return cert_key;
}
void *STUB_SAL_Calloc(uint32_t num, uint32_t size)
{
(void)num;
(void)size;
return NULL;
}
void *STUB_SAL_Dump(const void *src, uint32_t size)
{
(void)src;
(void)size;
return NULL;
}
FuncStubInfo g_TmpRpInfo = {0};
int32_t STUB_BSL_UIO_Read(BSL_UIO *uio, void *data, uint32_t len, uint32_t *readLen)
{
(void)uio;
(void)data;
(void)len;
(void)readLen;
return 0;
}
static HITLS_Config *GetHitlsConfigViaVersion(int ver)
{
switch (ver) {
case HITLS_VERSION_TLS12:
return HITLS_CFG_NewTLS12Config();
case HITLS_VERSION_TLS13:
return HITLS_CFG_NewTLS13Config();
case HITLS_VERSION_DTLS12:
return HITLS_CFG_NewDTLS12Config();
default:
return NULL;
}
}
/** @
* @test UT_TLS_CM_IS_DTLS_API_TC001
* @title Test HITLS_IsDtls
* @precon nan
* @brief HITLS_IsDtls
* 1. Input an empty TLS connection handle. Expected result 1.
* 2. Transfer the non-empty TLS connection handle information and leave isDtls blank. Expected result 1.
* 3. Transfer the non-empty TLS connection handle information. The isDtls parameter is not empty. Expected result 2 is
* obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_TLS_CM_IS_DTLS_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
uint8_t isDtls = 0;
ASSERT_TRUE(HITLS_IsHandShakeDone(ctx, &isDtls) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_IsHandShakeDone(ctx, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_IsHandShakeDone(ctx, &isDtls) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SET_CLEAR_CIPHERSUITES_API_TC001
* @title Test the HITLS_SetCipherSuites and HITLS_ClearTLS13CipherSuites interfaces.
* @precon nan
* @brief HITLS_SetCipherSuites
* 1. Input an empty TLS connection handle. Expected result 1.
* 2. Transfer non-empty TLS connection handle information and leave cipherSuites empty. Expected result 1.
* 3. Transfer the non-empty TLS connection handle information. If cipherSuites is not empty and cipherSuitesSize is 0,
* the expected result is 1.
* 4. Transfer the non-empty TLS connection handle information. Set cipherSuites to a value greater than
* HITLS_CFG_MAX_SIZE. Expected result 2.
* 5. The input parameters are valid, and the SAL_CALLOC table is instrumented. Expected result 3.
* 6. Transfer the non-null TLS connection handle information, set cipherSuites to an invalid value, and set
* cipherSuitesSize to a value smaller than HITLS_CFG_MAX_SIZE. Expected result 4 is displayed.
* 7. Transfer valid parameters. Expected result 5.
* HITLS_ClearTLS13CipherSuites
* 1. Input an empty TLS connection handle. Expected result 1.
* 2. Transfer the non-empty TLS connection handle information. Expected result 5.
* @expect 1. Returns HITLS_NULL_INPUT
* 2. Return HITLS_HITLS_CM_INVALID_LENGTH
* 3. Returns HITLS_MEMALLOC_FAIL
* 4. Return HITLS_HITLS_CM_NO_SUITABLE_CIPHER_SUITE
* 5. Returns HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_CLEAR_CIPHERSUITES_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
uint16_t cipherSuites[10] = {
HITLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
HITLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
HITLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
HITLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
HITLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
};
ASSERT_TRUE(HITLS_SetCipherSuites(ctx, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t)) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_ClearTLS13CipherSuites(ctx) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetCipherSuites(ctx, NULL, 0) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetCipherSuites(ctx, cipherSuites, 0) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetCipherSuites(ctx, cipherSuites, HITLS_CFG_MAX_SIZE + 1) == HITLS_CONFIG_INVALID_LENGTH);
STUB_Init();
FuncStubInfo tmpRpInfo;
STUB_Replace(&tmpRpInfo, BSL_SAL_Calloc, STUB_SAL_Calloc);
ASSERT_TRUE(
HITLS_SetCipherSuites(ctx, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t)) == HITLS_MEMALLOC_FAIL);
STUB_Reset(&tmpRpInfo);
uint16_t cipherSuites2[10] = {0};
cipherSuites2[0] = 0xFFFF;
cipherSuites2[1] = 0xEFFF;
ASSERT_TRUE(HITLS_SetCipherSuites(ctx, cipherSuites2, sizeof(cipherSuites2) / sizeof(uint16_t)) ==
HITLS_CONFIG_NO_SUITABLE_CIPHER_SUITE);
ASSERT_TRUE(HITLS_SetCipherSuites(ctx, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t)) == HITLS_SUCCESS);
if (tlsVersion == HITLS_VERSION_TLS13) {
ASSERT_TRUE(HITLS_ClearTLS13CipherSuites(ctx) == HITLS_SUCCESS);
ASSERT_TRUE(ctx->config.tlsConfig.tls13cipherSuitesSize == 0);
}
EXIT:
STUB_Reset(&tmpRpInfo);
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SET_GET_ENCRYPTHENMAC_FUNC_TC001
* @title HITLS_GetEncryptThenMac and HITLS_SetEncryptThenMac interface validation
* @precon nan
* @brief
* 1. After initialization, call the hitls_setencryptthenmac interface to set the value to true and call the
* HITLS_GetEncryptThenMac interface to query the value. Expected result 1.
* 2. Set hitls_setencryptthenmac to true at both ends. After the connection is set up, invoke the HITLS_GetEncryptThenMac
* interface to query the connection. Expected result 2.
* @expect
* 1. The return value is true.
* 2. The return value is true.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_GET_ENCRYPTHENMAC_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config, 1), HITLS_SUCCESS);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
uint32_t encryptThenMacType = 0;
ASSERT_EQ(HITLS_GetEncryptThenMac(server->ssl, &encryptThenMacType), HITLS_SUCCESS);
ASSERT_EQ(encryptThenMacType, 1);
ASSERT_EQ(HITLS_GetEncryptThenMac(client->ssl, &encryptThenMacType), HITLS_SUCCESS);
ASSERT_EQ(encryptThenMacType, 1);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_EQ(HITLS_GetEncryptThenMac(server->ssl, &encryptThenMacType), HITLS_SUCCESS);
ASSERT_EQ(encryptThenMacType, 1);
ASSERT_EQ(HITLS_GetEncryptThenMac(client->ssl, &encryptThenMacType), HITLS_SUCCESS);
ASSERT_EQ(encryptThenMacType, 1);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SET_SERVERNAME_FUNC_TC001
* @title HITLS_SetServerName invokes the interface to set the server name.
* @precon nan
* @brief
* 1. Initialize the client and server. Expected result 1
* 2. After the initialization, set the servername and run the HITLS_GetServerName command to check the server name.
* Expected result 2 is displayed
* @expect
* 1. Complete initialization
* 2. The returned result is consistent with the settings
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_SERVERNAME_FUNC_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetServerName(client->ssl, (uint8_t *)g_serverName, (uint32_t)strlen(g_serverName)),
HITLS_SUCCESS);
client->ssl->isClient = true;
const char *server_name = HITLS_GetServerName(client->ssl, HITLS_SNI_HOSTNAME_TYPE);
ASSERT_TRUE(memcmp(server_name, (uint8_t *)g_serverName, strlen(g_serverName)) == 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SET_GET_SESSION_TICKET_SUPPORT_API_TC001
* @title Test the HITLS_SetSessionTicketSupport and HITLS_GetSessionTicketSupport interfaces.
* @precon nan
* @brief HITLS_SetSessionTicketSupport
* 1. Input an empty TLS connection handle. Expected result 1.
* 2. Transfer a non-empty TLS connection handle and set isEnable to an invalid value. Expected result 2.
* 3. Transfer the non-empty TLS connection handle information and set isEnable to a valid value. Expected result 3 is
* obtained.
* HITLS_GetSessionTicketSupport
* 1. Input an empty TLS connection handle. Expected result 1.
* 2. Pass an empty getIsSupport pointer. Expected result 1.
* 3. Transfer the non-null TLS connection handle information and ensure that the getIsSupport pointer is not null.
* Expected result 3.
* @expect 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned and ctx->config.tlsConfig.isSupportSessionTicket is true.
* 3. Returns HITLS_SUCCES and ctx->config.tlsConfig.isSupportSessionTicket is true or false.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_GET_SESSION_TICKET_SUPPORT_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
uint8_t isSupport = -1;
uint8_t getIsSupport = -1;
ASSERT_TRUE(HITLS_SetSessionTicketSupport(ctx, isSupport) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetSessionTicketSupport(ctx, &getIsSupport) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetSessionTicketSupport(ctx, NULL) == HITLS_NULL_INPUT);
isSupport = 1;
ASSERT_TRUE(HITLS_SetSessionTicketSupport(ctx, isSupport) == HITLS_SUCCESS);
isSupport = -1;
ASSERT_TRUE(HITLS_SetSessionTicketSupport(ctx, isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(ctx->config.tlsConfig.isSupportSessionTicket = true);
isSupport = 0;
ASSERT_TRUE(HITLS_SetSessionTicketSupport(ctx, isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetSessionTicketSupport(ctx, &getIsSupport) == HITLS_SUCCESS);
ASSERT_TRUE(getIsSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_VERIFY_CLIENT_POST_HANDSHAKE_API_TC001
* @title Invoke the HITLS_VerifyClientPostHandshake interface during connection establishment.
* @precon nan
* @brief
* 1. Apply for and initialize the configuration file. Expected result 1.
* 2. Configure the client and server to support post-handshake extension. Expected result 3.
* 3. When a connection is established, the server is in the Try_RECV_CLIENT_HELLO state, and the
* HITLS_VerifyClientPostHandshake interface is invoked.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. The interface fails to be invoked.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_VERIFY_CLIENT_POST_HANDSHAKE_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
// Apply for and initialize the configuration file
config = HITLS_CFG_NewTLS13Config();
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
// Configure the client and server to support post-handshake extension
client->ssl->config.tlsConfig.isSupportPostHandshakeAuth = true;
server->ssl->config.tlsConfig.isSupportPostHandshakeAuth = true;
ASSERT_TRUE(client->ssl->config.tlsConfig.isSupportPostHandshakeAuth == true);
ASSERT_TRUE(server->ssl->config.tlsConfig.isSupportPostHandshakeAuth == true);
// he server is in the Try_RECV_CLIENT_HELLO state
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_RECV_CLIENT_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(server->ssl->hsCtx->state == TRY_RECV_CLIENT_HELLO);
// the HITLS_VerifyClientPostHandshake interface is invoked
ASSERT_EQ(HITLS_VerifyClientPostHandshake(client->ssl), HITLS_INVALID_INPUT);
ASSERT_EQ(HITLS_VerifyClientPostHandshake(server->ssl), HITLS_MSG_HANDLE_STATE_ILLEGAL);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_REMOVE_CERTANDKEY_API_TC001
* @title Test the HITLS_RemoveCertAndKey interface.
* @brief
* 1. Apply for and initialize the configuration file. Expected result 1.
* 2. Invoke the client HITLS_CFG_SetClientVerifySupport and HITLS_CFG_SetNoClientCertSupport. Expected result 2.
* 3. Invoke the HITLS_RemoveCertAndKey, Expected result 3.
* @expect
* 1. The initialization is successful.
* 2. The setting is successful.
* 3. Return HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_REMOVE_CERTANDKEY_API_TC001(void)
{
FRAME_Init();
int32_t ret;
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(config != NULL);
ret = HITLS_CFG_SetClientVerifySupport(config, true);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret = HITLS_CFG_SetNoClientCertSupport(config, true);
ASSERT_TRUE(ret == HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(server != NULL);
ret = HITLS_RemoveCertAndKey(client->ssl);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret = FRAME_CreateConnection(client, server, false, HS_STATE_BUTT);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(client->ssl->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(server->ssl->state == CM_STATE_TRANSPORTING);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
static int32_t TestHITLS_PasswordCb(char *buf, int32_t bufLen, int32_t flag, void *userdata)
{
(void)buf;
(void)bufLen;
(void)flag;
(void)userdata;
return 0;
}
/* @
* @test UT_TLS_CM_SET_GET_DEFAULT_API_TC001
* @title Test HITLS_SetDefaultPasswordCb/HITLS_GetDefaultPasswordCb interface
* @brief 1. Invoke the HITLS_SetDefaultPasswordCb interface. Expected result 1.
* 2. Invoke the HITLS_SetDefaultPasswordCb interface. The value of ctx is not empty and the value of password is
* not empty. Expected result 3.
* 3. Invoke the HITLS_GetDefaultPasswordCb interface and leave ctx blank. Expected result 2.
* @expect 1. Returns HITLS_NULL_INPUT
* 2. NULL is returned.
* 3. HITLS_SUCCESS is returned.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_GET_DEFAULT_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
tlsConfig = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetDefaultPasswordCb(NULL, TestHITLS_PasswordCb) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetDefaultPasswordCb(ctx, TestHITLS_PasswordCb) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetDefaultPasswordCb(NULL) == NULL);
ASSERT_TRUE(HITLS_GetDefaultPasswordCb(ctx) == TestHITLS_PasswordCb);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SET_GET_SESSION_API_TC001
* @title Test HITLS_SetSession/HITLS_GetSession interface
* @brief 1. If ctx is NULL, Invoke the HITLS_SetSession interface.Expected result 1.
* 2. Invoke the HITLS_SetSession interface.Expected result 2.
* 3. Invoke the HITLS_GetSession interface. Expected result 2.
* @expect 1. Returns HITLS_NULL_INPUT
* 2. returnes HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_GET_SESSION_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
tlsConfig = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetSession(NULL, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetSession(ctx, NULL) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetSession(ctx) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GET_PEERSIGNATURE_TYPE_API_TC001
* @title Test HITLS_GetPeerSignatureType interface
* @brief 1. If ctx is NULL, Invoke the HITLS_GetPeerSignatureType interface. Expected result 2.
* 2. Invoke the HITLS_GetPeerSignatureType interface. Expected result 1.
* @expect 1. Returns HITLS_CONFIG_NO_SUITABLE_CIPHER_SUITE
* 2.Returns HITLS_NULL_INPUT
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_PEERSIGNATURE_TYPE_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
tlsConfig = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
HITLS_SignAlgo sigType = {0};
ASSERT_EQ(HITLS_GetPeerSignatureType(NULL, NULL), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_GetPeerSignatureType(ctx, &sigType), HITLS_CONFIG_NO_SUITABLE_CIPHER_SUITE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
static void Test_Fatal_Alert(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len,
uint32_t bufSize, void *user)
{
(void)bufSize;
(void)user;
(void)len;
(void)data;
uint8_t alertdata[2] = {0x02, 0x29};
REC_Write(ctx, REC_TYPE_ALERT, alertdata, 2);
return;
}
/** @
* @test UT_TLS_CM_FATAL_ALERT_TC001
* @title recv fatal alert brefore client hello need to close connection
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1
* 2. After the initialization, send a fetal alert to server, expect reslut 2.
* @expect 1. The initialization is successful.
* 2. The client close the connection
@ */
/* BEGIN_CASE */
void UT_TLS_CM_FATAL_ALERT_TC001(int version)
{
RecWrapper wrapper = {
TRY_SEND_CLIENT_HELLO,
REC_TYPE_HANDSHAKE,
false,
NULL,
Test_Fatal_Alert
};
RegisterWrapper(wrapper);
FRAME_Init();
HITLS_Config *config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
/* Link initialization */
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(client->ssl->state == CM_STATE_IDLE);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ASSERT_EQ(server->ssl->state, CM_STATE_ALERTED);
ALERT_Info info = { 0 };
ALERT_GetInfo(server->ssl, &info);
/* Alert recv means the handshake state is in alerting state and no alert to be sent*/
ASSERT_EQ(info.flag, ALERT_FLAG_RECV);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_NO_CERTIFICATE_RESERVED);
EXIT:
ClearWrapper();
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
return;
}
/* END_CASE */
/* @
* @test UT_TLS_GET_GLOBALCONFIG_TC001
* @spec -
* @title test for HITLS_GetGlobalConfig
* @precon nan
* @brief HITLS_GetGlobalConfig
* 1. Transfer an empty TLS connection handle. Expected result 1 is obtained
* 2. Transfer non-empty TLS connection handle information. Expected result 2 is obtained
* @expect 1. return NULL
* 2. return globalConfig of TLS context
@ */
/* BEGIN_CASE */
void UT_TLS_GET_GLOBALCONFIG_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
ASSERT_TRUE(HITLS_GetGlobalConfig(ctx) == NULL);
config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetGlobalConfig(ctx) != NULL);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_HITLS_PEEK_TC001
* @brief 1. Establish connection between server and client
2. client sends a byte
3. server calls HITLS_Peek twice
4. server calls HITLS_Read to read one byte to make IO empty
5. server calls HITLS_Peek
* @expect 1. Return HITLS_SUCCESS
2. Return HITLS_SUCCESS
3. Return HITLS_SUCCESS
4. Return HITLS_SUCCESS
5. Return HITLS_REC_NORMAL_RECV_BUF_EMPTY
@ */
/* BEGIN_CASE */
void UT_TLS_HITLS_PEEK_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
FRAME_LinkObj *server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
uint8_t c2s[] = {0};
uint32_t writeLen;
ASSERT_TRUE(HITLS_Write(client->ssl, c2s, sizeof(c2s), &writeLen) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(client, server) == HITLS_SUCCESS);
uint8_t peekBuf[8] = {0};
uint8_t peekBuf1[8] = {0};
uint8_t peekBuf2[8] = {0};
uint8_t readBuf[8] = {0};
uint32_t peekLen = 0;
uint32_t peekLen1 = 0;
uint32_t peekLen2 = 0;
uint32_t readLen = 0;
ASSERT_EQ(HITLS_Peek(server->ssl, peekBuf, sizeof(peekBuf), &peekLen), HITLS_SUCCESS);
ASSERT_EQ(peekLen, sizeof(c2s));
ASSERT_EQ(memcmp(peekBuf, c2s, peekLen), 0);
ASSERT_EQ(HITLS_Peek(server->ssl, peekBuf1, sizeof(peekBuf1), &peekLen1), HITLS_SUCCESS);
ASSERT_EQ(peekLen1, sizeof(c2s));
ASSERT_EQ(memcmp(peekBuf1, c2s, peekLen1), 0);
ASSERT_EQ(HITLS_Read(server->ssl, readBuf, sizeof(readBuf), &readLen), HITLS_SUCCESS);
ASSERT_EQ(readLen, sizeof(c2s));
ASSERT_EQ(memcmp(readBuf, c2s, readLen), 0);
ASSERT_EQ(HITLS_Peek(server->ssl, peekBuf2, sizeof(peekBuf2), &peekLen2), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_EQ(peekLen2, 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_SetTmpDhCb_TC001
* @spec -
* @title HITLS_SetTmpDhCb interface test. The config field is empty.
* @precon nan
* @brief 1. If config is empty, expected result 1 occurs.
* @expect 1. HITLS_NULL_INPUT is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void UT_TLS_SetTmpDhCb_TC001(void)
{
// config is empty
ASSERT_TRUE(HITLS_SetTmpDhCb(NULL, DH_CB) == HITLS_NULL_INPUT);
EXIT:
;
}
/* END_CASE */
/** @
* @test UT_TLS_SET_VERSION_API_TC001
* @title Overwrite the input parameter of the HITLS_SetVersion interface.
* @precon nan
* @brief 1. Invoke the HITLS_SetVersion interface and leave ctx blank. Expected result 2 .
* 2. Invoke the HITLS_SetVersion interface. The ctx parameter is not empty. The minimum version number is
* DTLS1.0, and the maximum version number is DTLS1.2. Expected result 2 .
* 3. Invoke the HITLS_SetVersion interface. The ctx parameter is not empty, the minimum version number is
* DTLS1.2, and the maximum version number is DTLS1.2. Expected result 1 .
* 4. Invoke the HITLS_SetVersion interface, set ctx to a value, set the minimum version number to DTLS1.2, and
* set the maximum version number to DTLS1.0. Expected result 2 .
* 5. Invoke the HITLS_SetVersion interface, set ctx to a value, set the minimum version number to DTLS1.2, and
* set the maximum version number to TLS1.0. (Expected result 2)
* 6. Invoke the HITLS_SetVersion interface, set ctx to a value, set the minimum version number to DTLS1.2, and
* set the maximum version number to TLS1.2. Expected result 2 .
* 7. Invoke the HITLS_SetVersion interface, set ctx to a value, set the minimum version number to TLS1.0, and set
* the maximum version number to DTLS1.2. Expected result 2 .
* 8. Invoke the HITLS_SetVersion interface, set ctx to a value, set the minimum version number to TLS1.2, and set
* the maximum version number to DTLS1.2. Expected result 2 .
* @expect 1. The interface returns a success response, HITLS_SUCCESS.
* 2. The interface returns an error code.
@ */
/* BEGIN_CASE */
void UT_TLS_SET_VERSION_API_TC001(void)
{
HitlsInit();
HITLS_Config *tlsConfig = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
int32_t ret;
ret = HITLS_SetVersion(NULL, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12);
ASSERT_TRUE(ret != HITLS_SUCCESS);
ret = HITLS_SetVersion(ctx, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret = HITLS_SetVersion(ctx, HITLS_VERSION_DTLS12, HITLS_VERSION_TLS12);
ASSERT_TRUE(ret != HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_SET_ServerName_TC001
* @spec -
* @title HITLS_SetServerName invokes the interface to set the server name.
* @precon nan
* @brief
1. Initialize the client and server. Expected result 1
2. After the initialization, set the servername and run the HITLS_GetServerName command to check the server name.
Expected result 2 is displayed
* @expect
1. Complete initialization
2. The returned result is consistent with the settings
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void UT_TLS_SET_ServerName_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_SetServerName(client->ssl, (uint8_t *)g_serverName, (uint32_t)strlen((char *)g_serverName)), HITLS_SUCCESS);
client->ssl->isClient = true;
const char *server_name = HITLS_GetServerName(client->ssl, HITLS_SNI_HOSTNAME_TYPE);
ASSERT_TRUE(memcmp(server_name, g_serverName, strlen(g_serverName)) == 0);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_CERTIFICATE_REQUEST) == HITLS_SUCCESS);
server_name = HS_GetServerName(server->ssl);
ASSERT_TRUE(memcmp(server_name, g_serverName, strlen(g_serverName)) == 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test The interface is invoked in the Idle state. An exception is returned.
* @spec -
* @title UT_TLS_HITLS_READ_WRITE_TC001
* @precon nan
* @brief
1. When the connection is in the Idle state, call the hitls_read/hitls_write interface. Expected result 1 is obtained.
* @expect
1. The connection is not established.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void UT_TLS_HITLS_READ_WRITE_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = GetHitlsConfigViaVersion(version);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(client->ssl->state == CM_STATE_IDLE);
ASSERT_TRUE(server->ssl->state == CM_STATE_IDLE);
// 1. When the link is in the Idle state, call the hitls_read/hitls_write interface.
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ASSERT_TRUE(HITLS_Read(server->ssl, readBuf, READ_BUF_SIZE, &readLen) == HITLS_CM_LINK_UNESTABLISHED);
ASSERT_TRUE(HITLS_Read(client->ssl, readBuf, READ_BUF_SIZE, &readLen) == HITLS_CM_LINK_UNESTABLISHED);
// 1. When the link is in the Idle state, call the hitls_read/hitls_write interface.
uint8_t writeBuf[] = "abc";
uint32_t writeLen = 4;
uint32_t len = 0;
ASSERT_TRUE(HITLS_Write(client->ssl, writeBuf, writeLen, &len) == HITLS_CM_LINK_UNESTABLISHED);
ASSERT_TRUE(HITLS_Write(server->ssl, writeBuf, writeLen, &len) == HITLS_CM_LINK_UNESTABLISHED);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test test HITLS_Close in different cm state
* @spec -
* @title UT_TLS_HITLS_CLOSE_TC001
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1
2. Invoke HITLS_Connect to send the message. Expected result 2
3. Invoke HITLS_Close and failed to send the message. Expected result 3
4. Succeeded in invoking HITLS_Connect to resend the failed close_notify message. Expected result 4
5. Invoke HITLS_Close to send the message. Expected result 5
* @expect 1. The connection is not established.
2. The client status is CM_STATE_HANDSHAKING.
3. The client status is CM_STATE_ALERTING.
4. The client status is CM_STATE_ALERTED.
5. The client status is CM_STATE_CLOSED.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void UT_TLS_HITLS_CLOSE_TC001(int uioType)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
FRAME_Msg recvframeMsg = {0};
FRAME_Msg sndframeMsg = {0};
config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(config != NULL);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
client = FRAME_CreateLink(config, uioType);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, uioType);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_CERTIFICATE_REQUEST) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->hsCtx->state == TRY_RECV_CERTIFICATE_REQUEST);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(client->io);
ioUserData->sndMsg.len = 1;
ASSERT_TRUE(HITLS_Close(clientTlsCtx) == HITLS_REC_NORMAL_IO_BUSY);
ASSERT_EQ(clientTlsCtx->state, CM_STATE_ALERTED);
ioUserData->sndMsg.len = 0;
ASSERT_EQ(HITLS_Close(clientTlsCtx), HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_CLOSED);
EXIT:
CleanRecordBody(&recvframeMsg);
CleanRecordBody(&sndframeMsg);
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test test HITLS_Close in different cm state
* @spec -
* @title UT_TLS_HITLS_CLOSE_TC002
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1
2. Invoke HITLS_Close. Expected result 2
* @expect 1. The connection is not established.
2. The client status is CM_STATE_CLOSED.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void UT_TLS_HITLS_CLOSE_TC002(int uioType)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(config != NULL);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
client = FRAME_CreateLink(config, uioType);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, uioType);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(HITLS_Close(clientTlsCtx) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_CLOSED);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
int32_t ParseServerCookie(ParsePacket *pkt, ServerHelloMsg *msg);
/* @
* @test test ParseServerCookie and ParseClientCookie
* @spec -
* @title UT_TLS_PARSE_Cookie_TC001
* @precon nan
* @brief 1. Initialize the client. Expected result 1
2. Assemble a message with zero length cookie, invoke ParseServerCookie. Expected result 2
3. Assemble a message with zero length cookie, invoke ParseClientCookie. Expected result 2
* @expect 1. The connection is not established.
2. The return value is HITLS_PARSE_INVALID_MSG_LEN.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void UT_TLS_PARSE_Cookie_TC001()
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
CONN_Init(client->ssl);
ServerHelloMsg svrMsg = { 0 };
ClientHelloMsg cliMsg = { 0 };
uint8_t cookie[] = { 0x00 };
uint32_t bufOffset = 0;
ParsePacket pkt = {.ctx = client->ssl, .buf = cookie, .bufLen = sizeof(cookie), .bufOffset = &bufOffset};
ASSERT_EQ(ParseServerCookie(&pkt, &svrMsg), HITLS_PARSE_INVALID_MSG_LEN);
CleanServerHello(&svrMsg);
ASSERT_EQ(ParseClientCookie(&pkt, &cliMsg), HITLS_PARSE_INVALID_MSG_LEN);
CleanClientHello(&cliMsg);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/interface/test_suite_sdv_frame_tls_cm_1.c
|
C
|
unknown
| 37,949
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
#include <stddef.h>
#include <sys/types.h>
#include <regex.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/time.h>
#include <linux/ioctl.h>
#include "securec.h"
#include "bsl_sal.h"
#include "sal_net.h"
#include "hitls.h"
#include "frame_tls.h"
#include "cert_callback.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_errno.h"
#include "bsl_uio.h"
#include "frame_io.h"
#include "uio_abstraction.h"
#include "tls.h"
#include "tls_config.h"
#include "logger.h"
#include "process.h"
#include "hs_ctx.h"
#include "hlt.h"
#include "stub_replace.h"
#include "hitls_type.h"
#include "frame_link.h"
#include "session_type.h"
#include "common_func.h"
#include "hitls_func.h"
#include "hitls_cert_type.h"
#include "cert_mgr_ctx.h"
#include "parser_frame_msg.h"
#include "recv_process.h"
#include "simulate_io.h"
#include "rec_wrapper.h"
#include "cipher_suite.h"
#include "alert.h"
#include "conn_init.h"
#include "pack.h"
#include "send_process.h"
#include "cert.h"
#include "hitls_cert_reg.h"
#include "hitls_crypt_type.h"
#include "hs.h"
#include "hs_state_recv.h"
#include "app.h"
#include "record.h"
#include "rec_conn.h"
#include "session.h"
#include "frame_msg.h"
#include "pack_frame_msg.h"
#include "cert_mgr.h"
#include "hs_extensions.h"
#include "hlt_type.h"
#include "sctp_channel.h"
#include "hitls_crypt_init.h"
#include <stdlib.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_log.h"
#include "bsl_err.h"
#include "bsl_uio.h"
#include "hitls_crypt_reg.h"
#include "hitls_session.h"
#include "cert_method.h"
#include "bsl_list.h"
#include "session_mgr.h"
#include "hitls_x509_verify.h"
#define DEFAULT_DESCRIPTION_LEN 128
#define ERROR_HITLS_GROUP 1
#define ERROR_HITLS_SIGNATURE 0xffffu
typedef struct {
uint16_t version;
BSL_UIO_TransportType uioType;
HITLS_Config *config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_Session *clientSession; /* Set the session to the client for session resume. */
} ResumeTestInfo;
HITLS_CERT_X509 *HiTLS_X509_LoadCertFile(HITLS_Config *tlsCfg, const char *file);
void SAL_CERT_X509Free(HITLS_CERT_X509 *cert);
static HITLS_Config *GetHitlsConfigViaVersion(int ver)
{
switch (ver) {
case TLS1_2:
case HITLS_VERSION_TLS12:
return HITLS_CFG_NewTLS12Config();
case TLS1_3:
case HITLS_VERSION_TLS13:
return HITLS_CFG_NewTLS13Config();
case DTLS1_2:
case HITLS_VERSION_DTLS12:
return HITLS_CFG_NewDTLS12Config();
default:
return NULL;
}
}
int32_t Stub_Write(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen)
{
(void)uio;
(void)buf;
(void)len;
(void)writeLen;
return HITLS_SUCCESS;
}
int32_t Stub_Read(BSL_UIO *uio, void *buf, uint32_t len, uint32_t *readLen)
{
(void)uio;
(void)buf;
(void)len;
(void)readLen;
return HITLS_SUCCESS;
}
int32_t Stub_Ctrl(BSL_UIO *uio, BSL_UIO_CtrlParameter cmd, void *param)
{
(void)uio;
(void)cmd;
(void)param;
return HITLS_SUCCESS;
}
/* END_HEADER */
/** @
* @test UT_TLS_CFG_SET_VERSION_API_TC001
* @title Overwrite the input parameter of the HITLS_CFG_SetVersion interface.
* @precon nan
* @brief 1. Invoke the HITLS_CFG_SetVersion interface and leave config blank. Expected result 2 .
* 2. Invoke the HITLS_CFG_SetVersion interface. The config parameter is not empty. The minimum version number is
* DTLS1.0, and the maximum version number is DTLS1.2. Expected result 2 .
* 3. Invoke the HITLS_CFG_SetVersion interface. The config parameter is not empty, the minimum version number is
* DTLS1.2, and the maximum version number is DTLS1.2. Expected result 1 .
* 4. Invoke the HITLS_CFG_SetVersion interface, set config to a value, set the minimum version number to DTLS1.2, and
* set the maximum version number to DTLS1.0. Expected result 2 .
* 5. Invoke the HITLS_CFG_SetVersion interface, set config to a value, set the minimum version number to DTLS1.2, and
* set the maximum version number to TLS1.0. (Expected result 2)
* 6. Invoke the HITLS_CFG_SetVersion interface, set config to a value, set the minimum version number to DTLS1.2, and
* set the maximum version number to TLS1.2. Expected result 2 .
* 7. Invoke the HITLS_CFG_SetVersion interface, set config to a value, set the minimum version number to TLS1.0, and set
* the maximum version number to DTLS1.2. Expected result 2 .
* 8. Invoke the HITLS_CFG_SetVersion interface, set config to a value, set the minimum version number to TLS1.2, and set
* the maximum version number to DTLS1.2. Expected result 2 .
* @expect 1. The interface returns a success response, HITLS_SUCCESS.
* 2. The interface returns an error code.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_VERSION_API_TC001(void)
{
HitlsInit();
HITLS_Config *tlsConfig = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
int32_t ret;
ret = HITLS_CFG_SetVersion(NULL, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12);
ASSERT_TRUE(ret != HITLS_SUCCESS);
ret = HITLS_CFG_SetVersion(tlsConfig, HITLS_VERSION_DTLS10, HITLS_VERSION_DTLS12);
ASSERT_TRUE(ret != HITLS_SUCCESS);
ret = HITLS_CFG_SetVersion(tlsConfig, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret = HITLS_CFG_SetVersion(tlsConfig, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS10);
ASSERT_TRUE(ret != HITLS_SUCCESS);
ret = HITLS_CFG_SetVersion(tlsConfig, HITLS_VERSION_DTLS12, HITLS_VERSION_TLS10);
ASSERT_TRUE(ret != HITLS_SUCCESS);
ret = HITLS_CFG_SetVersion(tlsConfig, HITLS_VERSION_DTLS12, HITLS_VERSION_TLS12);
ASSERT_TRUE(ret != HITLS_SUCCESS);
ret = HITLS_CFG_SetVersion(tlsConfig, HITLS_VERSION_TLS10, HITLS_VERSION_DTLS12);
ASSERT_TRUE(ret != HITLS_SUCCESS);
ret = HITLS_CFG_SetVersion(tlsConfig, HITLS_VERSION_TLS12, HITLS_VERSION_DTLS12);
ASSERT_TRUE(ret != HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_VERSIONFORBID_API_TC001
* @title Test the HITLS_CFG_SetVersionForbid interface.
* @precon nan
* @brief HITLS_CFG_SetVersionForbid
* 1. Import empty configuration information. Expected result 1.
* 2. Transfer non-empty configuration information and set version to an invalid value. Expected result 2.
* 3. Transfer non-empty configuration information and set version to a valid value. Expected result 3.
* 4. Use HITLS_CFG_GetVersionSupport to view the result.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned, and invalid values in config are filtered out.
* 3. HITLS_SUCCES is returned and config is the expected value.
* 4. The HITLS_SUCCES parameter is returned, and the version parameter is set to the value recorded in the config file.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_VERSIONFORBID_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
uint32_t version = TLS12_VERSION_BIT;
ASSERT_TRUE(HITLS_CFG_SetVersionSupport(config, version) == HITLS_NULL_INPUT);
version = 0;
config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(HITLS_CFG_SetVersionForbid(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == TLS12_VERSION_BIT);
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS12);
HITLS_CFG_FreeConfig(config);
config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(HITLS_CFG_SetVersionForbid(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == TLS_VERSION_MASK);
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS13);
HITLS_CFG_FreeConfig(config);
config = HITLS_CFG_NewTLS12Config();
version = TLS12_VERSION_BIT;
ASSERT_TRUE(HITLS_CFG_SetVersionForbid(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == 0);
ASSERT_TRUE(config->minVersion == 0 && config->maxVersion == 0);
HITLS_CFG_FreeConfig(config);
config = HITLS_CFG_NewTLS12Config();
version = DTLS12_VERSION_BIT;
ASSERT_TRUE(HITLS_CFG_SetVersionForbid(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == TLS12_VERSION_BIT);
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS12);
version = 0x10000000U;
ASSERT_TRUE(HITLS_CFG_SetVersionForbid(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == TLS12_VERSION_BIT);
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS12);
HITLS_CFG_FreeConfig(config);
config = HITLS_CFG_NewTLSConfig();
version = DTLS12_VERSION_BIT;
ASSERT_TRUE(HITLS_CFG_SetVersionForbid(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == TLS_VERSION_MASK);
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS13);
version = 0x10000000U;
ASSERT_TRUE(HITLS_CFG_SetVersionForbid(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == TLS_VERSION_MASK);
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS13);
HITLS_CFG_FreeConfig(config);
config = HITLS_CFG_NewTLSConfig();
version = TLS13_VERSION_BIT;
ASSERT_TRUE(HITLS_CFG_SetVersionForbid(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == TLS12_VERSION_BIT);
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS12);
HITLS_CFG_FreeConfig(config);
config = HITLS_CFG_NewTLSConfig();
version = STREAM_VERSION_BITS;
ASSERT_TRUE(HITLS_CFG_SetVersionForbid(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == 0);
ASSERT_TRUE(config->minVersion == 0 && config->maxVersion == 0);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_VERSIONFORBID_API_TC002
* @title Test the HITLS_CFG_SetVersionForbid interface.
* @precon nan
* @brief HITLS_CFG_SetVersionForbid
* 1. Use HITLS_CFG_SetVersionForbid disable all version. Expected result 1.
* 2. Use HITLS_CFG_SetVersionSupport to set tls12 version. Expected result 2.
* 3. Use HITLS_CFG_GetVersionSupport to set tls13 version.
* @expect
* 1. config->version is 0, config->minVersion and config->maxVersion are 0.
* 2. config->version is TLS12_VERSION_BIT, config->minVersion and config->maxVersion are HITLS_VERSION_TLS12.
* 3. config->version is (TLS12_VERSION_BIT | TLS13_VERSION_BIT),
config->minVersion is HITLS_VERSION_TLS12 and config->maxVersion is HITLS_VERSION_TLS13.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_VERSIONFORBID_API_TC002(void)
{
FRAME_Init();
uint32_t version = TLS_VERSION_MASK;
HITLS_Config *config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(HITLS_CFG_SetVersionForbid(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == 0);
ASSERT_TRUE(config->minVersion == 0 && config->maxVersion == 0);
version = TLS12_VERSION_BIT;
ASSERT_TRUE(HITLS_CFG_SetVersionSupport(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == TLS12_VERSION_BIT);
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS12);
version = TLS13_VERSION_BIT;
ASSERT_TRUE(HITLS_CFG_SetVersionSupport(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == (TLS12_VERSION_BIT | TLS13_VERSION_BIT));
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS13);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_EXTENEDMASTERSECRETSUPPORT_API_TC001
* @spec -
* @title Test the HITLS_CFG_SetExtenedMasterSecretSupport and HITLS_CFG_GetExtenedMasterSecretSupport interfaces.
* @precon nan
* @brief HITLS_CFG_SetExtenedMasterSecretSupport
* 1. Import empty configuration information. Expected result 1.
* 2. Transfer non-empty configuration information and set support to an invalid value. Expected result 2.
* 3. Transfer non-empty configuration information and set support to a valid value. Expected result 3.
* HITLS_CFG_GetExtenedMasterSecretSupport
* 1. Import empty configuration information. Expected result 1.
* 2. Transfer an empty isSupport pointer. Expected result 1.
* 3. Transfer the non-null configuration information and the isSupport pointer is not null. Expected result 3 is
* obtained.
* @expect 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned and config->isSupportExtendMasterSecret is true.
* 3. Returns HITLS_SUCCES and config->isSupportExtendMasterSecret is true or false.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_EXTENEDMASTERSECRETSUPPORT_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
bool support = -1;
uint8_t isSupport = -1;
ASSERT_TRUE(HITLS_CFG_SetExtenedMasterSecretSupport(config, support) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetExtenedMasterSecretSupport(config, &isSupport) == HITLS_NULL_INPUT);
switch (tlsVersion) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
break;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
break;
default:
config = NULL;
break;
}
ASSERT_TRUE(HITLS_CFG_GetExtenedMasterSecretSupport(config, NULL) == HITLS_NULL_INPUT);
support = true;
ASSERT_TRUE(HITLS_CFG_SetExtenedMasterSecretSupport(config, support) == HITLS_SUCCESS);
support = -1;
ASSERT_TRUE(HITLS_CFG_SetExtenedMasterSecretSupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetExtenedMasterSecretSupport(config, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == true);
support = false;
ASSERT_TRUE(HITLS_CFG_SetExtenedMasterSecretSupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetExtenedMasterSecretSupport(config, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_POSTHANDSHAKEAUTHSUPPORT_API_TC001
* @spec -
* @titleTest the HITLS_CFG_SetPostHandshakeAuthSupport and HITLS_CFG_GetPostHandshakeAuthSupport interfaces.
* @precon nan
* @brief HITLS_CFG_SetPostHandshakeAuthSupport
* 1. Import empty configuration information. Expected result 1.
* 2. Transfer non-empty configuration information and set support to an invalid value. Expected result 2.
* 3. Transfer non-empty configuration information and set support to a valid value. Expected result 3.
* HITLS_CFG_GetPostHandshakeAuthSupport
* 1. Import empty configuration information. Expected result 1.
* 2. Transfer an empty isSupport pointer. Expected result 1.
* 3. Transfer the non-null configuration information and the isSupport pointer is not null. Expected result 3 is
* obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned and the value of config->isSupportPostHandshakeAuth is true.
* 3. HITLS_SUCCES is returned and config->isSupportPostHandshakeAuth is true or false.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_POSTHANDSHAKEAUTHSUPPORT_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
bool support = -1;
uint8_t isSupport = -1;
ASSERT_TRUE(HITLS_CFG_SetPostHandshakeAuthSupport(config, support) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetPostHandshakeAuthSupport(config, &isSupport) == HITLS_NULL_INPUT);
switch (tlsVersion) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
break;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
break;
default:
config = NULL;
break;
}
ASSERT_TRUE(HITLS_CFG_GetPostHandshakeAuthSupport(config, NULL) == HITLS_NULL_INPUT);
support = true;
ASSERT_TRUE(HITLS_CFG_SetPostHandshakeAuthSupport(config, support) == HITLS_SUCCESS);
support = -1;
ASSERT_TRUE(HITLS_CFG_SetPostHandshakeAuthSupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetPostHandshakeAuthSupport(config, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == true);
support = false;
ASSERT_TRUE(HITLS_CFG_SetPostHandshakeAuthSupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetPostHandshakeAuthSupport(config, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_CIPHERSUITES_FUNC_TC001
* @title Test the HITLS_CFG_SetCipherSuites and HITLS_CFG_ClearTLS13CipherSuites interfaces.
* @precon nan
* @brief
* 1. The client invokes the HITLS_CFG_SetCipherSuites interface to set the tls1.3 cipher suite HITLS_AES_128_GCM_SHA256.
* Expected result 1.
* 2. Call HITLS_CFG_ClearTLS13CipherSuites to clear the TLS1.3 algorithm suite. Expected result 2.
* 3. Check whether the value of config->tls13CipherSuites is NULL and whether the value of config->tls13cipherSuitesSize
* is 0. (Expected result 3)
* 4. Establish a connection. Expected result 4.
* @expect
* 1. The setting is successful.
* 2. The interface returns a success message.
* 3. config->tls13CipherSuites, config->tls13cipherSuitesSize = 0
* 4. TLS1.3 initialization fails, and TLS1.2 connection are established.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_CIPHERSUITES_FUNC_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config_c = NULL;
HITLS_Config *config_s = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
uint16_t cipherSuites[1] = {
HITLS_AES_128_GCM_SHA256
};
config_c = GetHitlsConfigViaVersion(tlsVersion);
config_s = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
ASSERT_TRUE(HITLS_CFG_SetCipherSuites(config_c, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t))
== HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_ClearTLS13CipherSuites(config_c) == HITLS_SUCCESS);
ASSERT_TRUE(config_c->tls13CipherSuites == NULL);
ASSERT_TRUE(config_c->tls13cipherSuitesSize == 0);
FRAME_CertInfo certInfo = {
"ecdsa/ca-nist521.der:ecdsa/inter-nist521.der:rsa_sha/ca-3072.der:rsa_sha/inter-3072.der",
NULL, NULL, NULL, NULL, NULL,};
client = FRAME_CreateLinkWithCert(config_c, BSL_UIO_TCP, &certInfo);
if (tlsVersion == TLS1_3) {
ASSERT_TRUE(client == NULL);
goto EXIT;
}
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @
* @test UT_TLS_CFG_SET_GET_KEYEXCHMODE_FUNC_TC001
* @title Setting the key exchange mode
* @precon nan
* @brief
* 1. Call HITLS_CFG_SetKeyExchMode to set the key exchange mode to TLS13_KE_MODE_PSK_ONLY. Expected result 1 is
* obtained.
* 2. Invoke the HITLS_CFG_GetKeyExchMode interface. (Expected result 2)
* 3. Call HITLS_CFG_SetKeyExchMode to set the key exchange mode to TLS13_KE_MODE_PSK_WITH_DHE. Expected result 3 is
* obtained.
* 4. Invoke the HITLS_CFG_GetKeyExchMode interface. (Expected result 4)
* @expect
* 1. The setting is successful.
* 2. The returned value is the same as that of TLS13_KE_MODE_PSK_ONLY.
* 3. The setting is successful.
* 4. The return value of the interface is the same as that of TLS13_KE_MODE_PSK_WITH_DHE.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_KEYEXCHMODE_FUNC_TC001()
{
FRAME_Init();
ResumeTestInfo testInfo = {0};
testInfo.version = HITLS_VERSION_TLS13;
testInfo.uioType = BSL_UIO_TCP;
testInfo.config = HITLS_CFG_NewTLS13Config();
ASSERT_EQ(HITLS_CFG_SetKeyExchMode(testInfo.config, TLS13_KE_MODE_PSK_ONLY), HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_GetKeyExchMode(testInfo.config), TLS13_KE_MODE_PSK_ONLY);
ASSERT_EQ(HITLS_CFG_SetKeyExchMode(testInfo.config, TLS13_KE_MODE_PSK_WITH_DHE), HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_GetKeyExchMode(testInfo.config), TLS13_KE_MODE_PSK_WITH_DHE);
EXIT:
HITLS_CFG_FreeConfig(testInfo.config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_VERSIONSUPPORT_API_TC001
* @spec -
* @title Test the HITLS_CFG_SetVersionSupport and HITLS_CFG_GetVersionSupport interfaces.
* @precon nan
* @brief HITLS_CFG_SetVersionSupport
* 1. Import empty configuration information. Expected result 1.
* 2. Transfer non-empty configuration information and set version to an invalid value. Expected result 2.
* 3. Transfer non-empty configuration information and set version to a valid value. Expected result 3.
* HITLS_CFG_GetVersionSupport
* 1. Import empty configuration information. Expected result 1.
* 2. Pass the null version pointer. Expected result 1.
* 3. Transfer non-null configuration information and ensure that the version pointer is not null. Expected result 4 is
* obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned, and invalid values in config are filtered out.
* 3. HITLS_SUCCES is returned and config is the expected value.
* 4. The HITLS_SUCCES parameter is returned, and the version parameter is set to the value recorded in the config file.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_VERSIONSUPPORT_API_TC001()
{
FRAME_Init();
HITLS_Config *config = NULL;
uint32_t version = 0;
ASSERT_TRUE(HITLS_CFG_SetVersionSupport(config, version) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetVersionSupport(config, &version) == HITLS_NULL_INPUT);
config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(HITLS_CFG_GetVersionSupport(config, NULL) == HITLS_NULL_INPUT);
version = (TLS13_VERSION_BIT << 1) | TLS13_VERSION_BIT | TLS12_VERSION_BIT;
ASSERT_TRUE(HITLS_CFG_SetVersionSupport(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS13);
version = TLS13_VERSION_BIT | TLS12_VERSION_BIT;
ASSERT_TRUE(HITLS_CFG_SetVersionSupport(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS13);
uint32_t getversion = 0;
ASSERT_TRUE(HITLS_CFG_GetVersionSupport(config, &getversion) == HITLS_SUCCESS);
ASSERT_TRUE(getversion == config->version);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_ENCRYPTTHENMAC_API_TC001
* @spec -
* @title Test the HITLS_CFG_SetEncryptThenMac and HITLS_CFG_GetEncryptThenMac interfaces.
* @precon nan
* @brief HITLS_CFG_SetEncryptThenMac
* 1. Import empty configuration information. Expected result 1.
* 2. Transfer non-null configuration information and set encryptThenMacType to an invalid value. Expected result 2 is
* obtained.
* 3. Transfer the non-empty configuration information and set encryptThenMacType to a valid value. Expected result 3 is
* obtained.
* HITLS_CFG_GetEncryptThenMac
* 1. Import empty configuration information. Expected result 1.
* 2. Pass the null encryptThenMacType pointer. Expected result 1.
* 3. Transfer non-null configuration information and ensure that the encryptThenMacType pointer is not null. Expected
* result 3.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned and config->isEncryptThenMac is true.
* 3. Returns HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_ENCRYPTTHENMAC_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
uint32_t encryptThenMacType = 0;
ASSERT_TRUE(HITLS_CFG_SetEncryptThenMac(config, encryptThenMacType) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetEncryptThenMac(config, &encryptThenMacType) == HITLS_NULL_INPUT);
switch (tlsVersion) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
break;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
break;
default:
config = NULL;
break;
}
ASSERT_TRUE(HITLS_CFG_GetEncryptThenMac(config, NULL) == HITLS_NULL_INPUT);
encryptThenMacType = 1;
ASSERT_TRUE(HITLS_CFG_SetEncryptThenMac(config, encryptThenMacType) == HITLS_SUCCESS);
encryptThenMacType = 2;
ASSERT_TRUE(HITLS_CFG_SetEncryptThenMac(config, encryptThenMacType) == HITLS_SUCCESS);
ASSERT_TRUE(config->isEncryptThenMac = true);
uint32_t getencryptThenMacType = -1;
ASSERT_TRUE(HITLS_CFG_GetEncryptThenMac(config, &getencryptThenMacType) == HITLS_SUCCESS);
ASSERT_TRUE(getencryptThenMacType == config->isEncryptThenMac);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_IS_DTLS_API_TC001
* @title Test the HITLS_CFG_IsDtls interface.
* @precon nan
* @brief
* 1. Transfer empty configuration information. Expected result 1.
* 2. Transfer the null pointer isDtls. Expected result 1.
* 3. Transfer the configuration information and ensure that the isDtls pointer is not null. Expected result 2 is
* obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. The HITLS_SUCCESS and isDtls information is returned.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_IS_DTLS_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
uint8_t isDtls = false;
ASSERT_TRUE(HITLS_CFG_IsDtls(config, &isDtls) == HITLS_NULL_INPUT);
switch (tlsVersion) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
break;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
break;
default:
config = NULL;
break;
}
ASSERT_TRUE(HITLS_CFG_IsDtls(config, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_IsDtls(config, &isDtls) == HITLS_SUCCESS);
ASSERT_TRUE(isDtls == false);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
typedef struct {
uint16_t version;
BSL_UIO_TransportType uioType;
HITLS_Config *s_config;
HITLS_Config *c_config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_Session *clientSession;
HITLS_TicketKeyCb serverKeyCb;
} ResumeTestInfo1;
HITLS_CRYPT_Key *cert_key = NULL;
HITLS_CRYPT_Key* DH_CB(HITLS_Ctx *ctx, int32_t isExport, uint32_t keyLen)
{
(void)ctx;
(void)isExport;
(void)keyLen;
return cert_key;
}
uint64_t RECORDPADDING_CB(HITLS_Ctx *ctx, int32_t type, uint64_t length, void *arg)
{
(void)ctx;
(void)type;
(void)length;
(void)arg;
return 100;
}
int32_t RecParseInnerPlaintext(TLS_Ctx *ctx, uint8_t *text, uint32_t *textLen, uint8_t *recType);
int32_t STUB_RecParseInnerPlaintext(TLS_Ctx *ctx, uint8_t *text, uint32_t *textLen, uint8_t *recType)
{
(void)ctx;
(void)text;
(void)textLen;
*recType = (uint8_t)REC_TYPE_APP;
return HITLS_SUCCESS;
}
/** @
* @test UT_TLS_CFG_GET_RECORDPADDING_API_TC001
* @title HITLS_CFG_SetRecordPaddingCb Connection
* @precon nan
* @brief 1. If config is empty, expected result 1.
2. RecordPADDING_CB is empty. Expected result 2.
3. RecordPADDING_CB is not empty. Expected result 3.
* @expect 1. The interface returns HITLS_NULL_INPUT.
2. The interface returns HITLS_SUCCESS.
3. The interface returns HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_RECORDPADDING_API_TC001()
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
// Config is empty
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCb(NULL, RECORDPADDING_CB) == HITLS_NULL_INPUT);
// RecordPADDING_CB is empty
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCb(config, NULL) == HITLS_SUCCESS);
// RecordPADDING_CB is not empty
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCb(config, RECORDPADDING_CB) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetRecordPaddingCb(config) == RECORDPADDING_CB);
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCbArg(config, RECORDPADDING_CB) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCbArg(NULL, RECORDPADDING_CB) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCbArg(config, NULL) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_RECORDPADDINGARG_API_TC001
* @title HITLS_CFG_SetRecordPaddingCbArg Connection
* @precon nan
* @brief 1. If config is empty, expected result 1.
2. RecordPADDING_CB is empty. Expected result 2.
3. RecordPADDING_CB is not empty. Expected result 3.
* @expect 1. The interface returns HITLS_NULL_INPUT.
2. The interface returns HITLS_SUCCESS.
3. The interface returns HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_RECORDPADDINGARG_API_TC001()
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
// Config is empty
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCb(NULL, RECORDPADDING_CB) == HITLS_NULL_INPUT);
// RecordPADDING_CB is empty
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCb(config, NULL) == HITLS_SUCCESS);
// RecordPADDING_CB is not empty
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCb(config, RECORDPADDING_CB) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetRecordPaddingCb(config) == RECORDPADDING_CB);
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCbArg(config, RECORDPADDING_CB) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCbArg(NULL, RECORDPADDING_CB) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCbArg(config, NULL) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
int32_t EXAMPLE_TicketKeyCallback(
uint8_t *keyName, uint32_t keyNameSize, HITLS_CipherParameters *cipher, uint8_t isEncrypt)
{
(void)keyName;
(void)keyNameSize;
(void)cipher;
(void)isEncrypt;
return 100;
}
/** @
* @test UT_TLS_CFG_SET_TICKET_CB_API_TC001
* @title Test HITLS_CFG_SetTicketKeyCallback interface
* @brief 1. If config is empty, expected result 1.
2. HITLS_CFG_SetTicketKeyCallback is empty. Expected result 2
3. HITLS_CFG_SetTicketKeyCallback is not empty. Expected result 2
* @expect 1. Returns HITLS_NULL_INPUT.
2. Returns HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_TICKET_CB_API_TC001()
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
// Config is empty
ASSERT_TRUE(HITLS_CFG_SetTicketKeyCallback(NULL, EXAMPLE_TicketKeyCallback) == HITLS_NULL_INPUT);
// HITLS_TicketKeyCb is empty
ASSERT_TRUE(HITLS_CFG_SetTicketKeyCallback(config, NULL) == HITLS_SUCCESS);
// HITLS_TicketKeyCb is not empty
ASSERT_TRUE(HITLS_CFG_SetTicketKeyCallback(config, EXAMPLE_TicketKeyCallback) == HITLS_SUCCESS);
SESSMGR_SetTicketKeyCb(config->sessMgr, EXAMPLE_TicketKeyCallback);
ASSERT_EQ(SESSMGR_GetTicketKeyCb(config->sessMgr), EXAMPLE_TicketKeyCallback);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_NEW_DTLSCONFIG_API_TC001
* @title Test HITLS_CFG_NewDTLSConfig interface
* @brief 1. Invoke the interface HITLS_CFG_NewTLS12Config, expected result 1.
* @expect 1. Returns not NULL.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_NEW_DTLSCONFIG_API_TC001()
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewDTLSConfig();
ASSERT_TRUE(config != NULL);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
#define DATA_MAX_LEN 1024
/** @
* @test UT_TLS_CFG_GET_SET_SESSION_TICKETKEY_API_TC001
* @title Test HITLS_CFG_SetSessionTicketKey interface
* @brief 1. Register the memory for config structure. Expected result 1.
* 2. If ticketKey is null, invoke HITLS_CFG_SetSessionTicketKey. Expected result 2.
* 3. Invoke HITLS_CFG_SetSessionTicketKey. Expected result 3.
* 4. If outSize is null, invoke HITLS_CFG_SetSessionTicketKey. Expected result 2.
* 5. Invoke HITLS_CFG_SetSessionTicketKey. Expected result 3.
* @expect 1. Memory register succeeded.
* 2. Return HITLS_NULL_INPUT.
* 3. Return HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_SET_SESSION_TICKETKEY_API_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
uint8_t getKey[DATA_MAX_LEN] = {0};
uint32_t getKeySize = DATA_MAX_LEN;
uint32_t outSize = 0;
char *ticketKey = "748ab9f3dc1a23748ab9f3dc1a23748ab9f3dc1a23748ab9f3dc1a23748ab9f3dc1a23748ab9f3d";
uint32_t ticketKeyLen = HITLS_TICKET_KEY_NAME_SIZE + HITLS_TICKET_KEY_SIZE + HITLS_TICKET_KEY_SIZE;
ASSERT_TRUE(HITLS_CFG_SetSessionTicketKey(config, NULL, ticketKeyLen) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetSessionTicketKey(config, (uint8_t *)ticketKey, ticketKeyLen) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetSessionTicketKey(config, getKey, getKeySize, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetSessionTicketKey(config, getKey, getKeySize, &outSize) == HITLS_SUCCESS);
ASSERT_TRUE(outSize == ticketKeyLen);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_ADD_CAINDICATION_API_TC001
* @title: Test Add different CA flag indication types.
* @brief
* 1. If data is NULL, Invoke the HITLS_CFG_AddCAIndication.Expected result 1.
* 2. Invoke the HITLS_CFG_AddCAIndication and set the transferred caType to HITLS_TRUSTED_CA_PRE_AGREED.Expected
* result 2.
* 3. Invoke the HITLS_CFG_AddCAIndication and set the transferred caType to HITLS_TRUSTED_CA_KEY_SHA1.Expected
* result 2.
* 4. Invoke the HITLS_CFG_AddCAIndication and set the transferred caType to HITLS_TRUSTED_CA_X509_NAME.Expected
* result 2.
* 5. Invoke the HITLS_CFG_AddCAIndication and set the transferred caType to HITLS_TRUSTED_CA_CERT_SHA1.Expected
* result 2.
* 6. Invoke the HITLS_CFG_AddCAIndication and set the transferred caType to HITLS_TRUSTED_CA_UNKNOWN.Expected
* result 2.
* @expect
* 1. Return HITLS_NULL_INPUT.
* 2. Return HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_ADD_CAINDICATION_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
uint8_t data[] = {0};
uint32_t len = sizeof(data);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(HITLS_CFG_AddCAIndication(config, HITLS_TRUSTED_CA_PRE_AGREED, NULL, len) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_AddCAIndication(config, HITLS_TRUSTED_CA_PRE_AGREED, data, len) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_AddCAIndication(config, HITLS_TRUSTED_CA_KEY_SHA1, data, len) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_AddCAIndication(config, HITLS_TRUSTED_CA_X509_NAME, data, len) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_AddCAIndication(config, HITLS_TRUSTED_CA_CERT_SHA1, data, len) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_AddCAIndication(config, HITLS_TRUSTED_CA_UNKNOWN, data, len) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_GET_CALIST_API_TC001
* @title Test HITLS_CFG_GetCAList interface
* @brief
* 1.Register the memory for config structure. Expected result 1.
* 1.Invoke the interface HITLS_CFG_GetCAList, expected result 2.
* @expect 1. Returns not NULL.
* 2. Returns NULL.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_CALIST_API_TC001()
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
ASSERT_TRUE(HITLS_CFG_GetCAList(config) == NULL);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_GET_VERSION_API_TC001
* @title Test HITLS_CFG_GetMinVersion/HITLS_CFG_GetMaxVersion/HITLS_SetVersion interface
* @brief
* 1.If minVersion is NULL, Invoke the HITLS_CFG_GetMinVersion.Expected result 1.
* 2.If maxVersion is NULL, Invoke the HITLS_CFG_GetMinVersion.Expected result 1.
* 3.Invoke HITLS_CFG_SetVersion.Expected result 2.
* 4.Invoke HITLS_CFG_GetMinVersion.Expected result 2.
* 5.Invoke HITLS_CFG_GetMaxVersion.Expected result 2.
* 6. Check minVersion is HITLS_VERSION_TLS12 and maxVersion is HITLS_VERSION_TLS13
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCES
* 3. Return HITLS_SUCCES，minVersion is HITLS_VERSION_TLS12 and maxVersion is HITLS_VERSION_TLS13
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_VERSION_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLSConfig();
uint16_t minVersion = 0;
uint16_t maxVersion = 0;
ASSERT_TRUE(HITLS_CFG_GetMinVersion(config, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetMaxVersion(config, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetVersion(config, HITLS_VERSION_TLS12, HITLS_VERSION_TLS13) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMinVersion(config, &minVersion) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMaxVersion(config, &maxVersion) == HITLS_SUCCESS);
ASSERT_TRUE(minVersion == HITLS_VERSION_TLS12 && maxVersion == HITLS_VERSION_TLS13);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_GET_SESSION_CACHEMODE_API_TC001
* @title Test ITLS_CFG_GetSessionCacheMoe interface
* @brief 1. Register the memory for config structure. Expected result 1.
* 2. Invoke HITLS_CFG_GetSessionCacheMode. Expected result 2.
* @expect 1. Memory register succeeded.
* 2. Return success and value is 0.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_SESSION_CACHEMODE_API_TC001(void)
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
HITLS_SESS_CACHE_MODE getCacheMode = 0;
ASSERT_EQ(HITLS_CFG_GetSessionCacheMode(config, &getCacheMode), 0);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_SET_GET_SESSIONCACHESIZE_API_TC001
* @title Test HITLS_CFG_SetSessionCacheSize/HITLS_CFG_GetSessionCacheSize interface
* @brief 1. Register the memory for config structure. Expected result 1.
* 2. Invoke HITLS_CFG_SetSessionCacheSize. Expected result 2.
* 3. Invoke HITLS_CFG_GetSessionCacheSize. Expected result 2.
* 4. Check getCacheSize and cacheSize is equal
* @expect 1. Memory register succeeded.
* 2. Return HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_SESSIONCACHESIZE_API_TC001()
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
uint32_t cacheSize = 10;
uint32_t getCacheSize = 0;
ASSERT_TRUE(HITLS_CFG_SetSessionCacheSize(config, cacheSize) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetSessionCacheSize(config, &getCacheSize) == HITLS_SUCCESS);
ASSERT_TRUE(getCacheSize == cacheSize);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_SET_GET_SESSION_TIMEOUT_API_TC001
* @title Test HITLS_CFG_GetSessionTimeout interface
* @brief 1. Register the memory for config structure. Expected result 1.
* 2. Invoke HITLS_CFG_SetSessionTimeout. Expected result 2.
* 3. Invoke HITLS_CFG_GetSessionTimeout. Expected result 2.
* 4. Check timeOut and getTimeOut is equal
* @expect 1. Memory register succeeded.
* 2. Return HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_SESSION_TIMEOUT_API_TC001()
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
uint64_t timeOut = 10;
uint64_t getTimeOut = 0;
ASSERT_TRUE(HITLS_CFG_SetSessionTimeout(config, timeOut) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetSessionTimeout(config, &getTimeOut) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_VERSIONFORBID_API_TC001
* @title Test HITLS_SetVersionForbid interface
* @brief 1. Register the memory for config structure. Expected result 1.
* 2. If context is NULL, invoke HITLS_SetVersionForbid. Expected result 3.
* 3. If context is NULL, invoke HITLS_SetVersionForbid. Expected result 2.
* @expect 1. Memory register succeeded.
* 2. Return HITLS_SUCCESS.
* 3. Return HITLS_NULL_INPUT
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_VERSIONFORBID_API_TC001(void)
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetVersionForbid(NULL, HITLS_VERSION_TLS12) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetVersionForbid(ctx, HITLS_VERSION_TLS12) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_CONFIGUSEDATA_API_TC001
* @title Test HITLS_CFG_SetConfigUserData/HITLS_CFG_GetConfigUserData interfaces
* @brief 1. Register the memory for config structure. Expected result 1.
* 2. If config is NULL, invoke HITLS_CFG_SetConfigUserData. Expected result 2.
* 3. Invoke HITLS_CFG_SetConfigUserData. Expected result 3.
* 3. Invoke HITLS_CFG_SetConfigUserData. Expected result 4.
* @expect 1. Memory register succeeded.
* 2. Return HITLS_NULL_INPUT.
* 3. Return HITLS_SUCCESS.
* 4. Return not NULL.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_CONFIGUSEDATA_API_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
char *userData = "123456";
ASSERT_TRUE(HITLS_CFG_SetConfigUserData(NULL, userData) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetConfigUserData(config, userData) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetConfigUserData(config) != NULL);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
void EXAMPLE_HITLS_ConfigUserDataFreeCb(
void* data)
{
(void)data;
return;
}
/** @
* @test UT_TLS_CFG_SET_CONFIG_USERDATA_FREECB_API_TC001
* @title Test HITLS_CFG_SetConfigUserDataFreeCb interfaces
* @brief 1. Register the memory for config structure. Expected result 1.
* 2. If config is NULL, invoke HITLS_CFG_SetConfigUserDataFreeCb. Expected result 2.
* 3. Invoke HITLS_CFG_SetConfigUserDataFreeCb. Expected result 3.
* @expect 1. Memory register succeeded.
* 2. Return HITLS_NULL_INPUT.
* 3. Return HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_CONFIG_USERDATA_FREECB_API_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
ASSERT_TRUE(HITLS_CFG_SetConfigUserDataFreeCb(NULL, EXAMPLE_HITLS_ConfigUserDataFreeCb) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetConfigUserDataFreeCb(config, EXAMPLE_HITLS_ConfigUserDataFreeCb) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_CERTIFICATE_API_TC001
* @title Test HITLS_CFG_SetCertificate interface
* @brief 1. Invoke the HITLS_CFG_SetCertificate interface, set tlsConfig to null, and set cert for the device
* certificate. (Expected result 1)
* 2. Invoke the HITLS_CFG_SetCertificate interface. Set tlsConfig and cert to an empty value for the device
* certificate.(Expected result 1)
* 3. Invoke the HITLS_CFG_SetCertificate interface. Ensure that tlsConfig and cert are not empty. Perform deep
* copy. (Expected result 3)
* 4. Invoke the HITLS_CFG_GetCertificate interface. The value of tlsConfig->certMgrCtx->currentCertKeyType is
* greater than the value of TLS_CERT_KEY_TYPE_UNKNOWN, Expected result 4 is obtained.
* 5. Invoke the HITLS_CFG_GetCertificate interface and leave tlsConfig empty. Expected result 4 is obtained.
* 6. Invoke the HITLS_CFG_SetCertificate interface, set tlsConfig->certMgrCtx to null, and set cert to a non-empty
* device certificate. (Expected result 2)
* 7. Invoke HITLS_CFG_GetCertificate
* Run the tlsConfig command to set certMgrCtx to null. Expected result 4 is obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Return HITLS_CERT_ERR_X509_DUP
* 3. HITLS_SUCCESS is returned.
* 4. NULL is returned.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_CERTIFICATE_API_TC001(int version, char *certFile)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_CERT_X509 *cert = HiTLS_X509_LoadCertFile(tlsConfig, certFile);
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ASSERT_TRUE(HITLS_CFG_SetCertificate(NULL, cert, false) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetCertificate(tlsConfig, NULL, true) == HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_CFG_SetCertificate(tlsConfig, cert, true), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetCertificate(tlsConfig) != NULL);
tlsConfig->certMgrCtx->currentCertKeyType = TLS_CERT_KEY_TYPE_UNKNOWN;
ASSERT_TRUE(HITLS_CFG_GetCertificate(tlsConfig) == NULL);
ASSERT_TRUE(HITLS_CFG_GetCertificate(NULL) == NULL);
SAL_CERT_MgrCtxFree(tlsConfig->certMgrCtx);
tlsConfig->certMgrCtx = NULL;
ASSERT_EQ(HITLS_CFG_SetCertificate(tlsConfig, cert, true), HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetCertificate(tlsConfig) == NULL);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
SAL_CERT_X509Free(cert);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_CHECK_PRIVATEKEY_API_TC001
* @title Test HITLS_CFG_CheckPrivateKey interface
* @brief 1. Invoke the HITLS_CFG_CheckPrivateKey interface and leave tlsConfig blank. Expected result 1
* 2. Invoke the HITLS_CFG_CheckPrivateKey interface. The tlsConfig parameter is not empty,
* The value of tlsConfig->certMgrCtx->currentCertKeyType is greater than or equal to the maximum value
* TLS_CERT_KEY_TYPE_UNKNOWN. Expected result 2
* 3. Invoke the HITLS_CFG_CheckPrivateKey interface and leave tlsConfig->certMgrCtx empty. Expected result 3
* @expect 1. Returns HITLS_NULL_INPUT
* 2. HITLS_CONFIG_NO_CERT is returned.
* 3. The HITLS_UNREGISTERED_CALLBACK message is returned.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_CHECK_PRIVATEKEY_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ASSERT_TRUE(HITLS_CFG_CheckPrivateKey(NULL) == HITLS_NULL_INPUT);
tlsConfig->certMgrCtx->currentCertKeyType = TLS_CERT_KEY_TYPE_UNKNOWN;
ASSERT_TRUE(HITLS_CFG_CheckPrivateKey(tlsConfig) == HITLS_CONFIG_NO_CERT);
SAL_CERT_MgrCtxFree(tlsConfig->certMgrCtx);
tlsConfig->certMgrCtx = NULL;
ASSERT_TRUE(HITLS_CFG_CheckPrivateKey(tlsConfig) == HITLS_UNREGISTERED_CALLBACK);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_ADD_CHAINCERT_API_TC001
* @title Test HITLS_CFG_GetChainCerts interface
* @brief 1. Invoke the HITLS_CFG_AddChainCert interface, set tlsConfig to null, and set addCert to a certificate to be
* added. Perform shallow copy. Expected result 1 .
* 2. Invoke the HITLS_CFG_AddChainCert interface. The tlsConfig parameter is not empty and the addCert parameter
* is empty.Perform deep copy. Expected result 1 .
* 3. Invoke the HITLS_CFG_AddChainCert interface. Ensure that tlsConfig is not empty and addCert is not empty.
* Perform shallow copy. Expected result 2 .
* 4. Invoke the HITLS_CFG_AddChainCert interface. The value of tlsConfig is not empty and the value of
* tlsConfig->certMgrCtx->currentCertKeyType is greater than or equal to the maximum value TLS_CERT_KEY_TYPE_UNKNOWN.
* Expected result 4 .
* 5. Invoke the HITLS_CFG_GetChainCerts interface. Set tlsConfig to a value greater than or equal to the maximum
* value TLS_CERT_KEY_TYPE_UNKNOWN. (Expected result 3)
* 6. Invoke the HITLS_CFG_GetChainCerts interface and leave tlsConfig blank. Expected result 3 .
* 7. Invoke the HITLS_CFG_LoadKeyBuffer interface. Set tlsConfig->certMgrCtx to null and addCert to the
* certificate to be added. Perform deep copy. Expected result 5 .
* 8. Invoke the HITLS_CFG_GetChainCerts interface and leave tlsConfig->certMgrCtx empty. Expected result 3.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCESS is returned.
* 3. NULL is returned.
* 4. Return ITLS_CERT_ERR_ADD_CHAIN_CERT
* 5. Return HITLS_CERT_ERR_X509_DUP
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_ADD_CHAINCERT_API_TC001(int version, char *certFile, char *addCertFile)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_CERT_X509 *cert = HITLS_CFG_ParseCert(tlsConfig, (const uint8_t *)certFile, strlen(certFile) + 1, TLS_PARSE_TYPE_FILE,
TLS_PARSE_FORMAT_ASN1);
cert = HiTLS_X509_LoadCertFile(tlsConfig, certFile);
HITLS_CERT_X509 *addCert = HiTLS_X509_LoadCertFile(tlsConfig, addCertFile);
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ASSERT_TRUE(HITLS_CFG_SetCertificate(tlsConfig, cert, false) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_AddChainCert(NULL, addCert, false) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_AddChainCert(tlsConfig, NULL, true) == HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_CFG_AddChainCert(tlsConfig, addCert, false), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetChainCerts(tlsConfig) != NULL);
tlsConfig->certMgrCtx->currentCertKeyType = TLS_CERT_KEY_TYPE_UNKNOWN;
ASSERT_EQ(HITLS_CFG_AddChainCert(tlsConfig, cert, true), HITLS_CERT_ERR_ADD_CHAIN_CERT);
ASSERT_TRUE(HITLS_CFG_GetChainCerts(tlsConfig) == NULL);
ASSERT_TRUE(HITLS_CFG_GetChainCerts(NULL) == NULL);
SAL_CERT_MgrCtxFree(tlsConfig->certMgrCtx);
tlsConfig->certMgrCtx = NULL;
ASSERT_EQ(HITLS_CFG_AddChainCert(tlsConfig, cert, true), HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetChainCerts(tlsConfig) == NULL);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
}
/* END_CASE */
/** @
* @test UT_HITLS_CFG_REMOVE_CERTANDKEY_API_TC001
* @title Test HITLS_CFG_RemoveCertAndKey interface
* @brief
* 1. Register the memory for config structure. Expected result 1.
* 2. Invoke HITLS_CFG_RemoveCertAndKey interface, expected result 3.
* 3. Invoke HITLS_CFG_SetCertificate interface, expected result 3.
* 4. Invoke HITLS_CFG_LoadKeyFile interface, expected result 3.
* 5. Invoke HITLS_CFG_GetCertificate interface, expected result 2.
* 6. Invoke HITLS_CFG_GetPrivateKey interface, expected result 2.
* 7. Invoke HITLS_CFG_CheckPrivateKey interface, expected result 3.
* 8. Invoke HITLS_CFG_RemoveCertAndKey interface, expected result 3.
* 9. Invoke HITLS_CFG_GetCertificate interface, expected result 4.
* 10. Invoke HITLS_CFG_GetPrivateKey interface, expected result 4.
* @expect 1. Create successful.
* 2. Return not NULL
* 3. Return HITLS_SUCCESS
* 4.Return NULL
@ */
/* BEGIN_CASE */
void UT_HITLS_CFG_REMOVE_CERTANDKEY_API_TC001(int version, char *certFile, char *keyFile)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_CERT_X509 *cert = HiTLS_X509_LoadCertFile(tlsConfig, certFile);
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ASSERT_EQ(HITLS_CFG_RemoveCertAndKey(tlsConfig), HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_SetCertificate(tlsConfig, cert, true), HITLS_SUCCESS);
#ifdef HITLS_TLS_FEATURE_PROVIDER
ASSERT_EQ(HITLS_CFG_ProviderLoadKeyFile(tlsConfig, keyFile, "ASN1", NULL), HITLS_SUCCESS);
#else
ASSERT_EQ(HITLS_CFG_LoadKeyFile(tlsConfig, keyFile, TLS_PARSE_FORMAT_ASN1), HITLS_SUCCESS);
#endif
ASSERT_TRUE(HITLS_CFG_GetCertificate(tlsConfig) != NULL);
ASSERT_TRUE(HITLS_CFG_GetPrivateKey(tlsConfig) != NULL);
ASSERT_EQ(HITLS_CFG_CheckPrivateKey(tlsConfig), HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_RemoveCertAndKey(tlsConfig), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetCertificate(tlsConfig) == NULL);
ASSERT_TRUE(HITLS_CFG_GetPrivateKey(tlsConfig) == NULL);
EXIT:
HITLS_CFG_FreeCert(tlsConfig, cert);
HITLS_CFG_FreeConfig(tlsConfig);
}
/* END_CASE */
void StubListDataDestroy(void *data)
{
BSL_SAL_FREE(data);
return;
}
/** @
* @test UT_HITLS_CFG_ADD_EXTRA_CHAINCERT_API_TC001
* @title Test HITLS_CFG_AddExtraChainCert interface
* @brief
* 1. Create a config object. Expected result 1 .
* 2. If the input value of config is null, invoke HITLS_CFG_GetExtraChainCerts to obtain the configured additional
* certificate chain. Expected result 2 .
* 3. Call the interface to add a certificate to the additional certificate chain and call HITLS_CFG_GetExtraChainCerts
* to obtain the configured additional certificate chain. Expected result 3 .
* 4. Call the API again to add certificate 2 to the additional certificate chain and call HITLS_CFG_GetExtraChainCerts
* to obtain the configured additional certificate chain. Expected result 4 .
5. Invoke HITLS_CFG_ClearChainCerts to clear the attached certificate chain. Expected result 5 .
* @expect
* 1. The config object is created successfully.
* 2. Failed to set the additional certificate chain. The obtained additional certificate chain is empty.
* 3. The additional certificate chain is successfully set and obtained.
* 4. The additional certificate chain is successfully set and obtained.
* 5. The STORE for obtaining the attached certificate chain does not change.
@ */
/* BEGIN_CASE */
void UT_HITLS_CFG_ADD_EXTRA_CHAINCERT_API_TC001(int version, char *certFile1, char *certFile2)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_CERT_X509 *cert1 = HiTLS_X509_LoadCertFile(tlsConfig, certFile1);
HITLS_CERT_X509 *cert2 = HiTLS_X509_LoadCertFile(tlsConfig, certFile2);
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ASSERT_TRUE(HITLS_CFG_AddExtraChainCert(NULL, cert1) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_AddExtraChainCert(tlsConfig, cert1) == HITLS_SUCCESS);
HITLS_CERT_Chain *extraChainCert = HITLS_CFG_GetExtraChainCerts(tlsConfig);
ASSERT_TRUE(extraChainCert->count == 1);
ASSERT_TRUE(HITLS_CFG_GetExtraChainCerts(tlsConfig) != NULL);
ASSERT_TRUE(HITLS_CFG_AddExtraChainCert(tlsConfig, cert2) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetExtraChainCerts(tlsConfig) != NULL);
ASSERT_TRUE(HITLS_CFG_ClearChainCerts(tlsConfig) == HITLS_SUCCESS);
HITLS_CERT_Chain *extraChainCert1 = HITLS_CFG_GetExtraChainCerts(tlsConfig);
ASSERT_TRUE(extraChainCert1->count == 2);
ASSERT_TRUE(HITLS_CFG_GetExtraChainCerts(tlsConfig) != NULL);
ASSERT_TRUE(HITLS_CFG_ClearExtraChainCerts(NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_ClearExtraChainCerts(tlsConfig) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetExtraChainCerts(tlsConfig) == NULL);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_SET_DTLS_MTU_API_TC001
* @title Test HITLS_SetMtu interface
* @brief 1. Create the TLS configuration object config.Expect result 1.
* 2. Use config to create the client and server.Expect result 2.
* 3. Invoke HITLS_SetMtu, Expect result 3.
* @expect 1. The config object is successfully created.
* 2. The client and server are successfully created.
* 3. Return HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_DTLS_MTU_API_TC001(void)
{
FRAME_Init();
uint32_t mtu = 1500;
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(HITLS_SetMtu(client->ssl, mtu) == HITLS_SUCCESS);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(HITLS_SetMtu(server->ssl, mtu) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
void Test_HITLS_KeyLogCb(HITLS_Ctx *ctx, const char *line)
{
(void)ctx;
(void)line;
printf("there is Test_HITLS_KeyLogCb\n");
}
/* @
* @test UT_TLS_CFG_LogSecret_TC001
* @spec -
* @title Test the HITLS_LogSecret interface.
* @precon nan
* @brief
* 1. Transfer an empty context. The label and secret are not empty, and the secret length is not 0.
* Expected result 1 is obtained.
* 2. Transfer a non-empty context. The label is empty, the secret is not empty,
* and the secret length is not 0. Expected result 1 is obtained.
* 3. Transfer a non-empty context. The label is not empty, the secret is empty,
* and the secret length is not 0. Expected result 1 is obtained.
* 4. Transfer a non-empty context. The label and secret are not empty, and the secret length is 0.
* Expected result 1 is obtained.
* 5. Transfer a non-empty context. The label and secret are not empty, and the secret length is not 0.
* Expected result 2 is obtained.
* @expect 1. return HITLS_NULL_INPUT
* 2. return HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_LogSecret_TC001()
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = NULL;
HITLS_CFG_SetKeyLogCb(config, Test_HITLS_KeyLogCb);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
const char label[] = "hello";
const char secret[] = "hello123";
ASSERT_EQ(HITLS_LogSecret(NULL, label, (const uint8_t *)secret, strlen(secret)), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_LogSecret(ctx, NULL, (const uint8_t *)secret, strlen(secret)), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_LogSecret(ctx, label, NULL, strlen(secret)), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_LogSecret(ctx, label, (const uint8_t *)secret, 0), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_LogSecret(ctx, label, (const uint8_t *)secret, strlen(secret)), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_SetTmpDhCb_TC001
* @spec -
* @title HITLS_CFG_SetTmpDhCb interface test. The config field is empty.
* @precon nan
* @brief 1. If config is empty, expected result 1 is obtained.
* @expect 1. HITLS_NULL_INPUT is returned.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SetTmpDhCb_TC001()
{
// config is empty
ASSERT_TRUE(HITLS_CFG_SetTmpDhCb(NULL, DH_CB) == HITLS_NULL_INPUT);
EXIT:
;
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_GET_CIPHERSUITESBYSTDNAME_TC001
* @spec -
* @title HITLS_CFG_GetCipherSuiteByStdName connection
* @precon nan
* @brief 1. Transfer a null pointer. Expected result 1 is obtained.
* 2. Transfer the "TLS_RSA_WITH_AES_128_CBC_SHA" character string. Expected result 2 is obtained.
* 3. Input the character string x. Expected result 3 is obtained.
* @expect 1. return NULL
* 2. return HITLS_RSA_WITH_AES_128_CBC_SHA
* 3. return NULL
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_CIPHERSUITESBYSTDNAME_TC001(void)
{
const char *StdName = NULL;
ASSERT_TRUE(HITLS_CFG_GetCipherSuiteByStdName((const uint8_t *)StdName) == NULL);
const char StdName2[] = "TLS_RSA_WITH_AES_128_CBC_SHA";
const HITLS_Cipher* Cipher2 = HITLS_CFG_GetCipherSuiteByStdName((const uint8_t *)StdName2);
ASSERT_TRUE(Cipher2->cipherSuite == HITLS_RSA_WITH_AES_128_CBC_SHA);
const char StdName3[] = "x";
ASSERT_TRUE(HITLS_CFG_GetCipherSuiteByStdName((const uint8_t *)StdName3) == NULL);
EXIT:
return;
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_CLEAR_CALIST_TC001
* @title HITLS_CFG_ClearCAList interface test
* @precon nan
* @brief 1. pass NULL parameter, expect result 1
* 2. pass config with NULL caList, expect result 1
* 3. pass normal config, expect result 1
* @expect 1. void function has no return value
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_CLEAR_CALIST_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
HITLS_Config *config2 = {0};
HITLS_CFG_ClearCAList(NULL);
HITLS_CFG_ClearCAList(config2);
HITLS_CFG_ClearCAList(config);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_SET_GET_DHAUTOSUPPORT_TC001
* @spec -
* @title HITLS_CFG_SetDhAutoSupport and HITLS_CFG_GetDhAutoSupport contact
* @precon nan
* @brief HITLS_CFG_SetDhAutoSupport
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and set support to an invalid value. Expected result 2 is obtained.
* 3. Transfer non-empty configuration information and set support to a valid value. Expected result 3 is obtained.
* HITLS_CFG_GetDhAutoSupport
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer an empty isSupport pointer. Expected result 1 is obtained.
* 3. Transfer the non-null configuration information and the isSupport pointer is not null. Expected result 3 is obtained.
* @expect 1. return HITLS_NULL_INPUT
* 2. return HITLS_SUCCES，and config->isSupportDhAuto is True
* 3. return HITLS_SUCCES，and config->isSupportDhAuto is False or True
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_DHAUTOSUPPORT_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
bool support = -1;
uint8_t isSupport = -1;
ASSERT_TRUE(HITLS_CFG_SetDhAutoSupport(config, support) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetDhAutoSupport(config, &isSupport) == HITLS_NULL_INPUT);
switch (tlsVersion) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
break;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
break;
default:
config = NULL;
break;
}
ASSERT_TRUE(HITLS_CFG_GetDhAutoSupport(config, NULL) == HITLS_NULL_INPUT);
support = true;
ASSERT_TRUE(HITLS_CFG_SetDhAutoSupport(config, support) == HITLS_SUCCESS);
support = -1;
ASSERT_TRUE(HITLS_CFG_SetDhAutoSupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetDhAutoSupport(config, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == true);
support = false;
ASSERT_TRUE(HITLS_CFG_SetDhAutoSupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetDhAutoSupport(config, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_GET_READ_AHEAD_TC001
* @title HITLS_CFG_GetReadAhead interface test
* @precon nan
* @brief 1. pass NULL config, expect result 1
* 2. pass NULL onOff, expect result 1
* 3. pass normal parameters, expect result 2
* @expect 1. return HITLS_NULL_INPUT
* 2. return HITLS_SUCCESS
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_READ_AHEAD_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
int32_t onOff = 0;
ASSERT_TRUE(HITLS_CFG_GetReadAhead(NULL, &onOff) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetReadAhead(config, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetReadAhead(config, &onOff) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_CONFIG_SET_KeyLogCb_TC001
* @spec -
* @title Test the HITLS_CFG_SetKeyLogCb and HITLS_CFG_GetKeyLogCb interfaces.
* @precon nan
* @brief HITLS_CFG_SetKeyLogCb and HITLS_CFG_GetKeyLogCb
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and set callback to a non-empty value. Expected result 2 is obtained.
* @expect 1. return HITLS_NULL_INPUT
* 2. return HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_KeyLogCb_TC001()
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
ASSERT_TRUE(HITLS_CFG_SetKeyLogCb(NULL, Test_HITLS_KeyLogCb) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetKeyLogCb(config, Test_HITLS_KeyLogCb) == HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_GetKeyLogCb(NULL), NULL);
ASSERT_EQ(HITLS_CFG_GetKeyLogCb(config), Test_HITLS_KeyLogCb);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
int g_recordPaddingCbArg = 1;
uint64_t RecordPaddingCb(HITLS_Ctx *ctx, int32_t type, uint64_t length, void *arg)
{
(void)ctx;
(void)type;
(void)length;
ASSERT_TRUE(g_recordPaddingCbArg == (*(int *)arg));
ASSERT_TRUE(&g_recordPaddingCbArg == arg);
EXIT:
return 0;
}
/** @
* @test UT_TLS_CFG_SET_RECORDPADDINGARG_API_TC002
* @title HITLS_CFG_SetRecordPaddingCbArg Connection
* @precon nan
* @brief 1. Create tls13 config, expected result 1.
2. Set RecordPaddingCb and RecordPaddingCbArg to 1 for the client, Expected result 2.
3. Establish a connection, Verify that the arg passed in RecordPaddingCb matches the set arg.
Expected result 3.
* @expect
* 1. The creating is successful.
* 2. The setting is successful.
* 3. The arg value is the same，TLS1.3 connection are established.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_RECORDPADDINGARG_API_TC002()
{
HitlsInit();
HITLS_Config *config_c = NULL;
HITLS_Config *config_s = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config_c = HITLS_CFG_NewTLS13Config();
config_s = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCb(config_c, RecordPaddingCb) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_SetRecordPaddingCbArg(config_c, &g_recordPaddingCbArg) == HITLS_SUCCESS);
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_LOADVERIFYDIR_MULTI_PATH_TC001
* @title Test HITLS_CFG_LoadVerifyDir with multiple CA paths
* @brief
* 1. Create a config object.
* 2. Pass in a string containing multiple paths (such as "/tmp/ca1:/tmp/ca2:/tmp/ca3").
* 3. Call HITLS_CFG_LoadVerifyDir.
* 4. Check that the number and content of caPaths in the cert store are consistent with the input.
* @expect
* 1. The interface returns success.
* 2. The number and content of paths in the cert store are consistent with the input.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_LOADVERIFYDIR_MULTI_PATH_TC001(void)
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
const char *multi_path = "/tmp/ca1:/tmp/ca2:/tmp/ca3:/tmp/ca3";
int32_t ret = HITLS_CFG_LoadVerifyDir(config, multi_path);
ASSERT_TRUE(ret == HITLS_SUCCESS);
HITLS_CERT_Store *store = SAL_CERT_GetCertStore(config->certMgrCtx);
ASSERT_TRUE(store != NULL);
HITLS_X509_StoreCtx *storeCtx = (HITLS_X509_StoreCtx *)store;
BslList *caPaths = storeCtx->caPaths;
ASSERT_TRUE(caPaths != NULL);
int expect_count = 3;
int actual_count = BSL_LIST_COUNT(caPaths);
ASSERT_TRUE(actual_count == expect_count);
const char *expect_paths[] = {"/tmp/ca1", "/tmp/ca2", "/tmp/ca3"};
for (int i = 0; i < expect_count; ++i) {
const char *path = (const char *)BSL_LIST_GetIndexNode(i, caPaths);
ASSERT_TRUE(path != NULL);
ASSERT_TRUE(strcmp(path, expect_paths[i]) == 0);
}
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_LOADVERIFYFILE_TC001
* @title Test HITLS_CFG_LoadVerifyFile with a single CA path
* @brief
* 1. Create a config object.
* 2. Pass in a string containing a single path.
* 3. Call HITLS_CFG_LoadVerifyFile.
* 4. Load a client certificate signed by the CA in the specified path.
* 5. Call HITLS_CFG_BuildCertChain to verify the client certificate.
* @expect
* 1. The interface returns success.
* 2. The client certificate is successfully verified.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_LOADVERIFYFILE_TC001(void)
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
const char *path = "../testdata/tls/certificate/pem/rsa_sha256/inter.pem";
int32_t ret = HITLS_CFG_LoadVerifyFile(config, path);
ASSERT_EQ(ret, HITLS_SUCCESS);
const char *path1 = "../testdata/tls/certificate/pem/rsa_sha256/ca.pem";
ret = HITLS_CFG_LoadVerifyFile(config, path1);
ASSERT_EQ(ret, HITLS_SUCCESS);
const char *certToVerify = "../testdata/tls/certificate/pem/rsa_sha256/client.pem";
ret = HITLS_CFG_LoadCertFile(config, certToVerify, TLS_PARSE_FORMAT_PEM);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_BuildCertChain(config, HITLS_BUILD_CHAIN_FLAG_NO_ROOT), HITLS_SUCCESS);
HITLS_CERT_Chain *chain = HITLS_CFG_GetChainCerts(config);
ASSERT_TRUE(chain != NULL);
ASSERT_TRUE(chain->count == 1);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_LOADVERIFYFILE_TC002
* @title Test HITLS_CFG_LoadVerifyFile with a single CA path
* @brief
* 1. Create a config object.
* 2. Pass in a string containing a single path.
* 3. Call HITLS_CFG_LoadVerifyFile.
* 4. Load a client certificate signed by the CA in the specified path.
* 5. Call HITLS_CFG_BuildCertChain to verify the client certificate.
* @expect
* 1. The interface returns success.
* 2. The client certificate verification fails.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_LOADVERIFYFILE_TC002(void)
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
const char *path = "../testdata/tls/certificate/pem/ecdsa_sha256/inter.pem";
int32_t ret = HITLS_CFG_LoadVerifyFile(config, path);
ASSERT_EQ(ret, HITLS_SUCCESS);
const char *certToVerify = "../testdata/tls/certificate/pem/rsa_sha256/client.pem";
ret = HITLS_CFG_LoadCertFile(config, certToVerify, TLS_PARSE_FORMAT_PEM);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_BuildCertChain(config, HITLS_BUILD_CHAIN_FLAG_NO_ROOT), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetChainCerts(config) == NULL);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_USECERTCHAINFILE_TC001
* @title Test HITLS_CFG_UseCertificateChainFile with a single file path
* @brief
* 1. Create a config object.
* 2. Pass in a string containing a single path.
* 3. Call HITLS_CFG_UseCertificateChainFile.
* 4. Load a client certificate signed by the CA in the specified path.
* 5. Call HITLS_CFG_BuildCertChain to verify the client certificate.
* @expect
* 1. The interface returns success.
* 2. The client certificate verification verified.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_USECERTCHAINFILE_TC001(void)
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
const char *path = "../testdata/tls/certificate/pem/rsa_sha256/cert_chain.pem";
int32_t ret = HITLS_CFG_UseCertificateChainFile(config, path);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_BuildCertChain(config, HITLS_BUILD_CHAIN_FLAG_CHECK), HITLS_SUCCESS);
HITLS_CERT_Chain *chain = HITLS_CFG_GetChainCerts(config);
ASSERT_TRUE(chain != NULL);
ASSERT_TRUE(chain->count == 1);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_USECERTCHAINFILE_TC002
* @title Test HITLS_CFG_UseCertificateChainFile with a single CA path
* @brief
* 1. Create a config object.
* 2. Pass in a string containing a single path.
* 3. Call HITLS_CFG_UseCertificateChainFile.
* 4. Load a client certificate signed by the CA in the specified path.
* 5. Call HITLS_CFG_BuildCertChain to verify the client certificate.
* @expect
* 1. The interface returns success.
* 2. The client certificate verification fails.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_USECERTCHAINFILE_TC002(void)
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
const char *path = "../testdata/tls/certificate/pem/rsa_sha256/cert_chain_damaged_ca.pem";
int32_t ret = HITLS_CFG_UseCertificateChainFile(config, path);
ASSERT_EQ(ret, HITLS_CFG_ERR_LOAD_CERT_FILE);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_USECERTCHAINFILE_TC003
* @title Test HITLS_CFG_LoadVerifyFile with a single CA path
* @brief
* 1. Create a config object.
* 2. Pass in a string containing a single path.
* 3. Call HITLS_CFG_UseCertificateChainFile.
* 4. Load a client certificate signed by the CA in the specified path.
* 5. Call HITLS_CFG_BuildCertChain to verify the client certificate.
* @expect
* 1. The interface returns success.
* 2. The client certificate verification fails.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_USECERTCHAINFILE_TC003(void)
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
const char *path = "../testdata/tls/certificate/pem/rsa_sha256/cert_chain_duplicate_ca.pem";
int32_t ret = HITLS_CFG_UseCertificateChainFile(config, path);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_BuildCertChain(config, HITLS_BUILD_CHAIN_FLAG_CHECK), HITLS_CERT_STORE_CTRL_ERR_ADD_CERT_LIST);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/interface/test_suite_sdv_frame_tls_config_1.c
|
C
|
unknown
| 75,107
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include "securec.h"
#include "hlt.h"
#include "hitls_error.h"
#include "hitls_func.h"
#include "conn_init.h"
#include "frame_tls.h"
#include "frame_link.h"
#include "alert.h"
#include "stub_replace.h"
#include "hs_common.h"
#include "change_cipher_spec.h"
#include "hs.h"
#include "simulate_io.h"
#include "rec_header.h"
#include "rec_wrapper.h"
#include "recv_client_hello.c"
#include "record.h"
#define READ_BUF_SIZE 18432
#define MAX_DIGEST_SIZE 64UL /* The longest known is SHA512 */
uint32_t g_uiPort = 8890;
/* END_HEADER */
static HITLS_Config *GetHitlsConfigViaVersion(int ver)
{
HITLS_Config *config;
int32_t ret;
switch (ver) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
ret = HITLS_CFG_SetCheckKeyUsage(config, false);
if (ret != HITLS_SUCCESS) {
return NULL;
}
return config;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
ret = HITLS_CFG_SetCheckKeyUsage(config, false);
if (ret != HITLS_SUCCESS) {
return NULL;
}
return config;
case HITLS_VERSION_DTLS12:
config = HITLS_CFG_NewDTLS12Config();
ret = HITLS_CFG_SetCheckKeyUsage(config, false);
if (ret != HITLS_SUCCESS) {
return NULL;
}
return config;
default:
return NULL;
}
}
int32_t STUB_BSL_UIO_Write(BSL_UIO *uio, const void *data, uint32_t len, uint32_t *writeLen)
{
(void)uio;
(void)data;
(void)len;
(void)writeLen;
return BSL_INTERNAL_EXCEPTION;
}
/** @
* @test SDV_TLS_CM_KEYUPDATE_FUNC_TC001
* @title HITLS_TLS_Interface_SDV_23_0_5_102
* @precon nan
* @brief
* 1. Set the version number to tls1.3. After the connection is established, invoke the HITLS_GetKeyUpdateType interface.
* Expected result 1 is obtained.
* 2. Set the version number to tls1.3. After the connection is created, call hitls_keyupdate successfully, and then call the
* HITLS_GetKeyUpdateType interface. Expected result 2 is obtained.
* 3. Set the version number to tls1.3. After the connection is created, call the hitls_keyupdate interface to construct an
* I/O exception. If the interface fails to be called, call the HITLS_GetKeyUpdateType interface again. Expected
* result 3 is obtained.
* @expect
* 1. The return value is 255.
* 2. The return value is 255.
* 3. The return value is the configured keyupdate type.
@ */
/* BEGIN_CASE */
void SDV_TLS_CM_KEYUPDATE_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
config->isSupportRenegotiation = true;
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config, 1), HITLS_SUCCESS);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ret = HITLS_GetKeyUpdateType(client->ssl);
ASSERT_EQ(ret, HITLS_KEY_UPDATE_REQ_END);
ret = HITLS_KeyUpdate(client->ssl, HITLS_UPDATE_NOT_REQUESTED);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_SUCCESS);
ret = HITLS_GetKeyUpdateType(client->ssl);
ASSERT_EQ(ret, HITLS_KEY_UPDATE_REQ_END);
FuncStubInfo tmpRpInfo = {0};
STUB_Replace(&tmpRpInfo, BSL_UIO_Write, STUB_BSL_UIO_Write);
ret = HITLS_KeyUpdate(client->ssl, HITLS_UPDATE_REQUESTED);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_ERR_IO_EXCEPTION);
ret = HITLS_GetKeyUpdateType(client->ssl);
ASSERT_EQ(ret, HITLS_UPDATE_REQUESTED);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
STUB_Reset(&tmpRpInfo);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/interface/test_suite_sdv_hlt_tls_cm_1.c
|
C
|
unknown
| 4,979
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include "crypt.h"
#include "hitls_crypt_type.h"
#include "hitls_crypt_init.h"
#define PRF_OUT_LEN 48
/* END_HEADER */
/* BEGIN_CASE */
void SDV_TLS_CRYPT_PRF_TC001(int hashAlgo, Hex *secret, Hex *label, Hex *seed, Hex *expect)
{
CRYPT_KeyDeriveParameters input = {0};
input.hashAlgo = hashAlgo;
input.secret = (uint8_t *)secret->x;
input.secretLen = secret->len;
input.label = (uint8_t *)label->x;
input.labelLen = label->len;
input.seed = (uint8_t *)seed->x;
input.seedLen = seed->len;
input.libCtx = NULL;
input.attrName = NULL;
uint8_t out[PRF_OUT_LEN] = {0};
HITLS_CryptMethodInit();
ASSERT_TRUE(PRF_OUT_LEN <= expect->len);
ASSERT_EQ(SAL_CRYPT_PRF(&input, out, PRF_OUT_LEN), HITLS_SUCCESS);
ASSERT_COMPARE("result cmp", out, PRF_OUT_LEN, expect->x, PRF_OUT_LEN);
EXIT:
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/interface/test_suite_sdv_tls_crypt.c
|
C
|
unknown
| 1,433
|
/*
* 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 <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
#include <stddef.h>
#include <unistd.h>
#include "securec.h"
#include "bsl_sal.h"
#include "hitls.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "hitls_cert_reg.h"
#include "hitls_crypt_type.h"
#include "tls.h"
#include "hs.h"
#include "hs_ctx.h"
#include "hs_state_recv.h"
#include "conn_init.h"
#include "app.h"
#include "record.h"
#include "rec_conn.h"
#include "session.h"
#include "recv_process.h"
#include "stub_replace.h"
#include "frame_tls.h"
#include "frame_msg.h"
#include "simulate_io.h"
#include "parser_frame_msg.h"
#include "pack_frame_msg.h"
#include "frame_io.h"
#include "frame_link.h"
#include "cert.h"
#include "cert_mgr.h"
#include "hs_extensions.h"
#include "hlt_type.h"
#include "hlt.h"
#include "sctp_channel.h"
#include "logger.h"
#define READ_BUF_SIZE (18 * 1024) /* Maximum length of the read message buffer */
typedef struct {
HITLS_Config *config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_HandshakeState state;
bool isClient;
bool isSupportExtendMasterSecret;
bool isSupportClientVerify;
bool isSupportNoClientCert;
bool isServerExtendMasterSecret;
bool isSupportRenegotiation; /* Renegotiation support flag */
bool needStopBeforeRecvCCS; /* CCS test, so that the TRY_RECV_FINISH stops before the CCS message is received */
} HandshakeTestInfo;
int32_t SendHelloReq(HITLS_Ctx *ctx)
{
/** Initialize the message buffer. */
uint8_t buf[HS_MSG_HEADER_SIZE] = {0u};
size_t len = HS_MSG_HEADER_SIZE;
/** Write records. */
return REC_Write(ctx, REC_TYPE_HANDSHAKE, buf, len);
}
#define TEST_CLIENT_SEND_FAIL 1
void TestSetCertPath(HLT_Ctx_Config *ctxConfig, char *SignatureType)
{
if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA1", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA1")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA1_EE_PATH, RSA_SHA1_PRIV_PATH, "NULL", "NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA256", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA256")) ==
0 ||
strncmp(SignatureType,
"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256",
strlen("CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA256_EE_PATH3, RSA_SHA256_PRIV_PATH3, "NULL", "NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA384", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA384")) ==
0 ||
strncmp(SignatureType,
"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384",
strlen("CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA384_EE_PATH, RSA_SHA384_PRIV_PATH, "NULL", "NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA512", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA512")) ==
0 ||
strncmp(SignatureType,
"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512",
strlen("CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA512_EE_PATH, RSA_SHA512_PRIV_PATH, "NULL", "NULL");
} else if (strncmp(SignatureType,
"CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256",
strlen("CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA_CA_PATH,
ECDSA_SHA_CHAIN_PATH,
ECDSA_SHA256_EE_PATH,
ECDSA_SHA256_PRIV_PATH,
"NULL",
"NULL");
} else if (strncmp(SignatureType,
"CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384",
strlen("CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA_CA_PATH,
ECDSA_SHA_CHAIN_PATH,
ECDSA_SHA384_EE_PATH,
ECDSA_SHA384_PRIV_PATH,
"NULL",
"NULL");
} else if (strncmp(SignatureType,
"CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512",
strlen("CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA_CA_PATH,
ECDSA_SHA_CHAIN_PATH,
ECDSA_SHA512_EE_PATH,
ECDSA_SHA512_PRIV_PATH,
"NULL",
"NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_ECDSA_SHA1", strlen("CERT_SIG_SCHEME_ECDSA_SHA1")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA1_CA_PATH,
ECDSA_SHA1_CHAIN_PATH,
ECDSA_SHA1_EE_PATH,
ECDSA_SHA1_PRIV_PATH,
"NULL",
"NULL");
}
}
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/interface_tlcp/test_suite_interface.base.c
|
C
|
unknown
| 5,477
|
/*
* 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.
*/
/* BEGIN_HEADER */
/* INCLUDE_BASE test_suite_interface */
#include <stdio.h>
#include "hitls_error.h"
#include "hitls_cert.h"
#include "hitls.h"
#include "hitls_func.h"
#include "securec.h"
#include "cert_method.h"
#include "cert_mgr.h"
#include "cert_mgr_ctx.h"
#include "frame_tls.h"
#include "frame_link.h"
#include "frame_io.h"
#include "session.h"
#include "bsl_list.h"
#include "bsl_sal.h"
#include "bsl_uio.h"
#include "alert.h"
#include "stub_replace.h"
#include "cert_callback.h"
#include "crypt_eal_rand.h"
#include "hitls_crypt_reg.h"
#include "hitls_crypt_init.h"
#include "uio_base.h"
/* END_HEADER */
#define BUF_MAX_SIZE 4096
int32_t g_uiPort = 18886;
static int TestHITLS_VerifyCb(int32_t isPreverifyOk, HITLS_CERT_StoreCtx *storeCtx)
{
(void)isPreverifyOk;
(void)storeCtx;
return 0;
}
static int32_t TestPasswordCb(char *buf, int32_t bufLen, int32_t flag, void *userdata)
{
(void)flag;
char *passwd = NULL;
static char pass[] = "123456";
if (userdata != NULL) {
passwd = userdata;
} else {
passwd = pass;
}
int32_t len = strlen(passwd);
if (len > bufLen) {
return -1;
}
memcpy(buf, passwd, len);
return len;
}
static uint32_t ReadFileBuffer(const char *filePath, char *data)
{
FILE *fd;
uint32_t size;
uint32_t bytes;
fd = fopen(filePath, "rb");
if (fd == NULL) {
return 0;
}
(void)fseek(fd, 0, SEEK_END);
size = (uint32_t)ftell(fd);
rewind(fd);
bytes = (uint32_t)fread(data, 1, size, fd);
(void)fclose(fd);
if (bytes != size) {
return 0;
}
return bytes;
}
/* @
* @test UT_TLS_CERT_CM_SetVerifyDepth_API_TC001
* @title The input parameter of the HITLS_SetVerifyDepth interface is replaced.
* @precon This test case covers the HITLS_SetVerifyDepth, HITLS_GetVerifyDepth
* @brief 1.Invoke the HITLS_SetVerifyDepth interface. The value of ctx is empty and the value of depth is not empty.
* Expected result 1 is obtained.
* 2.Invoke the HITLS_SetVerifyDepth interface. The values of ctx and depth are not empty.
* Expected result 2 is obtained.
* 3.Invoke the HITLS_GetVerifyDepth interface. The ctx field is empty and the depth address is not empty.
* Expected result 1 is obtained.
* @expect 1.Returns HITLS_NULL_INPUT
* 2.Returns HITLS_SUCCESS
* 3.Returns HITLS_NULL_INPUT
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CM_SetVerifyDepth_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
uint32_t depth = 5;
int32_t dep = 0;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetVerifyDepth(NULL, depth) == HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetVerifyDepth(ctx, depth), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetVerifyDepth(ctx, &dep) == HITLS_SUCCESS);
ASSERT_EQ(depth, dep);
ASSERT_TRUE(HITLS_GetVerifyDepth(NULL, &dep) == HITLS_NULL_INPUT);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CFG_SetDefaultPasswordCb_FUNC_001
* @title Set the password callback and set the user data defaultPasswdCbUserdata.
* @precon This test case covers the HITLS_CFG_SetDefaultPasswordCb, HITLS_CFG_GetDefaultPasswordCb,
* HITLS_CFG_SetDefaultPasswordCbUserdata, HITLS_CFG_GetDefaultPasswordCbUserdata
* @brief 1. Create a CTX object. Expected result 1 is obtained.
* 2. Set the password callback and set the incorrect user data defaultPasswdCbUserdata.
* Expected result 2 is obtained.
* @expect 1. Created successfully.
* 2. Failed to load the encrypted private key file.
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CFG_SetDefaultPasswordCb_FUNC_001(int version, char *keyFile, char *userdata)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ASSERT_TRUE(HITLS_CFG_SetDefaultPasswordCb(tlsConfig, TestPasswordCb) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetDefaultPasswordCb(tlsConfig) == TestPasswordCb);
ASSERT_TRUE(HITLS_CFG_SetDefaultPasswordCbUserdata(tlsConfig, userdata)== HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetDefaultPasswordCbUserdata(tlsConfig) == userdata);
#ifdef HITLS_TLS_FEATURE_PROVIDER
ASSERT_EQ(HITLS_CFG_ProviderLoadKeyFile(tlsConfig, keyFile, "ASN1", NULL),
HITLS_CFG_ERR_LOAD_KEY_FILE);
#else
ASSERT_EQ(HITLS_CFG_LoadKeyFile(tlsConfig, keyFile, TLS_PARSE_FORMAT_ASN1), HITLS_CFG_ERR_LOAD_KEY_FILE);
#endif
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CM_SetDefaultPasswordCbUserdata_API_TC001
* @title The input parameter of the HITLS_SetDefaultPasswordCbUserdata interface is replaced.
* @precon This test case covers the HITLS_SetDefaultPasswordCbUserdata, HITLS_GetDefaultPasswordCbUserdata
* @brief 1.Invoke the HITLS_SetDefaultPasswordCbUserdata interface. The value of ctx is empty and the value of
* userdata is not empty. Expected result 1 is obtained.
* 2.Invoke the HITLS_SetDefaultPasswordCbUserdata interface. The values of ctx and userdata are not empty.
* Expected result 2 is obtained.
* 3.Invoke the HITLS_GetDefaultPasswordCbUserdata interface and leave ctx blank. Expected result 3 is obtained.
* @expect 1.Returns HITLS_NULL_INPUT
* 2.Returns HITLS_SUCCESS
* 3.Returns NULL
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CM_SetDefaultPasswordCbUserdata_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
char *userData = "123456";
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetDefaultPasswordCbUserdata(NULL, userData) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetDefaultPasswordCbUserdata(ctx, userData) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetDefaultPasswordCbUserdata(NULL) == NULL);
ASSERT_TRUE(HITLS_GetDefaultPasswordCbUserdata(ctx) == userData);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CFG_LoadCertFile_API_TC001
* @title HITLS_CFG_LoadCertFile Loading a Device Certificate from a File
* @precon This test case covers the HITLS_CFG_LoadCertFile, HITLS_CFG_SetDefaultPasswordCbUserdata,
* HITLS_CFG_GetDefaultPasswordCbUserdata, HITLS_CFG_LoadKeyFile
* @brief 1. Apply for a configuration file. Expected result 1 is obtained.
* 2. Load an incorrect path. Expected result 2 is obtained.
* 3. Use the same keyword "123456" for mac word and pass word. Expected result 3 is obtained.
* @expect 1. The application is successful.
* 2. Failed to load the certificate.
* 3. The certificate is loaded successfully.
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CFG_LoadCertFile_API_TC001(int version, char *certFile1, char *certFile2, char *keyFile2, char *userdata)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ASSERT_EQ(
HITLS_CFG_LoadCertFile(tlsConfig, certFile1, TLS_PARSE_FORMAT_ASN1), HITLS_CFG_ERR_LOAD_CERT_FILE);
ASSERT_TRUE(HITLS_CFG_SetDefaultPasswordCbUserdata(tlsConfig, userdata) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetDefaultPasswordCbUserdata(tlsConfig) == userdata);
ASSERT_TRUE(HITLS_CFG_LoadCertFile(tlsConfig, certFile2, TLS_PARSE_FORMAT_ASN1) == HITLS_SUCCESS);
#ifdef HITLS_TLS_FEATURE_PROVIDER
ASSERT_TRUE(HITLS_CFG_ProviderLoadKeyFile(tlsConfig, keyFile2, "ASN1", NULL) == HITLS_SUCCESS);
#else
ASSERT_TRUE(HITLS_CFG_LoadKeyFile(tlsConfig, keyFile2, TLS_PARSE_FORMAT_ASN1) == HITLS_SUCCESS);
#endif
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CFG_LoadCertBuffer_FUNC_001
* @title HITLS_CFG_LoadCertBuffer Loads and Obtains the Device Certificate from the Buffer
* @precon nan
* @brief 1. Create a CTX object. Expected result 1 is obtained.
* 2. In the local context, the store is not initialized. Invoke HITLS_CFG_GetCertificate to obtain the device
* certificate. Expected result 2 is obtained.
* 3. Call the interface to convert the certificate file into a buffer. Expected result 3 is obtained.
* 4. Delete one byte from the buffer, that is, buffer1. Expected result 4 is obtained.
* 5. Add one byte to the buffer, that is, buffer2. Expected result 5 is obtained.
* 6. Call the interface to set the device certificate through buffer1. Expected result 6 is obtained.
* 7. Call the interface to set the device certificate through buffer2. Expected result 7 is obtained.
* 8. Call the interface to set the device certificate through the buffer. Expected result 8 is obtained.
* 9. Call the interface repeatedly to set the device certificate through the buffer. Expected result 9 is
* obtained.
* @expect 1. Created successfully.
* 2. The obtained content is empty.
* 3. The file is converted successfully.
* 4. Deleted successfully.
* 5. Adding succeeded.
* 6. Failed to load the device certificate.
* 7. Failed to load the device certificate.
* 8. Succeeded in loading the device certificate.
* 9. Failed to load the device certificate.
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CFG_LoadCertBuffer_FUNC_001(int version, char *certPath)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
uint8_t buf[BUF_MAX_SIZE] = {0};
uint32_t bufLen = ReadFileBuffer(certPath, (char *)buf);
ASSERT_TRUE(buf != NULL);
ASSERT_TRUE(bufLen <= BUF_MAX_SIZE);
uint8_t buf2[BUF_MAX_SIZE] = {0};
(void)memcpy_s(buf2, bufLen, buf, bufLen);
buf2[bufLen - 1] = 'b';
buf2[bufLen] = 0;
uint8_t buf1[BUF_MAX_SIZE] = {0};
(void)memcpy_s(buf1, bufLen, buf, bufLen);
buf1[bufLen - 2] = 0;
ASSERT_TRUE(HITLS_CFG_LoadCertBuffer(tlsConfig, buf, bufLen, TLS_PARSE_FORMAT_ASN1) == HITLS_SUCCESS);
ASSERT_EQ(
HITLS_CFG_LoadCertBuffer(tlsConfig, buf1, bufLen - 1, TLS_PARSE_FORMAT_ASN1), HITLS_CFG_ERR_LOAD_CERT_BUFFER);
ASSERT_TRUE(HITLS_CFG_LoadCertBuffer(tlsConfig, buf2, bufLen + 1, TLS_PARSE_FORMAT_ASN1) != HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_LoadCertBuffer(tlsConfig, buf, bufLen, TLS_PARSE_FORMAT_ASN1) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CM_LoadCertFile_API_TC001
* @title The input parameter of the HITLS_LoadCertFile interface is replaced.
* @precon nan
* @brief 1.Invoke the HITLS_LoadCertFile interface. The ctx field is empty, the device certificate file name is not
* empty, and the certificate format is PEM. Expected result 1 is obtained.
* 2.Invoke the HITLS_LoadCertFile interface. The ctx parameter is not empty, the device certificate file name
* is not empty, and the certificate format is PEM. Expected result 2 is obtained.
* @expect 1.Returns HITLS_NULL_INPUT
* 2.Returns HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CM_LoadCertFile_API_TC001(int version, char *certFile)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_LoadCertFile(NULL, NULL, TLS_PARSE_FORMAT_ASN1) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_LoadCertFile(ctx, certFile, TLS_PARSE_FORMAT_ASN1) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CM_LoadCertBuffer_API_TC001
* @title The input parameter of the HITLS_LoadCertBuffer interface is replaced.
* @precon nan
* @brief 1.Invoke the HITLS_LoadCertBuffer interface. The ctx field is empty, the certificate buffer is not empty, the
* buffer length is the actual buffer length, and the certificate format is PEM. Expected result 1 is
* displayed.
* 2.Invoke the HITLS_LoadCertBuffer interface. Ensure that ctx is not empty, the device certificate file name
* is not empty, and the certificate format is PEM. Expected result 2 is obtained.
* @expect 1.Returns HITLS_NULL_INPUT
* 2.Returns HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CM_LoadCertBuffer_API_TC001(int version, char *certFile)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
uint8_t certBuffer[BUF_MAX_SIZE] = {0};
uint32_t certBuffLen = ReadFileBuffer(certFile, (char *)certBuffer);
ASSERT_TRUE(certBuffLen <= BUF_MAX_SIZE);
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_LoadCertBuffer(NULL, certBuffer, certBuffLen, TLS_PARSE_FORMAT_ASN1) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_LoadCertBuffer(ctx, certBuffer, certBuffLen, TLS_PARSE_FORMAT_ASN1) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CFG_LoadKeyBuffer_FUNC_TC001
* @title Load the private key from buffer by using HITLS_CFG_LoadKeyBuffer interface
* @precon nan
* @brief 1. Apply for a configuration file. Expected result 1 is obtained
* 2. Call the API to convert the certificate file into a buffer. Expected result 2 is displayed
* 3. Delete one byte from the buffer, that is, buf1. Expected result 3 is obtained
* 4. Add one byte to the buffer, that is, buf2. Expected result 4
* 5. Call the interface to load the private key through buf1. Expected result 5
* 6. Call the interface to load the private key through buf2. Expected result 6
* 7. Invoke the interface to load the private key through the buffer. Expected result 7
* 8. Invoke the interface repeatedly to load the private key through the buffer. Expected result 8 is obtained
* @expect 1. The application is successful.
* 2. The file is converted successfully.
* 3. The deletion is successful.
* 4. The addition is successful.
* 5. The private key fails to be loaded.
* 6. The private key success to be loaded.
* 7. The private key is loaded.
* 8. The private key fails to be loaded
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CFG_LoadKeyBuffer_FUNC_TC001(int version, char *keyPath)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
uint8_t buf[BUF_MAX_SIZE] = {0};
uint32_t bufLen = ReadFileBuffer(keyPath, (char *)buf);
ASSERT_TRUE(buf != NULL);
ASSERT_TRUE(bufLen <= BUF_MAX_SIZE);
uint8_t buf2[BUF_MAX_SIZE] = {0};
memcpy_s(buf2, bufLen, buf, bufLen);
buf2[bufLen - 1] = 'a';
buf2[bufLen] = 0;
uint8_t buf1[BUF_MAX_SIZE] = {0};
memcpy_s(buf1, bufLen, buf, bufLen);
buf1[bufLen - 2] = 0;
ASSERT_TRUE(HITLS_CFG_LoadKeyBuffer(tlsConfig, buf, bufLen, TLS_PARSE_FORMAT_ASN1) == HITLS_SUCCESS);
ASSERT_EQ(
HITLS_CFG_LoadKeyBuffer(tlsConfig, buf1, bufLen - 1, TLS_PARSE_FORMAT_ASN1), HITLS_CFG_ERR_LOAD_KEY_BUFFER);
ASSERT_EQ(
HITLS_CFG_LoadKeyBuffer(tlsConfig, buf2, bufLen + 1, TLS_PARSE_FORMAT_ASN1), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_LoadKeyBuffer(tlsConfig, buf, bufLen, TLS_PARSE_FORMAT_ASN1) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CM_LoadKeyFile_API_TC001
* @title The error input parameter for HITLS_LoadKeyFile
* @precon nan
* @brief 1.Invoke the HITLS_LoadKeyFile interface. The ctx field is empty, the private key file name is not empty,
* and the private key format is PEM. Expected result 1
* 2.Invoke the HITLS_LoadKeyFile interface. The ctx field is not empty. The private key file name is not empty
* and the private key is in PEM format. Expected result 2 is obtained
* @expect 1.Back HITLS_NULL_INPUT
* 2.Back HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CM_LoadKeyFile_API_TC001(int version, char *keyFile)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_LoadKeyFile(NULL, keyFile, TLS_PARSE_FORMAT_ASN1) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_LoadKeyFile(ctx, keyFile, TLS_PARSE_FORMAT_ASN1) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_SetAndGetCert_FUNC_TC001
* @title Set and get verify result
* @precon nan
* @brief 1. Construct the CTX configuration and initialize the session and certificate management. Expected results 1
* 2. Call HITLS_GetVerifyResult to query the peer certificate verification result of the current context. Expected result 2
* 3. Call HITLS_SetVerifyResult to set the peer certificate verification result of the current context. Expected result 3
* 4. Call HITLS_GetVerifyResult to query the peer certificate verification result of the current context. Expected result 4 is obtained
* @expect 1. Initialization succeeded.
* 2. The verification result is 0.
* 3. The setting result is successful.
* 4. The verification result is the set value
@ */
/* BEGIN_CASE */
void UT_TLS_SetAndGetCert_FUNC_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
HITLS_ERROR result;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetVerifyResult(ctx, &result) == HITLS_SUCCESS);
ASSERT_EQ(result, HITLS_X509_V_OK);
ASSERT_TRUE(HITLS_SetVerifyResult(ctx, HITLS_X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetVerifyResult(ctx, &result) == HITLS_SUCCESS);
ASSERT_TRUE(result == HITLS_X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CM_LoadKeyBuffer_API_TC001
* @title The error input parameter for HITLS_LoadKeyBuffer
* @precon nan
* @brief 1. Invoke the HITLS_LoadKeyBuffer interface. The ctx field is empty, the private key buffer is not empty,
* the buffer length is the actual buffer length, and the private key format is PEM. Expected result 1 is
* displayed.
* 2. Invoke the HITLS_LoadKeyBuffer interface. The ctx and private key buffer are not empty, the buffer length
* is the actual buffer length, and the private key format is pem. The expected result is 1
* @expect 1. HITLS_NULL_INPUT is returned
* 2. HITLS_SUCCESS is returned
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CM_LoadKeyBuffer_API_TC001(int version, char *keyFile)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
uint8_t keyBuffer[BUF_MAX_SIZE] = {0};
uint32_t keyBuffLen = ReadFileBuffer(keyFile, (char *)keyBuffer);
ASSERT_TRUE(keyBuffLen <= BUF_MAX_SIZE);
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_LoadKeyBuffer(NULL, keyBuffer, keyBuffLen, TLS_PARSE_FORMAT_ASN1) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_LoadKeyBuffer(ctx, keyBuffer, keyBuffLen, TLS_PARSE_FORMAT_ASN1) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CFG_SetTlcpCertificate_FUNC_001
* If an unrecognized record type is received, ignore it.
* @title There are only four types of record layers.
* @precon Test Content: Record layer protocols include: handshake, alarm, and password specification change.
* To support protocol extensions, the record layer protocol may support other record types.
* Any new record types should be deassigned in addition to the Content Type values assigned for the types
* described above.
* In this test case, interface HITLS_CFG_SetTlcpCertificate, HITLS_CFG_SetTlcpPrivateKey is invoked at the
* bottom layer.
* @brief After the link is set up, the server receives abnormal messages (the recordType is 99) after receiving
* app data. The server is expected to return an alert.
* @expect 1. HITLS_REC_ERR_RECV_UNEXPECTED_MSG is returned
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CFG_SetTlcpCertificate_FUNC_001(void)
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLCPConfig();
ASSERT_TRUE(tlsConfig != NULL);
uint16_t cipherSuite[] = {HITLS_ECDHE_SM4_CBC_SM3, HITLS_ECC_SM4_CBC_SM3};
HITLS_CFG_SetCipherSuites(tlsConfig, cipherSuite, sizeof(cipherSuite) / sizeof(uint16_t));
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateTLCPLink(tlsConfig, BSL_UIO_TCP, true);
server = FRAME_CreateTLCPLink(tlsConfig, BSL_UIO_TCP, false);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
uint8_t dataBuf[] = "Hello World!";
uint8_t readBuf[READ_BUF_SIZE];
uint32_t readbytes;
uint32_t writeLen;
ASSERT_EQ(HITLS_Write(client->ssl, dataBuf, sizeof(dataBuf), &writeLen), HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(client, server) == HITLS_SUCCESS);
FrameUioUserData *ioServerData = BSL_UIO_GetUserData(server->io);
ioServerData->recMsg.msg[0] = 0x99u;
ASSERT_EQ(HITLS_Read(server->ssl, readBuf, READ_BUF_SIZE, &readbytes), HITLS_REC_ERR_RECV_UNEXPECTED_MSG);
ALERT_Info info = { 0 };
ALERT_GetInfo(server->ssl, &info);
ASSERT_EQ(info.flag, ALERT_FLAG_SEND);
ASSERT_EQ(info.level, ALERT_LEVEL_FATAL);
ASSERT_EQ(info.description, ALERT_UNEXPECTED_MESSAGE);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CFG_SetVerifyCb_API_TC001
* @title HITLS_CFG_SetVerifyCb interface input parameter test
* @precon This test case covers the HITLS_CFG_SetVerifyCb, HITLS_CFG_GetVerifyCb
* @brief 1. Invoke the HITLS_CFG_SetVerifyCb interface. Input empty tlsConfig and non-empty certificate verification
* callback. Expected result 1
* 2. Invoke the HITLS_CFG_SetVerifyCb interface. Input non-empty tlsConfig and non-empty certificate
* verification callback. Expected result 3
* 3. Invoke the HITLS_CFG_GetVerifyCb interface. Input empty tlsConfig, Expected result 2
* 4. Invoke the HITLS_CFG_SetVerifyCb interface. Input empty tlsConfig->certMgrCtx, and non-empty certificate
* verification callback, Expected result 1
* 5. Invoke the HITLS_CFG_GetVerifyCb interface. Input empty tlsConfig->certMgrCtx, Expected result 2
* Expected result 2
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return NULL
* 3. Return HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CFG_SetVerifyCb_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ASSERT_TRUE(HITLS_CFG_SetVerifyCb(NULL, TestHITLS_VerifyCb) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetVerifyCb(tlsConfig, TestHITLS_VerifyCb) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetVerifyCb(tlsConfig) == TestHITLS_VerifyCb);
ASSERT_TRUE(HITLS_CFG_GetVerifyCb(NULL) == NULL);
SAL_CERT_MgrCtxFree(tlsConfig->certMgrCtx);
tlsConfig->certMgrCtx = NULL;
ASSERT_TRUE(HITLS_CFG_SetVerifyCb(tlsConfig, TestHITLS_VerifyCb) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetVerifyCb(tlsConfig) == NULL);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CM_SetVerifyCb_API_TC001
* @title HITLS_SetVerifyCb interface input parameter test
* @precon This test case covers the HITLS_SetVerifyCb, HITLS_GetVerifyCb
* @brief 1.Invoke the HITLS_SetVerifyCb interface. Input empty ctx and non-empty certificate verification
* callback. Expected result 1
* 2.Invoke the HITLS_SetVerifyCb interface. Input non-empty ctx and non-empty certificate verification
* callback. Expected result 2
* 3.Invoke the HITLS_GetVerifyCb interface. Input empty ctx, Expected result 3
* @expect 1.Return HITLS_NULL_INPUT
* 2.Return HITLS_SUCCESS
* 3.Return NULL
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CM_SetVerifyCb_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetVerifyCb(NULL, TestHITLS_VerifyCb) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetVerifyCb(ctx, TestHITLS_VerifyCb) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetVerifyCb(NULL) == NULL);
ASSERT_TRUE(HITLS_GetVerifyCb(ctx) == TestHITLS_VerifyCb);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/*
* @test UT_TLS_CERT_GET_CERTIFICATE_API_TC001
*
* @title Overwrite the input parameter of the HITLS_GetCertificate interface.
*
* @brief
* 1. Invoke the HITLS_GetCertificate interface and leave ctx blank. Expected result 1.
* 2. Invoke the HITLS_GetPeerCertificate interface and leave ctx blank. Expected result 1.
* 3. Invoke the HITLS_GetPeerCertificate interface. The value of ctx is not empty and the value of ctx->session is empty.
* Expected result 1.
* 4. Invoke the HITLS_GetPeerCertChain interface and leave ctx blank. Expected result 1.
* 5. Invoke the HITLS_GetPeerCertChain interface. The value of ctx is not empty and the value of ctx->session is empty.
* Expected result 1 .
* @expect 1. Return NULL.
* @prior Level 1
* @auto TRUE
*/
/* BEGIN_CASE */
void UT_TLS_CERT_GET_CERTIFICATE_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetCertificate(NULL) == NULL);
ASSERT_TRUE(HITLS_GetPeerCertificate(NULL) == NULL);
ASSERT_TRUE(HITLS_GetPeerCertChain(NULL) == NULL);
ctx->session = NULL;
ASSERT_TRUE(HITLS_GetPeerCertificate(ctx) == NULL);
ASSERT_TRUE(HITLS_GetPeerCertChain(ctx) == NULL);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
void StubListDataDestroy(void *data)
{
BSL_SAL_FREE(data);
return;
}
/* @
* @test UT_TLS_CERT_GET_CALIST_FUNC_TC001
*
* @title Obtain the peer certificate chain and trusted CA list.
*
* @brief
* 1. Construct the CTX configuration. Expected result 1.
* 2. Invoke HITLS_GetPeerCertChain to obtain the peer certificate chain. Expected result 2.
* 3. Configure a certificate management instance for the session instance. Expected result 3.
* 4. Add the session instance to the SSL instance. Expected result 4.
* 5. If no certificate is loaded to the peer end, call HITLS_GetPeerCertificate to obtain the peer certificate.
* Expected result 5.
* 6. Create a peer certificate management instance and a certificate chain. Expected result 6.
* 7. Add the created certificates to the certificate linked list one by one. Expected result 7.
* 8. Invoke HITLS_GetPeerCertChain to obtain the peer certificate chain. Expected result 8.
* 9. Invoke the HITLS_GetPeerCAList client certificate authority (CA) list. Expected result 9.
* @expect
* 1. The creation is successful.
* 2. Obtaining failed. The session is empty.
* 3. The setting is successful, and the interface returns 0.
* 4. If the setting is successful, the interface returns 0.
* 5. Failed to obtain the certificate. The certificate is empty.
* 6. The peerCert and certificate chain are successfully created.
* 7. The interface returns 0.
* 8. The certificate successfully. The obtained peer certificate chain is correct. The obtained cert is
* correct.
* 9. The obtained CA certificate list is correct. The obtained cert is correct.
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_GET_CALIST_FUNC_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ctx->isClient = true;
HITLS_Session *session = HITLS_SESS_New();
ASSERT_TRUE(session != NULL);
CERT_Pair *peerCert = (CERT_Pair *)BSL_SAL_Calloc(1u, sizeof(CERT_Pair));
HITLS_CERT_X509 *cert1 = (HITLS_CERT_X509 *)BSL_SAL_Calloc(1u, sizeof(HITLS_CERT_X509));
HITLS_CERT_X509 *cert2 = (HITLS_CERT_X509 *)BSL_SAL_Calloc(1u, sizeof(HITLS_CERT_X509));
HITLS_CERT_X509 *cert3 = (HITLS_CERT_X509 *)BSL_SAL_Calloc(1u, sizeof(HITLS_CERT_X509));
peerCert->chain = (HITLS_CERT_Chain *)BSL_LIST_New(sizeof(HITLS_CERT_X509 *));
ASSERT_TRUE(peerCert->chain != NULL);
HITLS_CERT_Chain *certChain = peerCert->chain;
int32_t ret = BSL_LIST_AddElement((BslList *)certChain, cert1, BSL_LIST_POS_END);
ASSERT_TRUE(ret == 0);
ret = BSL_LIST_AddElement((BslList *)certChain, cert2, BSL_LIST_POS_END);
ASSERT_TRUE(ret == 0);
ret = BSL_LIST_AddElement((BslList *)certChain, cert3, BSL_LIST_POS_END);
ASSERT_TRUE(ret == 0);
ret = SESS_SetPeerCert(session, peerCert, false);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_SetSession(ctx, session) == HITLS_SUCCESS);
HITLS_CERT_Chain *getCertChain = HITLS_GetPeerCertChain(ctx);
ASSERT_TRUE(getCertChain != NULL);
HITLS_TrustedCAList *tmpCAList = ctx->peerInfo.caList;
HITLS_TrustedCANode *newNode1 = (HITLS_TrustedCANode *)BSL_SAL_Calloc(1, sizeof(HITLS_TrustedCANode));
ASSERT_TRUE(newNode1 != NULL);
newNode1->caType = HITLS_TRUSTED_CA_X509_NAME;
newNode1->data = NULL;
newNode1->dataSize = 0;
HITLS_TrustedCANode *newNode2 = (HITLS_TrustedCANode *)BSL_SAL_Calloc(1, sizeof(HITLS_TrustedCANode));
ASSERT_TRUE(newNode2 != NULL);
newNode2->caType = HITLS_TRUSTED_CA_X509_NAME;
newNode2->data = NULL;
newNode2->dataSize = 0;
ret = BSL_LIST_AddElement((BslList *)tmpCAList, newNode1, BSL_LIST_POS_END);
ASSERT_TRUE(ret == 0);
ret = BSL_LIST_AddElement((BslList *)tmpCAList, newNode2, BSL_LIST_POS_END);
ASSERT_TRUE(ret == 0);
HITLS_TrustedCAList *caList = HITLS_GetPeerCAList(ctx);
ASSERT_TRUE(caList != NULL);
ASSERT_EQ(caList->count, 2);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
BSL_LIST_DeleteAll((BslList *)peerCert->chain, StubListDataDestroy);
HITLS_SESS_Free(session);
}
/* END_CASE */
/* @
* @test UT_TLS_CRL_LOAD_FILE_FUNC_TC001
* @title HITLS_CFG_LoadCrlFile interface functional test
* @precon This test case covers the HITLS_CFG_LoadCrlFile interface
@ */
/* BEGIN_CASE */
void UT_TLS_CRL_LOAD_FILE_FUNC_TC001(void)
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(config != NULL);
const char *crlPath = "../testdata/tls/certificate/der/ed25519/ed25519.crl.der";
// Test successful CRL file loading
int32_t ret = HITLS_CFG_LoadCrlFile(config, crlPath, TLS_PARSE_FORMAT_ASN1);
ASSERT_EQ(ret, HITLS_SUCCESS);
// Test invalid parameters
ret = HITLS_CFG_LoadCrlFile(NULL, crlPath, TLS_PARSE_FORMAT_ASN1);
ASSERT_NE(ret, HITLS_SUCCESS);
ret = HITLS_CFG_LoadCrlFile(config, NULL, TLS_PARSE_FORMAT_ASN1);
ASSERT_NE(ret, HITLS_SUCCESS);
ret = HITLS_CFG_LoadCrlFile(config, "", TLS_PARSE_FORMAT_ASN1);
ASSERT_NE(ret, HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CRL_LOAD_BUFFER_FUNC_TC001
* @title HITLS_CFG_LoadCrlBuffer interface functional test
* @precon This test case covers the HITLS_CFG_LoadCrlBuffer interface
@ */
/* BEGIN_CASE */
void UT_TLS_CRL_LOAD_BUFFER_FUNC_TC001(void)
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(config != NULL);
const char *crlPath = "../testdata/tls/certificate/der/ed25519/ed25519.crl.der";
// Read CRL file content
FILE *file = fopen(crlPath, "rb");
ASSERT_TRUE(file != NULL);
fseek(file, 0, SEEK_END);
long fileSize = ftell(file);
fseek(file, 0, SEEK_SET);
ASSERT_TRUE(fileSize > 0);
uint8_t *crlData = (uint8_t *)BSL_SAL_Malloc(fileSize);
ASSERT_TRUE(crlData != NULL);
size_t bytesRead = fread(crlData, 1, fileSize, file);
fclose(file);
ASSERT_EQ(bytesRead, (size_t)fileSize);
// Test successful CRL buffer loading
int32_t ret = HITLS_CFG_LoadCrlBuffer(config, crlData, fileSize, TLS_PARSE_FORMAT_ASN1);
ASSERT_EQ(ret, HITLS_SUCCESS);
// Test invalid parameters
ret = HITLS_CFG_LoadCrlBuffer(NULL, crlData, fileSize, TLS_PARSE_FORMAT_ASN1);
ASSERT_NE(ret, HITLS_SUCCESS);
ret = HITLS_CFG_LoadCrlBuffer(config, NULL, fileSize, TLS_PARSE_FORMAT_ASN1);
ASSERT_NE(ret, HITLS_SUCCESS);
ret = HITLS_CFG_LoadCrlBuffer(config, crlData, 0, TLS_PARSE_FORMAT_ASN1);
ASSERT_NE(ret, HITLS_SUCCESS);
EXIT:
BSL_SAL_Free(crlData);
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CRL_CTX_LOAD_FILE_FUNC_TC001
* @title HITLS_LoadCrlFile interface functional test
* @precon This test case covers the HITLS_LoadCrlFile runtime context interface
@ */
/* BEGIN_CASE */
void UT_TLS_CRL_CTX_LOAD_FILE_FUNC_TC001(void)
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
const char *crlPath = "../testdata/tls/certificate/der/ed25519/ed25519.crl.der";
// Test successful CRL file loading in context
int32_t ret = HITLS_LoadCrlFile(ctx, crlPath, TLS_PARSE_FORMAT_ASN1);
ASSERT_EQ(ret, HITLS_SUCCESS);
// Test invalid parameters
ret = HITLS_LoadCrlFile(NULL, crlPath, TLS_PARSE_FORMAT_ASN1);
ASSERT_NE(ret, HITLS_SUCCESS);
EXIT:
HITLS_Free(ctx);
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CRL_CTX_LOAD_BUFFER_FUNC_TC001
* @title HITLS_LoadCrlBuffer interface functional test
* @precon This test case covers the HITLS_LoadCrlBuffer runtime context interface
@ */
/* BEGIN_CASE */
void UT_TLS_CRL_CTX_LOAD_BUFFER_FUNC_TC001(void)
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
const char *crlPath = "../testdata/tls/certificate/der/ed25519/ed25519.crl.der";
// Read CRL file content
FILE *file = fopen(crlPath, "rb");
ASSERT_TRUE(file != NULL);
fseek(file, 0, SEEK_END);
long fileSize = ftell(file);
fseek(file, 0, SEEK_SET);
ASSERT_TRUE(fileSize > 0);
uint8_t *crlData = (uint8_t *)BSL_SAL_Malloc(fileSize);
ASSERT_TRUE(crlData != NULL);
size_t bytesRead = fread(crlData, 1, fileSize, file);
fclose(file);
ASSERT_EQ(bytesRead, (size_t)fileSize);
// Test successful CRL buffer loading in context
int32_t ret = HITLS_LoadCrlBuffer(ctx, crlData, fileSize, TLS_PARSE_FORMAT_ASN1);
ASSERT_EQ(ret, HITLS_SUCCESS);
// Test invalid parameters
ret = HITLS_LoadCrlBuffer(NULL, crlData, fileSize, TLS_PARSE_FORMAT_ASN1);
ASSERT_NE(ret, HITLS_SUCCESS);
EXIT:
BSL_SAL_Free(crlData);
HITLS_Free(ctx);
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CRL_CFG_CLEAR_FUNC_TC001
* @title HITLS_CFG_ClearVerifyCrls interface functional test
* @precon This test case covers the HITLS_CFG_ClearVerifyCrls interface
@ */
/* BEGIN_CASE */
void UT_TLS_CRL_CFG_CLEAR_FUNC_TC001(void)
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(config != NULL);
const char *crlPath = "../testdata/tls/certificate/der/ed25519/ed25519.crl.der";
// Load CRL file first
int32_t ret = HITLS_CFG_LoadCrlFile(config, crlPath, TLS_PARSE_FORMAT_ASN1);
ASSERT_EQ(ret, HITLS_SUCCESS);
// Test successful CRL clearing
ret = HITLS_CFG_ClearVerifyCrls(config);
ASSERT_EQ(ret, HITLS_SUCCESS);
// Load CRL again to verify clearing worked
ret = HITLS_CFG_LoadCrlFile(config, crlPath, TLS_PARSE_FORMAT_ASN1);
ASSERT_EQ(ret, HITLS_SUCCESS);
// Test invalid parameter
ret = HITLS_CFG_ClearVerifyCrls(NULL);
ASSERT_NE(ret, HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CRL_CTX_CLEAR_FUNC_TC001
* @title HITLS_ClearVerifyCrls interface functional test
* @precon This test case covers the HITLS_ClearVerifyCrls runtime context interface
@ */
/* BEGIN_CASE */
void UT_TLS_CRL_CTX_CLEAR_FUNC_TC001(void)
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
const char *crlPath = "../testdata/tls/certificate/der/ed25519/ed25519.crl.der";
// Load CRL file first
int32_t ret = HITLS_LoadCrlFile(ctx, crlPath, TLS_PARSE_FORMAT_ASN1);
ASSERT_EQ(ret, HITLS_SUCCESS);
// Test successful CRL clearing
ret = HITLS_ClearVerifyCrls(ctx);
ASSERT_EQ(ret, HITLS_SUCCESS);
// Load CRL again to verify clearing worked
ret = HITLS_LoadCrlFile(ctx, crlPath, TLS_PARSE_FORMAT_ASN1);
ASSERT_EQ(ret, HITLS_SUCCESS);
// Test invalid parameter
ret = HITLS_ClearVerifyCrls(NULL);
ASSERT_NE(ret, HITLS_SUCCESS);
EXIT:
HITLS_Free(ctx);
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CRL_VERIFICATION_HANDSHAKE_TC001
* @title CRL verification in TLS handshake functional test
* @precon This test case covers CRL functionality during TLS handshake process
@ */
/* BEGIN_CASE */
void UT_TLS_CRL_VERIFICATION_HANDSHAKE_TC001(void)
{
HitlsInit();
FRAME_Init();
// Test data paths
const char *serverCertPath = "../testdata/tls/certificate/der/ed25519/ed25519.end.der";
const char *serverKeyPath = "../testdata/tls/certificate/der/ed25519/ed25519.end.key.der";
const char *intCaPath = "../testdata/tls/certificate/der/ed25519/ed25519.intca.der";
const char *caCertPath = "../testdata/tls/certificate/der/ed25519/ed25519.ca.der";
const char *crlPath = "../testdata/tls/certificate/der/ed25519/ed25519.crl.der";
// Test 1: Handshake without CRL - should succeed
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
// Configure server with certificate and key
ASSERT_EQ(HITLS_CFG_LoadCertFile(config, serverCertPath, TLS_PARSE_FORMAT_ASN1), HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_LoadKeyFile(config, serverKeyPath, TLS_PARSE_FORMAT_ASN1), HITLS_SUCCESS);
HITLS_CERT_X509 *caCert = HITLS_CFG_ParseCert(config, (const uint8_t *)caCertPath, strlen(caCertPath), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_ASN1);
ASSERT_TRUE(caCert != NULL);
ASSERT_EQ(HITLS_CFG_AddCertToStore(config, caCert, TLS_CERT_STORE_TYPE_DEFAULT, false), HITLS_SUCCESS);
caCert = HITLS_CFG_ParseCert(config, (const uint8_t *)intCaPath, strlen(intCaPath), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_ASN1);
ASSERT_TRUE(caCert != NULL);
ASSERT_EQ(HITLS_CFG_AddCertToStore(config, caCert, TLS_CERT_STORE_TYPE_DEFAULT, false), HITLS_SUCCESS);
FRAME_LinkObj *client = FRAME_CreateLinkBase(config, BSL_UIO_TCP, false);
ASSERT_TRUE(client != NULL);
FRAME_LinkObj *server = FRAME_CreateLinkBase(config, BSL_UIO_TCP, false);
ASSERT_TRUE(server != NULL);
// Attempt handshake without CRL - should succeed
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
server = FRAME_CreateLinkBase(config, BSL_UIO_TCP, false);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(HITLS_CFG_LoadCrlFile(config, crlPath, TLS_PARSE_FORMAT_ASN1), HITLS_SUCCESS);
client = FRAME_CreateLinkBase(config, BSL_UIO_TCP, false);
ASSERT_TRUE(client != NULL);
ASSERT_NE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CM_SetVerifyFlags_API_TC001
* @title The input parameter of the HITLS_CFG_SetVerifyFlags interface is replaced.
* @precon This test case covers the HITLS_CFG_SetVerifyFlags, HITLS_CFG_GetVerifyFlags
* @brief 1.Invoke the HITLS_CFG_SetVerifyFlags interface. The value of ctx is empty and the value of flags is 5.
* Expected result 1 is obtained.
* 2.Invoke the HITLS_CFG_SetVerifyFlags interface. The values of ctx and flags are not empty.
* Expected result 2 is obtained.
* 3.Invoke the HITLS_CFG_GetVerifyFlags interface. The ctx field is empty and the ff address is not empty.
* Expected result 1 is obtained.
* 4.Invoke the HITLS_CFG_GetVerifyFlags interface. The values of ctx and ff address are not empty.
* Expected result 2 is obtained.
* @expect 1.Returns HITLS_NULL_INPUT
* 2.Returns HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CM_SetVerifyFlags_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
uint32_t flags = 5;
uint32_t ff = 0;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ASSERT_TRUE(HITLS_CFG_SetVerifyFlags(NULL, flags) == HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_CFG_SetVerifyFlags(tlsConfig, flags), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetVerifyFlags(tlsConfig, &ff) == HITLS_SUCCESS);
ASSERT_EQ(flags, ff);
ASSERT_TRUE(HITLS_CFG_GetVerifyFlags(NULL, &ff) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetVerifyFlags(tlsConfig, NULL) == HITLS_NULL_INPUT);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
flags = 10;
uint32_t ff2 = 0;
ASSERT_TRUE(HITLS_SetVerifyFlags(NULL, flags) == HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetVerifyFlags(ctx, flags), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetVerifyFlags(ctx, &ff2) == HITLS_SUCCESS);
ASSERT_EQ((flags | ff), ff2);
ASSERT_TRUE(HITLS_GetVerifyFlags(NULL, &ff2) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetVerifyFlags(ctx, NULL) == HITLS_NULL_INPUT);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/interface_tlcp/test_suite_sdv_frame_cert_interface.c
|
C
|
unknown
| 43,911
|
/*
* 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.
*/
/* BEGIN_HEADER */
/* INCLUDE_BASE test_suite_interface */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <linux/limits.h>
#include <unistd.h>
#include <stdbool.h>
#include "hitls_error.h"
#include "hitls_cert.h"
#include "hitls.h"
#include "hitls_func.h"
#include "securec.h"
#include "cert_method.h"
#include "cert_mgr.h"
#include "cert_mgr_ctx.h"
#include "frame_tls.h"
#include "frame_link.h"
#include "frame_io.h"
#include "session.h"
#include "bsl_sal.h"
#include "bsl_uio.h"
#include "alert.h"
#include "stub_replace.h"
#include "cert_callback.h"
#include "crypt_eal_rand.h"
#include "hitls_crypt_reg.h"
#include "hitls_crypt_init.h"
#include "uio_base.h"
#include "hlt_type.h"
#include "hlt.h"
#include "hitls_cert_type.h"
#include "hitls_type.h"
#include "hitls_cert_reg.h"
#include "hitls_config.h"
#include "hitls_cert_init.h"
#include "bsl_log.h"
#include "bsl_err.h"
#include "logger.h"
#include "tls_config.h"
#include "tls.h"
#include "crypt_algid.h"
#include "crypt_errno.h"
#include "bsl_obj.h"
#include "bsl_errno.h"
#include "hitls_x509_adapt.h"
#include "hitls_pki_x509.h"
/* END_HEADER */
#define BUF_MAX_SIZE 4096
int32_t g_uiPort = 18886;
HITLS_CERT_X509 *HiTLS_X509_LoadCertFile(HITLS_Config *tlsCfg, const char *file);
/* @
* @test UT_TLS_CERT_CM_SetVerifyStore_API_TC001
* @title The input parameters of the HITLS_SetVerifyStore and HITLS_GetVerifyStore interfaces are replaced.
* @precon nan
* @brief 1.Invoke the HITLS_SetVerifyStore interface. The value of ctx is empty and the value of store for the CA
* certificate is not empty. Perform shallow copy. Expected result 1 is obtained.
* 2.Invoke the HITLS_SetVerifyStore interface. Set ctx and CA certificate store to a value that is not empty.
* Expected result 2 is obtained.
* 3.Invoke the HITLS_GetVerifyStore interface and leave tlsConfig blank. Expected result 3 is obtained.
* @expect 1.Returns HITLS_NULL_INPUT
* 2.Returns HITLS_SUCCESS
* 3.Returns NULL
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CM_SetVerifyStore_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
HITLS_CERT_Store *verifyStore = HITLS_X509_Adapt_StoreNew();
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetVerifyStore(NULL, verifyStore, false) == HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetVerifyStore(ctx, verifyStore, true), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetVerifyStore(ctx) == verifyStore);
ASSERT_TRUE(HITLS_GetVerifyStore(NULL) == NULL);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
HITLS_X509_StoreCtxFree(verifyStore);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CM_SetChainStore_API_TC001
* @title The input parameters of the HITLS_SetChainStore and HITLS_GetChainStore interfaces are replaced.
* @precon This test case covers the HITLS_SetChainStore、HITLS_GetChainStore
* @brief 1.Invoke the HITLS_SetChainStore interface. The ctx field is empty and the certificate chain store is not
* empty. Perform shallow copy. Expected result 1 is obtained.
* 2.Invoke the HITLS_SetChainStore interface. The value of ctx is not empty and the value of store in the
* certificate chain is not empty. Perform shallow copy. Expected result 2 is obtained.
* 3.Invoke the HITLS_GetChainStore interface and leave tlsConfig empty. Expected result 3 is obtained.
* @expect 1.Returns HITLS_NULL_INPUT
* 2.Returns HITLS_SUCCESS
* 3.Returns NULL
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CM_SetChainStore_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
HITLS_CERT_Store *chainStore = HITLS_X509_Adapt_StoreNew();
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetChainStore(NULL, chainStore, false) == HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetChainStore(ctx, chainStore, false), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetChainStore(ctx) == chainStore);
ASSERT_TRUE(HITLS_GetChainStore(NULL) == NULL);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CM_SetCertStore_API_TC001
* @title The input parameter of the HITLS_SetCertStore interface is replaced.
* @precon This test case covers the HITLS_SetCertStore、HITLS_GetCertStore
* @brief 1.Invoke the HITLS_SetCertStore interface. The value of ctx is empty, and the value of store for the trust
* certificate is not empty. Perform shallow copy. Expected result 1 is obtained.
* 2.Invoke the HITLS_SetCertStore interface. Ensure that ctx and store of the trust certificate are not empty.
* Perform shallow copy. Expected result 2 is obtained.
* 3.Invoke the HITLS_GetCertStore interface and leave ctx blank. Expected result 3 is obtained.
* @expect 1.Returns HITLS_NULL_INPUT
* 2.Returns HITLS_SUCCESS
* 3.Returns NULL
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CM_SetCertStore_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
HITLS_CERT_Store *certStore = HITLS_X509_Adapt_StoreNew();
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetCertStore(NULL, certStore, false) == HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetCertStore(ctx, certStore, false), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetCertStore(ctx) == certStore);
ASSERT_TRUE(HITLS_GetCertStore(NULL) == NULL);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_CM_SetDefaultPasswordCbUserdata_API_TC001
* @title The input parameter of the HITLS_SetDefaultPasswordCbUserdata interface is replaced.
* @precon This test case covers the HITLS_SetDefaultPasswordCbUserdata、HITLS_GetDefaultPasswordCbUserdata
* @brief 1.Invoke the HITLS_SetDefaultPasswordCbUserdata interface. The value of ctx is empty and the value of
* userdata is not empty. Expected result 1 is obtained.
* 2.Invoke the HITLS_SetDefaultPasswordCbUserdata interface. The values of ctx and userdata are not empty.
* Expected result 2 is obtained.
* 3.Invoke the HITLS_GetDefaultPasswordCbUserdata interface and leave ctx blank. Expected result 3 is obtained.
* @expect 1.Returns HITLS_NULL_INPUT
* 2.Returns HITLS_SUCCESS
* 3.Returns NULL
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_CM_SetDefaultPasswordCbUserdata_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
HITLS_CERT_Store *certStore = HITLS_X509_Adapt_StoreNew();
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetCertStore(NULL, certStore, false) == HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetCertStore(ctx, certStore, false), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetCertStore(ctx) == certStore);
ASSERT_TRUE(HITLS_GetCertStore(NULL) == NULL);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CERT_SetGetAndCheckPrivateKey_API_TC001
* @title The error input parameter for HITLS_SetPrivateKey
* @precon nan
* @brief 1.Invoke the HITLS_SetPrivateKey interface. Ensure that ctx is empty and privatekey is not empty.
* Perform deep copy. Expected result 1
* 2.Invoke the HITLS_SetPrivateKey interface. Ensure that ctx is not empty and privatekey is not empty.
* In shallow copy mode, expected result 2
* 3.Invoke the HITLS_GetPrivateKey interface. If ctx is empty, expected result 3
* 4.Invoke the HITLS_CheckPrivateKey interface. If ctx is empty, expected result 1 is obtained
* @expect 1.Back HITLS_NULL_INPUT
* 2.Back HITLS_SUCCESS
* 3.Back HITLS_NULL_INPUT
@ */
/* BEGIN_CASE */
void UT_TLS_CERT_SetGetAndCheckPrivateKey_API_TC001(int version, char *keyFile)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_CERT_Key *privatekey = HITLS_X509_Adapt_ProviderKeyParse(tlsConfig, (const uint8_t *)keyFile, sizeof(keyFile),
TLS_PARSE_TYPE_FILE, "ASN1", NULL);
#else
HITLS_CERT_Key *privatekey = HITLS_X509_Adapt_KeyParse(tlsConfig, (const uint8_t *)keyFile, sizeof(keyFile),
TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_ASN1);
#endif
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetPrivateKey(NULL, privatekey, true) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetPrivateKey(ctx, privatekey, false) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetPrivateKey(NULL) == NULL);
ASSERT_TRUE(HITLS_GetPrivateKey(ctx) != NULL);
ASSERT_TRUE(HITLS_CheckPrivateKey(NULL) == HITLS_NULL_INPUT);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_HITLS_CERT_ClearChainCerts_API_TC001
* @title HITLS_ClearChainCerts interface input parameter test
* @precon nan
* @brief 1. Invoke HITLS_ClearChainCerts interface. Input empty ctx. Expected result 1
* 2. Invoke HITLS_ClearChainCerts interface. Input non-empty ctx. Expected result 2
* 3. Invoke HITLS_ClearChainCerts interface. Input non-empty ctx and empty tlsConfig->certMgrCtx,
* Expected result 1
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_HITLS_CERT_ClearChainCerts_API_TC001(int version, char *certFile, char *addCertFile)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
HITLS_CERT_X509 *cert = HiTLS_X509_LoadCertFile(tlsConfig, certFile);
ASSERT_TRUE(cert != NULL);
HITLS_CERT_X509 *addCert = HiTLS_X509_LoadCertFile(tlsConfig, addCertFile);
ASSERT_TRUE(addCert != NULL);
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ASSERT_TRUE(HITLS_CFG_SetCertificate(tlsConfig, cert, false) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_AddChainCert(tlsConfig, addCert, false) == HITLS_SUCCESS);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_ClearChainCerts(NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_ClearChainCerts(ctx) == HITLS_SUCCESS);
SAL_CERT_MgrCtxFree(ctx->config.tlsConfig.certMgrCtx);
ctx->config.tlsConfig.certMgrCtx = NULL;
ASSERT_EQ(HITLS_ClearChainCerts(ctx), HITLS_NULL_INPUT);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/interface_tlcp/test_suite_sdv_frame_cert_interface_2.c
|
C
|
unknown
| 11,572
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <unistd.h>
#include "securec.h"
#include "bsl_sal.h"
#include "bsl_log.h"
#include "bsl_err.h"
#include "bsl_uio.h"
#include "hitls_error.h"
#include "hitls_cert_reg.h"
#include "hitls_crypt_reg.h"
#include "hitls_config.h"
#include "tls_config.h"
#include "hitls.h"
#include "hs_common.h"
#include "hitls_func.h"
#include "tls.h"
#include "conn_init.h"
#include "crypt_errno.h"
#include "stub_replace.h"
#include "frame_tls.h"
#include "frame_link.h"
#include "rec_wrapper.h"
#include "hlt_type.h"
#include "hlt.h"
#include "process.h"
#include "hitls_crypt_init.h"
#include "bsl_list.h"
#include "simulate_io.h"
#include "alert.h"
#include "crypt_default.h"
#include "stub_crypt.h"
#include "hitls_crypt.h"
#define READ_BUF_SIZE 18432
#define MAX_CERT_LIST 4294967295
#define MIN_CERT_LIST 0
#define DEFAULT_SECURITYLEVEL 0
/* END_HEADER */
static HITLS_Config *GetHitlsConfigViaVersion(int ver)
{
HITLS_Config *config;
int32_t ret;
switch (ver) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
ret = HITLS_CFG_SetCheckKeyUsage(config, false);
if (ret != HITLS_SUCCESS) {
return NULL;
}
return config;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
ret = HITLS_CFG_SetCheckKeyUsage(config, false);
if (ret != HITLS_SUCCESS) {
return NULL;
}
return config;
case HITLS_VERSION_DTLS12:
config = HITLS_CFG_NewDTLS12Config();
ret = HITLS_CFG_SetCheckKeyUsage(config, false);
if (ret != HITLS_SUCCESS) {
return NULL;
}
return config;
default:
return NULL;
}
}
typedef struct {
HITLS_Config *config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_HandshakeState state;
bool isClient;
bool isSupportExtendMasterSecret;
bool isSupportClientVerify;
bool isSupportNoClientCert;
bool isSupportRenegotiation;
bool isSupportSessionTicket;
bool needStopBeforeRecvCCS;
} HandshakeTestInfo;
static uint8_t g_clientRandom[RANDOM_SIZE];
static uint8_t g_serverRandom[RANDOM_SIZE];
/* @
* @test UT_TLS_CM_SET_GET_UIO_API_TC001
* @title Test the HITLS_SetUio and HITLS_GetUio interfaces
* @precon nan
* @brief HITLS_SetUio
* 1. Input an empty connection context and a non-empty UIO. Expected result 1 is obtained
* 2. Input an empty connection context and an empty UIO. Expected result 1 is obtained
* 3. Input a non-empty connection context and an empty UIO. Expected result 1 is obtained
* 4. Input a non-empty connection context and a non-empty UIO. Expected result 2 is obtained
* HITLS_GetUio
* 1. Input an empty connection context. Expected result 3 is obtained
* 2. Input a non-empty connection context. Expected result 4 is obtained
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCESS
* 3. Return a null pointer
* 4. Return connection uio
@*/
/* BEGIN_CASE */
void UT_TLS_CM_SET_GET_UIO_API_TC001(int tlsVersion)
{
HitlsInit();
HITLS_Config *tlsConfig = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx* ctx = HITLS_New(tlsConfig);
BSL_UIO *uio = NULL;
BSL_UIO *uio2;
int32_t ret;
uio = BSL_UIO_New(BSL_UIO_TcpMethod());
ret = HITLS_SetUio(NULL, uio);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetUio(NULL, NULL);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetUio(ctx, NULL);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetUio(ctx, uio);
ASSERT_TRUE(ret == HITLS_SUCCESS);
uio2 = HITLS_GetUio(NULL);
ASSERT_TRUE(uio2 == NULL);
uio2 = HITLS_GetUio(ctx);
ASSERT_TRUE(uio2 != NULL);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
BSL_UIO_Free(uio);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SET_GET_READ_UIO_API_TC001
* @title Test the HITLS_SetReadUio, HITLS_GetReadUio interfaces
* @precon nan
* @brief HITLS_SetReadUio
* 1. Input an empty connection context and a non-empty UIO. Expected result 1 is obtained
* 2. Input an empty connection context and an empty UIO. Expected result 1 is obtained
* 2. Input a non-empty connection context and an empty UIO. Expected result 1 is obtained
* 4. Input a non-empty connection context and a non-empty UIO. Expected result 2 is obtained
* HITLS_GetReadUio
* 1. Input an empty connection context. Expected result 3 is obtained
* 2. Input a non-empty connection context. Expected result 4 is obtained
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCESS
* 3. Return a null pointer
* 4. Return connection uio
@*/
/* BEGIN_CASE */
void UT_TLS_CM_SET_GET_READ_UIO_API_TC001(int tlsVersion)
{
HitlsInit();
HITLS_Config *tlsConfig = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(tlsConfig != NULL) ;
HITLS_Ctx* ctx = HITLS_New(tlsConfig);
BSL_UIO *uio = NULL;
BSL_UIO *uio2 = NULL;
int32_t ret;
uio = BSL_UIO_New(BSL_UIO_TcpMethod());
ret = HITLS_SetReadUio(NULL, uio);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetReadUio(NULL, NULL);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetReadUio(ctx, NULL);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetReadUio(ctx, uio);
ASSERT_TRUE(ret == HITLS_SUCCESS);
uio2 = HITLS_GetReadUio(NULL);
ASSERT_TRUE(uio2 == NULL);
uio2 = HITLS_GetReadUio(ctx);
ASSERT_TRUE(uio2 != NULL);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
BSL_UIO_Free(uio);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SET_ENDPOINT_FUNC_TC001
* @title Invoke HITLS_SetEndPoint after initialization, check whether the state is handshaking
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1 is obtained
* 2. After initialization, call HITLS_SetEndPoint and check the state status. Expected result 2 is obtained
* @expect 1. Complete initialization
* 2. state is handshaking
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_ENDPOINT_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
uint32_t ret = HITLS_SetEndPoint(server->ssl, true);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(server->ssl->state, CM_STATE_HANDSHAKING);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test The HITLS_SetEndPoint function fails to be invoked during link establishment
* @title UT_TLS_CM_SET_ENDPOINT_FUNC_TC002
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1 is obtained
* 2. Invoke HITLS_SetEndPoint during link establishment. Expected result 2 is obtained
* @expect 1. Complete initialization
* 2. Invoking failed
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_ENDPOINT_FUNC_TC002(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, TRY_SEND_SERVER_HELLO) == HITLS_SUCCESS);
uint32_t ret = HITLS_SetEndPoint(server->ssl, true);
ASSERT_EQ(ret, HITLS_MSG_HANDLE_STATE_ILLEGAL);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test Obtains the maximum writable plaintext length after initialization
* @title UT_TLS_CM_GET_MAXWRITESIZE_FUNC_TC001
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1 is obtained
* 2. Invoke HITLS_GetMaxWriteSize to obtain the maximum writable plaintext length.
* Expected result 2 is obtained
* @expect 1. Complete initialization
* 2. Obtain the length successfully, the length is equal to REC_MAX_PLAIN_LENGTH
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_MAXWRITESIZE_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
uint32_t len = 0;
uint32_t ret = CONN_Init(client->ssl);
ASSERT_EQ(ret, HITLS_SUCCESS);
ret = HITLS_GetMaxWriteSize(client->ssl, &len);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(len, REC_MAX_PLAIN_LENGTH);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SET_GET_USR_DATA_TC001
* @title test HITLS_SetUserData, HITLS_GetUserData interfaces
* @precon nan
* @brief HITLS_SetUserData
* 1. Input an empty connection context and a non-empty userData. Expected result 1 is obtained
* 2. Input an empty connection context and an empty userData. Expected result 1 is obtained
* 3. Input a non-empty connection context and an empty userData. Expected result 2 is obtained
* 4. Input a non-empty connection context and a non-empty userData. Expected result 2 is obtained
* HITLS_GetUserData
* 1. Input an empty connection context. Expected result 4 is obtained
* 2. Input a non-empty connection context. Expected result 3 is obtained
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCESS
* 3. Return userData
* 4. Return a null pointer
@*/
/* BEGIN_CASE */
void UT_TLS_CM_SET_GET_USR_DATA_API_TC001(int tlsVersion)
{
HitlsInit();
HITLS_Config *tlsConfig = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(tlsConfig != NULL) ;
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
int32_t ret;
uint8_t userData[5] = {0};
void *ret2 = HITLS_GetUserData(NULL);
ASSERT_TRUE(ret2 == NULL);
ret = HITLS_SetUserData(NULL, &userData);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetUserData(NULL, NULL);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetUserData(ctx, NULL);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret = HITLS_SetUserData(ctx, &userData);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret = HITLS_SetUserData(ctx, "userdata");
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret2 = HITLS_GetUserData(ctx);
ASSERT_TRUE(strcmp(ret2, "userdata") == 0);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SET_GET_USR_DATA_TC001
* @title test HITLS_SESS_SetUserData, HITLS_SESS_GetUserData interfaces
* @precon nan
* @brief HITLS_SESS_GetUserData
* 1. Input an empty connection context and a non-empty userData. Expected result 1 is obtained
* 2. Input an empty connection context and an empty userData. Expected result 1 is obtained
* 3. Input a non-empty connection context and an empty userData. Expected result 2 is obtained
* 4. Input a non-empty connection context and a non-empty userData. Expected result 2 is obtained
* HITLS_SESS_GetUserData
* 1. Input an empty connection context. Expected result 4 is obtained
* 2. Input a non-empty connection context. Expected result 3 is obtained
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCESS
* 3. Return userData
* 4. Return a null pointer
@*/
/* BEGIN_CASE */
void UT_TLS_CM_SESSION_SET_GET_USR_DATA_API_TC001(void)
{
HitlsInit();
HITLS_Session *session = HITLS_SESS_New();
int32_t ret;
uint8_t userData[5] = {0};
void *ret2 = HITLS_SESS_GetUserData(NULL);
ASSERT_TRUE(ret2 == NULL);
ret = HITLS_SESS_SetUserData(NULL, &userData);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SESS_SetUserData(NULL, NULL);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SESS_SetUserData(session, NULL);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret = HITLS_SESS_SetUserData(session, &userData);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret = HITLS_SESS_SetUserData(session, "userdata");
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret2 = HITLS_SESS_GetUserData(session);
ASSERT_TRUE(strcmp(ret2, "userdata") == 0);
EXIT:
HITLS_SESS_Free(session);
}
/* END_CASE */
/* @
* @test HITLS_SetShutdownState Set HITLS_SENT_SHUTDOWN to 1 and do not send the close_notify message.
* @title UT_TLS_CM_SET_SHUTDOWN_FUNC_TC001
* @precon nan
* @brief 1. Set HITLS_SENT_SHUTDOWN to 1 and invoke the Hitls_Close interface. Expected result 1 is obtained
* @expect 1. The interface is successfully invoked and the close_notify message is not sent
@*/
/* BEGIN_CASE */
void UT_TLS_CM_SET_SHUTDOWN_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = GetHitlsConfigViaVersion(version);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_SetShutdownState(client->ssl, 1) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Close(client->ssl) == HITLS_SUCCESS);
ASSERT_TRUE(client->ssl->state == CM_STATE_CLOSED);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(client, server) == HITLS_SUCCESS);
FrameUioUserData *ioUserData = BSL_UIO_GetUserData(server->io);
uint32_t readLen = ioUserData->recMsg.len;
ASSERT_TRUE(readLen == 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GET_SHUTDOWN_FUNC_TC001
* @title Use HITLS_GetShutdownState to obtain the configured value
* @precon nan
* @brief 1. Set HITLS_SENT_SHUTDOWN to 1 and invoke the HITLS_GetShutdownState interface. Expected result 1
* 2. Set HITLS_SENT_SHUTDOWN to 2 and invoke the HITLS_GetShutdownState interface. Expected result 2
* 3. Set HITLS_SENT_SHUTDOWN to 0 and invoke the HITLS_GetShutdownState interface. Expected result 3
* @expect 1. Obtain value 1
* 2. Obtain value 2
* 3. Obtain value 0.
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_SHUTDOWN_FUNC_TC001(int version)
{
int32_t ret;
uint32_t mode;
HitlsInit();
HITLS_Config *tlsConfig = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
CONN_Init(ctx);
ASSERT_TRUE(ctx != NULL);
for (uint32_t i = 0; i <= 2; i++) {
ret = HITLS_SetShutdownState(ctx, i);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret = HITLS_GetShutdownState(ctx, &mode);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(mode == i);
}
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GET_NEGOTIATED_VERSION_FUNC_TC001
* @title HITLS_GetNegotiatedVersion Interface in TLS1.2 Scenario and TLS1.3 Scenario
* @precon nan
* @brief 1. Set the protocol version to TLS1.2 or TLS1.3. After initialization, invoke the HITLS_GetNegotiatedVersion
* interface to obtain the negotiated version number. Expected result 1 is obtained
* 2. Set the protocol version to TLS1.2 or TLS1.3. After the connection is established, invoke the
* HITLS_GetNegotiatedVersion interface to obtain the negotiated version number. Expected result 2 is obtained
* @expect 1. obtained value is 0
* 2. obtained value is tls1.2/tls1.3
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_NEGOTIATED_VERSION_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
config->isSupportRenegotiation = true;
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config, 1), HITLS_SUCCESS);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
uint16_t negoVersion = HITLS_VERSION_TLCP_DTLCP11;
ret = HITLS_GetNegotiatedVersion(client->ssl, &negoVersion);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(negoVersion, 0);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ret = HITLS_GetNegotiatedVersion(client->ssl, &negoVersion);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(negoVersion, version);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SET_GET_MAX_PROTO_VERSION_API_TC001
* @title test HITLS_SetMaxProtoVersion, HITLS_GetMaxProtoVersion interfaces
* @precon nan
* @brief HITLS_SetMaxProtoVersion
* 1. Input an empty connection context. Expected result 1 is obtained
* 2. Input a non-empty connection context and version is too low. Expected result 2 is obtained
* 3. Input a non-empty connection context and normal version. Expected result 3 is obtained
* HITLS_GetMaxProtoVersion
* 1. Input an empty connection context and a null pointer. Expected result 1 is obtained
* 2. Input an empty connection context and a non-empty pointer. Expected result 1 is obtained
* 3. Input a non-empty connection context and a non-empty pointer. Expected result 3 is obtained
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_CONFIG_INVALID_VERSION
3. Return HITLS_SUCCESS
@*/
/* BEGIN_CASE */
void UT_TLS_CM_SET_GET_MAX_PROTO_VERSION_API_TC001(int tlsVersion)
{
HitlsInit();
HITLS_Config *tlsConfig = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
int32_t ret;
uint16_t maxVersion = 0;
ret = HITLS_SetMaxProtoVersion(NULL, HITLS_VERSION_TLS10);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetMaxProtoVersion(ctx, HITLS_VERSION_TLS10);
ASSERT_TRUE(ret == HITLS_CONFIG_INVALID_VERSION);
ret = HITLS_SetMaxProtoVersion(ctx, HITLS_VERSION_TLS13);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret = HITLS_GetMaxProtoVersion(NULL, NULL);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_GetMaxProtoVersion(NULL, &maxVersion);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_GetMaxProtoVersion(ctx, &maxVersion);
ASSERT_TRUE(ret == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SET_GET_MIN_PROTO_VERSION_API_TC001
* @title test HITLS_SetMinProtoVersion, HITLS_GetMinProtoVersion interfaces
* @precon nan
* @brief HITLS_SetMaxProtoVersion
* 1. Input an empty connection context. Expected result 1 is obtained
* 2. Input a non-empty connection context and version is too high. Expected result 2 is obtained
* 3. Input a non-empty connection context and normal version. Expected result 3 is obtained
* HITLS_GetMinProtoVersion
* 1. Input an empty connection context and a null pointer. Expected result 1 is obtained
* 2. Input an empty connection context and a non-empty pointer. Expected result 1 is obtained
* 3. Input a non-empty connection context and a non-empty pointer. Expected result 3 is obtained
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_CONFIG_INVALID_VERSION
* 3. Return HITLS_SUCCESS
@*/
/* BEGIN_CASE */
void UT_TLS_CM_SET_GET_MIN_PROTO_VERSION_API_TC001(int tlsVersion)
{
HitlsInit();
HITLS_Config *tlsConfig = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(tlsConfig != NULL) ;
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
int32_t ret;
uint16_t minVersion = 0;
ret = HITLS_SetMinProtoVersion(NULL, HITLS_VERSION_TLS12);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetMinProtoVersion(ctx, HITLS_VERSION_TLS13);
ASSERT_TRUE(ret == HITLS_CONFIG_INVALID_VERSION);
ret = HITLS_SetMinProtoVersion(ctx, HITLS_VERSION_TLS12);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret = HITLS_GetMinProtoVersion(NULL, NULL);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_GetMinProtoVersion(NULL, &minVersion);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_GetMinProtoVersion(ctx, &minVersion);
ASSERT_TRUE(ret == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_IS_AEAD_FUNC_TC001
* @title HITLS_IsAead Obtains whether to use the AEAD algorithm after negotiation
* @precon TLS12, HITLS_RSA_with_AES_128_CBC_SHA256 (not AEAD), TLS13, HITLS_CHACHA20_POLY1305_SHA256 /
* HITLS_AES_128_GCM_SHA256 (AEAD)
* @brief 1. Initialize the client and server and set the cipherSuite. Expected result 1
* 2. After connection is established, invoke HITLS_IsAead to check whether
* the AEAD algorithm is negotiated. Expected result 2
* @expect 1. Initialization is complete.
* 2. Value of isAEAD
@ */
/* BEGIN_CASE */
void UT_TLS_CM_IS_AEAD_FUNC_TC001(int version, int ciphersuite)
{
FRAME_Init();
int ret;
uint8_t isAEAD = 0;
HITLS_Config *config_c = GetHitlsConfigViaVersion(version);
HITLS_Config *config_s = GetHitlsConfigViaVersion(version);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
uint16_t cipherSuites[] = {(uint16_t)ciphersuite};
HITLS_CFG_SetCipherSuites(config_c, cipherSuites, sizeof(cipherSuites) / sizeof(uint16_t));
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
ret = HITLS_IsAead(client->ssl, &isAEAD);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(isAEAD == (version == HITLS_VERSION_TLS13));
ret = HITLS_IsAead(server->ssl, &isAEAD);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(isAEAD == (version == HITLS_VERSION_TLS13));
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test HITLS_IsHandShakeDone Check whether the handshake is complete during connection establishment
* @title UT_TLS_CM_IS_HSDONE_FUNC_TC001
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1
* 2. During connection establishment, invoke HITLS_IsHandShakeDone to check whether the handshake is complete.
* Expected result 2
* @expect 1. Initialization is complete
* 2. The interface returns 0 and the handshake is not done
@ */
/* BEGIN_CASE */
void UT_TLS_CM_IS_HSDONE_FUNC_TC001(int version, int state)
{
FRAME_Init();
int ret;
uint8_t isDone;
HITLS_Config *config = GetHitlsConfigViaVersion(version);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
HITLS_HandshakeState curState = (HITLS_HandshakeState)state;
ret = FRAME_CreateConnection(client, server, true, curState);
ret = HITLS_IsHandShakeDone(client->ssl, &isDone);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(isDone == 0);
ret = HITLS_IsHandShakeDone(server->ssl, &isDone);
ASSERT_TRUE(ret == HITLS_SUCCESS);
if (version == HITLS_VERSION_TLS12 && curState == TRY_RECV_FINISH) {
ASSERT_TRUE(isDone == 1);
} else {
ASSERT_TRUE(isDone == 0);
}
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test HITLS_IsHandShakeDone Check whether the handshake is complete after connection establishment
* @title UT_TLS_CM_IS_HSDONE_FUNC_TC002
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1
* 2. After the connection is established, invoke HITLS_IsHandShakeDone to check whether the handshake
* is complete. Expected result 2
* @expect 1. Initialization is complete
* 2. The interface returns 1 and the handshake is done
@ */
/* BEGIN_CASE */
void UT_TLS_CM_IS_HSDONE_FUNC_TC002(int version)
{
FRAME_Init();
int ret;
uint8_t isDone;
HITLS_Config *config = GetHitlsConfigViaVersion(version);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
ret = HITLS_IsHandShakeDone(client->ssl, &isDone);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(isDone == 1);
ret = HITLS_IsHandShakeDone(server->ssl, &isDone);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(isDone == 1);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_IS_SERVER_FUNC_TC001
* @title HITLS_IsServer The client invokes the interface to determine whether the current server is the server
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1
* 2. The client invokes the HITLS_IsServer interface to determine whether the current client is a server.
* Expected result 2
* 3. The server invokes the HITLS_IsServer interface to determine whether the current server is a server.
* Expected result 3
* @expect 1. Initialization is complete
* 2. The interface returns false
* 3. The interface returns true
@ */
/* BEGIN_CASE */
void UT_TLS_CM_IS_SERVER_FUNC_TC001(int version)
{
FRAME_Init();
int ret;
uint8_t isServer;
HITLS_Config *config = GetHitlsConfigViaVersion(version);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
ret = HITLS_IsServer(client->ssl, &isServer);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(isServer == false);
ret = HITLS_IsServer(server->ssl, &isServer);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(isServer == true);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_READHASPENDING_FUNC_TC001
* @title HITLS_ReadHasPending Interface test
* @precon nan
* @brief 1. After initialization, invoke the hitls_readhaspending interface. Expected result 1 is obtained.
* 2. After the connection is established, the peer sends data and the local
* invokes the hitls_readhaspending interface. Expected result 2 is obtained.
* @expect 1. Return 0
* 2. Return 1
@ */
/* BEGIN_CASE */
void UT_TLS_CM_READHASPENDING_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = GetHitlsConfigViaVersion(version);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
uint8_t isPending = 0;
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(HITLS_ReadHasPending(client->ssl, &isPending) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_ReadHasPending(server->ssl, &isPending) == HITLS_SUCCESS);
ASSERT_EQ(isPending, 0);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
uint8_t data[] = "Hello World";
uint32_t writeLen;
ASSERT_TRUE(HITLS_Write(client->ssl, data, sizeof(data), &writeLen) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(client, server) == HITLS_SUCCESS);
uint8_t readBuf[5] = {0};
uint32_t readLen = 0;
ASSERT_TRUE(HITLS_Read(server->ssl, readBuf, 5, &readLen) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_ReadHasPending(server->ssl, &isPending) == HITLS_SUCCESS);
ASSERT_EQ(isPending, 1);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GET_READPENDING_FUNC_TC001
* @title HITLS_GetReadPendingBytes interfaces test
* @precon nan
* @brief 1. After initialization, invoke the HITLS_GetReadPendingBytes interface to query data.
* Expected result 1 is obtained.
* 2. Simulate a scenario where the peer end sends app data during renegotiation to generate app data cache,
* and invoke HITLS_GetReadPendingBytes to obtain the cache value. Expected result 2 is obtained.
* 3. When the buffer length of the HITLS_Read read data is less than 16 KB, some data is left.
* Invoke the HITLS_GetReadPendingBytes interface to query the data. Expected result 3 is obtained.
* @expect 1. The return value is 0.
* 2. Returns the size of the cached value.
* 3. Returns the size of the left value.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_READPENDING_FUNC_TC001(void)
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
config->isSupportRenegotiation = true;
FRAME_LinkObj *client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
FRAME_LinkObj *server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(HITLS_GetReadPendingBytes(server->ssl) == 0);
ASSERT_TRUE(HITLS_GetReadPendingBytes(client->ssl) == 0);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(client->ssl) == HITLS_SUCCESS);
uint8_t data[] = "Hello World";
uint32_t writeLen;
ASSERT_TRUE(HITLS_Write(server->ssl, data, sizeof(data), &writeLen) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(server, client) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Connect(client->ssl) == HITLS_REC_NORMAL_IO_BUSY);
client->ssl->state = CM_STATE_ALERTING;
ASSERT_TRUE(HITLS_GetReadPendingBytes(client->ssl) == sizeof("Hello World"));
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test HITLS_GetPeerSignScheme Unidirectional authentication on the client
* @title UT_TLS_CM_GET_PEER_SIGN_SCHEME_FUNC_TC001
* @precon nan
* @brief 1. Configure unidirectional authentication. After the negotiation is complete,
* call the interface to obtain the local signature hash algorithm. Expected result 1 is displayed.
* 2. Call the interface to obtain the peer signature hash algorithm. Expected result 2 is obtained.
* @expect 1. Return 0
* 2. Return 0
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_PEER_SIGN_SCHEME_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
HITLS_CFG_SetClientVerifySupport(config, false);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
HITLS_SignHashAlgo peerSignScheme = CERT_SIG_SCHEME_UNKNOWN;
uint32_t ret = HITLS_GetPeerSignScheme(server->ssl, &peerSignScheme);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(peerSignScheme, 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test HITLS_GetPeerSignScheme Client two-way authentication Verification
* @title UT_TLS_CM_GET_PEER_SIGN_SCHEME_FUNC_TC002
* @precon nan
* @brief 1. Set two-way authentication. Before the client receives the certificate request, call the interface to
* obtain the local signature hash algorithm. Expected result 1 is obtained.
* 2. After receiving the certificate request, the client invokes the interface to obtain the negotiated
8 signature hash algorithm. Expected result 2 is displayed.
* @expect 1. Return 0
* 2. The returned value is the negotiated algorithm
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_PEER_SIGN_SCHEME_FUNC_TC002(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
HITLS_CFG_SetClientVerifySupport(config, true);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_CERTIFICATE_REQUEST) == HITLS_SUCCESS);
HITLS_SignHashAlgo peerSignScheme = CERT_SIG_SCHEME_UNKNOWN;
//
uint32_t ret = HITLS_GetPeerSignScheme(client->ssl, &peerSignScheme);
ASSERT_EQ(ret, HITLS_SUCCESS);
if (version == HITLS_VERSION_TLS13) {
ASSERT_EQ(peerSignScheme, 0);
} else {
ASSERT_NE(peerSignScheme, 0);
}
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
peerSignScheme = CERT_SIG_SCHEME_UNKNOWN;
ret = HITLS_GetPeerSignScheme(client->ssl, &peerSignScheme);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_NE(peerSignScheme, 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GET_PEER_SIGN_SCHEME_FUNC_TC003
* @title HITLS_GetPeerSignScheme Client Verification
* @precon nan
* @brief 1. Before the client receives the serverkeyexchange message, call the interface to obtain the peer signature
* hash algorithm. Expected result 1 is displayed.
* 2. After receiving the serverkeyexchange message, the client invokes the interface to obtain the signature
* hash algorithm of the peer end. Expected result 2 is obtained.
* @expect 1. Return 0
* 2. The return value is the algorithm used by the server
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_PEER_SIGN_SCHEME_FUNC_TC003(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
HITLS_CFG_SetClientVerifySupport(config, true);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
HITLS_SignHashAlgo peerSignScheme = CERT_SIG_SCHEME_UNKNOWN;
uint32_t ret = HITLS_GetPeerSignScheme(server->ssl, &peerSignScheme);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(peerSignScheme, 0);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
peerSignScheme = CERT_SIG_SCHEME_UNKNOWN;
ret = HITLS_GetPeerSignScheme(client->ssl, &peerSignScheme);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(peerSignScheme, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GET_PEER_SIGN_SCHEME_FUNC_TC004
* @title HITLS_GetPeerSignScheme two-way authentication verification on the server
* @precon nan
* @brief 1. Set two-way authentication. Before the server receives the certificate verify message,
* call the API to obtain the peer signature hash algorithm. Expected result 1 is obtained.
* 2. After receiving the certificate verify message, the server invokes the API to obtain the signature hash
* algorithm of the peer end. Expected result 2 is obtained.
* @expect 1. Return 0
* 2. The returned value is the algorithm used by the client
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_PEER_SIGN_SCHEME_FUNC_TC004(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
HITLS_CFG_SetClientVerifySupport(config, true);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_SEND_CERTIFICATE_VERIFY) == HITLS_SUCCESS);
HITLS_SignHashAlgo peerSignScheme = CERT_SIG_SCHEME_UNKNOWN;
uint32_t ret = HITLS_GetPeerSignScheme(server->ssl, &peerSignScheme);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(peerSignScheme, 0);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
peerSignScheme = CERT_SIG_SCHEME_UNKNOWN;
ret = HITLS_GetPeerSignScheme(server->ssl, &peerSignScheme);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_NE(peerSignScheme, 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GET_LOCAL_SIGN_SCHEME_FUNC_TC001
* @title HITLS_GetLocalSignScheme Server-side verification
* @precon nan
* @brief 1. Before the server receives the client hello message, call the interface to obtain the negotiated signature
* hash algorithm. Expected result 1 is displayed
* 2. After receiving the client hello message, the server invokes the interface to obtain the negotiated
* signature hash algorithm. Expected result 2 is displayed
* @expect 1. Return 0
* 2. The return value is the algorithm used by the server
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_LOCAL_SIGN_SCHEME_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
config->isSupportRenegotiation = true;
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config, 1), HITLS_SUCCESS);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
HITLS_SignHashAlgo localSignScheme = CERT_SIG_SCHEME_UNKNOWN;
ret = HITLS_GetLocalSignScheme(server->ssl, &localSignScheme);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(localSignScheme, 0);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
ret = HITLS_GetLocalSignScheme(server->ssl, &localSignScheme);
ASSERT_EQ(ret, HITLS_SUCCESS);
switch (version) {
case HITLS_VERSION_TLS12:
ASSERT_EQ(localSignScheme, CERT_SIG_SCHEME_RSA_PKCS1_SHA256);
break;
case HITLS_VERSION_TLS13:
ASSERT_EQ(localSignScheme, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256);
break;
default:
config = NULL;
break;
}
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SET_EC_GROUPS_FUNC_TC001
* @title test HITLS_SetEcGroups interface
* @precon nan
* @brief 1. Input an empty link context and a non-empty group. Normal groupsize. Expected result 1 is obtained
* 2. Input a non-empty link context, empty group, and normal groupsize. Expected result 1 is obtained.
* 3. Input a non-empty link context, a non-empty group, and groupsize 0. Expected result 1 is obtained
* 4. Transfer a non-empty link context, a non-empty group, and normal groupsize. Expected result 2 is obtained
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_EC_GROUPS_FUNC_TC001(int tlsVersion)
{
HitlsInit();
HITLS_Config *tlsConfig = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
uint16_t groups[] = {HITLS_EC_GROUP_SECP256R1, HITLS_EC_GROUP_SECP521R1};
uint32_t groupsSize = sizeof(groups) / sizeof(uint16_t);
int32_t ret;
ret = HITLS_SetEcGroups(NULL, groups, groupsSize);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetEcGroups(ctx, NULL, groupsSize);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetEcGroups(ctx, groups, 0);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetEcGroups(ctx, groups, groupsSize);
ASSERT_TRUE(ret == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SET_SIGAL_LIST_FUNC_TC001
* @title test HITLS_SetSigalgsList interface
* @precon nan
* @brief 1. Input an empty link context and a non-empty signAlg. Normal signAlgsSize. Expected result 1 is obtained
* 2. Input an non-empty link context and an empty signAlg. Normal signAlgsSize. Expected result 1 is obtained
* 2. Input a non-empty link context and a non-empty signAlg. 0 signAlgsSize. Expected result 1 is obtained
* 2. Input a non-empty link context and a non-empty signAlg. Normal signAlgsSize. Expected result 2 is obtained
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCESS
@*/
/* BEGIN_CASE */
void UT_TLS_CM_SET_SIGAL_LIST_FUNC_TC001(int tlsVersion)
{
HitlsInit();
HITLS_Config *tlsConfig = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(tlsConfig != NULL) ;
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
uint32_t signAlgsSize = sizeof(signAlgs) / sizeof(uint16_t);
int32_t ret;
ret = HITLS_SetSigalgsList(NULL, signAlgs, signAlgsSize);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetSigalgsList(ctx, NULL, signAlgsSize);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetSigalgsList(ctx, signAlgs, 0);
ASSERT_TRUE(ret == HITLS_NULL_INPUT);
ret = HITLS_SetSigalgsList(ctx, signAlgs, signAlgsSize);
ASSERT_TRUE(ret == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SET_EC_POINT_FUNC_TC001
* @title Set the normal dot format value.
* @precon nan
* @brief 1. Set pointFormats to HITLS_POINT_FORMAT_UNCOMPRESSED and invoke the HITLS_CFG_SetEcPointFormats interface.
* Expected result 1 is obtained.
* 2. Set pointFormats to HITLS_POINT_FORMAT_BUTT and invoke the HITLS_CFG_SetEcPointFormats interface.
* Expected result 2
* 3. Use config to generate ctx, due to the result 3
* 4. Set pointFormats to HITLS_POINT_FORMAT_UNCOMPRESSED again and generate ctx again. Expected result 4 is
* obtained. Set pointFormats to HITLS_POINT_FORMAT_UNCOMPRESSED and invoke the HITLS_SetEcPointFormats
* interface. Expected result 2
* @expect 1. Interface return value, HITLS_SUCCESS
* 2. Interface return value: HITLS_SUCCESS
* 3. Failed to generate the file.
* 4. The file is generated successfully.
* 5. The setting is successful.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_EC_POINT_FUNC_TC001(int version)
{
FRAME_Init();
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
HITLS_Config *Config = NULL;
HITLS_Ctx *ctx = NULL;
Config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(Config != NULL);
const uint8_t pointFormats[] = {HITLS_POINT_FORMAT_UNCOMPRESSED};
uint32_t pointFormatsSize = sizeof(pointFormats) / sizeof(uint8_t);
ASSERT_TRUE(HITLS_CFG_SetEcPointFormats(Config, pointFormats, pointFormatsSize) == HITLS_SUCCESS);
const uint8_t pointFormats2[] = {HITLS_POINT_FORMAT_BUTT};
uint32_t pointFormatsSize2 = sizeof(pointFormats2) / sizeof(uint8_t);
ASSERT_TRUE(HITLS_CFG_SetEcPointFormats(Config, pointFormats2, pointFormatsSize2) == HITLS_SUCCESS);
ctx = HITLS_New(Config);
if(version == TLS1_2){
ASSERT_TRUE(ctx == NULL);
}
HITLS_Free(ctx);
ASSERT_TRUE(HITLS_CFG_SetEcPointFormats(Config, pointFormats, pointFormatsSize) == HITLS_SUCCESS);
ctx = HITLS_New(Config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetEcPointFormats(ctx, pointFormats, pointFormatsSize) == HITLS_SUCCESS);
client = FRAME_CreateLink(Config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(Config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(Config);
HITLS_Free(ctx);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GET_CONFIG_FUNC_TC001
* @title After the initialization is complete, obtain the config file and check whether the configuration is consistent
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1 is obtained
* 2. After the initialization is complete, obtain hitlsConfig and check whether the main configurations are
* consistent with the settings. Expected result 2 is obtained.
* @expect 1. Complete initialization
* 2. Consistent results
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_CONFIG_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
config->isSupportRenegotiation = true;
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
const HITLS_Config *cfgFromCtx = NULL;
cfgFromCtx = HITLS_GetConfig(client->ssl);
ASSERT_TRUE(cfgFromCtx != NULL);
ASSERT_EQ(cfgFromCtx->signAlgorithmsSize, sizeof(signAlgs) / sizeof(uint16_t));
ASSERT_TRUE(memcmp(cfgFromCtx->signAlgorithms, signAlgs, cfgFromCtx->signAlgorithmsSize) == 0);
ASSERT_EQ(cfgFromCtx->isSupportRenegotiation, true);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GET_CURRENT_CIPHER_FUNC_TC001
* @title HITLS_GetCurrentCipher Obtain the negotiated cipher suite pointer after initialization and before negotiation
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1 is obtained
* 2. Before link establishment, call HITLS_GetCurrentCipher to obtain the negotiated cipher suite pointer.
* Expected result 2 is returned.
* @expect 1. Complete initialization
* 2. Return NULL
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_CURRENT_CIPHER_FUNC_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
tlsConfig = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
CONN_Init(ctx);
ASSERT_TRUE(ctx != NULL);
const HITLS_Cipher *hitlsCipher = HITLS_GetCurrentCipher(ctx);
ASSERT_EQ(hitlsCipher->cipherSuite, 0);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GET_RANDOM_FUNC_TC001
* @title tls1.3 Obtain clientRandom and serverRandom
* @precon nan
* @brief 1. establish connection
* 2. Obtain and compare clientRandom and serverRandom.
* @expect 1. Return success
* 2. The clientRandom stored on the server is the same as that sent by the client, and the serverRandom stored
8 on the client is the same as that sent by the server.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_RANDOM_FUNC_TC001(void)
{
HandshakeTestInfo testInfo = {0};
FRAME_Init();
testInfo.config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(testInfo.config != NULL);
testInfo.client = FRAME_CreateLink(testInfo.config, BSL_UIO_TCP);
ASSERT_TRUE(testInfo.client != NULL);
testInfo.server = FRAME_CreateLink(testInfo.config, BSL_UIO_TCP);
ASSERT_TRUE(testInfo.server != NULL);
FRAME_CreateConnection(testInfo.client, testInfo.server, true, HS_STATE_BUTT);
uint8_t clientRandom[RANDOM_SIZE];
uint8_t serverRandom[RANDOM_SIZE];
uint32_t randomSize = RANDOM_SIZE;
ASSERT_TRUE(HITLS_GetHsRandom(testInfo.client->ssl, g_clientRandom, &randomSize, true) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetHsRandom(testInfo.server->ssl, clientRandom, &randomSize, true) == HITLS_SUCCESS);
ASSERT_TRUE(randomSize == RANDOM_SIZE);
ASSERT_TRUE(memcmp(g_clientRandom, clientRandom, RANDOM_SIZE) == 0);
ASSERT_TRUE(HITLS_GetHsRandom(testInfo.server->ssl, g_serverRandom, &randomSize, false) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetHsRandom(testInfo.client->ssl, serverRandom, &randomSize, false) == HITLS_SUCCESS);
ASSERT_TRUE(randomSize == RANDOM_SIZE);
ASSERT_TRUE(memcmp(g_serverRandom, serverRandom, RANDOM_SIZE) == 0);
EXIT:
HITLS_CFG_FreeConfig(testInfo.config);
FRAME_FreeLink(testInfo.client);
FRAME_FreeLink(testInfo.server);
}
/* END_CASE */
/* @
* @test HITLS_GetHandShakeState change state to alerting, obtain the state
* @title UT_TLS_CM_GET_HANDSHAKE_STATE_FUNC_TC001
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1 is obtained
* 2. When an alerting message is generated during data transmission, invoke HITLS_GetHandShakeState to stop
* sending the alerting message and obtain the current status. Expected result 2 is obtained
* @expect 1. Complete initialization
* 2. Return TLS_CONNECTED
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_HANDSHAKE_STATE_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
config->isSupportRenegotiation = true;
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config, 1), HITLS_SUCCESS);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
client->ssl->method.sendAlert(client->ssl, ALERT_LEVEL_WARNING, ALERT_NO_CERTIFICATE_RESERVED);
ret = ALERT_Flush(client->ssl);
ASSERT_EQ(ret, HITLS_SUCCESS);
uint32_t state = 0;
ret = HITLS_GetHandShakeState(client->ssl, &state);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(state, TLS_CONNECTED);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test HITLS_GetStateString Query the handshake status in sequence.
* @title UT_TLS_CM_GET_STATE_STRING_FUNC_TC001
* @precon nan
* @brief 1. Invoke the HITLS_GetStateString interface and transfer values 0-30 and 255 at a time. Expected result 1.
* @expect 1. The interface returns the corresponding handshake status.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_STATE_STRING_FUNC_TC001()
{
const char goalStr[34][32] = {
"idle",
"connected",
"send hello request",
"send client hello",
"send hello retry request",
"send server hello",
"send hello verify request",
"send encrypted extensions",
"send certificate",
"send server key exchange",
"send certificate request",
"send server hello done",
"send client key exchange",
"send certificate verify",
"send new session ticket",
"send change cipher spec",
"send end of early data",
"send finished",
"send keyupdate",
"recv client hello",
"recv server hello",
"recv hello verify request",
"recv encrypted extensions",
"recv certificate",
"recv server key exchange",
"recv certificate request",
"recv server hello done",
"recv client key exchange",
"recv certificate verify",
"recv new session ticket",
"recv end of early data",
"recv finished",
"recv keyupdate",
"recv hello request",
};
int32_t ret;
for (uint32_t i = 0; i <= 30; i++) {
ret = strcmp(HITLS_GetStateString(i), goalStr[i]);
ASSERT_TRUE(strcmp(HITLS_GetStateString(i), goalStr[i]) == 0);
}
ASSERT_TRUE(strcmp(HITLS_GetStateString(255), "unknown") == 0);
EXIT:
return;
}
/* END_CASE */
/* @
* @test HITLS_IsHandShaking function point test
* @title UT_TLS_CM_IS_HANDSHAKING_FUNC_TC001
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1.
* 2. Invoke the HITLS_IsHandShaking interface to check whether handshake is in progress. Expected result 2.
* 3. Initiate a connection establishment request and invoke the HITLS_IsHandShaking interface during connection establishment. (Expected result 3)
* 4. Invoke HITLS_IsHandShaking to complete connection establishment. Expected result 4.
* 5. Invoke the HITLS_Renegotiate interface to initiate renegotiation. (Expected result 5.)
* 6. Invoke the HITLS_IsHandShaking interface to check whether the handshake is in progress. (Expected result 6)
* 7. After the renegotiation is complete, invoke the HITLS_IsHandShaking interface to check whether handshake is in progress. Expected result 7.
*@expect 1. Initialization is complete.
* 2. The interface output parameter is 0.
* 3. The interface output parameter is 1.
* 4. The interface output parameter is 0.
* 5. The state changes to the renegotiation state.
* 6. The output parameter of the interface is 1.
* 7. The interface output parameter is 0.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_IS_HANDSHAKING_FUNC_TC001(int version)
{
FRAME_Init();
uint8_t isHandShaking = 0;
HITLS_Config *tlsConfig = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(tlsConfig != NULL);
tlsConfig->isSupportRenegotiation = true;
FRAME_LinkObj *client = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(tlsConfig, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_IDLE);
ASSERT_TRUE(HITLS_IsHandShaking(clientTlsCtx, &isHandShaking) == HITLS_SUCCESS);
ASSERT_TRUE(isHandShaking == 0);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(HITLS_IsHandShaking(clientTlsCtx, &isHandShaking) == HITLS_SUCCESS);
ASSERT_TRUE(isHandShaking == 1);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(HITLS_IsHandShaking(clientTlsCtx, &isHandShaking) == HITLS_SUCCESS);
ASSERT_TRUE(isHandShaking == 0);
if (version == HITLS_VERSION_TLS12) {
ASSERT_EQ(HITLS_Renegotiate(clientTlsCtx), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Renegotiate(serverTlsCtx), HITLS_SUCCESS);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_RENEGOTIATION);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_RENEGOTIATION);
ASSERT_TRUE(HITLS_IsHandShaking(clientTlsCtx, &isHandShaking) == HITLS_SUCCESS);
ASSERT_TRUE(isHandShaking == 1);
ASSERT_TRUE(FRAME_CreateRenegotiationState(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(HITLS_IsHandShaking(clientTlsCtx, &isHandShaking) == HITLS_SUCCESS);
ASSERT_TRUE(isHandShaking == 0);
}
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test UT_TLS_CM_HITLS_IsBeforeHandShake_FUNC_TC001
* @title HITLS_IsBeforeHandShake Check whether the handshake is not performed
* @percon NA
* @brief
* 1. Initialize the client and server. Expected result 1
* 2. Call HITLS_IsBeforeHandShake to check whether the handshake has not been performed. Expected result 2
* 3. During transporting, call HITLS_IsBeforeHandShake to check whether the handshake has not been performed
* Expected result 3
* 4. Establish a connection and invoke the HITLS_IsBeforeHandShake interface to check whether the handshake
* has not been performed.Expected result 4
* @expect
* 1. Initialization is complete
* 2. isBefore will be 1
* 3. isBefore will be 0
* 4. isBefore will be 0
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_IsBeforeHandShake_FUNC_TC001(int version)
{
FRAME_Init();
int ret = 0;
uint8_t isBefore = 0;
HITLS_Config *config_c = GetHitlsConfigViaVersion(version);
HITLS_Config *config_s = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
FRAME_LinkObj *server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ret = HITLS_IsBeforeHandShake(client->ssl, &isBefore);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(client->ssl->state == CM_STATE_IDLE);
ASSERT_TRUE(isBefore == 1);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO), HITLS_SUCCESS);
ret = HITLS_IsBeforeHandShake(client->ssl, &isBefore);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(client->ssl->state == CM_STATE_HANDSHAKING);
ASSERT_TRUE(isBefore == 0);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(client->ssl->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(isBefore == 0);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test UT_TLS_CM_HITLS_GetClientVersion_FUNC_TC001
* @title HITLS_GetClientVersion Obtains the client and server version numbers
* after initialization and before negotiation.
* @percon NA
* @brief
* 1. Initialize the client and server. Expected result 1
* 2. Call HITLS_GetClientVersion to obtain the client and server version numbers. Expected result 2
* @expect
* 1. Completing the initialization
* 2. The interface returns all 0s
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetClientVersion_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
config->isSupportRenegotiation = true;
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
uint16_t clientVersion = HITLS_VERSION_TLS12;
ASSERT_TRUE(HITLS_GetClientVersion(client->ssl, &clientVersion) == HITLS_SUCCESS);
uint16_t serverVersion = HITLS_VERSION_TLS12;
ASSERT_TRUE(HITLS_GetClientVersion(server->ssl, &serverVersion) == HITLS_SUCCESS);
ASSERT_EQ(clientVersion, 0);
ASSERT_EQ(serverVersion, 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test UT_TLS_CM_HITLS_IsClient_FUNC_TC001
* @title Testing the HITLS_IsClient
* @percon NA
* @brief
* 1. Enter an empty TLS connection handle. Expected result 1
* 2. Enter a non-empty TLS connection handle and leave isClient empty. Expected result 1
* 3. Enter a non-empty TLS connection handle and leave isClient not empty. Expected result 2
* @expect
* 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCESS
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_IsClient_FUNC_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
bool isClient = 0;
ASSERT_TRUE(HITLS_IsClient(ctx, &isClient) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_IsClient(ctx, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_IsClient(ctx, &isClient) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/**
* @test HITLS_GetSharedGroup Obtain the first supported peer group when only one curve is matched on the client and
server.
* @title UT_TLS_CM_HITLS_GetSharedGroup_FUNC_TC001
* @precon nan
* @brief
* 1. Initialize the client and server. Expected result 1
* 2. Configure the client and server to support only one elliptic curve (the number of intersection groups is 1).
Expected result 2
* 3. Establish a connection and invoke the HITLS_GetSharedGroup interface to obtain the first supported peer group
(Expected result 3)
* @expect
* 1. Initialization is complete
* 2. The setting is successful
* 3. The interface returns the supported elliptic curve
@ */
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetSharedGroup_FUNC_TC001(int version)
{
FRAME_Init();
int ret;
uint16_t groupId;
HITLS_Config *config_c = GetHitlsConfigViaVersion(version);
HITLS_Config *config_s = GetHitlsConfigViaVersion(version);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
uint16_t groups_c[] = {HITLS_EC_GROUP_SECP256R1, HITLS_EC_GROUP_SECP384R1};
uint16_t signAlgs_c[] = {CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256,
CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384,
CERT_SIG_SCHEME_RSA_PKCS1_SHA256};
HITLS_CFG_SetGroups(config_c, groups_c, sizeof(groups_c) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_c, signAlgs_c, sizeof(signAlgs_c) / sizeof(uint16_t));
uint16_t groups_s[] = {HITLS_EC_GROUP_SECP256R1, HITLS_EC_GROUP_SECP521R1};
uint16_t signAlgs_s[] = {CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256,
CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512,
CERT_SIG_SCHEME_RSA_PKCS1_SHA256};
HITLS_CFG_SetGroups(config_s, groups_s, sizeof(groups_s) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_s, signAlgs_s, sizeof(signAlgs_s) / sizeof(uint16_t));
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ret = HITLS_GetSharedGroup(server->ssl, 1, &groupId);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(groupId == HITLS_EC_GROUP_SECP256R1);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test HITLS_GetSharedGroup Obtain the second supported peer group if only one matching curve exists on the client and
* server.
* @title UT_TLS_CM_HITLS_GetSharedGroup_FUNC_TC002
* @precon nan
* @brief
* 1. Initialize the client and server. Expected result 1
* 2. Configure only one elliptic curve supported by the client and server. Expected result 2
* 3. Establish a connection and invoke the HITLS_GetSharedGroup interface to obtain the second supported peer group,
* Expected result 3
* @expect
* 1. Initialization is complete
* 2. The setting is successful
* 3. The interface returns 0
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetSharedGroup_FUNC_TC002(int version)
{
FRAME_Init();
int ret;
uint16_t groupId;
HITLS_Config *config_c = GetHitlsConfigViaVersion(version);
HITLS_Config *config_s = GetHitlsConfigViaVersion(version);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
uint16_t groups_c[] = {HITLS_EC_GROUP_SECP256R1, HITLS_EC_GROUP_SECP384R1};
uint16_t signAlgs_c[] = {CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256,
CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384,
CERT_SIG_SCHEME_RSA_PKCS1_SHA256};
HITLS_CFG_SetGroups(config_c, groups_c, sizeof(groups_c) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_c, signAlgs_c, sizeof(signAlgs_c) / sizeof(uint16_t));
uint16_t groups_s[] = {HITLS_EC_GROUP_SECP256R1, HITLS_EC_GROUP_SECP521R1};
uint16_t signAlgs_s[] = {CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256,
CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512,
CERT_SIG_SCHEME_RSA_PKCS1_SHA256};
HITLS_CFG_SetGroups(config_s, groups_s, sizeof(groups_s) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_s, signAlgs_s, sizeof(signAlgs_s) / sizeof(uint16_t));
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ret = HITLS_GetSharedGroup(server->ssl, 2, &groupId);
ASSERT_TRUE(ret == HITLS_INVALID_INPUT);
ASSERT_TRUE(groupId == 0);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test HITLS_GetSharedGroup Obtain the second and third supported peer groups when the client and server have two
* matching curves.
* @title UT_TLS_CM_HITLS_GetSharedGroup_FUNC_TC003
* @precon nan
* @brief
* 1. Initialize the client and server. Expected result 1
* 2. Configure two elliptic curves supported by the client and server. Expected result 2
* 3. Establish a connection. Invoke HITLS_GetSharedGroup to obtain the second supported peer group and the third
* supported peer group, Expected result 3
* @expect
* 1. Initialization is complete
* 2. The setting is successful
* 3. The corresponding curve is returned for the first call and 0 is returned for the second call
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetSharedGroup_FUNC_TC003(int version)
{
FRAME_Init();
int ret;
uint16_t groupId;
HITLS_Config *config_c = GetHitlsConfigViaVersion(version);
HITLS_Config *config_s = GetHitlsConfigViaVersion(version);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
uint16_t groups_c[] = {HITLS_EC_GROUP_SECP256R1, HITLS_EC_GROUP_SECP384R1};
uint16_t signAlgs_c[] = {CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256,
CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384,
CERT_SIG_SCHEME_RSA_PKCS1_SHA256};
HITLS_CFG_SetGroups(config_c, groups_c, sizeof(groups_c) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_c, signAlgs_c, sizeof(signAlgs_c) / sizeof(uint16_t));
uint16_t groups_s[] = {HITLS_EC_GROUP_SECP256R1, HITLS_EC_GROUP_SECP384R1, HITLS_EC_GROUP_SECP521R1};
uint16_t signAlgs_s[] = {CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256,
CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384,
CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512};
HITLS_CFG_SetGroups(config_s, groups_s, sizeof(groups_s) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_s, signAlgs_s, sizeof(signAlgs_s) / sizeof(uint16_t));
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ret = HITLS_GetSharedGroup(server->ssl, 2, &groupId);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(groupId == HITLS_EC_GROUP_SECP384R1);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test HITLS_GetSharedGroup Obtain the first supported peer group when there is no matching curve on the client and
* server
* @title UT_TLS_CM_HITLS_GetSharedGroup_FUNC_TC004
* @precon In the current framework, the TLS13 client and server do not have a matching curve. The TLS12 client and
* server can successfully establish a connection. The TLS13 framework capability needs to be supplemented
* @brief
* 1. Initialize the client and server, Expected result 1
* 2. Configure the client and server not to support the elliptic curve. Expected result 2
* 3. Establish a connection. After the parameters are negotiated, invoke the HITLS_GetSharedGroup interface to obtain
* the supported peer group. Expected result 3
* @expect
* 1. Initialization is complete
* 2. The setting is successful
* 3. The interface returns 0
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetSharedGroup_FUNC_TC004(int version)
{
FRAME_Init();
int ret;
uint16_t groupId;
HITLS_Config *config_c = GetHitlsConfigViaVersion(version);
HITLS_Config *config_s = GetHitlsConfigViaVersion(version);
uint16_t signWrtVersion =
(version == HITLS_VERSION_TLS12) ? CERT_SIG_SCHEME_RSA_PKCS1_SHA256 : CERT_SIG_SCHEME_RSA_PSS_PSS_SHA256;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
uint16_t groups_c[] = {HITLS_EC_GROUP_SECP384R1};
uint16_t signAlgs_c[] = {signWrtVersion, CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384};
HITLS_CFG_SetGroups(config_c, groups_c, sizeof(groups_c) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_c, signAlgs_c, sizeof(signAlgs_c) / sizeof(uint16_t));
HITLS_CFG_SetDhAutoSupport(config_c, true);
uint16_t groups_s[] = {HITLS_EC_GROUP_SECP256R1, HITLS_EC_GROUP_SECP521R1};
uint16_t signAlgs_s[] = {
signWrtVersion, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512};
HITLS_CFG_SetGroups(config_s, groups_s, sizeof(groups_s) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_s, signAlgs_s, sizeof(signAlgs_s) / sizeof(uint16_t));
HITLS_CFG_SetDhAutoSupport(config_s, true);
FRAME_CertInfo certInfo = {
"rsa_pss_sha256/rsa_pss_root.crt",
"rsa_pss_sha256/rsa_pss_intCa.crt",
"rsa_pss_sha256/rsa_pss_dev.crt",
0,
"rsa_pss_sha256/rsa_pss_dev.key",
0,
};
client = (version == HITLS_VERSION_TLS12) ? FRAME_CreateLink(config_c, BSL_UIO_TCP)
: FRAME_CreateLinkWithCert(config_c, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(client != NULL);
server = (version == HITLS_VERSION_TLS12) ? FRAME_CreateLink(config_s, BSL_UIO_TCP)
: FRAME_CreateLinkWithCert(config_s, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(server != NULL);
ret = FRAME_CreateConnection(client, server, true, HS_STATE_BUTT);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ret = HITLS_GetSharedGroup(server->ssl, 1, &groupId);
ASSERT_TRUE(ret == HITLS_INVALID_INPUT);
ASSERT_TRUE(groupId == 0);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test HITLS_GetSharedGroup If the matched elliptic curve exists, obtain the (-1)th supported peer group.
* @title UT_TLS_CM_HITLS_GetSharedGroup_FUNC_TC005
* @precon nan
* @brief
* 1. Initialize the client and server. Expected result 1
* 2. Configure two elliptic curves supported by the client and server. Expected result 2
* 3. Establish a connection. Invoke HITLS_GetSharedGroup to obtain the (-1)th supported peer group. Expected result 3
* @expect
* 1. Initialization is complete
* 2. The setting is successful
* 3. The interface returns 2
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetSharedGroup_FUNC_TC005(int version)
{
FRAME_Init();
int ret;
uint16_t groupId;
HITLS_Config *config_c = GetHitlsConfigViaVersion(version);
HITLS_Config *config_s = GetHitlsConfigViaVersion(version);
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
uint16_t groups_c[] = {HITLS_EC_GROUP_SECP256R1, HITLS_EC_GROUP_SECP384R1};
uint16_t signAlgs_c[] = {CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256,
CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384,
CERT_SIG_SCHEME_RSA_PKCS1_SHA256};
HITLS_CFG_SetGroups(config_c, groups_c, sizeof(groups_c) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_c, signAlgs_c, sizeof(signAlgs_c) / sizeof(uint16_t));
uint16_t groups_s[] = {HITLS_EC_GROUP_SECP256R1, HITLS_EC_GROUP_SECP384R1, HITLS_EC_GROUP_SECP521R1};
uint16_t signAlgs_s[] = {CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256,
CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384,
CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512};
HITLS_CFG_SetGroups(config_s, groups_s, sizeof(groups_s) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_s, signAlgs_s, sizeof(signAlgs_s) / sizeof(uint16_t));
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ret = HITLS_GetSharedGroup(server->ssl, -1, &groupId);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(groupId == 2);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test UT_TLS_CM_HITLS_SetVersionSupport_HITLS_GetVersionSupport_API_TC001
* @title Test the HITLS_SetVersionSupport and HITLS_GetVersionSupport interfaces.
* @precon nan
* @brief
* HITLS_SetVersionSupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Input a non-empty TLS connection handle and set the version to an invalid value. Expected result 2
* 3. Input a non-empty TLS connection handle and set the version to a valid value. Expected result 3
* HITLS_GetVersionSupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Input an empty version pointer. Expected result 1
* 3. Input a non-empty TLS connection handle and ensure that the version pointer is not empty. Expected result 4
* @expect
* 1. Return HITLS_NULL_INPUT.
* 2. Return HITLS_SUCCESS, and invalid values in ctx->config.tlsConfig are filtered out
* 3. Return HITLS_SUCCESS is returned, and the value of ctx->config.tlsConfig is the expected value
* 4. Return HITLS_SUCCESS is returned and the value of version is the same as that recorded in config
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_SetVersionSupport_HITLS_GetVersionSupport_API_TC001()
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
uint32_t version = 0;
ASSERT_TRUE(HITLS_SetVersionSupport(ctx, version) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetVersionSupport(ctx, &version) == HITLS_NULL_INPUT);
config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetVersionSupport(ctx, NULL) == HITLS_NULL_INPUT);
version = (TLS13_VERSION_BIT << 1) | TLS13_VERSION_BIT | TLS12_VERSION_BIT;
ASSERT_TRUE(HITLS_SetVersionSupport(ctx, version) == HITLS_SUCCESS);
ASSERT_TRUE(ctx->config.tlsConfig.minVersion == HITLS_VERSION_TLS12 &&
ctx->config.tlsConfig.maxVersion == HITLS_VERSION_TLS13);
version = TLS13_VERSION_BIT | TLS12_VERSION_BIT;
ASSERT_TRUE(HITLS_SetVersionSupport(ctx, version) == HITLS_SUCCESS);
ASSERT_TRUE(ctx->config.tlsConfig.minVersion == HITLS_VERSION_TLS12 &&
ctx->config.tlsConfig.maxVersion == HITLS_VERSION_TLS13);
uint32_t getversion = 0;
ASSERT_TRUE(HITLS_GetVersionSupport(ctx, &getversion) == HITLS_SUCCESS);
ASSERT_TRUE(getversion == ctx->config.tlsConfig.version);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/**
* @test UT_TLS_CM_HITLS_SetQuietShutdown_HITLS_GetQuietShutdown_API_TC001
* @title Test the HITLS_SetQuietShutdown and HITLS_GetQuietShutdown interfaces
* @precon nan
* @brief
* HITLS_SetQuietShutdown
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Input a non-empty TLS connection handle and set mode to an invalid value. Expected result 2
* 3. Input a non-empty TLS connection handle and set mode to a valid value. Expected result 3
* HITLS_GetQuietShutdown
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Input an empty mode pointer. Expected result 1
* 3. Input a non-empty TLS connection handle and ensure that the mode pointer is not empty. Expected result 3
* @expect
* 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_CONFIG_INVALID_SET
* 3. Return HITLS_SUCCES
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_SetQuietShutdown_HITLS_GetQuietShutdown_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
int32_t mode = 0;
ASSERT_TRUE(HITLS_SetQuietShutdown(ctx, mode) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetQuietShutdown(ctx, &mode) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetQuietShutdown(ctx, NULL) == HITLS_NULL_INPUT);
mode = 1;
ASSERT_TRUE(HITLS_SetQuietShutdown(ctx, mode) == HITLS_SUCCESS);
mode = -1;
ASSERT_TRUE(HITLS_SetQuietShutdown(ctx, mode) == HITLS_CONFIG_INVALID_SET);
int32_t getMode = -1;
ASSERT_TRUE(HITLS_GetQuietShutdown(ctx, &getMode) == HITLS_SUCCESS);
ASSERT_TRUE(getMode == true);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/**
* @test UT_TLS_CM_HITLS_SetDhAutoSupport_API_TC001
* @title Test HITLS_SetDhAutoSupport
* @precon nan
* @brief
* HITLS_SetDhAutoSupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Input a non-empty TLS connection handle and set support to an invalid value. Expected result 2
* 3. Input a non-empty TLS connection handle and set support to a valid value. Expected result 3 is displayed.
* @expect
* 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCES, and isSupportDhAuto is ture
* 3. Return HITLS_SUCCES, and isSupportDhAuto is ture or false
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_SetDhAutoSupport_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
bool support = -1;
ASSERT_TRUE(HITLS_SetDhAutoSupport(ctx, support) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
support = true;
ASSERT_TRUE(HITLS_SetDhAutoSupport(ctx, support) == HITLS_SUCCESS);
support = -1;
ASSERT_TRUE(HITLS_SetDhAutoSupport(ctx, support) == HITLS_SUCCESS);
support = false;
ASSERT_TRUE(HITLS_SetDhAutoSupport(ctx, support) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/**
* @test UT_HITLS_CM_SET_TMPDH_TC001
* @spec -
* @title Test HITLS_SetTmpDh interface
* @precon nan
* @brief
* HITLS_SetTmpDh
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Input non-empty TLS connection handle information and leave dhPkey empty. Expected result 1
* 3. Input the non-empty TLS connection handle information and ensure that dhPkey is not empty. Expected result 2
* @expect
* 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCES
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_SetTmpDh_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
HITLS_CRYPT_Key *dhPkey = HITLS_CRYPT_GenerateDhKeyBySecbits(LIBCTX_FROM_CONFIG(config),
ATTRIBUTE_FROM_CONFIG(config), config, HITLS_SECURITY_LEVEL_THREE_SECBITS);
ASSERT_TRUE(HITLS_SetTmpDh(ctx, dhPkey) == HITLS_NULL_INPUT);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetTmpDh(ctx, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetTmpDh(ctx, dhPkey) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/**
* @test HITLS_GetPeerFinishVerifyData Obtaining Peer VerifyDATA After Link Establishment and Renegotiation Are Complete
* @title UT_TLS_CM_HITLS_GetPeerFinishVerifyData_FUNC_TC001
* @precon nan
* @brief
* 1. Initialize the client and server and obtain the verifyDATA. Expected result 1.
* 2. Send a connection setup request. Expected result 2
* 3. Call HITLS_GetPeerFinishVerifyData to obtain and store VerifyData. Expected result 3
* 4. Perform renegotiation. Expected result 4
* 5. Call HITLS_GetPeerFinishVerifyData to obtain VerifyData. Expected result 5
* @expect
* 1. Return HITLS_SUCCESS and the len of verifyDATA is 0
* 2. The connection is established.
* 3. Return HITLS_SUCCESS and the len of verifyDATA is not 0
* 4. Renegotiation succeeded.
* 5. Return HITLS_SUCCESS and the verifyDATA is different from result 1
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetPeerFinishVerifyData_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
config->isSupportRenegotiation = true;
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
uint8_t verifyDataNew[MAX_DIGEST_SIZE] = {0};
uint32_t verifyDataNewSize = 0;
uint8_t verifyDataOld[MAX_DIGEST_SIZE] = {0};
uint32_t verifyDataOldSize = 0;
uint32_t ret =
HITLS_GetPeerFinishVerifyData(serverTlsCtx, verifyDataOld, sizeof(verifyDataOld), &verifyDataOldSize);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(verifyDataOldSize, 0);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ret = HITLS_GetPeerFinishVerifyData(serverTlsCtx, verifyDataOld, sizeof(verifyDataOld), &verifyDataOldSize);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_NE(verifyDataOldSize, 0);
ASSERT_TRUE(memcmp(verifyDataNew, verifyDataOld, verifyDataOldSize) != 0);
ASSERT_TRUE(memcpy_s(verifyDataOld, sizeof(verifyDataOld), verifyDataNew, verifyDataNewSize) == EOK);
ASSERT_TRUE(HITLS_Renegotiate(serverTlsCtx) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(clientTlsCtx) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateRenegotiationState(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ret = HITLS_GetPeerFinishVerifyData(serverTlsCtx, verifyDataNew, sizeof(verifyDataNew), &verifyDataNewSize);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(verifyDataNewSize, verifyDataOldSize);
ASSERT_TRUE(memcmp(verifyDataNew, verifyDataOld, verifyDataOldSize) != 0);
ASSERT_TRUE(memcpy_s(verifyDataOld, sizeof(verifyDataOld), verifyDataNew, verifyDataNewSize) == EOK);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test HITLS_GetFinishVerifyData: Obtains the verification data before a connection is established
* @title UT_TLS_CM_HITLS_GetFinishVerifyData_FUNC_TC001
* @precon nan
* @brief
*1. Initialize the client and server. Expected result 1
*2. Call HITLS_GetFinishVerifyData to obtain VerifyData. Expected result 2
* @expect
*1. Completing the initialization
*2. The interface returns 0.
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetFinishVerifyData_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config, 1), HITLS_SUCCESS);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
uint8_t verifyDataNew[MAX_DIGEST_SIZE] = {0};
uint32_t verifyDataNewSize = 0;
ASSERT_TRUE(HITLS_GetFinishVerifyData(server->ssl, verifyDataNew, sizeof(verifyDataNew), &verifyDataNewSize) ==
HITLS_SUCCESS);
ASSERT_EQ(verifyDataNewSize, 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test HITLS_GetFinishVerifyData Obtain VerifyDATA after connection establishment
* @title UT_TLS_CM_HITLS_GetFinishVerifyData_FUNC_TC002
* @precon nan
* @brief
* 1. Initialize the client and server. Expected result 1
* 2. Send a link setup request. Expected result 2
* 3. Call HITLS_GetFinishVerifyData to obtain VerifyData. Expected result 3
* @expect
* 1. Completing the initialization
* 2. The connection is established
* 3. The value returned by the interface is not 0
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetFinishVerifyData_FUNC_TC002(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config, 1), HITLS_SUCCESS);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
uint8_t verifyDataNew[MAX_DIGEST_SIZE] = {0};
uint32_t verifyDataNewSize = 0;
ASSERT_TRUE(HITLS_GetFinishVerifyData(server->ssl, verifyDataNew, sizeof(verifyDataNew), &verifyDataNewSize) ==
HITLS_SUCCESS);
ASSERT_NE(verifyDataNewSize, 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test HITLS_GetFinishVerifyData Obtains VerifyDATA after link establishment and renegotiation.
* @title UT_TLS_CM_HITLS_GetFinishVerifyData_FUNC_TC003
* @precon nan
* @brief
* 1. Initialize the client and server. Expected result
* 2. Send a connection setup request. Expected result 2
* 3. Call HITLS_GetFinishVerifyData to obtain and store VerifyData. Expected result 3
* 4. Perform renegotiation. Expected result 4
* 5. Call HITLS_GetFinishVerifyData to obtain VerifyData. Expected result 5
* @expect
* 1. Complete the initialization
* 2. The link is established
* 3. The interface returns a value other than 0
* 4. Renegotiation succeeded
* 5. Inconsistent with the first link establishmen
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetFinishVerifyData_FUNC_TC003(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
config->isSupportRenegotiation = true;
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config, 1), HITLS_SUCCESS);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
uint16_t cipherSuite = HITLS_RSA_WITH_AES_128_CBC_SHA256;
int32_t ret = HITLS_CFG_SetCipherSuites(config, &cipherSuite, 1);
ASSERT_EQ(ret, HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
uint8_t verifyDataNew[MAX_DIGEST_SIZE] = {0};
uint32_t verifyDataNewSize = 0;
uint8_t verifyDataOld[MAX_DIGEST_SIZE] = {0};
uint32_t verifyDataOldSize = 0;
ASSERT_TRUE(HITLS_GetFinishVerifyData(server->ssl, verifyDataOld, sizeof(verifyDataOld), &verifyDataOldSize) ==
HITLS_SUCCESS);
ASSERT_NE(verifyDataOldSize, 0);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
ASSERT_TRUE(HITLS_Renegotiate(serverTlsCtx) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(clientTlsCtx) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateRenegotiationState(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(HITLS_GetFinishVerifyData(serverTlsCtx, verifyDataNew, sizeof(verifyDataNew), &verifyDataNewSize) ==
HITLS_SUCCESS);
ASSERT_TRUE(verifyDataNewSize == verifyDataOldSize);
ASSERT_TRUE(memcmp(verifyDataNew, verifyDataOld, verifyDataOldSize) != 0);
ASSERT_TRUE(memcpy_s(verifyDataOld, sizeof(verifyDataOld), verifyDataNew, verifyDataNewSize) == EOK);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
int32_t SendHelloReq(HITLS_Ctx *ctx)
{
uint8_t buf[HS_MSG_HEADER_SIZE] = {0u};
size_t len = HS_MSG_HEADER_SIZE;
return REC_Write(ctx, REC_TYPE_HANDSHAKE, buf, len);
}
/**
* @test UT_TLS_CM_HITLS_GetRenegotiationState_FUNC_TC001
* @title Verifying the HITLS_GetRenegotiationState Interface
* @precon nan
* @brief
* 1. After the client and server are initialized, initiate a connection establishment request. Expected result 1
* 2. Call the HITLS_GetRenegotiationState interface to query the renegotiation status. Expected result 2
* 3. The server invokes the hitls_renegotiate interface to initiate renegotiation and invokes the
* HITLS_GetRenegotiationState interface to query the renegotiation status on the server. Expected result 3
* 4. After receiving the hello request, the client invokes the HITLS_GetRenegotiationState interface
* to query the renegotiation status. Expected result 4
* 5. After receiving the client hello message, the server invokes the HITLS_GetRenegotiationState interface to query
* the renegotiation status. Expected result 5
* 6. After the renegotiation is complete, call the HITLS_GetRenegotiationState interface to query the renegotiation
* status on the client and server. Expected result 6
* 7. The client invokes the hitls_renegotiate interface to initiate renegotiation and invokes the
* HITLS_GetRenegotiationState interface to query the renegotiation status. Expected result 7
* @expect
* 1. The connection is successfully established
* 2. The return value is false
* 3. The return value is true
* 4. The return value is true
* 5. The return value is true
* 6. The return value is flase
* 7. The return value is true
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetRenegotiationState_FUNC_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
uint8_t isRenegotiation = true;
config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
client->ssl->config.tlsConfig.endpoint = HITLS_ENDPOINT_CLIENT;
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
HITLS_SetRenegotiationSupport(client->ssl, true);
HITLS_SetRenegotiationSupport(server->ssl, true);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetRenegotiationState(client->ssl, &isRenegotiation) == HITLS_SUCCESS);
ASSERT_TRUE(isRenegotiation == false);
ASSERT_TRUE(HITLS_Renegotiate(client->ssl) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(server->ssl) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetRenegotiationState(server->ssl, &isRenegotiation) == HITLS_SUCCESS);
ASSERT_TRUE(isRenegotiation == true);
ASSERT_TRUE(SendHelloReq(server->ssl) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(server, client) == HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(client->ssl), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
ASSERT_TRUE(HITLS_GetRenegotiationState(server->ssl, &isRenegotiation) == HITLS_SUCCESS);
ASSERT_TRUE(isRenegotiation == true);
ASSERT_EQ(FRAME_CreateRenegotiationState(client, server, false, TRY_SEND_SERVER_HELLO), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetRenegotiationState(server->ssl, &isRenegotiation) == HITLS_SUCCESS);
ASSERT_TRUE(isRenegotiation == true);
ASSERT_EQ(FRAME_CreateRenegotiationState(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetRenegotiationState(server->ssl, &isRenegotiation) == HITLS_SUCCESS);
ASSERT_TRUE(isRenegotiation == false);
ASSERT_TRUE(HITLS_Renegotiate(client->ssl) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(server->ssl) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetRenegotiationState(server->ssl, &isRenegotiation) == HITLS_SUCCESS);
ASSERT_TRUE(isRenegotiation == true);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test Verifying the HITLS_GetRwstate Interface
* @title UT_TLS_CM_HITLS_GetRwstate_FUNC_TC001
* @precon nan
* @brief
* 1. After the initialization, invoke the HITLS_GetRwstate interface to query data. Expected result 1
* 2. When reading data, set ruio to null, construct a read exception, and call the HITLS_GetRwstate interface for
* query. Expected result 2
* 3. When writing data, set uio to null, construct a write exception, and call the HITLS_GetRwstate interface for
* query. Expected result 3
* @expect
* 1. The returned status is nothing
* 2. The returned status is reading
* 3. The returned status is writing
*/
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetRwstate_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
uint8_t rwstate = HITLS_READING;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
uint32_t ret = HITLS_GetRwstate(client->ssl, &rwstate);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(rwstate, HITLS_NOTHING);
void *tmpUio = client->ssl->rUio;
client->ssl->rUio = NULL;
BSL_UIO_Free(tmpUio);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen = 0;
ret = HITLS_Read(client->ssl, readBuf, READ_BUF_SIZE, &readLen);
ret = HITLS_GetRwstate(client->ssl, &rwstate);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(rwstate, HITLS_READING);
tmpUio = client->ssl->uio;
client->ssl->uio = NULL;
BSL_UIO_Free(tmpUio);
FRAME_TrasferMsgBetweenLink(client, server);
HITLS_Accept(server->ssl);
ASSERT_EQ(ret, HITLS_SUCCESS);
uint8_t writeBuf[100] = {0};
uint32_t writeLen;
ret = HITLS_Write(client->ssl, writeBuf, sizeof(writeBuf), &writeLen);
ret = HITLS_GetRwstate(client->ssl, &rwstate);
ASSERT_EQ(ret, HITLS_SUCCESS);
ASSERT_EQ(rwstate, HITLS_WRITING);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test UT_HITLS_CM_SET_GET_CLIENTVERIFYSUPPORT_API_TC001
* @title Test the HITLS_SetClientVerifySupport and HITLS_GetClientVerifySupport interfaces.
* @precon nan
* @brief
* HITLS_SetClientVerifySupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer non-empty TLS connection handle information and set support to an invalid value. Expected result 2
* 3. Transfer the non-empty TLS connection handle information and set support to a valid value. Expected result 3
* HITLS_GetClientVerifySupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer an empty isSupport pointer. Expected result 1
* 3. Transfer the non-null TLS connection handle information and ensure that the isSupport pointer is not null.
* Expected result 3
* @expect
* 1. HITLS_NULL_INPUT is returned
* 2. Returns HITLS_SUCCES, isSupportClientVerify is true, and isSupportVerifyNone is false
* 3. HITLS_SUCCES is returned, isSupportClientVerify is true or false, and isSupportVerifyNone and isSupportVerifyNone
* are mutually exclusive, but can be false at the same time
*/
/* BEGIN_CASE */
void UT_HITLS_CM_SET_GET_CLIENTVERIFYSUPPORT_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
bool support = -1;
uint8_t isSupport = -1;
ASSERT_TRUE(HITLS_SetClientVerifySupport(ctx, support) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetClientVerifySupport(ctx, &isSupport) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetClientVerifySupport(ctx, NULL) == HITLS_NULL_INPUT);
support = true;
ASSERT_TRUE(HITLS_SetClientVerifySupport(ctx, support) == HITLS_SUCCESS);
ASSERT_TRUE(config->isSupportVerifyNone == false);
support = -1;
ASSERT_TRUE(HITLS_SetClientVerifySupport(ctx, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetClientVerifySupport(ctx, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == true);
support = false;
ASSERT_TRUE(HITLS_SetClientVerifySupport(ctx, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetClientVerifySupport(ctx, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/**
* @test UT_HITLS_CM_SET_GET_NOCLIENTCERTSUPPORT_API_TC001
* @title Test the HITLS_SetNoClientCertSupport and HITLS_GetClientVerifySupport interfaces
* @precon nan
* @brief
* HITLS_SetNoClientCertSupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer non-empty TLS connection handle information and set support to an invalid value. Expected result 2
* 3. Transfer the non-empty TLS connection handle information and set support to a valid value. Expected result 3
* HITLS_GetNoClientCertSupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer an empty isSupport pointer. Expected result 1
* 3. Transfer the non-null TLS connection handle information and ensure that the isSupport pointer is not null
* Expected result 3
* @expect
* 1. HITLS_NULL_INPUT is returned.
* 2. HITLS_SUCCES is returned and isSupportNoClientCert is true
* 3. Returns HITLS_SUCCES and isSupportNoClientCert is true or false
*/
/* BEGIN_CASE */
void UT_HITLS_CM_SET_GET_NOCLIENTCERTSUPPORT_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
bool support = -1;
uint8_t isSupport = -1;
ASSERT_TRUE(HITLS_SetNoClientCertSupport(ctx, support) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetNoClientCertSupport(ctx, &isSupport) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetNoClientCertSupport(ctx, NULL) == HITLS_NULL_INPUT);
support = true;
ASSERT_TRUE(HITLS_SetNoClientCertSupport(ctx, support) == HITLS_SUCCESS);
support = -1;
ASSERT_TRUE(HITLS_SetNoClientCertSupport(ctx, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetNoClientCertSupport(ctx, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == true);
support = false;
ASSERT_TRUE(HITLS_SetNoClientCertSupport(ctx, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetNoClientCertSupport(ctx, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/**
* @test UT_HITLS_CM_SET_GET_VERIFYNONESUPPORT_API_TC001
* @title Test the HITLS_SetVerifyNoneSupport and HITLS_GetVerifyNoneSupport interfaces
* @precon nan
* @brief
* HITLS_SetVerifyNoneSupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer non-empty TLS connection handle information and set support to an invalid value. Expected result 2
* 3. Transfer the non-empty TLS connection handle information and set support to a valid value. Expected result 3
* HITLS_GetVerifyNoneSupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer an empty isSupport pointer. Expected result 1
* 3. Transfer the non-null TLS connection handle information and ensure that the isSupport pointer is not null
* Expected result 3
* @expect
* 1. HITLS_NULL_INPUT is returned
* 2. Returns HITLS_SUCCES, isSupportVerifyNone is true, and isSupportClientVerify is false
* 3. HITLS_SUCCES is returned, isSupportVerifyNone is true or false, isSupportClientVerify and isSupportClientVerify
* are mutually exclusive, but can be false at the same time
*/
/* BEGIN_CASE */
void UT_HITLS_CM_SET_GET_VERIFYNONESUPPORT_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
bool support = -1;
uint8_t isSupport = -1;
ASSERT_TRUE(HITLS_SetVerifyNoneSupport(ctx, support) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetVerifyNoneSupport(ctx, &isSupport) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetVerifyNoneSupport(ctx, NULL) == HITLS_NULL_INPUT);
support = true;
ASSERT_TRUE(HITLS_SetVerifyNoneSupport(ctx, support) == HITLS_SUCCESS);
ASSERT_TRUE(config->isSupportClientVerify == false);
support = -1;
ASSERT_TRUE(HITLS_SetVerifyNoneSupport(ctx, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetVerifyNoneSupport(ctx, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == true);
support = false;
ASSERT_TRUE(HITLS_SetVerifyNoneSupport(ctx, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetVerifyNoneSupport(ctx, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/**
* @test UT_HITLS_CM_SET_GET_CLIENTONCEVERIFYSUPPORT_API_TC001
* @title Test the HITLS_SetClientOnceVerifySupport and HITLS_GetClientOnceVerifySupport interfaces.
* @precon nan
* @brief
* HITLS_SetClientOnceVerifySupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer non-empty TLS connection handle information and set support to an invalid value. Expected result 2
* 3. Transfer the non-empty TLS connection handle information and set support to a valid value. Expected result 3
* HITLS_GetClientOnceVerifySupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer an empty isSupport pointer. Expected result 1
* 3. Transfer the non-null TLS connection handle information and ensure that the isSupport pointer is not null.
* Expected result 3
* @expect
* 1. HITLS_NULL_INPUT is returned
* 2. HITLS_SUCCES is returned and isSupportPostHandshakeAuth is true
* 3. HITLS_SUCCES is returned and isSupportPostHandshakeAuth is true or false
*/
/* BEGIN_CASE */
void UT_HITLS_CM_SET_GET_CLIENTONCEVERIFYSUPPORT_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
bool support = -1;
uint8_t isSupport = -1;
ASSERT_TRUE(HITLS_SetClientOnceVerifySupport(ctx, support) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetClientOnceVerifySupport(ctx, &isSupport) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetClientOnceVerifySupport(ctx, NULL) == HITLS_NULL_INPUT);
support = true;
ASSERT_TRUE(HITLS_SetClientOnceVerifySupport(ctx, support) == HITLS_SUCCESS);
support = -1;
ASSERT_TRUE(HITLS_SetClientOnceVerifySupport(ctx, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetClientOnceVerifySupport(ctx, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == true);
support = false;
ASSERT_TRUE(HITLS_SetClientOnceVerifySupport(ctx, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetClientOnceVerifySupport(ctx, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/**
* @test Verifying the HITLS_ClearRenegotiationNum Interface
* @title UT_HITLS_CM_HITLS_ClearRenegotiationNum_FUNC_TC001
* @precon nan
* @brief
* 1. After initialization, invoke the HITLS_ClearRenegotiationNum interface to query data. Expected result 1
* 2. After the link is set up, invoke the HITLS_ClearRenegotiationNum interface to query the link. Expected result 2
* 3. Initiate renegotiation. After the renegotiation is successful, invoke the HITLS_ClearRenegotiationNum interface to
check the values of the client and server. Expected result 3
* 4. Initiate another five renegotiations. After the negotiation is complete, invoke the HITLS_ClearRenegotiationNum
interface to query the values of the client and server. Expected result 4
* 5. Invoke the HITLS_ClearRenegotiationNum interface again to query the values on the client and server. Expected
result 5
* 6. The client initiates renegotiation. The server rejects the renegotiation. Invoke the HITLS_ClearRenegotiationNum
interface to query the values of the client and server. Expected result 6
* @expect
* 1. The value is 0
* 2. The value is 0
* 3. The value is 1
* 4. The value is 0
* 5. The value is 0
* 6. The value is 1 for the client and 0 for the server
*/
/* BEGIN_CASE */
void UT_HITLS_CM_HITLS_ClearRenegotiationNum_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
uint16_t signAlgs[] = {CERT_SIG_SCHEME_RSA_PKCS1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256};
HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
config->isSupportRenegotiation = true;
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
HITLS_SetClientRenegotiateSupport(server->ssl, true);
uint32_t renegotiationNum = 0;
ASSERT_TRUE(HITLS_ClearRenegotiationNum(clientTlsCtx, &renegotiationNum) == HITLS_SUCCESS);
ASSERT_EQ(renegotiationNum, 0);
ASSERT_TRUE(HITLS_ClearRenegotiationNum(serverTlsCtx, &renegotiationNum) == HITLS_SUCCESS);
ASSERT_EQ(renegotiationNum, 0);
ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_ClearRenegotiationNum(clientTlsCtx, &renegotiationNum) == HITLS_SUCCESS);
ASSERT_EQ(renegotiationNum, 0);
ASSERT_TRUE(HITLS_ClearRenegotiationNum(serverTlsCtx, &renegotiationNum) == HITLS_SUCCESS);
ASSERT_EQ(renegotiationNum, 0);
uint8_t verifyDataNew[MAX_DIGEST_SIZE] = {0};
uint32_t verifyDataNewSize = 0;
uint8_t verifyDataOld[MAX_DIGEST_SIZE] = {0};
uint32_t verifyDataOldSize = 0;
ASSERT_TRUE(HITLS_GetFinishVerifyData(serverTlsCtx, verifyDataOld, sizeof(verifyDataOld), &verifyDataOldSize) ==
HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(serverTlsCtx) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(clientTlsCtx) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateRenegotiationState(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(HITLS_GetFinishVerifyData(serverTlsCtx, verifyDataNew, sizeof(verifyDataNew), &verifyDataNewSize) ==
HITLS_SUCCESS);
ASSERT_TRUE(verifyDataNewSize == verifyDataOldSize);
ASSERT_TRUE(memcmp(verifyDataNew, verifyDataOld, verifyDataOldSize) != 0);
ASSERT_TRUE(memcpy_s(verifyDataOld, sizeof(verifyDataOld), verifyDataNew, verifyDataNewSize) == EOK);
ASSERT_TRUE(HITLS_ClearRenegotiationNum(clientTlsCtx, &renegotiationNum) == HITLS_SUCCESS);
ASSERT_EQ(renegotiationNum, 1);
ASSERT_TRUE(HITLS_ClearRenegotiationNum(serverTlsCtx, &renegotiationNum) == HITLS_SUCCESS);
ASSERT_EQ(renegotiationNum, 1);
for (int i = 0; i < 5; ++i) {
ASSERT_TRUE(HITLS_Renegotiate(serverTlsCtx) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(clientTlsCtx) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateRenegotiationState(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(HITLS_GetFinishVerifyData(serverTlsCtx, verifyDataNew, sizeof(verifyDataNew), &verifyDataNewSize) ==
HITLS_SUCCESS);
ASSERT_TRUE(verifyDataNewSize == verifyDataOldSize);
ASSERT_TRUE(memcmp(verifyDataNew, verifyDataOld, verifyDataOldSize) != 0);
ASSERT_TRUE(memcpy_s(verifyDataOld, sizeof(verifyDataOld), verifyDataNew, verifyDataNewSize) == EOK);
}
ASSERT_TRUE(HITLS_ClearRenegotiationNum(clientTlsCtx, &renegotiationNum) == HITLS_SUCCESS);
ASSERT_EQ(renegotiationNum, 5);
ASSERT_TRUE(HITLS_ClearRenegotiationNum(serverTlsCtx, &renegotiationNum) == HITLS_SUCCESS);
ASSERT_EQ(renegotiationNum, 5);
ASSERT_TRUE(HITLS_ClearRenegotiationNum(clientTlsCtx, &renegotiationNum) == HITLS_SUCCESS);
ASSERT_EQ(renegotiationNum, 0);
ASSERT_TRUE(HITLS_ClearRenegotiationNum(serverTlsCtx, &renegotiationNum) == HITLS_SUCCESS);
ASSERT_EQ(renegotiationNum, 0);
ASSERT_TRUE(HITLS_Renegotiate(clientTlsCtx) == HITLS_SUCCESS);
serverTlsCtx->negotiatedInfo.isSecureRenegotiation = false;
ASSERT_EQ(FRAME_CreateRenegotiation(client, server), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
ASSERT_TRUE(serverTlsCtx->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(HITLS_GetFinishVerifyData(serverTlsCtx, verifyDataNew, sizeof(verifyDataNew), &verifyDataNewSize) ==
HITLS_SUCCESS);
ASSERT_TRUE(verifyDataNewSize == verifyDataOldSize);
ASSERT_TRUE(memcmp(verifyDataNew, verifyDataOld, verifyDataOldSize) == 0);
ASSERT_TRUE(memcpy_s(verifyDataOld, sizeof(verifyDataOld), verifyDataNew, verifyDataNewSize) == EOK);
ASSERT_TRUE(HITLS_ClearRenegotiationNum(clientTlsCtx, &renegotiationNum) == HITLS_SUCCESS);
ASSERT_EQ(renegotiationNum, 1);
ASSERT_TRUE(HITLS_ClearRenegotiationNum(serverTlsCtx, &renegotiationNum) == HITLS_SUCCESS);
ASSERT_EQ(renegotiationNum, 0);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test HITLS_GetNegotiateGroup: EC cipher suite
* @spec -
* @title UT_HITLS_CM_HITLS_GetNegotiateGroup_FUNC_TC001
* @precon nan
* @brief
* 1. Configure the two ends to use the EC cipher suite. Before connection establishment is complete, invoke the
* HITLS_GetNegotiateGroup interface to query the negotiated value. Expected result 1
* 2. Configure the EC cipher suite to be used at both ends. After the connection is established, invoke the
* HITLS_GetNegotiateGroup interface to query the negotiated value. Expected result 2
* @expect
* 1. The return value is 0
* 2. The returned value is the negotiated value
*/
/* BEGIN_CASE */
void UT_HITLS_CM_HITLS_GetNegotiateGroup_FUNC_TC001(int version)
{
FRAME_Init();
int ret;
HITLS_Config *config_c = GetHitlsConfigViaVersion(version);
HITLS_Config *config_s = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
uint16_t groupId;
uint16_t expectedGroupId = HITLS_EC_GROUP_SECP256R1;
uint16_t groups_c[] = {expectedGroupId, HITLS_EC_GROUP_SECP384R1};
uint16_t signAlgs_c[] = {CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384};
HITLS_CFG_SetGroups(config_c, groups_c, sizeof(groups_c) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_c, signAlgs_c, sizeof(signAlgs_c) / sizeof(uint16_t));
uint16_t groups_s[] = {expectedGroupId, HITLS_EC_GROUP_SECP521R1};
uint16_t signAlgs_s[] = {CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256, CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512};
HITLS_CFG_SetGroups(config_s, groups_s, sizeof(groups_s) / sizeof(uint16_t));
HITLS_CFG_SetSignature(config_s, signAlgs_s, sizeof(signAlgs_s) / sizeof(uint16_t));
FRAME_LinkObj *client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, TRY_RECV_SERVER_HELLO), HITLS_SUCCESS);
ret = HITLS_GetNegotiateGroup(client->ssl, &groupId);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_EQ(groupId, 0);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
ret = HITLS_GetNegotiateGroup(client->ssl, &groupId);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_EQ(groupId, expectedGroupId);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test HITLS_GetNegotiateGroup interface uses the RSA cipher suite.
* @spec -
* @title UT_HITLS_CM_HITLS_GetNegotiateGroup_FUNC_TC002
* @precon nan
* @brief
* 1. Set the RSA cipher suite to be used at both ends. After the connection is established, invoke the
HITLS_GetNegotiateGroup interface to query the negotiated value. Expected result 1
* @expect
* 1. The return value of tls12 is 0. The prerequisite is that the cipher suite does not contain the (EC)DHE. The cipher
suite involved in key exchange must have the same group. tls13 is the negotiated group. The current framework supports
only ECDHE. Therefore, the connection can be successfully established only when the same EC group exists, The default
common curve is HITLS_EC_GROUP_CURVE25519.
*/
/* BEGIN_CASE */
void UT_HITLS_CM_HITLS_GetNegotiateGroup_FUNC_TC002(int version)
{
FRAME_Init();
int ret;
HITLS_Config *config_c = GetHitlsConfigViaVersion(version);
HITLS_Config *config_s = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
if (version == HITLS_VERSION_TLS12) {
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config_c, true), HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_SetEncryptThenMac(config_s, true), HITLS_SUCCESS);
uint16_t cipherSuite = HITLS_RSA_WITH_AES_256_CBC_SHA;
ASSERT_EQ(HITLS_CFG_SetCipherSuites(config_c, &cipherSuite, 1), HITLS_SUCCESS);
}
FRAME_LinkObj *client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
FRAME_LinkObj *server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
uint16_t groupId;
uint16_t expectedGroupId = (version == HITLS_VERSION_TLS12) ? 0 : HITLS_EC_GROUP_CURVE25519;
ret = HITLS_GetNegotiateGroup(server->ssl, &groupId);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_EQ(groupId, expectedGroupId);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/**
* @test UT_HITLS_CM_SET_GET_CIPHERSERVERPREFERENCE_FUNC_TC001
* @title Test the HITLS_SetCipherServerPreference and HITLS_GetCipherServerPreference interfaces
* @precon nan
* @brief
* HITLS_SetCipherServerPreference
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer a non-empty TLS connection handle and set isSupport to an invalid value. Expected result 2
* 3. Transfer a non-empty TLS connection handle and set isSupport to a valid value. Expected result 3
* HITLS_GetCipherServerPreference
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer an empty isSupport pointer. Expected result 1
* 3. Transfer the non-null TLS connection handle information and ensure that the isSupport pointer is not null.
* Expected result 3
* @expect
* 1. HITLS_NULL_INPUT is returned
* 2. HITLS_SUCCES is returned and isSupportServerPreference is true
* 3. Returns HITLS_SUCCES and isSupportServerPreference is true or false
*/
/* BEGIN_CASE */
void UT_HITLS_CM_SET_GET_CIPHERSERVERPREFERENCE_FUNC_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
bool isSupport = false;
bool getIsSupport = false;
ASSERT_TRUE(HITLS_SetCipherServerPreference(ctx, isSupport) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetCipherServerPreference(ctx, &getIsSupport) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetCipherServerPreference(ctx, NULL) == HITLS_NULL_INPUT);
isSupport = true;
ASSERT_TRUE(HITLS_SetCipherServerPreference(ctx, isSupport) == HITLS_SUCCESS);
isSupport = -1;
ASSERT_TRUE(HITLS_SetCipherServerPreference(ctx, isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(config->isSupportServerPreference = true);
isSupport = false;
ASSERT_TRUE(HITLS_SetCipherServerPreference(ctx, isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetCipherServerPreference(ctx, &getIsSupport) == HITLS_SUCCESS);
ASSERT_TRUE(getIsSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/**
* @test UT_HITLS_CM_SET_GET_RENEGOTIATIONSUPPORT_FUNC_TC001
* @title Test the HITLS_SetRenegotiationSupport and HITLS_GetRenegotiationSupport interfaces.
* @precon nan
* @brief
* HITLS_SetRenegotiationSupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer non-empty TLS connection handle information and set support to an invalid value. Expected result 2
* 3. Transfer the non-empty TLS connection handle information and set support to a valid value. Expected result 3
* HITLS_GetRenegotiationSupport
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer an empty isSupport pointer. Expected result 1
* 3. Transfer the non-null TLS connection handle information and ensure that the isSupport pointer is not null.
* Expected result 3
* @expect
* 1. HITLS_NULL_INPUT is returned
* 2. HITLS_SUCCES is returned and isSupportRenegotiation is true
* 3. HITLS_SUCCES is returned and isSupportRenegotiation is true or false
*/
/* BEGIN_CASE */
void UT_HITLS_CM_SET_GET_RENEGOTIATIONSUPPORT_FUNC_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
bool support = -1;
uint8_t isSupport = -1;
ASSERT_TRUE(HITLS_SetRenegotiationSupport(ctx, support) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetRenegotiationSupport(ctx, &isSupport) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetRenegotiationSupport(ctx, NULL) == HITLS_NULL_INPUT);
support = true;
ASSERT_TRUE(HITLS_SetRenegotiationSupport(ctx, support) == HITLS_SUCCESS);
support = -1;
ASSERT_TRUE(HITLS_SetRenegotiationSupport(ctx, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetRenegotiationSupport(ctx, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == true);
support = false;
ASSERT_TRUE(HITLS_SetRenegotiationSupport(ctx, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetRenegotiationSupport(ctx, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/**
* @test UT_HITLS_CM_SET_GET_FLIGHTTRANSMITSWITCH_FUNC_TC001
* @title Test the HITLS_SetFlightTransmitSwitch and HITLS_GetFlightTransmitSwitch interfaces
* @precon nan
* @brief
* HITLS_SetFlightTransmitSwitch
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Transfer a non-empty TLS connection handle and set isEnable to an invalid value. Expected result 2
* 3. Transfer a non-empty TLS connection handle and set isEnable to a valid value. Expected result 3
* GetFlightTransmitSwitch
* 1. Input an empty TLS connection handle. Expected result 1
* 2. Pass an empty getIsEnable pointer. Expected result 1
* 3. Transfer the non-null TLS connection handle information and ensure that the getIsEnable pointer is not null.
* Expected result 3
* @expect
* 1. HITLS_NULL_INPUT is returned
* 2. HITLS_SUCCES is returned and ctx->config.tlsConfig.isFlightTransmitEnable is true
* 3. Returns HITLS_SUCCES and ctx->config.tlsConfig.isFlightTransmitEnable is true or false
*/
/* BEGIN_CASE */
void UT_HITLS_CM_SET_GET_FLIGHTTRANSMITSWITCH_FUNC_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
uint8_t isEnable = -1;
uint8_t getIsEnable = -1;
ASSERT_TRUE(HITLS_SetFlightTransmitSwitch(ctx, isEnable) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetFlightTransmitSwitch(ctx, &getIsEnable) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetFlightTransmitSwitch(ctx, NULL) == HITLS_NULL_INPUT);
isEnable = 1;
ASSERT_TRUE(HITLS_SetFlightTransmitSwitch(ctx, isEnable) == HITLS_SUCCESS);
isEnable = -1;
ASSERT_TRUE(HITLS_SetFlightTransmitSwitch(ctx, isEnable) == HITLS_SUCCESS);
ASSERT_TRUE(ctx->config.tlsConfig.isFlightTransmitEnable = true);
isEnable = 0;
ASSERT_TRUE(HITLS_SetFlightTransmitSwitch(ctx, isEnable) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetFlightTransmitSwitch(ctx, &getIsEnable) == HITLS_SUCCESS);
ASSERT_TRUE(getIsEnable == false);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/**
* @test UT_HITLS_CM_SET_GET_SetMaxCertList_FUNC_TC001
* @title HTLS_CFG_SetMaxCertList, HITLS_CFG_GetMaxCertList, HITLS_SetMaxCertList, and HITLS_GetMaxCertList APIs
* @precon nan
* @brief
* 1. Apply for and initialize config and ctx
* 2. Set the certificate chain length config to null and invoke the HITLS_CFG_SetMaxCertList interface
* 3. Invoke the HITLS_CFG_GetMaxCertList interface and check the output parameter value
* 4. Set the maximum length of the certificate chain by calling the HITLS_CFG_SetMaxCertList interface
* 5. Invoke the HITLS_CFG_GetMaxCertList interface and check the output parameter value
* 6. Set the minimum certificate chain length by calling the HITLS_CFG_SetMaxCertList interface
* 7. Invoke the HITLS_CFG_GetMaxCertList interface and check the output parameter value
* 8. Use the HITLS_SetMaxCertList and HITLS_GetMaxCertList interfaces to repeat the preceding test
* @expect
* 1. Initialization succeeds
* 2. HITLS_NULL_INPUT is returned
* 3. HITLS_NULL_INPUT is returned
* 4. The interface returns HITLS_SUCCESS
* 5. The value of MaxCertList returned by the interface is 2 ^ 32 - 1
* 6. The interface returns the HITLS_SUCCESS
* 7. The value of MaxCertList returned by the interface is 0
* 8. Same as above
*/
/* BEGIN_CASE */
void UT_HITLS_CM_SET_GET_SetMaxCertList_FUNC_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig;
HITLS_Ctx *ctx = NULL;
tlsConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
uint32_t maxSize;
// The config parameter is empty.
ASSERT_TRUE(HITLS_CFG_SetMaxCertList(NULL, MAX_CERT_LIST) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetMaxCertList(NULL, &maxSize) == HITLS_NULL_INPUT);
// Set the maximum value to 2 ^ 32 - 1.
ASSERT_TRUE(HITLS_CFG_SetMaxCertList(tlsConfig, MAX_CERT_LIST) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMaxCertList(tlsConfig, &maxSize) == HITLS_SUCCESS);
ASSERT_TRUE(maxSize == MAX_CERT_LIST);
// Set the minimum value to 0.
ASSERT_TRUE(HITLS_CFG_SetMaxCertList(tlsConfig, MIN_CERT_LIST) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMaxCertList(tlsConfig, &maxSize) == HITLS_SUCCESS);
ASSERT_TRUE(maxSize == MIN_CERT_LIST);
// The config parameter is empty.
ASSERT_TRUE(HITLS_SetMaxCertList(NULL, MAX_CERT_LIST) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetMaxCertList(NULL, &maxSize) == HITLS_NULL_INPUT);
// Set the maximum value to 2 ^ 32 - 1.
ASSERT_TRUE(HITLS_SetMaxCertList(ctx, MAX_CERT_LIST) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetMaxCertList(ctx, &maxSize) == HITLS_SUCCESS);
ASSERT_TRUE(maxSize == MAX_CERT_LIST);
// Set the minimum value to 0.
ASSERT_TRUE(HITLS_SetMaxCertList(ctx, MIN_CERT_LIST) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetMaxCertList(ctx, &maxSize) == HITLS_SUCCESS);
ASSERT_TRUE(maxSize == MIN_CERT_LIST);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
void ExampleInfoCallback(const HITLS_Ctx *ctx, int32_t eventType, int32_t value)
{
(void)ctx;
(void)eventType;
(void)value;
}
uint64_t Test_RecordPaddingCb(HITLS_Ctx *ctx, int32_t type, uint64_t length, void *arg)
{
(void)ctx;
(void)type;
(void)length;
(void)arg;
return HITLS_SUCCESS;
}
/* @
* @test UT_TLS_CM_InfoCb_API_TC001
* @title InfoCb Interface Parameter Test
* @precon nan
* @brief
1. Use the HITLS_GetInfoCb without HITLS_CFG_SetInfoCb. Expected result 1 is obtained.
2. Use the HITLS_SetInfoCb interface to set callback. Expected result 2
3. Use the HITLS_GetInfoCb . Expected result 3
4. Use the HITLS_GetInfoCb with the parameter is NULL . Expected result 4
* @expect
1. Return the NULL.
2. Return the HITLS_SUCCESS
3. Return value is not NULL.
4. Return the NULL.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_InfoCb_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(config != NULL);
FRAME_LinkObj *client = FRAME_CreateLink(config, BSL_UIO_UDP);
ASSERT_TRUE(client != NULL);
HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
ASSERT_TRUE(clientTlsCtx != NULL);
HITLS_InfoCb infoCallBack = HITLS_GetInfoCb(clientTlsCtx);
ASSERT_TRUE(infoCallBack == NULL);
int32_t ret = HITLS_SetInfoCb(clientTlsCtx, ExampleInfoCallback);
ASSERT_TRUE(ret == HITLS_SUCCESS);
infoCallBack = HITLS_GetInfoCb(clientTlsCtx);
ASSERT_TRUE(infoCallBack != NULL);
infoCallBack = HITLS_GetInfoCb(NULL);
ASSERT_TRUE(infoCallBack == NULL);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
}
/* END_CASE */
#define MSG_CB_PRINT_LEN 500
void msg_callback(int32_t writePoint, int32_t tlsVersion, int32_t contentType, const void *msg,
uint32_t msgLen, HITLS_Ctx *ctx, void *arg)
{
(void)writePoint;
(void)tlsVersion;
(void)contentType;
(void)msg;
(void)msgLen;
(void)ctx;
(void)arg;
}
/* @
* @test UT_TLS_CM_SetMsgCb_API_TC001
* @title HITLS_SetMsgCb Interface Parameter Test
* @precon nan
* @brief
1. Set ctx to NULL. Expected result 1 is obtained.
2. Use the HITLS_SetMsgCb interface to set callback. (Expected result 2)
* @expect
1. Return the HITLS_NULL_INPUT message.
2. Return the HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SetMsgCb_API_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = NULL;
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(HITLS_SetMsgCb(NULL, msg_callback), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetMsgCb(ctx, msg_callback), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GetError_API_TC001
* @title HITLS_GetError Interface Parameter Test
* @precon nan
* @brief 1. Set ctx to NULL. Expected result 1 is obtained.
2.Invoke the HITLS_GetError interface and send the return value. The expected result 2 is obtained
* @expect 1. Return the HITLS_ERR_SYSCALL message.
2. Link error codes are returned
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GetError_API_TC001(void)
{
FRAME_Init();
HITLS_Ctx *ctx = NULL;
HITLS_Config *config = NULL;
config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetError(NULL, HITLS_SUCCESS) == HITLS_ERR_SYSCALL);
ASSERT_TRUE(HITLS_GetError(ctx, HITLS_SUCCESS) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SetAlpnProtos_API_TC001
* @title HITLS_SetAlpnProtos Interface Parameter Test
* @precon nan
* @brief
1. Set ctx to NULL. Expected result 1 is obtained.
* @expect
1. Return the HITLS_NULL_INPUT message.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SetAlpnProtos_API_TC001()
{
HitlsInit();
uint8_t * alpnProtosname = (uint8_t *)"vpn|http";
uint32_t alpnProtosnameLen = sizeof(alpnProtosname);
ASSERT_TRUE(HITLS_SetAlpnProtos(NULL, alpnProtosname, alpnProtosnameLen) == HITLS_NULL_INPUT);
EXIT:
return;
}
/* END_CASE */
uint32_t SetPskClientCallback(HITLS_Ctx *ctx, const uint8_t *hint, uint8_t *identity, uint32_t maxIdentityLen,
uint8_t *psk, uint32_t maxPskLen)
{
(void)ctx;
(void)hint;
(void)identity;
(void)maxIdentityLen;
(void)psk;
(void)maxPskLen;
return HITLS_SUCCESS;
}
/* @
* @test UT_TLS_CM_SetPskClientCallback_API_TC001
* @title HITLS_SetPskClientCallback Interface Parameter Test
* @precon nan
* @brief
1. Set ctx to NULL. Expected result 1 is obtained.
2. Use the HITLS_SetPskClientCallback interface to set callback. Expected result 2
* @expect
1. Return the HITLS_NULL_INPUT message.
2. Return the HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SetPskClientCallback_API_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = NULL;
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(HITLS_SetPskClientCallback(NULL, SetPskClientCallback), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetPskClientCallback(ctx, SetPskClientCallback), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
static uint32_t SetPskServerCallback(HITLS_Ctx *ctx, const uint8_t *identity, uint8_t *psk, uint32_t maxPskLen)
{
(void)ctx;
(void)identity;
(void)psk;
(void)maxPskLen;
return HITLS_SUCCESS;
}
/* @
* @test UT_TLS_CM_SetPskServerCallback_API_TC001
* @title HITLS_SetPskServerCallback Interface Parameter Test
* @precon nan
* @brief
1. Set ctx to NULL. Expected result 1 is obtained.
2. Use the HITLS_SetPskServerCallback interface to set callback. Expected result 2
* @expect
1. Return the HITLS_NULL_INPUT message.
2. Return the HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SetPskServerCallback_API_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = NULL;
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(HITLS_SetPskServerCallback(NULL, SetPskServerCallback), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetPskServerCallback(ctx, SetPskServerCallback), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
static int32_t SetPskUsePsksessionCallback(HITLS_Ctx *ctx, uint32_t hashAlgo, const uint8_t **id,
uint32_t *idLen, HITLS_Session **session)
{
(void)ctx;
(void)hashAlgo;
(void)id;
(void)idLen;
(void)session;
return HITLS_SUCCESS;
}
/* @
* @test UT_TLS_CM_SetPskUseSessionCallback_API_TC001
* @title HITLS_SetPskUseSessionCallback Interface Parameter Test
* @precon nan
* @brief
1. Set ctx to NULL. Expected result 1 is obtained.
2. Use the HITLS_SetPskUseSessionCallback interface to set callback. Expected result 2
* @expect
1. Return the HITLS_NULL_INPUT message.
2. Return the HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SetPskUseSessionCallback_API_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = NULL;
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(HITLS_SetPskUseSessionCallback(NULL, SetPskUsePsksessionCallback), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetPskUseSessionCallback(ctx, SetPskUsePsksessionCallback), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
int32_t SetPskFindSessionCallback(HITLS_Ctx *ctx, const uint8_t *identity, uint32_t identityLen,
HITLS_Session **session)
{
(void)ctx;
(void)identity;
(void)identityLen;
(void)session;
return HITLS_SUCCESS;
}
/* @
* @test UT_TLS_CM_SetPskFindSessionCallback_API_TC001
* @title HITLS_SetPskFindSessionCallback Interface Parameter Test
* @precon nan
* @brief
1. Set ctx to NULL. Expected result 1 is obtained.
2. Use the HITLS_SetPskFindSessionCallback interface to set callback. Expected result 2
* @expect
1. Return the HITLS_NULL_INPUT message.
2. Return the HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SetPskFindSessionCallback_API_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = NULL;
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(HITLS_SetPskFindSessionCallback(NULL, SetPskFindSessionCallback), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetPskFindSessionCallback(ctx, SetPskFindSessionCallback), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SetNeedCheckPmsVersion_API_TC001
* @title HITLS_SetNeedCheckPmsVersion Interface Parameter Test
* @precon nan
* @brief
1. Set ctx to NULL. Expected result 1 is obtained.
2. Use the HITLS_SetNeedCheckPmsVersion interface to set parameter true. Expected result 2
* @expect
1. Return the HITLS_NULL_INPUT message.
2. Return the HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SetNeedCheckPmsVersion_API_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = NULL;
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(HITLS_SetNeedCheckPmsVersion(NULL, true), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetNeedCheckPmsVersion(ctx, true), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SetPskIdentityHint_API_TC001
* @title HITLS_SetPskIdentityHint Interface Parameter Test
* @precon nan
* @brief
1. Set ctx to NULL. Expected result 1 is obtained.
2. Use the HITLS_SetPskIdentityHint interface to set parameter. Expected result 2
* @expect
1. Return the HITLS_NULL_INPUT message.
2. Return the HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SetPskIdentityHint_API_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
uint8_t * identityH = (uint8_t *)"123456";
uint32_t identityHintLen = strlen((char *)identityH);
ASSERT_TRUE(HITLS_SetPskIdentityHint(ctx, identityH, identityHintLen) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
return;
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SETTICKETNUMS_API_TC001
* @title HITLS_SetTicketNums interface test
* @precon nan
* @brief
* 1. Apply for and initialize config and ctx.
* 2. Invoke the HITLS_SetTicketNums interface and set the input parameter of the HITLS_Ctx to NULL.
* 3. Invoke the HITLS_SetTicketNums interface and set the input parameter of the ticketNums to 0.
* 4. Invoke the HITLS_SetTicketNums interface and set normal ticketNums.
* @expect
* 1. Initialization succeeded.
* 2. The interface returns HITLS_NULL_INPUT.
* 3. The interface returns HITLS_SUCCESS.
* 4. The interface returns HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SETTICKETNUMS_API_TC001()
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(HITLS_SetTicketNums(NULL, 0), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetTicketNums(ctx, 0), HITLS_SUCCESS);
ASSERT_EQ(HITLS_SetTicketNums(ctx, 3), HITLS_SUCCESS);
ASSERT_EQ(HITLS_SetTicketNums(ctx, 100), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GETTICKETNUMS_API_TC001
* @title HITLS_GetTicketNums interface test
* @precon nan
* @brief
* 1. Apply for and initialize config and ctx.
* 2. Invoke the HITLS_GetRecordPaddingCb interface and set the input parameter of the HITLS_Ctx to NULL.
* 3. Invoke the HITLS_GetRecordPaddingCb interface to get the default ticketNums.
* 4. Invoke the HITLS_GetRecordPaddingCb interface and set normal ticketNums.
* 5. Invoke the HITLS_GetRecordPaddingCb interface to get the ticketNums
* @expect
* 1. Initialization succeeded.
* 2. The interface returns ticketNums is 2.
* 3. The interface returns HITLS_NULL_INPUT.
* 4. The interface returns HITLS_SUCCESS.
* 5. Consistent with the configured ticketNums.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GETTICKETNUMS_API_TC001()
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS13Config();
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
const int defaultNum = 2;
int TicketNum = 3;
ASSERT_EQ(HITLS_GetTicketNums(NULL), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_GetTicketNums(ctx), defaultNum);
ASSERT_EQ(HITLS_SetTicketNums(ctx, TicketNum), HITLS_SUCCESS);
ASSERT_EQ(HITLS_GetTicketNums(ctx), TicketNum);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SETRECORDPADDINGCB_API_TC001
* @title HITLS_SetRecordPaddingCb interface test
* @precon nan
* @brief
* 1. Apply for and initialize config and ctx.
* 2. Invoke the HITLS_SetRecordPaddingCb interface and set the input parameter of the HITLS_Ctx to NULL.
* 3. Invoke the HITLS_SetRecordPaddingCb interface and set the input parameter of the callback to NULL.
* 4. Invoke the HITLS_SetRecordPaddingCb interface and set normal callback.
* @expect
* 1. Initialization succeeded.
* 2. The interface returns HITLS_NULL_INPUT.
* 3. The interface returns HITLS_SUCCESS.
* 4. The interface returns HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SETRECORDPADDINGCB_API_TC001()
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(HITLS_SetRecordPaddingCb(NULL, 0), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetRecordPaddingCb(ctx, NULL), HITLS_SUCCESS);
ASSERT_EQ(HITLS_SetRecordPaddingCb(ctx, Test_RecordPaddingCb), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GETRECORDPADDINGCB_API_TC001
* @title HITLS_GetRecordPaddingCb interface test
* @precon nan
* @brief
* 1. Apply for and initialize config and ctx.
* 2. Invoke the HITLS_GetRecordPaddingCb interface to get the default callback.
* 3. Invoke the HITLS_GetRecordPaddingCb interface and set the input parameter of the HITLS_Ctx to NULL.
* 4. Invoke the HITLS_GetRecordPaddingCb interface and set normal callback.
* 5. Invoke the HITLS_GetRecordPaddingCb interface to get the callback
* @expect
* 1. Initialization succeeded.
* 2. The interface returns NULL.
* 3. The interface returns HITLS_NULL_INPUT.
* 4. The interface returns HITLS_SUCCESS.
* 5. Consistent with the configured callback.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GETRECORDPADDINGCB_API_TC001()
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(HITLS_GetRecordPaddingCb(ctx), NULL);
ASSERT_EQ(HITLS_GetRecordPaddingCb(NULL), NULL);
ASSERT_TRUE(HITLS_SetRecordPaddingCb(ctx, Test_RecordPaddingCb) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetRecordPaddingCb(ctx) == Test_RecordPaddingCb);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SETRECORDPADDINGCBARG_API_TC001
* @title HITLS_SetRecordPaddingCbArg interface test
* @precon nan
* @brief
* 1. Apply for and initialize config and ctx.
* 2. Invoke the HITLS_SetRecordPaddingCbArg interface and set the input parameter of the HITLS_Ctx to NULL.
* 3. Invoke the HITLS_SetRecordPaddingCbArg interface and set the input parameter of the RecordPaddingArg to NULL.
* 4. Invoke the HITLS_SetRecordPaddingCbArg interface and set normal recordPaddingArg.
* @expect
* 1. Initialization succeeded.
* 2. The interface returns HITLS_NULL_INPUT.
* 3. The interface returns HITLS_SUCCESS.
* 4. The interface returns HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SETRECORDPADDINGCBARG_API_TC001()
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
uint32_t arg = 1;
ASSERT_EQ(HITLS_SetRecordPaddingCbArg(NULL, &arg), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetRecordPaddingCbArg(ctx, NULL), HITLS_SUCCESS);
ASSERT_EQ(HITLS_SetRecordPaddingCbArg(ctx, &arg), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_GETRECORDPADDINGCBARG_API_TC001
* @title HITLS_GetRecordPaddingCbArg interface test
* @precon nan
* @brief
* 1. Apply for and initialize config and ctx.
* 2. Invoke the HITLS_GetRecordPaddingCbArg interface to get the default recordPaddingArg.
* 3. Invoke the HITLS_GetRecordPaddingCbArg interface and set the input parameter of the HITLS_Ctx to NULL.
* 4. Invoke the HITLS_GetRecordPaddingCbArg interface and set normal recordPaddingArg.
* 5. Invoke the HITLS_GetRecordPaddingCbArg interface to get the recordPaddingArg.
* @expect
* 1. Initialization succeeded.
* 2. The interface returns NULL.
* 3. The interface returns HITLS_NULL_INPUT.
* 4. The interface returns HITLS_SUCCESS.
* 5. Consistent with the configured recordPaddingArg.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GETRECORDPADDINGCBARG_API_TC001()
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
int arg = 1;
ASSERT_EQ(HITLS_GetRecordPaddingCbArg(ctx), NULL);
ASSERT_EQ(HITLS_GetRecordPaddingCbArg(NULL), NULL);
ASSERT_EQ(HITLS_SetRecordPaddingCbArg(ctx, &arg), HITLS_SUCCESS);
ASSERT_EQ(*(int*)HITLS_GetRecordPaddingCbArg(ctx) , arg);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SETCLOSECHECKKEYUSAGE_API_TC001
* @title HITLS_SetCheckKeyUsage interface test
* @precon nan
* @brief
* 1. Apply for and initialize config and ctx.
* 2. Invoke the HITLS_SetCheckKeyUsage interface and set the input parameter of the HITLS_Ctx to NULL.
* 3. Invoke the HITLS_SetCheckKeyUsage interface and set the input parameter of the isClose to true.
* 4. Invoke the HITLS_SetCheckKeyUsage interface and set the input parameter of the isClose to false.
* @expect
* 1. Initialization succeeded.
* 2. The interface returns HITLS_NULL_INPUT.
* 3. The interface returns HITLS_SUCCESS.
* 4. The interface returns HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SETCLOSECHECKKEYUSAGE_API_TC001()
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_EQ(HITLS_SetCheckKeyUsage(NULL, true), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetCheckKeyUsage(ctx, true), HITLS_SUCCESS);
ASSERT_EQ(HITLS_SetCheckKeyUsage(ctx, false), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
static int32_t STUB_ChangeState(TLS_Ctx *ctx, uint32_t nextState)
{
int32_t ret = HITLS_SUCCESS;
if (HS_STATE_BUTT == nextState) {
if (true == ctx->isClient) {
ctx->hsCtx->hsMsg = NULL;
ret = HITLS_REC_NORMAL_RECV_BUF_EMPTY;
}
}
HS_Ctx *hsCtx = (HS_Ctx *)ctx->hsCtx;
hsCtx->state = nextState;
return ret;
}
static bool StateCompare(FRAME_LinkObj *link, HITLS_HandshakeState state)
{
if ((link->ssl->hsCtx != NULL) && (link->ssl->hsCtx->state == state)) {
if (state != TRY_RECV_FINISH) {
return true;
}
}
return false;
}
/** @
* @test UT_TLS_CM_HITLS_DOHANDSHAKE_API_TC001
* @title HITLS_DoHandShake Interface Test
* @precon nan
* @brief 1、Invoke the HITLS_DoHandShake to create tls connect. The expected result 1 is obtained
* @expect 1、connect success
@ */
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_DOHANDSHAKE_API_TC001()
{
FRAME_Init();
HITLS_Config *config = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
int32_t clientRet;
int32_t serverRet;
int32_t ret;
uint32_t count = 0;
FuncStubInfo tmpRpInfo = { 0 };
STUB_Init();
STUB_Replace(&tmpRpInfo, HS_ChangeState, STUB_ChangeState);
HITLS_SetEndPoint(client->ssl, true);
do {
if (StateCompare(client, HS_STATE_BUTT)) {
ret = HITLS_SUCCESS;
break;
}
clientRet = HITLS_DoHandShake(client->ssl);
if (clientRet != HITLS_SUCCESS) {
ret = clientRet;
if ((clientRet != HITLS_REC_NORMAL_IO_BUSY) && (clientRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(client, server);
if (ret != HITLS_SUCCESS) {
break;
}
if (StateCompare(server, HS_STATE_BUTT)) {
ret = HITLS_SUCCESS;
break;
}
serverRet = HITLS_DoHandShake(server->ssl);
if (serverRet != HITLS_SUCCESS) {
ret = serverRet;
if ((serverRet != HITLS_REC_NORMAL_IO_BUSY) && (serverRet != HITLS_REC_NORMAL_RECV_BUF_EMPTY)) {
break;
}
}
ret = FRAME_TrasferMsgBetweenLink(server, client);
if (ret != HITLS_SUCCESS) {
break;
}
if (clientRet == HITLS_SUCCESS && serverRet == HITLS_SUCCESS) {
ret = HITLS_SUCCESS;
break;
}
count++;
ret = HITLS_INTERNAL_EXCEPTION;
} while (count < 40);
ASSERT_EQ(ret, HITLS_SUCCESS);
EXIT:
STUB_Reset(&tmpRpInfo);
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SECURITY_SECURITYLEVEL_API_TC001
* @title HITLS_GetSecurityLevel and HITLS_CFG_GetSecurityLevel Interface Test
* @precon nan
* @brief HITLS_GetSecurityLevel
1、Invoke HITLS_GetSecurityLevel to obtain the default security level. The expected result 1 is obtained
2、Check the obtained security level. The expected result 2 is obtained
HITLS_CFG_GetSecurityLevel
3、Invoke HITLS_CFG_GetSecurityLevel to obtain the default security level. The expected result 1 is obtained
4、Check the obtained security level. The expected result 2 is obtained
* @expect 1、return HITLS_SUCCESS
2、The security level is 1
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SECURITY_SECURITYLEVEL_API_TC001()
{
HitlsInit();
HITLS_Ctx *ctx = NULL;
HITLS_Config *Config;
int32_t level;
Config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(Config != NULL);
ctx = HITLS_New(Config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetSecurityLevel(ctx, &level) == HITLS_SUCCESS);
ASSERT_TRUE(level == 1);
ASSERT_TRUE(HITLS_CFG_GetSecurityLevel(Config, &level) == HITLS_SUCCESS);
ASSERT_TRUE(level == 1);
EXIT:
HITLS_CFG_FreeConfig(Config);
HITLS_Free(ctx);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SECURITY_SECURITYLEVEL_API_TC002
* @title HITLS_SetSecurityLevel and HITLS_CFG_SetSecurityLevel Interface Parameter Test
* @precon nan
* @brief HITLS_SetSecurityLevel
1、Invoke the HITLS_SetSecurityLevel to configure the security level.The expected result 1 is obtained
2、Invoke HITLS_GetSecurityLevel to obtain the default security level. The expected result 2 is obtained
3、Check the obtained security level. The expected result 3 is obtained
HITLS_CFG_SetSecurityLevel
4、Invoke the HITLS_CFG_SetSecurityLevel to configure the security level.The expected result 1 is obtained
5、Invoke HITLS_GetSecurityLevel to obtain the default security level. The expected result 2 is obtained
6、Check the obtained security level. The expected result 3 is obtained
* @expect 1、return HITLS_SUCCESS
2、return HITLS_SUCCESS
3、The security level is equal to the configured security level.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SECURITY_SECURITYLEVEL_API_TC002()
{
HitlsInit();
HITLS_Ctx *ctx = NULL;
HITLS_Config *Config;
int32_t level;
Config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(Config != NULL);
ctx = HITLS_New(Config);
ASSERT_TRUE(ctx != NULL);
for(int32_t i = 0; i <= 5; i++){
ASSERT_TRUE(HITLS_SetSecurityLevel(ctx, i) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetSecurityLevel(ctx, &level) == HITLS_SUCCESS);
ASSERT_TRUE(level == i);
ASSERT_TRUE(HITLS_CFG_SetSecurityLevel(Config, i) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetSecurityLevel(Config, &level) == HITLS_SUCCESS);
ASSERT_TRUE(level == i);
}
EXIT:
HITLS_CFG_FreeConfig(Config);
HITLS_Free(ctx);
}
/* END_CASE */
int32_t TEST_HITLS_SecurityCb(const HITLS_Ctx *ctx, const HITLS_Config *config, int32_t option,
int32_t bits, int32_t id, void *other, void *exData)
{
(void)ctx;
(void)config;
(void)option;
(void)bits;
(void)id;
(void)other;
(void)exData;
return HITLS_SUCCESS;
}
/** @
* @test UT_TLS_CM_SECURITY_SECURITYCB_API_TC001
* @title HITLS_SetSecurityCb HITLS_SetSecurityExData HITLS_GetSecurityCb and HITLS_GetSecurityExData Interface Test
* @precon nan
* @brief 1、Invoke the HITLS_SetSecurityCb interface and set the first parameter to NULL.
The expected result 1 is obtained
2、Invoke the HITLS_SetSecurityCb interface and transfer the first parameter to a normal parameter.
The expected result 2 is obtained
3、Invoke the HITLS_SetSecurityExData interface and set the first parameter to NULL. The expected result 3 is obtained
4、Invoke the HITLS_SetSecurityExData interface and transfer the first parameter to a normal parameter.
The expected result 4 is obtained
5、Invoke the HITLS_GetSecurityCb interface and set the parameter to NULL. The expected result 5 is obtained
6、Invoke the HITLS_GetSecurityCb interface and transfer the parameter to a normal parameter.
The expected result 5 is obtained
7、Invoke the HITLS_GetSecurityExData interface and set the parameter to NULL. The expected result 7 is obtained
8、Invoke the HITLS_GetSecurityExData interface and transfer the parameter to a normal parameter.
The expected result 8 is obtained
* @expect 1、return HITLS_NULL_INPUT
2、 return HITLS_SUCCESS
3、 return HITLS_NULL_INPUT
4、 return HITLS_SUCCESS
5、 return NULL
6、 The returned value is equal to the configured value TEST_HITLS_SecurityCb.
7、 return NULL
8、 The returned value is equal to the configured value securityExData.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SECURITY_SECURITYCB_API_TC001()
{
HitlsInit();
HITLS_Ctx *ctx = NULL;
HITLS_Config *Config;
Config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(Config != NULL);
ctx = HITLS_New(Config);
int32_t userdata = 0;
void *securityExData = &userdata;
ASSERT_EQ(HITLS_SetSecurityCb(NULL, TEST_HITLS_SecurityCb), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetSecurityCb(ctx, TEST_HITLS_SecurityCb), HITLS_SUCCESS);
ASSERT_EQ(HITLS_SetSecurityExData(NULL, securityExData), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_SetSecurityExData(ctx, securityExData), HITLS_SUCCESS);
ASSERT_EQ(HITLS_GetSecurityCb(NULL), NULL);
ASSERT_EQ(HITLS_GetSecurityCb(ctx), TEST_HITLS_SecurityCb);
ASSERT_EQ(HITLS_GetSecurityExData(NULL), NULL);
ASSERT_EQ(HITLS_GetSecurityExData(ctx), securityExData);
EXIT:
HITLS_CFG_FreeConfig(Config);
HITLS_Free(ctx);
}
/* END_CASE */
/** @
* @test UT_TLS_CM_SECURITY_SECURITYCB_API_TC002
* @title HITLS_CFG_SetSecurityCb HITLS_CFG_SetSecurityExData HITLS_CFG_GetSecurityCb and
HITLS_CFG_GetSecurityExData Interface Test
* @precon nan
* @brief 1、Invoke the HITLS_CFG_SetSecurityCb interface and set the first parameter to NULL.
The expected result 1 is obtained
2、Invoke the HITLS_CFG_SetSecurityCb interface and transfer the first parameter to a normal parameter.
The expected result 2 is obtained
3、Invoke the HITLS_CFG_SetSecurityExData interface and set the first parameter to NULL.
The expected result 3 is obtained
4、Invoke the HITLS_CFG_SetSecurityExData interface and transfer the first parameter to a normal parameter.
The expected result 4 is obtained
5、Invoke the HITLS_CFG_GetSecurityCb interface and set the parameter to NULL. The expected result 5 is obtained
6、Invoke the HITLS_CFG_GetSecurityCb interface and transfer the parameter to a normal parameter.
The expected result 5 is obtained
7、Invoke the HITLS_CFG_GetSecurityExData interface and set the parameter to NULL. The expected result 7 is obtained
8、Invoke the HITLS_CFG_GetSecurityExData interface and transfer the parameter to a normal parameter.
The expected result 8 is obtained
* @expect 1、return HITLS_NULL_INPUT
2、 return HITLS_SUCCESS
3、 return HITLS_NULL_INPUT
4、 return HITLS_SUCCESS
5、 return NULL
6、 The returned value is equal to the configured value TEST_HITLS_SecurityCb.
7、 return NULL
8、 The returned value is equal to the configured value securityExData.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SECURITY_SECURITYCB_API_TC002()
{
HitlsInit();
HITLS_Config *Config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(Config != NULL);
int32_t userdata = 0;
void *securityExData = &userdata;
ASSERT_EQ(HITLS_CFG_SetSecurityCb(NULL, TEST_HITLS_SecurityCb), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_CFG_SetSecurityCb(Config, TEST_HITLS_SecurityCb), HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_SetSecurityExData(NULL, securityExData), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_CFG_SetSecurityExData(Config, securityExData), HITLS_SUCCESS);
ASSERT_EQ(HITLS_CFG_GetSecurityCb(NULL), NULL);
ASSERT_EQ(HITLS_CFG_GetSecurityCb(Config), TEST_HITLS_SecurityCb);
ASSERT_EQ(HITLS_CFG_GetSecurityExData(NULL), NULL);
ASSERT_EQ(HITLS_CFG_GetSecurityExData(Config), securityExData);
EXIT:
HITLS_CFG_FreeConfig(Config);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_IS_DTLS_API_TC001
* @title Test HITLS_IsDtls
* @precon nan
* @brief HITLS_IsDtls
* 1. Input an empty TLS connection handle. Expected result 1.
* 2. Transfer the non-empty TLS connection handle information and leave isDtls blank. Expected result 1.
* 3. Transfer the non-empty TLS connection handle information. The isDtls parameter is not empty. Expected result 2.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_TLS_CM_IS_DTLS_API_TC001(int tlsVersion)
{
HitlsInit();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
uint8_t isDtls = 0;
ASSERT_TRUE(HITLS_IsDtls(ctx, &isDtls) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_IsDtls(ctx, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_IsDtls(ctx, &isDtls) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/*@
* @test UT_TLS_CM_GET_SELECTEDALPNPROTO_API_TC001
*
* @title test HITLS_GetSelectedAlpnProto interface
* @brief
* 1. Construct the CTX configuration. Expected result 1.
* 2. Construct the CTX connection handle. Expected result 1.
* 3. tls connection handle is NULL, Invoke the HITLS_GetSelectedAlpnProto interface. Expected result 2.
* 4. proto is NULL ,invoke the HITLS_CFG_SetSessionIdCtx interface.Expected result 2.
* 5. protoLen is NULL, Invoke the HITLS_GetSessionTicketKey interface.Expected result 2
* @expect 1. Return not NULL.
* 2. Return not HITLS_NULL_INPUT.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_SELECTEDALPNPROTO_API_TC001()
{
HitlsInit();
HITLS_Config *tlsConfig;
HITLS_Ctx *ctx = NULL;
tlsConfig = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
uint8_t * alpnProtosname = (uint8_t *)"vpn|http";
uint32_t alpnProtosnameLen = sizeof(alpnProtosname);
ASSERT_TRUE(HITLS_GetSelectedAlpnProto(NULL, &alpnProtosname, &alpnProtosnameLen) == HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_GetSelectedAlpnProto(ctx, NULL, &alpnProtosnameLen), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_GetSelectedAlpnProto(ctx, &alpnProtosname, NULL), HITLS_NULL_INPUT);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
return;
}
/* END_CASE */
#define DATA_MAX_LEN 1024
/*@
* @test UT_TLS_CM_GET_SET_SESSIONTICKETKEY_API_TC001
*
* @title test HITLS_SetSessionTicketKey/HITLS_GetSessionTicketKey interface
* @brief 1. Construct the CTX connection handle. Expected result 1.
* 2. tls connection handle is NULL, Invoke the HITLS_SetSessionTicketKey interface. Expected result 2.
* 3. tls connection handle is NULL, Invoke the HITLS_GetSessionTicketKey interface.Expected result 2.
* @expect 1. Return not NULL.
* 2. Return HITLS_NULL_INPUT.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_GET_SET_SESSIONTICKETKEY_API_TC001(int version)
{
FRAME_Init();
uint8_t key[] = "748ab9f3dc1a23";
HITLS_Config *config = GetHitlsConfigViaVersion(version);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
uint8_t getKey[DATA_MAX_LEN] = {0};
uint32_t getKeySize = DATA_MAX_LEN;
uint32_t outSize = 0;
uint32_t ticketKeyRandLen = HITLS_TICKET_KEY_NAME_SIZE + HITLS_TICKET_KEY_SIZE + HITLS_TICKET_KEY_SIZE;
ASSERT_TRUE(HITLS_SetSessionTicketKey(NULL, key, ticketKeyRandLen) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetSessionTicketKey(NULL, getKey, getKeySize, &outSize) == HITLS_NULL_INPUT);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_SET_SESSIONIDCTX_API_TC001
*
* @title test HITLS_CFG_SetSessionIdCtx interface
* @precon nan
* @brief 1. Construct the CTX connection handle. Expected result 1.
* 2. config is NULL, Invoke the HITLS_CFG_SetSessionIdCtx interface. Expected result 4.
* 3. invoke the HITLS_CFG_SetSessionIdCtx interface.Expected result 2.
* 4. tls connection handle is NULL, Invoke the HITLS_SetSessionIdCtx interface.Expected
* result 4.
* 5. Invoke the HITLS_SetSessionIdCtx interface. Expected result 2.
* @expect 1. Return not NULL.
* 2. Return not HITLS_NULL_INPUT.
* 3. Return NULL.
* 4. Return HITLS_NULL_INPUT.
@ */
/* BEGIN_CASE */
void UT_TLS_CM_SET_SESSIONIDCTX_API_TC001(int version)
{
FRAME_Init();
char *key = "748ab9f3dc1a23";
HITLS_Config *config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
HITLS_Ctx *ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
uint32_t keyLen = strlen(key);
ASSERT_TRUE(HITLS_CFG_SetSessionIdCtx(NULL, (const uint8_t *)key, keyLen)== HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetSessionIdCtx(config, (const uint8_t *)key, keyLen)!= HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetSessionIdCtx(NULL, (const uint8_t *)key, keyLen)== HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetSessionIdCtx(ctx, (const uint8_t *)key, keyLen)!= HITLS_NULL_INPUT);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_TLS_CM_HITLS_GetCertificate_API_TC001
* @title Cover the input parameter of the HITLS_GetCertificate interface.
* @precon nan
* @brief 1. Invoke the HITLS_GetCertificate interface and leave ctx blank. Expected result 1.
* 2. Invoke the HITLS_GetPeerCertificate interface and leave ctx blank. Expected result 1.
* 3. Invoke the HITLS_GetPeerCertificate interface. The value of ctx is not empty and the value of ctx->session
* is empty. Expected result 1.
* 4. Invoke the HITLS_GetPeerCertChain interface and leave ctx blank. Expected result 1.
* 5. Invoke the HITLS_GetPeerCertChain interface. The value of ctx is not empty and the value of ctx->session is
* empty. Expected result 1.
* @expect 1.Return NULL
@ */
/* BEGIN_CASE */
void UT_TLS_CM_HITLS_GetCertificate_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetCertificate(NULL) == NULL);
ASSERT_TRUE(HITLS_GetPeerCertificate(NULL) == NULL);
ASSERT_TRUE(HITLS_GetPeerCertChain(NULL) == NULL);
ctx->session = NULL;
ASSERT_TRUE(HITLS_GetPeerCertificate(ctx) == NULL);
ASSERT_TRUE(HITLS_GetPeerCertChain(ctx) == NULL);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_HITLS_CM_HITLS_Set_and_Get_ErrorCode_API_TC001
* @spec -
* @title Cover the input parameter of HITLS_SetChainStore and HITLS_GetChainStore interface
* @precon nan
* @brief 1. Invoke the HITLS_GetErrorCode interface and leave ctx blank. Expected result 1.
2. Invoke the HITLS_GetErrorCode interface with ctx not empty. Expected result 3.
3. Invoke the HITLS_SetErrorCode interface and leave ctx blank. Expected result 1.
4. Invoke the HITLS_SetErrorCode interface. The value of ctx is not empty. Expected result 2.
* @expect 1. Return HITLS_NULL_INPUT
2. Return HITLS_SUCCESS
3. Return errorCode
* @prior Level 1
* @auto TRUE
@ */
/* BEGIN_CASE */
void UT_HITLS_CM_HITLS_Set_and_Get_ErrorCode_API_TC001(int version)
{
HitlsInit();
HITLS_Config *tlsConfig = NULL;
HITLS_Ctx *ctx = NULL;
uint32_t errorCode = 0;
tlsConfig = HitlsNewCtx(version);
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
HITLS_SetErrorCode(ctx, errorCode);
ASSERT_TRUE(HITLS_GetErrorCode(NULL) == HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_GetErrorCode(ctx), errorCode);
ASSERT_TRUE(HITLS_SetErrorCode(ctx, errorCode) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_SetErrorCode(NULL, errorCode) == HITLS_NULL_INPUT);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_HITLS_CM_SET_GET_ENCRYPTTHENMAC_TC001
* @title Test the HITLS_SetEncryptThenMac and HITLS_GetEncryptThenMac interfaces.
* @precon nan
* @brief HITLS_SetEncryptThenMac
* 1. Transfer an empty TLS connection handle. Expected result 1.
* 2. Transfer a non-empty TLS connection handle and set encryptThenMacType to an invalid value. Expected result 2.
* 3. Transfer a non-empty TLS connection handle and set encryptThenMacType to a valid value. Expected result 3.
* HITLS_GetEncryptThenMac
* 1. Transfer an empty TLS connection handle. Expected result 1.
* 2. Transfer an empty encryptThenMacType pointer. Expected result 1.
* 3. Transfer the non-null TLS connection handle information and ensure that the encryptThenMacType pointer is not null. Expected result 3.
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCES and isEncryptThenMac is True
* 3. Return HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_HITLS_CM_SET_GET_ENCRYPTTHENMAC_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
uint32_t encryptThenMacType = 0;
ASSERT_TRUE(HITLS_SetEncryptThenMac(ctx, encryptThenMacType) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetEncryptThenMac(ctx, &encryptThenMacType) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetEncryptThenMac(ctx, NULL) == HITLS_NULL_INPUT);
encryptThenMacType = 1;
ASSERT_TRUE(HITLS_SetEncryptThenMac(ctx, encryptThenMacType) == HITLS_SUCCESS);
encryptThenMacType = -1;
ASSERT_TRUE(HITLS_SetEncryptThenMac(ctx, encryptThenMacType) == HITLS_SUCCESS);
ASSERT_TRUE(config->isEncryptThenMac = true);
uint32_t getencryptThenMacType = -1;
ASSERT_TRUE(HITLS_GetEncryptThenMac(ctx, &getencryptThenMacType) == HITLS_SUCCESS);
ASSERT_TRUE(getencryptThenMacType == true);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/* @
* @test UT_HITLS_CM_HITLS_GetPostHandshakeAuthSupport_TC001
* @title Test the HITLS_GetPostHandshakeAuthSupport interfaces.
* @precon nan
* @brief 1. Transfer an empty TLS connection handle. Expected result 1.
* 2. Transfer a non-empty TLS connection handle and set isSupport to to NULL. Expected result 1.
* 3. Transfer a non-empty TLS connection handle and set isSupport to a valid value. Expected result 2.
* @expect 1. Return HITLS_NULL_INPUT
* 2. Return HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_HITLS_CM_HITLS_GetPostHandshakeAuthSupport_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
uint32_t isSupport = 0;
ASSERT_TRUE(HITLS_GetPostHandshakeAuthSupport(NULL, NULL) == HITLS_NULL_INPUT);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetEncryptThenMac(ctx, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetEncryptThenMac(ctx, isSupport) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/interface_tlcp/test_suite_sdv_frame_cm_interface.c
|
C
|
unknown
| 172,166
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/time.h>
#include <linux/ioctl.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
#include <stddef.h>
#include <sys/types.h>
#include <regex.h>
#include "securec.h"
#include "bsl_sal.h"
#include "sal_net.h"
#include "hitls.h"
#include "frame_tls.h"
#include "cert_callback.h"
#include "hitls_config.h"
#include "hitls_error.h"
#include "bsl_errno.h"
#include "bsl_uio.h"
#include "frame_io.h"
#include "uio_abstraction.h"
#include "tls.h"
#include "tls_config.h"
#include "logger.h"
#include "process.h"
#include "hs_ctx.h"
#include "hlt.h"
#include "stub_replace.h"
#include "hitls_type.h"
#include "frame_link.h"
#include "session_type.h"
#include "common_func.h"
#include "hitls_func.h"
#include "hitls_cert_type.h"
#include "cert_mgr_ctx.h"
#include "parser_frame_msg.h"
#include "recv_process.h"
#include "simulate_io.h"
#include "rec_wrapper.h"
#include "cipher_suite.h"
#include "alert.h"
#include "conn_init.h"
#include "pack.h"
#include "send_process.h"
#include "cert.h"
#include "hitls_cert_reg.h"
#include "hitls_crypt_type.h"
#include "hs.h"
#include "hs_state_recv.h"
#include "app.h"
#include "record.h"
#include "rec_conn.h"
#include "session.h"
#include "frame_msg.h"
#include "pack_frame_msg.h"
#include "cert_mgr.h"
#include "hs_extensions.h"
#include "hlt_type.h"
#include "sctp_channel.h"
#include "hitls_crypt_init.h"
#include "crypt_default.h"
#include "stub_crypt.h"
#include "hitls_crypt.h"
#include "security.h"
/* END_HEADER */
#define DEFAULT_DESCRIPTION_LEN 128
#define ERROR_HITLS_GROUP 1
#define ERROR_HITLS_SIGNATURE 0xffffu
typedef struct {
uint16_t version;
BSL_UIO_TransportType uioType;
HITLS_Config *config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_Session *clientSession; /* Set the session to the client for session resume. */
} ResumeTestInfo;
static HITLS_Config *GetHitlsConfigViaVersion(int ver)
{
switch (ver) {
case TLS1_2:
case HITLS_VERSION_TLS12:
return HITLS_CFG_NewTLS12Config();
case TLS1_3:
case HITLS_VERSION_TLS13:
return HITLS_CFG_NewTLS13Config();
case DTLS1_2:
case HITLS_VERSION_DTLS12:
return HITLS_CFG_NewDTLS12Config();
default:
return NULL;
}
}
static int32_t UT_ClientHelloCb(HITLS_Ctx *ctx, int32_t *alert, void *arg)
{
(void)ctx;
(void)alert;
return *(int32_t *)arg;
}
static int32_t UT_CookieGenerateCb(HITLS_Ctx *ctx, uint8_t *cookie, uint32_t *cookie_len)
{
(void)ctx;
(void)cookie;
(void)cookie_len;
return 0;
}
static int32_t UT_CookieVerifyCb(HITLS_Ctx *ctx, const uint8_t *cookie, uint32_t cookie_len)
{
(void)ctx;
(void)cookie;
(void)cookie_len;
return 1;
}
/** @
* @test UT_TLS_CFG_UPREF_FUNC_TC001
* @spec -
* @title Invoke the HITLS_CFG_UpRef interface to change the number of config reference times.
* @precon nan
* @brief 1. Apply for and initialize config.
2. Invoke the HITLS_CFG_UpRef interface and transfer the config parameter.
3. Check the number of times the config file is referenced.
* @expect 1. The application is successful.
2. The invoking is successful.
3. The number of references is 2.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_UPREF_FUNC_TC001()
{
HitlsInit();
HITLS_Config *config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
ASSERT_TRUE(HITLS_CFG_UpRef(config) == HITLS_SUCCESS);
ASSERT_TRUE(config->references.count == 2);
HITLS_CFG_FreeConfig(config);
ASSERT_TRUE(config->references.count == 1);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_RESUMPTIONONRENEGOSUPPORT_API_TC001
* @Specifications-
* @title Test the HITLS_CFG_SetResumptionOnRenegoSupport interface for setting ResumptionOnRenegoSupport.
* @preppynan
* @brief HITLS_CFG_Setting negotiation support
* 1. Transfer empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and support invalid values. Expected result 2 is displayed.
* 3. The input configuration information is not empty and the value can be valid. Expected result 3 is obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned and isResumptionOnRenego is set to true.
* 3. HITLS_SUCCES is returned and isResumptionOnRenego is set to true or false.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_RESUMPTIONONRENEGOSUPPORT_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
bool support = -1;
ASSERT_TRUE(HITLS_CFG_SetResumptionOnRenegoSupport(config, support) == HITLS_NULL_INPUT);
switch (tlsVersion) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
break;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
break;
default:
config = NULL;
break;
}
ASSERT_TRUE(HITLS_CFG_SetResumptionOnRenegoSupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(config->isResumptionOnRenego == true);
support = false;
ASSERT_TRUE(HITLS_CFG_SetResumptionOnRenegoSupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(config->isResumptionOnRenego == false);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_NOCLIENTCERTSUPPORT_API_TC001
* @spec -
* @title Test the HITLS_CFG_SetNoClientCertSupport and HITLS_CFG_GetNoClientVerifySupport interfaces.
* @precon nan
* @brief HITLS_CFG_SetNoClientCertSupport
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and set support to an invalid value. Expected result 2 is obtained.
* 3. Transfer non-empty configuration information and set support to a valid value. Expected result 3 is obtained.
* HITLS_CFG_GetNoClientCertSupport
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer an empty isSupport pointer. Expected result 1 is obtained.
* 3. Transfer the non-null configuration information and the isSupport pointer is not null. Expected result 3 is
* obtained.
* @expect 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned and config->isSupportNoClientCert is true.
* 3. Returns HITLS_SUCCES and config->isSupportNoClientCert is true or false.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_NOCLIENTCERTSUPPORT_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
bool support = -1;
uint8_t isSupport = -1;
ASSERT_TRUE(HITLS_CFG_SetNoClientCertSupport(config, support) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetNoClientCertSupport(config, &isSupport) == HITLS_NULL_INPUT);
switch (tlsVersion) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
break;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
break;
default:
config = NULL;
break;
}
ASSERT_TRUE(HITLS_CFG_GetNoClientCertSupport(config, NULL) == HITLS_NULL_INPUT);
support = true;
ASSERT_TRUE(HITLS_CFG_SetNoClientCertSupport(config, support) == HITLS_SUCCESS);
support = -1;
ASSERT_TRUE(HITLS_CFG_SetNoClientCertSupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetNoClientCertSupport(config, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == true);
support = false;
ASSERT_TRUE(HITLS_CFG_SetNoClientCertSupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetNoClientCertSupport(config, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_CLIENTVERIFYSUPPORT_API_TC001
* @spec -
* @title Test the HITLS_CFG_SetClientVerifySupport and HITLS_CFG_GetClientVerifySupport interfaces.
* @precon nan
* @brief HITLS_CFG_SetClientVerifySupport
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and set support to an invalid value. Expected result 2 is obtained.
* 3. Transfer non-empty configuration information and set support to a valid value. Expected result 3 is obtained.
* HITLS_CFG_GetClientVerifySupport
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer an empty isSupport pointer. Expected result 1 is obtained.
* 3. Transfer the non-null configuration information and the isSupport pointer is not null. Expected result 3 is
* obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned, and config->isSupportClientVerify is true and isSupportVerifyNone is false.
* 3. HITLS_SUCCES is returned, and config->isSupportClientVerify is true or false. isSupportVerifyNone and
isSupportVerifyNone are mutually exclusive, but can be false at the same time.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_CLIENTVERIFYSUPPORT_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
bool support = -1;
uint8_t isSupport = -1;
ASSERT_TRUE(HITLS_CFG_SetClientVerifySupport(config, support) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetClientVerifySupport(config, &isSupport) == HITLS_NULL_INPUT);
switch (tlsVersion) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
break;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
break;
default:
config = NULL;
break;
}
ASSERT_TRUE(HITLS_CFG_GetClientVerifySupport(config, NULL) == HITLS_NULL_INPUT);
support = true;
ASSERT_TRUE(HITLS_CFG_SetClientVerifySupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(config->isSupportVerifyNone == false);
support = -1;
ASSERT_TRUE(HITLS_CFG_SetClientVerifySupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetClientVerifySupport(config, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == true);
support = false;
ASSERT_TRUE(HITLS_CFG_SetClientVerifySupport(config, support) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetClientVerifySupport(config, &isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(isSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_TMPDH_API_TC001
* @spec -
* @title Test the HITLS_CFG_SetTmpDh interface.
* @precon nan
* @brief HITLS_CFG_SetTmpDh
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and leave dhPkey empty. Expected result 1 is obtained.
* 3. Transfer non-empty configuration information and set dhPkey to a non-empty value. Expected result 2 is displayed.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_TMPDH_API_TC001(int tlsVersion, int securityBits, int securityLevel)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_CRYPT_Key *dhPkey = NULL;
switch (tlsVersion) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
break;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
break;
default:
config = NULL;
break;
}
dhPkey = HITLS_CRYPT_GenerateDhKeyBySecbits(LIBCTX_FROM_CONFIG(config), ATTRIBUTE_FROM_CONFIG(config), config,
securityBits);
ASSERT_TRUE(HITLS_CFG_SetTmpDh(NULL, dhPkey) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetSecurityLevel(config, securityLevel) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_SetTmpDh(config, NULL) == HITLS_NULL_INPUT);
if (SECURITY_GetSecbits(securityLevel) <= securityBits) {
ASSERT_TRUE(HITLS_CFG_SetTmpDh(config, dhPkey) == HITLS_SUCCESS);
} else {
ASSERT_TRUE(HITLS_CFG_SetTmpDh(config, dhPkey) == HITLS_CRYPT_ERR_DH);
}
EXIT:
if (SECURITY_GetSecbits(securityLevel) > securityBits) {
SAL_CRYPT_FreeDhKey(dhPkey);
}
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
int32_t g_securityBits = 0;
static HITLS_CRYPT_Key *UT_TmpDhCb(HITLS_Ctx *ctx, int32_t isExport, uint32_t keyLen)
{
(void)isExport;
(void)keyLen;
HITLS_CRYPT_Key *dhPkey = NULL;
HITLS_Config *config = &ctx->config.tlsConfig;
dhPkey = HITLS_CRYPT_GenerateDhKeyBySecbits(LIBCTX_FROM_CONFIG(config), ATTRIBUTE_FROM_CONFIG(config), config,
g_securityBits);
return dhPkey;
}
/* @
* @test UT_TLS_CFG_SET_TMPDHCB_API_TC001
* @title Set tmpdhcallback. The link setup status varies according to the security level.
* @precon nan
* @brief
* 1. Set the RSA certificate and algorithm suite.
* 2. Set dh callback and generate dhkey through dhcb.
* 3. Set security level to 2, set tmpdh key to 80 bits, and set up a link.
* 4. Set security level to 2, set tmpdh key to 112 bits, and set up a link.
* 5. Set security level to 1, set tmpdh key to 128 bits, and set up a link.
* 6. Set security level to 2, set tmpdh key to 128 bits, and set up a link.
* @expect
* 1. The setting is successful.
* 2. The setting is successful.
* 3. The link fails to be set up.
* 4. The link is set up successfully.
* 5. The link is set up successfully.
* 6. The link is set up successfully.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_TMPDHCB_API_TC001(int securityBits, int securityLevel)
{
FRAME_Init();
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
uint16_t pfsCipherSuites[] = {HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256};
HITLS_Config *clientConfig = HITLS_CFG_NewTLS12Config();
HITLS_Config *serverConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(clientConfig != NULL);
ASSERT_TRUE(serverConfig != NULL);
ASSERT_TRUE(HiTLS_X509_LoadCertAndKey(clientConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA256_EE_PATH3, NULL,
RSA_SHA256_PRIV_PATH3, NULL) == HITLS_SUCCESS);
ASSERT_TRUE(HiTLS_X509_LoadCertAndKey(serverConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA256_EE_PATH3, NULL,
RSA_SHA256_PRIV_PATH3, NULL) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_SetCipherSuites(clientConfig, pfsCipherSuites, sizeof(pfsCipherSuites) / sizeof(uint16_t)) ==
HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_SetCipherSuites(serverConfig, pfsCipherSuites, sizeof(pfsCipherSuites) / sizeof(uint16_t)) ==
HITLS_SUCCESS);
HITLS_CFG_SetDhAutoSupport(serverConfig, false);
g_securityBits = securityBits;
ASSERT_TRUE(HITLS_CFG_SetTmpDhCb(serverConfig, UT_TmpDhCb) == HITLS_SUCCESS);
FRAME_CertInfo certInfo = {0, 0, 0, 0, 0, 0};
client = FRAME_CreateLinkWithCert(clientConfig, BSL_UIO_TCP, &certInfo);
server = FRAME_CreateLinkWithCert(serverConfig, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_TRUE(HITLS_SetSecurityLevel(server->ssl, securityLevel) == HITLS_SUCCESS);
if (SECURITY_GetSecbits(securityLevel) > securityBits) {
ASSERT_EQ(FRAME_CreateConnection(client, server, false, TRY_SEND_SERVER_KEY_EXCHANGE), HITLS_SUCCESS);
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_MSG_HANDLE_ERR_GET_DH_KEY);
} else {
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
}
EXIT:
HITLS_CFG_FreeConfig(serverConfig);
HITLS_CFG_FreeConfig(clientConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_CLIENTHELLOCB_API_TC001
* @title Test the HITLS_CFG_SetClientHelloCb interface.
* @precon nan
* @brief HITLS_CFG_SetClientHelloCb
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and leave callback empty. Expected result 1 is obtained.
* 3. Transfer non-empty configuration information and set callback to a non-empty value. Expected result 2 is obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_CLIENTHELLOCB_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
int32_t cbRetVal = 0;
ASSERT_TRUE(HITLS_CFG_SetClientHelloCb(config, UT_ClientHelloCb, &cbRetVal) == HITLS_NULL_INPUT);
switch (tlsVersion) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
break;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
break;
default:
config = NULL;
break;
}
ASSERT_TRUE(HITLS_CFG_SetClientHelloCb(config, NULL, &cbRetVal) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetClientHelloCb(config, UT_ClientHelloCb, &cbRetVal) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_COOKIEGENERATECB_API_TC001
* @title Test the HITLS_CFG_SetCookieGenCb interface.
* @precon nan
* @brief HITLS_CFG_SetCookieGenCb
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and leave callback empty. Expected result 1 is obtained.
* 3. Transfer non-empty configuration information and set callback to a non-empty value. Expected result 2 is obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_COOKIEGENERATECB_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
ASSERT_TRUE(HITLS_CFG_SetCookieGenCb(config, UT_CookieGenerateCb) == HITLS_NULL_INPUT);
config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(HITLS_CFG_SetCookieGenCb(config, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetCookieGenCb(config, UT_CookieGenerateCb) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_COOKIEVERIFYCB_API_TC001
* @title Test the HITLS_CFG_SetCookieVerifyCb interface.
* @precon nan
* @brief HITLS_CFG_SetCookieVerifyCb
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and leave callback empty. Expected result 1 is obtained.
* 3. Transfer non-empty configuration information and set callback to a non-empty value. Expected result 2 is obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_COOKIEVERIFYCB_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
ASSERT_TRUE(HITLS_CFG_SetCookieVerifyCb(config, UT_CookieVerifyCb) == HITLS_NULL_INPUT);
config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(HITLS_CFG_SetCookieVerifyCb(config, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetCookieVerifyCb(config, UT_CookieVerifyCb) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_VERSION_API_TC001
* @title Test the HITLS_CFG_SetVersion, HITLS_CFG_GetMinVersion, and HITLS_CFG_GetMaxVersion interfaces.
* @precon nan
* @brief HITLS_CFG_SetVersion
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information, set minVersion to 0, and set maxVersion to a value other than 0.
* Expected result 2 is obtained.
* 3. Transfer non-empty configuration information, set minVersion to 0, and set maxVersion to 0. Expected result 3 is
* obtained.
* 4. Transfer non-empty configuration information, set minVersion to 0, and set maxVersion to 0. Expected result 4 is
* obtained.
* 5. Transfer non-empty configuration information, and set both minVersion and maxVersion to 0. Expected result 5 is
* obtained.
* 5. Transfer non-empty configuration information, set minVersion to dtls, and set maxVersion to dtls. Expected result 5
* is obtained.
* 6. Transfer non-empty configuration information, set minVersion to TLCP, and set maxVersion to TLCP. Expected result 5
* is obtained.
* HITLS_CFG_GetMinVersion
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer an empty MinVersion pointer. Expected result 1 is obtained.
* 3. Transfer the non-null configuration information and the MinVersion pointer is not null. Expected result 5 is
* obtained.
* HITLS_CFG_GetMaxVersion
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Pass an empty MaxVersion pointer. Expected result 1 is obtained.
* 3. Transfer non-null configuration information and ensure that the MaxVersion pointer is not null. Expected result 5
* is obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_SUCCES and minVersion is HITLS_VERSION_SSL30.
* 3. Returns HITLS_SUCCES and maxVersion is HITLS_VERSION_TLS13.
* 4. The HITLS_SUCCES table is returned, and the version value is 0, which is cleared.
* 5. Returns HITLS_SUCCES with minVersion and maxVersion set to the configured values.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_VERSION_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
HITLS_Config *dtlsConfig = NULL;
HITLS_Config *tlcpConfig = NULL;
uint16_t minVersion = 0;
uint16_t maxVersion = 0;
ASSERT_TRUE(HITLS_CFG_SetVersion(config, minVersion, maxVersion) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetMinVersion(config, &minVersion) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetMaxVersion(config, &maxVersion) == HITLS_NULL_INPUT);
config = HITLS_CFG_NewTLSConfig();
dtlsConfig = HITLS_CFG_NewDTLSConfig();
tlcpConfig = HITLS_CFG_NewTLCPConfig();
ASSERT_TRUE(HITLS_CFG_GetMinVersion(config, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetMaxVersion(config, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetVersion(config, 0, 0) == HITLS_SUCCESS);
ASSERT_TRUE(config->version == TLS_VERSION_MASK);
ASSERT_TRUE(HITLS_CFG_SetVersion(config, HITLS_VERSION_TLS12, HITLS_VERSION_TLS13) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMinVersion(config, &minVersion) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMaxVersion(config, &maxVersion) == HITLS_SUCCESS);
ASSERT_TRUE(minVersion == HITLS_VERSION_TLS12 && maxVersion == HITLS_VERSION_TLS13);
ASSERT_TRUE(HITLS_CFG_SetVersion(config, 0, HITLS_VERSION_TLS13) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMinVersion(config, &minVersion) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMaxVersion(config, &maxVersion) == HITLS_SUCCESS);
ASSERT_TRUE(minVersion == HITLS_VERSION_TLS12 && maxVersion == HITLS_VERSION_TLS13);
ASSERT_TRUE(HITLS_CFG_SetVersion(config, HITLS_VERSION_TLS12, 0) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMinVersion(config, &minVersion) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMaxVersion(config, &maxVersion) == HITLS_SUCCESS);
ASSERT_TRUE(minVersion == HITLS_VERSION_TLS12 && maxVersion == HITLS_VERSION_TLS13);
ASSERT_TRUE(HITLS_CFG_SetVersion(dtlsConfig, HITLS_VERSION_DTLS12, HITLS_VERSION_DTLS12) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMinVersion(dtlsConfig, &minVersion) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMaxVersion(dtlsConfig, &maxVersion) == HITLS_SUCCESS);
ASSERT_TRUE(minVersion == HITLS_VERSION_DTLS12 && maxVersion == HITLS_VERSION_DTLS12);
ASSERT_TRUE(HITLS_CFG_SetVersion(tlcpConfig, HITLS_VERSION_TLCP_DTLCP11, HITLS_VERSION_TLCP_DTLCP11) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMinVersion(tlcpConfig, &minVersion) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMaxVersion(tlcpConfig, &maxVersion) == HITLS_SUCCESS);
ASSERT_TRUE(minVersion == HITLS_VERSION_TLCP_DTLCP11 && maxVersion == HITLS_VERSION_TLCP_DTLCP11);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_CFG_FreeConfig(dtlsConfig);
HITLS_CFG_FreeConfig(tlcpConfig);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_GET_HASHID_API_TC001
* @title Test the HITLS_CFG_GetHashId interface.
* @precon nan
* @brief
* 1. Input an empty cipher suite. Expected result 1 is obtained.
* 2. Transfer an empty hashId. Expected result 1 is obtained.
* 3. Import the HITLS_RSA_WITH_AES_128_CBC_SHA cipher suite and set hashAlg to HITLS_HASH_BUTT. Expected result 2 is
* obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCESS is returned and HashId is HITLS_HASH_SHA1.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_HASHID_API_TC001(void)
{
const HITLS_Cipher *cipher = NULL;
HITLS_HashAlgo hashId = HITLS_HASH_BUTT;
ASSERT_TRUE(HITLS_CFG_GetHashId(cipher, &hashId) == HITLS_NULL_INPUT);
const uint16_t cipherID = HITLS_RSA_WITH_AES_128_CBC_SHA;
cipher = HITLS_CFG_GetCipherByID(cipherID);
ASSERT_TRUE(HITLS_CFG_GetHashId(cipher, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetHashId(cipher, &hashId) == HITLS_SUCCESS);
ASSERT_TRUE(hashId == HITLS_HASH_SHA1);
EXIT:
return;
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_GET_MACID_API_TC001
* @title Test the HITLS_CFG_GetMacId interface.
* @precon nan
* @brief
* 1. Input an empty cipher suite. Expected result 1 is obtained.
* 2. Input an empty macAlg. Expected result 1
* 3. Input the HITLS_RSA_WITH_AES_128_CBC_SHA cipher suite and set macAlg to HITLS_MAC_BUTT. Expected result 2 is
* obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_SUCCESS and macAlg is HITLS_MAC_1.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_MACID_API_TC001(void)
{
const HITLS_Cipher *cipher = NULL;
HITLS_MacAlgo macAlg = HITLS_MAC_BUTT;
ASSERT_TRUE(HITLS_CFG_GetMacId(cipher, &macAlg) == HITLS_NULL_INPUT);
const uint16_t cipherID = HITLS_RSA_WITH_AES_128_CBC_SHA;
cipher = HITLS_CFG_GetCipherByID(cipherID);
ASSERT_TRUE(HITLS_CFG_GetMacId(cipher, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetMacId(cipher, &macAlg) == HITLS_SUCCESS);
ASSERT_TRUE(macAlg == HITLS_MAC_1);
EXIT:
return;
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_GET_KEYEXCHID_API_TC001
* @title Test the HITLS_CFG_GetKeyExchId interface.
* @precon nan
* @brief
* 1. Input an empty cipher suite. Expected result 1 is obtained.
* 2. Input null kxAlg. Expected result 1
* 3. Input the HITLS_RSA_WITH_AES_128_CBC_SHA cipher suite and set kxAlg to HITLS_KEY_EXCH_BUTT. Expected result 2 is
* obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_SUCCESS and kxAlg is HITLS_KEY_EXCH_RSA.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_KEYEXCHID_API_TC001(void)
{
const HITLS_Cipher *cipher = NULL;
HITLS_KeyExchAlgo kxAlg = HITLS_KEY_EXCH_BUTT;
ASSERT_TRUE(HITLS_CFG_GetKeyExchId(cipher, &kxAlg) == HITLS_NULL_INPUT);
const uint16_t cipherID = HITLS_RSA_WITH_AES_128_CBC_SHA;
cipher = HITLS_CFG_GetCipherByID(cipherID);
ASSERT_TRUE(HITLS_CFG_GetKeyExchId(cipher, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetKeyExchId(cipher, &kxAlg) == HITLS_SUCCESS);
ASSERT_TRUE(kxAlg == HITLS_KEY_EXCH_RSA);
EXIT:
return;
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_GET_CIPHERSUITESTDNAME_API_TC001
* @title Test the HITLS_CFG_GetCipherSuiteStdName interface.
* @precon nan
* @brief
* 1. Input an empty cipher suite. Expected result 1 is obtained.
* 2.Import the HITLS_RSA_WITH_AES_128_CBC_SHA cipher suite. Expected result 2 is obtained.
* @expect
* 1. Return "(NONE)"
* 2. Return "TLS_RSA_WITH_AES_128_CBC_SHA256"
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_CIPHERSUITESTDNAME_API_TC001(void)
{
const HITLS_Cipher *cipher = NULL;
ASSERT_TRUE(strcmp((char *)HITLS_CFG_GetCipherSuiteStdName(cipher),"(NONE)") == 0);
const uint16_t cipherID = HITLS_RSA_WITH_AES_128_CBC_SHA;
cipher = HITLS_CFG_GetCipherByID(cipherID);
ASSERT_TRUE(strcmp((char *)HITLS_CFG_GetCipherSuiteStdName(cipher),"TLS_RSA_WITH_AES_128_CBC_SHA") == 0);
EXIT:
return;
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_GET_DESCRIPTION_API_TC001
* @title Test the HITLS_CFG_GetDescription interface.
* @precon nan
* @brief
* 1. Input an empty cipher suite. Expected result 1 is obtained.
* 2. Input an empty buff. Expected result 1 is obtained.
* 3. Transfer a buff whose length is less than the length of CIPHERSUITE_DESCRIPTION_MAXLEN. Expected result 1 is
* obtained.
* 4. Transfer the abnormal algorithm name cipher suite. Expected result 2 is obtained.
* 5. Import the HITLS_RSA_WITH_AES_128_CBC_SHA cipher suite whose buff size is DEFAULT_DESCRIPTION_LEN. Expected result
* 3 is obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_CONFIG_INVALID_LENGTH.
* 3. Returns HITLS_SUCCESS, and buff is Description.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_DESCRIPTION_API_TC001(void)
{
const HITLS_Cipher *cipher = NULL;
char buff[DEFAULT_DESCRIPTION_LEN] = {0};
ASSERT_TRUE(HITLS_CFG_GetDescription(cipher, (uint8_t *)buff, sizeof(buff)) == HITLS_NULL_INPUT);
const uint16_t cipherID = HITLS_RSA_WITH_AES_128_CBC_SHA;
cipher = HITLS_CFG_GetCipherByID(cipherID);
ASSERT_TRUE(HITLS_CFG_GetDescription(cipher, NULL, sizeof(buff)) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetDescription(cipher, (uint8_t *)buff, 0) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetDescription(cipher, (uint8_t *)buff, sizeof(buff)) == HITLS_SUCCESS);
HITLS_Cipher *newCipher = (HITLS_Cipher *)malloc(sizeof(HITLS_Cipher));
memcpy(newCipher, cipher, sizeof(HITLS_Cipher));
newCipher->name =
"************************************************************************************************************";
ASSERT_TRUE(HITLS_CFG_GetDescription(newCipher, (uint8_t *)buff, sizeof(buff)) == HITLS_CONFIG_INVALID_LENGTH);
EXIT:
free(newCipher);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_CIPHER_ISAEAD_API_TC001
* @title Test the HITLS_CIPHER_IsAead interface.
* @precon nan
* @brief
* 1. Input an empty cipher suite. Expected result 1 is obtained.
* 2. Import the HITLS_RSA_WITH_AES_128_GCM_SHA256 cipher suite. Expected result 2 is obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_SUCCESS and isAead is true.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_CIPHER_ISAEAD_API_TC001(void)
{
const HITLS_Cipher *cipher = NULL;
uint8_t isAead = false;
ASSERT_TRUE(HITLS_CIPHER_IsAead(cipher, &isAead) == HITLS_NULL_INPUT);
const uint16_t cipherID = HITLS_RSA_WITH_AES_128_GCM_SHA256;
cipher = HITLS_CFG_GetCipherByID(cipherID);
ASSERT_TRUE(HITLS_CIPHER_IsAead(cipher, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CIPHER_IsAead(cipher, &isAead) == HITLS_SUCCESS);
ASSERT_TRUE(isAead == true);
EXIT:
return;
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_VERSIONSUPPORT_API_TC001
* @spec -
* @title Test the HITLS_CFG_SetVersionSupport and HITLS_CFG_GetVersionSupport interfaces.
* @precon nan
* @brief HITLS_CFG_SetVersionSupport
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and set version to an invalid value. Expected result 2 is obtained.
* 3. Transfer non-empty configuration information and set version to a valid value. Expected result 3 is obtained.
* HITLS_CFG_GetVersionSupport
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Pass the null version pointer. Expected result 1 is obtained.
* 3. Transfer non-null configuration information and ensure that the version pointer is not null. Expected result 4 is
* obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned, and invalid values in config are filtered out.
* 3. HITLS_SUCCES is returned and config is the expected value.
* 4. The HITLS_SUCCES parameter is returned, and the version parameter is set to the value recorded in the config file.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_VERSIONSUPPORT_API_TC001()
{
FRAME_Init();
HITLS_Config *config = NULL;
uint32_t version = 0;
ASSERT_TRUE(HITLS_CFG_SetVersionSupport(config, version) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetVersionSupport(config, &version) == HITLS_NULL_INPUT);
config = HITLS_CFG_NewTLSConfig();
ASSERT_TRUE(HITLS_CFG_GetVersionSupport(config, NULL) == HITLS_NULL_INPUT);
version = (TLS13_VERSION_BIT << 1) | TLS13_VERSION_BIT | TLS12_VERSION_BIT;
ASSERT_TRUE(HITLS_CFG_SetVersionSupport(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS13);
version = TLS13_VERSION_BIT | TLS12_VERSION_BIT;
ASSERT_TRUE(HITLS_CFG_SetVersionSupport(config, version) == HITLS_SUCCESS);
ASSERT_TRUE(config->minVersion == HITLS_VERSION_TLS12 && config->maxVersion == HITLS_VERSION_TLS13);
uint32_t getversion = 0;
ASSERT_TRUE(HITLS_CFG_GetVersionSupport(config, &getversion) == HITLS_SUCCESS);
ASSERT_TRUE(getversion == config->version);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_QUIETSHUTDOWN_API_TC001
* @title Test the HITLS_CFG_SetQuietShutdown and HITLS_CFG_GetQuietShutdown interfaces.
* @precon nan
* @brief HITLS_CFG_SetQuietShutdown
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and set mode to an invalid value. Expected result 2 is obtained.
* 3. Transfer non-empty configuration information and set mode to a valid value. Expected result 3 is obtained.
* HITLS_CFG_GetQuietShutdown
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer a null mode pointer. Expected result 1 is obtained.
* 3. Transfer non-null configuration information and ensure that the mode pointer is not null. Expected result 3 is
* obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_CONFIG_INVALID_SET
* 3. Returns HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_QUIETSHUTDOWN_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
int32_t mode = 0;
ASSERT_TRUE(HITLS_CFG_SetQuietShutdown(config, mode) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetQuietShutdown(config, &mode) == HITLS_NULL_INPUT);
switch (tlsVersion) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
break;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
break;
default:
config = NULL;
break;
}
ASSERT_TRUE(HITLS_CFG_GetQuietShutdown(config, NULL) == HITLS_NULL_INPUT);
mode = 1;
ASSERT_TRUE(HITLS_CFG_SetQuietShutdown(config, mode) == HITLS_SUCCESS);
mode = 2;
ASSERT_TRUE(HITLS_CFG_SetQuietShutdown(config, mode) == HITLS_CONFIG_INVALID_SET);
int32_t getMode = -1;
ASSERT_TRUE(HITLS_CFG_GetQuietShutdown(config, &getMode) == HITLS_SUCCESS);
ASSERT_TRUE(getMode == config->isQuietShutdown);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_CIPHERSERVERPREFERENCE_API_TC001
* @title Test the HITLS_CFG_SetCipherServerPreference and HITLS_CFG_GetCipherServerPreference interfaces.
* @precon nan
* @brief HITLS_CFG_SetCipherServerPreference
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and set isSupport to an invalid value. Expected result 2 is obtained.
* 3. Transfer a non-empty configuration information and set isSupport to a valid value. Expected result 3 is obtained.
* HITLS_CFG_GetCipherServerPreference
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer an empty isSupport pointer. Expected result 1 is obtained.
* 3. Transfer the non-null configuration information and the isSupport pointer is not null. Expected result 3 is
* obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned and config->isSupportServerPreference is set to true.
* 3. Returns HITLS_SUCCES, and config->isSupportServerPreference is true or false.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_CIPHERSERVERPREFERENCE_API_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
bool isSupport = false;
bool getIsSupport = false;
ASSERT_TRUE(HITLS_CFG_SetCipherServerPreference(config, isSupport) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetCipherServerPreference(config, &getIsSupport) == HITLS_NULL_INPUT);
switch (tlsVersion) {
case HITLS_VERSION_TLS12:
config = HITLS_CFG_NewTLS12Config();
break;
case HITLS_VERSION_TLS13:
config = HITLS_CFG_NewTLS13Config();
break;
default:
config = NULL;
break;
}
ASSERT_TRUE(HITLS_CFG_GetCipherServerPreference(config, NULL) == HITLS_NULL_INPUT);
isSupport = true;
ASSERT_TRUE(HITLS_CFG_SetCipherServerPreference(config, isSupport) == HITLS_SUCCESS);
isSupport = 2;
ASSERT_TRUE(HITLS_CFG_SetCipherServerPreference(config, isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(config->isSupportServerPreference = true);
isSupport = false;
ASSERT_TRUE(HITLS_CFG_SetCipherServerPreference(config, isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetCipherServerPreference(config, &getIsSupport) == HITLS_SUCCESS);
ASSERT_TRUE(getIsSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_HELLO_VERIFY_REQ_API_TC001
* @title Test the HITLS_CFG_SetDtlsCookieExchangeSupport and HITLS_CFG_GetDtlsCookieExchangeSupport interfaces.
* @precon nan
* @brief HITLS_CFG_SetDtlsCookieExchangeSupport
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer non-empty configuration information and set isSupport to an invalid value. Expected result 2 is obtained.
* 3. Transfer a non-empty configuration information and set isSupport to a valid value. Expected result 3 is obtained.
* HITLS_CFG_GetDtlsCookieExchangeSupport
* 1. Import empty configuration information. Expected result 1 is obtained.
* 2. Transfer an empty isSupport pointer. Expected result 1 is obtained.
* 3. Transfer the non-null configuration information and the isSupport pointer is not null. Expected result 3 is
* obtained.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. HITLS_SUCCES is returned and config->isSupportDtlsCookieExchange is set to true.
* 3. Returns HITLS_SUCCES, and config->isSupportDtlsCookieExchange is true or false.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_HELLO_VERIFY_REQ_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = NULL;
bool isSupport = false;
bool getIsSupport = false;
ASSERT_TRUE(HITLS_CFG_SetDtlsCookieExchangeSupport(config, isSupport) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetDtlsCookieExchangeSupport(config, &getIsSupport) == HITLS_NULL_INPUT);
config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(HITLS_CFG_GetDtlsCookieExchangeSupport(config, NULL) == HITLS_NULL_INPUT);
isSupport = true;
ASSERT_TRUE(HITLS_CFG_SetDtlsCookieExchangeSupport(config, isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(config->isSupportDtlsCookieExchange = true);
isSupport = false;
ASSERT_TRUE(HITLS_CFG_SetDtlsCookieExchangeSupport(config, isSupport) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetDtlsCookieExchangeSupport(config, &getIsSupport) == HITLS_SUCCESS);
ASSERT_TRUE(getIsSupport == false);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_RENEGOTIATIONSUPPORT_FUNC_TC001
* @title Test the function of supporting the renegotiation function by setting the HITLS_CFG_SetRenegotiationSupport and
* obtaining the function of supporting the renegotiation function by the HITLS_CFG_GetRenegotiationSupport.
* @precon nan
* @brief 1. Call HITLS_CFG_SetRenegotiationSupport to disable renegotiation. Expected result 1 is obtained.
* 2. Invoke the HITLS_CFG_GetRenegotiationSupport interface to obtain the configured value. (Expected result
* 2)
* 3. Invoke the HITLS_SetRenegotiationSupport interface to support renegotiation. Expected result 3 is
* obtained.
* 4. Invoke the HITLS_GetRenegotiationSupport interface to obtain the configured value. Expected result 4 is
* obtained.
* 5. Establish a connection. and check whether the value of isSecureRenegotiation in the
* negotiation information is true. Expected result 5 is obtained.
* 6. Perform renegotiation. Expected result 6 is obtained.
* @expect 1. Setting succeeded.
* 2. The interface returns false.
* 3. The setting is successful.
* 4. The interface returns true.
* 5. The value of isSecureRenegotiation is true.
* 6. The renegotiation succeeds.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_RENEGOTIATIONSUPPORT_FUNC_TC001()
{
FRAME_Init();
FRAME_LinkObj *clientRes;
FRAME_LinkObj *serverRes;
HITLS_Config *config = NULL;
uint8_t supportrenegotiation;
config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
HITLS_CFG_SetRenegotiationSupport(config, false);
HITLS_CFG_GetRenegotiationSupport(config, &supportrenegotiation);
ASSERT_TRUE(supportrenegotiation == false);
clientRes = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(clientRes != NULL);
serverRes = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(serverRes != NULL);
HITLS_SetRenegotiationSupport(clientRes->ssl, true);
HITLS_SetRenegotiationSupport(serverRes->ssl, true);
HITLS_GetRenegotiationSupport(clientRes->ssl, &supportrenegotiation);
ASSERT_TRUE(supportrenegotiation == true);
FRAME_CreateConnection(clientRes, serverRes, true, HS_STATE_BUTT);
ASSERT_TRUE(clientRes->ssl->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(serverRes->ssl->state == CM_STATE_TRANSPORTING);
ASSERT_TRUE(HITLS_Renegotiate(serverRes->ssl) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(clientRes->ssl) == HITLS_SUCCESS);
ASSERT_TRUE(FRAME_CreateRenegotiationState(clientRes, serverRes, true, HS_STATE_BUTT) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(clientRes);
FRAME_FreeLink(serverRes);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_ECPOINTFORMATS_FUNC_TC001
* @title Set the normal dot format value.
* @precon nan
* @brief 1. Set pointFormats to HITLS_POINT_FORMAT_UNCOMPRESSED and invoke the HITLS_CFG_SetEcPointFormats interface.
* Expected result 1 is obtained.
* 2. Set pointFormats to HITLS_POINT_FORMAT_BUTT and invoke the HITLS_CFG_SetEcPointFormats interface.
* (Expected result 2)
* 3. Use config to generate ctx, due to the result 3
* 4. Set pointFormats to HITLS_POINT_FORMAT_UNCOMPRESSED again and generate ctx again. Expected result 4 is
* obtained. Set pointFormats to HITLS_POINT_FORMAT_UNCOMPRESSED and invoke the HITLS_SetEcPointFormats
* interface. (Expected result 2)
* 5. Set pointFormats to HITLS_POINT_FORMAT_UNCOMPRESSED and invoke the HITLS_SetEcPointFormats interface.
* Expected result 2 is obtained.
* @expect 1. Interface return value, HITLS_SUCCESS
* 2. Interface return value: HITLS_SUCCESS
* 3. Failed to generate the file.
* 4. The file is generated successfully.
* 5. The setting is successful.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_ECPOINTFORMATS_FUNC_TC001(int version)
{
FRAME_Init();
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
HITLS_Config *Config = NULL;
HITLS_Ctx *ctx = NULL;
Config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(Config != NULL);
const uint8_t pointFormats[] = {HITLS_POINT_FORMAT_UNCOMPRESSED};
uint32_t pointFormatsSize = sizeof(pointFormats) / sizeof(uint8_t);
ASSERT_TRUE(HITLS_CFG_SetEcPointFormats(Config, pointFormats, pointFormatsSize) == HITLS_SUCCESS);
const uint8_t pointFormats2[] = {HITLS_POINT_FORMAT_BUTT};
uint32_t pointFormatsSize2 = sizeof(pointFormats2) / sizeof(uint8_t);
ASSERT_TRUE(HITLS_CFG_SetEcPointFormats(Config, pointFormats2, pointFormatsSize2) == HITLS_SUCCESS);
ctx = HITLS_New(Config);
if(version == TLS1_2){
ASSERT_TRUE(ctx == NULL);
}
HITLS_Free(ctx);
ASSERT_TRUE(HITLS_CFG_SetEcPointFormats(Config, pointFormats, pointFormatsSize) == HITLS_SUCCESS);
ctx = HITLS_New(Config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_SetEcPointFormats(ctx, pointFormats, pointFormatsSize) == HITLS_SUCCESS);
client = FRAME_CreateLink(Config, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(Config, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(Config);
HITLS_Free(ctx);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
typedef struct {
HITLS_Config *config;
FRAME_LinkObj *client;
FRAME_LinkObj *server;
HITLS_HandshakeState state;
bool isClient;
bool isSupportExtendMasterSecret;
bool isSupportClientVerify;
bool isSupportNoClientCert;
bool isSupportRenegotiation;
bool isSupportSessionTicket;
bool needStopBeforeRecvCCS;
} HandshakeTestInfo;
/** @
* @test UT_TLS_CFG_SET_GROUPS_FUNC_TC001
* @title Sets the elliptic curve that does not exist.
* @precon nan
* @brief 1. Set group to 0x0001 and invoke the HITLS_CFG_SetGroups interface. Expected result 1 is obtained.
* 2. Establish a connection. Check whether the group value in the client hello message sent by the client is
* 0x0001.Expected result 2 is obtained.
* 3. Establish a connection and check whether the connection is successfully established. (Expected result 3)
* @expect 1. Interface HITLS_SUCCESS
* 2. The value of group in the client hello message is 0x0001.
* 3. connection establishment fails.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GROUPS_FUNC_TC001(int version)
{
FRAME_Init();
HandshakeTestInfo testInfo = {0};
uint16_t group[] = {ERROR_HITLS_GROUP};
uint32_t grouplength = sizeof(group) / sizeof(uint16_t);
testInfo.isClient = false;
testInfo.config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(testInfo.config != NULL);
ASSERT_TRUE(HITLS_CFG_SetGroups(testInfo.config, group, grouplength) == HITLS_SUCCESS);
if (version == TLS1_2) {
uint16_t cipherSuite[] = {HITLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256};
HITLS_CFG_SetCipherSuites(testInfo.config, cipherSuite, sizeof(cipherSuite) / sizeof(uint16_t));
}
FRAME_CertInfo certInfo = {
"rsa_sha/ca-3072.der:rsa_sha/inter-3072.der",
"rsa_sha/inter-3072.der",
"rsa_sha/end-sha256.der",
NULL,
"rsa_sha/end-sha256.key.der",
NULL,
};
testInfo.client = FRAME_CreateLinkWithCert(testInfo.config, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(testInfo.client != NULL);
testInfo.server = FRAME_CreateLinkWithCert(testInfo.config, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(testInfo.server != NULL);
if (version == TLS1_2) {
ASSERT_EQ(FRAME_CreateConnection(testInfo.client, testInfo.server, testInfo.isClient, HS_STATE_BUTT),
HITLS_MSG_HANDLE_CIPHER_SUITE_ERR);
} else {
ASSERT_EQ(FRAME_CreateConnection(testInfo.client, testInfo.server, testInfo.isClient, HS_STATE_BUTT),
HITLS_MSG_HANDLE_ILLEGAL_SELECTED_GROUP);
}
EXIT:
HITLS_CFG_FreeConfig(testInfo.config);
FRAME_FreeLink(testInfo.client);
FRAME_FreeLink(testInfo.server);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_SIGNATURE_FUNC_TC001
* @title Set a nonexistent signature algorithm.
* @precon nan
* @brief
* 1. Set Signature to 0xffff and call the HITLS_CFG_SetSignature interface. (Expected result 1)
* @expect
* 1. Interface return value: HITLS_CONFIG_INVALID_LENGTH
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_SIGNATURE_FUNC_TC001(int version)
{
FRAME_Init();
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
HITLS_Config *config = NULL;
config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(config != NULL);
uint16_t signAlgs[] = {ERROR_HITLS_SIGNATURE};
ASSERT_TRUE(HITLS_CFG_SetSignature(config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t)) == HITLS_SUCCESS);
client = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(client == NULL);
server = FRAME_CreateLink(config, BSL_UIO_TCP);
ASSERT_TRUE(server == NULL);
EXIT:
HITLS_CFG_FreeConfig(config);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
void ExampleInfoCallback(const HITLS_Ctx *ctx, int32_t eventType, int32_t value)
{
(void)ctx;
(void)eventType;
(void)value;
}
#define MSG_CB_PRINT_LEN 500
void msg_callback(int32_t writePoint, int32_t tlsVersion, int32_t contentType, const void *msg,
uint32_t msgLen, HITLS_Ctx *ctx, void *arg)
{
(void)writePoint;
(void)tlsVersion;
(void)contentType;
(void)msg;
(void)msgLen;
(void)ctx;
(void)arg;
}
/* @
* @test UT_TLS_CFG_InfoCb_API_TC001
* @title InfoCb Interface Parameter Test
* @precon nan
* @brief
1. Use the HITLS_CFG_GetInfoCb without HITLS_CFG_SetInfoCb. Expected result 1 is obtained.
2. Use the HITLS_CFG_SetInfoCb interface to set callback. Expected result 2
3. Use the HITLS_CFG_GetInfoCb . Expected result 3
4. Use the HITLS_CFG_GetInfoCb with the parameter is NULL . Expected result 4
* @expect
1. Return the NULL.
2. Return the HITLS_SUCCESS
3. Return value is not NULL.
4. Return the NULL.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_InfoCb_API_TC001(void)
{
FRAME_Init();
HITLS_Config *config = HITLS_CFG_NewDTLS12Config();
ASSERT_TRUE(config != NULL);
HITLS_InfoCb infoCallBack = HITLS_CFG_GetInfoCb(config);
ASSERT_TRUE(infoCallBack == NULL);
int32_t ret = HITLS_CFG_SetInfoCb(config, ExampleInfoCallback);
ASSERT_TRUE(ret == HITLS_SUCCESS);
infoCallBack = HITLS_CFG_GetInfoCb(config);
ASSERT_TRUE(infoCallBack != NULL);
infoCallBack = HITLS_CFG_GetInfoCb(NULL);
ASSERT_TRUE(infoCallBack == NULL);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_SetMsgCb_API_TC001
* @title HITLS_CFG_SetMsgCb Interface Parameter Test
* @precon nan
* @brief
1. Set config to NULL. Expected result 1 is obtained.
2. Invoke the HITLS_CFG_SetMsgCb interface to set callback. (Expected result 2)
* @expect
1. Return the HITLS_NULL_INPUT message.
2. Return the HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SetMsgCb_API_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
ASSERT_EQ(HITLS_CFG_SetMsgCb(NULL, msg_callback), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_CFG_SetMsgCb(tlsConfig, msg_callback), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_SetMsgCbArg_API_TC001
* @title HITLS_CFG_SetMsgCbArg Interface Parameter Test
* @precon nan
* @brief 1. Set config to NULL. Expected result 1 is obtained.
2. Use the HITLS_CFG_SetMsgCbArg interface to set Arg. Expected result 2 is obtained.
* @expect 1. The HITLS_NULL_INPUT message is returned.
2. Return the HITLS_SUCCESS
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SetMsgCbArg_API_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig;
tlsConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
ASSERT_EQ(HITLS_CFG_SetMsgCbArg(NULL, msg_callback), HITLS_NULL_INPUT);
ASSERT_EQ(HITLS_CFG_SetMsgCbArg(tlsConfig, msg_callback), HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_SETTMPDH_FUNC_TC001
* @title Set tmpdhkey. The link setup status varies according to the security level.
* @precon nan
* @brief
* 1. Set the RSA certificate and algorithm suite.
* 2. Set the dh key to not follow the certificate, and set the tmpdh key with 80 security bits.
* 3. Set the security level to 0 and set up a link.
* 4. Set the security level to 2 and set up a link.
* @expect
* 1. The setting is successful.
* 2. The setting is successful.
* 3. The link is set up successfully.
* 4. The link fails to be set up.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SETTMPDH_FUNC_TC001(int level)
{
(void)level;
FRAME_Init();
HITLS_Config *clientConfig = NULL;
HITLS_Config *serverConfig = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
HITLS_CRYPT_Key *key = NULL;
uint16_t pfsCipherSuites[] = {HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256};
clientConfig = HITLS_CFG_NewTLS12Config();
serverConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(clientConfig != NULL);
ASSERT_TRUE(serverConfig != NULL);
ASSERT_TRUE(HiTLS_X509_LoadCertAndKey(clientConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH,
RSA_SHA256_EE_PATH3, NULL, RSA_SHA256_PRIV_PATH3,NULL) == HITLS_SUCCESS);
ASSERT_TRUE(HiTLS_X509_LoadCertAndKey(serverConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH,
RSA_SHA256_EE_PATH3, NULL, RSA_SHA256_PRIV_PATH3,NULL) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_SetCipherSuites(clientConfig, pfsCipherSuites, sizeof(pfsCipherSuites) / sizeof(uint16_t)) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_SetCipherSuites(serverConfig, pfsCipherSuites, sizeof(pfsCipherSuites) / sizeof(uint16_t)) == HITLS_SUCCESS);
HITLS_CFG_SetSecurityLevel(serverConfig, level);
HITLS_CFG_SetSecurityLevel(clientConfig, level);
HITLS_CFG_SetDhAutoSupport(serverConfig, false);
int32_t secBits = 80;
key = HITLS_CRYPT_GenerateDhKeyBySecbits(LIBCTX_FROM_CONFIG(serverConfig), ATTRIBUTE_FROM_CONFIG(serverConfig),
serverConfig, secBits);
HITLS_CFG_SetTmpDh(serverConfig, key);
FRAME_CertInfo certInfo = {0, 0, 0, 0, 0, 0};
client = FRAME_CreateLinkWithCert(clientConfig, BSL_UIO_TCP, &certInfo);
server = FRAME_CreateLinkWithCert(serverConfig, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
if (level > 1) {
ASSERT_EQ(FRAME_CreateConnection(client, server, false, TRY_SEND_SERVER_KEY_EXCHANGE), HITLS_SUCCESS);
FRAME_TrasferMsgBetweenLink(server, client);
HITLS_Connect(client->ssl);
ASSERT_EQ(HITLS_Accept(server->ssl) , HITLS_MSG_HANDLE_ERR_GET_DH_KEY);
} else {
ASSERT_EQ(FRAME_CreateConnection(client, server, false, HS_STATE_BUTT), HITLS_SUCCESS);
}
EXIT:
if (SECURITY_GetSecbits(level) > secBits) {
SAL_CRYPT_FreeDhKey(key);
}
HITLS_CFG_FreeConfig(clientConfig);
HITLS_CFG_FreeConfig(serverConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/* @
* @test UT_TLS_CFG_SET_POSTHANDSHAKEAUTHSUPPORT_API_TC001
*
* @title Test the HITLS_SetPostHandshakeAuthSupport interface.
*
* @brief
* 1. The default value of the TLS connection handle isSupportPostHandshakeAuth is fasle. Expected result 1。
* 2. Run the HITLS_SetPostHandshakeAuthSupport command to set a handle. The value of isSupportPostHandshakeAuth is true.
* Expected result 2.
* @expect
* 1. isSupportPostHandshakeAuth is false.
* 2. isSupportPostHandshakeAuth is true.
@*/
/* BEGIN_CASE */
void UT_TLS_CFG_SET_POSTHANDSHAKEAUTHSUPPORT_API_TC001(int tlsVersion)
{
HitlsInit();
HITLS_Config *tlsConfig = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(tlsConfig != NULL);
HITLS_Ctx *ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(ctx->config.tlsConfig.isSupportPostHandshakeAuth == false);
int ret = HITLS_SetPostHandshakeAuthSupport(ctx, true);
ASSERT_TRUE(ret == HITLS_SUCCESS);
ASSERT_TRUE(ctx->config.tlsConfig.isSupportPostHandshakeAuth == true);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_GET_SECURE_RENEGOTIATIONSUPPORET_FUNC_TC001
* @title HITLS_GetSecureRenegotationSupport The client does not support security renegotiation,
* but the server supports security renegotiation. Obtains whether security renegotiation is supported.
* @precon nan
* @brief HITLS_GetSecureRenegotationSupport
* 1. Transfer an empty TLS connection handle. Expected result 1.
* 2. Transfer the non-empty TLS connection handle information and leave isSecureRenegotiation blank. Expected result 1.
* 3. Transfer the non-empty TLS connection handle information. The isSecureRenegotiation parameter is not empty.
* Expected result 2.
* @expect
* 1. Returns HITLS_NULL_INPUT
* 2. Returns HITLS_SUCCES
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_GET_SECURE_RENEGOTIATIONSUPPORET_API_TC001(void)
{
HitlsInit();
HITLS_Config *config = NULL;
HITLS_Ctx *ctx = NULL;
uint8_t isSecureRenegotiation = 0;
ASSERT_TRUE(HITLS_GetSecureRenegotiationSupport(NULL, &isSecureRenegotiation) == HITLS_NULL_INPUT);
config = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config != NULL);
ctx = HITLS_New(config);
ASSERT_TRUE(ctx != NULL);
ASSERT_TRUE(HITLS_GetSecureRenegotiationSupport(ctx, NULL) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetSecureRenegotiationSupport(ctx, &isSecureRenegotiation) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
HITLS_Free(ctx);
}
/* END_CASE */
/** @
* @test UT_TLS_CFG_SET_GET_DHAUTOSUPPORT_FUNC_TC001
* @title Test the HITLS_SetDhAutoSupport and HITLS_CFG_GetDhAutoSupport interfaces.
* @precon nan
* @brief
* 1. Invoke the HITLS_CFG_SetDhAutoSupport interface to set the parameter to false. Expected result 1 is obtained.
* 2. Establish a connection. Expected result 2 is obtained.
* @expect
* 1. The setting is successful.
* 2. connection establishment fails.
@ */
/* BEGIN_CASE */
void UT_TLS_CFG_SET_GET_DHAUTOSUPPORT_FUNC_TC001(void)
{
FRAME_Init();
HITLS_Config *clientConfig = NULL;
HITLS_Config *serverConfig = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
uint16_t pfsCipherSuites[] = {HITLS_DHE_RSA_WITH_AES_128_GCM_SHA256};
clientConfig = HITLS_CFG_NewTLS12Config();
serverConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(clientConfig != NULL);
ASSERT_TRUE(serverConfig != NULL);
ASSERT_TRUE(HiTLS_X509_LoadCertAndKey(clientConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH,
RSA_SHA256_EE_PATH3, NULL, RSA_SHA256_PRIV_PATH3,NULL) == HITLS_SUCCESS);
ASSERT_TRUE(HiTLS_X509_LoadCertAndKey(serverConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH,
RSA_SHA256_EE_PATH3, NULL, RSA_SHA256_PRIV_PATH3,NULL) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_SetCipherSuites(clientConfig, pfsCipherSuites, sizeof(pfsCipherSuites) / sizeof(uint16_t)) ==
HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_SetCipherSuites(serverConfig, pfsCipherSuites, sizeof(pfsCipherSuites) / sizeof(uint16_t)) ==
HITLS_SUCCESS);
HITLS_CFG_SetDhAutoSupport(serverConfig, false);
FRAME_CertInfo certInfo = {0, 0, 0, 0, 0, 0};
client = FRAME_CreateLinkWithCert(clientConfig, BSL_UIO_TCP, &certInfo);
server = FRAME_CreateLinkWithCert(serverConfig, BSL_UIO_TCP, &certInfo);
ASSERT_TRUE(client != NULL);
ASSERT_TRUE(server != NULL);
ASSERT_EQ(FRAME_CreateConnection(client, server, false, TRY_SEND_SERVER_KEY_EXCHANGE), HITLS_SUCCESS);
FRAME_TrasferMsgBetweenLink(server, client);
HITLS_Connect(client->ssl);
ASSERT_EQ(HITLS_Accept(server->ssl), HITLS_MSG_HANDLE_ERR_GET_DH_KEY);
EXIT:
HITLS_CFG_FreeConfig(clientConfig);
HITLS_CFG_FreeConfig(serverConfig);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/interface_tlcp/test_suite_sdv_frame_config_interface.c
|
C
|
unknown
| 60,656
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdio.h>
#include <linux/limits.h>
#include <unistd.h>
#include <stdbool.h>
#include "hitls_error.h"
#include "hitls_cert.h"
#include "hitls.h"
#include "hitls_func.h"
#include "securec.h"
#include "cert_method.h"
#include "cert_mgr.h"
#include "cert_mgr_ctx.h"
#include "frame_tls.h"
#include "frame_link.h"
#include "frame_io.h"
#include "hlt_type.h"
#include "process.h"
#include "hlt.h"
#include "session.h"
#include "bsl_sal.h"
#include "alert.h"
#include "stub_replace.h"
#include "cert_callback.h"
#include "crypt_eal_rand.h"
#include "hitls_crypt_reg.h"
#include "hitls_crypt_init.h"
#include "logger.h"
#include "uio_base.h"
#include "hitls_cert_type.h"
#include "hitls_type.h"
#include "hitls_cert_reg.h"
#include "hitls_config.h"
#include "hitls_cert_init.h"
#include "bsl_log.h"
#include "bsl_err.h"
#include "tls_config.h"
#include "tls.h"
#include "crypt_algid.h"
#include "crypt_errno.h"
#include "bsl_uio.h"
#include "bsl_obj.h"
#include "bsl_errno.h"
#include "hitls_x509_adapt.h"
/* END_HEADER */
#define BUF_MAX_SIZE 4096
int32_t g_uiPort = 18886;
#define DEFAULT_CERT_PATH "../../testcode/testdata/tls/certificate/der/"
#define CERT_PATH_LEN 120
#define SUCCESS (0)
#define ERROR (1)
#define MAX_BUFFER (8192)
#define READ_BUF_LEN_18K (18 * 1024)
#define READ_DATA_18432 18432
#define PASSWDLEN (10)
#define CERT_PATH_BUFFER (100)
#define RSA_ROOT_CERT_DER "rsa_sha/ca-3072.der"
#define RSA_CA_CERT_DER "rsa_sha/inter-3072.der"
#define RSA_EE_CERT_DER "rsa_sha/end-sha1.der"
#define RSA_PRIV_KEY_DER "rsa_sha/end-sha1.key.der"
#define RSA_EE_CERT_DER "rsa_sha/end-sha1.der"
#define RSA_PRIV_KEY_DER "rsa_sha/end-sha1.key.der"
#define RSA_ROOT_CERT2_DER "rsa_sha256/ca.der"
#define RSA_CA_CERT2_DER "rsa_sha256/inter.der"
#define RSA_EE_CERT2_DER "rsa_sha256/server.der"
#define RSA_PRIV_KEY2_DER "rsa_sha256/server.key.der"
#define ECDSA_ROOT_CERT_DER "ecdsa/ca-nist521.der"
#define ECDSA_CA_CERT_DER "ecdsa/inter-nist521.der"
#define ECDSA_EE_CERT_DER "ecdsa/end256-sha256.der"
#define ECDSA_PRIV_KEY_DER "ecdsa/end256-sha256.key.der"
typedef enum {
SHALLOW_COPY = 0,
DEEP_COPY,
} COPY_WAY;
typedef enum {
ECDSA_CERT,
ED25519_CERT,
RSA_CERT,
RSA_CERT_TWO,
RSA_CERT_THREE,
} EE_CERT_TYPE;
typedef enum {
FROM_CONFIG,
FROM_CTX,
FROM_BUFFER_TO_CONFIG,
FROM_BUFFER_TO_CTX
} LOAD_CERT_WAY;
typedef LOAD_CERT_WAY LOAD_KEY_WAY;
int GetCertPathFrom(int eeCertType, char **rootCA, char **ca, char **ee, char **prvKey)
{
switch (eeCertType) {
case RSA_CERT:
*rootCA = RSA_ROOT_CERT_DER;
*ca = RSA_CA_CERT_DER;
*ee = RSA_EE_CERT_DER;
*prvKey = RSA_PRIV_KEY_DER;
return SUCCESS;
case RSA_CERT_TWO:
*rootCA = RSA_ROOT_CERT2_DER;
*ca = RSA_CA_CERT2_DER;
*ee = RSA_EE_CERT2_DER;
*prvKey = RSA_PRIV_KEY2_DER;
return SUCCESS;
case RSA_CERT_THREE:
*rootCA = RSA_ROOT_CERT_DER;
*ca = RSA_CA_CERT_DER;
*ee = RSA_EE_CERT_DER;
*prvKey = RSA_PRIV_KEY_DER;
return SUCCESS;
case ECDSA_CERT:
*rootCA = ECDSA_ROOT_CERT_DER;
*ca = ECDSA_CA_CERT_DER;
*ee = ECDSA_EE_CERT_DER;
*prvKey = ECDSA_PRIV_KEY_DER;
return SUCCESS;
default:
return ERROR;
}
}
int NormalizePath(char* normalizedPath, const char* path) {
int ret;
ret = sprintf_s(normalizedPath, CERT_PATH_LEN, "%s%s", DEFAULT_CERT_PATH, path);
if (ret <= 0) {
LOG_ERROR("sprintf_s Error");
return ERROR;
}
return SUCCESS;
}
int Dtls_DataTransfer(HITLS_Ctx *clientCtx, HLT_Process *remoteProcess, HLT_Tls_Res *serverRes)
{
uint8_t *writeBuf = (uint8_t *)"hello world";
uint32_t writeLen = strlen((char *)writeBuf);
uint8_t readBuf[READ_DATA_18432] = { 0 };
uint32_t readLen = 0;
ASSERT_EQ(HLT_TlsWrite(clientCtx, writeBuf, writeLen), SUCCESS);
ASSERT_EQ(HLT_ProcessTlsRead(remoteProcess, serverRes, readBuf, READ_DATA_18432, &readLen), 0);
ASSERT_COMPARE("COMPARE DATA", writeBuf, writeLen, readBuf, readLen);
return SUCCESS;
EXIT:
return ERROR;
}
HITLS_Ctx *Dtls_New_Ctx(HLT_Process *localProcess, HITLS_Config* clientConfig)
{
HITLS_Ctx *clientCtx = HLT_TlsNewSsl(clientConfig);
ASSERT_TRUE(clientCtx != NULL);
HLT_Ssl_Config clientCtxConfig;
clientCtxConfig.sockFd = localProcess->connFd;
clientCtxConfig.connType = SCTP;
ASSERT_TRUE_AND_LOG("HLT_TlsSetSsl", HLT_TlsSetSsl(clientCtx, &clientCtxConfig) == 0);
return clientCtx;
EXIT:
return NULL;
}
void TestSetCertPath(HLT_Ctx_Config *ctxConfig, char *SignatureType)
{
if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA1", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA1")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA1_EE_PATH, RSA_SHA1_PRIV_PATH, "NULL", "NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA256", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA256")) ==
0 ||
strncmp(SignatureType,
"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256",
strlen("CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA256")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA256_EE_PATH3, RSA_SHA256_PRIV_PATH3, "NULL", "NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA384", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA384")) ==
0 ||
strncmp(SignatureType,
"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384",
strlen("CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA384")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA384_EE_PATH, RSA_SHA384_PRIV_PATH, "NULL", "NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_RSA_PKCS1_SHA512", strlen("CERT_SIG_SCHEME_RSA_PKCS1_SHA512")) ==
0 ||
strncmp(SignatureType,
"CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512",
strlen("CERT_SIG_SCHEME_RSA_PSS_RSAE_SHA512")) == 0) {
HLT_SetCertPath(
ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA512_EE_PATH, RSA_SHA512_PRIV_PATH, "NULL", "NULL");
} else if (strncmp(SignatureType,
"CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256",
strlen("CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA_CA_PATH,
ECDSA_SHA_CHAIN_PATH,
ECDSA_SHA256_EE_PATH,
ECDSA_SHA256_PRIV_PATH,
"NULL",
"NULL");
} else if (strncmp(SignatureType,
"CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384",
strlen("CERT_SIG_SCHEME_ECDSA_SECP384R1_SHA384")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA_CA_PATH,
ECDSA_SHA_CHAIN_PATH,
ECDSA_SHA384_EE_PATH,
ECDSA_SHA384_PRIV_PATH,
"NULL",
"NULL");
} else if (strncmp(SignatureType,
"CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512",
strlen("CERT_SIG_SCHEME_ECDSA_SECP521R1_SHA512")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA_CA_PATH,
ECDSA_SHA_CHAIN_PATH,
ECDSA_SHA512_EE_PATH,
ECDSA_SHA512_PRIV_PATH,
"NULL",
"NULL");
} else if (strncmp(SignatureType, "CERT_SIG_SCHEME_ECDSA_SHA1", strlen("CERT_SIG_SCHEME_ECDSA_SHA1")) == 0) {
HLT_SetCertPath(ctxConfig,
ECDSA_SHA1_CA_PATH,
ECDSA_SHA1_CHAIN_PATH,
ECDSA_SHA1_EE_PATH,
ECDSA_SHA1_PRIV_PATH,
"NULL",
"NULL");
}
}
HITLS_CERT_X509 *HiTLS_X509_LoadCertFile(HITLS_Config *tlsCfg, const char *file);
/* @
* @test SDV_TLS_LoadAndDelCert_FUNC_TC001
* @title Loading and Deleting Certificates
* @precon nan
* @brief 1. Initialize the client and server. Expected result 1
2. Load the certificate to the certificate chain. Expected result 2
3. Load the first certificate and private key to the certificate chain. Expected result 2
4. Load the second certificate to the certificate chain. Expected result 2
5. Run the config command to remove all certificates. Expected result 3
6. Load the third certificate to the certificate chain. Expected result 2
7. Remove all certificates in CTX mode. Expected result 3
8. Load the third certificate to the certificate chain. Expected result 2
9. Initiate link establishment. Expected result 4 is obtained
* @expect 1. Initialization succeeded.
2. Loading succeeded.
3. Removing succeeded.
4. Link setup succeeded
@ */
/* BEGIN_CASE */
void SDV_TLS_CERT_LoadAndDelCert_FUNC_TC001(int delWay)
{
if (!IsEnableSctpAuth()) {
return;
}
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HITLS_Config* serverConfig = NULL;
// Stores the path where the certificate is loaded for the first time.
char *rootCAFilePath1 = NULL;
char *caFilePath1 = NULL;
char *eeFilePath1 = NULL;
char *eeKeyPath1 = NULL;
// Stores the path where the certificate is loaded for the second time.
char *rootCAFilePath2 = NULL;
char *caFilePath2 = NULL;
char *eeFilePath2 = NULL;
char *eeKeyPath2 = NULL;
HITLS_CERT_X509 *eeCert3 = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
HILT_TransportType connType = SCTP;
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, g_uiPort, false);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
TestSetCertPath(clientCtxConfig, "CERT_SIG_SCHEME_ECDSA_SECP256R1_SHA256");
rootCAFilePath1 = DEFAULT_CERT_PATH""RSA_ROOT_CERT_DER;
caFilePath1 = DEFAULT_CERT_PATH""RSA_CA_CERT_DER;
eeFilePath1 = DEFAULT_CERT_PATH""RSA_EE_CERT_DER;
eeKeyPath1 = DEFAULT_CERT_PATH""RSA_PRIV_KEY_DER;
rootCAFilePath2 = DEFAULT_CERT_PATH""ECDSA_ROOT_CERT_DER;
caFilePath2 = DEFAULT_CERT_PATH""ECDSA_CA_CERT_DER;
eeFilePath2 = DEFAULT_CERT_PATH""ECDSA_EE_CERT_DER;
eeKeyPath2 = DEFAULT_CERT_PATH""ECDSA_PRIV_KEY_DER;
ASSERT_EQ(HLT_TlsRegCallback(HITLS_CALLBACK_DEFAULT), SUCCESS);
serverConfig = HLT_TlsNewCtx(DTLS1_2);
ASSERT_TRUE(serverConfig != NULL);
uint16_t group = HITLS_EC_GROUP_SECP256R1;
ASSERT_EQ(HITLS_CFG_SetGroups(serverConfig, &group, 1), SUCCESS);
// Load the certificate to the Chain Store.
HITLS_CERT_Store *chainStore = HITLS_X509_Adapt_StoreNew();
ASSERT_TRUE(chainStore != NULL);
ASSERT_EQ(HITLS_CFG_SetVerifyStore(serverConfig, chainStore, SHALLOW_COPY), SUCCESS);
HITLS_CERT_X509 *rootCACert2 = HiTLS_X509_LoadCertFile(serverConfig, rootCAFilePath2);
ASSERT_TRUE(rootCACert2 != NULL);
ASSERT_EQ(HITLS_CFG_AddCertToStore(serverConfig, rootCACert2, TLS_CERT_STORE_TYPE_VERIFY, false), HITLS_SUCCESS);
HITLS_CERT_X509 *caCert2 = HiTLS_X509_LoadCertFile(serverConfig, caFilePath2);
ASSERT_TRUE(caCert2 != NULL);
ASSERT_EQ(HITLS_CFG_AddCertToStore(serverConfig, caCert2, TLS_CERT_STORE_TYPE_VERIFY, false), HITLS_SUCCESS);
// Loading the device certificate and corresponding private key for the first time
HITLS_CERT_X509 *eeCert1 = HiTLS_X509_LoadCertFile(serverConfig, eeFilePath2);
ASSERT_TRUE(eeCert1 != NULL);
ASSERT_EQ(HITLS_CFG_SetCertificate(serverConfig, eeCert1, SHALLOW_COPY), SUCCESS);
HITLS_CERT_Key *prvKey1 = HITLS_CFG_ParseKey(serverConfig, (const uint8_t *)eeKeyPath2, strlen(eeKeyPath1),
TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_ASN1);
ASSERT_TRUE(prvKey1 != NULL);
ASSERT_EQ(HITLS_CFG_SetPrivateKey(serverConfig, prvKey1, SHALLOW_COPY), SUCCESS);
// The private key is not loaded when the certificate is loaded for the second time.
HITLS_CERT_X509 *eeCert2 = HiTLS_X509_LoadCertFile(serverConfig, eeFilePath2);
ASSERT_TRUE(eeCert2 != NULL);
ASSERT_EQ(HITLS_CFG_SetCertificate(serverConfig, eeCert2, SHALLOW_COPY), SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetCertificate(serverConfig) == eeCert2);
if (delWay == FROM_CONFIG) {
ASSERT_EQ(HITLS_CFG_RemoveCertAndKey(serverConfig), SUCCESS);
// Reload the certificate without loading the private key.
eeCert3 = HiTLS_X509_LoadCertFile(serverConfig, eeFilePath2);
ASSERT_TRUE(eeCert3 != NULL);
ASSERT_EQ(HITLS_CFG_SetCertificate(serverConfig, eeCert3, SHALLOW_COPY), SUCCESS);
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_CERT_Key *prvKey2 = HITLS_X509_Adapt_ProviderKeyParse(serverConfig, (const uint8_t *)eeKeyPath2,
strlen(eeKeyPath2), TLS_PARSE_TYPE_FILE, "ASN1", NULL);
#else
HITLS_CERT_Key *prvKey2 = HITLS_X509_Adapt_KeyParse(serverConfig, (const uint8_t *)eeKeyPath2,
strlen(eeKeyPath2), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_ASN1);
#endif
ASSERT_TRUE(prvKey2 != NULL);
ASSERT_EQ(HITLS_CFG_SetPrivateKey(serverConfig, prvKey2, SHALLOW_COPY), SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetPrivateKey(serverConfig) == prvKey2);
}
HITLS_Ctx *serverCtx = Dtls_New_Ctx(localProcess, serverConfig);
ASSERT_TRUE(serverCtx != NULL);
if (delWay == FROM_CTX) {
// After the certificate is loaded from Config, the certificate is copied to CTX.
ASSERT_TRUE(HITLS_GetCertificate(serverCtx) != eeCert2);
ASSERT_EQ(HITLS_RemoveCertAndKey(serverCtx), SUCCESS);
// Reload the certificate without loading the private key.
eeCert3 = HiTLS_X509_LoadCertFile(serverConfig, eeFilePath2);
ASSERT_TRUE(eeCert3 != NULL);
ASSERT_EQ(HITLS_SetCertificate(serverCtx, eeCert3, SHALLOW_COPY), SUCCESS);
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_CERT_Key *prvKey2 = HITLS_X509_Adapt_ProviderKeyParse(serverConfig, (const uint8_t *)eeKeyPath2,
strlen(eeKeyPath2), TLS_PARSE_TYPE_FILE, "ASN1", NULL);
#else
HITLS_CERT_Key *prvKey2 = HITLS_X509_Adapt_KeyParse(serverConfig, (const uint8_t *)eeKeyPath2,
strlen(eeKeyPath2), TLS_PARSE_TYPE_FILE, TLS_PARSE_FORMAT_ASN1);
#endif
ASSERT_TRUE(prvKey2 != NULL);
ASSERT_EQ(HITLS_SetPrivateKey(serverCtx, prvKey2, SHALLOW_COPY), SUCCESS);
ASSERT_TRUE(HITLS_GetCertificate(serverCtx) == eeCert3);
ASSERT_TRUE(HITLS_GetPrivateKey(serverCtx) == prvKey2);
}
unsigned long int tlsAcceptId = HLT_TlsAccept(serverCtx);
clientRes = HLT_ProcessTlsConnect(remoteProcess, DTLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_GetTlsAcceptResultFromId(tlsAcceptId), 0);
ASSERT_EQ(Dtls_DataTransfer(serverCtx, remoteProcess, clientRes), SUCCESS);
EXIT:
HLT_FreeAllProcess();
return;
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/interface_tlcp/test_suite_sdv_hlt_cert_interface.c
|
C
|
unknown
| 15,849
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <unistd.h>
#include <semaphore.h>
#include "securec.h"
#include "hlt.h"
#include "logger.h"
#include "hitls_config.h"
#include "hitls_cert_type.h"
#include "hitls.h"
#include "process.h"
#include "hitls_error.h"
#include "hitls_type.h"
#include "hitls_func.h"
#include "hitls.h"
#include "conn_init.h"
#include "frame_tls.h"
#include "frame_msg.h"
#include "frame_io.h"
#include "frame_link.h"
#include "hs_common.h"
#include "change_cipher_spec.h"
#include "stub_replace.h"
#define READ_BUF_SIZE 18432
#define Port 7788
#define ROOT_DER "%s/ca.der:%s/inter.der"
#define INTCA_DER "%s/inter.der"
#define SERVER_DER "%s/server.der"
#define SERVER_KEY_DER "%s/server.key.der"
#define CLIENT_DER "%s/client.der"
#define CLIENT_KEY_DER "%s/client.key.der"
#define BUF_SZIE 18432
/* END_HEADER */
static uint32_t g_uiPort = 18889;
static void SetCertPath_2(HLT_Ctx_Config *ctxConfig, char *cipherSuite)
{
if (strstr(cipherSuite, "RSA") != NULL) {
HLT_SetCertPath(ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA1_EE_PATH, RSA_SHA1_PRIV_PATH, NULL, NULL);
} else if (strstr(cipherSuite, "ECDSA") != NULL) {
HLT_SetCertPath(ctxConfig, ECDSA_SHA_CA_PATH, ECDSA_SHA_CHAIN_PATH, ECDSA_SHA1_EE_PATH, ECDSA_SHA1_PRIV_PATH, NULL, NULL);
} else {
HLT_SetCertPath(ctxConfig, RSA_SHA_CA_PATH, RSA_SHA_CHAIN_PATH, RSA_SHA1_EE_PATH, RSA_SHA1_PRIV_PATH, NULL, NULL);
}
}
/**
* @test SDV_HITLS_CM_HITLS_GetNegotiateGroup_FUNC_TC001
* @title To test the setting of the HITLS_SetCipherServerPreference interface of the dtls.
* @precon By default, the algorithm preferred by the client is preferred.
* @brief
* 1. Initialize the hitls.
* 2. Create an SSL ctx object.
* 3. Create an SSL object.
* 4. Connect
* 5. Check for connection errors.
* 6. Check whether the negotiated cipher suite is the client preference.
* 7. Check whether the negotiated group is the client preference.
* 8. Check that the negotiated signature algorithm is the client preference.
* @expect
* 1. successful
* 2. successful
* 3. successful
* 4. successful
* 5. successful
* 6. successful
* 7. successful
* 8. successful
*/
/* BEGIN_CASE */
void SDV_HITLS_CM_HITLS_GetNegotiateGroup_FUNC_TC001(char *serverCipherSuite, char *clientCipherSuite, int expectResult)
{
if (!IsEnableSctpAuth()) {
return;
}
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
HILT_TransportType connType = SCTP;
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
SetCertPath_2(serverCtxConfig, serverCipherSuite);
HLT_SetGroups(serverCtxConfig, "HITLS_EC_GROUP_SECP256R1:HITLS_EC_GROUP_SECP384R1");
HLT_SetCipherSuites(serverCtxConfig, serverCipherSuite);
HLT_SetSignature(serverCtxConfig, "CERT_SIG_SCHEME_RSA_PKCS1_SHA384:CERT_SIG_SCHEME_RSA_PKCS1_SHA512");
serverRes = HLT_ProcessTlsAccept(localProcess, DTLS1_2, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
SetCertPath_2(clientCtxConfig, clientCipherSuite);
HLT_SetGroups(clientCtxConfig, "HITLS_EC_GROUP_SECP384R1:HITLS_EC_GROUP_SECP256R1");
HLT_SetCipherSuites(clientCtxConfig, clientCipherSuite);
HLT_SetSignature(clientCtxConfig, "CERT_SIG_SCHEME_RSA_PKCS1_SHA512:CERT_SIG_SCHEME_RSA_PKCS1_SHA384");
clientRes = HLT_ProcessTlsConnect(remoteProcess, DTLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_TRUE(HLT_ProcessTlsWrite(localProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")) == 0);
uint8_t readBuf[BUF_SZIE] = {0};
uint32_t readLen;
ASSERT_TRUE(HLT_ProcessTlsRead(remoteProcess, clientRes, readBuf, sizeof(readBuf), &readLen) == 0);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
HITLS_Ctx *testCtx = (HITLS_Ctx *)serverRes->ssl;
ASSERT_TRUE(testCtx->negotiatedInfo.cipherSuiteInfo.cipherSuite == expectResult);
ASSERT_TRUE(testCtx->negotiatedInfo.negotiatedGroup == HITLS_EC_GROUP_SECP384R1);
ASSERT_TRUE(testCtx->negotiatedInfo.signScheme == CERT_SIG_SCHEME_RSA_PKCS1_SHA512);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/**
* @test SDV_HITLS_CM_HITLS_GetNegotiateGroup_FUNC_TC002
* @title To test the setting of the HITLS_SetCipherServerPreference interface of the dtls.
* @precon Set the algorithm for preferentially selecting the server-side preference.
* @brief
* 1. Initialize the hitls.
* 2. Create an SSL ctx object.
* 3. Create an SSL object.
* 4. Connect
* 5. Check for connection errors.
* 6. Check whether the negotiated algorithm is the server preference.
* @expect
* 1. successful
* 2. successful
* 3. successful
* 4. successful
* 5. successful
* 6. successful
*/
/* BEGIN_CASE */
void SDV_HITLS_CM_HITLS_GetNegotiateGroup_FUNC_TC002(char *serverCipherSuite, char *clientCipherSuite, int expectResult)
{
if (!IsEnableSctpAuth()) {
return;
}
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
HILT_TransportType connType = SCTP;
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
SetCertPath_2(serverCtxConfig, serverCipherSuite);
HLT_SetGroups(serverCtxConfig, "NULL");
HLT_SetCipherSuites(serverCtxConfig, serverCipherSuite);
HLT_SetSignature(serverCtxConfig, "CERT_SIG_SCHEME_RSA_PKCS1_SHA384:CERT_SIG_SCHEME_RSA_PKCS1_SHA512");
serverRes = HLT_ProcessTlsAccept(localProcess, DTLS1_2, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
int32_t ret = HITLS_SetCipherServerPreference(serverRes->ssl, true);
ASSERT_TRUE(ret == HITLS_SUCCESS);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
SetCertPath_2(clientCtxConfig, clientCipherSuite);
HLT_SetGroups(clientCtxConfig, "NULL");
HLT_SetCipherSuites(clientCtxConfig, clientCipherSuite);
HLT_SetSignature(clientCtxConfig, "NULL");
clientRes = HLT_ProcessTlsConnect(remoteProcess, DTLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_TRUE(HLT_ProcessTlsWrite(localProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")) == 0);
uint8_t readBuf[BUF_SZIE] = {0};
uint32_t readLen;
ASSERT_TRUE(HLT_ProcessTlsRead(remoteProcess, clientRes, readBuf, sizeof(readBuf), &readLen) == 0);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
HITLS_Ctx *testCtx = (HITLS_Ctx *)serverRes->ssl;
ASSERT_TRUE(testCtx->negotiatedInfo.cipherSuiteInfo.cipherSuite == expectResult);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/**
* @test SDV_HITLS_CM_HITLS_GetNegotiateGroup_FUNC_TC003
* @title To test the setting of the HITLS_SetCipherServerPreference interface of the dtls.
* @precon Set the signature algorithm preferred by the server.
* @brief
* 1. Initialize the hitls.
* 2. Create an SSL ctx object.
* 3. Create an SSL object.
* 4. Connect
* 5. Check for connection errors.
* 6. Check whether the negotiated signature algorithm is the server preference.
* @expect
* 1. successful
* 2. successful
* 3. successful
* 4. successful
* 5. successful
* 6. successful
*/
/* BEGIN_CASE */
void SDV_HITLS_CM_HITLS_GetNegotiateGroup_FUNC_TC003(char *serverCipherSuite, char *clientCipherSuite)
{
if (!IsEnableSctpAuth()) {
return;
}
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
HILT_TransportType connType = SCTP;
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
SetCertPath_2(serverCtxConfig, serverCipherSuite);
HLT_SetCipherSuites(serverCtxConfig, serverCipherSuite);
HLT_SetGroups(serverCtxConfig, "NULL");
HLT_SetSignature(serverCtxConfig, "CERT_SIG_SCHEME_RSA_PKCS1_SHA384:CERT_SIG_SCHEME_RSA_PKCS1_SHA512");
serverRes = HLT_ProcessTlsAccept(localProcess, DTLS1_2, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
int32_t ret = HITLS_SetCipherServerPreference(serverRes->ssl, true);
ASSERT_TRUE(ret == HITLS_SUCCESS);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
SetCertPath_2(clientCtxConfig, clientCipherSuite);
HLT_SetCipherSuites(clientCtxConfig, clientCipherSuite);
HLT_SetGroups(clientCtxConfig, "NULL");
HLT_SetSignature(clientCtxConfig, "CERT_SIG_SCHEME_RSA_PKCS1_SHA512:CERT_SIG_SCHEME_RSA_PKCS1_SHA384");
clientRes = HLT_ProcessTlsConnect(remoteProcess, DTLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_TRUE(HLT_ProcessTlsWrite(localProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")) == 0);
uint8_t readBuf[BUF_SZIE] = {0};
uint32_t readLen;
ASSERT_TRUE(HLT_ProcessTlsRead(remoteProcess, clientRes, readBuf, sizeof(readBuf), &readLen) == 0);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
HITLS_Ctx *testCtx = (HITLS_Ctx *)serverRes->ssl;
ASSERT_TRUE(testCtx->negotiatedInfo.signScheme == CERT_SIG_SCHEME_RSA_PKCS1_SHA384);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
/**
* @test SDV_HITLS_CM_HITLS_GetNegotiateGroup_FUNC_TC004
* @title To test the setting of the HITLS_SetCipherServerPreference interface of the dtls.
* @precon Set the preference group of the server.
* @brief
* 1. Initialize the hitls.
* 2. Create an SSL ctx object.
* 3. Create an SSL object.
* 4. Connect
* 5. Check for connection errors.
* 6. Check whether the negotiated group is the server preference.
* @expect
* 1. successful
* 2. successful
* 3. successful
* 4. successful
* 5. successful
* 6. successful
*/
/* BEGIN_CASE */
void SDV_HITLS_CM_HITLS_GetNegotiateGroup_FUNC_TC004(char *serverCipherSuite, char *clientCipherSuite)
{
if (!IsEnableSctpAuth()) {
return;
}
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
HILT_TransportType connType = SCTP;
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, g_uiPort, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
SetCertPath_2(serverCtxConfig, serverCipherSuite);
HLT_SetCipherSuites(serverCtxConfig, serverCipherSuite);
HLT_SetGroups(serverCtxConfig, "HITLS_EC_GROUP_SECP256R1:HITLS_EC_GROUP_SECP384R1");
HLT_SetSignature(serverCtxConfig, "NULL");
serverRes = HLT_ProcessTlsAccept(localProcess, DTLS1_2, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
int32_t ret = HITLS_SetCipherServerPreference(serverRes->ssl, true);
ASSERT_TRUE(ret == HITLS_SUCCESS);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
SetCertPath_2(clientCtxConfig, clientCipherSuite);
HLT_SetCipherSuites(clientCtxConfig, clientCipherSuite);
HLT_SetGroups(clientCtxConfig, "HITLS_EC_GROUP_SECP384R1:HITLS_EC_GROUP_SECP256R1");
HLT_SetSignature(clientCtxConfig, "NULL");
clientRes = HLT_ProcessTlsConnect(remoteProcess, DTLS1_2, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_TRUE(HLT_ProcessTlsWrite(localProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")) == 0);
uint8_t readBuf[BUF_SZIE] = {0};
uint32_t readLen;
ASSERT_TRUE(HLT_ProcessTlsRead(remoteProcess, clientRes, readBuf, sizeof(readBuf), &readLen) == 0);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
HITLS_Ctx *testCtx = (HITLS_Ctx *)serverRes->ssl;
ASSERT_TRUE(testCtx->negotiatedInfo.negotiatedGroup == HITLS_EC_GROUP_SECP256R1);
EXIT:
HLT_FreeAllProcess();
}
/* END_CASE */
int32_t REC_GetMaxWriteSize(const TLS_Ctx *ctx, uint32_t *len);
int32_t STUB_REC_GetMaxWriteSize(const TLS_Ctx *ctx, uint32_t *len)
{
(void)ctx;
*len = 100;
return HITLS_SUCCESS;
}
/* @
* @test SDV_TLS_CM_FRAGMENTATION_FUNC_TC001
* @title DTLS Message Fragmentation
* @precon nan
* @brief
* 1. Initialize the client and server processes.
* 2. The interface for obtaining the maximum message length is stubbed and the maximum message length is changed to 100.
* 3. Creat and connect linck.
* @expect
* 1. The initialization is successful.
* 2. The stub is successful.
* 3. The link is set up successfully.
@ */
/* BEGIN_CASE */
void SDV_TLS_CM_FRAGMENTATION_FUNC_TC001(void)
{
if (!IsEnableSctpAuth()) {
return;
}
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
HLT_Ctx_Config *serverConfig = NULL;
HLT_Ctx_Config *clientConfig = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
HILT_TransportType connType = SCTP;
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, Port, false);
ASSERT_TRUE(remoteProcess != NULL);
serverConfig = HLT_NewCtxConfig(NULL, "SERVER");
clientConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(serverConfig != NULL);
ASSERT_TRUE(clientConfig != NULL);
serverRes = HLT_ProcessTlsAccept(remoteProcess, DTLS1_2, serverConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
STUB_Init();
FuncStubInfo stubInfo = {0};
STUB_Replace(&stubInfo, REC_GetMaxWriteSize, STUB_REC_GetMaxWriteSize);
clientRes = HLT_ProcessTlsInit(localProcess, DTLS1_2, clientConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_TRUE(HLT_TlsConnect(clientRes->ssl) == 0);
EXIT:
STUB_Reset(&stubInfo);
HLT_FreeAllProcess();
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/interface_tlcp/test_suite_sdv_hlt_cm_interface.c
|
C
|
unknown
| 15,727
|
/*
* 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.
*/
/* BEGIN_HEADER */
#include <stdlib.h>
#include <semaphore.h>
#include <unistd.h>
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/select.h>
#include <sys/time.h>
#include <linux/ioctl.h>
#include "securec.h"
#include "bsl_sal.h"
#include "alert.h"
#include "hitls_error.h"
#include "hitls_cert_reg.h"
#include "hitls_crypt_reg.h"
#include "hitls_config.h"
#include "tls_config.h"
#include "hitls.h"
#include "hitls_func.h"
#include "pack_frame_msg.h"
#include "hlt.h"
#include "logger.h"
#include "hitls_cert_type.h"
#include "crypt_util_rand.h"
#include "common_func.h"
#include "frame_tls.h"
#include "conn_init.h"
#include "tls.h"
#include "simulate_io.h"
#include "frame_io.h"
#include "frame_link.h"
#include "stub_replace.h"
#include "session_type.h"
#include "cert_callback.h"
#include "bsl_sal.h"
#include "sal_net.h"
#include "parse_msg.h"
#include "hs_msg.h"
#include "hitls_crypt_init.h"
#include "uio_abstraction.h"
#include "process.h"
#include "rec_wrapper.h"
#include "hs_ctx.h"
#include "hitls_type.h"
/* END_HEADER */
#define Port 7788
#define READ_BUF_SIZE 18432
#define ROOT_DER "%s/ca.der:%s/inter.der"
#define INTCA_DER "%s/inter.der"
#define SERVER_DER "%s/server.der"
#define SERVER_KEY_DER "%s/server.key.der"
#define CLIENT_DER "%s/client.der"
#define CLIENT_KEY_DER "%s/client.key.der"
#define RENEGOTIATE_FAIL 1
#define MAX_CERT_LIST 4294967295
#define MIN_CERT_LIST 0
static uint32_t g_useFlight = 0; /* Range required in the test case */
static uint32_t g_flag; /* Used to record the number of handshake messages in the current flight. */
static uint32_t g_flight = 0; /* is used to record the number of the current flight */
static HLT_FrameHandle g_frameHandle;
static HITLS_Config *GetHitlsConfigViaVersion(int ver)
{
switch (ver) {
case TLS1_2:
case HITLS_VERSION_TLS12:
return HITLS_CFG_NewTLS12Config();
case TLS1_3:
case HITLS_VERSION_TLS13:
return HITLS_CFG_NewTLS13Config();
case DTLS1_2:
case HITLS_VERSION_DTLS12:
return HITLS_CFG_NewDTLS12Config();
default:
return NULL;
}
}
static void TEST_MsgHandle(void *msg, void *data)
{
(void)data;
(void)msg;
}
/* Verify whether the parsed msg meets the requirements. Restrict the msg input parameter. */
static bool CheckHandleType(FRAME_Msg *msg)
{
if (msg->recType.data != REC_TYPE_HANDSHAKE) {
if (msg->recType.data == (uint64_t)g_frameHandle.expectReType) {
return true;
}
} else {
if (msg->recType.data == (uint64_t)g_frameHandle.expectReType &&
msg->body.hsMsg.type.data == (uint64_t)g_frameHandle.expectHsType) {
return true;
}
}
return false;
}
/* Obtain the frameType. The input parameters frameHandle and frameType must not be empty. */
static int32_t GetFrameType(HLT_FrameHandle *frameHandle, FRAME_Type *frameType)
{
if (frameHandle->ctx == NULL) {
return HITLS_NULL_INPUT;
}
TLS_Ctx *tmpCtx = (TLS_Ctx *)frameHandle->ctx;
frameType->versionType = tmpCtx->negotiatedInfo.version > 0 ?
tmpCtx->negotiatedInfo.version : tmpCtx->config.tlsConfig.maxVersion;
frameType->keyExType = tmpCtx->hsCtx->kxCtx->keyExchAlgo;
frameType->recordType = frameHandle->expectReType;
frameType->handshakeType = frameHandle->expectHsType;
return HITLS_SUCCESS;
}
static int32_t STUB_Write(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen)
{
FRAME_Msg msg = {0};
uint32_t parseLen = 0;
uint32_t offset = 0;
uint32_t msgCnt = 0;
FRAME_Type frameType = { 0 };
(void)GetFrameType(&g_frameHandle, &frameType);
g_flight++;
while (offset < len) {
(void)FRAME_ParseMsgHeader(&frameType, &((uint8_t*)buf)[offset], len - offset, &msg, &parseLen);
offset += parseLen + msg.length.data;
if (g_flight == g_useFlight) {
msgCnt++;
}
FRAME_CleanMsg(&frameType, &msg);
}
if (CheckHandleType(&msg) && g_flight == g_useFlight) {
g_flag = msgCnt;
}
return BSL_UIO_TcpMethod()->uioWrite(uio, buf, len, writeLen);
}
static int SetCertPath(HLT_Ctx_Config *ctxConfig, const char *certStr, bool isServer)
{
char caCertPath[50];
char chainCertPath[30];
char eeCertPath[30];
char privKeyPath[30];
int32_t ret = sprintf_s(caCertPath, sizeof(caCertPath), ROOT_DER, certStr, certStr);
ASSERT_TRUE(ret > 0);
ret = sprintf_s(chainCertPath, sizeof(chainCertPath), INTCA_DER, certStr);
ASSERT_TRUE(ret > 0);
ret = sprintf_s(eeCertPath, sizeof(eeCertPath), isServer ? SERVER_DER : CLIENT_DER, certStr);
ASSERT_TRUE(ret > 0);
ret = sprintf_s(privKeyPath, sizeof(privKeyPath), isServer ? SERVER_KEY_DER : CLIENT_KEY_DER, certStr);
ASSERT_TRUE(ret > 0);
HLT_SetCaCertPath(ctxConfig, (char *)caCertPath);
HLT_SetChainCertPath(ctxConfig, (char *)chainCertPath);
HLT_SetEeCertPath(ctxConfig, (char *)eeCertPath);
HLT_SetPrivKeyPath(ctxConfig, (char *)privKeyPath);
return 0;
EXIT:
return -1;
}
/* @
* @test SDV_TLS_CFG_SET_GET_VERIFYNONESUPPORT_FUNC_TC001
* @title The server does not verify the client certificate.
* @precon nan
* @brief
* 1. The server invokes the HITLS_CFG_SetVerifyNoneSupport and sets the parameter to false. Expected result 1 is
* obtained.
* 2. The server invokes the HITLS_CFG_SetVerifyNoneSupport interface to obtain the configuration result. (Expected
* result 2)
* 3. The server invokes the HITLS_SetVerifyNoneSupport interface and sets it to true. Expected result 3 is obtained.
* 4. The server invokes the HITLS_GetVerifyNoneSupport interface to obtain the configuration result. (Expected result 4)
* 4. Establish a connection. Expected result 4 is obtained.
* @expect
* 1. The setting is successful.
* 2. The setting is successful.
* 3. The setting is successful.
* 4. The connection is successfully established.
@ */
/* BEGIN_CASE */
void SDV_TLS_CFG_SET_GET_VERIFYNONESUPPORT_FUNC_TC001(int version, int connType)
{
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
uint8_t c_flag = 0;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, Port, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
ASSERT_EQ(SetCertPath(serverCtxConfig, "ecdsa_sha256", true), 0);
HLT_SetCipherSuites(serverCtxConfig, "HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256");
serverRes = HLT_ProcessTlsAccept(localProcess, version, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HITLS_SetVerifyNoneSupport(serverRes->ssl, true);
HITLS_GetVerifyNoneSupport(serverRes->ssl, &c_flag);
ASSERT_TRUE(c_flag == 1);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_SetCertPath(clientCtxConfig, "ecdsa_sha256/ca.der", "NULL", "NULL", "NULL", "NULL", "NULL");
HLT_SetCipherSuites(serverCtxConfig, "HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256");
clientRes = HLT_ProcessTlsInit(remoteProcess, version, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
ASSERT_EQ(HLT_RpcTlsConnect(remoteProcess, clientRes->sslId), HITLS_SUCCESS);
ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
ASSERT_TRUE(HLT_ProcessTlsWrite(localProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")) == 0);
uint8_t readBuf[READ_BUF_SIZE] = {0};
uint32_t readLen;
ASSERT_TRUE(HLT_ProcessTlsRead(remoteProcess, clientRes, readBuf, sizeof(readBuf), &readLen) == 0);
ASSERT_TRUE(readLen == strlen("Hello World"));
ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
EXIT:
HLT_CleanFrameHandle();
HLT_FreeAllProcess();
}
/* END_CASE */
/** @
* @test HITLS_TLS1_2_Config_SDV_23_0_5_047
* @title Enable dual-end verification. The server verifies the client certificate only once.
* @precon nan
* @brief
* 1. The server invokes the HITLS_CFG_SetClientVerifySupport and sets the parameter to true.
* 2. Set the value of HITLS_CFG_SetClientOnceVerifySupport to false when the server invokes the
* HITLS_CFG_SetClientOnceVerifySupport.
* 3. The server invokes the HITLS_CFG_SetClientOnceVerifySupport interface to obtain the configuration result.
* 4. The server invokes the HITLS_SetClientOnceVerifySupport interface and sets it to true.
* 5. The server invokes the HITLS_SetClientOnceVerifySupport interface to obtain the configuration result.
* 6. Establish a connection. After the connection is established, perform renegotiation. Stop the status on the server to
* TRY_SEND_CERTIFICATIONATE_REQUEST. The expected result is obtained.
* @expect
* 1. If the status fails to be stopped, the certificate will not be verified during the renegotiation.
@ */
/* BEGIN_CASE */
void SDV_TLS_CFG_SET_GET_CLIENTVERIFYUPPORT_FUNC_TC001(int clientverify)
{
FRAME_Init();
HITLS_Config *config_c = NULL;
HITLS_Config *config_s = NULL;
FRAME_LinkObj *client = NULL;
FRAME_LinkObj *server = NULL;
config_c = HITLS_CFG_NewTLS12Config();
config_s = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(config_c != NULL);
ASSERT_TRUE(config_s != NULL);
uint8_t c_flag;
if (clientverify) {
HITLS_CFG_SetClientVerifySupport(config_s, true);
} else {
HITLS_CFG_SetClientVerifySupport(config_s, false);
}
HITLS_CFG_SetClientOnceVerifySupport(config_s, false);
HITLS_CFG_GetClientOnceVerifySupport(config_s, &c_flag);
ASSERT_TRUE(c_flag == 0);
client = FRAME_CreateLink(config_c, BSL_UIO_TCP);
ASSERT_TRUE(client != NULL);
server = FRAME_CreateLink(config_s, BSL_UIO_TCP);
ASSERT_TRUE(server != NULL);
HITLS_SetClientOnceVerifySupport(server->ssl, true);
HITLS_GetClientOnceVerifySupport(server->ssl, &c_flag);
ASSERT_TRUE(c_flag == 1);
HITLS_SetRenegotiationSupport(server->ssl, true);
HITLS_SetRenegotiationSupport(client->ssl, true);
HITLS_GetRenegotiationSupport(server->ssl, &c_flag);
ASSERT_TRUE(c_flag == 1);
ASSERT_EQ(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT), HITLS_SUCCESS);
uint8_t verifyDataNew[MAX_DIGEST_SIZE] = {0};
uint32_t verifyDataNewSize = 0;
uint8_t verifyDataOld[MAX_DIGEST_SIZE] = {0};
uint32_t verifyDataOldSize = 0;
ASSERT_TRUE(HITLS_GetFinishVerifyData(server->ssl, verifyDataOld, sizeof(verifyDataOld),
&verifyDataOldSize) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(client->ssl) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_Renegotiate(server->ssl) == HITLS_SUCCESS);
ASSERT_EQ(FRAME_CreateRenegotiationState(client, server, false, TRY_SEND_CERTIFICATE_REQUEST), HITLS_INTERNAL_EXCEPTION);
ASSERT_TRUE(HITLS_GetFinishVerifyData(server->ssl, verifyDataNew, sizeof(verifyDataNew),
&verifyDataNewSize) == HITLS_SUCCESS);
ASSERT_TRUE(memcmp(verifyDataNew, verifyDataOld, verifyDataOldSize) != 0);
EXIT:
HITLS_CFG_FreeConfig(config_c);
HITLS_CFG_FreeConfig(config_s);
FRAME_FreeLink(client);
FRAME_FreeLink(server);
}
/* END_CASE */
/** @
* @test SDV_TLS_CFG_ADD_CAINDICATION_FUNC_TC001
* @title: Add different CA flag indication types.
* @precon nan
* @brief
* 1. Invoke the HITLS_CFG_AddCAIndication interface and set the transferred caType to HITLS_TRUSTED_CA_PRE_AGREED and
* HITLS_TRUSTED_CA_PRE_AGREED respectively. HITLS_TRUSTED_CA_KEY_SHA1, HITLS_TRUSTED_CA_X509_NAME,
* HITLS_TRUSTED_CA_CERT_SHA1, When the HITLS_TRUSTED_CA_UNKNOWN macro is used, expected result 1 is obtained.
* 2. Check the return value of the interface. Expected result 2 is obtained.
* @expect
* 1. The invoking is successful.
* 2. The interface returns HITLS_SUCCESS.
@ */
/* BEGIN_CASE */
void SDV_TLS_CFG_ADD_CAINDICATION_FUNC_TC001(int tlsVersion)
{
FRAME_Init();
HITLS_Config *config = NULL;
uint8_t data[] = {0};
uint32_t len = sizeof(data);
config = GetHitlsConfigViaVersion(tlsVersion);
ASSERT_TRUE(HITLS_CFG_AddCAIndication(config, HITLS_TRUSTED_CA_PRE_AGREED, data, len) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_AddCAIndication(config, HITLS_TRUSTED_CA_KEY_SHA1, data, len) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_AddCAIndication(config, HITLS_TRUSTED_CA_X509_NAME, data, len) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_AddCAIndication(config, HITLS_TRUSTED_CA_CERT_SHA1, data, len) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_AddCAIndication(config, HITLS_TRUSTED_CA_UNKNOWN, data, len) == HITLS_SUCCESS);
EXIT:
HITLS_CFG_FreeConfig(config);
}
/* END_CASE */
/** @
* @test SDV_TLS_CFG_GET_CIPHERBYID_FUNC_TC001
* @title Obtain the CipherId based on the known cipher suite.
* @precon nan
* @brief
* 1. Invoke the HITLS_CFG_GetCipherByID and set the transferred id to the HITLS_AES_128_GCM_SHA256 macro to obtain the
* HITLS_Cipher structure. (Expected result 1)
* 2. Invoke the HITLS_CFG_GetCipherId interface and transfer the obtained structure. (Expected result 2)
* @expect
* 1. The interface returns the corresponding HITLS_Cipher structure.
* 2. HITLS_CIPHER_AES_128_GCM is returned.
@ */
/* BEGIN_CASE */
void SDV_TLS_CFG_GET_CIPHERBYID_FUNC_TC001()
{
FRAME_Init();
HITLS_CipherAlgo cipherAlgo;
const HITLS_Cipher* cipher = HITLS_CFG_GetCipherByID(HITLS_AES_128_GCM_SHA256);
HITLS_CFG_GetCipherId(cipher, &cipherAlgo);
ASSERT_EQ(cipherAlgo, HITLS_CIPHER_AES_128_GCM);
EXIT:
return;
}
/* END_CASE */
/** @
* @test SDV_TLS_CFG_GET_AUTHID_FUNC_TC001
* @title Self-registration cipher. Invoke the interface to obtain the AuthId.
* @precon nan
* @brief
* 1. Register a HITLS_Cipher structure, set cipherid to HITLS_AUTH_NULL, and call HITLS_CFG_GetAuthId. Expected result 1
* is obtained.
* @expect
* 1. HITLS_AUTH_NULL is returned.
@ */
/* BEGIN_CASE */
void SDV_TLS_CFG_GET_AUTHID_FUNC_TC001()
{
FRAME_Init();
HITLS_AuthAlgo cipherSuite;
HITLS_Cipher *cipher = (HITLS_Cipher *)malloc(sizeof(HITLS_Cipher));
cipher->authAlg = HITLS_AUTH_NULL;
HITLS_CFG_GetAuthId(cipher, &cipherSuite);
ASSERT_EQ(cipherSuite, HITLS_AUTH_NULL);
EXIT:
free(cipher);
}
/* END_CASE */
/** @
* @test SDV_TLS_CFG_GET_CIPHERSUITENAME_FUNC_TC001
* @title Query the name of the algorithm suite.
* @precon nan
* @brief
* 1. Set cipher to HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 and invoke the HITLS_CFG_GetCipherSuiteName interface.
* Expected result 1 is obtained.
* @expect
* 1. Return value of the char* conversion interface, which is the same as that of the
* HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.
@ */
/* BEGIN_CASE */
void SDV_TLS_CFG_GET_CIPHERSUITENAME_FUNC_TC001()
{
FRAME_Init();
const HITLS_Cipher* cipher = HITLS_CFG_GetCipherByID(HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256);
const uint8_t* name = HITLS_CFG_GetCipherSuiteName(cipher);
ASSERT_TRUE(strcmp((char *)name, "HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256") == 0);
EXIT:
return;
}
/* END_CASE */
/** @
* @test SDV_TLS_CFG_GET_CIPHERVERSION_FUNC_TC001
* @title Query the cipher suite version and obtain the algorithm based on the ID.
* @precon nan
* @brief
* 1. Set cipher to HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 () and invoke the HITLS_CFG_GetCipherVersion interface.
* (Expected result 1)
* 2. Set cipher to HITLS_AES_128_GCM_SHA256 () and invoke the HITLS_CFG_GetCipherVersion interface. (Expected result 2)
* 3. Set cipher to HITLS_RSA_WITH_AES_128_CBC_SHA () and invoke the HITLS_CFG_GetCipherVersion interface. (Expected
* result 3)
* @expect
* 1. Interface return value: HITLS_VERSION_TLS12
* 2. Interface return value: HITLS_VERSION_TLS13, HITLS_VERSION_TLS13
* 3. Interface return value: HITLS_VERSION_SSL30
@ */
/* BEGIN_CASE */
void SDV_TLS_CFG_GET_CIPHERVERSION_FUNC_TC001()
{
FRAME_Init();
int32_t version;
const HITLS_Cipher *cipher = HITLS_CFG_GetCipherByID(HITLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256);
ASSERT_EQ(HITLS_CFG_GetCipherVersion(cipher, &version), HITLS_SUCCESS);
ASSERT_EQ(HITLS_VERSION_TLS12, version);
cipher = HITLS_CFG_GetCipherByID(HITLS_AES_128_GCM_SHA256);
ASSERT_EQ(HITLS_CFG_GetCipherVersion(cipher, &version), HITLS_SUCCESS);
ASSERT_EQ(HITLS_VERSION_TLS13, version);
cipher = HITLS_CFG_GetCipherByID(HITLS_RSA_WITH_AES_128_CBC_SHA);
ASSERT_EQ(HITLS_CFG_GetCipherVersion(cipher, &version), HITLS_SUCCESS);
ASSERT_EQ(HITLS_VERSION_SSL30, version);
EXIT:
version = 1;
}
/* END_CASE */
/** @
* @test SDV_TLS_CFG_GET_CIPHERSUITE_FUNC_TC001
* @title Obtain the cipher suite based on the supported cipher suite ID.
* @precon nan
* @brief
* 1. Invoke the HITLS_CFG_GetCipherByID and set the input ID to the HITLS_AES_128_GCM_SHA256 macro to obtain the
* cipherinfo structure. Expected result 1 is obtained.
* 2. Invoke the HITLS_CFG_GetCipherSuite interface and transfer the obtained structure. (Expected result 2)
* @expect
* 1. The interface returns the corresponding HITLS_Cipher structure.
* 2. HITLS_AES_128_GCM_SHA256 is returned.
@ */
/* BEGIN_CASE */
void SDV_TLS_CFG_GET_CIPHERSUITE_FUNC_TC001()
{
FRAME_Init();
uint16_t cipherSuite;
const HITLS_Cipher* cipher = HITLS_CFG_GetCipherByID(HITLS_AES_128_GCM_SHA256);
HITLS_CFG_GetCipherSuite(cipher, &cipherSuite);
ASSERT_EQ(cipherSuite, HITLS_AES_128_GCM_SHA256);
EXIT:
return;
}
/* END_CASE */
/** @
* @test SDV_TLS_CFG_GET_FLIGHTTRANSMITSWITH_FUNC_TC001
* @titleThe client sends messages by flight.
* @precon nan
* @brief 1. The server invokes the HITLS_CFG_SetFlightTransmitSwitch interface and sets the parameter to false. Expected
result 1 is obtained.
2. The server invokes the HITLS_CFG_GetFlightTransmitSwitch interface to obtain the configuration result.
(Expected result 2)
3. The client invokes the HITLS_SetFlightTransmitSwitch interface to set the parameter to true. Expected result
3 is obtained.
4. The client invokes the HITLS_GetFlightTransmitSwitch interface to obtain the configuration result. Expected
result 4 is obtained.
5. Establish a link and count the number of messages sent by the client in the second flight. Expected result 5
is obtained.
* @expect
1. The setting is successful.
2. The obtained result is false.
3. The setting is successful.
4. The obtained result is true.
5. The connection is set up successfully, and the number of the second flight messages sent by the client is 3.
@ */
/* BEGIN_CASE */
void SDV_TLS_CFG_GET_FLIGHTTRANSMITSWITH_FUNC_TC001(int version)
{
FRAME_Init();
HITLS_Config *Config = NULL;
HITLS_Ctx *ctx = NULL;
uint8_t support;
Config = GetHitlsConfigViaVersion(version);
ASSERT_TRUE(Config != NULL);
ctx = HITLS_New(Config);
ASSERT_TRUE(ctx != NULL);
HITLS_CFG_SetFlightTransmitSwitch(Config, false);
HITLS_CFG_GetFlightTransmitSwitch(Config, &support);
ASSERT_TRUE(support == false);
HITLS_SetFlightTransmitSwitch(ctx, true);
HITLS_GetFlightTransmitSwitch(ctx, &support);
ASSERT_TRUE(support == true);
HLT_Tls_Res *serverRes = NULL;
HLT_Tls_Res *clientRes = NULL;
HLT_Process *localProcess = NULL;
HLT_Process *remoteProcess = NULL;
localProcess = HLT_InitLocalProcess(HITLS);
ASSERT_TRUE(localProcess != NULL);
remoteProcess = HLT_LinkRemoteProcess(HITLS, TCP, Port, true);
ASSERT_TRUE(remoteProcess != NULL);
HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
ASSERT_TRUE(serverCtxConfig != NULL);
HLT_SetFlightTransmitSwitch(serverCtxConfig, false);
serverRes = HLT_ProcessTlsAccept(remoteProcess, version, serverCtxConfig, NULL);
ASSERT_TRUE(serverRes != NULL);
HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
ASSERT_TRUE(clientCtxConfig != NULL);
HLT_SetFlightTransmitSwitch(clientCtxConfig, true);
clientRes = HLT_ProcessTlsInit(localProcess, version, clientCtxConfig, NULL);
ASSERT_TRUE(clientRes != NULL);
HLT_FrameHandle frameHandle = {
.ctx = clientRes->ssl,
.frameCallBack = TEST_MsgHandle,
.userData = NULL,
.expectHsType = CLIENT_KEY_EXCHANGE,
.expectReType = REC_TYPE_HANDSHAKE,
.ioState = EXP_NONE,
.pointType = POINT_SEND,
.method.uioWrite = STUB_Write,
};
ASSERT_TRUE(HLT_SetFrameHandle(&frameHandle) == HITLS_SUCCESS);
g_useFlight = 2;
ASSERT_TRUE(HLT_TlsConnect(clientRes->ssl) == HITLS_SUCCESS);
if (version == TLS1_2) {
ASSERT_EQ(g_flag, 3);
} else {
ASSERT_EQ(g_flag, 2);
}
HLT_CleanFrameHandle();
EXIT:
g_flag = 0;
g_flight = 0;
HLT_CleanFrameHandle();
HLT_FreeAllProcess();
HITLS_CFG_FreeConfig(Config);
HITLS_Free(ctx);
return;
}
/* END_CASE */
/** @
* @test SDV_TLS_CFG_GET_MAXCERTLIST_API_TC001
* @title HTLS_CFG_SetMaxCertList, HITLS_CFG_GetMaxCertList, HITLS_SetMaxCertList, and HITLS_GetMaxCertList APIs
* @precon nan
* @brief
* 1. Apply for and initialize config and ctx.
* 2. Set the certificate chain length config to null and invoke the HITLS_CFG_SetMaxCertList interface.
* 3. Invoke the HITLS_CFG_GetMaxCertList interface and check the output parameter value.
* 4. Set the maximum length of the certificate chain by calling the HITLS_CFG_SetMaxCertList interface.
* 5. Invoke the HITLS_CFG_GetMaxCertList interface and check the output parameter value.
* 6. Set the minimum certificate chain length by calling the HITLS_CFG_SetMaxCertList interface.
* 7. Invoke the HITLS_CFG_GetMaxCertList interface and check the output parameter value.
* 8. Use the HITLS_SetMaxCertList and HITLS_GetMaxCertList interfaces to repeat the preceding test.
* @expect
* 1. Initialization succeeds.
* 2. HITLS_NULL_INPUT is returned.
* 3. HITLS_NULL_INPUT is returned.
* 4. The interface returns HITLS_SUCCESS.
* 5. The value of MaxCertList returned by the interface is 2 ^ 32 - 1.
* 6. The interface returns the HITLS_SUCCESS.
* 7. The value of MaxCertList returned by the interface is 0.
* 8. Same as above
@ */
/* BEGIN_CASE */
void SDV_TLS_CFG_GET_MAXCERTLIST_API_TC001()
{
FRAME_Init();
HITLS_Config *tlsConfig;
HITLS_Ctx *ctx = NULL;
tlsConfig = HITLS_CFG_NewTLS12Config();
ASSERT_TRUE(tlsConfig != NULL);
ctx = HITLS_New(tlsConfig);
ASSERT_TRUE(ctx != NULL);
uint32_t maxSize;
ASSERT_TRUE(HITLS_CFG_SetMaxCertList(NULL, MAX_CERT_LIST) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_GetMaxCertList(NULL, &maxSize) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_CFG_SetMaxCertList(tlsConfig, MAX_CERT_LIST) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMaxCertList(tlsConfig, &maxSize) == HITLS_SUCCESS);
ASSERT_TRUE(maxSize == MAX_CERT_LIST);
ASSERT_TRUE(HITLS_CFG_SetMaxCertList(tlsConfig, MIN_CERT_LIST) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_CFG_GetMaxCertList(tlsConfig, &maxSize) == HITLS_SUCCESS);
ASSERT_TRUE(maxSize == MIN_CERT_LIST);
ASSERT_TRUE(HITLS_SetMaxCertList(NULL, MAX_CERT_LIST) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_GetMaxCertList(NULL, &maxSize) == HITLS_NULL_INPUT);
ASSERT_TRUE(HITLS_SetMaxCertList(ctx, MAX_CERT_LIST) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetMaxCertList(ctx, &maxSize) == HITLS_SUCCESS);
ASSERT_TRUE(maxSize == MAX_CERT_LIST);
ASSERT_TRUE(HITLS_SetMaxCertList(ctx, MIN_CERT_LIST) == HITLS_SUCCESS);
ASSERT_TRUE(HITLS_GetMaxCertList(ctx, &maxSize) == HITLS_SUCCESS);
ASSERT_TRUE(maxSize == MIN_CERT_LIST);
EXIT:
HITLS_CFG_FreeConfig(tlsConfig);
HITLS_Free(ctx);
}
/* END_CASE */
|
2301_79861745/bench_create
|
testcode/sdv/testcase/tls/interface_tlcp/test_suite_sdv_hlt_config_interface.c
|
C
|
unknown
| 24,545
|
/*
* 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 ALTER_H
#define ALTER_H
#include <stdbool.h>
#include <stdint.h>
#include "hitls_build.h"
#include "tls.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
ALERT_FLAG_NO = 0, /* no alert message */
ALERT_FLAG_RECV, /* received the alert message */
ALERT_FLAG_SEND, /* the alert message needs to be sent */
} ALERT_FLAG;
/** obtain the messages about receiving and sending by Alert */
typedef struct {
uint8_t flag; /* send and receive flags, see ALERT_FLAG */
uint8_t level; /* Alert level. For details, see ALERT_Level. */
uint8_t description; /* Alert description. For details, see ALERT_Description. */
uint8_t reverse; /* reserve, 4-byte aligned */
} ALERT_Info;
/**
* @ingroup alert
* @brief Alert initialization function
*
* @param ctx [IN] tls Context
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_INTERNAL_EXCEPTION An unexpected internal error occurs.
* @retval HITLS_MEMALLOC_FAIL Failed to apply for memory.
*/
int32_t ALERT_Init(TLS_Ctx *ctx);
/**
* @ingroup alert
* @brief Alert deinitialization function
*
* @param ctx [IN] tls Context
*
*/
void ALERT_Deinit(TLS_Ctx *ctx);
/**
* @ingroup alert
* @brief Check whether there are received or sent alert messages to be processed.
*
* @attention ctx cannot be empty.
* @param ctx [IN] tls Context
*
* @retval true: The processing is required.
* @retval false: No processing is required.
*/
bool ALERT_GetFlag(const TLS_Ctx *ctx);
/**
* @ingroup alert
* @brief Obtain the alert information.
*
* @attention ctx and info cannot be empty. Ensure that the value is used when Alert_GetFlag is true.
* @param ctx [IN] tls Context
* @param info [IN] Alert information record
*/
void ALERT_GetInfo(const TLS_Ctx *ctx, ALERT_Info *info);
/**
* @brief Clear the alert information.
*
* @attention ctx cannot be empty.
* @param ctx [IN] tls Context
*/
void ALERT_CleanInfo(const TLS_Ctx *ctx);
/**
* @brief Send an alert message and cache it in the alert module.
*
* @attention ctx cannot be empty.
* @param ctx [IN] tls Context
* @param level [IN] Alert level
* @param description [IN] alert Description
*
*/
void ALERT_Send(const TLS_Ctx *ctx, ALERT_Level level, ALERT_Description description);
/**
* @brief Send the alert message cached by the alert module to the network layer.
*
* @attention ctx cannot be empty. Alert_Send must be invoked before flushing.
* @param ctx [IN] tls Context
*
* @retval HITLS_SUCCESS succeeded.
* @retval See REC_Write
*/
int32_t ALERT_Flush(TLS_Ctx *ctx);
/**
* @brief Process alert message after decryption
*
* @attention ctx cannot be empty.
* @param ctx [IN] tls Context
* @param data [IN] alert data
* @param dataLen [IN] alert data length
* @retval HITLS_REC_NORMAL_RECV_UNEXPECT_MSG
*/
int32_t ProcessDecryptedAlert(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen);
/**
* @brief Process plaintext alert message in TLS13
*
* @attention ctx cannot be empty.
* @param ctx [IN] tls Context
* @param data [IN] alert data
* @param dataLen [IN] alert data length
* @retval HITLS_REC_NORMAL_RECV_UNEXPECT_MSG
*/
int32_t ProcessPlainAlert(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen);
/**
* @ingroup alert
* @brief Clear the number of consecutive received warnings
*
* @param ctx [IN] tls Context
*/
void ALERT_ClearWarnCount(TLS_Ctx *ctx);
/**
* @ingroup alert
* @brief Increase the number of alert and check whether it has exceeded the threshold or not
*
* @param ctx [IN] tls Context
* @param threshold [IN] alert number threshold
* @retval the number of alert has exceeded the threshold or not
*/
bool ALERT_HaveExceeded(TLS_Ctx *ctx, uint8_t threshold);
#ifdef HITLS_BSL_LOG
int32_t ReturnAlertProcess(TLS_Ctx *ctx, int32_t err, uint32_t logId, const void *logStr,
ALERT_Description description);
#define RETURN_ALERT_PROCESS(ctx, err, logId, logStr, description) \
ReturnAlertProcess(ctx, err, logId, LOG_STR(logStr), description)
#else
#define RETURN_ALERT_PROCESS(ctx, err, logId, logStr, description) \
(ctx)->method.sendAlert(ctx, ALERT_LEVEL_FATAL, description), (err)
#endif /* HITLS_BSL_LOG */
#ifdef __cplusplus
}
#endif
#endif /* ALTER_H */
|
2301_79861745/bench_create
|
tls/alert/include/alert.h
|
C
|
unknown
| 4,799
|
/*
* 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_sal.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 "tls.h"
#include "rec.h"
#ifdef HITLS_TLS_FEATURE_FLIGHT
#include "bsl_uio.h"
#include "hitls.h"
#endif
#include "record.h"
#include "alert.h"
#define ALERT_DATA_LEN 2u /* alert data length */
/** Alert context, which records the sending and receiving information */
struct AlertCtx {
uint8_t flag; /* send and receive flags, for details, see ALERT_FLAG */
bool isFlush; /* whether the message is sent successfully */
uint8_t warnCount; /* count the number of consecutive received warnings */
uint8_t level; /* Alert level. For details, see ALERT_Level */
uint8_t description; /* Alert description: For details, see ALERT_Description */
uint8_t reverse; /* reserve, 4-byte aligned */
};
bool ALERT_GetFlag(const TLS_Ctx *ctx)
{
return (ctx->alertCtx->flag != ALERT_FLAG_NO);
}
void ALERT_GetInfo(const TLS_Ctx *ctx, ALERT_Info *info)
{
struct AlertCtx *alertCtx = ctx->alertCtx;
info->flag = alertCtx->flag;
info->level = alertCtx->level;
info->description = alertCtx->description;
return;
}
void ALERT_CleanInfo(const TLS_Ctx *ctx)
{
uint8_t alertCount = ctx->alertCtx->warnCount;
(void)memset_s(ctx->alertCtx, sizeof(struct AlertCtx), 0, sizeof(struct AlertCtx));
ctx->alertCtx->warnCount = alertCount;
return;
}
/* check whether the operation is abnormal */
bool AlertIsAbnormalInput(const struct AlertCtx *alertCtx, ALERT_Level level)
{
if (level != ALERT_LEVEL_FATAL && level != ALERT_LEVEL_WARNING) {
return true;
}
if (alertCtx->flag != ALERT_FLAG_NO) {
// a critical alert exists and cannot be overwritten
if (alertCtx->level == ALERT_LEVEL_FATAL) {
return true;
}
// common alarms are not allowed to overwrite CLOSE NOTIFY
if (level == ALERT_LEVEL_WARNING &&
alertCtx->level == ALERT_LEVEL_WARNING &&
alertCtx->description == ALERT_CLOSE_NOTIFY) {
return true;
}
}
return false;
}
void ALERT_Send(const TLS_Ctx *ctx, ALERT_Level level, ALERT_Description description)
{
struct AlertCtx *alertCtx = ctx->alertCtx;
// prevent abnormal operations
if (AlertIsAbnormalInput(alertCtx, level)) {
return;
}
alertCtx->level = (uint8_t)level;
alertCtx->description = (uint8_t)description;
alertCtx->flag = ALERT_FLAG_SEND;
alertCtx->isFlush = false;
return;
}
int32_t ALERT_Flush(TLS_Ctx *ctx)
{
struct AlertCtx *alertCtx = ctx->alertCtx;
int32_t ret;
if (alertCtx->flag != ALERT_FLAG_SEND) {
BSL_ERR_PUSH_ERROR(HITLS_ALERT_NO_WANT_SEND);
return HITLS_ALERT_NO_WANT_SEND;
}
#ifdef HITLS_TLS_PROTO_TLS
if (REC_GetOutBufPendingSize(ctx) != 0) {
ret = REC_OutBufFlush(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif
if (alertCtx->isFlush == false) {
if (ctx->recCtx != NULL && ctx->recCtx->pendingData != NULL && alertCtx->description == ALERT_CLOSE_NOTIFY) {
return HITLS_REC_NORMAL_IO_BUSY;
}
uint8_t data[ALERT_DATA_LEN];
/** obtain the alert level */
data[0] = alertCtx->level;
data[1] = alertCtx->description;
if (ctx->negotiatedInfo.version == HITLS_VERSION_SSL30 && alertCtx->description == ALERT_PROTOCOL_VERSION) {
data[1] = ALERT_HANDSHAKE_FAILURE;
}
/** write the record */
ret = REC_Write(ctx, REC_TYPE_ALERT, data, ALERT_DATA_LEN);
if (!IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
alertCtx->isFlush = true;
}
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16267, "Write fail");
}
alertCtx->isFlush = true;
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15768, BSL_LOG_LEVEL_WARN, BSL_LOG_BINLOG_TYPE_RUN,
"Sent an Alert msg:level[%u] description[%u]", data[0], data[1], 0, 0);
}
#ifdef HITLS_TLS_FEATURE_FLIGHT
/* if isFlightTransmitEnable is enabled, the stored handshake information needs to be sent */
uint8_t isFlightTransmitEnable = 0;
(void)HITLS_GetFlightTransmitSwitch(ctx, &isFlightTransmitEnable);
if (isFlightTransmitEnable == 1) {
ret = REC_FlightTransmit(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif /* HITLS_TLS_FEATURE_FLIGHT */
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_PROTO_TLS13
static uint32_t ALERT_GetVersion(const TLS_Ctx *ctx)
{
if (ctx->negotiatedInfo.version > 0) {
/* the version has been negotiated */
return ctx->negotiatedInfo.version;
} else {
/* if the version is not negotiated, the latest version supported by the local end is returned */
return ctx->config.tlsConfig.maxVersion;
}
}
#endif /* HITLS_TLS_PROTO_TLS13 */
int32_t ALERT_Init(TLS_Ctx *ctx)
{
if (ctx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15772, 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;
}
// prevent multi init of ctx->alertCtx
if (ctx->alertCtx != NULL) {
return HITLS_SUCCESS;
}
ctx->alertCtx = (struct AlertCtx *)BSL_SAL_Malloc(sizeof(struct AlertCtx));
if (ctx->alertCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15773, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"malloc alert ctx fail.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
(void)memset_s(ctx->alertCtx, sizeof(struct AlertCtx), 0, sizeof(struct AlertCtx));
return HITLS_SUCCESS;
}
void ALERT_Deinit(TLS_Ctx *ctx)
{
if (ctx == NULL) {
return;
}
BSL_SAL_FREE(ctx->alertCtx);
return;
}
int32_t ProcessDecryptedAlert(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen)
{
struct AlertCtx *alertCtx = ctx->alertCtx;
/** if the message lengths are not equal, an error code is returned */
if (dataLen != ALERT_DATA_LEN) {
BSL_ERR_PUSH_ERROR(HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15769, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"get a alert msg with illegal len %u", dataLen, 0, 0, 0);
ALERT_Send(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG;
}
/** record the alert message */
if (data[0] == ALERT_LEVEL_FATAL || data[0] == ALERT_LEVEL_WARNING) {
// prevent abnormal operations
if (AlertIsAbnormalInput(alertCtx, data[0]) == true) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_REC_NORMAL_RECV_UNEXPECT_MSG, BINLOG_ID16268, "input abnormal");
}
alertCtx->flag = ALERT_FLAG_RECV;
alertCtx->level = data[0];
alertCtx->description = data[1];
#ifdef HITLS_TLS_PROTO_TLS13
if (ALERT_GetVersion(ctx) == HITLS_VERSION_TLS13 && alertCtx->description != ALERT_CLOSE_NOTIFY) {
alertCtx->level = ALERT_LEVEL_FATAL;
}
#endif
if (alertCtx->level == ALERT_LEVEL_FATAL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16269, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"alert fatal", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
}
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15770, BSL_LOG_LEVEL_WARN, BSL_LOG_BINLOG_TYPE_RUN,
"got a alert msg:level[%u] description[%u]", data[0], data[1], 0, 0);
return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG;
}
BSL_ERR_PUSH_ERROR(HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15771, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"get a alert msg with illegal type", 0, 0, 0, 0);
/** Decoding error. Send an alert. */
ALERT_Send(ctx, ALERT_LEVEL_FATAL, ALERT_ILLEGAL_PARAMETER);
return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG;
}
#ifdef HITLS_TLS_PROTO_TLS13
int32_t ProcessPlainAlert(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen)
{
if (ctx->isClient == true && REC_HaveReadSuiteInfo(ctx)) {
return RETURN_ALERT_PROCESS(ctx, HITLS_REC_NORMAL_RECV_UNEXPECT_MSG, BINLOG_ID16270,
"receive plain alert", ALERT_UNEXPECTED_MESSAGE);
}
if (ctx->isClient == false && ctx->plainAlertForbid == true) {
return RETURN_ALERT_PROCESS(ctx, HITLS_REC_NORMAL_RECV_UNEXPECT_MSG, BINLOG_ID16271,
"tls1.3 forbid to receive plain alert", ALERT_UNEXPECTED_MESSAGE);
}
return ProcessDecryptedAlert(ctx, data, dataLen);
}
#endif /* HITLS_TLS_PROTO_TLS13 */
void ALERT_ClearWarnCount(TLS_Ctx *ctx)
{
ctx->alertCtx->warnCount = 0;
return;
}
bool ALERT_HaveExceeded(TLS_Ctx *ctx, uint8_t threshold)
{
ctx->alertCtx->warnCount += 1;
return ctx->alertCtx->warnCount >= threshold;
}
#ifdef HITLS_BSL_LOG
int32_t ReturnAlertProcess(TLS_Ctx *ctx, int32_t err, uint32_t logId, const void *logStr,
ALERT_Description description)
{
if (logStr != NULL) {
BSL_LOG_BINLOG_FIXLEN(logId, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, logStr, 0, 0, 0, 0);
}
if (description != ALERT_UNKNOWN) {
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, description);
}
return err;
}
int32_t ReturnErrorNumberProcess(int32_t err, uint32_t logId, const void *logStr)
{
(void)logStr;
BSL_LOG_BINLOG_FIXLEN(logId, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, logStr, 0, 0, 0, 0);
return err;
}
#endif /* HITLS_BSL_LOG */
|
2301_79861745/bench_create
|
tls/alert/src/alert.c
|
C
|
unknown
| 10,275
|
/*
* 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 APP_H
#define APP_H
#include <stdint.h>
#include "hitls_build.h"
#include "tls.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @ingroup app
* @brief TLS can read data of any length, not in the unit of record. DTLS can read data in the unit of record.
* Reads num bytes from the CTX to the buffer. Users can transfer any num bytes (num must be greater than 0).
*
* @attention Reads only the application data decrypted by one record at a time.
* HITLS copies the application data to the input cache.
* If the cache size is less than 16K, the maximum size of the application message decrypted from a single record is 16K
* This will result in a partial copy of the application data.
* You can call APP_GetReadPendingBytes to obtain the size of the remaining readable application data in current record.
* This is useful in DTLS scenarios.
*
* @param ctx [IN] TLS context
* @param buf [OUT] Place the data which read from the TLS context into the buffer.
* @param num [IN] Attempting to read num bytes
* @param readLen [OUT] Read length
*
* @retval HITLS_SUCCESS Read successful.
* @retval Other return value refers to REC_Read.
*/
int32_t APP_Read(TLS_Ctx *ctx, uint8_t *buf, uint32_t num, uint32_t *readLen);
/**
* @ingroup app
* @brief Obtain the maximum writable plaintext length of a single record.
*
* @param ctx [IN] TLS_Ctx context
* @param len [OUT] Maximum length of the plaintext
*
* @retval HITLS_SUCCESS Obtain successful.
* @retval Other return value refers to REC_GetMaxWriteSize.
*/
int32_t APP_GetMaxWriteSize(const TLS_Ctx *ctx, uint32_t *len);
/**
* @ingroup app
* @brief Send app message in the unit of record.
*
* @param ctx [IN] TLS context
* @param data [IN] Data to be written
* @param dataLen [IN] Data length
* @param writeLen [OUT] Length of Successful Writes
*
* @retval HITLS_SUCCESS Write successful.
* @retval HITLS_APP_ERR_TOO_LONG_TO_WRITE The data to be written is too long.
* @retval Other reuturn value referst to REC_Write.
*/
int32_t APP_Write(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t *writeLen);
#ifdef __cplusplus
}
#endif
#endif
|
2301_79861745/bench_create
|
tls/app/include/app.h
|
C
|
unknown
| 2,688
|
/*
* 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_sal.h"
#include "bsl_list.h"
#include "tls_binlog_id.h"
#include "bsl_uio.h"
#include "bsl_log_internal.h"
#include "bsl_log.h"
#include "bsl_err_internal.h"
#include "hitls_error.h"
#include "rec.h"
#include "app_ctx.h"
#include "rec.h"
#include "record.h"
#include "app.h"
static int32_t ReadAppData(TLS_Ctx *ctx, uint8_t *buf, uint32_t num, uint32_t *readLen)
{
return REC_Read(ctx, REC_TYPE_APP, buf, readLen, num);
}
int32_t APP_Read(TLS_Ctx *ctx, uint8_t *buf, uint32_t num, uint32_t *readLen)
{
int32_t ret;
uint32_t readbytes;
if (ctx == NULL || buf == NULL || num == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15659, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"APP: input null pointer or read bufLen is 0.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_APP_ERR_ZERO_READ_BUF_LEN);
return HITLS_APP_ERR_ZERO_READ_BUF_LEN;
}
// read data to the buffer in non-blocking mode
do {
ret = ReadAppData(ctx, buf, num, &readbytes);
if (ret != HITLS_SUCCESS) {
return ret;
}
} while (readbytes == 0); // do not exit the loop until data is read
*readLen = readbytes;
return HITLS_SUCCESS;
}
int32_t APP_GetMaxWriteSize(const TLS_Ctx *ctx, uint32_t *len)
{
return REC_GetMaxWriteSize(ctx, len);
}
static int32_t SavePendingData(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen)
{
#ifdef HITLS_TLS_PROTO_DTLS
if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
return HITLS_SUCCESS;
}
#endif
RecCtx *recCtx = (RecCtx *)ctx->recCtx;
// Stores the plaintext data to be sent.
recCtx->pendingData = data;
recCtx->pendingDataSize = dataLen;
return HITLS_SUCCESS;
}
static int32_t CheckDataLen(TLS_Ctx *ctx, const uint8_t *data, uint32_t *sendLen)
{
RecCtx *recCtx = (RecCtx *)ctx->recCtx;
if (recCtx->pendingData != NULL) {
if ((
#ifdef HITLS_TLS_FEATURE_MODE_ACCEPT_MOVING_WRITE_BUFFER
(ctx->config.tlsConfig.modeSupport & HITLS_MODE_ACCEPT_MOVING_WRITE_BUFFER) == 0 &&
#endif
recCtx->pendingData != data) || recCtx->pendingDataSize > *sendLen) {
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16241, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"The two buffer addresses are inconsistent.", 0, 0, 0, 0);
return HITLS_APP_ERR_WRITE_BAD_RETRY;
}
*sendLen = recCtx->pendingDataSize;
return HITLS_SUCCESS;
}
uint32_t maxWriteLen = 0u;
int32_t ret = REC_GetMaxWriteSize(ctx, &maxWriteLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15660, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"APP: Get record max write size fail.", 0, 0, 0, 0);
return ret;
}
if (*sendLen > maxWriteLen) {
*sendLen = maxWriteLen;
}
return SavePendingData(ctx, data, *sendLen);
}
int32_t APP_Write(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen, uint32_t *writeLen)
{
int32_t ret = HITLS_SUCCESS;
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
ret = REC_QueryMtu(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif /* HITLS_TLS_PROTO_DTLS12 && HITLS_BSL_UIO_UDP */
ret = REC_RecOutBufReSet(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint32_t sendLen = dataLen;
ret = CheckDataLen(ctx, data, &sendLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
*writeLen = 0;
ret = REC_Write(ctx, REC_TYPE_APP, data, sendLen);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16274, "Write fail");
}
#ifdef HITLS_TLS_FEATURE_FLIGHT
if (ctx->config.tlsConfig.isFlightTransmitEnable) {
ret = REC_FlightTransmit(ctx);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif
*writeLen = sendLen;
ctx->recCtx->pendingData = NULL;
ctx->recCtx->pendingDataSize = 0;
return HITLS_SUCCESS;
}
|
2301_79861745/bench_create
|
tls/app/src/app.c
|
C
|
unknown
| 4,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.
*/
#ifndef APP_CTX_H
#define APP_CTX_H
#include <stdint.h>
#include "hitls_build.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef HITLS_TLS_FEATURE_RENEGOTIATION
/**
* @ingroup hitls_cert_type
* @brief Describe the APP cache linked list.
*/
typedef struct BslList AppList;
#endif
typedef struct {
uint8_t *buf; /* buffer */
uint32_t bufSize; /* size of the buffer */
uint32_t start; /* start position */
uint32_t end; /* end position */
} AppBuf;
#ifdef __cplusplus
}
#endif
#endif
|
2301_79861745/bench_create
|
tls/app/src/app_ctx.h
|
C
|
unknown
| 1,066
|
/*
* 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 CHANGE_CIPHER_SPEC_H
#define CHANGE_CIPHER_SPEC_H
#include <stdint.h>
#include "hitls_build.h"
#include "tls.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @ingroup change cipher spec
* @brief CCS initialization function
*
* @param ctx [IN] SSL context
*
* @retval HITLS_SUCCESS Initializition successful.
* @retval HITLS_INTERNAL_EXCEPTION An unexpected internal error occurs.
* @retval HITLS_MEMALLOC_FAIL Failed to apply for memory.
*/
int32_t CCS_Init(TLS_Ctx *ctx);
/**
* @ingroup change cipher spec
* @brief CCS deinitialization function
*
* @param ctx [IN] ssl context
*
*/
void CCS_DeInit(TLS_Ctx *ctx);
/**
* @ingroup change cipher spec
* @brief Check whether the Change cipher spec message is received.
*
* @param ctx [IN] TLS context
*
* @retval True if the Change cipher spec message is received else false.
*/
bool CCS_IsRecv(const TLS_Ctx *ctx);
/**
* @ingroup change cipher spec
* @brief Send a packet for changing the cipher suite.
*
* @param ctx [IN] TLS context
*
* @retval HITLS_SUCCESS Send successful.
* @retval HITLS_INTERNAL_EXCEPTION An unexpected internal error occurs.
* @retval For other error codes, see REC_Write.
*/
int32_t CCS_Send(TLS_Ctx *ctx);
/**
* @ingroup change cipher spec
* @brief Control function
*
* @param ctx [IN] TLS context
* @param cmd [IN] Control command
*
* @retval HITLS_SUCCESS succeeded.
* @retval HITLS_INTERNAL_EXCEPTION An unexpected internal error
* @retval HITLS_CCS_INVALID_CMD Invalid instruction
*/
int32_t CCS_Ctrl(TLS_Ctx *ctx, CCS_Cmd cmd);
/**
* @brief Process CCS message after decryption
*
* @attention ctx cannot be empty.
* @param ctx [IN] tls Context
* @param data [IN] ccs data
* @param dataLen [IN] ccs data length
* @retval HITLS_REC_NORMAL_RECV_UNEXPECT_MSG
*/
int32_t ProcessDecryptedCCS(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen);
/**
* @brief Process plaintext CCS message in TLS13
*
* @attention ctx cannot be empty.
* @param ctx [IN] tls Context
* @param data [IN] ccs data
* @param dataLen [IN] ccs data length
* @retval HITLS_REC_NORMAL_RECV_UNEXPECT_MSG
*/
int32_t ProcessPlainCCS(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen);
#ifdef __cplusplus
}
#endif
#endif
|
2301_79861745/bench_create
|
tls/ccs/include/change_cipher_spec.h
|
C
|
unknown
| 2,864
|
/*
* 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_sal.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 "bsl_uio.h"
#include "uio_base.h"
#include "rec.h"
#ifdef HITLS_TLS_FEATURE_INDICATOR
#include "indicator.h"
#endif
#include "hs.h"
#include "alert.h"
#include "change_cipher_spec.h"
struct CcsCtx {
bool isReady; /* Whether to allow receiving CCS */
bool ccsRecvflag; /* Indicates whether the CCS is received. */
bool isAllowActiveCipher; /* Flag for allow activating the receiving key suite */
bool activeCipherFlag; /* Flag for activating the receiving key suite */
};
bool CCS_IsRecv(const TLS_Ctx *ctx)
{
return ctx->ccsCtx->ccsRecvflag;
}
int32_t CCS_Send(TLS_Ctx *ctx)
{
int32_t ret;
const uint8_t buf[1] = {1u};
const uint32_t len = 1u;
if (ctx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15616, 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;
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_SCTP) && defined(HITLS_TLS_FEATURE_RENEGOTIATION)
/* rfc6083 4.7. Handshake
Before sending a ChangeCipherSpec message, all outstanding SCTP user
messages MUST have been acknowledged by the SCTP peer and MUST NOT be
revoked by the SCTP peer. */
if (BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_SCTP) && ctx->negotiatedInfo.isRenegotiation) {
bool isBuffEmpty = false;
ret = BSL_UIO_Ctrl(ctx->uio, BSL_UIO_SCTP_SND_BUFF_IS_EMPTY, (int32_t)sizeof(isBuffEmpty), &isBuffEmpty);
if (ret != BSL_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16275, BSL_LOG_LEVEL_FATAL, BSL_LOG_BINLOG_TYPE_RUN,
"UIO_Ctrl fail, ret %d", ret, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_UIO_FAIL);
return HITLS_UIO_FAIL;
}
/* When the SCTP sending buffer is not empty, the CCS cannot be sent. */
if (isBuffEmpty != true) {
BSL_ERR_PUSH_ERROR(HITLS_REC_NORMAL_IO_BUSY);
return HITLS_REC_NORMAL_IO_BUSY;
}
}
#endif
/** Write record */
ret = REC_Write(ctx, REC_TYPE_CHANGE_CIPHER_SPEC, buf, len);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16276, "Write fail");
}
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask) &&
BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_UDP)) {
ret = REC_RetransmitListAppend(ctx->recCtx, REC_TYPE_CHANGE_CIPHER_SPEC, buf, len);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif
#ifdef HITLS_TLS_FEATURE_INDICATOR
INDICATOR_MessageIndicate(1, HS_GetVersion(ctx), REC_TYPE_CHANGE_CIPHER_SPEC, buf, 1,
ctx, ctx->config.tlsConfig.msgArg);
#endif
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15617, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"written a change cipher spec message.", 0, 0, 0, 0);
return HITLS_SUCCESS;
}
int32_t CCS_Ctrl(TLS_Ctx *ctx, CCS_Cmd cmd)
{
if (ctx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15618, 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;
}
switch (cmd) {
case CCS_CMD_RECV_READY:
ctx->ccsCtx->isReady = true;
break;
case CCS_CMD_RECV_EXIT_READY:
ctx->ccsCtx->isReady = false;
ctx->ccsCtx->ccsRecvflag = false;
ctx->ccsCtx->isAllowActiveCipher = false;
ctx->ccsCtx->activeCipherFlag = false;
break;
case CCS_CMD_RECV_ACTIVE_CIPHER_SPEC:
ctx->ccsCtx->isAllowActiveCipher = true;
if (ctx->ccsCtx->ccsRecvflag == true && ctx->ccsCtx->activeCipherFlag == false) {
/** Enable key specification */
int32_t ret = REC_ActivePendingState(ctx, false);
if (ret != HITLS_SUCCESS) {
ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_INTERNAL_ERROR);
return ret;
}
ctx->ccsCtx->activeCipherFlag = true;
}
break;
default:
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15619, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ChangeCipherSpec error ctrl cmd", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CCS_INVALID_CMD);
return HITLS_CCS_INVALID_CMD;
}
return HITLS_SUCCESS;
}
int32_t CCS_Init(TLS_Ctx *ctx)
{
if (ctx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15620, 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;
}
// Prevent the ctx->ccsCtx from being initialized multiple times.
if (ctx->ccsCtx != NULL) {
return HITLS_SUCCESS;
}
ctx->ccsCtx = (struct CcsCtx *)BSL_SAL_Malloc(sizeof(struct CcsCtx));
if (ctx->ccsCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15621, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ccs ctx malloc failed.", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
(void)memset_s(ctx->ccsCtx, sizeof(struct CcsCtx), 0, sizeof(struct CcsCtx));
return HITLS_SUCCESS;
}
void CCS_DeInit(TLS_Ctx *ctx)
{
if (ctx == NULL) {
return;
}
BSL_SAL_FREE(ctx->ccsCtx);
return;
}
int32_t ProcessPlainCCS(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen)
{
if (ctx->ccsCtx->isReady == false) {
#if defined(HITLS_TLS_PROTO_DTLS12) && defined(HITLS_BSL_UIO_UDP)
if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask) &&
BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_UDP)) {
ctx->rwstate = HITLS_READING;
return HITLS_REC_NORMAL_RECV_BUF_EMPTY;
}
#endif
return RETURN_ALERT_PROCESS(ctx, HITLS_REC_NORMAL_RECV_UNEXPECT_MSG, BINLOG_ID15612,
"recv unexpected ccs msg", ALERT_UNEXPECTED_MESSAGE);
}
/** The read length is abnormal. */
if (dataLen != 1u) {
return RETURN_ALERT_PROCESS(ctx, HITLS_REC_NORMAL_RECV_UNEXPECT_MSG, BINLOG_ID15613,
"ccs msg length err", ALERT_UNEXPECTED_MESSAGE);
}
/** Message exception. */
if (data[0] != 1u) {
return RETURN_ALERT_PROCESS(ctx, HITLS_REC_NORMAL_RECV_UNEXPECT_MSG, BINLOG_ID15614,
"ccs msg err", ALERT_UNEXPECTED_MESSAGE);
}
/** Multiple generate ccs messages are received: If UDP transmission is used, ignore the ccs. */
if (ctx->ccsCtx->ccsRecvflag == true && !BSL_UIO_GetUioChainTransportType(ctx->uio, BSL_UIO_UDP) &&
HS_GetVersion(ctx) != HITLS_VERSION_TLS13) {
return RETURN_ALERT_PROCESS(ctx, HITLS_REC_NORMAL_RECV_UNEXPECT_MSG, BINLOG_ID16277,
"Multiple generate ccs msg are received", ALERT_UNEXPECTED_MESSAGE);
}
if (ctx->ccsCtx->isAllowActiveCipher == true && ctx->ccsCtx->activeCipherFlag == false) {
/** Enable key specification */
if (REC_ActivePendingState(ctx, false) != HITLS_SUCCESS) {
return RETURN_ALERT_PROCESS(ctx, HITLS_REC_NORMAL_RECV_UNEXPECT_MSG, BINLOG_ID16278,
"ActivePendingState err", ALERT_INTERNAL_ERROR);
}
ctx->ccsCtx->activeCipherFlag = true;
}
ctx->ccsCtx->ccsRecvflag = true;
#ifdef HITLS_TLS_FEATURE_INDICATOR
INDICATOR_MessageIndicate(0, HS_GetVersion(ctx), REC_TYPE_CHANGE_CIPHER_SPEC, data, 1,
ctx, ctx->config.tlsConfig.msgArg);
#endif
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15615, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"got a change cipher spec message.", 0, 0, 0, 0);
#ifdef HITLS_TLS_SUITE_CIPHER_CBC
ctx->negotiatedInfo.isEncryptThenMacRead = ctx->negotiatedInfo.isEncryptThenMac;
#endif
return HITLS_REC_NORMAL_RECV_UNEXPECT_MSG;
}
int32_t ProcessDecryptedCCS(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen)
{
#ifdef HITLS_TLS_PROTO_TLS13
if (HS_GetVersion(ctx) == HITLS_VERSION_TLS13) {
return RETURN_ALERT_PROCESS(ctx, HITLS_REC_NORMAL_RECV_UNEXPECT_MSG, BINLOG_ID15612,
"recv encrypted ccs msg", ALERT_UNEXPECTED_MESSAGE);
}
#endif
return ProcessPlainCCS(ctx, data, dataLen);
}
|
2301_79861745/bench_create
|
tls/ccs/src/change_cipher_spec.c
|
C
|
unknown
| 9,066
|
/*
* 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 "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_list.h"
#include "hitls_error.h"
#include "hitls_cert_reg.h"
#include "hitls_security.h"
#include "tls.h"
#ifdef HITLS_TLS_FEATURE_SECURITY
#include "security.h"
#endif
#include "cert_mgr_ctx.h"
#include "cert_method.h"
#include "cert_mgr.h"
#include "cert.h"
#include "config_type.h"
#include "pack.h"
#include "custom_extensions.h"
#ifdef HITLS_TLS_FEATURE_SECURITY
static int32_t CheckKeySecbits(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert, HITLS_CERT_Key *key)
{
int32_t ret;
int32_t secBits = 0;
HITLS_Config *config = &ctx->config.tlsConfig;
ret = SAL_CERT_KeyCtrl(config, key, CERT_KEY_CTRL_GET_SECBITS, NULL, (void *)&secBits);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16303, "GET_SECBITS fail");
}
ret = SECURITY_SslCheck((HITLS_Ctx *)ctx, HITLS_SECURITY_SECOP_EE_KEY, secBits, 0, cert);
if (ret != SECURITY_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16304, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SslCheck fail, ret %d", ret, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CERT_ERR_EE_KEY_WITH_INSECURE_SECBITS);
ctx->method.sendAlert((TLS_Ctx *)ctx, ALERT_LEVEL_FATAL, ALERT_INSUFFICIENT_SECURITY);
return HITLS_CERT_ERR_EE_KEY_WITH_INSECURE_SECBITS;
}
return HITLS_SUCCESS;
}
#endif
CERT_Type CertKeyType2CertType(HITLS_CERT_KeyType keyType)
{
switch (keyType) {
case TLS_CERT_KEY_TYPE_RSA:
case TLS_CERT_KEY_TYPE_RSA_PSS:
return CERT_TYPE_RSA_SIGN;
case TLS_CERT_KEY_TYPE_DSA:
return CERT_TYPE_DSS_SIGN;
case TLS_CERT_KEY_TYPE_SM2:
case TLS_CERT_KEY_TYPE_ECDSA:
case TLS_CERT_KEY_TYPE_ED25519:
return CERT_TYPE_ECDSA_SIGN;
default:
break;
}
return CERT_TYPE_UNKNOWN;
}
HITLS_CERT_KeyType SAL_CERT_SignScheme2CertKeyType(const HITLS_Ctx *ctx, HITLS_SignHashAlgo signScheme)
{
const TLS_SigSchemeInfo *info = ConfigGetSignatureSchemeInfo(&ctx->config.tlsConfig, signScheme);
if (info == NULL) {
return TLS_CERT_KEY_TYPE_UNKNOWN;
}
return info->keyType;
}
HITLS_SignHashAlgo SAL_CERT_GetDefaultSignHashAlgo(HITLS_CERT_KeyType keyType)
{
switch (keyType) {
case TLS_CERT_KEY_TYPE_RSA:
return CERT_SIG_SCHEME_RSA_PKCS1_SHA1;
case TLS_CERT_KEY_TYPE_RSA_PSS:
return CERT_SIG_SCHEME_RSA_PSS_PSS_SHA256;
case TLS_CERT_KEY_TYPE_DSA:
return CERT_SIG_SCHEME_DSA_SHA1;
case TLS_CERT_KEY_TYPE_ECDSA:
return CERT_SIG_SCHEME_ECDSA_SHA1;
case TLS_CERT_KEY_TYPE_ED25519:
return CERT_SIG_SCHEME_ED25519;
#ifdef HITLS_TLS_PROTO_TLCP11
case TLS_CERT_KEY_TYPE_SM2:
return CERT_SIG_SCHEME_SM2_SM3;
#endif
default:
break;
}
return CERT_SIG_SCHEME_UNKNOWN;
}
int32_t CheckCertType(CERT_Type expectCertType, HITLS_CERT_KeyType checkedKeyType)
{
if (expectCertType == CERT_TYPE_UNKNOWN) {
/* The certificate type is not specified. This check is not required. */
return HITLS_SUCCESS;
}
/* Convert the key type to the certificate type. */
CERT_Type checkedCertType = CertKeyType2CertType(checkedKeyType);
if (expectCertType != checkedCertType) {
BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_CERT);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15034, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"unexpect cert: expect cert type = %u, checked key type = %u.", expectCertType, checkedKeyType, 0, 0);
return HITLS_MSG_HANDLE_UNSUPPORT_CERT;
}
return HITLS_SUCCESS;
}
static bool IsSignSchemeExist(const uint16_t *signSchemeList, uint32_t signSchemeNum, HITLS_SignHashAlgo signScheme)
{
for (uint32_t i = 0; i < signSchemeNum; i++) {
if (signSchemeList[i] == signScheme) {
return true;
}
}
return false;
}
typedef struct {
uint32_t baseSignAlgorithmsSize;
const uint16_t *baseSignAlgorithms;
uint32_t selectSignAlgorithmsSize;
const uint16_t *selectSignAlgorithms;
} SelectSignAlgorithms;
static int32_t CheckSelectSignAlgorithms(TLS_Ctx *ctx, const SelectSignAlgorithms *select,
HITLS_CERT_KeyType checkedKeyType, HITLS_CERT_Key *pubkey, bool isNegotiateSignAlgo)
{
uint32_t baseSignAlgorithmsSize = select->baseSignAlgorithmsSize;
const uint16_t *baseSignAlgorithms = select->baseSignAlgorithms;
uint32_t selectSignAlgorithmsSize = select->selectSignAlgorithmsSize;
const uint16_t *selectSignAlgorithms = select->selectSignAlgorithms;
const TLS_SigSchemeInfo *info = NULL;
(void)pubkey;
#ifdef HITLS_TLS_PROTO_TLS13
int32_t paraId = 0;
(void)SAL_CERT_KeyCtrl(&ctx->config.tlsConfig, pubkey, CERT_KEY_CTRL_GET_PARAM_ID, NULL, (void *)¶Id);
#endif
for (uint32_t i = 0; i < baseSignAlgorithmsSize; i++) {
info = ConfigGetSignatureSchemeInfo(&ctx->config.tlsConfig, baseSignAlgorithms[i]);
if (info == NULL || info->keyType != (int32_t)checkedKeyType) {
continue;
}
#ifdef HITLS_TLS_PROTO_TLS13
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLS13 && info->paraId != 0 && info->paraId != paraId) {
continue;
}
#endif
if (!IsSignSchemeExist(selectSignAlgorithms, selectSignAlgorithmsSize, baseSignAlgorithms[i])) {
/* The signature algorithm must be the same as the algorithm configured on the peer end. */
continue;
}
#ifdef HITLS_TLS_FEATURE_SECURITY
if (SECURITY_SslCheck(ctx, HITLS_SECURITY_SECOP_SIGALG_CHECK, 0, baseSignAlgorithms[i],
NULL) != SECURITY_SUCCESS) {
continue;
}
#endif
if (!isNegotiateSignAlgo) {
/* Only the signature algorithm in the certificate is checked.
The signature algorithm in the handshake message is not negotiated. */
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_PROTO_TLS13
const uint32_t rsaPkcsv15Mask = 0x01;
const uint32_t dsaMask = 0x02;
const uint32_t sha1Mask = 0x0200;
const uint32_t sha224Mask = 0x0300;
/* rfc8446 4.2.3. Signature Algorithms */
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLS13) {
if (((baseSignAlgorithms[i] & 0xff) == rsaPkcsv15Mask) ||
((baseSignAlgorithms[i] & 0xff) == dsaMask) ||
((baseSignAlgorithms[i] & 0xff00) == sha1Mask) ||
((baseSignAlgorithms[i] & 0xff00) == sha224Mask)) {
/* not defined for use in signed TLS handshake messages in TLS1.3 */
continue;
}
}
#endif
ctx->negotiatedInfo.signScheme = baseSignAlgorithms[i];
return HITLS_SUCCESS;
}
BSL_ERR_PUSH_ERROR(HITLS_CERT_ERR_NO_SIGN_SCHEME_MATCH);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15981, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"unexpect cert: no available signature scheme, key type = %u.", checkedKeyType, 0, 0, 0);
return HITLS_CERT_ERR_NO_SIGN_SCHEME_MATCH;
}
static int32_t CheckSignScheme(TLS_Ctx *ctx, const uint16_t *signSchemeList, uint32_t signSchemeNum,
HITLS_CERT_KeyType checkedKeyType, HITLS_CERT_Key *pubkey, bool isNegotiateSignAlgo)
{
if (signSchemeList == NULL) {
if (!isNegotiateSignAlgo) {
/* Do not save the signature algorithm used for sending handshake messages. */
return HITLS_SUCCESS;
}
/* No signature algorithm is specified.
The default signature algorithm is used when handshake messages are sent. */
HITLS_SignHashAlgo signScheme = SAL_CERT_GetDefaultSignHashAlgo(checkedKeyType);
if (signScheme == CERT_SIG_SCHEME_UNKNOWN
#ifdef HITLS_TLS_FEATURE_SECURITY
|| SECURITY_SslCheck(ctx, HITLS_SECURITY_SECOP_SIGALG_CHECK, 0, signScheme, NULL) != SECURITY_SUCCESS
#endif
) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16074, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"unexpect key type: no available signature scheme, key type = %u.", checkedKeyType, 0, 0, 0);
return HITLS_CERT_ERR_NO_SIGN_SCHEME_MATCH;
}
ctx->negotiatedInfo.signScheme = signScheme;
return HITLS_SUCCESS;
}
SelectSignAlgorithms select = { 0 };
bool supportServer = ctx->config.tlsConfig.isSupportServerPreference;
select.baseSignAlgorithmsSize = supportServer ? ctx->config.tlsConfig.signAlgorithmsSize : signSchemeNum;
select.baseSignAlgorithms = supportServer ? ctx->config.tlsConfig.signAlgorithms : signSchemeList;
select.selectSignAlgorithmsSize = supportServer ? signSchemeNum : ctx->config.tlsConfig.signAlgorithmsSize;
select.selectSignAlgorithms = supportServer ? signSchemeList : ctx->config.tlsConfig.signAlgorithms;
return CheckSelectSignAlgorithms(ctx, &select, checkedKeyType, pubkey, isNegotiateSignAlgo);
}
int32_t CheckCurveName(HITLS_Config *config, const uint16_t *curveList, uint32_t curveNum, HITLS_CERT_Key *pubkey)
{
uint32_t curveName = HITLS_NAMED_GROUP_BUTT;
int32_t ret = SAL_CERT_KeyCtrl(config, pubkey, CERT_KEY_CTRL_GET_CURVE_NAME, NULL, (void *)&curveName);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15036, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"internal error: unable to get curve name.", 0, 0, 0, 0);
return ret;
}
for (uint32_t i = 0; i < curveNum; i++) {
if (curveName == curveList[i]) {
return HITLS_SUCCESS;
}
}
BSL_ERR_PUSH_ERROR(HITLS_CERT_ERR_NO_CURVE_MATCH);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15037, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"unexpect cert: no curve match, which used %u.", curveName, 0, 0, 0);
return HITLS_CERT_ERR_NO_CURVE_MATCH;
}
int32_t CheckPointFormat(HITLS_Config *config, const uint8_t *ecPointFormatList, uint32_t listSize,
HITLS_CERT_Key *pubkey)
{
uint32_t ecPointFormat = HITLS_POINT_FORMAT_BUTT;
int32_t ret = SAL_CERT_KeyCtrl(config, pubkey, CERT_KEY_CTRL_GET_POINT_FORMAT, NULL, (void *)&ecPointFormat);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15038, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"internal error: unable to get point format.", 0, 0, 0, 0);
return ret;
}
for (uint32_t i = 0; i < listSize; i++) {
if (ecPointFormat == ecPointFormatList[i]) {
return HITLS_SUCCESS;
}
}
BSL_ERR_PUSH_ERROR(HITLS_CERT_ERR_NO_POINT_FORMAT_MATCH);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15039, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"unexpect cert: no point format match, which used %u.", ecPointFormat, 0, 0, 0);
return HITLS_CERT_ERR_NO_POINT_FORMAT_MATCH;
}
int32_t IsEcParamCompatible(HITLS_Config *config, const CERT_ExpectInfo *info, HITLS_CERT_Key *pubkey)
{
int32_t ret;
/* If the client has used a Supported Elliptic Curves Extension, the public key in the server's certificate MUST
respect the client's choice of elliptic curves */
if (info->ellipticCurveNum != 0) {
ret = CheckCurveName(config, info->ellipticCurveList, info->ellipticCurveNum, pubkey);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
if (info->ecPointFormatNum != 0) {
ret = CheckPointFormat(config, info->ecPointFormatList, info->ecPointFormatNum, pubkey);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
return HITLS_SUCCESS;
}
static int32_t CheckCertTypeAndSignScheme(HITLS_Ctx *ctx, const CERT_ExpectInfo *expectCertInfo, HITLS_CERT_Key *pubkey,
bool isNegotiateSignAlgo, bool signCheck)
{
HITLS_Config *config = &ctx->config.tlsConfig;
uint32_t keyType = TLS_CERT_KEY_TYPE_UNKNOWN;
int32_t ret = SAL_CERT_KeyCtrl(config, pubkey, CERT_KEY_CTRL_GET_TYPE, NULL, (void *)&keyType);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15041, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"check certificate error: pubkey type unknown.", 0, 0, 0, 0);
return ret;
}
ret = CheckCertType(expectCertInfo->certType, keyType);
if (ret != HITLS_SUCCESS) {
return ret;
}
if (signCheck == true) {
ret = CheckSignScheme(ctx, expectCertInfo->signSchemeList, expectCertInfo->signSchemeNum,
keyType, pubkey, isNegotiateSignAlgo);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
/* ECDSA certificate. The curve ID and point format must be checked.
TLS_CERT_KEY_TYPE_SM2 does not check the curve ID and point format. TLCP curves is sm2 and is not compressed. */
if (keyType == TLS_CERT_KEY_TYPE_ECDSA && ctx->negotiatedInfo.version != HITLS_VERSION_TLS13) {
ret = IsEcParamCompatible(config, expectCertInfo, pubkey);
}
return ret;
}
int32_t SAL_CERT_CheckCertInfo(HITLS_Ctx *ctx, const CERT_ExpectInfo *expectCertInfo, HITLS_CERT_X509 *cert,
bool isNegotiateSignAlgo, bool signCheck)
{
HITLS_Config *config = &ctx->config.tlsConfig;
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
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_ID15040, "get pubkey fail");
}
do {
#ifdef HITLS_TLS_FEATURE_SECURITY
ret = CheckKeySecbits(ctx, cert, pubkey);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16307, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CheckKeySecbits fail", 0, 0, 0, 0);
break;
}
#endif
ret = CheckCertTypeAndSignScheme(ctx, expectCertInfo, pubkey, isNegotiateSignAlgo, signCheck);
if (ret != HITLS_SUCCESS) {
break;
}
} while (false);
SAL_CERT_KeyFree(mgrCtx, pubkey);
return ret;
}
/*
* Server: Currently, two certificates are required for either of the two cipher suites supported.
* If the ECDHE cipher suite is used, the client needs to obtain the encrypted certificate to generate the premaster key
* and the signature certificate authenticates the identity.
* If the ECC cipher suite is used, the server public key is required to encrypt the premaster key
* and the signature certificate authentication is required.
* Client: Only the ECDHE cipher suite requires the client encryption certificate.
* In this case, the value of isNeedClientCert is true and may not be two-way authentication. (The specific value
* depends on the server configuration.)
* Therefore, the client does not verify any certificate and only sets the index.
* */
#ifdef HITLS_TLS_PROTO_TLCP11
static int32_t TlcpSelectCertByInfo(HITLS_Ctx *ctx, CERT_ExpectInfo *info)
{
int32_t encCertKeyType = TLS_CERT_KEY_TYPE_SM2;
CERT_MgrCtx *mgrCtx = ctx->config.tlsConfig.certMgrCtx;
CERT_Pair *certPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)encCertKeyType, (uintptr_t *)&certPair);
if (ret != HITLS_SUCCESS || certPair == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_SELECT_CERTIFICATE, BINLOG_ID17336,
"The certificate required by TLCP is not loaded");
}
HITLS_CERT_X509 *cert = certPair->cert;
HITLS_CERT_X509 *encCert = certPair->encCert;
if (ctx->isClient == false || ctx->negotiatedInfo.cipherSuiteInfo.kxAlg == HITLS_KEY_EXCH_ECDHE) {
if (cert == NULL || encCert == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_SELECT_CERTIFICATE, BINLOG_ID15042,
"The certificate required by TLCP is not loaded");
}
ret = SAL_CERT_CheckCertInfo(ctx, info, cert, true, true);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16308, "CheckCertInfo fail");
}
ret = SAL_CERT_CheckCertInfo(ctx, info, encCert, true, false);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16309, "CheckCertInfo fail");
}
} else {
/* Check whether the certificate is missing when the client sends the certificate
or sends it to the server for processing. Check whether the authentication-related signature certificate
or derived encryption certificate exists when the client uses the certificate. */
if (cert != NULL) {
ret = SAL_CERT_CheckCertInfo(ctx, info, cert, true, true);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16310, "CheckCertInfo fail");
}
}
if (encCert != NULL) {
ret = SAL_CERT_CheckCertInfo(ctx, info, encCert, true, false);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16311, "CheckCertInfo fail");
}
}
}
mgrCtx->currentCertKeyType = TLS_CERT_KEY_TYPE_SM2;
return HITLS_SUCCESS;
}
#endif
static int32_t SelectCertByInfo(HITLS_Ctx *ctx, CERT_ExpectInfo *info)
{
int32_t ret;
CERT_MgrCtx *mgrCtx = ctx->config.tlsConfig.certMgrCtx;
if (mgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_UNREGISTERED_CALLBACK);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID16312, "unregistered callback");
}
BSL_HASH_Hash *certPairs = mgrCtx->certPairs;
BSL_HASH_Iterator it = BSL_HASH_IterBegin(certPairs);
while (it != BSL_HASH_IterEnd(certPairs)) {
uint32_t keyType = (uint32_t)BSL_HASH_HashIterKey(certPairs, it);
CERT_Pair *certPair = (CERT_Pair *)BSL_HASH_IterValue(certPairs, it);
if (certPair == NULL || certPair->cert == NULL || certPair->privateKey == NULL) {
it = BSL_HASH_IterNext(certPairs, it);
continue;
}
ret = SAL_CERT_CheckCertInfo(ctx, info, certPair->cert, true, true);
if (ret != HITLS_SUCCESS) {
it = BSL_HASH_IterNext(certPairs, it);
continue;
}
/* Find a proper certificate and record the corresponding subscript. */
mgrCtx->currentCertKeyType = keyType;
return HITLS_SUCCESS;
}
return HITLS_CERT_ERR_SELECT_CERTIFICATE;
}
int32_t SAL_CERT_SelectCertByInfo(HITLS_Ctx *ctx, CERT_ExpectInfo *info)
{
int32_t ret = HITLS_SUCCESS;
CERT_MgrCtx *mgrCtx = ctx->config.tlsConfig.certMgrCtx;
if (mgrCtx == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID16313, "unregistered callback");
}
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
#ifdef HITLS_TLS_PROTO_TLCP11
ret = TlcpSelectCertByInfo(ctx, info);
#endif
} else {
ret = SelectCertByInfo(ctx, info);
}
if (ret == HITLS_SUCCESS) {
return ret;
}
BSL_ERR_PUSH_ERROR(HITLS_CERT_ERR_SELECT_CERTIFICATE);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16151, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"select certificate fail. ret %d", ret, 0, 0, 0);
mgrCtx->currentCertKeyType = TLS_CERT_KEY_TYPE_UNKNOWN;
return HITLS_CERT_ERR_SELECT_CERTIFICATE;
}
int32_t EncodeCertificate(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert, PackPacket *pkt, uint32_t certIndex)
{
if (ctx == NULL || pkt == NULL || cert == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16314, 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;
}
(void)certIndex;
int32_t ret;
HITLS_Config *config = &ctx->config.tlsConfig;
uint32_t certLen = 0;
ret = SAL_CERT_X509Ctrl(config, cert, CERT_CTRL_GET_ENCODE_LEN, NULL, (void *)&certLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15043, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode certificate error: unable to get encode length.", 0, 0, 0, 0);
return ret;
}
if (certLen == 0) {
BSL_ERR_PUSH_ERROR(HITLS_CERT_ERR_ENCODE_CERT);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15044, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"cert encode len is 0", 0, 0, 0, 0);
return HITLS_CERT_ERR_ENCODE_CERT;
}
/* Write the length of the certificate data (3 bytes). */
ret = PackAppendUint24ToBuf(pkt, certLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* Reserve space for certificate data and encode directly */
uint8_t *certBuf = NULL;
ret = PackReserveBytes(pkt, certLen, &certBuf);
if (ret != HITLS_SUCCESS) {
return ret;
}
uint32_t usedLen = 0;
/* Write the certificate data using the low-level encoding function */
ret = SAL_CERT_X509Encode(ctx, cert, certBuf, certLen, &usedLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16315, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "X509Encode err", 0, 0, 0, 0);
return ret;
}
ret = PackSkipBytes(pkt, usedLen);
if (ret != HITLS_SUCCESS) {
return ret;
}
#ifdef HITLS_TLS_PROTO_TLS13
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLS13) {
/* If an extension applies to the entire chain, it SHOULD be included in the first CertificateEntry. */
/* Start length field for extensions */
uint32_t exLenPos = 0;
ret = PackStartLengthField(pkt, sizeof(uint16_t), &exLenPos);
if (ret != HITLS_SUCCESS) {
return ret;
}
#ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
if (IsPackNeedCustomExtensions(CUSTOM_EXT_FROM_CTX(ctx), HITLS_EX_TYPE_TLS1_3_CERTIFICATE)) {
ret = PackCustomExtensions(ctx, pkt, HITLS_EX_TYPE_TLS1_3_CERTIFICATE, cert, certIndex);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
/* Close extension length field */
PackCloseUint16Field(pkt, exLenPos);
}
#endif
return HITLS_SUCCESS;
}
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 EncodeEECert(HITLS_Ctx *ctx, PackPacket *pkt, HITLS_CERT_X509 **cert)
{
CERT_MgrCtx *mgrCtx = ctx->config.tlsConfig.certMgrCtx;
CERT_Pair *currentCertPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)mgrCtx->currentCertKeyType, (uintptr_t *)¤tCertPair);
if (ret != HITLS_SUCCESS || currentCertPair == NULL || currentCertPair->cert == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_CERT_ERR_EXP_CERT);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_EXP_CERT, BINLOG_ID16152, "first cert is null");
}
HITLS_CERT_X509 *tmpCert = currentCertPair->cert;
#ifdef HITLS_TLS_FEATURE_SECURITY
HITLS_CERT_Key *key = currentCertPair->privateKey;
ret = CheckKeySecbits(ctx, tmpCert, key);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16317, "check key fail");
}
#endif
/* Write the first device certificate. */
ret = EncodeCertificate(ctx, tmpCert, pkt, 0);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16153, "encode fail");
}
#ifdef HITLS_TLS_PROTO_TLCP11
/* If the TLCP algorithm is used and the encryption certificate is required, write the
second encryption certificate. */
HITLS_CERT_X509 *certEnc = currentCertPair->encCert;
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11 && certEnc != NULL) {
#ifdef HITLS_TLS_FEATURE_SECURITY
HITLS_CERT_Key *keyEnc = currentCertPair->encPrivateKey;
ret = CheckKeySecbits(ctx, certEnc, keyEnc);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif
ret = EncodeCertificate(ctx, certEnc, pkt, 1);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16154, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"TLCP encode device certificate error.", 0, 0, 0, 0);
return ret;
}
}
#endif
*cert = tmpCert;
return HITLS_SUCCESS;
}
#ifdef HITLS_TLS_FEATURE_SECURITY
static int32_t CheckCertChainFromStore(HITLS_Config *config, HITLS_CERT_X509 *cert)
{
HITLS_CERT_Key *pubkey = NULL;
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
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(HITLS_CFG_ERR_LOAD_CERT_FILE, BINLOG_ID16318, "GET_PUB_KEY fail");
}
int32_t secBits = 0;
ret = SAL_CERT_KeyCtrl(config, pubkey, CERT_KEY_CTRL_GET_SECBITS, NULL, (void *)&secBits);
SAL_CERT_KeyFree(mgrCtx, pubkey);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16319, "GET_SECBITS fail");
}
ret = SECURITY_CfgCheck(config, HITLS_SECURITY_SECOP_CA_KEY, secBits, 0, cert); // cert key
if (ret != SECURITY_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16320, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"CfgCheck fail, ret %d", ret, 0, 0, 0);
return HITLS_CERT_ERR_CA_KEY_WITH_INSECURE_SECBITS;
}
int32_t signAlg = 0;
ret = SAL_CERT_X509Ctrl(config, cert, CERT_CTRL_GET_SIGN_ALGO, NULL, (void *)&signAlg);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16321, "GET_SIGN_ALGO fail");
}
ret = SECURITY_CfgCheck(config, HITLS_SECURITY_SECOP_SIGALG_CHECK, 0, signAlg, NULL);
if (ret != SECURITY_SUCCESS) {
return HITLS_CERT_ERR_INSECURE_SIG_ALG ;
}
return HITLS_SUCCESS;
}
#endif
static int32_t EncodeCertificateChain(HITLS_Ctx *ctx, PackPacket *pkt)
{
HITLS_CERT_X509 *tempCert = NULL;
HITLS_Config *config = &ctx->config.tlsConfig;
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
CERT_Pair *currentCertPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)mgrCtx->currentCertKeyType, (uintptr_t *)¤tCertPair);
if (ret != HITLS_SUCCESS || currentCertPair == NULL) {
return HITLS_SUCCESS;
}
HITLS_CERT_Chain *chain = NULL;
if (BSL_LIST_COUNT(currentCertPair->chain) > 0) {
chain = currentCertPair->chain;
} else {
chain = mgrCtx->extraChain;
}
tempCert = (HITLS_CERT_X509 *)BSL_LIST_GET_FIRST(chain);
uint32_t certIndex = 1;
while (tempCert != NULL) {
ret = EncodeCertificate(ctx, tempCert, pkt, certIndex);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID15048, "encode cert chain err");
}
certIndex++;
tempCert = BSL_LIST_GET_NEXT(chain);
}
return HITLS_SUCCESS;
}
static int32_t EncodeCertStore(HITLS_Ctx *ctx, PackPacket *pkt, HITLS_CERT_X509 *cert)
{
HITLS_Config *config = &ctx->config.tlsConfig;
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
HITLS_CERT_Store *store = (mgrCtx->chainStore != NULL) ? mgrCtx->chainStore : mgrCtx->certStore;
HITLS_CERT_X509 *certList[TLS_DEFAULT_VERIFY_DEPTH] = {0};
uint32_t certNum = TLS_DEFAULT_VERIFY_DEPTH;
if (store != NULL) {
int32_t ret = SAL_CERT_BuildChain(config, store, cert, certList, &certNum);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16322, "BuildChain fail");
}
/* The first device certificate has been written. The certificate starts from the second one. */
for (uint32_t i = 1; i < certNum; i++) {
#ifdef HITLS_TLS_FEATURE_SECURITY
ret = CheckCertChainFromStore(config, certList[i]);
if (ret != HITLS_SUCCESS) {
FreeCertList(certList, certNum);
return ret;
}
#endif
ret = EncodeCertificate(ctx, certList[i], pkt, i);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16155, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode cert chain error in No.%u.", i, 0, 0, 0);
FreeCertList(certList, certNum);
return ret;
}
}
}
FreeCertList(certList, certNum);
return HITLS_SUCCESS;
}
/*
* The constructed certificate chain is incomplete (excluding the root certificate).
* Therefore, in the buildCertChain callback, the return value is ignored, even if the error returned by this call.
* In fact, certificates are not verified but chains are constructed as many as possible.
* So do not need to invoke buildCertChain if the certificate is encrypted using the TLCP.
* If the TLCP is used, the server has checked that the two certificates are not empty.
* The client does not check, the message is sent based on the configuration.
* If the message will be sent, the signature certificate must exist.
* */
int32_t SAL_CERT_EncodeCertChain(HITLS_Ctx *ctx, PackPacket *pkt)
{
if (ctx == NULL || pkt == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_NULL_INPUT, BINLOG_ID16323, "input null");
}
HITLS_CERT_X509 *cert = NULL;
HITLS_Config *config = &ctx->config.tlsConfig;
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
if (mgrCtx == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID16324, "unregistered callback");
}
CERT_Pair *currentCertPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)mgrCtx->currentCertKeyType, (uintptr_t *)¤tCertPair);
if (ret != HITLS_SUCCESS || currentCertPair == NULL) {
/* No certificate needs to be sent at the local end. */
return HITLS_SUCCESS;
}
ret = EncodeEECert(ctx, pkt, &cert);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID15046, "encode device cert err");
}
// Check the size. If a certificate exists in the chain, directly put the data in the chain into the buf and return.
if (BSL_LIST_COUNT(currentCertPair->chain) > 0 || BSL_LIST_COUNT(mgrCtx->extraChain) > 0) {
return EncodeCertificateChain(ctx, pkt);
}
return EncodeCertStore(ctx, pkt, cert);
}
#ifdef HITLS_TLS_PROTO_TLS13
// rfc8446 4.4.2.4. Receiving a Certificate Message
// Any endpoint receiving any certificate which it would need to validate using any signature algorithm using an MD5
// hash MUST abort the handshake with a "bad_certificate" alert.
// Currently, the MD5 signature algorithm is not available, but it is still an unknown one.
int32_t CheckCertSignature(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert)
{
HITLS_Config *config = &ctx->config.tlsConfig;
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLS13) {
HITLS_SignHashAlgo signAlg = CERT_SIG_SCHEME_UNKNOWN;
const uint32_t md5Mask = 0x0100;
(void)SAL_CERT_X509Ctrl(config, cert, CERT_CTRL_GET_SIGN_ALGO, NULL, (void *)&signAlg);
if ((signAlg == CERT_SIG_SCHEME_UNKNOWN) || (((uint32_t)signAlg & 0xff00) == md5Mask)) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_CTRL_ERR_GET_SIGN_ALGO, BINLOG_ID16325, "signAlg unknow");
}
}
return HITLS_SUCCESS;
}
#endif
static void DestoryParseChain(HITLS_CERT_X509 *encCert, HITLS_CERT_X509 *cert, HITLS_CERT_Chain *newChain)
{
SAL_CERT_X509Free(encCert);
SAL_CERT_X509Free(cert);
SAL_CERT_ChainFree(newChain);
}
#ifdef HITLS_TLS_PROTO_TLCP11
static bool TlcpCheckSignCertKeyUsage(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert)
{
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
return SAL_CERT_CheckCertKeyUsage(ctx, cert, CERT_KEY_CTRL_IS_DIGITAL_SIGN_USAGE) ||
SAL_CERT_CheckCertKeyUsage(ctx, cert, CERT_KEY_CTRL_IS_NON_REPUDIATION_USAGE);
}
return true;
}
static bool TlcpCheckEncCertKeyUsage(HITLS_Ctx *ctx, HITLS_CERT_X509 *encCert)
{
if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
return SAL_CERT_CheckCertKeyUsage(ctx, encCert, CERT_KEY_CTRL_IS_KEYENC_USAGE) ||
SAL_CERT_CheckCertKeyUsage(ctx, encCert, CERT_KEY_CTRL_IS_DATA_ENC_USAGE) ||
SAL_CERT_CheckCertKeyUsage(ctx, encCert, CERT_KEY_CTRL_IS_KEY_AGREEMENT_USAGE);
}
return false;
}
#endif
int32_t ParseChain(HITLS_Ctx *ctx, CERT_Item *item, HITLS_CERT_Chain **chain, HITLS_CERT_X509 **encCert)
{
if (ctx == NULL || chain == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_NULL_INPUT, BINLOG_ID16326, "input null");
}
HITLS_CERT_X509 *encCertLocal = NULL;
HITLS_Config *config = &ctx->config.tlsConfig;
HITLS_CERT_Chain *newChain = SAL_CERT_ChainNew();
if (newChain == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMALLOC_FAIL, BINLOG_ID15049, "ChainNew fail");
}
CERT_Item *listNode = item;
while (listNode != NULL) {
HITLS_CERT_X509 *cert = SAL_CERT_X509Parse(LIBCTX_FROM_CONFIG(config),
ATTRIBUTE_FROM_CONFIG(config), config, listNode->data, listNode->dataSize,
TLS_PARSE_TYPE_BUFF, TLS_PARSE_FORMAT_ASN1);
if (cert == NULL) {
DestoryParseChain(encCertLocal, NULL, newChain);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_PARSE_MSG, BINLOG_ID15050, "parse cert chain err");
}
#ifdef HITLS_TLS_PROTO_TLS13
if (CheckCertSignature(ctx, cert) != HITLS_SUCCESS) {
DestoryParseChain(encCertLocal, cert, newChain);
return HITLS_CERT_CTRL_ERR_GET_SIGN_ALGO;
}
#endif
#ifdef HITLS_TLS_PROTO_TLCP11
if ((encCert != NULL) && (TlcpCheckEncCertKeyUsage(ctx, cert) == true)) {
SAL_CERT_X509Free(encCertLocal);
encCertLocal = cert;
listNode = listNode->next;
continue;
}
#endif
/* Add a certificate to the certificate chain. */
if (SAL_CERT_ChainAppend(newChain, cert) != HITLS_SUCCESS) {
DestoryParseChain(encCertLocal, cert, newChain);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMALLOC_FAIL, BINLOG_ID15051, "ChainAppend fail");
}
listNode = listNode->next;
}
if (encCert != NULL) {
*encCert = encCertLocal;
}
*chain = newChain;
return HITLS_SUCCESS;
}
int32_t SAL_CERT_ParseCertChain(HITLS_Ctx *ctx, CERT_Item *item, CERT_Pair **certPair)
{
if (ctx == NULL || item == NULL || certPair == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_NULL_INPUT, BINLOG_ID16327, "input null");
}
HITLS_CERT_X509 *encCert = NULL;
HITLS_Config *config = &ctx->config.tlsConfig;
if (config->certMgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_UNREGISTERED_CALLBACK);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID16328, "unregistered callback");
}
/* Parse the first device certificate. */
HITLS_CERT_X509 *cert = SAL_CERT_X509Parse(LIBCTX_FROM_CONFIG(config),
ATTRIBUTE_FROM_CONFIG(config), config, item->data, item->dataSize,
TLS_PARSE_TYPE_BUFF, TLS_PARSE_FORMAT_ASN1);
if (cert == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_PARSE_MSG, BINLOG_ID15052, "X509Parse fail");
}
#ifdef HITLS_TLS_PROTO_TLS13
if (CheckCertSignature(ctx, cert) != HITLS_SUCCESS) {
SAL_CERT_X509Free(cert);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_CTRL_ERR_GET_SIGN_ALGO, BINLOG_ID16329, "check signature fail");
}
#endif
#ifdef HITLS_TLS_PROTO_TLCP11
if (!TlcpCheckSignCertKeyUsage(ctx, cert)) {
SAL_CERT_X509Free(cert);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_KEYUSAGE, BINLOG_ID15341, "check sign cert keyusage fail");
}
#endif
/* Parse other certificates in the certificate chain. */
HITLS_CERT_Chain *chain = NULL;
HITLS_CERT_X509 **inParseEnc = ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11 ? &encCert : NULL;
int32_t ret = ParseChain(ctx, item->next, &chain, inParseEnc);
if (ret != HITLS_SUCCESS) {
SAL_CERT_X509Free(cert);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16330, "ParseChain fail");
}
CERT_Pair *newCertPair = BSL_SAL_Calloc(1u, sizeof(CERT_Pair));
if (newCertPair == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
SAL_CERT_X509Free(cert);
SAL_CERT_X509Free(encCert);
SAL_CERT_ChainFree(chain);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMALLOC_FAIL, BINLOG_ID15053, "Calloc fail");
}
newCertPair->cert = cert;
#ifdef HITLS_TLS_PROTO_TLCP11
newCertPair->encCert = encCert;
#endif
newCertPair->chain = chain;
*certPair = newCertPair;
return HITLS_SUCCESS;
}
int32_t SAL_CERT_VerifyCertChain(HITLS_Ctx *ctx, CERT_Pair *certPair, bool isTlcpEncCert)
{
(void)isTlcpEncCert;
if (ctx == NULL || certPair == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_NULL_INPUT, BINLOG_ID16331, "input null");
}
int32_t ret;
uint32_t i = 0;
HITLS_Config *config = &ctx->config.tlsConfig;
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
if (mgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_UNREGISTERED_CALLBACK);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID16332, "mgrCtx null");
}
HITLS_CERT_Chain *chain = certPair->chain;
/* Obtain the number of certificates. The first device certificate must also be included. */
uint32_t certNum = (uint32_t)(BSL_LIST_COUNT(chain) + 1);
HITLS_CERT_X509 **certList = (HITLS_CERT_X509 **)BSL_SAL_Calloc(1u, sizeof(HITLS_CERT_X509 *) * certNum);
if (certList == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMALLOC_FAIL, BINLOG_ID15054, "Calloc fail");
}
certList[i++] =
#ifdef HITLS_TLS_PROTO_TLCP11
isTlcpEncCert ? certPair->encCert :
#endif
certPair->cert;
HITLS_CERT_X509 *currCert = NULL;
for (uint32_t index = 0u; index < (certNum - 1); ++index) {
currCert = (HITLS_CERT_X509 *)BSL_LIST_GetIndexNode(index, chain);
certList[i++] = currCert;
}
/* Verify the certificate chain. */
HITLS_CERT_Store *store = (mgrCtx->verifyStore != NULL) ? mgrCtx->verifyStore : mgrCtx->certStore;
if (store == NULL) {
BSL_SAL_FREE(certList);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_VERIFY_CERT_CHAIN, BINLOG_ID16333, "Calloc fail");
}
ret = SAL_CERT_VerifyChain(ctx, store, certList, i);
BSL_SAL_FREE(certList);
return ret;
}
uint32_t SAL_CERT_GetSignMaxLen(HITLS_Config *config, HITLS_CERT_Key *key)
{
uint32_t len = 0;
int32_t ret = SAL_CERT_KeyCtrl(config, key, CERT_KEY_CTRL_GET_SIGN_LEN, NULL, &len);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15056, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"get signature length error: callback ret = 0x%x.", ret, 0, 0, 0);
return 0;
}
return len;
}
#ifdef HITLS_TLS_CONFIG_CERT_CALLBACK
int32_t HITLS_CFG_SetCheckPriKeyCb(HITLS_Config *config, CERT_CheckPrivateKeyCallBack checkPrivateKey)
{
if (config == NULL || config->certMgrCtx == NULL || checkPrivateKey == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
#ifndef HITLS_TLS_FEATURE_PROVIDER
config->certMgrCtx->method.checkPrivateKey = checkPrivateKey;
#endif
return HITLS_SUCCESS;
}
CERT_CheckPrivateKeyCallBack HITLS_CFG_GetCheckPriKeyCb(HITLS_Config *config)
{
if (config == NULL || config->certMgrCtx == NULL) {
return NULL;
}
#ifndef HITLS_TLS_FEATURE_PROVIDER
return config->certMgrCtx->method.checkPrivateKey;
#else
return NULL;
#endif
}
#endif /* HITLS_TLS_CONFIG_CERT_CALLBACK */
#ifdef HITLS_TLS_PROTO_TLCP11
static uint8_t *EncodeEncCert(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert, uint32_t *useLen)
{
if (ctx == NULL || cert == NULL || useLen == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16336, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return NULL;
}
uint32_t certLen;
HITLS_Config *config = &ctx->config.tlsConfig;
int32_t ret = SAL_CERT_X509Ctrl(config, cert, CERT_CTRL_GET_ENCODE_LEN, NULL, (void *)&certLen);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16157, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode gm enc certificate error: unable to get encode length.", 0, 0, 0, 0);
return NULL;
}
uint8_t *data = BSL_SAL_Calloc(1u, certLen);
if (data == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16158, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"signature data memory alloc fail.", 0, 0, 0, 0);
return NULL;
}
ret = SAL_CERT_X509Encode(ctx, cert, data, certLen, useLen);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(data);
BSL_ERR_PUSH_ERROR(HITLS_INTERNAL_EXCEPTION);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16232, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"encode cert error: callback ret = 0x%x.", (uint32_t)ret, 0, 0, 0);
return NULL;
}
return data;
}
uint8_t *SAL_CERT_SrvrGmEncodeEncCert(HITLS_Ctx *ctx, uint32_t *useLen)
{
if (ctx == NULL || useLen == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16337, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return NULL;
}
int keyType = TLS_CERT_KEY_TYPE_SM2;
CERT_MgrCtx *mgrCtx = ctx->config.tlsConfig.certMgrCtx;
CERT_Pair *currentCertPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)keyType, (uintptr_t *)¤tCertPair);
if (ret != HITLS_SUCCESS || currentCertPair == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17337, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "encCert null", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return NULL;
}
HITLS_CERT_X509 *cert = currentCertPair->encCert;
return EncodeEncCert(ctx, cert, useLen);
}
uint8_t *SAL_CERT_ClntGmEncodeEncCert(HITLS_Ctx *ctx, CERT_Pair *peerCert, uint32_t *useLen)
{
return EncodeEncCert(ctx, peerCert->encCert, useLen);
}
#endif
#if defined(HITLS_TLS_PROTO_TLCP11) || defined(HITLS_TLS_CONFIG_KEY_USAGE)
bool SAL_CERT_CheckCertKeyUsage(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert, HITLS_CERT_CtrlCmd keyusage)
{
if (ctx == NULL || cert == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16338, 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;
}
uint8_t isUsage = false;
if (keyusage != CERT_KEY_CTRL_IS_KEYENC_USAGE && keyusage != CERT_KEY_CTRL_IS_DIGITAL_SIGN_USAGE &&
keyusage != CERT_KEY_CTRL_IS_KEY_CERT_SIGN_USAGE && keyusage != CERT_KEY_CTRL_IS_KEY_AGREEMENT_USAGE &&
keyusage != CERT_KEY_CTRL_IS_DATA_ENC_USAGE && keyusage != CERT_KEY_CTRL_IS_NON_REPUDIATION_USAGE) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16339, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "keyusage err", 0, 0, 0, 0);
return (bool)isUsage;
}
HITLS_Config *config = &ctx->config.tlsConfig;
if (SAL_CERT_X509Ctrl(config, cert, keyusage, NULL, (void *)&isUsage) != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16340, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "%d fail", keyusage, 0, 0, 0);
return false;
}
return (bool)isUsage;
}
#endif
|
2301_79861745/bench_create
|
tls/cert/cert_adapt/cert.c
|
C
|
unknown
| 44,429
|
/*
* 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 "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 "hitls_error.h"
#include "cert_method.h"
#include "cert_mgr_ctx.h"
HITLS_CERT_Chain *SAL_CERT_ChainNew(void)
{
BslList *newChain = BSL_LIST_New(sizeof(HITLS_CERT_X509 *));
if (newChain == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15010, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"new cert chain error: out of memory.", 0, 0, 0, 0);
}
return newChain;
}
int32_t SAL_CERT_ChainAppend(HITLS_CERT_Chain *chain, HITLS_CERT_X509 *cert)
{
/* add the tail to the end of the certificate chain, corresponding to the top of the stack */
int32_t ret = BSL_LIST_AddElement(chain, cert, BSL_LIST_POS_END);
if (ret != BSL_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15011, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"append cert to chain error: out of memory.", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
return HITLS_SUCCESS;
}
static void CertChainInnerDestroyCb(void *cert)
{
SAL_CERT_X509Free((HITLS_CERT_X509 *)cert);
}
/* release the linked list without retaining the head node */
void SAL_CERT_ChainFree(HITLS_CERT_Chain *chain)
{
/* only certificates on the chain are destroyed, chain itself will be not destroyed */
BSL_LIST_DeleteAll(chain, CertChainInnerDestroyCb);
BSL_SAL_FREE(chain);
return;
}
/* copy the certificate chain */
HITLS_CERT_Chain *SAL_CERT_ChainDup(CERT_MgrCtx *mgrCtx, HITLS_CERT_Chain *chain)
{
int32_t ret;
uint32_t listSize = (uint32_t)BSL_LIST_COUNT(chain);
HITLS_CERT_X509 *dupCert = NULL;
HITLS_CERT_X509 *currCert = NULL;
if (BSL_LIST_COUNT(chain) < 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16070, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"dup cert chain error: list size tainted.", 0, 0, 0, 0);
return NULL;
}
BslList *newChain = SAL_CERT_ChainNew();
if (newChain == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15012, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"dup cert chain error: out of memory.", 0, 0, 0, 0);
return NULL;
}
for (uint32_t index = 0u; index < listSize; ++index) {
currCert = (HITLS_CERT_X509 *)BSL_LIST_GetIndexNode(index, chain);
if (currCert == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15002, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"dup cert error: currCert NULL.", 0, 0, 0, 0);
goto EXIT;
}
dupCert = SAL_CERT_X509Dup(mgrCtx, currCert);
if (dupCert == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15013, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"dup cert chain error: x509 dup error.", 0, 0, 0, 0);
goto EXIT;
}
ret = SAL_CERT_ChainAppend(newChain, dupCert);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15014, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"dup cert chain error: append new cert node error.", 0, 0, 0, 0);
SAL_CERT_X509Free(dupCert);
goto EXIT;
}
}
return newChain;
EXIT:
/* free the certificate chain */
SAL_CERT_ChainFree(newChain);
return NULL;
}
|
2301_79861745/bench_create
|
tls/cert/cert_adapt/cert_chain.c
|
C
|
unknown
| 3,956
|
/*
* 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 "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_reg.h"
#include "hitls_x509_adapt.h"
#ifdef HITLS_TLS_FEATURE_PROVIDER
#include "hitls_pki_x509.h"
#endif /* HITLS_TLS_FEATURE_PROVIDER */
#include "tls_config.h"
#include "tls.h"
#include "cert_mgr_ctx.h"
#include "cert_method.h"
#ifndef HITLS_TLS_FEATURE_PROVIDER
HITLS_CERT_MgrMethod g_certMgrMethod = {0};
static bool IsMethodValid(const HITLS_CERT_MgrMethod *method)
{
bool valid = method == NULL ||
method->certStoreNew == NULL ||
method->certStoreDup == NULL ||
method->certStoreFree == NULL ||
method->certStoreCtrl == NULL ||
method->buildCertChain == NULL ||
method->verifyCertChain == NULL ||
method->certEncode == NULL ||
method->certParse == NULL ||
method->certDup == NULL ||
method->certFree == NULL ||
method->certCtrl == NULL ||
method->keyParse == NULL ||
method->keyDup == NULL ||
method->keyFree == NULL ||
method->keyCtrl == NULL ||
method->createSign == NULL ||
method->verifySign == NULL ||
method->checkPrivateKey == NULL;
if (valid) {
return false;
}
return true;
}
int32_t HITLS_CERT_RegisterMgrMethod(HITLS_CERT_MgrMethod *method)
{
/* check the callbacks that must be set */
if (IsMethodValid(method) == false) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_NULL_INPUT, BINLOG_ID16108, "input NULL");
}
if (memcpy_s(&g_certMgrMethod, sizeof(HITLS_CERT_MgrMethod), method, sizeof(HITLS_CERT_MgrMethod)) != EOK) {
return HITLS_MEMCPY_FAIL;
}
return HITLS_SUCCESS;
}
void HITLS_CERT_DeinitMgrMethod(void)
{
HITLS_CERT_MgrMethod mgr = {0};
(void)memcpy_s(&g_certMgrMethod, sizeof(HITLS_CERT_MgrMethod), &mgr, sizeof(HITLS_CERT_MgrMethod));
}
HITLS_CERT_MgrMethod *SAL_CERT_GetMgrMethod(void)
{
return &g_certMgrMethod;
}
HITLS_CERT_MgrMethod *HITLS_CERT_GetMgrMethod(void)
{
return SAL_CERT_GetMgrMethod();
}
#endif /* HITLS_TLS_FEATURE_PROVIDER */
int32_t CheckCertCallBackRetVal(const char *logStr, 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.", logStr, callBackRet, 0, 0);
BSL_ERR_PUSH_ERROR((int32_t)hitlsRet);
return (int32_t)hitlsRet;
}
return HITLS_SUCCESS;
}
HITLS_CERT_Store *SAL_CERT_StoreNew(const CERT_MgrCtx *mgrCtx)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_X509_ProviderStoreCtxNew(LIBCTX_FROM_CERT_MGR_CTX(mgrCtx), ATTRIBUTE_FROM_CERT_MGR_CTX(mgrCtx));
#else
return mgrCtx->method.certStoreNew();
#endif
}
HITLS_CERT_Store *SAL_CERT_StoreDup(const CERT_MgrCtx *mgrCtx, HITLS_CERT_Store *store)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
(void)mgrCtx;
return HITLS_X509_Adapt_StoreDup(store);
#else
return mgrCtx->method.certStoreDup(store);
#endif
}
void SAL_CERT_StoreFree(const CERT_MgrCtx *mgrCtx, HITLS_CERT_Store *store)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
(void)mgrCtx;
return HITLS_X509_StoreCtxFree(store);
#else
mgrCtx->method.certStoreFree(store);
#endif
}
int32_t SAL_CERT_BuildChain(HITLS_Config *config, HITLS_CERT_Store *store, HITLS_CERT_X509 *cert,
HITLS_CERT_X509 **certList, uint32_t *num)
{
int32_t ret;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ret = HITLS_X509_Adapt_BuildCertChain(config, store, cert, certList, num);
#else
ret = config->certMgrCtx->method.buildCertChain(config, store, cert, certList, num);
#endif
return CheckCertCallBackRetVal("cert store build chain by cert", ret, BINLOG_ID16083, HITLS_CERT_ERR_BUILD_CHAIN);
}
int32_t SAL_CERT_VerifyChain(HITLS_Ctx *ctx, HITLS_CERT_Store *store, HITLS_CERT_X509 **certList, uint32_t num)
{
int32_t ret;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ret = HITLS_X509_Adapt_VerifyCertChain(ctx, store, certList, num);
#else
ret = ctx->config.tlsConfig.certMgrCtx->method.verifyCertChain(ctx, store, certList, num);
#endif
return CheckCertCallBackRetVal("cert store verify chain", ret, BINLOG_ID16084, HITLS_CERT_ERR_VERIFY_CERT_CHAIN);
}
int32_t SAL_CERT_X509Encode(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert, uint8_t *buf, uint32_t len, uint32_t *usedLen)
{
int32_t ret;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ret = HITLS_X509_Adapt_CertEncode(ctx, cert, buf, len, usedLen);
#else
ret = ctx->config.tlsConfig.certMgrCtx->method.certEncode(ctx, cert, buf, len, usedLen);
#endif
return CheckCertCallBackRetVal("encode cert", ret, BINLOG_ID16086, HITLS_CERT_ERR_ENCODE_CERT);
}
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)
{
(void)config;
return HITLS_X509_Adapt_BundleCertParse(libCtx, attrName, buf, len, type, SAL_CERT_GetParseFormatStr(format));
}
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)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
(void)config;
return HITLS_CERT_ProviderCertParse(libCtx, attrName, buf, len, type, SAL_CERT_GetParseFormatStr(format));
#else
(void)libCtx;
(void)attrName;
return config->certMgrCtx->method.certParse(config, buf, len, type, format);
#endif
}
HITLS_CERT_X509 *SAL_CERT_X509Dup(const CERT_MgrCtx *mgrCtx, HITLS_CERT_X509 *cert)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
(void)mgrCtx;
return (HITLS_CERT_X509 *)HITLS_X509_CertDup(cert);
#else
return mgrCtx->method.certDup(cert);
#endif
}
void SAL_CERT_X509Free(HITLS_CERT_X509 *cert)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
HITLS_X509_CertFree(cert);
#else
if (cert == NULL) {
return;
}
g_certMgrMethod.certFree(cert);
#endif
}
HITLS_CERT_X509 *SAL_CERT_X509Ref(const CERT_MgrCtx *mgrCtx, HITLS_CERT_X509 *cert)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
(void)mgrCtx;
return HITLS_X509_Adapt_CertRef(cert);
#else
if (mgrCtx->method.certRef == NULL) {
return NULL;
}
return mgrCtx->method.certRef(cert);
#endif
}
typedef struct {
const char *name;
HITLS_ParseFormat format;
} ParseFormatMap;
static const ParseFormatMap g_parseFormatMap[] = {
{"PEM", TLS_PARSE_FORMAT_PEM},
{"ASN1", TLS_PARSE_FORMAT_ASN1},
{"PFX_COM", TLS_PARSE_FORMAT_PFX_COM},
{"PKCS12", TLS_PARSE_FORMAT_PKCS12}
};
const char *SAL_CERT_GetParseFormatStr(HITLS_ParseFormat format)
{
for (size_t i = 0; i < sizeof(g_parseFormatMap) / sizeof(g_parseFormatMap[0]); i++) {
if (g_parseFormatMap[i].format == format) {
return g_parseFormatMap[i].name;
}
}
return NULL;
}
#ifndef HITLS_TLS_FEATURE_PROVIDER
static HITLS_ParseFormat GetTlsParseFormat(const char *format)
{
if (format == NULL) {
return TLS_PARSE_FORMAT_BUTT;
}
for (size_t i = 0; i < sizeof(g_parseFormatMap) / sizeof(g_parseFormatMap[0]); i++) {
if (BSL_SAL_StrcaseCmp(format, g_parseFormatMap[i].name) == 0) {
return g_parseFormatMap[i].format;
}
}
return TLS_PARSE_FORMAT_BUTT;
}
#endif
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)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_X509_Adapt_ProviderKeyParse(config, buf, len, type, format, encodeType);
#else
(void)encodeType;
return config->certMgrCtx->method.keyParse(config, buf, len, type, GetTlsParseFormat(format));
#endif
}
HITLS_CERT_Key *SAL_CERT_KeyDup(const CERT_MgrCtx *mgrCtx, HITLS_CERT_Key *key)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
(void)mgrCtx;
return (HITLS_CERT_Key *)CRYPT_EAL_PkeyDupCtx(key);
#else
return mgrCtx->method.keyDup(key);
#endif
}
void SAL_CERT_KeyFree(const CERT_MgrCtx *mgrCtx, HITLS_CERT_Key *key)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
(void)mgrCtx;
CRYPT_EAL_PkeyFreeCtx(key);
#else
if (key == NULL) {
return;
}
mgrCtx->method.keyFree(key);
#endif
}
/* change the error code when modifying the ctrl command */
static const struct {
HITLS_CERT_CtrlCmd cmd;
uint32_t err;
} g_tlsCertCtrlErrorCode[] = {
{ CERT_STORE_CTRL_SET_VERIFY_DEPTH, HITLS_CERT_STORE_CTRL_ERR_SET_VERIFY_DEPTH },
{ CERT_STORE_CTRL_ADD_CERT_LIST, HITLS_CERT_STORE_CTRL_ERR_ADD_CERT_LIST },
{ CERT_STORE_CTRL_ADD_CRL_LIST, HITLS_CERT_STORE_CTRL_ERR_ADD_CRL_LIST },
{ CERT_STORE_CTRL_CLEAR_CRL_LIST, HITLS_CERT_STORE_CTRL_ERR_CLEAR_CRL_LIST },
{ CERT_STORE_CTRL_GET_VERIFY_DEPTH, HITLS_CERT_STORE_CTRL_ERR_GET_VERIFY_DEPTH },
{ CERT_CTRL_GET_ENCODE_LEN, HITLS_CERT_CTRL_ERR_GET_ENCODE_LEN },
{ CERT_CTRL_GET_PUB_KEY, HITLS_CERT_CTRL_ERR_GET_PUB_KEY },
{ CERT_CTRL_GET_SIGN_ALGO, HITLS_CERT_CTRL_ERR_GET_SIGN_ALGO },
{ CERT_CTRL_GET_ENCODE_SUBJECT_DN, HITLS_CERT_CTRL_ERR_GET_SUBJECT_DN },
{ CERT_CTRL_IS_SELF_SIGNED, HITLS_CERT_CTRL_ERR_IS_SELF_SIGNED },
{ CERT_KEY_CTRL_GET_SIGN_LEN, HITLS_CERT_KEY_CTRL_ERR_GET_SIGN_LEN },
{ CERT_KEY_CTRL_GET_TYPE, HITLS_CERT_KEY_CTRL_ERR_GET_TYPE },
{ CERT_KEY_CTRL_GET_CURVE_NAME, HITLS_CERT_KEY_CTRL_ERR_GET_CURVE_NAME },
{ CERT_KEY_CTRL_GET_POINT_FORMAT, HITLS_CERT_KEY_CTRL_ERR_GET_POINT_FORMAT },
{ CERT_KEY_CTRL_GET_SECBITS, HITLS_CERT_KEY_CTRL_ERR_GET_SECBITS },
{ CERT_KEY_CTRL_IS_KEYENC_USAGE, HITLS_CERT_KEY_CTRL_ERR_IS_ENC_USAGE },
{ CERT_KEY_CTRL_IS_DIGITAL_SIGN_USAGE, HITLS_CERT_KEY_CTRL_ERR_IS_DIGITAL_SIGN_USAGE },
{ CERT_KEY_CTRL_IS_KEY_CERT_SIGN_USAGE, HITLS_CERT_KEY_CTRL_ERR_IS_KEY_CERT_SIGN_USAGE },
{ CERT_KEY_CTRL_IS_KEY_AGREEMENT_USAGE, HITLS_CERT_KEY_CTRL_ERR_IS_KEY_AGREEMENT_USAGE },
{ CERT_KEY_CTRL_GET_PARAM_ID, HITLS_CERT_KEY_CTRL_ERR_GET_PARAM_ID },
{ CERT_KEY_CTRL_IS_DATA_ENC_USAGE, HITLS_CERT_KEY_CTRL_ERR_IS_DATA_ENC_USAGE },
{ CERT_KEY_CTRL_IS_NON_REPUDIATION_USAGE, HITLS_CERT_KEY_CTRL_ERR_IS_NON_REPUDIATION_USAGE },
{ CERT_STORE_CTRL_GET_VERIFY_FLAGS, HITLS_CERT_STORE_CTRL_ERR_GET_VERIFY_FLAGS },
{ CERT_STORE_CTRL_SET_VERIFY_FLAGS, HITLS_CERT_STORE_CTRL_ERR_SET_VERIFY_FLAGS },
};
static uint32_t GetTlsCertCtrlErrorCode(HITLS_CERT_CtrlCmd cmd)
{
for (size_t i = 0; i < sizeof(g_tlsCertCtrlErrorCode) / sizeof(g_tlsCertCtrlErrorCode[0]); i++) {
if (g_tlsCertCtrlErrorCode[i].cmd == cmd) {
return g_tlsCertCtrlErrorCode[i].err;
}
}
return HITLS_CERT_CTRL_ERR_INVALID_CMD;
}
int32_t SAL_CERT_StoreCtrl(HITLS_Config *config, HITLS_CERT_Store *store, HITLS_CERT_CtrlCmd cmd, void *in, void *out)
{
int32_t ret;
if (cmd > CERT_CTRL_BUTT - 1) {
BSL_ERR_PUSH_ERROR(HITLS_CERT_CTRL_ERR_INVALID_CMD);
return HITLS_CERT_CTRL_ERR_INVALID_CMD;
}
#ifdef HITLS_TLS_FEATURE_PROVIDER
ret = HITLS_X509_Adapt_StoreCtrl(config, store, cmd, in, out);
#else
ret = config->certMgrCtx->method.certStoreCtrl(config, store, cmd, in, out);
#endif
return CheckCertCallBackRetVal("cert store ctrl", ret, BINLOG_ID16094, GetTlsCertCtrlErrorCode(cmd));
}
int32_t SAL_CERT_X509Ctrl(HITLS_Config *config, HITLS_CERT_X509 *cert, HITLS_CERT_CtrlCmd cmd, void *in, void *out)
{
if (cert == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16279, 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 (cmd > CERT_CTRL_BUTT - 1) {
BSL_ERR_PUSH_ERROR(HITLS_CERT_CTRL_ERR_INVALID_CMD);
return HITLS_CERT_CTRL_ERR_INVALID_CMD;
}
int32_t ret;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ret = HITLS_X509_Adapt_CertCtrl(config, cert, cmd, in, out);
#else
ret = config->certMgrCtx->method.certCtrl(config, cert, cmd, in, out);
#endif
return CheckCertCallBackRetVal("cert ctrl", ret, BINLOG_ID16096, GetTlsCertCtrlErrorCode(cmd));
}
int32_t SAL_CERT_KeyCtrl(HITLS_Config *config, HITLS_CERT_Key *key, HITLS_CERT_CtrlCmd cmd, void *in, void *out)
{
if (key == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16280, 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 (cmd > CERT_CTRL_BUTT - 1) {
BSL_ERR_PUSH_ERROR(HITLS_CERT_CTRL_ERR_INVALID_CMD);
return HITLS_CERT_CTRL_ERR_INVALID_CMD;
}
int32_t ret;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ret = HITLS_X509_Adapt_KeyCtrl(config, key, cmd, in, out);
#else
ret = config->certMgrCtx->method.keyCtrl(config, key, cmd, in, out);
#endif
return CheckCertCallBackRetVal("key ctrl", ret, BINLOG_ID16098, GetTlsCertCtrlErrorCode(cmd));
}
int32_t SAL_CERT_CreateSign(HITLS_Ctx *ctx, HITLS_CERT_Key *key, CERT_SignParam *signParam)
{
if (key == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16281, 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;
}
int32_t ret;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ret = HITLS_X509_Adapt_CreateSign(ctx, key, signParam->signAlgo, signParam->hashAlgo, signParam->data,
signParam->dataLen, signParam->sign, &signParam->signLen);
#else
ret = ctx->config.tlsConfig.certMgrCtx->method.createSign(ctx, key, signParam->signAlgo,
signParam->hashAlgo, signParam->data, signParam->dataLen, signParam->sign, &signParam->signLen);
#endif
return CheckCertCallBackRetVal("create signature", ret, BINLOG_ID16103, HITLS_CERT_ERR_CREATE_SIGN);
}
int32_t SAL_CERT_VerifySign(HITLS_Ctx *ctx, HITLS_CERT_Key *key, CERT_SignParam *signParam)
{
int32_t ret;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ret = HITLS_X509_Adapt_VerifySign(ctx, key, signParam->signAlgo,
signParam->hashAlgo, signParam->data, signParam->dataLen, signParam->sign, signParam->signLen);
#else
ret = ctx->config.tlsConfig.certMgrCtx->method.verifySign(ctx, key, signParam->signAlgo,
signParam->hashAlgo, signParam->data, signParam->dataLen, signParam->sign, signParam->signLen);
#endif
return CheckCertCallBackRetVal("verify signature", ret, BINLOG_ID16101, HITLS_CERT_ERR_VERIFY_SIGN);
}
#if defined(HITLS_TLS_SUITE_KX_RSA) || defined(HITLS_TLS_PROTO_TLCP11)
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)
{
int32_t ret;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ret = HITLS_X509_Adapt_Encrypt(ctx, key, in, inLen, out, outLen);
#else
if (ctx->config.tlsConfig.certMgrCtx->method.encrypt == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID15333, "unregistered encrypt");
}
ret = ctx->config.tlsConfig.certMgrCtx->method.encrypt(ctx, key, in, inLen, out, outLen);
#endif
return CheckCertCallBackRetVal("pubkey encrypt", ret, BINLOG_ID15059, HITLS_CERT_ERR_ENCRYPT);
}
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)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return HITLS_X509_Adapt_Decrypt(ctx, key, in, inLen, out, outLen);
#else
if (ctx->config.tlsConfig.certMgrCtx->method.decrypt == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID15334, "unregistered decrypt");
}
return ctx->config.tlsConfig.certMgrCtx->method.decrypt(ctx, key, in, inLen, out, outLen);
#endif
}
#endif /* HITLS_TLS_SUITE_KX_RSA || HITLS_TLS_PROTO_TLCP11 */
int32_t SAL_CERT_CheckPrivateKey(HITLS_Config *config, HITLS_CERT_X509 *cert, HITLS_CERT_Key *key)
{
int32_t ret;
#ifdef HITLS_TLS_FEATURE_PROVIDER
ret = HITLS_X509_Adapt_CheckPrivateKey(config, cert, key);
#else
ret = config->certMgrCtx->method.checkPrivateKey(config, cert, key);
#endif
return CheckCertCallBackRetVal(
"check cert and private key", ret, BINLOG_ID15538, HITLS_CERT_ERR_CHECK_CERT_AND_KEY);
}
HITLS_CERT_CRLList *SAL_CERT_CrlParse(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, HITLS_ParseFormat format)
{
return HITLS_X509_Adapt_CrlParse(config, buf, len, type, format);
}
void SAL_CERT_CrlFree(HITLS_CERT_CRLList *crlList)
{
HITLS_X509_Adapt_CrlFree(crlList);
}
|
2301_79861745/bench_create
|
tls/cert/cert_adapt/cert_method.c
|
C
|
unknown
| 17,133
|
/*
* 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 "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 "hitls_cert_reg.h"
#include "tls_config.h"
#include "cert_method.h"
#include "cert_mgr_ctx.h"
bool SAL_CERT_MgrIsEnable(void)
{
#ifdef HITLS_TLS_FEATURE_PROVIDER
return true;
#else
HITLS_CERT_MgrMethod *method = SAL_CERT_GetMgrMethod();
return (method->certStoreNew != NULL);
#endif
}
CERT_MgrCtx *SAL_CERT_MgrCtxNew(void)
{
return SAL_CERT_MgrCtxProviderNew(NULL, NULL);
}
CERT_MgrCtx *SAL_CERT_MgrCtxProviderNew(HITLS_Lib_Ctx *libCtx, const char *attrName)
{
CERT_MgrCtx *newCtx = BSL_SAL_Calloc(1, sizeof(CERT_MgrCtx));
if (newCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16085, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"new cert manager context error: out of memory.", 0, 0, 0, 0);
return NULL;
}
newCtx->currentCertKeyType = TLS_CERT_KEY_TYPE_UNKNOWN;
newCtx->certPairs = BSL_HASH_Create(CERT_DEFAULT_HASH_BKT_SIZE, NULL, NULL, NULL, NULL);
if (newCtx->certPairs == NULL) {
BSL_SAL_FREE(newCtx);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17338, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"new cert manager context error: new certPairs failed.", 0, 0, 0, 0);
return NULL;
}
#ifndef HITLS_TLS_FEATURE_PROVIDER
HITLS_CERT_MgrMethod *method = SAL_CERT_GetMgrMethod();
(void)memcpy_s(&newCtx->method, sizeof(HITLS_CERT_MgrMethod), method, sizeof(HITLS_CERT_MgrMethod));
#endif
newCtx->certStore = SAL_CERT_StoreNew(newCtx);
if (newCtx->certStore == NULL) {
BSL_HASH_Destory(newCtx->certPairs);
BSL_SAL_FREE(newCtx);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15016, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"new cert manager context error: new store failed.", 0, 0, 0, 0);
return NULL;
}
newCtx->libCtx = libCtx;
newCtx->attrName = attrName;
return newCtx;
}
int32_t StoreDup(CERT_MgrCtx *destMgrCtx, CERT_MgrCtx *srcMgrCtx)
{
if (srcMgrCtx->certStore != NULL) {
destMgrCtx->certStore = SAL_CERT_StoreDup(srcMgrCtx, srcMgrCtx->certStore);
if (destMgrCtx->certStore == NULL) {
/* releasing resources at the call point */
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_STORE_DUP, BINLOG_ID16092, "StoreDup fail");
}
}
if (srcMgrCtx->chainStore != NULL) {
destMgrCtx->chainStore = SAL_CERT_StoreDup(srcMgrCtx, srcMgrCtx->chainStore);
if (destMgrCtx->chainStore == NULL) {
/* releasing resources at the call point */
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_STORE_DUP, BINLOG_ID16093, "StoreDup fail");
}
}
if (srcMgrCtx->verifyStore != NULL) {
destMgrCtx->verifyStore = SAL_CERT_StoreDup(srcMgrCtx, srcMgrCtx->verifyStore);
if (destMgrCtx->verifyStore == NULL) {
/* releasing resources at the call point */
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_STORE_DUP, BINLOG_ID16095, "StoreDup fail");
}
}
return HITLS_SUCCESS;
}
CERT_MgrCtx *SAL_CERT_MgrCtxDup(CERT_MgrCtx *mgrCtx)
{
int32_t ret;
if (mgrCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16282, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "mgrCtx null", 0, 0, 0, 0);
return NULL;
}
CERT_MgrCtx *newCtx = BSL_SAL_Calloc(1, sizeof(CERT_MgrCtx));
if (newCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16097, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"dup cert manager context error: out of memory.", 0, 0, 0, 0);
return NULL;
}
#ifndef HITLS_TLS_FEATURE_PROVIDER
(void)memcpy_s(&newCtx->method, sizeof(HITLS_CERT_MgrMethod), &mgrCtx->method, sizeof(HITLS_CERT_MgrMethod));
#endif
ret = SAL_CERT_HashDup(newCtx, mgrCtx);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16283, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"SAL_CERT_HashDup fail, ret %d", ret, 0, 0, 0);
SAL_CERT_MgrCtxFree(newCtx);
return NULL;
}
if (mgrCtx->extraChain != NULL) {
newCtx->extraChain = SAL_CERT_ChainDup(mgrCtx, mgrCtx->extraChain);
if (newCtx->extraChain == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16284, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ChainDup fail", 0, 0, 0, 0);
SAL_CERT_MgrCtxFree(newCtx);
return NULL;
}
}
ret = StoreDup(newCtx, mgrCtx);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16285, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"StoreDup fail, ret %d", ret, 0, 0, 0);
SAL_CERT_MgrCtxFree(newCtx);
return NULL;
}
newCtx->currentCertKeyType = mgrCtx->currentCertKeyType;
newCtx->defaultPasswdCb = mgrCtx->defaultPasswdCb;
newCtx->defaultPasswdCbUserData = mgrCtx->defaultPasswdCbUserData;
newCtx->verifyCb = mgrCtx->verifyCb;
newCtx->libCtx = LIBCTX_FROM_CERT_MGR_CTX(mgrCtx);
newCtx->attrName = ATTRIBUTE_FROM_CERT_MGR_CTX(mgrCtx);
#ifdef HITLS_TLS_FEATURE_CERT_CB
newCtx->certCb = mgrCtx->certCb;
newCtx->certCbArg = mgrCtx->certCbArg;
#endif /* HITLS_TLS_FEATURE_CERT_CB */
return newCtx;
}
void SAL_CERT_MgrCtxFree(CERT_MgrCtx *mgrCtx)
{
if (mgrCtx == NULL) {
return;
}
SAL_CERT_ClearCertAndKey(mgrCtx);
SAL_CERT_ChainFree(mgrCtx->extraChain);
mgrCtx->extraChain = NULL;
SAL_CERT_StoreFree(mgrCtx, mgrCtx->verifyStore);
mgrCtx->verifyStore = NULL;
SAL_CERT_StoreFree(mgrCtx, mgrCtx->chainStore);
mgrCtx->chainStore = NULL;
SAL_CERT_StoreFree(mgrCtx, mgrCtx->certStore);
mgrCtx->certStore = NULL;
BSL_HASH_Destory(mgrCtx->certPairs);
mgrCtx->certPairs = NULL;
BSL_SAL_FREE(mgrCtx);
return;
}
|
2301_79861745/bench_create
|
tls/cert/cert_adapt/cert_mgr_create.c
|
C
|
unknown
| 6,550
|
/*
* 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 "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 "cert_method.h"
#include "cert.h"
#include "cert_mgr_ctx.h"
int32_t SAL_CERT_SetCertStore(CERT_MgrCtx *mgrCtx, HITLS_CERT_Store *store)
{
if (mgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
SAL_CERT_StoreFree(mgrCtx, mgrCtx->certStore);
mgrCtx->certStore = store;
return HITLS_SUCCESS;
}
HITLS_CERT_Store *SAL_CERT_GetCertStore(CERT_MgrCtx *mgrCtx)
{
if (mgrCtx == NULL) {
return NULL;
}
return mgrCtx->certStore;
}
int32_t SAL_CERT_SetChainStore(CERT_MgrCtx *mgrCtx, HITLS_CERT_Store *store)
{
if (mgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
SAL_CERT_StoreFree(mgrCtx, mgrCtx->chainStore);
mgrCtx->chainStore = store;
return HITLS_SUCCESS;
}
HITLS_CERT_Store *SAL_CERT_GetChainStore(CERT_MgrCtx *mgrCtx)
{
if (mgrCtx == NULL) {
return NULL;
}
return mgrCtx->chainStore;
}
int32_t SAL_CERT_SetVerifyStore(CERT_MgrCtx *mgrCtx, HITLS_CERT_Store *store)
{
if (mgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
SAL_CERT_StoreFree(mgrCtx, mgrCtx->verifyStore);
mgrCtx->verifyStore = store;
return HITLS_SUCCESS;
}
HITLS_CERT_Store *SAL_CERT_GetVerifyStore(CERT_MgrCtx *mgrCtx)
{
if (mgrCtx == NULL) {
return NULL;
}
return mgrCtx->verifyStore;
}
static int32_t GetOrInsertCertPair(CERT_MgrCtx *mgrCtx, HITLS_CERT_KeyType keyType, CERT_Pair **certPair)
{
CERT_Pair *newCertPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)keyType, (uintptr_t *)&newCertPair);
if (ret != HITLS_SUCCESS || newCertPair == NULL) {
newCertPair = BSL_SAL_Calloc(1u, sizeof(CERT_Pair));
if (newCertPair == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMALLOC_FAIL, BINLOG_ID16102, "certPair calloc fail");
}
ret = BSL_HASH_Insert(mgrCtx->certPairs, keyType, 0, (uintptr_t)newCertPair, sizeof(CERT_Pair));
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(newCertPair);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID17339, "insert fail");
}
}
*certPair = newCertPair;
return HITLS_SUCCESS;
}
int32_t SAL_CERT_SetCurrentCert(HITLS_Config *config, HITLS_CERT_X509 *cert, bool isTlcpEncCert)
{
(void)isTlcpEncCert;
if (cert == NULL || config == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
if (mgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_UNREGISTERED_CALLBACK);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID16286, "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_ID16099, "GET PUB KEY 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(mgrCtx, pubkey);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16100, "GET KEY TYPE fail");
}
CERT_Pair *certPair = NULL;
ret = GetOrInsertCertPair(mgrCtx, keyType, &certPair);
if (ret != HITLS_SUCCESS || certPair == NULL) {
return HITLS_MEMALLOC_FAIL;
}
HITLS_CERT_Key **privateKey = NULL;
HITLS_CERT_X509 **certPairCert = NULL;
#ifdef HITLS_TLS_PROTO_TLCP11
if (isTlcpEncCert) {
privateKey = &certPair->encPrivateKey;
certPairCert = &certPair->encCert;
} else
#endif
{
privateKey = &certPair->privateKey;
certPairCert = &certPair->cert;
}
if (*privateKey != NULL) {
ret = SAL_CERT_CheckPrivateKey(config, cert, *privateKey);
if (ret != HITLS_SUCCESS) {
/* If the certificate does not match the private key, release the private key. */
SAL_CERT_KeyFree(mgrCtx, *privateKey);
*privateKey = NULL;
}
}
SAL_CERT_X509Free(*certPairCert);
*certPairCert = cert;
mgrCtx->currentCertKeyType = keyType;
return HITLS_SUCCESS;
}
HITLS_CERT_X509 *SAL_CERT_GetCurrentCert(CERT_MgrCtx *mgrCtx)
{
if (mgrCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16287, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "mgrCtx null", 0, 0, 0, 0);
return NULL;
}
uint32_t keyType = mgrCtx->currentCertKeyType;
CERT_Pair *certPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)keyType, (uintptr_t *)&certPair);
if (ret != HITLS_SUCCESS || certPair == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16288, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "idx err", 0, 0, 0, 0);
return NULL;
}
return certPair->cert;
}
HITLS_CERT_X509 *SAL_CERT_GetCert(CERT_MgrCtx *mgrCtx, HITLS_CERT_KeyType keyType)
{
if (mgrCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16289, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "mgrCtx null", 0, 0, 0, 0);
return NULL;
}
CERT_Pair *certPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)keyType, (uintptr_t *)&certPair);
if (ret != HITLS_SUCCESS || certPair == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16290, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "idx err", 0, 0, 0, 0);
return NULL;
}
return certPair->cert;
}
int32_t SAL_CERT_SetCurrentPrivateKey(HITLS_Config *config, HITLS_CERT_Key *key, bool isTlcpEncCertPriKey)
{
(void)isTlcpEncCertPriKey;
if (key == NULL || config == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
if (mgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_UNREGISTERED_CALLBACK);
return HITLS_UNREGISTERED_CALLBACK;
}
uint32_t keyType = TLS_CERT_KEY_TYPE_UNKNOWN;
int32_t ret = SAL_CERT_KeyCtrl(config, key, CERT_KEY_CTRL_GET_TYPE, NULL, (void *)&keyType);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID16104, "get key type fail");
}
CERT_Pair *certPair = NULL;
ret = GetOrInsertCertPair(mgrCtx, keyType, &certPair);
if (ret != HITLS_SUCCESS || certPair == NULL) {
return HITLS_MEMALLOC_FAIL;
}
HITLS_CERT_Key **certPairPrivateKey = NULL;
HITLS_CERT_X509 **cert = NULL;
#ifdef HITLS_TLS_PROTO_TLCP11
if (isTlcpEncCertPriKey) {
certPairPrivateKey = &certPair->encPrivateKey;
cert = &certPair->encCert;
} else
#endif
{
certPairPrivateKey = &certPair->privateKey;
cert = &certPair->cert;
}
if (*cert != NULL) {
ret = SAL_CERT_CheckPrivateKey(config, *cert, key);
if (ret != HITLS_SUCCESS) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16107, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"set private key error: cert and key mismatch, key type = %u.", keyType, 0, 0, 0);
/* The certificate does not match the private key. */
return ret;
}
}
SAL_CERT_KeyFree(mgrCtx, *certPairPrivateKey);
*certPairPrivateKey = key;
mgrCtx->currentCertKeyType = keyType;
return HITLS_SUCCESS;
}
HITLS_CERT_Key *SAL_CERT_GetCurrentPrivateKey(CERT_MgrCtx *mgrCtx, bool isTlcpEncCert)
{
(void)isTlcpEncCert;
if (mgrCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16291, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "mgrCtx null", 0, 0, 0, 0);
return NULL;
}
uint32_t keyType = mgrCtx->currentCertKeyType;
CERT_Pair *certPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)keyType, (uintptr_t *)&certPair);
if (ret != HITLS_SUCCESS || certPair == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16292, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "certPair null", 0, 0, 0, 0);
return NULL;
}
#ifdef HITLS_TLS_PROTO_TLCP11
if (isTlcpEncCert) {
return certPair->encPrivateKey;
}
#endif
return certPair->privateKey;
}
HITLS_CERT_Key *SAL_CERT_GetPrivateKey(CERT_MgrCtx *mgrCtx, HITLS_CERT_KeyType keyType)
{
if (mgrCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16293, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "mgrCtx null", 0, 0, 0, 0);
return NULL;
}
CERT_Pair *certPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)keyType, (uintptr_t *)&certPair);
if (ret != HITLS_SUCCESS || certPair == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16294, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "certPair null", 0, 0, 0, 0);
return NULL;
}
return certPair->privateKey;
}
int32_t SAL_CERT_AddChainCert(CERT_MgrCtx *mgrCtx, HITLS_CERT_X509 *cert)
{
if (mgrCtx == NULL || cert == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_NULL_INPUT, BINLOG_ID16392, "null input");
}
uint32_t keyType = mgrCtx->currentCertKeyType;
if (keyType == TLS_CERT_KEY_TYPE_UNKNOWN) {
BSL_ERR_PUSH_ERROR(HITLS_CERT_ERR_ADD_CHAIN_CERT);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_ADD_CHAIN_CERT, BINLOG_ID16390, "keyType unknown");
}
CERT_Pair *certPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)keyType, (uintptr_t *)&certPair);
if (ret != HITLS_SUCCESS || certPair == NULL) {
/* the certificate has not been loaded yet */
BSL_ERR_PUSH_ERROR(HITLS_CERT_ERR_ADD_CHAIN_CERT);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_ADD_CHAIN_CERT, BINLOG_ID16391, "certPair null");
}
HITLS_CERT_Chain *newChain = NULL;
HITLS_CERT_Chain *chain = certPair->chain;
if (chain == NULL) {
newChain = SAL_CERT_ChainNew();
if (newChain == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMALLOC_FAIL, BINLOG_ID16295, "ChainNew fail");
}
chain = newChain;
}
ret = SAL_CERT_ChainAppend(chain, cert);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(newChain);
return ret;
}
certPair->chain = chain;
return HITLS_SUCCESS;
}
HITLS_CERT_Chain *SAL_CERT_GetCurrentChainCerts(CERT_MgrCtx *mgrCtx)
{
if (mgrCtx == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16296, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "mgrCtx null", 0, 0, 0, 0);
return NULL;
}
CERT_Pair *certPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)mgrCtx->currentCertKeyType, (uintptr_t *)&certPair);
if (ret != HITLS_SUCCESS || certPair == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16297, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "certPair null", 0, 0, 0, 0);
return NULL;
}
return certPair->chain;
}
void SAL_CERT_ClearCurrentChainCerts(CERT_MgrCtx *mgrCtx)
{
if (mgrCtx == NULL) {
return;
}
CERT_Pair *certPair = NULL;
int32_t ret = BSL_HASH_At(mgrCtx->certPairs, (uintptr_t)mgrCtx->currentCertKeyType, (uintptr_t *)&certPair);
if (ret != HITLS_SUCCESS || certPair == NULL || certPair->chain == NULL) {
return;
}
SAL_CERT_ChainFree(certPair->chain);
certPair->chain = NULL;
return;
}
void SAL_CERT_ClearCertAndKey(CERT_MgrCtx *mgrCtx)
{
if (mgrCtx == NULL) {
return;
}
BSL_HASH_Hash *certPairs = mgrCtx->certPairs;
for (BSL_HASH_Iterator it = BSL_HASH_IterBegin(certPairs); it != BSL_HASH_IterEnd(certPairs);) {
uint32_t keyType = (uint32_t)BSL_HASH_HashIterKey(certPairs, it);
CERT_Pair *certPair = (CERT_Pair *)BSL_HASH_IterValue(certPairs, it);
SAL_CERT_PairClear(mgrCtx, certPair);
BSL_SAL_FREE(certPair);
it = BSL_HASH_Erase(certPairs, keyType);
}
mgrCtx->currentCertKeyType = TLS_CERT_KEY_TYPE_UNKNOWN;
return;
}
int32_t SAL_CERT_AddExtraChainCert(CERT_MgrCtx *mgrCtx, HITLS_CERT_X509 *cert)
{
if (mgrCtx == NULL || cert == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
HITLS_CERT_Chain *newChain = NULL;
HITLS_CERT_Chain *chain = mgrCtx->extraChain;
if (chain == NULL) {
newChain = SAL_CERT_ChainNew();
if (newChain == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return RETURN_ERROR_NUMBER_PROCESS(HITLS_MEMALLOC_FAIL, BINLOG_ID16298, "ChainNew fail");
}
chain = newChain;
}
int32_t ret = SAL_CERT_ChainAppend(chain, cert);
if (ret != HITLS_SUCCESS) {
BSL_SAL_FREE(newChain);
return ret;
}
mgrCtx->extraChain = chain;
return HITLS_SUCCESS;
}
HITLS_CERT_Chain *SAL_CERT_GetExtraChainCerts(CERT_MgrCtx *mgrCtx, bool isExtraChainCertsOnly)
{
if (mgrCtx == NULL) {
return NULL;
}
if (mgrCtx->extraChain == NULL && !isExtraChainCertsOnly) {
return SAL_CERT_GetCurrentChainCerts(mgrCtx);
}
return mgrCtx->extraChain;
}
void SAL_CERT_ClearExtraChainCerts(CERT_MgrCtx *mgrCtx)
{
if (mgrCtx == NULL) {
return;
}
HITLS_CERT_Chain *chain = mgrCtx->extraChain;
if (chain == NULL) {
return;
}
SAL_CERT_ChainFree(chain);
mgrCtx->extraChain = NULL;
return;
}
int32_t SAL_CERT_CtrlVerifyParams(HITLS_Config *config, HITLS_CERT_Store *store, uint32_t cmd, void *in, void *out)
{
CERT_MgrCtx *mgrCtx = config->certMgrCtx;
if (mgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
HITLS_CERT_Store *tempStore = store;
if (tempStore == NULL) {
tempStore = (mgrCtx->verifyStore != NULL) ? mgrCtx->verifyStore : mgrCtx->certStore;
if (tempStore == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_NULL_INPUT, BINLOG_ID15327, "store is null");
}
}
int32_t ret = SAL_CERT_StoreCtrl(config, tempStore, cmd, in, out);
if (ret != HITLS_SUCCESS) {
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID15326, "SAL_CERT_StoreCtrl fail");
}
return HITLS_SUCCESS;
}
int32_t SAL_CERT_SetDefaultPasswordCb(CERT_MgrCtx *mgrCtx, HITLS_PasswordCb cb)
{
if (mgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
mgrCtx->defaultPasswdCb = cb;
return HITLS_SUCCESS;
}
HITLS_PasswordCb SAL_CERT_GetDefaultPasswordCb(CERT_MgrCtx *mgrCtx)
{
if (mgrCtx == NULL) {
return NULL;
}
return mgrCtx->defaultPasswdCb;
}
int32_t SAL_CERT_SetDefaultPasswordCbUserdata(CERT_MgrCtx *mgrCtx, void *userdata)
{
if (mgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
mgrCtx->defaultPasswdCbUserData = userdata;
return HITLS_SUCCESS;
}
void *SAL_CERT_GetDefaultPasswordCbUserdata(CERT_MgrCtx *mgrCtx)
{
if (mgrCtx == NULL) {
return NULL;
}
return mgrCtx->defaultPasswdCbUserData;
}
int32_t SAL_CERT_SetVerifyCb(CERT_MgrCtx *mgrCtx, HITLS_VerifyCb cb)
{
if (mgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
mgrCtx->verifyCb = cb;
return HITLS_SUCCESS;
}
HITLS_VerifyCb SAL_CERT_GetVerifyCb(CERT_MgrCtx *mgrCtx)
{
if (mgrCtx == NULL) {
return NULL;
}
return mgrCtx->verifyCb;
}
#ifdef HITLS_TLS_FEATURE_CERT_CB
int32_t SAL_CERT_SetCertCb(CERT_MgrCtx *mgrCtx, HITLS_CertCb certCb, void *arg)
{
if (mgrCtx == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
return HITLS_NULL_INPUT;
}
mgrCtx->certCb = certCb;
mgrCtx->certCbArg = arg;
return HITLS_SUCCESS;
}
#endif /* HITLS_TLS_FEATURE_CERT_CB */
|
2301_79861745/bench_create
|
tls/cert/cert_adapt/cert_mgr_ctrl.c
|
C
|
unknown
| 16,552
|
/*
* 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_CTX_H
#define CERT_MGR_CTX_H
#include <stdint.h>
#include "hitls_crypt_type.h"
#include "hitls_cert_reg.h"
#include "cert.h"
#include "bsl_hash.h"
#ifdef __cplusplus
extern "C" {
#endif
#define CERT_DEFAULT_HASH_BKT_SIZE 64u
struct CertPairInner {
HITLS_CERT_X509 *cert; /* device certificate */
#ifdef HITLS_TLS_PROTO_TLCP11
/* encrypted device cert. Currently this field is used only when the peer-end encrypted certificate is stored. */
HITLS_CERT_X509 *encCert;
HITLS_CERT_Key *encPrivateKey;
#endif
HITLS_CERT_Key *privateKey; /* private key corresponding to the certificate */
HITLS_CERT_Chain *chain; /* certificate chain */
};
struct CertMgrCtxInner {
uint32_t currentCertKeyType; /* keyType to the certificate in use. */
/* Indicates the certificate resources on the link. Only one certificate of a type can be loaded. */
BSL_HASH_Hash *certPairs; /* cert hash table. key keyType, value CERT_Pair */
HITLS_CERT_Chain *extraChain;
HITLS_CERT_Store *verifyStore; /* Verifies the store, which is used to verify the certificate chain. */
HITLS_CERT_Store *chainStore; /* Certificate chain store, used to assemble the certificate chain */
HITLS_CERT_Store *certStore; /* Default CA store */
#ifndef HITLS_TLS_FEATURE_PROVIDER
HITLS_CERT_MgrMethod method; /* callback function */
#endif
HITLS_PasswordCb defaultPasswdCb; /* Default password callback, used in loading certificate. */
void *defaultPasswdCbUserData; /* Set the userData used by the default password callback. */
HITLS_VerifyCb verifyCb; /* Certificate verification callback function */
#ifdef HITLS_TLS_FEATURE_CERT_CB
HITLS_CertCb certCb; /* Certificate callback function */
void *certCbArg; /* Argument for the certificate callback function */
#endif /* HITLS_TLS_FEATURE_CERT_CB */
HITLS_Lib_Ctx *libCtx; /* library context */
const char *attrName; /* attrName */
};
CERT_Type CertKeyType2CertType(HITLS_CERT_KeyType keyType);
int32_t CheckCurveName(HITLS_Config *config, const uint16_t *curveList, uint32_t curveNum, HITLS_CERT_Key *pubkey);
int32_t CheckPointFormat(HITLS_Config *config, const uint8_t *ecPointFormatList, uint32_t listSize,
HITLS_CERT_Key *pubkey);
/* These functions can be stored in a separate header file. */
HITLS_CERT_Chain *SAL_CERT_ChainNew(void);
int32_t SAL_CERT_ChainAppend(HITLS_CERT_Chain *chain, HITLS_CERT_X509 *cert);
HITLS_CERT_Chain *SAL_CERT_ChainDup(CERT_MgrCtx *mgrCtx, HITLS_CERT_Chain *chain);
#define LIBCTX_FROM_CERT_MGR_CTX(mgrCtx) ((mgrCtx == NULL) ? NULL : (mgrCtx)->libCtx)
#define ATTRIBUTE_FROM_CERT_MGR_CTX(mgrCtx) ((mgrCtx == NULL) ? NULL : (mgrCtx)->attrName)
#ifdef __cplusplus
}
#endif
#endif
|
2301_79861745/bench_create
|
tls/cert/cert_adapt/cert_mgr_ctx.h
|
C
|
unknown
| 3,486
|
/*
* 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_sal.h"
#include "tls_binlog_id.h"
#include "hitls_cert_type.h"
#include "cert_method.h"
#include "cert_mgr.h"
#include "cert_mgr_ctx.h"
HITLS_CERT_X509 *SAL_CERT_PairGetX509(CERT_Pair *certPair)
{
if (certPair == NULL) {
return NULL;
}
return certPair->cert;
}
#ifdef HITLS_TLS_PROTO_TLCP11
HITLS_CERT_X509 *SAL_CERT_GetTlcpEncCert(CERT_Pair *certPair)
{
if (certPair == NULL) {
return NULL;
}
return certPair->encCert;
}
#endif
#if defined(HITLS_TLS_CONNECTION_INFO_NEGOTIATION)
HITLS_CERT_Chain *SAL_CERT_PairGetChain(CERT_Pair *certPair)
{
if (certPair == NULL) {
return NULL;
}
return certPair->chain;
}
#endif /* HITLS_TLS_CONNECTION_INFO_NEGOTIATION */
#ifdef HITLS_TLS_PROTO_TLCP11
static int32_t TlcpCertPairDup(CERT_MgrCtx *mgrCtx, CERT_Pair *srcCertPair, CERT_Pair *destCertPair)
{
if (srcCertPair->encCert != NULL) {
destCertPair->encCert = SAL_CERT_X509Dup(mgrCtx, srcCertPair->encCert);
if (destCertPair->encCert == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17341, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"enc X509Dup fail", 0, 0, 0, 0);
return HITLS_CERT_ERR_X509_DUP;
}
}
if (srcCertPair->encPrivateKey != NULL) {
destCertPair->encPrivateKey = SAL_CERT_KeyDup(mgrCtx, srcCertPair->encPrivateKey);
if (destCertPair->encPrivateKey == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17342, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"enc KeyDup fail", 0, 0, 0, 0);
return HITLS_CERT_ERR_X509_DUP;
}
}
return HITLS_SUCCESS;
}
#endif
CERT_Pair *SAL_CERT_PairDup(CERT_MgrCtx *mgrCtx, CERT_Pair *srcCertPair)
{
CERT_Pair *destCertPair = BSL_SAL_Calloc(1, sizeof(CERT_MgrCtx));
if (destCertPair == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16299, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "Calloc fail", 0, 0, 0, 0);
return NULL;
}
do {
#ifdef HITLS_TLS_PROTO_TLCP11
if (TlcpCertPairDup(mgrCtx, srcCertPair, destCertPair) != HITLS_SUCCESS) {
break;
}
#endif
if (srcCertPair->cert != NULL) {
destCertPair->cert = SAL_CERT_X509Dup(mgrCtx, srcCertPair->cert);
if (destCertPair->cert == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16300, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"X509Dup fail", 0, 0, 0, 0);
break;
}
}
if (srcCertPair->privateKey != NULL) {
destCertPair->privateKey = SAL_CERT_KeyDup(mgrCtx, srcCertPair->privateKey);
if (destCertPair->privateKey == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16301, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"KeyDup fail", 0, 0, 0, 0);
break;
}
}
if (srcCertPair->chain != NULL) {
destCertPair->chain = SAL_CERT_ChainDup(mgrCtx, srcCertPair->chain);
if (destCertPair->chain == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16302, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"ChainDup fail", 0, 0, 0, 0);
break;
}
}
return destCertPair;
} while (false);
SAL_CERT_PairFree(mgrCtx, destCertPair);
return NULL;
}
void SAL_CERT_PairClear(CERT_MgrCtx *mgrCtx, CERT_Pair *certPair)
{
if (mgrCtx == NULL || certPair == NULL) {
return;
}
if (certPair->cert != NULL) {
SAL_CERT_X509Free(certPair->cert);
}
#ifdef HITLS_TLS_PROTO_TLCP11
if (certPair->encCert != NULL) {
SAL_CERT_X509Free(certPair->encCert);
}
if (certPair->encPrivateKey != NULL) {
SAL_CERT_KeyFree(mgrCtx, certPair->encPrivateKey);
}
#endif
if (certPair->privateKey != NULL) {
SAL_CERT_KeyFree(mgrCtx, certPair->privateKey);
}
if (certPair->chain != NULL) {
SAL_CERT_ChainFree(certPair->chain);
}
(void)memset_s(certPair, sizeof(CERT_Pair), 0, sizeof(CERT_Pair));
return;
}
void SAL_CERT_PairFree(CERT_MgrCtx *mgrCtx, CERT_Pair *certPair)
{
SAL_CERT_PairClear(mgrCtx, certPair);
BSL_SAL_FREE(certPair);
return;
}
int32_t SAL_CERT_HashDup(CERT_MgrCtx *destMgrCtx, CERT_MgrCtx *srcMgrCtx)
{
destMgrCtx->certPairs = BSL_HASH_Create(CERT_DEFAULT_HASH_BKT_SIZE, NULL, NULL, NULL, NULL);
if (destMgrCtx->certPairs == NULL) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17347, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
"BSL_HASH_Create fail", 0, 0, 0, 0);
return HITLS_MEMALLOC_FAIL;
}
BSL_HASH_Hash *certPairs = srcMgrCtx->certPairs;
BSL_HASH_Iterator iter = BSL_HASH_IterBegin(certPairs);
while (iter != BSL_HASH_IterEnd(certPairs)) {
uint32_t keyType = (uint32_t)BSL_HASH_HashIterKey(certPairs, iter);
CERT_Pair *certPair = (CERT_Pair *)BSL_HASH_IterValue(certPairs, iter);
if (certPair != NULL) {
CERT_Pair *newCertPair = SAL_CERT_PairDup(srcMgrCtx, certPair);
if (newCertPair == NULL) {
return RETURN_ERROR_NUMBER_PROCESS(HITLS_CERT_ERR_X509_DUP, BINLOG_ID17348, "x509dup fail");
}
int32_t ret = BSL_HASH_Insert(destMgrCtx->certPairs, keyType, 0, (uintptr_t)newCertPair, sizeof(CERT_Pair));
if (ret != HITLS_SUCCESS) {
SAL_CERT_PairFree(destMgrCtx, newCertPair);
return RETURN_ERROR_NUMBER_PROCESS(ret, BINLOG_ID17349, "insert fail");
}
}
iter = BSL_HASH_IterNext(certPairs, iter);
}
return HITLS_SUCCESS;
}
|
2301_79861745/bench_create
|
tls/cert/cert_adapt/cert_pair.c
|
C
|
unknown
| 6,242
|
/*
* 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_sal.h"
#include "bsl_err_internal.h"
#include "hitls_cert_type.h"
#include "hitls_type.h"
#include "hitls_pki_x509.h"
#include "bsl_list.h"
#include "hitls_error.h"
static int32_t BuildArrayFromList(HITLS_X509_List *list, HITLS_CERT_X509 **listArray, uint32_t *num)
{
HITLS_X509_Cert *elemt = NULL;
int32_t i = 0;
int32_t ret;
for (elemt = BSL_LIST_GET_FIRST(list); elemt != NULL; elemt = BSL_LIST_GET_NEXT(list), i++) {
int ref = 0;
ret = HITLS_X509_CertCtrl(elemt, HITLS_X509_REF_UP, (void *)&ref, (int32_t)sizeof(int));
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
listArray[i] = elemt;
}
*num = i;
return HITLS_SUCCESS;
}
static int32_t BuildCertListFromCertArray(HITLS_CERT_X509 **listCert, uint32_t num, HITLS_X509_List **list)
{
int32_t ret = HITLS_SUCCESS;
HITLS_X509_Cert **listArray = (HITLS_X509_Cert **)listCert;
*list = BSL_LIST_New(num);
if (*list == NULL) {
BSL_ERR_PUSH_ERROR(HITLS_MEMALLOC_FAIL);
return HITLS_MEMALLOC_FAIL;
}
for (uint32_t i = 0; i < num; i++) {
int ref = 0;
ret = HITLS_X509_CertCtrl(listArray[i], HITLS_X509_REF_UP, (void *)&ref, (int32_t)sizeof(int));
if (ret != HITLS_SUCCESS) {
BSL_LIST_FREE(*list, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
return ret;
}
ret = BSL_LIST_AddElement(*list, listArray[i], BSL_LIST_POS_END);
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
BSL_LIST_FREE(*list, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
return ret;
}
}
return HITLS_SUCCESS;
}
int32_t HITLS_X509_Adapt_BuildCertChain(HITLS_Config *config, HITLS_CERT_Store *store, HITLS_CERT_X509 *cert,
HITLS_CERT_X509 **list, uint32_t *num)
{
(void)config;
*num = 0;
HITLS_X509_List *certChain = NULL;
int32_t ret = HITLS_X509_CertChainBuild((HITLS_X509_StoreCtx *)store, false, cert, &certChain);
if (ret != HITLS_SUCCESS) {
return ret;
}
ret = BuildArrayFromList(certChain, list, num);
BSL_LIST_FREE(certChain, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
return ret;
}
int32_t HITLS_X509_Adapt_VerifyCertChain(HITLS_Ctx *ctx, HITLS_CERT_Store *store, HITLS_CERT_X509 **list, uint32_t num)
{
(void)ctx;
/* The default user id as specified in GM/T 0009-2012 */
char sm2DefaultUserid[] = "1234567812345678";
HITLS_X509_List *certList = NULL;
int32_t ret = BuildCertListFromCertArray(list, num, &certList);
if (ret != HITLS_SUCCESS) {
return ret;
}
int64_t sysTime = BSL_SAL_CurrentSysTimeGet();
if (sysTime == 0) {
ret = HITLS_CERT_SELF_ADAPT_INVALID_TIME;
BSL_ERR_PUSH_ERROR(HITLS_CERT_SELF_ADAPT_INVALID_TIME);
goto EXIT;
}
ret = HITLS_X509_StoreCtxCtrl((HITLS_X509_StoreCtx *)store, HITLS_X509_STORECTX_SET_TIME, &sysTime,
sizeof(sysTime));
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = HITLS_X509_StoreCtxCtrl((HITLS_X509_StoreCtx *)store, HITLS_X509_STORECTX_SET_VFY_SM2_USERID,
sm2DefaultUserid, strlen(sm2DefaultUserid));
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
goto EXIT;
}
ret = HITLS_X509_CertVerify((HITLS_X509_StoreCtx *)store, certList);
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
EXIT:
BSL_LIST_FREE(certList, (BSL_LIST_PFUNC_FREE)HITLS_X509_CertFree);
return ret;
}
#endif /* defined(HITLS_TLS_CALLBACK_CERT) || defined(HITLS_TLS_FEATURE_PROVIDER) */
|
2301_79861745/bench_create
|
tls/cert/hitls_x509_adapt/hitls_x509_cert_chain.c
|
C
|
unknown
| 4,346
|
/*
* 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 "crypt_eal_pkey.h"
#include "hitls_error.h"
#include "hitls_cert_type.h"
#include "hitls_type.h"
#include "hitls_pki_cert.h"
#include "hitls_error.h"
#include "bsl_err_internal.h"
#include "tls_config.h"
#include "cert_mgr_ctx.h"
#include "config_type.h"
int32_t HITLS_X509_Adapt_CertEncode(HITLS_Ctx *ctx, HITLS_CERT_X509 *cert, uint8_t *buf, uint32_t len,
uint32_t *usedLen)
{
(void)ctx;
*usedLen = 0;
uint32_t encodeLen = 0;
int32_t ret = HITLS_X509_CertCtrl((HITLS_X509_Cert *)cert, HITLS_X509_GET_ENCODELEN, &encodeLen,
(int32_t)sizeof(uint32_t));
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (len < encodeLen) {
BSL_ERR_PUSH_ERROR(HITLS_INVALID_INPUT);
return HITLS_INVALID_INPUT;
}
uint8_t *encodedBuff = NULL;
ret = HITLS_X509_CertCtrl((HITLS_X509_Cert *)cert, HITLS_X509_GET_ENCODE, (void *)&encodedBuff, 0);
if (ret != HITLS_SUCCESS) {
return ret;
}
(void)memcpy_s(buf, len, encodedBuff, encodeLen);
*usedLen = encodeLen;
return ret;
}
#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)
{
BSL_Buffer encodedCert = { NULL, 0 };
int ret;
HITLS_X509_Cert *cert = NULL;
switch (type) {
case TLS_PARSE_TYPE_FILE:
ret = HITLS_X509_ProviderCertParseFile(libCtx, attrName, format, (const char *)buf, &cert);
break;
case TLS_PARSE_TYPE_BUFF:
encodedCert.data = (uint8_t *)(uintptr_t)buf;
encodedCert.dataLen = len;
ret = HITLS_X509_ProviderCertParseBuff(libCtx, attrName, format, &encodedCert, &cert);
break;
default:
BSL_ERR_PUSH_ERROR(HITLS_CERT_SELF_ADAPT_UNSUPPORT_FORMAT);
ret = HITLS_CERT_SELF_ADAPT_UNSUPPORT_FORMAT;
break;
}
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return NULL;
}
return cert;
}
#else
HITLS_CERT_X509 *HITLS_X509_Adapt_CertParse(HITLS_Config *config, const uint8_t *buf, uint32_t len,
HITLS_ParseType type, HITLS_ParseFormat format)
{
(void)config;
BSL_Buffer encodedCert = { NULL, 0 };
int ret;
HITLS_X509_Cert *cert = NULL;
switch (type) {
case TLS_PARSE_TYPE_FILE:
ret = HITLS_X509_CertParseFile(format, (const char *)buf, &cert);
break;
case TLS_PARSE_TYPE_BUFF:
encodedCert.data = (uint8_t *)(uintptr_t)buf;
encodedCert.dataLen = len;
ret = HITLS_X509_CertParseBuff(format, &encodedCert, &cert);
break;
default:
BSL_ERR_PUSH_ERROR(HITLS_CERT_SELF_ADAPT_UNSUPPORT_FORMAT);
ret = HITLS_CERT_SELF_ADAPT_UNSUPPORT_FORMAT;
break;
}
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return NULL;
}
return cert;
}
#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)
{
BSL_Buffer encodedCert = { NULL, 0 };
int ret;
HITLS_X509_List *certlist = NULL;
switch (type) {
case TLS_PARSE_TYPE_FILE:
ret = HITLS_X509_ProviderCertParseBundleFile(libCtx, attrName, format, (const char *)buf, &certlist);
break;
case TLS_PARSE_TYPE_BUFF:
encodedCert.data = (uint8_t *)(uintptr_t)buf;
encodedCert.dataLen = len;
ret = HITLS_X509_ProviderCertParseBundleBuff(libCtx, attrName, format, &encodedCert, &certlist);
break;
default:
BSL_ERR_PUSH_ERROR(HITLS_CERT_SELF_ADAPT_UNSUPPORT_FORMAT);
return NULL;
}
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return NULL;
}
return certlist;
}
void HITLS_X509_Adapt_CertFree(HITLS_CERT_X509 *cert)
{
HITLS_X509_CertFree(cert);
}
HITLS_CERT_X509 *HITLS_X509_Adapt_CertRef(HITLS_CERT_X509 *cert)
{
int ref = 0;
int ret = HITLS_X509_CertCtrl(cert, HITLS_X509_REF_UP, (void *)&ref, (int32_t)sizeof(int));
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return NULL;
}
return cert;
}
HITLS_CERT_X509 *HITLS_X509_Adapt_CertDup(HITLS_CERT_X509 *cert)
{
return HITLS_X509_Adapt_CertRef(cert);
}
static HITLS_SignHashAlgo BslCid2SignHashAlgo(HITLS_Config *config, BslCid signAlgId, BslCid hashAlgId)
{
uint32_t size = 0;
const TLS_SigSchemeInfo *sigSchemeInfoList = ConfigGetSignatureSchemeInfoList(config, &size);
for (size_t i = 0; i < size; i++) {
if (sigSchemeInfoList[i].signHashAlgId == (int32_t)signAlgId &&
sigSchemeInfoList[i].hashAlgId == (int32_t)hashAlgId) {
return sigSchemeInfoList[i].signatureScheme;
}
}
return CERT_SIG_SCHEME_UNKNOWN;
}
static int32_t CertCtrlGetSignAlgo(HITLS_Config *config, HITLS_CERT_X509 *cert, HITLS_SignHashAlgo *algSign)
{
BslCid signAlgCid = 0;
BslCid hashCid = 0;
*algSign = CERT_SIG_SCHEME_UNKNOWN;
int32_t ret = HITLS_X509_CertCtrl(cert, HITLS_X509_GET_SIGNALG, &signAlgCid, sizeof(BslCid));
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
ret = HITLS_X509_CertCtrl(cert, HITLS_X509_GET_SIGN_MDALG, &hashCid, sizeof(BslCid));
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
*algSign = BslCid2SignHashAlgo(config, signAlgCid, hashCid);
return HITLS_SUCCESS;
}
#if defined(HITLS_TLS_PROTO_TLCP11) || defined(HITLS_TLS_CONFIG_KEY_USAGE)
static int32_t CertCheckKeyUsage(HITLS_Config *config, HITLS_CERT_X509 *cert, uint32_t inKeyUsage, bool *res)
{
(void)config;
uint32_t keyUsage = 0;
int32_t ret = HITLS_X509_CertCtrl(cert, HITLS_X509_EXT_GET_KUSAGE, &keyUsage, sizeof(uint32_t));
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
return ret;
}
if (keyUsage == HITLS_X509_EXT_KU_NONE) {
#ifdef HITLS_TLS_PROTO_TLCP11
// Key usage must be present, otherwise the chain is broken.
if (config == NULL) {
return HITLS_INVALID_INPUT;
}
if (config->maxVersion == HITLS_VERSION_TLCP_DTLCP11) {
BSL_ERR_PUSH_ERROR(HITLS_CERT_ERR_NO_KEYUSAGE);
return HITLS_CERT_ERR_NO_KEYUSAGE;
}
#endif
*res = true;
return HITLS_SUCCESS;
}
*res = (keyUsage & inKeyUsage) != 0;
return HITLS_SUCCESS;
}
#endif
int32_t HITLS_X509_Adapt_CertCtrl(HITLS_Config *config, HITLS_CERT_X509 *cert, HITLS_CERT_CtrlCmd cmd,
void *input, void *output)
{
(void)input;
int32_t ret = HITLS_SUCCESS;
switch (cmd) {
case CERT_CTRL_GET_ENCODE_LEN:
ret = HITLS_X509_CertCtrl(cert, HITLS_X509_GET_ENCODELEN, output, (uint32_t)sizeof(int32_t));
break;
case CERT_CTRL_GET_PUB_KEY:
ret = HITLS_X509_CertCtrl(cert, HITLS_X509_GET_PUBKEY, output, (uint32_t)sizeof(CRYPT_EAL_PkeyPub *));
break;
case CERT_CTRL_GET_SIGN_ALGO:
return CertCtrlGetSignAlgo(config, cert, (HITLS_SignHashAlgo *)output);
#if defined(HITLS_TLS_PROTO_TLCP11) || defined(HITLS_TLS_CONFIG_KEY_USAGE)
case CERT_KEY_CTRL_IS_KEYENC_USAGE:
return CertCheckKeyUsage(config, cert, HITLS_X509_EXT_KU_KEY_ENCIPHERMENT, (bool *)output);
case CERT_KEY_CTRL_IS_DIGITAL_SIGN_USAGE:
return CertCheckKeyUsage(config, cert, HITLS_X509_EXT_KU_DIGITAL_SIGN, (bool *)output);
case CERT_KEY_CTRL_IS_KEY_CERT_SIGN_USAGE:
return CertCheckKeyUsage(config, cert, HITLS_X509_EXT_KU_KEY_CERT_SIGN, (bool *)output);
case CERT_KEY_CTRL_IS_KEY_AGREEMENT_USAGE:
return CertCheckKeyUsage(config, cert, HITLS_X509_EXT_KU_KEY_AGREEMENT, (bool *)output);
case CERT_KEY_CTRL_IS_DATA_ENC_USAGE:
return CertCheckKeyUsage(config, cert, HITLS_X509_EXT_KU_DATA_ENCIPHERMENT, (bool *)output);
case CERT_KEY_CTRL_IS_NON_REPUDIATION_USAGE:
return CertCheckKeyUsage(config, cert, HITLS_X509_EXT_KU_NON_REPUDIATION, (bool *)output);
#endif
case CERT_CTRL_GET_ENCODE_SUBJECT_DN:
ret = HITLS_X509_CertCtrl(cert, HITLS_X509_GET_ENCODE_SUBJECT_DN, output, sizeof(BSL_Buffer *));
break;
case CERT_CTRL_IS_SELF_SIGNED:
return HITLS_X509_CertCtrl(cert, HITLS_X509_IS_SELF_SIGNED, (bool *)output, (uint32_t)sizeof(bool));
default:
BSL_ERR_PUSH_ERROR(HITLS_CERT_SELF_ADAPT_ERR);
return HITLS_CERT_SELF_ADAPT_ERR;
}
if (ret != HITLS_SUCCESS) {
BSL_ERR_PUSH_ERROR(ret);
}
return ret;
}
#endif /* defined(HITLS_TLS_CALLBACK_CERT) || defined(HITLS_TLS_FEATURE_PROVIDER) */
|
2301_79861745/bench_create
|
tls/cert/hitls_x509_adapt/hitls_x509_cert_magr.c
|
C
|
unknown
| 9,604
|
/*
* 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) */
|
2301_79861745/bench_create
|
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);
}
}
|
2301_79861745/bench_create
|
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) */
|
2301_79861745/bench_create
|
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
}
|
2301_79861745/bench_create
|
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) */
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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
}
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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);
}
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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 void SetTlsMinMaxVersion(TLS_Config *config)
{
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 (int32_t i = versionBitsSize - 1; i >= 0; i--) {
if ((config->version & versionBits[i]) == versionBits[i]) {
config->maxVersion = versions[i];
break;
}
}
if ((config->version & DTLS12_VERSION_BIT) == DTLS12_VERSION_BIT) {
config->maxVersion = HITLS_VERSION_DTLS12;
config->minVersion = HITLS_VERSION_DTLS12;
}
}
static int32_t ProcessEvent(HITLS_Ctx *ctx, ManageEventProcess proc)
{
return proc(ctx);
}
static int32_t SetConnState(HITLS_Ctx *ctx, bool isClient)
{
TLS_Config *config = &ctx->config.tlsConfig;
if (config->endpoint == HITLS_ENDPOINT_UNDEFINED) {
config->endpoint = isClient ? HITLS_ENDPOINT_CLIENT : HITLS_ENDPOINT_SERVER;
}
if (config->endpoint == HITLS_ENDPOINT_CLIENT) {
return HITLS_SetEndPoint(ctx, true);
}
if (config->endpoint == HITLS_ENDPOINT_SERVER) {
SetTlsMinMaxVersion(config);
return HITLS_SetEndPoint(ctx, false);
}
return HITLS_SUCCESS;
}
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;
if (GetConnState(ctx) == CM_STATE_IDLE) {
ret = SetConnState(ctx, true);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
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;
if (GetConnState(ctx) == CM_STATE_IDLE) {
ret = SetConnState(ctx, false);
if (ret != HITLS_SUCCESS) {
return ret;
}
}
#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
|
2301_79861745/bench_create
|
tls/cm/src/conn_establish.c
|
C
|
unknown
| 26,907
|
/*
* 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;
}
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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;
}
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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;
destConfig->endpoint = srcConfig->endpoint;
#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;
}
#ifdef HITLS_TLS_PROTO_TLS12
newConfig->version |= TLS12_VERSION_BIT;
#endif
#ifdef HITLS_TLS_PROTO_TLS13
newConfig->version |= TLS13_VERSION_BIT;
#endif
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;
}
static void ChangeMinMaxVersion(uint32_t versionMask, uint32_t originVersionMask, uint16_t *minVersion,
uint16_t *maxVersion)
{
/* The original supported version is disabled. This is abnormal and packets cannot be sent */
if ((versionMask & ~originVersionMask) != 0 && versionMask != 0) {
return;
}
/* Currently, only DTLS1.2 is supported. DTLS1.0 is not supported */
if ((versionMask & DTLS12_VERSION_BIT) == DTLS12_VERSION_BIT) {
*maxVersion = HITLS_VERSION_DTLS12;
*minVersion = HITLS_VERSION_DTLS12;
return;
}
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);
uint32_t minIdx = 0;
uint32_t maxIdx = 0;
bool found = false;
uint32_t intersection = versionMask & originVersionMask;
for (uint32_t i = 0; i < versionBitsSize; i++) {
if ((intersection & versionBits[i]) == versionBits[i]) {
if (!found) {
minIdx = i;
found = true;
}
maxIdx = i;
} else if (found) {
break;
}
}
if (found == false) {
// No version is supported
*minVersion = 0;
*maxVersion = 0;
return;
}
*minVersion = versions[minIdx];
*maxVersion = versions[maxIdx];
}
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;
uint16_t begin = IS_DTLS_VERSION(minVersion) ? maxVersion : minVersion;
uint16_t end = IS_DTLS_VERSION(maxVersion) ? minVersion : maxVersion;
for (uint16_t version = begin; version <= end; 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 & originVersionMask);
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)
{
uint16_t minVersion = 0;
uint16_t maxVersion = 0;
ChangeMinMaxVersion(config->originVersionMask, config->originVersionMask, &minVersion, &maxVersion);
if (*tmpMinVersion == 0) {
if (config->originVersionMask == DTLS_VERSION_MASK) {
*tmpMinVersion = HITLS_VERSION_DTLS12;
} else {
*tmpMinVersion = minVersion;
}
}
if (*tmpMaxVersion == 0) {
if (config->originVersionMask == DTLS_VERSION_MASK) {
*tmpMaxVersion = HITLS_VERSION_DTLS12;
} else {
*tmpMaxVersion = maxVersion;
}
}
return;
}
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;
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;
}
uint16_t tmpMinVersion = minVersion;
uint16_t tmpMaxVersion = maxVersion;
ChangeTmpVersion(config, &tmpMinVersion, &tmpMaxVersion);
ret = CheckVersion(tmpMinVersion, tmpMaxVersion);
if (ret != HITLS_SUCCESS) {
return ret;
}
/* In invalid cases, both maxVersion and minVersion are 0 */
ret = ChangeVersionMask(config, tmpMinVersion, tmpMaxVersion);
if (ret != HITLS_SUCCESS) {
ChangeMinMaxVersion(config->version, config->originVersionMask, &config->minVersion, &config->maxVersion);
}
return HITLS_SUCCESS;
}
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)
config->version &= ~noVersion;
ChangeMinMaxVersion(config->version, config->originVersionMask, &config->minVersion, &config->maxVersion);
return HITLS_SUCCESS;
}
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;
}
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;
}
uint32_t tmp = version & config->originVersionMask;
config->version |= tmp;
/* Update the maximum supported version */
ChangeMinMaxVersion(config->version, config->originVersionMask, &config->minVersion, &config->maxVersion);
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
int32_t HITLS_CFG_SetEndPoint(HITLS_Config *config, bool isClient)
{
if (config == NULL) {
return HITLS_NULL_INPUT;
}
config->endpoint = isClient ? HITLS_ENDPOINT_CLIENT : HITLS_ENDPOINT_SERVER;
return HITLS_SUCCESS;
}
|
2301_79861745/bench_create
|
tls/config/src/config.c
|
C
|
unknown
| 65,027
|
/*
* 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 CreateAndAddTrustedCANode(HITLS_Config *config, HITLS_CERT_X509 *cert, HITLS_TrustedCANode *caNode,
HITLS_TrustedCAList *list)
{
int32_t ret = HITLS_SUCCESS;
BSL_Buffer nodeBuffer = {0};
#ifdef HITLS_TLS_FEATURE_SECURITY
ret = CheckCertSecuritylevel(config, cert, false);
if (ret != HITLS_SUCCESS) {
return ret;
}
#endif
ret = SAL_CERT_X509Ctrl(config, cert, CERT_CTRL_GET_ENCODE_SUBJECT_DN, NULL, (void *)&nodeBuffer);
if (ret != HITLS_SUCCESS) {
return ret;
}
caNode->caType = HITLS_TRUSTED_CA_X509_NAME;
caNode->data = nodeBuffer.data;
caNode->dataSize = nodeBuffer.dataLen;
ret = BSL_LIST_AddElement(list, caNode, BSL_LIST_POS_END);
if (ret != BSL_SUCCESS) {
return ret;
}
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 = NULL;
HITLS_CERT_Chain *certList =
SAL_CERT_X509ParseBundleFile(LIBCTX_FROM_CONFIG(config), ATTRIBUTE_FROM_CONFIG(config), config,
(const uint8_t *)input, inputLen, inputType, format);
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;
}
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;
}
while (tempCert != NULL) {
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;
}
ret = CreateAndAddTrustedCANode(config, tempCert, newCaNode, list);
if (ret != HITLS_SUCCESS) {
goto ERR;
}
tempCert = (HITLS_CERT_X509 *)BSL_LIST_GET_NEXT(certList);
}
*caList = list;
SAL_CERT_ChainFree(certList);
return ret;
ERR:
SAL_CERT_ChainFree(certList);
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;
}
#ifdef HITLS_TLS_CONFIG_CERT_VERIFY_LOCATION
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_VERIFY_LOCATION */
#endif /* HITLS_TLS_CONFIG_CERT_LOAD_FILE */
#ifdef HITLS_TLS_CONFIG_CERT_VERIFY_LOCATION
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;
}
#endif /* HITLS_TLS_CONFIG_CERT_VERIFY_LOCATION */
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;
}
|
2301_79861745/bench_create
|
tls/config/src/config_cert.c
|
C
|
unknown
| 39,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 <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;
}
if (config->minVersion == 0 || config->maxVersion == 0) {
BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17374, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
"minVersion or maxVersion is 0", 0, 0, 0, 0);
BSL_ERR_PUSH_ERROR(HITLS_CONFIG_INVALID_VERSION);
return HITLS_CONFIG_INVALID_VERSION;
}
/* 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;
}
|
2301_79861745/bench_create
|
tls/config/src/config_check.c
|
C
|
unknown
| 11,066
|
/*
* 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
|
2301_79861745/bench_create
|
tls/config/src/config_default.c
|
C
|
unknown
| 16,903
|
/*
* 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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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 */
}
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
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 */
|
2301_79861745/bench_create
|
tls/feature/session/src/session.c
|
C
|
unknown
| 23,148
|