Star1133
749
代码
代码
Issues27
Pull Requests52
Actions
项目讨论
Wiki
分析
Star1133
749
已合并
1. Add DTLCP over sctp 2. Use IS_SUPPORT_DATAGRAM to decide whether to go to the DTLS or TLS branch during handshakes #152
这好吗创建于 2025年2月19日
1. Add DTLCP over sctp 2. Use IS_SUPPORT_DATAGRAM to decide whether to go to the DTLS or TLS branch during handshakes #152
已合并
这好吗创建于 2025年2月19日
从usern4me/openhitlsdev合入到openHiTLS/openhitlsmain
共 69 个文件变更+1748-173
Mconfig/macro_config/hitls_config_layer_tls.h+12-0
@@ -36,11 +36,23 @@
36 #ifndef HITLS_TLS_PROTO_TLCP1136 #ifndef HITLS_TLS_PROTO_TLCP11
37 #define HITLS_TLS_PROTO_TLCP1137 #define HITLS_TLS_PROTO_TLCP11
38 #endif38 #endif
39+ #ifndef HITLS_TLS_PROTO_DTLCP11
40+ #define HITLS_TLS_PROTO_DTLCP11
41+ #endif
39 #ifndef HITLS_TLS_PROTO_DTLS1242 #ifndef HITLS_TLS_PROTO_DTLS12
40 #define HITLS_TLS_PROTO_DTLS1243 #define HITLS_TLS_PROTO_DTLS12
41 #endif44 #endif
42#endif45#endif
43 46 
47+#if defined(HITLS_TLS_PROTO_DTLCP11)
B
Bbaoyi849302025年2月21日

这里感觉有点奇怪，版本之间存在这种依赖关系，考虑下是否可以用内部宏处理公共代码，此处用版本来推导内部宏的形式。

likedislike
48+ #ifndef HITLS_TLS_PROTO_DTLS12
49+ #define HITLS_TLS_PROTO_DTLS12
50+ #endif
51+ #ifndef HITLS_TLS_PROTO_TLCP11
52+ #define HITLS_TLS_PROTO_TLCP11
53+ #endif
54+#endif
55+ 
44#if defined(HITLS_TLS_PROTO_TLS12) || defined(HITLS_TLS_PROTO_TLS13) || defined(HITLS_TLS_PROTO_TLCP11)56#if defined(HITLS_TLS_PROTO_TLS12) || defined(HITLS_TLS_PROTO_TLS13) || defined(HITLS_TLS_PROTO_TLCP11)
45 #ifndef HITLS_TLS_PROTO_TLS57 #ifndef HITLS_TLS_PROTO_TLS
46 #define HITLS_TLS_PROTO_TLS58 #define HITLS_TLS_PROTO_TLS
Minclude/bsl/bsl_uio.h+2-0
@@ -67,6 +67,8 @@ typedef enum {
67 BSL_UIO_EXTEND = 10000, /* extension value */67 BSL_UIO_EXTEND = 10000, /* extension value */
68} BSL_UIO_TransportType;68} BSL_UIO_TransportType;
69 69 
70+#define IS_TRANSTYPE_DATAGRAM(transportType) ((transportType) == BSL_UIO_SCTP || (transportType) == BSL_UIO_UDP)
71+ 
70/**72/**
71 * @ingroup bsl_uio73 * @ingroup bsl_uio
72 * @brief Sctp auth key, hitls Use the BSL_UIO_Method.ctrl method to transfer the BSL_UIO_SCTP_ADD_AUTH_SHARED_KEY74 * @brief Sctp auth key, hitls Use the BSL_UIO_Method.ctrl method to transfer the BSL_UIO_SCTP_ADD_AUTH_SHARED_KEY
Minclude/tls/hitls_config.h+40-3
@@ -34,9 +34,9 @@ extern "C" {
34 34 
35/**35/**
36* @ingroup hitls_config36* @ingroup hitls_config
37-* @brief TLCP 1.1 version37+* @brief (D)TLCP 1.1 version
38*/38*/
39-#define HITLS_VERSION_TLCP11 0x0101u39+#define HITLS_VERSION_TLCP_DTLCP11 0x0101u
40 40 
41/**41/**
42 * @ingroup hitls_config42 * @ingroup hitls_config
@@ -260,7 +260,7 @@ HITLS_Config *HITLS_CFG_ProviderNewDTLS12Config(HITLS_Lib_Ctx *libCtx, const cha
260 * The user can call the HITLS_CFG_SetXXX interface to modify the settings.260 * The user can call the HITLS_CFG_SetXXX interface to modify the settings.
261 *261 *
262 * @attention The default configuration is as follows:262 * @attention The default configuration is as follows:
263- Version number: HITLS_VERSION_TLCP11263+ Version number: HITLS_VERSION_TLCP_DTLCP11
264 Algorithm suite: HITLS_ECDHE_SM4_CBC_SM3, HITLS_ECC_SM4_CBC_SM3, HITLS_ECDHE_SM4_GCM_SM3, HITLS_ECC_SM4_GCM_SM3264 Algorithm suite: HITLS_ECDHE_SM4_CBC_SM3, HITLS_ECC_SM4_CBC_SM3, HITLS_ECDHE_SM4_GCM_SM3, HITLS_ECC_SM4_GCM_SM3
265 EC point format: HITLS_POINT_FORMAT_UNCOMPRESSED265 EC point format: HITLS_POINT_FORMAT_UNCOMPRESSED
266 groups:sm2266 groups:sm2
@@ -291,6 +291,43 @@ HITLS_Config *HITLS_CFG_NewTLCPConfig(void);
291 */291 */
292HITLS_Config *HITLS_CFG_ProviderNewTLCPConfig(HITLS_Lib_Ctx *libCtx, const char *attrName);292HITLS_Config *HITLS_CFG_ProviderNewTLCPConfig(HITLS_Lib_Ctx *libCtx, const char *attrName);
293 293 
294+/**
295+ * @ingroup hitls_config
296+ * @brief Create DTLCP configuration items, including the default settings. The user can call the
297+ * HITLS_CFG_SetXXX interface to modify the settings.
298+ *
299+ * @attention The default configuration is as follows:
300+ Version number: HITLS_VERSION_TLCP_DTLCP11
301+ Algorithm suite: HITLS_ECDHE_SM4_CBC_SM3, HITLS_ECC_SM4_CBC_SM3, HITLS_ECDHE_SM4_GCM_SM3, HITLS_ECC_SM4_GCM_SM3
302+ EC point format: HITLS_POINT_FORMAT_UNCOMPRESSED
303+ groups:sm2
304+ Extended Master Key: Enabled
305+ Signature algorithm: All signature algorithms in the HITLS_SignHashAlgo table
306+ Dual-ended check: Disabled
307+ Allow Client No Certificate: Not Allowed
308+ Renegotiation: Not supported
309+ This API is a version-specific API. After the configuration context is created,
310+ the HITLS_SetVersion, HITLS_CFG_SetVersion, HITLS_SetVersionSupport, HITLS_CFG_SetVersionSupport,
311+ HITLS_SetMinProtoVersion, or HITLS_SetMaxProtoVersion interface cannot be used to set other supported versions.
312+ * @retval HITLS_Config, object pointer succeeded.
313+ * @retval NULL, object application failed.
314+ */
315+HITLS_Config *HITLS_CFG_NewDTLCPConfig(void);
316+ 
317+/**
318+ * @ingroup hitls_config
319+ * @brief Create DTLCP configuration items with provider, including the default settings. Same as HITLS_CFG_NewDTLCPConfig
320+ * except that it requires libCtx and attribute parameters.
321+ *
322+ * @param[in] libCtx: The library context.
323+ * @param[in] attrName: The attribute name.
324+ *
325+ * @retval HITLS_Config, object pointer succeeded.
326+ * @retval NULL, failed to apply for the object.
327+ * @see HITLS_CFG_FreeConfig
328+ */
329+HITLS_Config *HITLS_CFG_ProviderNewDTLCPConfig(HITLS_Lib_Ctx *libCtx, const char *attrName);
330+ 
294/**331/**
295 * @ingroup hitls_config332 * @ingroup hitls_config
296 * @brief Create a TLS12 configuration item, including the default configuration.333 * @brief Create a TLS12 configuration item, including the default configuration.
Minclude/tls/hitls_type.h+8-0
@@ -90,6 +90,14 @@ typedef struct CertVerifyParamInner HITLS_CertVerifyParam;
90/* Currently, only DTLS12 is supported. DTLS10 is not supported */90/* Currently, only DTLS12 is supported. DTLS10 is not supported */
91#define DTLS_VERSION_MASK DTLS12_VERSION_BIT91#define DTLS_VERSION_MASK DTLS12_VERSION_BIT
92 92 
93+#define STREAM_VERSION_BITS \
94+ (SSLV2_VERSION_BIT | SSLV3_VERSION_BIT | TLS10_VERSION_BIT | TLS11_VERSION_BIT | TLS12_VERSION_BIT | \
95+ TLS13_VERSION_BIT | TLCP11_VERSION_BIT)
96+#define DATAGRAM_VERSION_BITS (DTLS10_VERSION_BIT | DTLS12_VERSION_BIT | DTLCP11_VERSION_BIT)
97+ 
98+#define TLCP_VERSION_BITS (TLCP11_VERSION_BIT | DTLCP11_VERSION_BIT)
99+#define ALL_VERSION (STREAM_VERSION_BITS | DATAGRAM_VERSION_BITS)
100+ 
93/**101/**
94 * @ingroup hitls_type102 * @ingroup hitls_type
95 * @brief HITLS_SESS_CACHE_MODE: mode for storing hitls sessions.103 * @brief HITLS_SESS_CACHE_MODE: mode for storing hitls sessions.
Mtestcode/framework/tls/func_wrapper/src/rec_wrapper.c+1-1
@@ -93,7 +93,7 @@ static int32_t WrapperDecryptFunc(TLS_Ctx *ctx, RecConnState *state, const REC_T
93 uint8_t *data, uint32_t *dataLen)93 uint8_t *data, uint32_t *dataLen)
94{94{
95 int32_t ret = RecGetOriginCryptFuncs(state->suiteInfo)->decrypt(ctx, state, cryptMsg, data, dataLen);95 int32_t ret = RecGetOriginCryptFuncs(state->suiteInfo)->decrypt(ctx, state, cryptMsg, data, dataLen);
96- if (ret == HITLS_SUCCESS && IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion) && g_recWrapper.isRecRead ) {96+ if (ret == HITLS_SUCCESS && IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask) && g_recWrapper.isRecRead) {
97 if (g_recWrapper.recordType != cryptMsg->type) {97 if (g_recWrapper.recordType != cryptMsg->type) {
98 return ret;98 return ret;
99 }99 }
Mtestcode/framework/tls/include/frame_msg.h+2-0
@@ -333,6 +333,7 @@ typedef struct {
333 uint8_t reverse; /* To be deleted. The member is not processed because some code uses it */333 uint8_t reverse; /* To be deleted. The member is not processed because some code uses it */
334 uint16_t version; /* To be deleted. The member is not processed because some code uses it */334 uint16_t version; /* To be deleted. The member is not processed because some code uses it */
335 uint16_t bodyLen; /* To be deleted. The member is not processed because some code uses it */335 uint16_t bodyLen; /* To be deleted. The member is not processed because some code uses it */
336+ BSL_UIO_TransportType transportType;
336 uint64_t epochSeq; /* To be deleted. The member is not processed because some code uses it */337 uint64_t epochSeq; /* To be deleted. The member is not processed because some code uses it */
337 338 
338 FRAME_Integer recType; /* record the message type */339 FRAME_Integer recType; /* record the message type */
@@ -362,6 +363,7 @@ typedef struct {
362 /* To ensure that the memory can be released normally, a value is assigned to the member during parsing */363 /* To ensure that the memory can be released normally, a value is assigned to the member during parsing */
363 HS_MsgType handshakeType;364 HS_MsgType handshakeType;
364 HITLS_KeyExchAlgo keyExType;365 HITLS_KeyExchAlgo keyExType;
366+ BSL_UIO_TransportType transportType;
365} FRAME_Type;367} FRAME_Type;
366 368 
367/**369/**
Mtestcode/framework/tls/include/hlt_type.h+1-0
@@ -118,6 +118,7 @@ typedef enum {
118 TLS1_2,118 TLS1_2,
119 TLS1_3,119 TLS1_3,
120 TLCP1_1,120 TLCP1_1,
121+ DTLCP1_1,
121} TLS_VERSION;122} TLS_VERSION;
122 123 
123typedef enum {124typedef enum {
Mtestcode/framework/tls/msg/src/frame_msg_method.c+15-21
@@ -37,6 +37,7 @@ typedef struct {
37 FRAME_LinkObj *server;37 FRAME_LinkObj *server;
38 HITLS_HandshakeState state;38 HITLS_HandshakeState state;
39 bool isClient;39 bool isClient;
40+ BSL_UIO_TransportType transportType;
40} LinkPara;41} LinkPara;
41 42 
42static void CleanLinkPara(LinkPara *linkPara)43static void CleanLinkPara(LinkPara *linkPara)
@@ -48,19 +49,12 @@ static void CleanLinkPara(LinkPara *linkPara)
48 49 
49static int32_t PauseState(LinkPara *linkPara, uint16_t version)50static int32_t PauseState(LinkPara *linkPara, uint16_t version)
50{51{
51- /* Check the TLS version type, which is converted to connection enumeration. */52+ (void)version;
52- BSL_UIO_TransportType transportType = BSL_UIO_UNKNOWN;53+ 
53- if (IS_DTLS_VERSION(version)) {54+ BSL_UIO_TransportType transportType = linkPara->transportType;
54- transportType = BSL_UIO_SCTP;
55- } else if (version == HITLS_VERSION_TLS12 || version == HITLS_VERSION_TLS13 || version == HITLS_VERSION_TLCP11) {
56- transportType = BSL_UIO_TCP;
57- } else {
58- /* Link establishment in other versions is not supported. */
59- return HITLS_INTERNAL_EXCEPTION;
60- }
61#ifdef HITLS_TLS_PROTO_TLCP1155#ifdef HITLS_TLS_PROTO_TLCP11
62 /* Constructing a Link */56 /* Constructing a Link */
63- if ( version == HITLS_VERSION_TLCP11 ) {57+ if ( version == HITLS_VERSION_TLCP_DTLCP11 ) {
64 linkPara->client = FRAME_CreateTLCPLink(linkPara->config, transportType, true);58 linkPara->client = FRAME_CreateTLCPLink(linkPara->config, transportType, true);
65 linkPara->server = FRAME_CreateTLCPLink(linkPara->config, transportType, false);59 linkPara->server = FRAME_CreateTLCPLink(linkPara->config, transportType, false);
66 } else60 } else
@@ -142,8 +136,13 @@ static int32_t SetLinkConfig(uint16_t version, HITLS_KeyExchAlgo keyExAlgo, Link
142 linkPara->config = HITLS_CFG_NewTLS12Config();136 linkPara->config = HITLS_CFG_NewTLS12Config();
143 } else if (version == HITLS_VERSION_TLS13) {137 } else if (version == HITLS_VERSION_TLS13) {
144 linkPara->config = HITLS_CFG_NewTLS13Config();138 linkPara->config = HITLS_CFG_NewTLS13Config();
145- } else if (version == HITLS_VERSION_TLCP11) {139+ } else if (version == HITLS_VERSION_TLCP_DTLCP11) {
146- linkPara->config = HITLS_CFG_NewTLCPConfig();140+ if (IS_TRANSTYPE_DATAGRAM(linkPara->transportType)) {
141+ linkPara->config = HITLS_CFG_NewDTLCPConfig();
142+ } else {
143+ linkPara->config = HITLS_CFG_NewTLCPConfig();
144+ }
145+ 
147 return HITLS_SUCCESS;146 return HITLS_SUCCESS;
148 }147 }
149#ifdef HITLS_TLS_CONFIG_KEY_USAGE148#ifdef HITLS_TLS_CONFIG_KEY_USAGE
@@ -151,12 +150,6 @@ static int32_t SetLinkConfig(uint16_t version, HITLS_KeyExchAlgo keyExAlgo, Link
151#endif /* HITLS_TLS_CONFIG_KEY_USAGE */150#endif /* HITLS_TLS_CONFIG_KEY_USAGE */
152 151 
153 int32_t ret;152 int32_t ret;
154-#ifdef HITLS_TLS_PROTO_ALL
155- ret = HITLS_CFG_SetVersion(linkPara->config, version, version);
156- if (ret != HITLS_SUCCESS) {
157- return ret;
158- }
159-#endif
160#ifdef HITLS_TLS_FEATURE_CERT_MODE153#ifdef HITLS_TLS_FEATURE_CERT_MODE
161 ret = HITLS_CFG_SetClientVerifySupport(linkPara->config, true);154 ret = HITLS_CFG_SetClientVerifySupport(linkPara->config, true);
162 if (ret != HITLS_SUCCESS) {155 if (ret != HITLS_SUCCESS) {
@@ -184,6 +177,7 @@ static int32_t GetdefaultHsMsg(FRAME_Type *frameType, FRAME_Msg *parsedMsg)
184 LinkPara linkPara = {0};177 LinkPara linkPara = {0};
185 178 
186 /* Configure config. */179 /* Configure config. */
180+ linkPara.transportType = frameType->transportType;
187 ret = SetLinkConfig(frameType->versionType, frameType->keyExType, &linkPara);181 ret = SetLinkConfig(frameType->versionType, frameType->keyExType, &linkPara);
188 if (ret != HITLS_SUCCESS) {182 if (ret != HITLS_SUCCESS) {
189 CleanLinkPara(&linkPara);183 CleanLinkPara(&linkPara);
@@ -233,8 +227,8 @@ static void SetDefaultRecordHeader(FRAME_Type *frameType, FRAME_Msg *msg, REC_Ty
233 msg->recVersion.state = INITIAL_FIELD;227 msg->recVersion.state = INITIAL_FIELD;
234 if (IS_DTLS_VERSION(frameType->versionType)) {228 if (IS_DTLS_VERSION(frameType->versionType)) {
235 msg->recVersion.data = HITLS_VERSION_DTLS12;229 msg->recVersion.data = HITLS_VERSION_DTLS12;
236- } else if (frameType->versionType == HITLS_VERSION_TLCP11) {230+ } else if (frameType->versionType == HITLS_VERSION_TLCP_DTLCP11) {
237- msg->recVersion.data = HITLS_VERSION_TLCP11;231+ msg->recVersion.data = HITLS_VERSION_TLCP_DTLCP11;
238 } else {232 } else {
239 msg->recVersion.data = HITLS_VERSION_TLS12;233 msg->recVersion.data = HITLS_VERSION_TLS12;
240 }234 }
Mtestcode/framework/tls/msg/src/frame_pack_msg.c+11-9
@@ -1039,7 +1039,7 @@ static int32_t PackClientEcdheMsg(FRAME_Type *type, const FRAME_ClientKeyExchang
1039 uint32_t bufLen, uint32_t *usedLen)1039 uint32_t bufLen, uint32_t *usedLen)
1040{1040{
1041 uint32_t offset = 0;1041 uint32_t offset = 0;
1042- if (type->versionType == HITLS_VERSION_TLCP11) { /* Three bytes are added to the client key exchange. */1042+ if (type->versionType == HITLS_VERSION_TLCP_DTLCP11) { /* Three bytes are added to the client key exchange. */
1043 buf[offset] = HITLS_EC_CURVE_TYPE_NAMED_CURVE;1043 buf[offset] = HITLS_EC_CURVE_TYPE_NAMED_CURVE;
1044 offset += sizeof(uint8_t);1044 offset += sizeof(uint8_t);
1045 BSL_Uint16ToByte(HITLS_EC_GROUP_SM2, &buf[offset]);1045 BSL_Uint16ToByte(HITLS_EC_GROUP_SM2, &buf[offset]);
@@ -1106,8 +1106,9 @@ static int32_t PackFinishedMsg(const FRAME_FinishedMsg *finished, uint8_t *buf,
1106}1106}
1107 1107 
1108static void PackHsMsgHeader(uint16_t version, const FRAME_HsMsg *hsMsg, uint32_t bodyLen,1108static void PackHsMsgHeader(uint16_t version, const FRAME_HsMsg *hsMsg, uint32_t bodyLen,
1109- uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)1109+ uint8_t *buf, uint32_t bufLen, uint32_t *usedLen, BSL_UIO_TransportType transportType)
1110{1110{
1111+ (void)version;
1111 uint32_t offset = 0;1112 uint32_t offset = 0;
1112 uint32_t bufOffset;1113 uint32_t bufOffset;
1113 1114 
@@ -1115,7 +1116,7 @@ static void PackHsMsgHeader(uint16_t version, const FRAME_HsMsg *hsMsg, uint32_t
1115 1116 
1116 bufOffset = offset;1117 bufOffset = offset;
1117 PackInteger24(&hsMsg->length, &buf[offset], bufLen - offset, &offset);1118 PackInteger24(&hsMsg->length, &buf[offset], bufLen - offset, &offset);
1118- if (IS_DTLS_VERSION(version)) {1119+ if (IS_TRANSTYPE_DATAGRAM(transportType)) {
1119 PackInteger16(&hsMsg->sequence, &buf[offset], bufLen - offset, &offset);1120 PackInteger16(&hsMsg->sequence, &buf[offset], bufLen - offset, &offset);
1120 PackInteger24(&hsMsg->fragmentOffset, &buf[offset], bufLen - offset, &offset);1121 PackInteger24(&hsMsg->fragmentOffset, &buf[offset], bufLen - offset, &offset);
1121 if (hsMsg->fragmentLength.state == INITIAL_FIELD) {1122 if (hsMsg->fragmentLength.state == INITIAL_FIELD) {
@@ -1212,7 +1213,7 @@ static int32_t PackHandShakeMsg(FRAME_Type *type, const FRAME_Msg *msg,
1212 uint32_t headerLen;1213 uint32_t headerLen;
1213 uint32_t bodyLen = 0;1214 uint32_t bodyLen = 0;
1214 1215 
1215- if (IS_DTLS_VERSION(type->versionType)) { // DTLS1216+ if (IS_TRANSTYPE_DATAGRAM(type->transportType)) { // DTLS
1216 if (bufLen < DTLS_HS_MSG_HEADER_SIZE) {1217 if (bufLen < DTLS_HS_MSG_HEADER_SIZE) {
1217 return HITLS_INTERNAL_EXCEPTION;1218 return HITLS_INTERNAL_EXCEPTION;
1218 }1219 }
@@ -1237,7 +1238,7 @@ static int32_t PackHandShakeMsg(FRAME_Type *type, const FRAME_Msg *msg,
1237 }1238 }
1238 1239 
1239 // Assemble the handshake packet header.1240 // Assemble the handshake packet header.
1240- PackHsMsgHeader(type->versionType, hsMsg, bodyLen, buf, headerLen, &headerLen);1241+ PackHsMsgHeader(type->versionType, hsMsg, bodyLen, buf, headerLen, &headerLen, type->transportType);
1241 1242 
1242 // Splicing body and head1243 // Splicing body and head
1243 // If some fields are missing in the header, the packet body is filled with an offset forward.1244 // If some fields are missing in the header, the packet body is filled with an offset forward.
@@ -1287,13 +1288,14 @@ static int32_t PackAppMsg(const FRAME_Msg *msg, uint8_t *buf, uint32_t bufLen, u
1287}1288}
1288 1289 
1289static int32_t PackRecordHeader(uint16_t version, const FRAME_Msg *msg, uint32_t bodyLen,1290static int32_t PackRecordHeader(uint16_t version, const FRAME_Msg *msg, uint32_t bodyLen,
1290- uint8_t *buf, uint32_t bufLen, uint32_t *usedLen)1291+ uint8_t *buf, uint32_t bufLen, uint32_t *usedLen, BSL_UIO_TransportType transportType)
1291{1292{
1293+ (void)version;
1292 uint32_t offset = 0;1294 uint32_t offset = 0;
1293 1295 
1294 PackInteger8(&msg->recType, &buf[offset], bufLen, &offset);1296 PackInteger8(&msg->recType, &buf[offset], bufLen, &offset);
1295 PackInteger16(&msg->recVersion, &buf[offset], bufLen - offset, &offset);1297 PackInteger16(&msg->recVersion, &buf[offset], bufLen - offset, &offset);
1296- if (IS_DTLS_VERSION(version)) {1298+ if (IS_TRANSTYPE_DATAGRAM(transportType)) {
1297 PackInteger16(&msg->epoch, &buf[offset], bufLen - offset, &offset);1299 PackInteger16(&msg->epoch, &buf[offset], bufLen - offset, &offset);
1298 PackInteger48(&msg->sequence, &buf[offset], bufLen - offset, &offset);1300 PackInteger48(&msg->sequence, &buf[offset], bufLen - offset, &offset);
1299 }1301 }
@@ -1348,7 +1350,7 @@ int32_t FRAME_PackMsg(FRAME_Type *frameType, const FRAME_Msg *msg, uint8_t *buff
1348 return HITLS_INTERNAL_EXCEPTION;1350 return HITLS_INTERNAL_EXCEPTION;
1349 }1351 }
1350 1352 
1351- if (IS_DTLS_VERSION(frameType->versionType)) { // DTLS1353+ if (IS_TRANSTYPE_DATAGRAM(frameType->transportType)) { // DTLS
1352 if (bufLen < DTLS_RECORD_HEADER_LEN) {1354 if (bufLen < DTLS_RECORD_HEADER_LEN) {
1353 return HITLS_INTERNAL_EXCEPTION;1355 return HITLS_INTERNAL_EXCEPTION;
1354 }1356 }
@@ -1373,7 +1375,7 @@ int32_t FRAME_PackMsg(FRAME_Type *frameType, const FRAME_Msg *msg, uint8_t *buff
1373 }1375 }
1374 1376 
1375 // Assemble the packet header.1377 // Assemble the packet header.
1376- PackRecordHeader(frameType->versionType, msg, bodyLen, buffer, headerLen, &headerLen);1378+ PackRecordHeader(frameType->versionType, msg, bodyLen, buffer, headerLen, &headerLen, frameType->transportType);
1377 1379 
1378 // Splicing body and head1380 // Splicing body and head
1379 // If some fields are missing in the header, the packet body is filled with an offset forward.1381 // If some fields are missing in the header, the packet body is filled with an offset forward.
Mtestcode/framework/tls/msg/src/frame_parse_msg.c+4-4
@@ -347,7 +347,7 @@ static int32_t ParseClientHelloMsg(FRAME_Type *frameType, const uint8_t *buffer,
347 ParseFieldInteger8(&buffer[offset], bufLen - offset, &clientHello->sessionIdSize, &offset);347 ParseFieldInteger8(&buffer[offset], bufLen - offset, &clientHello->sessionIdSize, &offset);
348 ParseFieldArray8(&buffer[offset], bufLen - offset, &clientHello->sessionId,348 ParseFieldArray8(&buffer[offset], bufLen - offset, &clientHello->sessionId,
349 clientHello->sessionIdSize.data, &offset);349 clientHello->sessionIdSize.data, &offset);
350- if (IS_DTLS_VERSION(frameType->versionType)) {350+ if (IS_TRANSTYPE_DATAGRAM(frameType->transportType)) {
351 ParseFieldInteger8(&buffer[offset], bufLen - offset, &clientHello->cookiedLen, &offset);351 ParseFieldInteger8(&buffer[offset], bufLen - offset, &clientHello->cookiedLen, &offset);
352 ParseFieldArray8(&buffer[offset], bufLen - offset, &clientHello->cookie, clientHello->cookiedLen.data, &offset);352 ParseFieldArray8(&buffer[offset], bufLen - offset, &clientHello->cookie, clientHello->cookiedLen.data, &offset);
353 }353 }
@@ -789,7 +789,7 @@ static int32_t ParseClientKxMsg(FRAME_Type *frameType, const uint8_t *buffer, ui
789 case HITLS_KEY_EXCH_ECDHE:789 case HITLS_KEY_EXCH_ECDHE:
790 /* Compatible with OpenSSL. Three bytes are added to the client key exchange. */790 /* Compatible with OpenSSL. Three bytes are added to the client key exchange. */
791#ifdef HITLS_TLS_PROTO_TLCP11791#ifdef HITLS_TLS_PROTO_TLCP11
792- if (frameType->versionType == HITLS_VERSION_TLCP11) {792+ if (frameType->versionType == HITLS_VERSION_TLCP_DTLCP11) {
793 // Curve type + Curve ID + Public key length793 // Curve type + Curve ID + Public key length
794 uint8_t minLen = sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint8_t);794 uint8_t minLen = sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint8_t);
795 if (bufLen < minLen) {795 if (bufLen < minLen) {
@@ -904,7 +904,7 @@ static int32_t ParseHsMsg(FRAME_Type *frameType, const uint8_t *buffer, uint32_t
904 ParseFieldInteger8(&buffer[0], bufLen, &hsMsg->type, &offset);904 ParseFieldInteger8(&buffer[0], bufLen, &hsMsg->type, &offset);
905 ParseFieldInteger24(&buffer[offset], bufLen - offset, &hsMsg->length, &offset);905 ParseFieldInteger24(&buffer[offset], bufLen - offset, &hsMsg->length, &offset);
906 906 
907- if (IS_DTLS_VERSION(frameType->versionType)) {907+ if (IS_TRANSTYPE_DATAGRAM(frameType->transportType)) {
908 ParseFieldInteger16(&buffer[offset], bufLen - offset, &hsMsg->sequence, &offset);908 ParseFieldInteger16(&buffer[offset], bufLen - offset, &hsMsg->sequence, &offset);
909 ParseFieldInteger24(&buffer[offset], bufLen - offset, &hsMsg->fragmentOffset, &offset);909 ParseFieldInteger24(&buffer[offset], bufLen - offset, &hsMsg->fragmentOffset, &offset);
910 ParseFieldInteger24(&buffer[offset], bufLen - offset, &hsMsg->fragmentLength, &offset);910 ParseFieldInteger24(&buffer[offset], bufLen - offset, &hsMsg->fragmentLength, &offset);
@@ -1017,7 +1017,7 @@ int32_t FRAME_ParseMsgHeader(
1017 ParseFieldInteger8(&buffer[0], bufLen, &msg->recType, &offset);1017 ParseFieldInteger8(&buffer[0], bufLen, &msg->recType, &offset);
1018 ParseFieldInteger16(&buffer[offset], bufLen - offset, &msg->recVersion, &offset);1018 ParseFieldInteger16(&buffer[offset], bufLen - offset, &msg->recVersion, &offset);
1019 1019 
1020- if (IS_DTLS_VERSION(frameType->versionType)) {1020+ if (IS_TRANSTYPE_DATAGRAM(frameType->transportType)) {
1021 ParseFieldInteger16(&buffer[offset], bufLen - offset, &msg->epoch, &offset);1021 ParseFieldInteger16(&buffer[offset], bufLen - offset, &msg->epoch, &offset);
1022 ParseFieldInteger48(&buffer[offset], bufLen - offset, &msg->sequence, &offset);1022 ParseFieldInteger48(&buffer[offset], bufLen - offset, &msg->sequence, &offset);
1023 }1023 }
Mtestcode/framework/tls/msg/src/pack_frame_msg.c+2-2
@@ -64,7 +64,7 @@ int32_t GenClientHelloMandatoryCtx(TLS_Ctx *tlsCtx, FRAME_Msg *msg)
64 }64 }
65 65 
66#ifdef HITLS_TLS_PROTO_DTLS1266#ifdef HITLS_TLS_PROTO_DTLS12
67- if (IS_DTLS_VERSION(clientHello->version) && clientHello->cookieLen > 0) {67+ if (IS_SUPPORT_DATAGRAM(tlsConfig->originVersionMask) && clientHello->cookieLen > 0) {
68 tlsCtx->negotiatedInfo.cookieSize = clientHello->cookieLen;68 tlsCtx->negotiatedInfo.cookieSize = clientHello->cookieLen;
69 tlsCtx->negotiatedInfo.cookie = (uint8_t *)BSL_SAL_Dump(clientHello->cookie, clientHello->cookieLen);69 tlsCtx->negotiatedInfo.cookie = (uint8_t *)BSL_SAL_Dump(clientHello->cookie, clientHello->cookieLen);
70 if (tlsCtx->negotiatedInfo.cookie == NULL) {70 if (tlsCtx->negotiatedInfo.cookie == NULL) {
@@ -409,7 +409,7 @@ int32_t PackRecordHeader(FRAME_Msg *msg)
409 offset += sizeof(uint16_t);409 offset += sizeof(uint16_t);
410 410 
411#ifdef HITLS_TLS_PROTO_DTLS12411#ifdef HITLS_TLS_PROTO_DTLS12
412- if (IS_DTLS_VERSION(msg->version)) {412+ if (IS_TRANSTYPE_DATAGRAM(msg->transportType)) {
413 BSL_Uint64ToByte(msg->epochSeq, &msg->buffer[offset]);413 BSL_Uint64ToByte(msg->epochSeq, &msg->buffer[offset]);
414 offset += sizeof(uint64_t);414 offset += sizeof(uint64_t);
415 }415 }
Mtestcode/framework/tls/msg/src/parser_frame_msg.c+1-1
@@ -46,7 +46,7 @@ int32_t ParserRecordHeader(FRAME_Msg *frameMsg, const uint8_t *buffer, uint32_t
46 bufOffset += sizeof(uint16_t);46 bufOffset += sizeof(uint16_t);
47 47 
48#ifdef HITLS_TLS_PROTO_DTLS1248#ifdef HITLS_TLS_PROTO_DTLS12
49- if (IS_DTLS_VERSION(frameMsg->version)) {49+ if (IS_TRANSTYPE_DATAGRAM(frameMsg->transportType)) {
50 frameMsg->epochSeq = BSL_ByteToUint64(&buffer[bufOffset]);50 frameMsg->epochSeq = BSL_ByteToUint64(&buffer[bufOffset]);
51 bufOffset += sizeof(uint64_t);51 bufOffset += sizeof(uint64_t);
52 }52 }
Mtestcode/framework/tls/rpc/src/hitls_func.c+6-0
@@ -251,6 +251,12 @@ HITLS_Config *HitlsNewCtx(TLS_VERSION tlsVersion)
251 LOG_DEBUG("HiTLS New TLCP1_1 Ctx");251 LOG_DEBUG("HiTLS New TLCP1_1 Ctx");
252 hitlsConfig = HITLS_CFG_NewTLCPConfig();252 hitlsConfig = HITLS_CFG_NewTLCPConfig();
253 break;253 break;
254+#endif
255+#ifdef HITLS_TLS_PROTO_DTLCP11
256+ case DTLCP1_1:
257+ LOG_DEBUG("HiTLS New DTLCP1_1 Ctx");
258+ hitlsConfig = HITLS_CFG_NewDTLCPConfig();
259+ break;
254#endif260#endif
255 default:261 default:
256 /* Unknown protocol type */262 /* Unknown protocol type */
Mtestcode/framework/tls/rpc/src/hlt_func.c+2-2
@@ -525,8 +525,8 @@ HLT_Ctx_Config* HLT_NewCtxConfigTLCP(char *setFile, const char *key, bool isClie
525 ctxConfig->isSupportClientVerify = false;525 ctxConfig->isSupportClientVerify = false;
526 ctxConfig->isSupportNoClientCert = false;526 ctxConfig->isSupportNoClientCert = false;
527 ctxConfig->isSupportExtendMasterSecret = false;527 ctxConfig->isSupportExtendMasterSecret = false;
528- ctxConfig->minVersion = HITLS_VERSION_TLCP11;528+ ctxConfig->minVersion = HITLS_VERSION_TLCP_DTLCP11;
529- ctxConfig->maxVersion = HITLS_VERSION_TLCP11;529+ ctxConfig->maxVersion = HITLS_VERSION_TLCP_DTLCP11;
530 ctxConfig->isClient = isClient;530 ctxConfig->isClient = isClient;
531 ctxConfig->setSessionCache = 2;531 ctxConfig->setSessionCache = 2;
532 HLT_SetGroups(ctxConfig, "NULL");532 HLT_SetGroups(ctxConfig, "NULL");
Mtestcode/sdv/testcase/tls/ciphersuite/test_suite_sdv_hlt_ciphersuite.c+5-2
@@ -168,7 +168,7 @@ static void CONNECT(int version, int connType, char *Ciphersuite, int hasPsk, ch
168 168 
169 HLT_Ctx_Config *serverCtxConfig = NULL;169 HLT_Ctx_Config *serverCtxConfig = NULL;
170 HLT_Ctx_Config *clientCtxConfig = NULL;170 HLT_Ctx_Config *clientCtxConfig = NULL;
171- if (version == TLCP1_1) {171+ if (version == TLCP1_1 || version == DTLCP1_1) {
172 serverCtxConfig = HLT_NewCtxConfigTLCP(NULL, "SERVER", false);172 serverCtxConfig = HLT_NewCtxConfigTLCP(NULL, "SERVER", false);
173 clientCtxConfig = HLT_NewCtxConfigTLCP(NULL, "CLIENT", true);173 clientCtxConfig = HLT_NewCtxConfigTLCP(NULL, "CLIENT", true);
174 } else {174 } else {
@@ -188,7 +188,7 @@ static void CONNECT(int version, int connType, char *Ciphersuite, int hasPsk, ch
188 serverCtxConfig->securitylevel = g_testSecurityLevel;188 serverCtxConfig->securitylevel = g_testSecurityLevel;
189 clientCtxConfig->securitylevel = g_testSecurityLevel;189 clientCtxConfig->securitylevel = g_testSecurityLevel;
190 190 
191- if (version == TLCP1_1) {191+ if (version == TLCP1_1 || version == DTLCP1_1) {
192 SetGMCert(serverCtxConfig, clientCtxConfig, cert);192 SetGMCert(serverCtxConfig, clientCtxConfig, cert);
193 } else {193 } else {
194 SetCert(serverCtxConfig, cert);194 SetCert(serverCtxConfig, cert);
@@ -295,6 +295,9 @@ void SDV_TLS_GM_CIPHER_SUITE(void)
295 for (uint16_t i = 0; i < sizeof(HITLS_GM_Ciphersuite) / sizeof(HITLS_GM_Ciphersuite[0]); i++) {295 for (uint16_t i = 0; i < sizeof(HITLS_GM_Ciphersuite) / sizeof(HITLS_GM_Ciphersuite[0]); i++) {
296 SUB_PROC_BEGIN(continue);296 SUB_PROC_BEGIN(continue);
297 CONNECT(TLCP1_1, TCP, HITLS_GM_Ciphersuite[i], 0, "SM2");297 CONNECT(TLCP1_1, TCP, HITLS_GM_Ciphersuite[i], 0, "SM2");
298+ if (IsEnableSctpAuth()) {
299+ CONNECT(DTLCP1_1, SCTP, HITLS_GM_Ciphersuite[i], 0, "SM2");
300+ }
298 SUB_PROC_END();301 SUB_PROC_END();
299 }302 }
300 SUB_PROC_WAIT(sizeof(HITLS_GM_Ciphersuite) / sizeof(HITLS_GM_Ciphersuite[0]));303 SUB_PROC_WAIT(sizeof(HITLS_GM_Ciphersuite) / sizeof(HITLS_GM_Ciphersuite[0]));
Atestcode/sdv/testcase/tls/consistency/dtlcp/test_suite_sdv_frame_dtlcp_consistency.base.c+408-0
@@ -0,0 +1,408 @@
1+/*
2+ * This file is part of the openHiTLS project.
3+ *
4+ * openHiTLS is licensed under the Mulan PSL v2.
5+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
6+ * You may obtain a copy of Mulan PSL v2 at:
7+ *
8+ * http://license.coscl.org.cn/MulanPSL2
9+ *
10+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
11+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
12+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
13+ * See the Mulan PSL v2 for more details.
14+ */
15+ 
16+#include <stdio.h>
17+#include <stddef.h>
18+#include <unistd.h>
19+#include "securec.h"
20+#include "bsl_sal.h"
21+#include "hitls.h"
22+#include "hitls_config.h"
23+#include "hitls_error.h"
24+#include "hitls_cert_reg.h"
25+#include "hitls_crypt_type.h"
26+#include "tls.h"
27+#include "hs.h"
28+#include "hs_ctx.h"
29+#include "hs_state_recv.h"
30+#include "conn_init.h"
31+#include "recv_process.h"
32+#include "stub_replace.h"
33+#include "stub_crypt.h"
34+#include "frame_tls.h"
35+#include "frame_msg.h"
36+#include "simulate_io.h"
37+#include "parser_frame_msg.h"
38+#include "pack_frame_msg.h"
39+#include "frame_io.h"
40+#include "frame_link.h"
41+#include "cert.h"
42+#include "cert_mgr.h"
43+#include "hs_extensions.h"
44+#include "hlt_type.h"
45+#include "hlt.h"
46+#include "sctp_channel.h"
47+#include "rec_wrapper.h"
48+#include "process.h"
49+#include "pthread.h"
50+#include "unistd.h"
51+#include "rec_header.h"
52+#include "bsl_log.h"
53+#include "cert_callback.h"
54+ 
55+ 
56+#define BUF_SIZE_DTO_TEST 18432
57+int32_t g_uiPort = 18887;
58+ 
59+#define PARSEMSGHEADER_LEN 13
60+#define ILLEGAL_VALUE 0xFF
61+#define HASH_EXDATA_LEN_ERROR 23
62+#define SIGNATURE_ALGORITHMS 0x04, 0x03
63+#define READ_BUF_SIZE (18 * 1024)
64+#define TEMP_DATA_LEN 1024
65+#define REC_DTLS_RECORD_HEADER_LEN 13
66+#define BUF_TOOLONG_LEN ((1 << 14) + 1)
67+ 
68+typedef struct {
69+ HITLS_Config *config;
70+ FRAME_LinkObj *client;
71+ FRAME_LinkObj *server;
72+ HITLS_HandshakeState state;
73+ bool isClient;
74+ bool isSupportExtendMasterSecret;
75+ bool isSupportClientVerify;
76+ bool isSupportNoClientCert;
77+ bool isSupportRenegotiation;
78+} HandshakeTestInfo;
79+ 
80+int32_t StatusPark(HandshakeTestInfo *testInfo, int uioType)
81+{
82+ testInfo->client = FRAME_CreateTLCPLink(testInfo->config, uioType, true);
83+ if (testInfo->client == NULL) {
84+ return HITLS_INTERNAL_EXCEPTION;
85+ }
86+ 
87+ testInfo->server = FRAME_CreateTLCPLink(testInfo->config, uioType, false);
88+ if (testInfo->server == NULL) {
89+ return HITLS_INTERNAL_EXCEPTION;
90+ }
91+ 
92+ if (FRAME_CreateConnection(testInfo->client, testInfo->server,
93+ testInfo->isClient, testInfo->state) != HITLS_SUCCESS) {
94+ return HITLS_INTERNAL_EXCEPTION;
95+ }
96+ 
97+ return HITLS_SUCCESS;
98+}
99+ 
100+int32_t DefaultCfgStatusPark(HandshakeTestInfo *testInfo, int uioType)
101+{
102+ FRAME_Init();
103+ 
104+ testInfo->config = HITLS_CFG_NewDTLCPConfig();
105+ 
106+ if (testInfo->config == NULL) {
107+ return HITLS_INTERNAL_EXCEPTION;
108+ }
109+ 
110+ HITLS_CFG_SetCheckKeyUsage(testInfo->config, false);
111+ testInfo->config->isSupportExtendMasterSecret = testInfo->isSupportExtendMasterSecret;
112+ testInfo->config->isSupportClientVerify = testInfo->isSupportClientVerify;
113+ testInfo->config->isSupportNoClientCert = testInfo->isSupportNoClientCert;
114+ testInfo->config->isSupportRenegotiation = testInfo->isSupportRenegotiation;
115+ 
116+ return StatusPark(testInfo, uioType);
117+}
118+ 
119+int32_t DefaultCfgStatusParkWithSuite(HandshakeTestInfo *testInfo)
120+{
121+ FRAME_Init();
122+ 
123+ 
124+ testInfo->config = HITLS_CFG_NewDTLCPConfig();
125+ if (testInfo->config == NULL) {
126+ return HITLS_INTERNAL_EXCEPTION;
127+ }
128+ 
129+ HITLS_CFG_SetCheckKeyUsage(testInfo->config, false);
130+ uint16_t cipherSuits[] = {HITLS_ECDHE_SM4_CBC_SM3,HITLS_ECC_SM4_CBC_SM3};
131+ HITLS_CFG_SetCipherSuites(testInfo->config, cipherSuits, sizeof(cipherSuits) / sizeof(uint16_t));
132+ 
133+ testInfo->config->isSupportExtendMasterSecret = testInfo->isSupportExtendMasterSecret;
134+ testInfo->config->isSupportClientVerify = testInfo->isSupportClientVerify;
135+ testInfo->config->isSupportNoClientCert = testInfo->isSupportNoClientCert;
136+ 
137+ return StatusPark(testInfo, BSL_UIO_SCTP);
138+}
139+ 
140+int32_t SendHelloReqWithIndex(HITLS_Ctx *ctx, uint8_t index)
141+{
142+ int32_t ret;
143+ 
144+ uint8_t buf[DTLS_HS_MSG_HEADER_SIZE] = {0u};
145+ buf[5] = index;
146+ size_t len = DTLS_HS_MSG_HEADER_SIZE;
147+ 
148+ 
149+ ret = REC_Write(ctx, REC_TYPE_HANDSHAKE, buf, len);
150+ return ret;
151+}
152+ 
153+int32_t ConstructAnEmptyCertMsg(FRAME_LinkObj *link)
154+{
155+ FRAME_Msg frameMsg = {0};
156+ FrameUioUserData *ioUserData = BSL_UIO_GetUserData(link->io);
157+ 
158+ 
159+ uint8_t *buffer = ioUserData->recMsg.msg;
160+ uint32_t len = ioUserData->recMsg.len;
161+ if (len == 0) {
162+ return HITLS_MEMCPY_FAIL;
163+ }
164+ 
165+ 
166+ uint32_t parseLen = 0;
167+ if (ParserTotalRecord(link, &frameMsg, buffer, len, &parseLen) != HITLS_SUCCESS) {
168+ return HITLS_INTERNAL_EXCEPTION;
169+ }
170+ 
171+ 
172+ CERT_Item *tmpCert = frameMsg.body.handshakeMsg.body.certificate.cert;
173+ frameMsg.body.handshakeMsg.body.certificate.cert = NULL;
174+ frameMsg.bodyLen = 15;
175+ 
176+ 
177+ if (PackFrameMsg(&frameMsg) != HITLS_SUCCESS) {
178+ frameMsg.body.handshakeMsg.body.certificate.cert = tmpCert;
179+ CleanRecordBody(&frameMsg);
180+ return HITLS_INTERNAL_EXCEPTION;
181+ }
182+ 
183+ 
184+ ioUserData->recMsg.len = 0;
185+ if (FRAME_TransportRecMsg(link->io, frameMsg.buffer, frameMsg.len) != HITLS_SUCCESS) {
186+ frameMsg.body.handshakeMsg.body.certificate.cert = tmpCert;
187+ CleanRecordBody(&frameMsg);
188+ return HITLS_INTERNAL_EXCEPTION;
189+ }
190+ 
191+ frameMsg.body.handshakeMsg.body.certificate.cert = tmpCert;
192+ CleanRecordBody(&frameMsg);
193+ return HITLS_SUCCESS;
194+}
195+ 
196+static int32_t GetDisorderClientFinished1(FRAME_LinkObj *client, uint8_t *data, uint32_t len, uint32_t *usedLen)
197+{
198+ int32_t ret;
199+ uint32_t readLen = 0;
200+ uint32_t offset = 0;
201+ (void)HITLS_Connect(client->ssl);
202+ ret = FRAME_TransportSendMsg(client->io, &data[offset], len - offset, &readLen);
203+ if (readLen == 0 || ret != HITLS_SUCCESS) {
204+ return HITLS_INTERNAL_EXCEPTION;
205+ }
206+ offset += readLen;
207+ 
208+ (void)HITLS_Connect(client->ssl);
209+ ret = FRAME_TransportSendMsg(client->io, &data[offset], len - offset, &readLen);
210+ if (readLen == 0 || ret != HITLS_SUCCESS) {
211+ return HITLS_INTERNAL_EXCEPTION;
212+ }
213+ offset += readLen;
214+ 
215+ uint8_t tmpData[TEMP_DATA_LEN] = {0};
216+ uint32_t tmpLen = sizeof(tmpData);
217+ (void)HITLS_Connect(client->ssl);
218+ ret = FRAME_TransportSendMsg(client->io, tmpData, tmpLen, &readLen);
219+ if (readLen == 0 || ret != HITLS_SUCCESS) {
220+ return HITLS_INTERNAL_EXCEPTION;
221+ }
222+ tmpLen = readLen;
223+ (void)HITLS_Connect(client->ssl);
224+ ret = FRAME_TransportSendMsg(client->io, &data[offset], len - offset, &readLen);
225+ if (readLen == 0 || ret != HITLS_SUCCESS) {
226+ return HITLS_INTERNAL_EXCEPTION;
227+ }
228+ offset += readLen;
229+ if (memcpy_s(&data[offset], len - offset, tmpData, tmpLen) != EOK) {
230+ return HITLS_MEMCPY_FAIL;
231+ }
232+ offset += tmpLen;
233+ *usedLen = offset;
234+ return HITLS_SUCCESS;
235+}
236+ 
237+static int32_t GetDisorderServerFinished(FRAME_LinkObj *server, uint8_t *data, uint32_t len, uint32_t *usedLen)
238+{
239+ int32_t ret;
240+ uint32_t readLen = 0;
241+ uint32_t offset = 0;
242+ uint8_t tmpData[TEMP_DATA_LEN] = {0};
243+ uint32_t tmpLen = sizeof(tmpData);
244+ (void)HITLS_Accept(server->ssl);
245+ ret = FRAME_TransportSendMsg(server->io, tmpData, tmpLen, &readLen);
246+ if (readLen == 0 || ret != HITLS_SUCCESS) {
247+ return HITLS_INTERNAL_EXCEPTION;
248+ }
249+ tmpLen = readLen;
250+ (void)HITLS_Accept(server->ssl);
251+ ret = FRAME_TransportSendMsg(server->io, &data[offset], len - offset, &readLen);
252+ if (readLen == 0 || ret != HITLS_SUCCESS) {
253+ return HITLS_INTERNAL_EXCEPTION;
254+ }
255+ offset += readLen;
256+ if (memcpy_s(&data[offset], len - offset, tmpData, tmpLen) != EOK) {
257+ return HITLS_MEMCPY_FAIL;
258+ }
259+ offset += tmpLen;
260+ *usedLen = offset;
261+ return HITLS_SUCCESS;
262+}
263+ 
264+static int32_t AppWrite(HITLS_Ctx *ctx)
265+{
266+ int32_t ret;
267+ uint8_t writeBuf[] = "GET HTTP 1.0";
268+ uint32_t len = strlen((char *)writeBuf);
269+ do {
270+ uint32_t writeLen;
271+ ret = HITLS_Write(ctx, writeBuf, len, &writeLen);
272+ } while (ret == HITLS_REC_NORMAL_RECV_BUF_EMPTY || ret == HITLS_REC_NORMAL_IO_BUSY);
273+ return ret;
274+}
275+ 
276+static int32_t GetDisorderServerFinish_AppData(FRAME_LinkObj *server, uint8_t *data, uint32_t len, uint32_t *usedLen)
277+{
278+ int32_t ret;
279+ uint32_t readLen = 0;
280+ uint32_t offset = 0;
281+ uint8_t ccs[TEMP_DATA_LEN] = {0};
282+ uint32_t ccsLen = sizeof(ccs);
283+ (void)HITLS_Accept(server->ssl);
284+ ret = FRAME_TransportSendMsg(server->io, ccs, ccsLen, &readLen);
285+ if (readLen == 0 || ret != HITLS_SUCCESS) {
286+ return HITLS_INTERNAL_EXCEPTION;
287+ }
288+ ccsLen = readLen;
289+ uint8_t finished[TEMP_DATA_LEN] = {0};
290+ uint32_t finishedLen = sizeof(finished);
291+ (void)HITLS_Accept(server->ssl);
292+ ret = FRAME_TransportSendMsg(server->io, finished, finishedLen, &readLen);
293+ if (readLen == 0 || ret != HITLS_SUCCESS) {
294+ return HITLS_INTERNAL_EXCEPTION;
295+ }
296+ finishedLen = readLen;
297+ uint8_t app[TEMP_DATA_LEN] = {0};
298+ uint32_t appLen = sizeof(finished);
299+ ret = AppWrite(server->ssl);
300+ if (ret != HITLS_SUCCESS) {
301+ return ret;
302+ }
303+ ret = FRAME_TransportSendMsg(server->io, app, appLen, &readLen);
304+ if (readLen == 0 || ret != HITLS_SUCCESS) {
305+ return HITLS_INTERNAL_EXCEPTION;
306+ }
307+ appLen = readLen;
308+ if (memcpy_s(&data[offset], len - offset, ccs, ccsLen) != EOK) {
309+ return HITLS_MEMCPY_FAIL;
310+ }
311+ offset += ccsLen;
312+ if (memcpy_s(&data[offset], len - offset, app, appLen) != EOK) {
313+ return HITLS_MEMCPY_FAIL;
314+ }
315+ offset += appLen;
316+ if (memcpy_s(&data[offset], len - offset, finished, finishedLen) != EOK) {
317+ return HITLS_MEMCPY_FAIL;
318+ }
319+ offset += finishedLen;
320+ *usedLen = offset;
321+ return HITLS_SUCCESS;
322+}
323+ 
324+int32_t DefaultCfgStatusPark1(HandshakeTestInfo *testInfo)
325+{
326+ FRAME_Init();
327+ testInfo->config = HITLS_CFG_NewDTLCPConfig();
328+ if (testInfo->config == NULL) {
329+ return HITLS_INTERNAL_EXCEPTION;
330+ }
331+ 
332+ HITLS_CFG_SetCheckKeyUsage(testInfo->config, false);
333+ uint16_t groups[] = {HITLS_EC_GROUP_SM2};
334+ HITLS_CFG_SetGroups(testInfo->config, groups, sizeof(groups) / sizeof(uint16_t));
335+ uint16_t signAlgs[] = {CERT_SIG_SCHEME_SM2_SM3};
336+ HITLS_CFG_SetSignature(testInfo->config, signAlgs, sizeof(signAlgs) / sizeof(uint16_t));
337+ HITLS_CFG_SetClientVerifySupport(testInfo->config, testInfo->isSupportClientVerify);
338+ HITLS_CFG_SetNoClientCertSupport(testInfo->config, false);
339+ HITLS_CFG_SetExtenedMasterSecretSupport(testInfo->config, true);
340+ return StatusPark(testInfo, BSL_UIO_SCTP);
341+}
342+ 
343+static int32_t GetRepeatsApp(FRAME_LinkObj *obj, uint8_t *data, uint32_t *usedLen)
344+{
345+ int32_t ret;
346+ uint32_t readLen = 0;
347+ uint32_t offset = 0;
348+ uint8_t app[TEMP_DATA_LEN] = {0};
349+ uint32_t appLen = sizeof(app);
350+ ret = AppWrite(obj->ssl);
351+ if (ret != HITLS_SUCCESS) {
352+ return ret;
353+ }
354+ ret = FRAME_TransportSendMsg(obj->io, app, appLen, &readLen);
355+ if (readLen == 0 || ret != HITLS_SUCCESS) {
356+ return HITLS_INTERNAL_EXCEPTION;
357+ }
358+ appLen = readLen;
359+ if (memcpy_s(&data[offset], TEMP_DATA_LEN, app, appLen) != EOK) {
360+ return HITLS_MEMCPY_FAIL;
361+ }
362+ offset += appLen;
363+ if (memcpy_s(&data[offset], TEMP_DATA_LEN - offset, app, appLen) != EOK) {
364+ return HITLS_MEMCPY_FAIL;
365+ }
366+ offset += appLen;
367+ *usedLen = offset;
368+ return HITLS_SUCCESS;
369+}
370+ 
371+static int32_t GetDisorderApp(FRAME_LinkObj *obj, uint8_t *data, uint32_t *usedLen)
372+{
373+ int32_t ret;
374+ uint32_t readLen = 0;
375+ uint32_t offset = 0;
376+ uint8_t app1[TEMP_DATA_LEN] = {0};
377+ uint32_t app1Len = sizeof(app1);
378+ ret = AppWrite(obj->ssl);
379+ if (ret != HITLS_SUCCESS) {
380+ return ret;
381+ }
382+ ret = FRAME_TransportSendMsg(obj->io, app1, app1Len, &readLen);
383+ if (readLen == 0 || ret != HITLS_SUCCESS) {
384+ return HITLS_INTERNAL_EXCEPTION;
385+ }
386+ app1Len = readLen;
387+ uint8_t app2[TEMP_DATA_LEN] = {0};
388+ uint32_t app2Len = sizeof(app2);
389+ ret = AppWrite(obj->ssl);
390+ if (ret != HITLS_SUCCESS) {
391+ return ret;
392+ }
393+ ret = FRAME_TransportSendMsg(obj->io, app2, app2Len, &readLen);
394+ if (readLen == 0 || ret != HITLS_SUCCESS) {
395+ return HITLS_INTERNAL_EXCEPTION;
396+ }
397+ app2Len = readLen;
398+ if (memcpy_s(&data[offset], TEMP_DATA_LEN, app2, app2Len) != EOK) {
399+ return HITLS_MEMCPY_FAIL;
400+ }
401+ offset += app2Len;
402+ if (memcpy_s(&data[offset], TEMP_DATA_LEN - offset, app1, app1Len) != EOK) {
403+ return HITLS_MEMCPY_FAIL;
404+ }
405+ offset += app1Len;
406+ *usedLen = offset;
407+ return HITLS_SUCCESS;
408+}
Atestcode/sdv/testcase/tls/consistency/dtlcp/test_suite_sdv_frame_dtlcp_consistency.c+654-0
@@ -0,0 +1,654 @@
1+/*
2+ * This file is part of the openHiTLS project.
3+ *
4+ * openHiTLS is licensed under the Mulan PSL v2.
5+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
6+ * You may obtain a copy of Mulan PSL v2 at:
7+ *
8+ * http://license.coscl.org.cn/MulanPSL2
9+ *
10+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
11+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
12+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
13+ * See the Mulan PSL v2 for more details.
14+ */
15+ 
16+/* BEGIN_HEADER */
17+/* INCLUDE_BASE test_suite_sdv_frame_dtlcp_consistency */
18+/* END_HEADER */
19+ 
20+ 
21+/* @
22+* @test UT_TLS_DTLCP_CONSISTENCY_RFC6083_RETRANSMISSION_TC001
23+* @spec -
24+* @title Check that DTLCP over SCTP does not support retransmission.
25+* @precon nan
26+* @brief 1. Use the default initialization mode on the client and server. Expected result 1.
27+* 2. The client initiates a DTLCP connection request. After receiving the client hello packet, the server does not reply with the server hello packet. The delay is 3 seconds. Check the sending buffer of the client. Expected result 2.
28+* @expect 1: The initialization is successful.
29+* 2: The sending buffer of the client is empty.
30+* @prior Level 1
31+* @auto TRUE
32+@ */
33+/* BEGIN_CASE */
34+void UT_TLS_DTLCP_CONSISTENCY_RFC6083_RETRANSMISSION_TC001(void)
35+{
36+ HandshakeTestInfo testInfo = {0};
37+ testInfo.state = TRY_SEND_CLIENT_HELLO;
38+ testInfo.isSupportExtendMasterSecret = true;
39+ testInfo.isClient = true;
40+ ASSERT_TRUE(DefaultCfgStatusPark(&testInfo, BSL_UIO_SCTP) == HITLS_SUCCESS);
41+ 
42+ CONN_Deinit(testInfo.client->ssl);
43+ 
44+ ASSERT_TRUE(testInfo.client->ssl != NULL);
45+ ASSERT_EQ(HITLS_Connect(testInfo.client->ssl), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
46+ 
47+ ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(testInfo.client, testInfo.server) == HITLS_SUCCESS);
48+ 
49+ sleep(3);
50+ 
51+ ASSERT_TRUE(testInfo.client->ssl != NULL);
52+ ASSERT_EQ(HITLS_Connect(testInfo.client->ssl), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
53+ 
54+ FrameUioUserData *ioUserData = BSL_UIO_GetUserData(testInfo.client->io);
55+ uint32_t sndLen = ioUserData->sndMsg.len;
56+ ASSERT_TRUE(sndLen == 0);
57+ 
58+EXIT:
59+ HITLS_CFG_FreeConfig(testInfo.config);
60+ FRAME_FreeLink(testInfo.client);
61+ FRAME_FreeLink(testInfo.server);
62+}
63+/* END_CASE */
64+ 
65+/* @
66+* @test UT_TLS_DTLCP_CONSISTENCY_RFC6347_FINISH_TC001
67+* @spec -
68+* @titleThe client receives a FINISH message and the CCS message is out of order.
69+* @precon nan
70+* @brief 1. Initialize the client and server based on the default configuration. Expected result 1.
71+* 2. The client initiates a connection request and constructs the scenario where the FINISH message and CCS message are out of order. That is, the client processes the FINISH message and then processes the CCS message. After the processing, the client continues to establish a connection. Expected result 2 is displayed.
72+* @expect 1: The initialization is successful.
73+* 2: The client waits to receive the FINISH message.
74+* @prior Level 1
75+* @auto TRUE
76+@ */
77+/* BEGIN_CASE */
78+void UT_TLS_DTLCP_CONSISTENCY_RFC6347_FINISH_TC001(void)
79+{
80+ HandshakeTestInfo testInfo = {0};
81+ testInfo.isClient = false;
82+ testInfo.state = TRY_SEND_CHANGE_CIPHER_SPEC;
83+ ASSERT_TRUE(DefaultCfgStatusPark(&testInfo, BSL_UIO_SCTP) == HITLS_SUCCESS);
84+ uint8_t data[MAX_RECORD_LENTH] = {0};
85+ uint32_t len = MAX_RECORD_LENTH;
86+ ASSERT_TRUE(GetDisorderServerFinished(testInfo.server, data, len, &len) == HITLS_SUCCESS);
87+ FrameUioUserData *ioUserData = BSL_UIO_GetUserData(testInfo.client->io);
88+ ASSERT_TRUE(ioUserData->recMsg.len == 0);
89+ ASSERT_TRUE(FRAME_TransportRecMsg(testInfo.client->io, data, len) == HITLS_SUCCESS);
90+ (void)HITLS_Connect(testInfo.client->ssl);
91+ ASSERT_TRUE(testInfo.client->ssl->state == CM_STATE_HANDSHAKING);
92+ ASSERT_TRUE(testInfo.client->ssl->hsCtx->state == TRY_RECV_FINISH);
93+ 
94+EXIT:
95+ HITLS_CFG_FreeConfig(testInfo.config);
96+ FRAME_FreeLink(testInfo.client);
97+ FRAME_FreeLink(testInfo.server);
98+}
99+/* END_CASE */
100+ 
101+/* @
102+* @test UT_TLS_DTLS_CONSISTENCY_RFC6347_FINISH_TC002
103+* @spec -
104+* @titleThe server receives a FINISH message and the CCS message is out of order.
105+* @precon nan
106+* @brief 1. Initialize the client and server based on the default configuration. Expected result 1.
107+* 2. The client initiates a connection request and constructs the scenario where the FINISH message and CCS message are out of order.
108+That is, the server processes the FINISH message and then processes the CCS message. After the processing, the server continues to
109+establish a connection. Expected result 2 is displayed.
110+* @expect 1: The initialization is successful.
111+* 2: The server is waiting to receive the FINISH message.
112+* @prior Level 1
113+* @auto TRUE
114+@ */
115+/* BEGIN_CASE */
116+void UT_TLS_DTLCP_CONSISTENCY_RFC6347_FINISH_TC002(void)
117+{
118+ FRAME_Msg frameMsg = {0};
119+ FRAME_Type frameType = {0};
120+ HandshakeTestInfo testInfo = {0};
121+ testInfo.isClient = true;
122+ testInfo.state = TRY_SEND_CLIENT_KEY_EXCHANGE;
123+ ASSERT_TRUE(DefaultCfgStatusPark(&testInfo, BSL_UIO_SCTP) == HITLS_SUCCESS);
124+ uint8_t data[MAX_RECORD_LENTH] = {0};
125+ uint32_t len = MAX_RECORD_LENTH;
126+ ASSERT_TRUE(GetDisorderClientFinished1(testInfo.client, data, len, &len) == HITLS_SUCCESS);
127+ FrameUioUserData *ioUserData = BSL_UIO_GetUserData(testInfo.server->io);
128+ ASSERT_TRUE(ioUserData->recMsg.len == 0);
129+ ASSERT_TRUE(FRAME_TransportRecMsg(testInfo.server->io, data, len) == HITLS_SUCCESS);
130+ (void)HITLS_Accept(testInfo.server->ssl);
131+ ASSERT_TRUE(testInfo.server->ssl->state == CM_STATE_HANDSHAKING);
132+ ASSERT_TRUE(testInfo.server->ssl->hsCtx->state == TRY_RECV_FINISH);
133+ 
134+EXIT:
135+ FRAME_CleanMsg(&frameType, &frameMsg);
136+ HITLS_CFG_FreeConfig(testInfo.config);
137+ FRAME_FreeLink(testInfo.client);
138+ FRAME_FreeLink(testInfo.server);
139+}
140+/* END_CASE */
141+ 
142+/* @
143+* @test UT_TLS_DTLCP_CONSISTENCY_RFC6347_FINISH_TC003
144+* @spec -
145+* @titleThe client receives a FINISH message and the APP message is out of order.
146+* @precon nan
147+* @brief 1. Initialize the client and server using the default configuration. Expected result 1.
148+* 2. The client initiates a connection request and constructs the scenario where the FINISH message and APP message are out of order. That is, the client processes the APP message first, processes the FINISH message, and then continues to establish a connection. Expected result 2.
149+* @expect 1: Initialization succeeded.
150+* 2: The connection between the client and server is successfully established.
151+* @prior Level 1
152+* @auto TRUE
153+@ */
154+/* BEGIN_CASE */
155+void UT_TLS_DTLCP_CONSISTENCY_RFC6347_FINISH_TC003(void)
156+{
157+ HandshakeTestInfo testInfo = {0};
158+ testInfo.isClient = false;
159+ testInfo.state = TRY_SEND_CHANGE_CIPHER_SPEC;
160+ ASSERT_TRUE(DefaultCfgStatusPark(&testInfo, BSL_UIO_SCTP) == HITLS_SUCCESS);
161+ uint8_t data[MAX_RECORD_LENTH] = {0};
162+ uint32_t len = MAX_RECORD_LENTH;
163+ ASSERT_TRUE(GetDisorderServerFinish_AppData(testInfo.server, data, len, &len) == HITLS_SUCCESS);
164+ FrameUioUserData *ioUserData = BSL_UIO_GetUserData(testInfo.client->io);
165+ ASSERT_TRUE(ioUserData->recMsg.len == 0);
166+ ASSERT_TRUE(FRAME_TransportRecMsg(testInfo.client->io, data, len) == HITLS_SUCCESS);
167+ (void)HITLS_Connect(testInfo.client->ssl);
168+ ASSERT_TRUE(testInfo.client->ssl->state == CM_STATE_TRANSPORTING);
169+ ASSERT_TRUE(HITLS_Read(testInfo.client->ssl, data, MAX_RECORD_LENTH, &len) == HITLS_SUCCESS);
170+ 
171+EXIT:
172+ HITLS_CFG_FreeConfig(testInfo.config);
173+ FRAME_FreeLink(testInfo.client);
174+ FRAME_FreeLink(testInfo.server);
175+}
176+/* END_CASE */
177+ 
178+/* @
179+* @test UT_TLS_DTLCP_CONSISTENCY_RFC6347_DISORDER_TC001
180+* @spec -
181+* @titleThe server receives out-of-order APP messages.
182+* @precon nan
183+* @brief 1. Initialize the configuration on the client and server. Expected result 1.
184+* 2. Initiate a connection application by using DTLCP. Expected result 2.
185+* 3. Construct an app message whose SN is 2 and send it to the server. When the server invokes HiTLS_Read, expected result 3.
186+* 4. Construct an app message whose SN is 1 and send it to the server. When the server invokes HiTLS_Read, expected result 4.
187+* @expect 1: Initializing the configuration succeeded.
188+* 2: The DTLCP connection is successfully created.
189+* 3: The interface returns a success response.
190+* 4: The interface returns a success response.
191+* @prior Level 1
192+* @auto TRUE
193+@ */
194+/* BEGIN_CASE */
195+void UT_TLS_DTLCP_CONSISTENCY_RFC6347_DISORDER_TC001(void)
196+{
197+ HandshakeTestInfo testInfo = {0};
198+ testInfo.isClient = true;
199+ testInfo.state = HS_STATE_BUTT;
200+ ASSERT_EQ(DefaultCfgStatusPark1(&testInfo), HITLS_SUCCESS);
201+ uint8_t data[MAX_RECORD_LENTH] = {0};
202+ uint32_t len = MAX_RECORD_LENTH;
203+ ASSERT_TRUE(GetDisorderApp(testInfo.client, data, &len) == HITLS_SUCCESS);
204+ FrameUioUserData *ioUserData = BSL_UIO_GetUserData(testInfo.server->io);
205+ ASSERT_TRUE(ioUserData->recMsg.len == 0);
206+ ASSERT_TRUE(FRAME_TransportRecMsg(testInfo.server->io, data, len) == HITLS_SUCCESS);
207+ uint8_t app1Data[MAX_RECORD_LENTH] = {0};
208+ uint32_t app1Len = MAX_RECORD_LENTH;
209+ ASSERT_TRUE(HITLS_Read(testInfo.server->ssl, app1Data, MAX_RECORD_LENTH, &app1Len) == HITLS_SUCCESS);
210+ uint8_t app2Data[MAX_RECORD_LENTH] = {0};
211+ uint32_t app2Len = MAX_RECORD_LENTH;
212+ ASSERT_TRUE(HITLS_Read(testInfo.server->ssl, app2Data, MAX_RECORD_LENTH, &app2Len) == HITLS_SUCCESS);
213+ ASSERT_EQ(app1Len, app2Len);
214+ ASSERT_EQ(memcmp(app1Data, app2Data, app2Len), 0);
215+EXIT:
216+ HITLS_CFG_FreeConfig(testInfo.config);
217+ FRAME_FreeLink(testInfo.client);
218+ FRAME_FreeLink(testInfo.server);
219+}
220+/* END_CASE */
221+ 
222+/* @
223+* @test UT_TLS_DTLCP_CONSISTENCY_RFC6347_DISORDER_TC002
224+* @spec -
225+* @titleThe client receives out-of-order APP messages.
226+* @precon nan
227+* @brief 1. Initialize the configuration on the client and server. Expected result 1.
228+* 2. Initiate a connection request using DTLCP. Expected result 2.
229+* 3. Construct an app message whose sequence number is 2 and send it to the client. When the client invokes HiTLS_Read, expected result 3.
230+* 4. Construct an app message whose sequence number is 1 and send it to the client. When the client invokes HiTLS_Read, expected result 4.
231+* @expect 1: Initializing the configuration succeeded.
232+* 2: The DTLCP connection is successfully created.
233+* 3: The interface returns a success response.
234+* 4: The interface returns a success response.
235+* @prior Level 1
236+* @auto TRUE
237+@ */
238+/* BEGIN_CASE */
239+void UT_TLS_DTLCP_CONSISTENCY_RFC6347_DISORDER_TC002(void)
240+{
241+ HandshakeTestInfo testInfo = {0};
242+ testInfo.isClient = false;
243+ testInfo.state = HS_STATE_BUTT;
244+ ASSERT_EQ(DefaultCfgStatusPark1(&testInfo), HITLS_SUCCESS);
245+ uint8_t data[MAX_RECORD_LENTH] = {0};
246+ uint32_t len = MAX_RECORD_LENTH;
247+ ASSERT_TRUE(GetDisorderApp(testInfo.server, data, &len) == HITLS_SUCCESS);
248+ FrameUioUserData *ioUserData = BSL_UIO_GetUserData(testInfo.client->io);
249+ ASSERT_TRUE(ioUserData->recMsg.len == 0);
250+ ASSERT_TRUE(FRAME_TransportRecMsg(testInfo.client->io, data, len) == HITLS_SUCCESS);
251+ uint8_t app1Data[MAX_RECORD_LENTH] = {0};
252+ uint32_t app1Len = MAX_RECORD_LENTH;
253+ ASSERT_TRUE(HITLS_Read(testInfo.client->ssl, app1Data, MAX_RECORD_LENTH, &app1Len) == HITLS_SUCCESS);
254+ uint8_t app2Data[MAX_RECORD_LENTH] = {0};
255+ uint32_t app2Len = MAX_RECORD_LENTH;
256+ ASSERT_TRUE(HITLS_Read(testInfo.client->ssl, app2Data, MAX_RECORD_LENTH, &app2Len) == HITLS_SUCCESS);
257+ ASSERT_EQ(app1Len, app2Len);
258+ ASSERT_EQ(memcmp(app1Data, app2Data, app1Len), 0);
259+EXIT:
260+ HITLS_CFG_FreeConfig(testInfo.config);
261+ FRAME_FreeLink(testInfo.client);
262+ FRAME_FreeLink(testInfo.server);
263+}
264+/* END_CASE */
265+ 
266+/* @
267+* @test UT_TLS_DTLCP_CONSISTENCY_RFC6347_APPDATA_TC001
268+* @spec -
269+* @title The server receives duplicate APP messages.
270+* @precon nan
271+* @brief 1. Initialize the configuration on the client and server. Expected result 1.
272+* 2. Initiate a connection application by using DTLCP. Expected result 2.
273+* 3. Construct an app message whose SN is 1 and send it to the server. When the server invokes HiTLS_Read, expected result 3.
274+* 4. Construct the app message whose SN is 1 and send it to the server. When the server invokes HiTLS_Read, expected result 4.
275+* 5. The server constructs data and sends it to the client. When the client invokes HiTLS_Read, expected result 5.
276+* @expect 1: Initializing the configuration succeeded.
277+* 2: The DTLCP connection is successfully created.
278+* 3: The interface returns a success response.
279+* 4: The interface returns a success response.
280+* 5: The interface returns a success response.
281+* @prior Level 1
282+* @auto TRUE
283+@ */
284+/* BEGIN_CASE */
285+void UT_TLS_DTLCP_CONSISTENCY_RFC6347_APPDATA_TC001(void)
286+{
287+ HandshakeTestInfo testInfo = {0};
288+ testInfo.isClient = true;
289+ testInfo.state = HS_STATE_BUTT;
290+ ASSERT_EQ(DefaultCfgStatusPark1(&testInfo), HITLS_SUCCESS);
291+ uint8_t data[MAX_RECORD_LENTH] = {0};
292+ uint32_t len = MAX_RECORD_LENTH;
293+ ASSERT_TRUE(GetRepeatsApp(testInfo.client, data, &len) == HITLS_SUCCESS);
294+ FrameUioUserData *ioUserData = BSL_UIO_GetUserData(testInfo.server->io);
295+ ASSERT_TRUE(ioUserData->recMsg.len == 0);
296+ ASSERT_TRUE(FRAME_TransportRecMsg(testInfo.server->io, data, len) == HITLS_SUCCESS);
297+ ASSERT_TRUE(HITLS_Read(testInfo.server->ssl, data, MAX_RECORD_LENTH, &len) == HITLS_SUCCESS);
298+ ASSERT_EQ(HITLS_Read(testInfo.server->ssl, data, MAX_RECORD_LENTH, &len), HITLS_SUCCESS);
299+ uint8_t writeData[] = {"abcd1234"};
300+ uint32_t writeLen = strlen("abcd1234");
301+ uint8_t readData[MAX_RECORD_LENTH] = {0};
302+ uint32_t readLen = MAX_RECORD_LENTH;
303+ uint8_t tmpData[MAX_RECORD_LENTH];
304+ uint32_t tmpLen;
305+ uint32_t sendNum;
306+ ASSERT_TRUE(HITLS_Write(testInfo.server->ssl, writeData, writeLen, &sendNum) == HITLS_SUCCESS);
307+ ASSERT_TRUE(FRAME_TransportSendMsg(testInfo.server->io, tmpData, MAX_RECORD_LENTH, &tmpLen) == HITLS_SUCCESS);
308+ ASSERT_TRUE(FRAME_TransportRecMsg(testInfo.client->io, tmpData, tmpLen) == HITLS_SUCCESS);
309+ ASSERT_EQ(HITLS_Read(testInfo.client->ssl, readData, MAX_RECORD_LENTH, &readLen), HITLS_SUCCESS);
310+ ASSERT_EQ(readLen, writeLen);
311+ ASSERT_EQ(memcmp(writeData, readData, readLen), 0);
312+EXIT:
313+ HITLS_CFG_FreeConfig(testInfo.config);
314+ FRAME_FreeLink(testInfo.client);
315+ FRAME_FreeLink(testInfo.server);
316+}
317+/* END_CASE */
318+ 
319+/* @
320+* @test UT_TLS_DTLCP_CONSISTENCY_RFC6347_APPDATA_TC002
321+* @spec -
322+* @titleThe client receives duplicate APP messages.
323+* @precon nan
324+* @brief 1. Initialize the configuration on the client and server. Expected result 1.
325+* 2. Initiate a connection application by using DTLCP. Expected result 2.
326+* 3. Construct an app message whose sequence number is 1 and send the message to the client. When the client invokes HiTLS_Read, expected result 3.
327+* 4. Construct an app message with the sequence number being 1 and send it to the client. When the client invokes HiTLS_Read, expected result 4.
328+* 5. The server constructs data and sends it to the client. When the client invokes HiTLS_Read, expected result 5.
329+* @expect 1: Initializing the configuration succeeded.
330+* 2: The DTLCP connection is successfully created.
331+* 3: The interface returns a success response.
332+* 4: The interface returns a success response.
333+* 5: The interface returns a success response.
334+* @prior Level 1
335+* @auto TRUE
336+@ */
337+/* BEGIN_CASE */
338+void UT_TLS_DTLCP_CONSISTENCY_RFC6347_APPDATA_TC002(void)
339+{
340+ HandshakeTestInfo testInfo = {0};
341+ testInfo.isClient = false;
342+ testInfo.state = HS_STATE_BUTT;
343+ ASSERT_EQ(DefaultCfgStatusPark1(&testInfo), HITLS_SUCCESS);
344+ uint8_t data[MAX_RECORD_LENTH] = {0};
345+ uint32_t len = MAX_RECORD_LENTH;
346+ ASSERT_TRUE(GetRepeatsApp(testInfo.server, data, &len) == HITLS_SUCCESS);
347+ FrameUioUserData *ioUserData = BSL_UIO_GetUserData(testInfo.client->io);
348+ ASSERT_TRUE(ioUserData->recMsg.len == 0);
349+ ASSERT_TRUE(FRAME_TransportRecMsg(testInfo.client->io, data, len) == HITLS_SUCCESS);
350+ ASSERT_TRUE(HITLS_Read(testInfo.client->ssl, data, MAX_RECORD_LENTH, &len) == HITLS_SUCCESS);
351+ ASSERT_EQ(HITLS_Read(testInfo.client->ssl, data, MAX_RECORD_LENTH, &len), HITLS_SUCCESS);
352+ uint8_t writeData[] = {"abcd1234"};
353+ uint32_t writeLen = strlen("abcd1234");
354+ uint8_t readData[MAX_RECORD_LENTH] = {0};
355+ uint32_t readLen = MAX_RECORD_LENTH;
356+ uint8_t tmpData[MAX_RECORD_LENTH];
357+ uint32_t tmpLen;
358+ uint32_t sendNum;
359+ ASSERT_TRUE(HITLS_Write(testInfo.server->ssl, writeData, writeLen, &sendNum) == HITLS_SUCCESS);
360+ ASSERT_TRUE(FRAME_TransportSendMsg(testInfo.server->io, tmpData, MAX_RECORD_LENTH, &tmpLen) == HITLS_SUCCESS);
361+ ASSERT_TRUE(FRAME_TransportRecMsg(testInfo.client->io, tmpData, tmpLen) == HITLS_SUCCESS);
362+ ASSERT_EQ(HITLS_Read(testInfo.client->ssl, readData, MAX_RECORD_LENTH, &readLen), HITLS_SUCCESS);
363+ ASSERT_EQ(readLen, writeLen);
364+ ASSERT_EQ(memcmp(writeData, readData, readLen), 0);
365+EXIT:
366+ HITLS_CFG_FreeConfig(testInfo.config);
367+ FRAME_FreeLink(testInfo.client);
368+ FRAME_FreeLink(testInfo.server);
369+}
370+/* END_CASE */
371+ 
372+/* @
373+* @test UT_TLS_DTLCP_CONSISTENCY_RFC6347_CLIENT_HELLO_TC001
374+* @spec -
375+* @title The server receives a Client Hello packet after the connection is established.
376+* @precon nan
377+* @brief 1. Initialize the client and server based on the default configuration. Expected result 1.
378+* 2. The client initiates a connection request. Expected result 2.
379+* 3. Construct a Client Hello packet and send it to the server. The server invokes HiTLS_Read to receive the packet. Expected result 3.
380+* 4. The client invokes HiTLS_Write to send data to the server, and the server invokes HiTLS_Read to read data. (Expected result 4)
381+* @expect 1: Initialization succeeded.
382+* 2: The connection between the client and server is successfully established.
383+* 3: The HiTLS_Read returns an error code, indicating that the receiving buffer is empty.
384+* 4: The data read by the server is consistent with the data sent by the client.
385+* @prior Level 1
386+* @auto TRUE
387+@ */
388+/* BEGIN_CASE */
389+void UT_TLS_DTLCP_CONSISTENCY_RFC6347_CLIENT_HELLO_TC001(void)
390+{
391+ HandshakeTestInfo testInfo = {0};
392+ FRAME_Msg frameMsg = {0};
393+ FRAME_Type frameType = {0};
394+ testInfo.isClient = true;
395+ testInfo.state = HS_STATE_BUTT;
396+ ASSERT_EQ(DefaultCfgStatusPark1(&testInfo), HITLS_SUCCESS);
397+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
398+ frameType.recordType = REC_TYPE_HANDSHAKE;
399+ frameType.handshakeType = CLIENT_HELLO;
400+ frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
401+ frameType.transportType = BSL_UIO_SCTP;
402+ ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);
403+ uint32_t sendLen = MAX_RECORD_LENTH;
404+ uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
405+ ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
406+ ASSERT_TRUE(REC_Write(testInfo.client->ssl, REC_TYPE_HANDSHAKE,
407+ &sendBuf[REC_DTLS_RECORD_HEADER_LEN], sendLen - REC_DTLS_RECORD_HEADER_LEN) == HITLS_SUCCESS);
408+ ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(testInfo.client, testInfo.server) == HITLS_SUCCESS);
409+ uint8_t data[MAX_RECORD_LENTH] = {0};
410+ uint32_t len = MAX_RECORD_LENTH;
411+ ASSERT_TRUE(testInfo.server->ssl != NULL);
412+ ASSERT_EQ(HITLS_Read(testInfo.server->ssl, data, MAX_RECORD_LENTH, &len), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
413+ uint8_t writeData[] = {"abcd1234"};
414+ uint32_t writeLen = strlen("abcd1234");
415+ uint8_t readData[MAX_RECORD_LENTH] = {0};
416+ uint32_t readLen = MAX_RECORD_LENTH;
417+ uint8_t tmpData[MAX_RECORD_LENTH];
418+ uint32_t tmpLen;
419+ uint32_t sendNum;
420+ ASSERT_EQ(HITLS_Write(testInfo.client->ssl, writeData, writeLen, &sendNum), HITLS_SUCCESS);
421+ ASSERT_TRUE(FRAME_TransportSendMsg(testInfo.client->io, tmpData, MAX_RECORD_LENTH, &tmpLen) == HITLS_SUCCESS);
422+ ASSERT_TRUE(FRAME_TransportRecMsg(testInfo.server->io, tmpData, tmpLen) == HITLS_SUCCESS);
423+ ASSERT_EQ(HITLS_Read(testInfo.server->ssl, readData, MAX_RECORD_LENTH, &readLen), HITLS_SUCCESS);
424+ ASSERT_EQ(readLen, writeLen);
425+ ASSERT_EQ(memcmp(writeData, readData, readLen), 0);
426+EXIT:
427+ HITLS_CFG_FreeConfig(testInfo.config);
428+ FRAME_CleanMsg(&frameType, &frameMsg);
429+ FRAME_FreeLink(testInfo.client);
430+ FRAME_FreeLink(testInfo.server);
431+}
432+/* END_CASE */
433+ 
434+/* @
435+* @test UT_TLS_DTLCP_CONSISTENCY_RFC8422_ECPOINT_TC001
436+* @spec -
437+* @titleThe client receives an abnormal dot format field.
438+* @precon nan
439+* @brief 1. The client and server use the default initialization. Expected result 1.
440+* 2. The client initiates a connection request. When the client wants to read the Server Hello message,
441+* Modify the Elliptic curves point formats field, change the group supported by the field to 0x01, and send the field to the client. Expected result 2.
442+* @expect 1. Initialization succeeded.
443+* 2. The client sends a FATAL ALERT with the description of ALERT_ELLEGAL_PARAMETER.
444+* @prior Level 1
445+* @auto TRUE
446+@ */
447+/* BEGIN_CASE */
448+void UT_TLS_DTLCP_CONSISTENCY_RFC8422_ECPOINT_TC001(void)
449+{
450+ HandshakeTestInfo testInfo = {0};
451+ testInfo.state = TRY_RECV_SERVER_HELLO;
452+ testInfo.isSupportExtendMasterSecret = true;
453+ testInfo.isClient = true;
454+ ASSERT_TRUE(DefaultCfgStatusPark(&testInfo, BSL_UIO_SCTP) == HITLS_SUCCESS);
455+ FrameUioUserData *ioUserData = BSL_UIO_GetUserData(testInfo.client->io);
456+ uint8_t *recvBuf = ioUserData->recMsg.msg;
457+ uint32_t recvLen = ioUserData->recMsg.len;
458+ ASSERT_TRUE(recvLen != 0);
459+ uint32_t parseLen = 0;
460+ FRAME_Msg frameMsg = {0};
461+ FRAME_Type frameType = {0};
462+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
463+ frameType.recordType = REC_TYPE_HANDSHAKE;
464+ frameType.handshakeType = SERVER_HELLO;
465+ frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
466+ frameType.transportType = BSL_UIO_SCTP;
467+ ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
468+ uint8_t Gdata[] = { 0x01 };
469+ FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
470+ serverMsg->pointFormats.exState = INITIAL_FIELD;
471+ ASSERT_TRUE(FRAME_ModifyMsgInteger(HS_EX_TYPE_POINT_FORMATS, &(serverMsg->pointFormats.exType)) == HITLS_SUCCESS);
472+ serverMsg->pointFormats.exLen.state = INITIAL_FIELD;
473+ ASSERT_TRUE(FRAME_ModifyMsgArray8(Gdata, sizeof(Gdata)/sizeof(uint8_t),
474+ &(serverMsg->pointFormats.exData), &(serverMsg->pointFormats.exDataLen)) == HITLS_SUCCESS);
475+ uint32_t sendLen = MAX_RECORD_LENTH;
476+ uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
477+ ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
478+ ioUserData->recMsg.len = 0;
479+ ASSERT_TRUE(FRAME_TransportRecMsg(testInfo.client->io, sendBuf, sendLen) == HITLS_SUCCESS);
480+ FRAME_CleanMsg(&frameType, &frameMsg);
481+ memset_s(&frameMsg, sizeof(frameMsg), 0, sizeof(frameMsg));
482+ ASSERT_TRUE(testInfo.client->ssl != NULL);
483+ ASSERT_EQ(HITLS_Connect(testInfo.client->ssl), HITLS_MSG_HANDLE_UNSUPPORT_POINT_FORMAT);
484+ ioUserData = BSL_UIO_GetUserData(testInfo.client->io);
485+ uint8_t *sndBuf = ioUserData->sndMsg.msg;
486+ uint32_t sndLen = ioUserData->sndMsg.len;
487+ ASSERT_TRUE(sndLen != 0);
488+ parseLen = 0;
489+ frameType.recordType = REC_TYPE_ALERT;
490+ ASSERT_TRUE(FRAME_ParseMsg(&frameType, sndBuf, sndLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
491+ ASSERT_TRUE(frameMsg.recType.data == REC_TYPE_ALERT);
492+ FRAME_AlertMsg *alertMsg = &frameMsg.body.alertMsg;
493+ ASSERT_TRUE(alertMsg->alertLevel.data == ALERT_LEVEL_FATAL);
494+ ASSERT_TRUE(alertMsg->alertDescription.data == ALERT_ILLEGAL_PARAMETER);
495+ 
496+EXIT:
497+ FRAME_CleanMsg(&frameType, &frameMsg);
498+ HITLS_CFG_FreeConfig(testInfo.config);
499+ FRAME_FreeLink(testInfo.client);
500+ FRAME_FreeLink(testInfo.server);
501+}
502+/* END_CASE */
503+ 
504+/* @
505+* @test UT_TLS_DTLCP_CONSISTENCY_RFC8422_EXTENSION_MISS_TC001
506+* @spec -
507+* @title The server receives a Client Hello packet that does not carry the group or dot format.
508+* @precon nan
509+* @brief 1. Configure the HITLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 cipher suite on the client and initialize the cipher suite on the server by default. Expected result 1.
510+* 2. When the client initiates a connection request and the server is about to read ClientHello,
511+* Delete the supported_groups and ec_point_formats fields from the packet. Expected result 2.
512+* @expect 1. Initialization succeeded.
513+* 2. The server sends a Server Hello packet with the HITLS_ECDHE_SM4_CBC_SM3 algorithm suite.
514+* @prior Level 1
515+* @auto TRUE
516+@ */
517+/* BEGIN_CASE */
518+void UT_TLS_DTLCP_CONSISTENCY_RFC8422_EXTENSION_MISS_TC001(void)
519+{
520+ HandshakeTestInfo testInfo = {0};
521+ testInfo.state = TRY_RECV_CLIENT_HELLO;
522+ testInfo.isSupportExtendMasterSecret = true;
523+ testInfo.isClient = false;
524+ ASSERT_TRUE(DefaultCfgStatusPark(&testInfo, BSL_UIO_SCTP) == HITLS_SUCCESS);
525+ FrameUioUserData *ioUserData = BSL_UIO_GetUserData(testInfo.server->io);
526+ uint8_t *recvBuf = ioUserData->recMsg.msg;
527+ uint32_t recvLen = ioUserData->recMsg.len;
528+ ASSERT_TRUE(recvLen != 0);
529+ uint32_t parseLen = 0;
530+ FRAME_Msg frameMsg = {0};
531+ FRAME_Type frameType = {0};
532+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
533+ frameType.recordType = REC_TYPE_HANDSHAKE;
534+ frameType.handshakeType = CLIENT_HELLO;
535+ frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
536+ frameType.transportType = BSL_UIO_SCTP;
537+ ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
538+ FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
539+ clientMsg->supportedGroups.exState = MISSING_FIELD;
540+ clientMsg->pointFormats.exState = MISSING_FIELD;
541+ uint32_t sendLen = MAX_RECORD_LENTH;
542+ uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
543+ ASSERT_TRUE(FRAME_PackMsg(&frameType, &frameMsg, sendBuf, sendLen, &sendLen) == HITLS_SUCCESS);
544+ ioUserData->recMsg.len = 0;
545+ ASSERT_TRUE(FRAME_TransportRecMsg(testInfo.server->io, sendBuf, sendLen) == HITLS_SUCCESS);
546+ FRAME_CleanMsg(&frameType, &frameMsg);
547+ memset_s(&frameMsg, sizeof(frameMsg), 0, sizeof(frameMsg));
548+ CONN_Deinit(testInfo.server->ssl);
549+ ASSERT_TRUE(testInfo.server->ssl != NULL);
550+ ASSERT_EQ(HITLS_Accept(testInfo.server->ssl), HITLS_REC_NORMAL_IO_BUSY);
551+ ioUserData = BSL_UIO_GetUserData(testInfo.server->io);
552+ uint8_t *sndBuf = ioUserData->sndMsg.msg;
553+ uint32_t sndLen = ioUserData->sndMsg.len;
554+ ASSERT_TRUE(sndLen != 0);
555+ parseLen = 0;
556+ frameType.recordType = REC_TYPE_HANDSHAKE;
557+ ASSERT_TRUE(FRAME_ParseMsg(&frameType, sndBuf, sndLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
558+ ASSERT_TRUE(frameMsg.recType.data == REC_TYPE_HANDSHAKE);
559+ ASSERT_TRUE(frameMsg.body.hsMsg.type.data == SERVER_HELLO);
560+ FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
561+ ASSERT_EQ(serverMsg->cipherSuite.data, HITLS_ECDHE_SM4_CBC_SM3);
562+ 
563+EXIT:
564+ FRAME_CleanMsg(&frameType, &frameMsg);
565+ HITLS_CFG_FreeConfig(testInfo.config);
566+ FRAME_FreeLink(testInfo.client);
567+ FRAME_FreeLink(testInfo.server);
568+}
569+/* END_CASE */
570+ 
571+/* when receive alert between finish and ccs, dtlcp should cache it*/
572+/* BEGIN_CASE */
573+void UT_DTLCP_RFC6347_RECV_ALERT_AFTER_CCS_TC001()
574+{
575+ FRAME_Init();
576+ HITLS_Config *tlsConfig = HITLS_CFG_NewDTLCPConfig();
577+ ASSERT_TRUE(tlsConfig != NULL);
578+ FRAME_LinkObj *client = FRAME_CreateTLCPLink(tlsConfig, BSL_UIO_SCTP, true);
579+ FRAME_LinkObj *server = FRAME_CreateTLCPLink(tlsConfig, BSL_UIO_SCTP, false);
580+ client->needStopBeforeRecvCCS = true;
581+ server->needStopBeforeRecvCCS = true;
582+ ASSERT_TRUE(client != NULL);
583+ ASSERT_TRUE(server != NULL);
584+ HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
585+ HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
586+ ASSERT_TRUE(FRAME_CreateConnection(client, server, true, TRY_RECV_FINISH) == HITLS_SUCCESS);
587+ 
588+ // client receive ccs, wait to receive finish
589+ ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
590+ uint8_t alertdata[2] = {0x02, 0x0a};
591+ ASSERT_EQ(REC_Write(serverTlsCtx, REC_TYPE_ALERT, alertdata, sizeof(alertdata)), HITLS_SUCCESS);
592+ ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(server, client) == HITLS_SUCCESS);
593+ 
594+ // client cache the alert, wait to receive finish
595+ ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_REC_NORMAL_RECV_BUF_EMPTY);
596+ ASSERT_TRUE(clientTlsCtx->state == CM_STATE_HANDSHAKING);
597+ // server send finish, handshake success
598+ ASSERT_EQ(HITLS_Accept(serverTlsCtx), HITLS_SUCCESS);
599+ ASSERT_TRUE(FRAME_TrasferMsgBetweenLink(server, client) == HITLS_SUCCESS);
600+ // client receive finish, handshake success
601+ ASSERT_EQ(HITLS_Connect(clientTlsCtx), HITLS_SUCCESS);
602+ ASSERT_TRUE(clientTlsCtx->state == CM_STATE_TRANSPORTING);
603+ // client read cached alert
604+ uint8_t readBuf[READ_BUF_SIZE] = {0};
605+ uint32_t readLen = 0;
606+ ASSERT_EQ(HITLS_Read(clientTlsCtx, readBuf, READ_BUF_SIZE, &readLen), HITLS_REC_NORMAL_RECV_UNEXPECT_MSG);
607+ ASSERT_TRUE(clientTlsCtx->state == CM_STATE_ALERTED);
608+EXIT:
609+ HITLS_CFG_FreeConfig(tlsConfig);
610+ FRAME_FreeLink(client);
611+ FRAME_FreeLink(server);
612+}
613+/* END_CASE */
614+ 
615+/* @
616+* @test UT_TLS_DTLCP_CONSISTENCY_RFC6347_TC001
617+* @spec -
618+* @title The client receives a Hello Request message which msg seq is not 0.
619+* @precon nan
620+* @brief 1. Use the default configuration items to configure the client and server. Expected result 1.
621+* 2. After the client finished handshake, the client receives a Hello Request message. Expected result 2.
622+* @expect 1. The initialization is successful.
623+* 2. The client igore the message.
624+* @prior Level 1
625+* @auto TRUE
626+@ */
627+/* BEGIN_CASE */
628+void UT_TLS_DTLCP_CONSISTENCY_RFC6347_TC001()
629+{
630+ FRAME_Init();
631+ HITLS_Config *tlsConfig = HITLS_CFG_NewDTLCPConfig();
632+ tlsConfig->isSupportRenegotiation = true;
633+ ASSERT_TRUE(tlsConfig != NULL);
634+ FRAME_LinkObj *client = FRAME_CreateTLCPLink(tlsConfig, BSL_UIO_SCTP, true);
635+ FRAME_LinkObj *server = FRAME_CreateTLCPLink(tlsConfig, BSL_UIO_SCTP, false);
636+ ASSERT_TRUE(client != NULL);
637+ ASSERT_TRUE(server != NULL);
638+ HITLS_Ctx *clientTlsCtx = FRAME_GetTlsCtx(client);
639+ HITLS_Ctx *serverTlsCtx = FRAME_GetTlsCtx(server);
640+ ASSERT_TRUE(FRAME_CreateConnection(client, server, true, HS_STATE_BUTT) == HITLS_SUCCESS);
641+ uint8_t buf[DTLS_HS_MSG_HEADER_SIZE] = {0u};
642+ buf[5] = 1;
643+ size_t len = DTLS_HS_MSG_HEADER_SIZE;
644+ REC_Write(serverTlsCtx, REC_TYPE_HANDSHAKE, buf, len);
645+ ASSERT_EQ(FRAME_TrasferMsgBetweenLink(server, client), HITLS_SUCCESS);
646+ uint8_t readData[MAX_RECORD_LENTH] = {0};
647+ uint32_t readLen = MAX_RECORD_LENTH;
648+ ASSERT_EQ(HITLS_Read(clientTlsCtx, readData, MAX_RECORD_LENTH, &readLen), HITLS_MSG_HANDLE_UNMATCHED_SEQUENCE);
649+EXIT:
650+ HITLS_CFG_FreeConfig(tlsConfig);
651+ FRAME_FreeLink(client);
652+ FRAME_FreeLink(server);
653+}
654+/* END_CASE */
Atestcode/sdv/testcase/tls/consistency/dtlcp/test_suite_sdv_frame_dtlcp_consistency.data+38-0
@@ -0,0 +1,38 @@
1+UT_TLS_DTLCP_CONSISTENCY_RFC6083_RETRANSMISSION_TC001
2+UT_TLS_DTLCP_CONSISTENCY_RFC6083_RETRANSMISSION_TC001:
3+ 
4+UT_TLS_DTLCP_CONSISTENCY_RFC6347_FINISH_TC001
5+UT_TLS_DTLCP_CONSISTENCY_RFC6347_FINISH_TC001:
6+ 
7+UT_TLS_DTLCP_CONSISTENCY_RFC6347_FINISH_TC002
8+UT_TLS_DTLCP_CONSISTENCY_RFC6347_FINISH_TC002:
9+ 
10+UT_TLS_DTLCP_CONSISTENCY_RFC6347_FINISH_TC003
11+UT_TLS_DTLCP_CONSISTENCY_RFC6347_FINISH_TC003:
12+ 
13+UT_TLS_DTLCP_CONSISTENCY_RFC6347_DISORDER_TC001
14+UT_TLS_DTLCP_CONSISTENCY_RFC6347_DISORDER_TC001:
15+ 
16+UT_TLS_DTLCP_CONSISTENCY_RFC6347_APPDATA_TC001
17+UT_TLS_DTLCP_CONSISTENCY_RFC6347_APPDATA_TC001:
18+ 
19+UT_TLS_DTLCP_CONSISTENCY_RFC6347_APPDATA_TC001
20+UT_TLS_DTLCP_CONSISTENCY_RFC6347_APPDATA_TC001:
21+ 
22+UT_TLS_DTLCP_CONSISTENCY_RFC6347_APPDATA_TC002
23+UT_TLS_DTLCP_CONSISTENCY_RFC6347_APPDATA_TC002:
24+ 
25+UT_TLS_DTLCP_CONSISTENCY_RFC6347_CLIENT_HELLO_TC001
26+UT_TLS_DTLCP_CONSISTENCY_RFC6347_CLIENT_HELLO_TC001:
27+ 
28+UT_TLS_DTLCP_CONSISTENCY_RFC8422_ECPOINT_TC001
29+UT_TLS_DTLCP_CONSISTENCY_RFC8422_ECPOINT_TC001:
30+ 
31+UT_TLS_DTLCP_CONSISTENCY_RFC8422_EXTENSION_MISS_TC001
32+UT_TLS_DTLCP_CONSISTENCY_RFC8422_EXTENSION_MISS_TC001:
33+ 
34+UT_DTLCP_RFC6347_RECV_ALERT_AFTER_CCS_TC001
35+UT_DTLCP_RFC6347_RECV_ALERT_AFTER_CCS_TC001:
36+ 
37+UT_TLS_DTLCP_CONSISTENCY_RFC6347_TC001
38+UT_TLS_DTLCP_CONSISTENCY_RFC6347_TC001:
Atestcode/sdv/testcase/tls/consistency/dtlcp/test_suite_sdv_hlt_dtlcp_consistency.c+299-0
@@ -0,0 +1,299 @@
1+/*
2+ * This file is part of the openHiTLS project.
3+ *
4+ * openHiTLS is licensed under the Mulan PSL v2.
5+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
6+ * You may obtain a copy of Mulan PSL v2 at:
7+ *
8+ * http://license.coscl.org.cn/MulanPSL2
9+ *
10+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
11+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
12+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
13+ * See the Mulan PSL v2 for more details.
14+ */
15+ 
16+/* BEGIN_HEADER */
17+ 
18+#include <stdio.h>
19+#include <stddef.h>
20+#include <unistd.h>
21+#include "securec.h"
22+#include "bsl_sal.h"
23+#include "hitls.h"
24+#include "hitls_config.h"
25+#include "hitls_error.h"
26+#include "hitls_cert_reg.h"
27+#include "hitls_crypt_type.h"
28+#include "tls.h"
29+#include "hs.h"
30+#include "hs_ctx.h"
31+#include "hs_state_recv.h"
32+#include "conn_init.h"
33+#include "recv_process.h"
34+#include "stub_replace.h"
35+#include "stub_crypt.h"
36+#include "frame_tls.h"
37+#include "frame_msg.h"
38+#include "simulate_io.h"
39+#include "parser_frame_msg.h"
40+#include "pack_frame_msg.h"
41+#include "frame_io.h"
42+#include "frame_link.h"
43+#include "cert.h"
44+#include "cert_mgr.h"
45+#include "hs_extensions.h"
46+#include "hlt_type.h"
47+#include "hlt.h"
48+#include "sctp_channel.h"
49+#include "rec_wrapper.h"
50+#include "process.h"
51+#include "pthread.h"
52+#include "unistd.h"
53+#include "rec_header.h"
54+#include "bsl_log.h"
55+#include "cert_callback.h"
56+#include "bsl_uio.h"
57+#include "uio_abstraction.h"
58+/* END_HEADER */
59+ 
60+#define BUF_SIZE_DTO_TEST 18432
61+ 
62+void Hello(void *ssl)
63+{
64+ const char *writeBuf = "Hello world";
65+ ASSERT_TRUE(HLT_TlsWrite(ssl, (uint8_t *)writeBuf, strlen(writeBuf)) == 0);
66+EXIT:
67+ return;
68+}
69+ 
70+/**
71+* @test SDV_TLS_DTLCP_HANDSHAKE_FUNC_TC001
72+* @spec -
73+* @title Check whether DTLCP over SCTP can handshake successfully.
74+* @precon nan
75+* @brief
76+* 1. Use the default configuration items to configure the client and server. Expected result 1.
77+* 2. A DTLCP over SCTP connection is established between the client and server. Expected result 2.
78+* 3. Construct a app message and send it to the client. Check the server ret. Expected result 3.
79+* @expect
80+* 1. The initialization is successful.
81+* 2. The connection is set up successfully.
82+* 3. The server ret is HITLS_SUCCESS.
83+* @prior Level 1
84+* @auto TRUE
85+@ */
86+/* BEGIN_CASE */
87+void SDV_TLS_DTLCP_HANDSHAKE_FUNC_TC001(int connType)
88+{
89+ if (connType == SCTP && !IsEnableSctpAuth()) {
90+ return;
91+ }
92+ bool certverifyflag = true;
93+ 
94+ HLT_Tls_Res *serverRes = NULL;
95+ HLT_Tls_Res *clientRes = NULL;
96+ HLT_Process *localProcess = NULL;
97+ HLT_Process *remoteProcess = NULL;
98+ 
99+ localProcess = HLT_InitLocalProcess(HITLS);
100+ ASSERT_TRUE(localProcess != NULL);
101+ remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, 16790, true);
102+ ASSERT_TRUE(remoteProcess != NULL);
103+ 
104+ HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfigTLCP(NULL, "SERVER", false);
105+ ASSERT_TRUE(serverCtxConfig != NULL);
106+ 
107+ serverCtxConfig->isSupportClientVerify = certverifyflag;
108+ 
109+ serverRes = HLT_ProcessTlsAccept(localProcess, DTLCP1_1, serverCtxConfig, NULL);
110+ ASSERT_TRUE(serverRes != NULL);
111+ 
112+ HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfigTLCP(NULL, "CLIENT", true);
113+ ASSERT_TRUE(clientCtxConfig != NULL);
114+ 
115+ clientCtxConfig->isSupportClientVerify = certverifyflag;
116+ 
117+ clientRes = HLT_ProcessTlsConnect(remoteProcess, DTLCP1_1, clientCtxConfig, NULL);
118+ ASSERT_TRUE(clientRes != NULL);
119+ 
120+ ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
121+ 
122+ ASSERT_EQ(HLT_ProcessTlsWrite(localProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")), HITLS_SUCCESS);
123+ uint8_t readBuf[1024] = {0};
124+ uint32_t readLen;
125+ ASSERT_TRUE(HLT_ProcessTlsRead(remoteProcess, clientRes, readBuf, sizeof(readBuf), &readLen) == 0);
126+ ASSERT_TRUE(readLen == strlen("Hello World"));
127+ ASSERT_TRUE(memcmp("Hello World", readBuf, readLen) == 0);
128+EXIT:
129+ HLT_FreeAllProcess();
130+}
131+/* END_CASE */
132+ 
133+/*
134+* @
135+* @test SDV_TLS_DTLCP_CONSISTENCY_RFC5246_UNEXPETED_REORD_TYPE_TC001
136+* @Specifications-
137+* @Title1. Construct a scenario where renegotiation messages and application messages are sent at the same time.
138+* It is expected that the server processes renegotiation messages first.
139+* @preconan
140+* @short
141+* @ Previous Level 1
142+* @autotrue
143+@ */
144+/* BEGIN_CASE */
145+void SDV_TLS_DTLCP_CONSISTENCY_RFC5246_UNEXPETED_REORD_TYPE_TC001()
146+{
147+ int version = TLS1_2;
148+ int connType = TCP;
149+ Process *localProcess = NULL;
150+ Process *remoteProcess = NULL;
151+ HLT_FD sockFd = {0};
152+ HITLS_Session *session = NULL;
153+ TLS_TYPE local = HITLS;
154+ TLS_TYPE remote = HITLS;
155+ localProcess = HLT_InitLocalProcess(local);
156+ ASSERT_TRUE(localProcess != NULL);
157+ remoteProcess = HLT_CreateRemoteProcess(remote);
158+ ASSERT_TRUE(remoteProcess != NULL);
159+ int32_t serverConfigId = HLT_RpcTlsNewCtx(remoteProcess, version, false);
160+ void *clientConfig = HLT_TlsNewCtx(version);
161+ ASSERT_TRUE(clientConfig != NULL);
162+ HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfig(NULL, "CLIENT");
163+ HLT_SetRenegotiationSupport(clientCtxConfig, true);
164+ HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfig(NULL, "SERVER");
165+ HLT_SetRenegotiationSupport(serverCtxConfig, true);
166+ HLT_SetClientRenegotiateSupport(serverCtxConfig, true);
167+ ASSERT_TRUE(HLT_TlsSetCtx(clientConfig, clientCtxConfig) == 0);
168+ ASSERT_TRUE(HLT_RpcTlsSetCtx(remoteProcess, serverConfigId, serverCtxConfig) == 0);
169+ DataChannelParam channelParam;
170+ channelParam.port = 1666;
171+ channelParam.type = connType;
172+ channelParam.isBlock = true;
173+ sockFd = HLT_CreateDataChannel(localProcess, remoteProcess, channelParam);
174+ ASSERT_TRUE((sockFd.srcFd > 0) && (sockFd.peerFd > 0));
175+ remoteProcess->connFd = sockFd.peerFd;
176+ localProcess->connFd = sockFd.srcFd;
177+ remoteProcess->connType = connType;
178+ localProcess->connType = connType;
179+ int32_t serverSslId = HLT_RpcTlsNewSsl(remoteProcess, serverConfigId);
180+ HLT_Ssl_Config *serverSslConfig;
181+ serverSslConfig = HLT_NewSslConfig(NULL);
182+ ASSERT_TRUE(serverSslConfig != NULL);
183+ serverSslConfig->sockFd = remoteProcess->connFd;
184+ serverSslConfig->connType = connType;
185+ ASSERT_TRUE(HLT_RpcTlsSetSsl(remoteProcess, serverSslId, serverSslConfig) == 0);
186+ HLT_RpcTlsAccept(remoteProcess, serverSslId);
187+ void *clientSsl = HLT_TlsNewSsl(clientConfig);
188+ ASSERT_TRUE(clientSsl != NULL);
189+ HLT_Ssl_Config *clientSslConfig;
190+ clientSslConfig = HLT_NewSslConfig(NULL);
191+ ASSERT_TRUE(clientSslConfig != NULL);
192+ clientSslConfig->sockFd = localProcess->connFd;
193+ clientSslConfig->connType = connType;
194+ HLT_TlsSetSsl(clientSsl, clientSslConfig);
195+ ASSERT_TRUE(HLT_TlsConnect(clientSsl) == 0);
196+ ASSERT_TRUE(HITLS_Renegotiate(clientSsl) == HITLS_SUCCESS);
197+ const char *writeBuf = "Hello world";
198+ pthread_t thrd;
199+ ASSERT_TRUE(pthread_create(&thrd, NULL, (void *)Hello, clientSsl) == 0);
200+ sleep(2);
201+ uint8_t readBuf[BUF_SIZE_DTO_TEST] = {0};
202+ uint32_t readLen;
203+ ASSERT_TRUE(memset_s(readBuf, BUF_SIZE_DTO_TEST, 0, BUF_SIZE_DTO_TEST) == EOK);
204+ ASSERT_TRUE(HLT_RpcTlsRead(remoteProcess, serverSslId, readBuf, BUF_SIZE_DTO_TEST, &readLen) == 0);
205+ pthread_join(thrd, NULL);
206+ ASSERT_TRUE(readLen == strlen(writeBuf));
207+ ASSERT_TRUE(memcmp(writeBuf, readBuf, readLen) == 0);
208+ ASSERT_TRUE(HLT_RpcTlsClose(remoteProcess, serverSslId) == 0);
209+ ASSERT_TRUE(HLT_TlsClose(clientSsl) == 0);
210+ HLT_RpcCloseFd(remoteProcess, sockFd.peerFd, remoteProcess->connType);
211+ HLT_CloseFd(sockFd.srcFd, localProcess->connType);
212+ 
213+EXIT:
214+ ClearWrapper();
215+ HLT_CleanFrameHandle();
216+ HITLS_SESS_Free(session);
217+ HLT_FreeAllProcess();
218+}
219+/* END_CASE */
220+static int32_t DtlsSctpUioWriteException(BSL_UIO *uio, const void *buf, uint32_t len, uint32_t *writeLen)
221+{
222+ int32_t ret;
223+ static int32_t count = 0;
224+ count++;
225+ if (count == 1) {
226+ ret = SctpDefaultWrite(uio, (uint8_t *)buf, len / 2, writeLen);
227+ } else {
228+ ret = SctpDefaultWrite(uio, (uint8_t *)buf, len, writeLen);
229+ }
230+ return ret;
231+}
232+/**
233+* @test SDV_TLS_DTLCP_WRITE_APP_FAILED_TC001
234+* @spec -
235+* @title The client and server receive the client Hello message after the connection establishment is complete.
236+* @precon nan
237+* @brief
238+* 1. Use the default configuration items to configure the client and server. Expected result 1.
239+* 2. A DTLCP over SCTP connection is established between the client and server. Expected result 2.
240+* 3. Construct a app message and send it to the client. Check the server ret. Expected result 3.
241+* 4. Construct a app message and send it to the client. Check the server ret. Expected result 4.
242+* @expect
243+* 1. The initialization is successful.
244+* 2. The connection is set up successfully.
245+* 3. The server ret is HITLS_REC_ERR_IO_EXCEPTION.
246+* 4. The server ret is HITLS_SUCCESS.
247+* @prior Level 1
248+* @auto TRUE
249+@ */
250+/* BEGIN_CASE */
251+void SDV_TLS_DTLCP_WRITE_APP_FAILED_TC001(int version, int connType)
252+{
253+ if (connType == SCTP && !IsEnableSctpAuth()){
254+ return;
255+ }
256+ bool certverifyflag = true;
257+ 
258+ HLT_Tls_Res *serverRes = NULL;
259+ HLT_Tls_Res *clientRes = NULL;
260+ HLT_Process *localProcess = NULL;
261+ HLT_Process *remoteProcess = NULL;
262+ 
263+ localProcess = HLT_InitLocalProcess(HITLS);
264+ ASSERT_TRUE(localProcess != NULL);
265+ remoteProcess = HLT_LinkRemoteProcess(HITLS, connType, 16790, true);
266+ ASSERT_TRUE(remoteProcess != NULL);
267+ 
268+ HLT_Ctx_Config *serverCtxConfig = HLT_NewCtxConfigTLCP(NULL, "SERVER", false);
269+ ASSERT_TRUE(serverCtxConfig != NULL);
270+ 
271+ serverCtxConfig->isSupportClientVerify = certverifyflag;
272+ 
273+ serverRes = HLT_ProcessTlsAccept(localProcess, version, serverCtxConfig, NULL);
274+ ASSERT_TRUE(serverRes != NULL);
275+ 
276+ HLT_Ctx_Config *clientCtxConfig = HLT_NewCtxConfigTLCP(NULL, "CLIENT", true);
277+ ASSERT_TRUE(clientCtxConfig != NULL);
278+ 
279+ clientCtxConfig->isSupportClientVerify = certverifyflag;
280+ 
281+ clientRes = HLT_ProcessTlsConnect(remoteProcess, version, clientCtxConfig, NULL);
282+ ASSERT_TRUE(clientRes != NULL);
283+ 
284+ ASSERT_TRUE(HLT_GetTlsAcceptResult(serverRes) == 0);
285+ 
286+ HITLS_Ctx *ctx = serverRes->ssl;
287+ BSL_UIO *uio = ctx->uio;
288+ uio->method.write = DtlsSctpUioWriteException;
289+ ASSERT_EQ(HLT_ProcessTlsWrite(localProcess, serverRes, (uint8_t *)"Hello World", strlen("Hello World")), HITLS_REC_ERR_IO_EXCEPTION);
290+ ASSERT_EQ(HLT_ProcessTlsWrite(localProcess, serverRes, (uint8_t *)"Hello World2", strlen("Hello World2")), HITLS_SUCCESS);
291+ uint8_t readBuf[1024] = {0};
292+ uint32_t readLen;
293+ ASSERT_TRUE(HLT_ProcessTlsRead(remoteProcess, clientRes, readBuf, sizeof(readBuf), &readLen) == 0);
294+ ASSERT_TRUE(readLen == strlen("Hello World2"));
295+ ASSERT_TRUE(memcmp("Hello World2", readBuf, readLen) == 0);
296+EXIT:
297+ HLT_FreeAllProcess();
298+}
299+/* END_CASE */
Atestcode/sdv/testcase/tls/consistency/dtlcp/test_suite_sdv_hlt_dtlcp_consistency.data+8-0
@@ -0,0 +1,8 @@
1+SDV_TLS_DTLCP_HANDSHAKE_FUNC_TC001
2+SDV_TLS_DTLCP_HANDSHAKE_FUNC_TC001:SCTP
3+ 
4+SDV_TLS_DTLCP_CONSISTENCY_RFC5246_UNEXPETED_REORD_TYPE_TC001 tls12
5+SDV_TLS_DTLCP_CONSISTENCY_RFC5246_UNEXPETED_REORD_TYPE_TC001:
6+ 
7+SDV_TLS_DTLCP_WRITE_APP_FAILED_TC001
8+SDV_TLS_DTLCP_WRITE_APP_FAILED_TC001:DTLCP1_1:SCTP
Mtestcode/sdv/testcase/tls/consistency/dtls12/test_suite_sdv_frame_dtls12_consistency.c+32-0
@@ -49,6 +49,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_UNEXPETED_REORD_TYPE_TC001(void)
49 frameType.recordType = REC_TYPE_HANDSHAKE;49 frameType.recordType = REC_TYPE_HANDSHAKE;
50 frameType.handshakeType = CLIENT_HELLO;50 frameType.handshakeType = CLIENT_HELLO;
51 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;51 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
52+ frameType.transportType = BSL_UIO_SCTP;
52 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);53 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);
53 uint32_t sendLen = MAX_RECORD_LENTH;54 uint32_t sendLen = MAX_RECORD_LENTH;
54 uint8_t sendBuf[MAX_RECORD_LENTH] = {0};55 uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
@@ -110,6 +111,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_SEQ_NUMBER_TC001(int uioType)
110 frameType.recordType = REC_TYPE_HANDSHAKE;111 frameType.recordType = REC_TYPE_HANDSHAKE;
111 frameType.handshakeType = CLIENT_HELLO;112 frameType.handshakeType = CLIENT_HELLO;
112 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;113 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
114+ frameType.transportType = uioType;
113 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);115 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
114 ASSERT_TRUE(parseLen == recvLen);116 ASSERT_TRUE(parseLen == recvLen);
115 ASSERT_TRUE(frameMsg.body.hsMsg.sequence.data == 0);117 ASSERT_TRUE(frameMsg.body.hsMsg.sequence.data == 0);
@@ -153,6 +155,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_SEQ_NUMBER_TC002(int uioType)
153 frameType.recordType = REC_TYPE_HANDSHAKE;155 frameType.recordType = REC_TYPE_HANDSHAKE;
154 frameType.handshakeType = SERVER_HELLO;156 frameType.handshakeType = SERVER_HELLO;
155 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;157 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
158+ frameType.transportType = uioType;
156 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);159 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
157 ASSERT_TRUE(parseLen == recvLen);160 ASSERT_TRUE(parseLen == recvLen);
158 ASSERT_TRUE(frameMsg.body.hsMsg.sequence.data == 0);161 ASSERT_TRUE(frameMsg.body.hsMsg.sequence.data == 0);
@@ -196,6 +199,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_SEQ_NUMBER_TC003(int uioType)
196 uint32_t parseLen = 0;199 uint32_t parseLen = 0;
197 frameType.versionType = HITLS_VERSION_DTLS12;200 frameType.versionType = HITLS_VERSION_DTLS12;
198 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;201 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
202+ frameType.transportType = uioType;
199 ASSERT_TRUE(FRAME_ParseMsgHeader(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);203 ASSERT_TRUE(FRAME_ParseMsgHeader(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
200 ASSERT_TRUE(parseLen == PARSEMSGHEADER_LEN);204 ASSERT_TRUE(parseLen == PARSEMSGHEADER_LEN);
201 ASSERT_TRUE(frameMsg.body.hsMsg.sequence.data == 0);205 ASSERT_TRUE(frameMsg.body.hsMsg.sequence.data == 0);
@@ -209,6 +213,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_SEQ_NUMBER_TC003(int uioType)
209 FRAME_Type frameType_1 = {0};213 FRAME_Type frameType_1 = {0};
210 frameType_1.versionType = HITLS_VERSION_DTLS12;214 frameType_1.versionType = HITLS_VERSION_DTLS12;
211 frameType_1.keyExType = HITLS_KEY_EXCH_ECDHE;215 frameType_1.keyExType = HITLS_KEY_EXCH_ECDHE;
216+ frameType_1.transportType = uioType;
212 ASSERT_TRUE(FRAME_ParseMsgHeader(&frameType_1, recvBuf_1, recvLen_1, &frameMsg_1, &parseLen_1) == HITLS_SUCCESS);217 ASSERT_TRUE(FRAME_ParseMsgHeader(&frameType_1, recvBuf_1, recvLen_1, &frameMsg_1, &parseLen_1) == HITLS_SUCCESS);
213 ASSERT_TRUE(parseLen_1 == PARSEMSGHEADER_LEN);218 ASSERT_TRUE(parseLen_1 == PARSEMSGHEADER_LEN);
214 ASSERT_TRUE(frameMsg_1.body.hsMsg.sequence.data == 0);219 ASSERT_TRUE(frameMsg_1.body.hsMsg.sequence.data == 0);
@@ -259,6 +264,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_MSGLENGTH_TOOLONG_TC001(int uioType)
259 frameType.recordType = REC_TYPE_HANDSHAKE;264 frameType.recordType = REC_TYPE_HANDSHAKE;
260 frameType.handshakeType = CERTIFICATE;265 frameType.handshakeType = CERTIFICATE;
261 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;266 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
267+ frameType.transportType = uioType;
262 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);268 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
263 uint8_t *certDataTemp = (uint8_t *)BSL_SAL_Calloc(1, (uint32_t)BUF_TOOLONG_LEN);269 uint8_t *certDataTemp = (uint8_t *)BSL_SAL_Calloc(1, (uint32_t)BUF_TOOLONG_LEN);
264 ASSERT_TRUE(certDataTemp != NULL);270 ASSERT_TRUE(certDataTemp != NULL);
@@ -323,6 +329,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_MSGLENGTH_TOOLONG_TC002(int uioType)
323 frameType.recordType = REC_TYPE_HANDSHAKE;329 frameType.recordType = REC_TYPE_HANDSHAKE;
324 frameType.handshakeType = CERTIFICATE;330 frameType.handshakeType = CERTIFICATE;
325 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;331 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
332+ frameType.transportType = uioType;
326 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);333 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
327 uint8_t *certDataTemp = (uint8_t *)BSL_SAL_Calloc(1, (uint32_t)BUF_TOOLONG_LEN);334 uint8_t *certDataTemp = (uint8_t *)BSL_SAL_Calloc(1, (uint32_t)BUF_TOOLONG_LEN);
328 ASSERT_TRUE(certDataTemp != NULL);335 ASSERT_TRUE(certDataTemp != NULL);
@@ -380,6 +387,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_MSGLENGTH_TOOLONG_TC003(int uioType)
380 FRAME_Type frameType = {0};387 FRAME_Type frameType = {0};
381 frameType.versionType = HITLS_VERSION_DTLS12;388 frameType.versionType = HITLS_VERSION_DTLS12;
382 frameType.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;389 frameType.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;
390+ frameType.transportType = uioType;
383 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);391 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);
384 uint8_t *certDataTemp = (uint8_t *)BSL_SAL_Calloc(1, (uint32_t)BUF_TOOLONG_LEN);392 uint8_t *certDataTemp = (uint8_t *)BSL_SAL_Calloc(1, (uint32_t)BUF_TOOLONG_LEN);
385 ASSERT_TRUE(certDataTemp != NULL);393 ASSERT_TRUE(certDataTemp != NULL);
@@ -439,6 +447,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_MSGLENGTH_ZERO_TC001(void)
439 frameType.recordType = REC_TYPE_HANDSHAKE;447 frameType.recordType = REC_TYPE_HANDSHAKE;
440 frameType.handshakeType = CLIENT_HELLO;448 frameType.handshakeType = CLIENT_HELLO;
441 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;449 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
450+ frameType.transportType = BSL_UIO_SCTP;
442 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);451 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
443 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;452 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
444 clientMsg->extensionState = MISSING_FIELD;453 clientMsg->extensionState = MISSING_FIELD;
@@ -513,6 +522,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_MSGLENGTH_ZERO_TC002(void)
513 frameType.recordType = REC_TYPE_HANDSHAKE;522 frameType.recordType = REC_TYPE_HANDSHAKE;
514 frameType.handshakeType = SERVER_HELLO;523 frameType.handshakeType = SERVER_HELLO;
515 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;524 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
525+ frameType.transportType = BSL_UIO_SCTP;
516 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);526 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
517 FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;527 FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
518 serverMsg->version.state = MISSING_FIELD;528 serverMsg->version.state = MISSING_FIELD;
@@ -585,6 +595,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_MSGLENGTH_ZERO_TC003(void)
585 frameType.recordType = REC_TYPE_HANDSHAKE;595 frameType.recordType = REC_TYPE_HANDSHAKE;
586 frameType.handshakeType = CERTIFICATE;596 frameType.handshakeType = CERTIFICATE;
587 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;597 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
598+ frameType.transportType = BSL_UIO_SCTP;
588 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);599 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
589 FRAME_CertificateMsg *certifiMsg = &frameMsg.body.hsMsg.body.certificate;600 FRAME_CertificateMsg *certifiMsg = &frameMsg.body.hsMsg.body.certificate;
590 certifiMsg->certsLen.state = MISSING_FIELD;601 certifiMsg->certsLen.state = MISSING_FIELD;
@@ -649,6 +660,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_MSGLENGTH_ZERO_TC004(void)
649 frameType.recordType = REC_TYPE_HANDSHAKE;660 frameType.recordType = REC_TYPE_HANDSHAKE;
650 frameType.handshakeType = SERVER_KEY_EXCHANGE;661 frameType.handshakeType = SERVER_KEY_EXCHANGE;
651 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;662 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
663+ frameType.transportType = BSL_UIO_SCTP;
652 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);664 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
653 FRAME_ServerKeyExchangeMsg *serverKeyExMsg = &frameMsg.body.hsMsg.body.serverKeyExchange;665 FRAME_ServerKeyExchangeMsg *serverKeyExMsg = &frameMsg.body.hsMsg.body.serverKeyExchange;
654 serverKeyExMsg->keyEx.ecdh.curveType.state = MISSING_FIELD;666 serverKeyExMsg->keyEx.ecdh.curveType.state = MISSING_FIELD;
@@ -718,6 +730,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_MSGLENGTH_ZERO_TC005(void)
718 frameType.recordType = REC_TYPE_HANDSHAKE;730 frameType.recordType = REC_TYPE_HANDSHAKE;
719 frameType.handshakeType = CLIENT_KEY_EXCHANGE;731 frameType.handshakeType = CLIENT_KEY_EXCHANGE;
720 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;732 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
733+ frameType.transportType = BSL_UIO_SCTP;
721 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);734 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
722 FRAME_ClientKeyExchangeMsg *clientKeyExMsg = &frameMsg.body.hsMsg.body.clientKeyExchange;735 FRAME_ClientKeyExchangeMsg *clientKeyExMsg = &frameMsg.body.hsMsg.body.clientKeyExchange;
723 clientKeyExMsg->pubKey.state = MISSING_FIELD;736 clientKeyExMsg->pubKey.state = MISSING_FIELD;
@@ -777,6 +790,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_MSGLENGTH_ZERO_TC006(void)
777 FRAME_Type frameType1 = {0};790 FRAME_Type frameType1 = {0};
778 frameType1.versionType = HITLS_VERSION_DTLS12;791 frameType1.versionType = HITLS_VERSION_DTLS12;
779 frameType1.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;792 frameType1.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;
793+ frameType1.transportType = BSL_UIO_SCTP;
780 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType1, &frameMsg1) == HITLS_SUCCESS);794 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType1, &frameMsg1) == HITLS_SUCCESS);
781 FRAME_CcsMsg *CcsMidMsg = &frameMsg1.body.ccsMsg;795 FRAME_CcsMsg *CcsMidMsg = &frameMsg1.body.ccsMsg;
782 CcsMidMsg->ccsType.state = MISSING_FIELD;796 CcsMidMsg->ccsType.state = MISSING_FIELD;
@@ -824,6 +838,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_MSGLENGTH_ZERO_TC007(void)
824 FRAME_Type frameType1 = {0};838 FRAME_Type frameType1 = {0};
825 frameType1.versionType = HITLS_VERSION_DTLS12;839 frameType1.versionType = HITLS_VERSION_DTLS12;
826 frameType1.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;840 frameType1.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;
841+ frameType1.transportType = BSL_UIO_SCTP;
827 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType1, &frameMsg1) == HITLS_SUCCESS);842 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType1, &frameMsg1) == HITLS_SUCCESS);
828 FRAME_CcsMsg *CcsMidMsg = &frameMsg1.body.ccsMsg;843 FRAME_CcsMsg *CcsMidMsg = &frameMsg1.body.ccsMsg;
829 CcsMidMsg->ccsType.state = MISSING_FIELD;844 CcsMidMsg->ccsType.state = MISSING_FIELD;
@@ -876,6 +891,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_COMPRESSED_TC001(int uioType)
876 frameType.recordType = REC_TYPE_HANDSHAKE;891 frameType.recordType = REC_TYPE_HANDSHAKE;
877 frameType.handshakeType = CLIENT_HELLO;892 frameType.handshakeType = CLIENT_HELLO;
878 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;893 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
894+ frameType.transportType = uioType;
879 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);895 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
880 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;896 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
881 *(clientMsg->compressionMethods.data) = 1;897 *(clientMsg->compressionMethods.data) = 1;
@@ -940,6 +956,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_COMPRESSED_TC002(int uioType)
940 frameType.recordType = REC_TYPE_HANDSHAKE;956 frameType.recordType = REC_TYPE_HANDSHAKE;
941 frameType.handshakeType = SERVER_HELLO;957 frameType.handshakeType = SERVER_HELLO;
942 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;958 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
959+ frameType.transportType = uioType;
943 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);960 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
944 FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;961 FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
945 serverMsg->compressionMethod.data = 1;962 serverMsg->compressionMethod.data = 1;
@@ -1004,6 +1021,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_CIPHER_TC001(void)
1004 frameType.recordType = REC_TYPE_HANDSHAKE;1021 frameType.recordType = REC_TYPE_HANDSHAKE;
1005 frameType.handshakeType = CLIENT_HELLO;1022 frameType.handshakeType = CLIENT_HELLO;
1006 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1023 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
1024+ frameType.transportType = BSL_UIO_SCTP;
1007 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);1025 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
1008 uint16_t suite[] = {0x00B6, 0x00B7, ILLEGAL_VALUE, HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384};1026 uint16_t suite[] = {0x00B6, 0x00B7, ILLEGAL_VALUE, HITLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384};
1009 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;1027 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
@@ -1068,6 +1086,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_CIPHER_TC002(void)
1068 frameType.recordType = REC_TYPE_HANDSHAKE;1086 frameType.recordType = REC_TYPE_HANDSHAKE;
1069 frameType.handshakeType = SERVER_HELLO;1087 frameType.handshakeType = SERVER_HELLO;
1070 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1088 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
1089+ frameType.transportType = BSL_UIO_SCTP;
1071 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);1090 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
1072 FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;1091 FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
1073 serverMsg->cipherSuite.data = ILLEGAL_VALUE;1092 serverMsg->cipherSuite.data = ILLEGAL_VALUE;
@@ -1134,6 +1153,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_SIGNATURE_TC001(void)
1134 frameType.recordType = REC_TYPE_HANDSHAKE;1153 frameType.recordType = REC_TYPE_HANDSHAKE;
1135 frameType.handshakeType = CLIENT_HELLO;1154 frameType.handshakeType = CLIENT_HELLO;
1136 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1155 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
1156+ frameType.transportType = BSL_UIO_SCTP;
1137 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);1157 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
1138 ASSERT_TRUE(frameMsg.body.hsMsg.type.data == CLIENT_HELLO);1158 ASSERT_TRUE(frameMsg.body.hsMsg.type.data == CLIENT_HELLO);
1139 frameMsg.body.hsMsg.body.clientHello.signatureAlgorithms.exState = MISSING_FIELD;1159 frameMsg.body.hsMsg.body.clientHello.signatureAlgorithms.exState = MISSING_FIELD;
@@ -1196,6 +1216,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_SIGNATURE_TC002(void)
1196 frameType.recordType = REC_TYPE_HANDSHAKE;1216 frameType.recordType = REC_TYPE_HANDSHAKE;
1197 frameType.handshakeType = SERVER_HELLO;1217 frameType.handshakeType = SERVER_HELLO;
1198 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1218 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
1219+ frameType.transportType = BSL_UIO_SCTP;
1199 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);1220 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
1200 FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;1221 FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
1201 serverMsg->secRenego.exState = INITIAL_FIELD;1222 serverMsg->secRenego.exState = INITIAL_FIELD;
@@ -1265,6 +1286,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_SIGNATURE_TC003(int uioType)
1265 frameType.recordType = REC_TYPE_HANDSHAKE;1286 frameType.recordType = REC_TYPE_HANDSHAKE;
1266 frameType.handshakeType = CLIENT_HELLO;1287 frameType.handshakeType = CLIENT_HELLO;
1267 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1288 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
1289+ frameType.transportType = uioType;
1268 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);1290 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
1269 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;1291 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
1270 clientMsg->signatureAlgorithms.exDataLen.data = HASH_EXDATA_LEN_ERROR ;1292 clientMsg->signatureAlgorithms.exDataLen.data = HASH_EXDATA_LEN_ERROR ;
@@ -1330,6 +1352,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_SIGNATURE_TC004(void)
1330 frameType.recordType = REC_TYPE_HANDSHAKE;1352 frameType.recordType = REC_TYPE_HANDSHAKE;
1331 frameType.handshakeType = CLIENT_HELLO;1353 frameType.handshakeType = CLIENT_HELLO;
1332 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1354 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
1355+ frameType.transportType = BSL_UIO_SCTP;
1333 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);1356 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
1334 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;1357 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
1335 uint16_t Signature[] = {ILLEGAL_VALUE};1358 uint16_t Signature[] = {ILLEGAL_VALUE};
@@ -1397,6 +1420,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_SIGNATURE_TC005(void)
1397 frameType.recordType = REC_TYPE_HANDSHAKE;1420 frameType.recordType = REC_TYPE_HANDSHAKE;
1398 frameType.handshakeType = SERVER_HELLO;1421 frameType.handshakeType = SERVER_HELLO;
1399 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1422 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
1423+ frameType.transportType = BSL_UIO_SCTP;
1400 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);1424 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
1401 FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;1425 FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
1402 serverMsg->secRenego.exState = INITIAL_FIELD;1426 serverMsg->secRenego.exState = INITIAL_FIELD;
@@ -1466,6 +1490,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_SIGNATURE_TC007(int uioType)
1466 frameType.recordType = REC_TYPE_HANDSHAKE;1490 frameType.recordType = REC_TYPE_HANDSHAKE;
1467 frameType.handshakeType = CLIENT_HELLO;1491 frameType.handshakeType = CLIENT_HELLO;
1468 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1492 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
1493+ frameType.transportType = uioType;
1469 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);1494 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
1470 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;1495 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
1471 clientMsg->signatureAlgorithms.exState = MISSING_FIELD;1496 clientMsg->signatureAlgorithms.exState = MISSING_FIELD;
@@ -1523,6 +1548,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_CERTIFICATE_TC003(int uioType)
1523 frameType.recordType = REC_TYPE_HANDSHAKE;1548 frameType.recordType = REC_TYPE_HANDSHAKE;
1524 frameType.handshakeType = CERTIFICATE;1549 frameType.handshakeType = CERTIFICATE;
1525 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1550 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
1551+ frameType.transportType = uioType;
1526 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);1552 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);
1527 uint32_t sendLen = MAX_RECORD_LENTH;1553 uint32_t sendLen = MAX_RECORD_LENTH;
1528 uint8_t sendBuf[MAX_RECORD_LENTH] = {0};1554 uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
@@ -1580,6 +1606,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_CERTIFICATE_TC004(void)
1580 frameType.recordType = REC_TYPE_HANDSHAKE;1606 frameType.recordType = REC_TYPE_HANDSHAKE;
1581 frameType.handshakeType = CERTIFICATE_VERIFY;1607 frameType.handshakeType = CERTIFICATE_VERIFY;
1582 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1608 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
1609+ frameType.transportType = BSL_UIO_SCTP;
1583 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);1610 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);
1584 uint32_t sendLen = MAX_RECORD_LENTH;1611 uint32_t sendLen = MAX_RECORD_LENTH;
1585 uint8_t sendBuf[MAX_RECORD_LENTH] = {0};1612 uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
@@ -1641,6 +1668,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_VERSION_TC001(int uioType)
1641 frameType.recordType = REC_TYPE_HANDSHAKE;1668 frameType.recordType = REC_TYPE_HANDSHAKE;
1642 frameType.handshakeType = CLIENT_HELLO;1669 frameType.handshakeType = CLIENT_HELLO;
1643 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1670 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
1671+ frameType.transportType = uioType;
1644 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);1672 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
1645 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;1673 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
1646 clientMsg->version.data = HITLS_VERSION_DTLS10;1674 clientMsg->version.data = HITLS_VERSION_DTLS10;
@@ -1812,6 +1840,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC5246_HELLO_REQUEST_TC003(int uioType)
1812 uint32_t parseLen = 0;1840 uint32_t parseLen = 0;
1813 frameType.versionType = HITLS_VERSION_DTLS12;1841 frameType.versionType = HITLS_VERSION_DTLS12;
1814 frameType.recordType = REC_TYPE_ALERT;1842 frameType.recordType = REC_TYPE_ALERT;
1843+ frameType.transportType = uioType;
1815 ASSERT_TRUE(FRAME_ParseMsg(&frameType, sndBuf, sndLen, &frameMsg, &parseLen) == HITLS_SUCCESS);1844 ASSERT_TRUE(FRAME_ParseMsg(&frameType, sndBuf, sndLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
1816 ASSERT_TRUE(frameMsg.recType.data == REC_TYPE_ALERT);1845 ASSERT_TRUE(frameMsg.recType.data == REC_TYPE_ALERT);
1817 FRAME_AlertMsg *alertMsg = &frameMsg.body.alertMsg;1846 FRAME_AlertMsg *alertMsg = &frameMsg.body.alertMsg;
@@ -2438,6 +2467,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC6347_CLIENT_HELLO_TC001(int uioType)
2438 frameType.recordType = REC_TYPE_HANDSHAKE;2467 frameType.recordType = REC_TYPE_HANDSHAKE;
2439 frameType.handshakeType = CLIENT_HELLO;2468 frameType.handshakeType = CLIENT_HELLO;
2440 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;2469 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
2470+ frameType.transportType = BSL_UIO_SCTP;
2441 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);2471 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);
2442 uint32_t sendLen = MAX_RECORD_LENTH;2472 uint32_t sendLen = MAX_RECORD_LENTH;
2443 uint8_t sendBuf[MAX_RECORD_LENTH] = {0};2473 uint8_t sendBuf[MAX_RECORD_LENTH] = {0};
@@ -2678,6 +2708,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC8422_ECPOINT_TC001(void)
2678 frameType.recordType = REC_TYPE_HANDSHAKE;2708 frameType.recordType = REC_TYPE_HANDSHAKE;
2679 frameType.handshakeType = SERVER_HELLO;2709 frameType.handshakeType = SERVER_HELLO;
2680 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;2710 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
2711+ frameType.transportType = BSL_UIO_SCTP;
2681 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);2712 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
2682 uint8_t Gdata[] = { 0x01 };2713 uint8_t Gdata[] = { 0x01 };
2683 FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;2714 FRAME_ServerHelloMsg *serverMsg = &frameMsg.body.hsMsg.body.serverHello;
@@ -2747,6 +2778,7 @@ void UT_TLS_DTLS_CONSISTENCY_RFC8422_EXTENSION_MISS_TC001(void)
2747 frameType.recordType = REC_TYPE_HANDSHAKE;2778 frameType.recordType = REC_TYPE_HANDSHAKE;
2748 frameType.handshakeType = CLIENT_HELLO;2779 frameType.handshakeType = CLIENT_HELLO;
2749 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;2780 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
2781+ frameType.transportType = BSL_UIO_SCTP;
2750 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);2782 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
2751 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;2783 FRAME_ClientHelloMsg *clientMsg = &frameMsg.body.hsMsg.body.clientHello;
2752 clientMsg->supportedGroups.exState = MISSING_FIELD;2784 clientMsg->supportedGroups.exState = MISSING_FIELD;
Mtestcode/sdv/testcase/tls/consistency/tlcp/test_suite_sdv_frame_tlcp_consistency.base.c+1-0
@@ -214,4 +214,5 @@ void SetFrameType(FRAME_Type *frametype, uint16_t versionType, REC_Type recordTy
214 frametype->recordType = recordType;214 frametype->recordType = recordType;
215 frametype->handshakeType = handshakeType;215 frametype->handshakeType = handshakeType;
216 frametype->keyExType = keyExType;216 frametype->keyExType = keyExType;
217+ frametype->transportType = BSL_UIO_TCP;
217}218}
Mtestcode/sdv/testcase/tls/consistency/tlcp/test_suite_sdv_frame_tlcp_consistency_1.c+9-9
@@ -39,7 +39,7 @@ void UT_TLS_TLCP_CONSISTENCY_UNEXPECT_RECORDTYPE_TC001(void)
39 39 
40 FRAME_Msg frameMsg = { 0 };40 FRAME_Msg frameMsg = { 0 };
41 FRAME_Type frameType = { 0 };41 FRAME_Type frameType = { 0 };
42- frameType.versionType = HITLS_VERSION_TLCP11;42+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
43 frameType.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;43 frameType.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;
44 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;44 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
45 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);45 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);
@@ -100,7 +100,7 @@ void UT_TLS_TLCP_CONSISTENCY_UNEXPECT_RECORDTYPE_TC002(void)
100 100 
101 FRAME_Msg frameMsg = { 0 };101 FRAME_Msg frameMsg = { 0 };
102 FRAME_Type frameType = { 0 };102 FRAME_Type frameType = { 0 };
103- frameType.versionType = HITLS_VERSION_TLCP11;103+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
104 frameType.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;104 frameType.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;
105 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;105 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
106 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);106 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);
@@ -161,7 +161,7 @@ void UT_TLS_TLCP_CONSISTENCY_UNEXPECT_RECORDTYPE_TC003(void)
161 161 
162 FRAME_Msg frameMsg = { 0 };162 FRAME_Msg frameMsg = { 0 };
163 FRAME_Type frameType = { 0 };163 FRAME_Type frameType = { 0 };
164- frameType.versionType = HITLS_VERSION_TLCP11;164+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
165 frameType.recordType = REC_TYPE_HANDSHAKE;165 frameType.recordType = REC_TYPE_HANDSHAKE;
166 frameType.handshakeType = SERVER_HELLO;166 frameType.handshakeType = SERVER_HELLO;
167 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;167 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
@@ -308,7 +308,7 @@ void UT_TLS_TLCP_CONSISTENCY_UNEXPECT_RECORDTYPE_TC005(void)
308 308 
309 FRAME_Msg frameMsg = { 0 };309 FRAME_Msg frameMsg = { 0 };
310 FRAME_Type frameType = { 0 };310 FRAME_Type frameType = { 0 };
311- SetFrameType(&frameType, HITLS_VERSION_TLCP11, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);311+ SetFrameType(&frameType, HITLS_VERSION_TLCP_DTLCP11, REC_TYPE_HANDSHAKE, SERVER_HELLO, HITLS_KEY_EXCH_ECDHE);
312 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);312 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);
313 313 
314 /* Reassembly */314 /* Reassembly */
@@ -1613,7 +1613,7 @@ void UT_TLS_TLCP_CONSISTENCY_MSGLENGTH_TOOLONG_TC001(void)
1613 uint32_t parseLen = 0;1613 uint32_t parseLen = 0;
1614 FRAME_Msg frameMsg = {0};1614 FRAME_Msg frameMsg = {0};
1615 FRAME_Type frameType = {0};1615 FRAME_Type frameType = {0};
1616- frameType.versionType = HITLS_VERSION_TLCP11;1616+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
1617 frameType.recordType = REC_TYPE_HANDSHAKE;1617 frameType.recordType = REC_TYPE_HANDSHAKE;
1618 frameType.handshakeType = CERTIFICATE;1618 frameType.handshakeType = CERTIFICATE;
1619 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1619 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
@@ -1682,7 +1682,7 @@ void UT_TLS_TLCP_CONSISTENCY_MSGLENGTH_TOOLONG_TC002(void)
1682 uint32_t parseLen = 0;1682 uint32_t parseLen = 0;
1683 FRAME_Msg frameMsg = {0};1683 FRAME_Msg frameMsg = {0};
1684 FRAME_Type frameType = {0};1684 FRAME_Type frameType = {0};
1685- frameType.versionType = HITLS_VERSION_TLCP11;1685+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
1686 frameType.recordType = REC_TYPE_HANDSHAKE;1686 frameType.recordType = REC_TYPE_HANDSHAKE;
1687 frameType.handshakeType = CERTIFICATE;1687 frameType.handshakeType = CERTIFICATE;
1688 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1688 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
@@ -1746,7 +1746,7 @@ void UT_TLS_TLCP_CONSISTENCY_MSGLENGTH_TOOLONG_TC003(void)
1746 1746 
1747 FRAME_Msg frameMsg = {0};1747 FRAME_Msg frameMsg = {0};
1748 FRAME_Type frameType = {0};1748 FRAME_Type frameType = {0};
1749- frameType.versionType = HITLS_VERSION_TLCP11;1749+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
1750 frameType.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;1750 frameType.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;
1751 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);1751 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType, &frameMsg) == HITLS_SUCCESS);
1752 1752 
@@ -1808,7 +1808,7 @@ void UT_TLS_TLCP_CONSISTENCY_MSGLENGTH_TOOLONG_TC004(void)
1808 1808 
1809 FRAME_Msg frameMsg1 = {0};1809 FRAME_Msg frameMsg1 = {0};
1810 FRAME_Type frameType1 = {0};1810 FRAME_Type frameType1 = {0};
1811- frameType1.versionType = HITLS_VERSION_TLCP11;1811+ frameType1.versionType = HITLS_VERSION_TLCP_DTLCP11;
1812 frameType1.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;1812 frameType1.recordType = REC_TYPE_CHANGE_CIPHER_SPEC;
1813 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType1, &frameMsg1) == HITLS_SUCCESS);1813 ASSERT_TRUE(FRAME_GetDefaultMsg(&frameType1, &frameMsg1) == HITLS_SUCCESS);
1814 1814 
@@ -1957,7 +1957,7 @@ void UT_TLS_TLCP_CONSISTENCY_NONZERO_MESSAGELEN_TC001()
1957 ASSERT_TRUE(recvLen != 0);1957 ASSERT_TRUE(recvLen != 0);
1958 1958 
1959 uint32_t parseLen = 0;1959 uint32_t parseLen = 0;
1960- frameType.versionType = HITLS_VERSION_TLCP11;1960+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
1961 frameType.recordType = REC_TYPE_HANDSHAKE;1961 frameType.recordType = REC_TYPE_HANDSHAKE;
1962 frameType.handshakeType = SERVER_HELLO_DONE;1962 frameType.handshakeType = SERVER_HELLO_DONE;
1963 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1963 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
Mtestcode/sdv/testcase/tls/consistency/tlcp/test_suite_sdv_frame_tlcp_consistency_1.data+11-11
@@ -32,40 +32,40 @@ UT_TLS_TLCP_CONSISTENCY_UNKNOW_RECORDTYPE_TC04
32UT_TLS_TLCP_CONSISTENCY_UNKNOW_RECORDTYPE_TC04:32UT_TLS_TLCP_CONSISTENCY_UNKNOW_RECORDTYPE_TC04:
33 33 
34UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC00134UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC001
35-UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC001:HITLS_VERSION_TLCP1135+UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC001:HITLS_VERSION_TLCP_DTLCP11
36 36 
37UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC00237UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC002
38-UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC002:HITLS_VERSION_TLCP1138+UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC002:HITLS_VERSION_TLCP_DTLCP11
39 39 
40UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC00340UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC003
41-UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC003:HITLS_VERSION_TLCP1141+UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC003:HITLS_VERSION_TLCP_DTLCP11
42 42 
43UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC00443UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC004
44UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC004:44UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC004:
45 45 
46UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC00546UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC005
47-UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC005:HITLS_VERSION_TLCP1147+UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC005:HITLS_VERSION_TLCP_DTLCP11
48 48 
49UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC00649UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC006
50-UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC006:HITLS_VERSION_TLCP1150+UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC006:HITLS_VERSION_TLCP_DTLCP11
51 51 
52UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC00752UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC007
53-UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC007:HITLS_VERSION_TLCP1153+UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC007:HITLS_VERSION_TLCP_DTLCP11
54 54 
55UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC00855UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC008
56-UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC008:HITLS_VERSION_TLCP1156+UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC008:HITLS_VERSION_TLCP_DTLCP11
57 57 
58UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC00958UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC009
59-UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC009:HITLS_VERSION_TLCP1159+UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC009:HITLS_VERSION_TLCP_DTLCP11
60 60 
61UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC01061UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC010
62-UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC010:HITLS_VERSION_TLCP1162+UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC010:HITLS_VERSION_TLCP_DTLCP11
63 63 
64UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC01164UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC011
65-UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC011:HITLS_VERSION_TLCP1165+UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC011:HITLS_VERSION_TLCP_DTLCP11
66 66 
67UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC01267UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC012
68-UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC012:HITLS_VERSION_TLCP1168+UT_TLS_TLCP_CONSISTENCY_UNEXPECT_HANDSHAKEMSG_TC012:HITLS_VERSION_TLCP_DTLCP11
69 69 
70UT_TLS_TLCP_CONSISTENCY_MSGLENGTH_TOOLONG_TC00170UT_TLS_TLCP_CONSISTENCY_MSGLENGTH_TOOLONG_TC001
71UT_TLS_TLCP_CONSISTENCY_MSGLENGTH_TOOLONG_TC001:71UT_TLS_TLCP_CONSISTENCY_MSGLENGTH_TOOLONG_TC001:
Mtestcode/sdv/testcase/tls/consistency/tlcp/test_suite_sdv_frame_tlcp_consistency_3.c+17-14
@@ -28,12 +28,12 @@ static void Test_MisSessionId(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len,
28 (void)bufSize;28 (void)bufSize;
29 (void)user;29 (void)user;
30 FRAME_Type frameType = { 0 };30 FRAME_Type frameType = { 0 };
31- frameType.versionType = HITLS_VERSION_TLCP11;31+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
32 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;32 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
33 FRAME_Msg frameMsg = { 0 };33 FRAME_Msg frameMsg = { 0 };
34 frameMsg.recType.data = REC_TYPE_HANDSHAKE;34 frameMsg.recType.data = REC_TYPE_HANDSHAKE;
35 frameMsg.length.data = *len;35 frameMsg.length.data = *len;
36- frameMsg.recVersion.data = HITLS_VERSION_TLCP11;36+ frameMsg.recVersion.data = HITLS_VERSION_TLCP_DTLCP11;
37 uint32_t parseLen = 0;37 uint32_t parseLen = 0;
38 FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);38 FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
39 ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);39 ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_HELLO);
@@ -103,12 +103,12 @@ static void Test_DiffServerKeyEx(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len,
103 (void)bufSize;103 (void)bufSize;
104 (void)user;104 (void)user;
105 FRAME_Type frameType = { 0 };105 FRAME_Type frameType = { 0 };
106- frameType.versionType = HITLS_VERSION_TLCP11;106+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
107 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;107 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
108 FRAME_Msg frameMsg = { 0 };108 FRAME_Msg frameMsg = { 0 };
109 frameMsg.recType.data = REC_TYPE_HANDSHAKE;109 frameMsg.recType.data = REC_TYPE_HANDSHAKE;
110 frameMsg.length.data = *len;110 frameMsg.length.data = *len;
111- frameMsg.recVersion.data = HITLS_VERSION_TLCP11;111+ frameMsg.recVersion.data = HITLS_VERSION_TLCP_DTLCP11;
112 uint32_t parseLen = 0;112 uint32_t parseLen = 0;
113 FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);113 FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
114 ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_KEY_EXCHANGE);114 ASSERT_EQ(frameMsg.body.hsMsg.type.data, SERVER_KEY_EXCHANGE);
@@ -407,6 +407,7 @@ static void TEST_SendUnexpectCertificateMsg(void *msg, void *data)
407 frameType->recordType = REC_TYPE_HANDSHAKE;407 frameType->recordType = REC_TYPE_HANDSHAKE;
408 frameType->handshakeType = CERTIFICATE;408 frameType->handshakeType = CERTIFICATE;
409 frameType->keyExType = HITLS_KEY_EXCH_ECDHE;409 frameType->keyExType = HITLS_KEY_EXCH_ECDHE;
410+ frameType->transportType = BSL_UIO_TCP;
410 if (memcpy_s(msg, sizeof(FRAME_Msg), &newFrameMsg, sizeof(newFrameMsg)) != EOK) {411 if (memcpy_s(msg, sizeof(FRAME_Msg), &newFrameMsg, sizeof(newFrameMsg)) != EOK) {
411 Print("TEST_SendUnexpectCertificateMsg memcpy_s Error!");412 Print("TEST_SendUnexpectCertificateMsg memcpy_s Error!");
412 }413 }
@@ -452,12 +453,14 @@ static void Test_ErrCertVerify(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len,
452 (void)bufSize;453 (void)bufSize;
453 (void)user;454 (void)user;
454 FRAME_Type frameType = { 0 };455 FRAME_Type frameType = { 0 };
455- frameType.versionType = HITLS_VERSION_TLCP11;456+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
456 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;457 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
458+ frameType.transportType = BSL_UIO_TCP;
457 FRAME_Msg frameMsg = { 0 };459 FRAME_Msg frameMsg = { 0 };
458 frameMsg.recType.data = REC_TYPE_HANDSHAKE;460 frameMsg.recType.data = REC_TYPE_HANDSHAKE;
459 frameMsg.length.data = *len;461 frameMsg.length.data = *len;
460- frameMsg.recVersion.data = HITLS_VERSION_TLCP11;462+ frameMsg.recVersion.data = HITLS_VERSION_TLCP_DTLCP11;
463+ frameMsg.transportType = BSL_UIO_TCP;
461 uint32_t parseLen = 0;464 uint32_t parseLen = 0;
462 FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);465 FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
463 ASSERT_EQ(frameMsg.body.hsMsg.type.data, CERTIFICATE_VERIFY);466 ASSERT_EQ(frameMsg.body.hsMsg.type.data, CERTIFICATE_VERIFY);
@@ -632,11 +635,11 @@ static void Test_Finish_Len_TooLong(HITLS_Ctx *ctx, uint8_t *data, uint32_t *len
632 (void)bufSize;635 (void)bufSize;
633 (void)user;636 (void)user;
634 FRAME_Type frameType = { 0 };637 FRAME_Type frameType = { 0 };
635- frameType.versionType = HITLS_VERSION_TLCP11;638+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
636 FRAME_Msg frameMsg = { 0 };639 FRAME_Msg frameMsg = { 0 };
637 frameMsg.recType.data = REC_TYPE_HANDSHAKE;640 frameMsg.recType.data = REC_TYPE_HANDSHAKE;
638 frameMsg.length.data = *len;641 frameMsg.length.data = *len;
639- frameMsg.recVersion.data = HITLS_VERSION_TLCP11;642+ frameMsg.recVersion.data = HITLS_VERSION_TLCP_DTLCP11;
640 uint32_t parseLen = 0;643 uint32_t parseLen = 0;
641 FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);644 FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
642 ASSERT_EQ(parseLen, *len);645 ASSERT_EQ(parseLen, *len);
@@ -659,11 +662,11 @@ static void Test_Finish_Len_TooLong_client(HITLS_Ctx *ctx, uint8_t *data, uint32
659 (void)bufSize;662 (void)bufSize;
660 (void)user;663 (void)user;
661 FRAME_Type frameType = { 0 };664 FRAME_Type frameType = { 0 };
662- frameType.versionType = HITLS_VERSION_TLCP11;665+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
663 FRAME_Msg frameMsg = { 0 };666 FRAME_Msg frameMsg = { 0 };
664 frameMsg.recType.data = REC_TYPE_HANDSHAKE;667 frameMsg.recType.data = REC_TYPE_HANDSHAKE;
665 frameMsg.length.data = *len;668 frameMsg.length.data = *len;
666- frameMsg.recVersion.data = HITLS_VERSION_TLCP11;669+ frameMsg.recVersion.data = HITLS_VERSION_TLCP_DTLCP11;
667 uint32_t parseLen = 0;670 uint32_t parseLen = 0;
668 FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);671 FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
669 ASSERT_EQ(parseLen, *len);672 ASSERT_EQ(parseLen, *len);
@@ -695,7 +698,7 @@ void UT_TLS_TLCP_CONSISTENCY_ERROR_FINISH_001(void)
695 FRAME_Init();698 FRAME_Init();
696 699 
697 ResumeTestInfo testInfo = {0};700 ResumeTestInfo testInfo = {0};
698- testInfo.version = HITLS_VERSION_TLCP11;701+ testInfo.version = HITLS_VERSION_TLCP_DTLCP11;
699 testInfo.uioType = BSL_UIO_TCP;702 testInfo.uioType = BSL_UIO_TCP;
700 RecWrapper wrapper = {703 RecWrapper wrapper = {
701 TRY_SEND_FINISH,704 TRY_SEND_FINISH,
@@ -740,7 +743,7 @@ void UT_TLS_TLCP_CONSISTENCY_ERROR_FINISH_002(void)
740 FRAME_Init();743 FRAME_Init();
741 744 
742 ResumeTestInfo testInfo = {0};745 ResumeTestInfo testInfo = {0};
743- testInfo.version = HITLS_VERSION_TLCP11;746+ testInfo.version = HITLS_VERSION_TLCP_DTLCP11;
744 testInfo.uioType = BSL_UIO_TCP;747 testInfo.uioType = BSL_UIO_TCP;
745 RecWrapper wrapper = {748 RecWrapper wrapper = {
746 TRY_SEND_FINISH,749 TRY_SEND_FINISH,
@@ -943,7 +946,7 @@ void UT_TLS_TLCP_CONSISTENCY_DISORDER_TC003(void)
943 946 
944 FRAME_Msg frameMsg = {0};947 FRAME_Msg frameMsg = {0};
945 FRAME_Type frameType = {0};948 FRAME_Type frameType = {0};
946- frameType.versionType = HITLS_VERSION_TLCP11;949+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
947 frameType.recordType = REC_TYPE_HANDSHAKE;950 frameType.recordType = REC_TYPE_HANDSHAKE;
948 frameType.handshakeType = CLIENT_KEY_EXCHANGE;951 frameType.handshakeType = CLIENT_KEY_EXCHANGE;
949 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;952 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
@@ -1445,7 +1448,7 @@ void UT_TLS_TLCP_CONSISTENCY_AMEND_APPDATA_TC001(char *cipherSuite, int isClient
1445 ASSERT_TRUE(recvLen != 0);1448 ASSERT_TRUE(recvLen != 0);
1446 1449 
1447 uint32_t parseLen = 0;1450 uint32_t parseLen = 0;
1448- frameType.versionType = HITLS_VERSION_TLCP11;1451+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
1449 frameType.recordType = REC_TYPE_APP;1452 frameType.recordType = REC_TYPE_APP;
1450 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;1453 frameType.keyExType = HITLS_KEY_EXCH_ECDHE;
1451 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);1454 ASSERT_TRUE(FRAME_ParseMsg(&frameType, recvBuf, recvLen, &frameMsg, &parseLen) == HITLS_SUCCESS);
Mtestcode/sdv/testcase/tls/consistency/tlcp/test_suite_sdv_hlt_tlcp_consistency.c+2-2
@@ -1256,11 +1256,11 @@ static void TEST_Client_SessionidLength_TooLong(HITLS_Ctx *ctx, uint8_t *data, u
1256 (void)ctx;1256 (void)ctx;
1257 (void)user;1257 (void)user;
1258 FRAME_Type frameType = {0};1258 FRAME_Type frameType = {0};
1259- frameType.versionType = HITLS_VERSION_TLCP11;1259+ frameType.versionType = HITLS_VERSION_TLCP_DTLCP11;
1260 FRAME_Msg frameMsg = {0};1260 FRAME_Msg frameMsg = {0};
1261 frameMsg.recType.data = REC_TYPE_HANDSHAKE;1261 frameMsg.recType.data = REC_TYPE_HANDSHAKE;
1262 frameMsg.length.data = *len;1262 frameMsg.length.data = *len;
1263- frameMsg.recVersion.data = HITLS_VERSION_TLCP11;1263+ frameMsg.recVersion.data = HITLS_VERSION_TLCP_DTLCP11;
1264 uint32_t parseLen = 0;1264 uint32_t parseLen = 0;
1265 FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);1265 FRAME_ParseMsgBody(&frameType, data, *len, &frameMsg, &parseLen);
1266 ASSERT_EQ(parseLen, *len);1266 ASSERT_EQ(parseLen, *len);
Mtestcode/sdv/testcase/tls/consistency/tls12/test_suite_tls12_consistency_rfc5246.base.c+1-0
@@ -489,4 +489,5 @@ void SetFrameType(FRAME_Type *frametype, uint16_t versionType, REC_Type recordTy
489 frametype->recordType = recordType;489 frametype->recordType = recordType;
490 frametype->handshakeType = handshakeType;490 frametype->handshakeType = handshakeType;
491 frametype->keyExType = keyExType;491 frametype->keyExType = keyExType;
492+ frametype->transportType = BSL_UIO_TCP;
492}493}
Mtestcode/sdv/testcase/tls/consistency/tls13/test_suite_sdv_frame_tls13_consistency_rfc8446_2.c+1-0
@@ -3056,6 +3056,7 @@ void SetFrameType(FRAME_Type *frametype, uint16_t versionType, REC_Type recordTy
3056 frametype->recordType = recordType;3056 frametype->recordType = recordType;
3057 frametype->handshakeType = handshakeType;3057 frametype->handshakeType = handshakeType;
3058 frametype->keyExType = keyExType;3058 frametype->keyExType = keyExType;
3059+ frametype->transportType = BSL_UIO_TCP;
3059}3060}
3060 3061 
3061/** @3062/** @
Mtestcode/sdv/testcase/tls/consistency/tls13/test_suite_sdv_frame_tls13_consistency_rfc8446_kex.c+1-0
@@ -77,6 +77,7 @@ void SetFrameType(FRAME_Type *frametype, uint16_t versionType, REC_Type recordTy
77 frametype->recordType = recordType;77 frametype->recordType = recordType;
78 frametype->handshakeType = handshakeType;78 frametype->handshakeType = handshakeType;
79 frametype->keyExType = keyExType;79 frametype->keyExType = keyExType;
80+ frametype->transportType = BSL_UIO_TCP;
80}81}
81 82 
82void TestSetCertPath(HLT_Ctx_Config *ctxConfig, char *SignatureType)83void TestSetCertPath(HLT_Ctx_Config *ctxConfig, char *SignatureType)
Mtestcode/sdv/testcase/tls/consistency/tls13/test_suite_tls13_consistency_rfc8446.base.c+1-0
@@ -215,6 +215,7 @@ void SetFrameType(FRAME_Type *frametype, uint16_t versionType, REC_Type recordTy
215 frametype->recordType = recordType;215 frametype->recordType = recordType;
216 frametype->handshakeType = handshakeType;216 frametype->handshakeType = handshakeType;
217 frametype->keyExType = keyExType;217 frametype->keyExType = keyExType;
218+ frametype->transportType = BSL_UIO_TCP;
218}219}
219 220 
220FieldState *GetDataAddress(FRAME_Msg *data, void *member)221FieldState *GetDataAddress(FRAME_Msg *data, void *member)
Mtestcode/sdv/testcase/tls/interface_tlcp/test_suite_sdv_frame_cm_interface.c+1-1
@@ -483,7 +483,7 @@ void UT_TLS_CM_GET_NEGOTIATED_VERSION_FUNC_TC001(int version)
483 ASSERT_TRUE(client != NULL);483 ASSERT_TRUE(client != NULL);
484 server = FRAME_CreateLink(config, BSL_UIO_TCP);484 server = FRAME_CreateLink(config, BSL_UIO_TCP);
485 ASSERT_TRUE(server != NULL);485 ASSERT_TRUE(server != NULL);
486- uint16_t negoVersion = HITLS_VERSION_TLCP11;486+ uint16_t negoVersion = HITLS_VERSION_TLCP_DTLCP11;
487 ret = HITLS_GetNegotiatedVersion(client->ssl, &negoVersion);487 ret = HITLS_GetNegotiatedVersion(client->ssl, &negoVersion);
488 ASSERT_EQ(ret, HITLS_SUCCESS);488 ASSERT_EQ(ret, HITLS_SUCCESS);
489 ASSERT_EQ(negoVersion, 0);489 ASSERT_EQ(negoVersion, 0);
Mtestcode/sdv/testcase/tls/interface_tlcp/test_suite_sdv_frame_config_interface.c+2-2
@@ -567,10 +567,10 @@ void UT_TLS_CFG_SET_GET_VERSION_API_TC001(void)
567 ASSERT_TRUE(HITLS_CFG_GetMaxVersion(dtlsConfig, &maxVersion) == HITLS_SUCCESS);567 ASSERT_TRUE(HITLS_CFG_GetMaxVersion(dtlsConfig, &maxVersion) == HITLS_SUCCESS);
568 ASSERT_TRUE(minVersion == HITLS_VERSION_DTLS12 && maxVersion == HITLS_VERSION_DTLS12);568 ASSERT_TRUE(minVersion == HITLS_VERSION_DTLS12 && maxVersion == HITLS_VERSION_DTLS12);
569 569 
570- ASSERT_TRUE(HITLS_CFG_SetVersion(tlcpConfig, HITLS_VERSION_TLCP11, HITLS_VERSION_TLCP11) == HITLS_SUCCESS);570+ ASSERT_TRUE(HITLS_CFG_SetVersion(tlcpConfig, HITLS_VERSION_TLCP_DTLCP11, HITLS_VERSION_TLCP_DTLCP11) == HITLS_SUCCESS);
571 ASSERT_TRUE(HITLS_CFG_GetMinVersion(tlcpConfig, &minVersion) == HITLS_SUCCESS);571 ASSERT_TRUE(HITLS_CFG_GetMinVersion(tlcpConfig, &minVersion) == HITLS_SUCCESS);
572 ASSERT_TRUE(HITLS_CFG_GetMaxVersion(tlcpConfig, &maxVersion) == HITLS_SUCCESS);572 ASSERT_TRUE(HITLS_CFG_GetMaxVersion(tlcpConfig, &maxVersion) == HITLS_SUCCESS);
573- ASSERT_TRUE(minVersion == HITLS_VERSION_TLCP11 && maxVersion == HITLS_VERSION_TLCP11);573+ ASSERT_TRUE(minVersion == HITLS_VERSION_TLCP_DTLCP11 && maxVersion == HITLS_VERSION_TLCP_DTLCP11);
574 574 
575EXIT:575EXIT:
576 HITLS_CFG_FreeConfig(config);576 HITLS_CFG_FreeConfig(config);
Mtls/app/src/app.c+1-1
@@ -64,7 +64,7 @@ int32_t APP_GetMaxWriteSize(const TLS_Ctx *ctx, uint32_t *len)
64static int32_t SavePendingData(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen)64static int32_t SavePendingData(TLS_Ctx *ctx, const uint8_t *data, uint32_t dataLen)
65{65{
66#ifdef HITLS_TLS_PROTO_DTLS66#ifdef HITLS_TLS_PROTO_DTLS
67- if (IS_DTLS_VERSION(ctx->negotiatedInfo.version)) {67+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
68 return HITLS_SUCCESS;68 return HITLS_SUCCESS;
69 }69 }
70#endif70#endif
Mtls/cert/cert_adapt/cert.c+2-2
@@ -566,7 +566,7 @@ int32_t SAL_CERT_SelectCertByInfo(HITLS_Ctx *ctx, CERT_ExpectInfo *info)
566 /* The user does not set the certificate callback. */566 /* The user does not set the certificate callback. */
567 return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID16313, "unregistered callback");567 return RETURN_ERROR_NUMBER_PROCESS(HITLS_UNREGISTERED_CALLBACK, BINLOG_ID16313, "unregistered callback");
568 }568 }
569- if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11) {569+ if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
570#ifdef HITLS_TLS_PROTO_TLCP11570#ifdef HITLS_TLS_PROTO_TLCP11
571 ret = TlcpSelectCertByInfo(ctx, info);571 ret = TlcpSelectCertByInfo(ctx, info);
572#endif572#endif
@@ -679,7 +679,7 @@ static int32_t EncodeEECert(HITLS_Ctx *ctx, uint8_t *buf, uint32_t bufLen, uint3
679 /* If the TLCP algorithm is used and the encryption certificate is required,679 /* If the TLCP algorithm is used and the encryption certificate is required,
680 write the second encryption certificate. */680 write the second encryption certificate. */
681 HITLS_CERT_X509 *certEnc = currentCertPair->encCert;681 HITLS_CERT_X509 *certEnc = currentCertPair->encCert;
682- if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11 && certEnc != NULL) {682+ if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11 && certEnc != NULL) {
683#ifdef HITLS_TLS_FEATURE_SECURITY683#ifdef HITLS_TLS_FEATURE_SECURITY
684 HITLS_CERT_Key *keyEnc = currentCertPair->encPrivateKey;684 HITLS_CERT_Key *keyEnc = currentCertPair->encPrivateKey;
685 ret = CheckKeySecbits(ctx, certEnc, keyEnc);685 ret = CheckKeySecbits(ctx, certEnc, keyEnc);
Mtls/cm/src/conn_create.c+1-1
@@ -209,7 +209,7 @@ static void ConfigPmtu(HITLS_Ctx *ctx, BSL_UIO *uio)
209 (void)uio;209 (void)uio;
210#ifdef HITLS_TLS_PROTO_DTLS12210#ifdef HITLS_TLS_PROTO_DTLS12
211 /* The PMTU needs to be set for DTLS. If the PMTU is not set, use the default value */211 /* The PMTU needs to be set for DTLS. If the PMTU is not set, use the default value */
212- if ((ctx->config.pmtu == 0) && IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion)) {212+ if ((ctx->config.pmtu == 0) && IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
213 ctx->config.pmtu = DTLS_SCTP_PMTU;213 ctx->config.pmtu = DTLS_SCTP_PMTU;
214 }214 }
215#endif215#endif
Mtls/cm/src/conn_read.c+1-1
@@ -228,7 +228,7 @@ static int32_t PreprocessUnexpectHsMsg(HITLS_Ctx *ctx)
228 228 
229static void ConsumeHandshakeMessage(HITLS_Ctx *ctx)229static void ConsumeHandshakeMessage(HITLS_Ctx *ctx)
230{230{
231- bool isDtls = IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion);231+ bool isDtls = IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask);
232 uint32_t headerLen = isDtls ? DTLS_HS_MSG_HEADER_SIZE : HS_MSG_HEADER_SIZE;232 uint32_t headerLen = isDtls ? DTLS_HS_MSG_HEADER_SIZE : HS_MSG_HEADER_SIZE;
233 int32_t ret = ReadHsMessage(ctx, headerLen);233 int32_t ret = ReadHsMessage(ctx, headerLen);
234 if (ret != HITLS_SUCCESS) {234 if (ret != HITLS_SUCCESS) {
Mtls/config/src/cipher_suite.c+7-7
@@ -1443,7 +1443,7 @@ static const CipherSuiteInfo g_cipherSuiteList[] = {
1443 .hashAlg = HITLS_HASH_SM3,1443 .hashAlg = HITLS_HASH_SM3,
1444 .signScheme = CERT_SIG_SCHEME_SM2_SM3,1444 .signScheme = CERT_SIG_SCHEME_SM2_SM3,
1445 KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),1445 KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
1446- VERSION_SCOPE(HITLS_VERSION_TLCP11, HITLS_VERSION_TLCP11, 0, 0),1446+ VERSION_SCOPE(HITLS_VERSION_TLCP_DTLCP11, HITLS_VERSION_TLCP_DTLCP11, 0, 0),
1447 .cipherType = HITLS_CBC_CIPHER,1447 .cipherType = HITLS_CBC_CIPHER,
1448 .strengthBits = 128},1448 .strengthBits = 128},
1449#endif1449#endif
@@ -1459,7 +1459,7 @@ static const CipherSuiteInfo g_cipherSuiteList[] = {
1459 .hashAlg = HITLS_HASH_SM3,1459 .hashAlg = HITLS_HASH_SM3,
1460 .signScheme = CERT_SIG_SCHEME_SM2_SM3,1460 .signScheme = CERT_SIG_SCHEME_SM2_SM3,
1461 KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),1461 KEY_BLOCK_PARTITON_LENGTH(16u, 16u, 32u, 16u, 16u, 32u),
1462- VERSION_SCOPE(HITLS_VERSION_TLCP11, HITLS_VERSION_TLCP11, 0, 0),1462+ VERSION_SCOPE(HITLS_VERSION_TLCP_DTLCP11, HITLS_VERSION_TLCP_DTLCP11, 0, 0),
1463 .cipherType = HITLS_CBC_CIPHER,1463 .cipherType = HITLS_CBC_CIPHER,
1464 .strengthBits = 128},1464 .strengthBits = 128},
1465#endif1465#endif
@@ -1475,7 +1475,7 @@ static const CipherSuiteInfo g_cipherSuiteList[] = {
1475 .hashAlg = HITLS_HASH_SM3,1475 .hashAlg = HITLS_HASH_SM3,
1476 .signScheme = CERT_SIG_SCHEME_SM2_SM3,1476 .signScheme = CERT_SIG_SCHEME_SM2_SM3,
1477 KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),1477 KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
1478- VERSION_SCOPE(HITLS_VERSION_TLCP11, HITLS_VERSION_TLCP11, 0, 0),1478+ VERSION_SCOPE(HITLS_VERSION_TLCP_DTLCP11, HITLS_VERSION_TLCP_DTLCP11, 0, 0),
1479 .cipherType = HITLS_AEAD_CIPHER,1479 .cipherType = HITLS_AEAD_CIPHER,
1480 .strengthBits = 128},1480 .strengthBits = 128},
1481#endif1481#endif
@@ -1491,7 +1491,7 @@ static const CipherSuiteInfo g_cipherSuiteList[] = {
1491 .hashAlg = HITLS_HASH_SM3,1491 .hashAlg = HITLS_HASH_SM3,
1492 .signScheme = CERT_SIG_SCHEME_SM2_SM3,1492 .signScheme = CERT_SIG_SCHEME_SM2_SM3,
1493 KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),1493 KEY_BLOCK_PARTITON_LENGTH(4u, 16u, 0u, 0u, 8u, 16u),
1494- VERSION_SCOPE(HITLS_VERSION_TLCP11, HITLS_VERSION_TLCP11, 0, 0),1494+ VERSION_SCOPE(HITLS_VERSION_TLCP_DTLCP11, HITLS_VERSION_TLCP_DTLCP11, 0, 0),
1495 .cipherType = HITLS_AEAD_CIPHER,1495 .cipherType = HITLS_AEAD_CIPHER,
1496 .strengthBits = 128},1496 .strengthBits = 128},
1497#endif1497#endif
@@ -1749,7 +1749,7 @@ bool CFG_GetSignParamBySchemes(uint16_t version, HITLS_SignHashAlgo scheme, HITL
1749{1749{
1750 bool ret = false;1750 bool ret = false;
1751#ifdef HITLS_TLS_PROTO_TLCP111751#ifdef HITLS_TLS_PROTO_TLCP11
1752- if (version == HITLS_VERSION_TLCP11) {1752+ if (version == HITLS_VERSION_TLCP_DTLCP11) {
1753 for (uint32_t i = 0; i < (sizeof(g_signSchemeListGm) / sizeof(g_signSchemeListGm[0])); i++) {1753 for (uint32_t i = 0; i < (sizeof(g_signSchemeListGm) / sizeof(g_signSchemeListGm[0])); i++) {
1754 if (scheme == g_signSchemeListGm[i].scheme) {1754 if (scheme == g_signSchemeListGm[i].scheme) {
1755 *signAlg = g_signSchemeListGm[i].signAlg;1755 *signAlg = g_signSchemeListGm[i].signAlg;
@@ -1831,8 +1831,8 @@ static const uint8_t* ProtocolToString(uint16_t version)
1831 case HITLS_VERSION_DTLS12:1831 case HITLS_VERSION_DTLS12:
1832 ret = "DTLSv1.2";1832 ret = "DTLSv1.2";
1833 break;1833 break;
1834- case HITLS_VERSION_TLCP11:1834+ case HITLS_VERSION_TLCP_DTLCP11:
1835- ret = "TLCP1.1";1835+ ret = "(D)TLCP1.1";
1836 break;1836 break;
1837 default:1837 default:
1838 ret = "unknown";1838 ret = "unknown";
Mtls/config/src/config.c+38-4
@@ -525,6 +525,30 @@ HITLS_Config *HITLS_CFG_ProviderNewDTLS12Config(HITLS_Lib_Ctx *libCtx, const cha
525 525 
526#endif526#endif
527 527 
528+#ifdef HITLS_TLS_PROTO_DTLCP11
529+HITLS_Config *HITLS_CFG_NewDTLCPConfig(void)
530+{
531+ return HITLS_CFG_ProviderNewDTLCPConfig(NULL, NULL);
532+}
533+ 
534+HITLS_Config *HITLS_CFG_ProviderNewDTLCPConfig(HITLS_Lib_Ctx *libCtx, const char *attrName)
535+{
536+ HITLS_Config *newConfig = CreateConfig();
537+ if (newConfig == NULL) {
538+ return NULL;
539+ }
540+
541+ newConfig->version |= DTLCP11_VERSION_BIT; // Enable DTLCP 1.1
542+ if (DefaultConfig(libCtx, attrName, HITLS_VERSION_TLCP_DTLCP11, newConfig) != HITLS_SUCCESS) {
543+ BSL_SAL_FREE(newConfig);
544+ return NULL;
545+ }
546+ newConfig->originVersionMask = newConfig->version;
547+ return newConfig;
548+}
549+ 
550+#endif
551+ 
528#ifdef HITLS_TLS_PROTO_TLCP11552#ifdef HITLS_TLS_PROTO_TLCP11
529HITLS_Config *HITLS_CFG_NewTLCPConfig(void)553HITLS_Config *HITLS_CFG_NewTLCPConfig(void)
530{554{
@@ -537,8 +561,8 @@ HITLS_Config *HITLS_CFG_ProviderNewTLCPConfig(HITLS_Lib_Ctx *libCtx, const char
537 if (newConfig == NULL) {561 if (newConfig == NULL) {
538 return NULL;562 return NULL;
539 }563 }
540- newConfig->version |= TLCP11_VERSION_BIT; // Enable TLS 1.2564+ newConfig->version |= TLCP11_VERSION_BIT; // Enable TLCP 1.1
541- if (DefaultConfig(libCtx, attrName, HITLS_VERSION_TLCP11, newConfig) != HITLS_SUCCESS) {565+ if (DefaultConfig(libCtx, attrName, HITLS_VERSION_TLCP_DTLCP11, newConfig) != HITLS_SUCCESS) {
542 BSL_SAL_FREE(newConfig);566 BSL_SAL_FREE(newConfig);
543 return NULL;567 return NULL;
544 }568 }
@@ -668,6 +692,16 @@ uint32_t MapVersion2VersionBit(bool isDatagram, uint16_t version)
668 case HITLS_VERSION_TLS13:692 case HITLS_VERSION_TLS13:
669 ret = TLS13_VERSION_BIT;693 ret = TLS13_VERSION_BIT;
670 break;694 break;
695+ case HITLS_VERSION_TLCP_DTLCP11:
696+ if (isDatagram) {
697+ ret = DTLCP11_VERSION_BIT;
698+ } else {
699+ ret = TLCP11_VERSION_BIT;
700+ }
701+ break;
702+ case HITLS_VERSION_DTLS12:
703+ ret = DTLS12_VERSION_BIT;
704+ break;
671 default:705 default:
672 break;706 break;
673 }707 }
@@ -700,7 +734,7 @@ static int ChangeVersionMask(HITLS_Config *config, uint16_t minVersion, uint16_t
700 }734 }
701 735 
702 for (uint16_t version = minVersion; version <= maxVersion; version++) {736 for (uint16_t version = minVersion; version <= maxVersion; version++) {
703- versionBit = MapVersion2VersionBit(false, version);737+ versionBit = MapVersion2VersionBit(IS_SUPPORT_DATAGRAM(originVersionMask), version);
704 versionMask |= versionBit;738 versionMask |= versionBit;
705 }739 }
706 740 
@@ -808,7 +842,7 @@ int32_t HITLS_CFG_SetVersionForbid(HITLS_Config *config, uint32_t noVersion)
808 }842 }
809 // Now only DTLS1.2 is supported, so single version is not supported (disable to version 0)843 // Now only DTLS1.2 is supported, so single version is not supported (disable to version 0)
810 if ((config->originVersionMask & TLS_VERSION_MASK) == TLS_VERSION_MASK) {844 if ((config->originVersionMask & TLS_VERSION_MASK) == TLS_VERSION_MASK) {
811- uint32_t noVersionBit = MapVersion2VersionBit(false, noVersion);845+ uint32_t noVersionBit = MapVersion2VersionBit(IS_SUPPORT_DATAGRAM(config->originVersionMask), noVersion);
812 if ((config->version & (~noVersionBit)) == 0) {846 if ((config->version & (~noVersionBit)) == 0) {
813 return HITLS_SUCCESS; // Not all is disabled but the return value is SUCCESS847 return HITLS_SUCCESS; // Not all is disabled but the return value is SUCCESS
814 }848 }
Mtls/config/src/config_check.c+3-3
@@ -32,7 +32,7 @@ static bool IsSignAlgValid(uint16_t signAlg, uint16_t version)
32{32{
33 uint32_t listLen = 0;33 uint32_t listLen = 0;
34#ifdef HITLS_TLS_PROTO_TLCP1134#ifdef HITLS_TLS_PROTO_TLCP11
35- const SignSchemeInfo *signSchemeList = (version != HITLS_VERSION_TLCP11) ?35+ const SignSchemeInfo *signSchemeList = (version != HITLS_VERSION_TLCP_DTLCP11) ?
36 CFG_GetSignSchemeList(&listLen) :36 CFG_GetSignSchemeList(&listLen) :
37 CFG_GetSignSchemeListTlcp(&listLen);37 CFG_GetSignSchemeListTlcp(&listLen);
38#else38#else
@@ -54,7 +54,7 @@ static bool CFG_IsValidVersion(uint16_t version)
54 case HITLS_VERSION_TLS12:54 case HITLS_VERSION_TLS12:
55 case HITLS_VERSION_TLS13:55 case HITLS_VERSION_TLS13:
56 case HITLS_VERSION_DTLS12:56 case HITLS_VERSION_DTLS12:
57- case HITLS_VERSION_TLCP11:57+ case HITLS_VERSION_TLCP_DTLCP11:
58 return true;58 return true;
59 default:59 default:
60 break;60 break;
@@ -238,7 +238,7 @@ int32_t CheckVersion(uint16_t minVersion, uint16_t maxVersion)
238 return HITLS_CONFIG_INVALID_VERSION;238 return HITLS_CONFIG_INVALID_VERSION;
239 }239 }
240#ifdef HITLS_TLS_PROTO_TLCP11240#ifdef HITLS_TLS_PROTO_TLCP11
241- if (minVersion == HITLS_VERSION_TLCP11 || maxVersion == HITLS_VERSION_TLCP11) {241+ if (minVersion == HITLS_VERSION_TLCP_DTLCP11 || maxVersion == HITLS_VERSION_TLCP_DTLCP11) {
242 if (minVersion != maxVersion) {242 if (minVersion != maxVersion) {
243 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16233, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,243 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16233, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
244 "Config max version [0x%x] or min version [0x%x] is invalid.", maxVersion,244 "Config max version [0x%x] or min version [0x%x] is invalid.", maxVersion,
Mtls/config/src/config_default.c+4-4
@@ -134,7 +134,7 @@ static int32_t SetDefaultSignHashAlg(HITLS_Config *config)
134{134{
135 uint32_t listLen = 0;135 uint32_t listLen = 0;
136#ifdef HITLS_TLS_PROTO_TLCP11136#ifdef HITLS_TLS_PROTO_TLCP11
137- const SignSchemeInfo *signHashAlgList = (config->maxVersion != HITLS_VERSION_TLCP11) ?137+ const SignSchemeInfo *signHashAlgList = (config->maxVersion != HITLS_VERSION_TLCP_DTLCP11) ?
138 CFG_GetSignSchemeList(&listLen) :138 CFG_GetSignSchemeList(&listLen) :
139 CFG_GetSignSchemeListTlcp(&listLen);139 CFG_GetSignSchemeListTlcp(&listLen);
140#else140#else
@@ -212,9 +212,9 @@ static void InitConfig(HITLS_Config *config)
212 config->needCheckKeyUsage = true;212 config->needCheckKeyUsage = true;
213#endif213#endif
214#ifdef HITLS_TLS_CONFIG_MANUAL_DH214#ifdef HITLS_TLS_CONFIG_MANUAL_DH
215- config->isSupportDhAuto = (config->maxVersion == HITLS_VERSION_TLCP11) ? false : true;215+ config->isSupportDhAuto = (config->maxVersion == HITLS_VERSION_TLCP_DTLCP11) ? false : true;
216#endif216#endif
217- if (config->maxVersion == HITLS_VERSION_TLCP11) {217+ if (config->maxVersion == HITLS_VERSION_TLCP_DTLCP11) {
218 config->isSupportExtendMasterSecret = false;218 config->isSupportExtendMasterSecret = false;
219 }219 }
220#ifdef HITLS_TLS_FEATURE_FLIGHT220#ifdef HITLS_TLS_FEATURE_FLIGHT
@@ -254,7 +254,7 @@ static int32_t DefaultCipherSuitesByVersion(uint16_t version, HITLS_Config *conf
254 uint32_t size = sizeof(g_tls12CipherSuites);254 uint32_t size = sizeof(g_tls12CipherSuites);
255 switch (version) {255 switch (version) {
256#ifdef HITLS_TLS_PROTO_TLCP11256#ifdef HITLS_TLS_PROTO_TLCP11
257- case HITLS_VERSION_TLCP11:257+ case HITLS_VERSION_TLCP_DTLCP11:
258 groups = g_tlcpCipherSuites;258 groups = g_tlcpCipherSuites;
259 size = sizeof(g_tlcpCipherSuites);259 size = sizeof(g_tlcpCipherSuites);
260 break;260 break;
Mtls/config/src/config_group.c+1-1
@@ -92,7 +92,7 @@ static const TLS_GroupInfo GROUP_INFO[] = {
92 CRYPT_PKEY_SM2, // CRYPT_PKEY_SM292 CRYPT_PKEY_SM2, // CRYPT_PKEY_SM2
93 128, // secBits93 128, // secBits
94 HITLS_EC_GROUP_SM2, // groupId94 HITLS_EC_GROUP_SM2, // groupId
95- TLCP11_VERSION_BIT, // versionBits95+ TLCP11_VERSION_BIT | DTLCP11_VERSION_BIT, // versionBits
96 false,96 false,
97 },97 },
98 {98 {
Mtls/feature/security/src/security_default.c+2-2
@@ -123,12 +123,12 @@ static int32_t CheckVersion(int32_t id, int32_t level)
123#ifdef HITLS_TLS_PROTO_TLCP11123#ifdef HITLS_TLS_PROTO_TLCP11
124 /* If the level is greater than or equal to 1, SSL2.0, SSL3.0, TLS1.0, and TLS1.1 cannot be used. */124 /* If the level is greater than or equal to 1, SSL2.0, SSL3.0, TLS1.0, and TLS1.1 cannot be used. */
125 if ((level >= HITLS_SECURITY_LEVEL_ONE) && ((uint32_t)id < HITLS_VERSION_TLS12) &&125 if ((level >= HITLS_SECURITY_LEVEL_ONE) && ((uint32_t)id < HITLS_VERSION_TLS12) &&
126- ((uint32_t)id != HITLS_VERSION_TLCP11)) {126+ ((uint32_t)id != HITLS_VERSION_TLCP_DTLCP11)) {
127 return SECURITY_ERR;127 return SECURITY_ERR;
128 }128 }
129 /* Level is greater than or equal to 4 and TLCP1.1 is prohibited because the security strength of the signature129 /* Level is greater than or equal to 4 and TLCP1.1 is prohibited because the security strength of the signature
130 * algorithm CERT_SIG_SCHEME_SM2_SM3 is 128 bits. */130 * algorithm CERT_SIG_SCHEME_SM2_SM3 is 128 bits. */
131- if ((level >= HITLS_SECURITY_LEVEL_FOUR) && ((uint32_t)id == HITLS_VERSION_TLCP11)) {131+ if ((level >= HITLS_SECURITY_LEVEL_FOUR) && ((uint32_t)id == HITLS_VERSION_TLCP_DTLCP11)) {
132 return SECURITY_ERR;132 return SECURITY_ERR;
133 }133 }
134#else134#else
Mtls/handshake/common/src/hs_common.c+2-2
@@ -435,7 +435,7 @@ bool IsNeedServerKeyExchange(const TLS_Ctx *ctx)
435 }435 }
436 }436 }
437#ifdef HITLS_TLS_PROTO_TLCP11437#ifdef HITLS_TLS_PROTO_TLCP11
438- if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11) {438+ if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
439 return true; /* The TLCP needs to send the ServerKeyExchange message. */439 return true; /* The TLCP needs to send the ServerKeyExchange message. */
440 }440 }
441#endif441#endif
@@ -687,7 +687,7 @@ uint32_t HS_GetBinderLen(HITLS_Session *session, HITLS_HashAlgo *hashAlg)
687 687 
688bool GroupConformToVersion(const TLS_Ctx *ctx, uint16_t version, uint16_t group)688bool GroupConformToVersion(const TLS_Ctx *ctx, uint16_t version, uint16_t group)
689{689{
690- uint32_t versionBits = MapVersion2VersionBit(IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion), version);690+ uint32_t versionBits = MapVersion2VersionBit(IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask), version);
691 const TLS_GroupInfo *groupInfo = ConfigGetGroupInfo(&ctx->config.tlsConfig, group);691 const TLS_GroupInfo *groupInfo = ConfigGetGroupInfo(&ctx->config.tlsConfig, group);
692 if (groupInfo == NULL || ((groupInfo->versionBits & versionBits) != versionBits)) {692 if (groupInfo == NULL || ((groupInfo->versionBits & versionBits) != versionBits)) {
693 return false;693 return false;
Mtls/handshake/common/src/hs_kx.c+1-1
@@ -490,7 +490,7 @@ static int32_t GenPremasterSecretFromEcdhe(TLS_Ctx *ctx, uint8_t *preMasterSecre
490{490{
491#ifdef HITLS_TLS_PROTO_TLCP11491#ifdef HITLS_TLS_PROTO_TLCP11
492 int32_t ret = HITLS_SUCCESS;492 int32_t ret = HITLS_SUCCESS;
493- if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11) {493+ if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
494 HITLS_Config *config = &ctx->config.tlsConfig;494 HITLS_Config *config = &ctx->config.tlsConfig;
495 CERT_MgrCtx *certMgrCtx = config->certMgrCtx;495 CERT_MgrCtx *certMgrCtx = config->certMgrCtx;
496 HITLS_CERT_Key *priKey = SAL_CERT_GetCurrentPrivateKey(certMgrCtx, true);496 HITLS_CERT_Key *priKey = SAL_CERT_GetCurrentPrivateKey(certMgrCtx, true);
Mtls/handshake/common/src/hs_verify.c+1-1
@@ -319,7 +319,7 @@ static uint8_t *GetUnsignData(TLS_Ctx *ctx, uint32_t *dataLen, bool isClient, HI
319 }319 }
320#endif /* HITLS_TLS_PROTO_TLS13 */320#endif /* HITLS_TLS_PROTO_TLS13 */
321#ifdef HITLS_TLS_PROTO_TLCP11321#ifdef HITLS_TLS_PROTO_TLCP11
322- if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11) {322+ if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
323 return TlcpGetUnsignData(ctx, dataLen);323 return TlcpGetUnsignData(ctx, dataLen);
324 }324 }
325#endif325#endif
Mtls/handshake/pack/src/pack.c+6-1
@@ -217,7 +217,12 @@ int32_t HS_PackMsg(TLS_Ctx *ctx, HS_MsgType type, uint8_t *buf, uint32_t bufLen,
217#ifdef HITLS_TLS_PROTO_TLS_BASIC217#ifdef HITLS_TLS_PROTO_TLS_BASIC
218 case HITLS_VERSION_TLS12:218 case HITLS_VERSION_TLS12:
219#ifdef HITLS_TLS_PROTO_TLCP11219#ifdef HITLS_TLS_PROTO_TLCP11
220- case HITLS_VERSION_TLCP11:220+ case HITLS_VERSION_TLCP_DTLCP11:
221+#if defined(HITLS_TLS_PROTO_DTLCP11)
B
Bbaoyi849302025年2月21日

emmm 感觉这两个版本号一致，我们不能用不同的宏来表示，这样会引起误导，我们应该用一个联合的宏来表示，类似这种 HITLS_VERSION_TLCP11_DTLCP11 ?

likedislike
222+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
223+ return Dtls12PackMsg(ctx, type, buf, bufLen, usedLen);
224+ }
225+#endif
221#endif226#endif
222 return Tls12PackMsg(ctx, type, buf, bufLen, usedLen);227 return Tls12PackMsg(ctx, type, buf, bufLen, usedLen);
223#endif /* HITLS_TLS_PROTO_TLS_BASIC */228#endif /* HITLS_TLS_PROTO_TLS_BASIC */
Mtls/handshake/pack/src/pack_certificate_request.c+1-1
@@ -136,7 +136,7 @@ int32_t PackCertificateRequest(const TLS_Ctx *ctx, uint8_t *buf, uint32_t bufLen
136 136 
137#if defined(HITLS_TLS_PROTO_TLS12) || defined(HITLS_TLS_PROTO_DTLS12)137#if defined(HITLS_TLS_PROTO_TLS12) || defined(HITLS_TLS_PROTO_DTLS12)
138 /* TLCP does not have the signature algorithm field */138 /* TLCP does not have the signature algorithm field */
139- if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP11) {139+ if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP_DTLCP11) {
140 len = 0u;140 len = 0u;
141 ret = PackSignAlgorithms(ctx, &buf[offset], bufLen - offset, &len);141 ret = PackSignAlgorithms(ctx, &buf[offset], bufLen - offset, &len);
142 if (ret != HITLS_SUCCESS) {142 if (ret != HITLS_SUCCESS) {
Mtls/handshake/pack/src/pack_certificate_verify.c+1-1
@@ -43,7 +43,7 @@ int32_t PackCertificateVerify(const TLS_Ctx *ctx, uint8_t *buf, uint32_t bufLen,
43 }43 }
44#if defined(HITLS_TLS_PROTO_TLS12) || defined(HITLS_TLS_PROTO_DTLS12) || defined(HITLS_TLS_PROTO_TLS13)44#if defined(HITLS_TLS_PROTO_TLS12) || defined(HITLS_TLS_PROTO_DTLS12) || defined(HITLS_TLS_PROTO_TLS13)
45 45 
46- if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP11) {46+ if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP_DTLCP11) {
47 BSL_Uint16ToByte((uint16_t)ctx->negotiatedInfo.signScheme, &buf[offset]);47 BSL_Uint16ToByte((uint16_t)ctx->negotiatedInfo.signScheme, &buf[offset]);
48 offset += sizeof(uint16_t);48 offset += sizeof(uint16_t);
49 }49 }
Mtls/handshake/pack/src/pack_client_hello.c+1-2
@@ -229,8 +229,7 @@ static int32_t PackSessionAndCookie(const TLS_Ctx *ctx, uint8_t *buf, uint32_t b
229 229 
230#ifdef HITLS_TLS_PROTO_DTLS12230#ifdef HITLS_TLS_PROTO_DTLS12
231 const TLS_Config *tlsConfig = &ctx->config.tlsConfig;231 const TLS_Config *tlsConfig = &ctx->config.tlsConfig;
232- uint16_t version = (tlsConfig->maxVersion == HITLS_VERSION_TLS13) ? HITLS_VERSION_TLS12 : tlsConfig->maxVersion;232+ if (IS_SUPPORT_DATAGRAM(tlsConfig->originVersionMask)) {
233- if (IS_DTLS_VERSION(version)) {
234 len = 0u;233 len = 0u;
235 ret = PackClientCookie(ctx->negotiatedInfo.cookie, (uint8_t)ctx->negotiatedInfo.cookieSize,234 ret = PackClientCookie(ctx->negotiatedInfo.cookie, (uint8_t)ctx->negotiatedInfo.cookieSize,
236 &buf[offset], bufLen - offset, &len);235 &buf[offset], bufLen - offset, &len);
Mtls/handshake/pack/src/pack_client_key_exchange.c+1-1
@@ -54,7 +54,7 @@ static int32_t PackClientKxMsgNamedCurve(const TLS_Ctx *ctx, uint8_t *buf, uint3
54 }54 }
55#ifdef HITLS_TLS_PROTO_TLCP1155#ifdef HITLS_TLS_PROTO_TLCP11
56 if (ctx->negotiatedInfo.version ==56 if (ctx->negotiatedInfo.version ==
57- HITLS_VERSION_TLCP11) { /* Compatible with OpenSSL. Three bytes are added to the client key exchange. */57+ HITLS_VERSION_TLCP_DTLCP11) { /* Compatible with OpenSSL. Three bytes are added to the client key exchange. */
58 if (bufLen < (sizeof(uint8_t) + pubKeyLen + sizeof(uint8_t) + sizeof(uint16_t))) {58 if (bufLen < (sizeof(uint8_t) + pubKeyLen + sizeof(uint8_t) + sizeof(uint16_t))) {
59 return PackBufLenError(BINLOG_ID16216, BINGLOG_STR("ClientKx"));59 return PackBufLenError(BINLOG_ID16216, BINGLOG_STR("ClientKx"));
60 }60 }
Mtls/handshake/pack/src/pack_extensions.c+4-4
@@ -73,10 +73,10 @@ static bool IsNeedPreSharedKey(const TLS_Ctx *ctx)
73 return true;73 return true;
74}74}
75 75 
76-bool Tls13NeedPack(uint32_t version)76+bool Tls13NeedPack(const TLS_Ctx *ctx, uint32_t version)
77{77{
78 bool tls13NeedPack = false;78 bool tls13NeedPack = false;
79- if (IS_DTLS_VERSION(version)) {79+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
80 tls13NeedPack = false;80 tls13NeedPack = false;
81 } else {81 } else {
82 tls13NeedPack = (version >= HITLS_VERSION_TLS13) ? true : false;82 tls13NeedPack = (version >= HITLS_VERSION_TLS13) ? true : false;
@@ -786,7 +786,7 @@ static int32_t PackExtensions(const TLS_Ctx *ctx, uint8_t *buf, uint32_t *bufLen
786 786 
787static bool IsNeedEms(const TLS_Ctx *ctx)787static bool IsNeedEms(const TLS_Ctx *ctx)
788{788{
789- if (ctx->config.tlsConfig.maxVersion == HITLS_VERSION_TLCP11) {789+ if (ctx->config.tlsConfig.maxVersion == HITLS_VERSION_TLCP_DTLCP11) {
790 return false;790 return false;
791 }791 }
792 return true;792 return true;
@@ -1169,7 +1169,7 @@ static int32_t PackServerExtensions(const TLS_Ctx *ctx, uint8_t *buf, uint32_t b
1169#ifdef HITLS_TLS_PROTO_TLS131169#ifdef HITLS_TLS_PROTO_TLS13
1170 uint32_t version = HS_GetVersion(ctx);1170 uint32_t version = HS_GetVersion(ctx);
1171 bool isHrrKeyshare = IsHrrKeyShare(ctx);1171 bool isHrrKeyshare = IsHrrKeyShare(ctx);
1172- bool isTls13 = Tls13NeedPack(version);1172+ bool isTls13 = Tls13NeedPack(ctx, version);
1173#endif /* HITLS_TLS_PROTO_TLS13 */1173#endif /* HITLS_TLS_PROTO_TLS13 */
1174 const TLS_NegotiatedInfo *negoInfo = &ctx->negotiatedInfo;1174 const TLS_NegotiatedInfo *negoInfo = &ctx->negotiatedInfo;
1175 (void)negoInfo;1175 (void)negoInfo;
Mtls/handshake/pack/src/pack_server_key_exchange.c+1-1
@@ -68,7 +68,7 @@ static int32_t SignKeyExchParams(TLS_Ctx *ctx, uint8_t *kxData, uint32_t kxDataL
68 return HITLS_MEMALLOC_FAIL;68 return HITLS_MEMALLOC_FAIL;
69 }69 }
70#ifdef HITLS_TLS_PROTO_TLCP1170#ifdef HITLS_TLS_PROTO_TLCP11
71- if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP11)71+ if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP_DTLCP11)
72#endif /* HITLS_TLS_PROTO_TLCP11 */72#endif /* HITLS_TLS_PROTO_TLCP11 */
73 {73 {
74 if (ctx->negotiatedInfo.version >= HITLS_VERSION_TLS12) {74 if (ctx->negotiatedInfo.version >= HITLS_VERSION_TLS12) {
Mtls/handshake/parse/src/parse.c+13-3
@@ -161,7 +161,7 @@ static int32_t CheckHsMsgLen(TLS_Ctx *ctx, HS_MsgInfo *hsMsgInfo)
161 return ParseErrorProcess(ctx, HITLS_PARSE_EXCESSIVE_MESSAGE_SIZE, 0,161 return ParseErrorProcess(ctx, HITLS_PARSE_EXCESSIVE_MESSAGE_SIZE, 0,
162 NULL, ALERT_ILLEGAL_PARAMETER);162 NULL, ALERT_ILLEGAL_PARAMETER);
163 }163 }
164- uint32_t headerLen = IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion) ?164+ uint32_t headerLen = IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask) ?
165 DTLS_HS_MSG_HEADER_SIZE : HS_MSG_HEADER_SIZE;165 DTLS_HS_MSG_HEADER_SIZE : HS_MSG_HEADER_SIZE;
166 ret = HS_GrowMsgBuf(ctx, headerLen + hsMsgInfo->length, true);166 ret = HS_GrowMsgBuf(ctx, headerLen + hsMsgInfo->length, true);
167 if (ret != HITLS_SUCCESS) {167 if (ret != HITLS_SUCCESS) {
@@ -337,7 +337,12 @@ int32_t HS_ParseMsgHeader(TLS_Ctx *ctx, const uint8_t *data, uint32_t len, HS_Ms
337 case HITLS_VERSION_TLS12:337 case HITLS_VERSION_TLS12:
338 case HITLS_VERSION_TLS13:338 case HITLS_VERSION_TLS13:
339#ifdef HITLS_TLS_PROTO_TLCP11339#ifdef HITLS_TLS_PROTO_TLCP11
340- case HITLS_VERSION_TLCP11:340+ case HITLS_VERSION_TLCP_DTLCP11:
341+#if defined(HITLS_TLS_PROTO_DTLCP11)
342+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
343+ return DtlsParseHsMsgHeader(ctx, data, len, hsMsgInfo);
344+ }
345+#endif
341#endif346#endif
342 return TlsParseHsMsgHeader(ctx, data, len, hsMsgInfo);347 return TlsParseHsMsgHeader(ctx, data, len, hsMsgInfo);
343#endif /* HITLS_TLS_PROTO_TLS */348#endif /* HITLS_TLS_PROTO_TLS */
@@ -376,7 +381,12 @@ int32_t HS_ParseMsg(TLS_Ctx *ctx, const HS_MsgInfo *hsMsgInfo, HS_Msg *hsMsg)
376#ifdef HITLS_TLS_PROTO_TLS_BASIC381#ifdef HITLS_TLS_PROTO_TLS_BASIC
377 case HITLS_VERSION_TLS12:382 case HITLS_VERSION_TLS12:
378#ifdef HITLS_TLS_PROTO_TLCP11383#ifdef HITLS_TLS_PROTO_TLCP11
379- case HITLS_VERSION_TLCP11:384+ case HITLS_VERSION_TLCP_DTLCP11:
385+#if defined(HITLS_TLS_PROTO_DTLCP11)
386+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
387+ return ParseHandShakeMsg(ctx, &hsMsgInfo->rawMsg[DTLS_HS_MSG_HEADER_SIZE], hsMsgInfo->length, hsMsg);
388+ }
389+#endif
380#endif390#endif
381 return ParseHandShakeMsg(ctx, &hsMsgInfo->rawMsg[HS_MSG_HEADER_SIZE], hsMsgInfo->length, hsMsg);391 return ParseHandShakeMsg(ctx, &hsMsgInfo->rawMsg[HS_MSG_HEADER_SIZE], hsMsgInfo->length, hsMsg);
382#endif /* HITLS_TLS_PROTO_TLS_BASIC */392#endif /* HITLS_TLS_PROTO_TLS_BASIC */
Mtls/handshake/parse/src/parse_client_hello.c+1-1
@@ -216,7 +216,7 @@ int32_t ParseClientHello(TLS_Ctx *ctx, const uint8_t *data, uint32_t len, HS_Msg
216 }216 }
217 217 
218#ifdef HITLS_TLS_PROTO_DTLS12218#ifdef HITLS_TLS_PROTO_DTLS12
219- if (IS_DTLS_VERSION(HS_GetVersion(ctx))) {219+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
220 /* Cookies need to be parsed in DTLS */220 /* Cookies need to be parsed in DTLS */
221 ret = ParseCookie(&pkt, &msg->cookieLen, &msg->cookie);221 ret = ParseCookie(&pkt, &msg->cookieLen, &msg->cookie);
222 if (ret != HITLS_SUCCESS) {222 if (ret != HITLS_SUCCESS) {
Mtls/handshake/parse/src/parse_client_key_exchange.c+1-1
@@ -48,7 +48,7 @@ static int32_t ParseClientKxMsgEcdhe(ParsePacket *pkt, ClientKeyExchangeMsg *msg
48 48 
49 /* Compatible with OpenSSL, add 3 bytes to the client key exchange */49 /* Compatible with OpenSSL, add 3 bytes to the client key exchange */
50#ifdef HITLS_TLS_PROTO_TLCP1150#ifdef HITLS_TLS_PROTO_TLCP11
51- if (pkt->ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11) {51+ if (pkt->ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
52 // Curve type + Curve ID + Public key length52 // Curve type + Curve ID + Public key length
53 uint8_t minLen = sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint8_t);53 uint8_t minLen = sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint8_t);
54 if (pkt->bufLen - *pkt->bufOffset < minLen) {54 if (pkt->bufLen - *pkt->bufOffset < minLen) {
Mtls/handshake/parse/src/parse_server_key_exchange.c+2-2
@@ -181,7 +181,7 @@ static int32_t ParseEcdhePublicKey(ParsePacket *pkt, ServerEcdh *ecdh)
181 }181 }
182 182 
183#ifdef HITLS_TLS_PROTO_TLCP11183#ifdef HITLS_TLS_PROTO_TLCP11
184- if (pkt->ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11) {184+ if (pkt->ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
185 ecdh->ecPara.param.namedcurve = HITLS_EC_GROUP_SM2;185 ecdh->ecPara.param.namedcurve = HITLS_EC_GROUP_SM2;
186 }186 }
187#endif /* HITLS_TLS_PROTO_TLCP11 */187#endif /* HITLS_TLS_PROTO_TLCP11 */
@@ -279,7 +279,7 @@ static int32_t ParseServerEcdhe(ParsePacket *pkt, ServerKeyExchangeMsg *msg)
279 uint32_t keyExDataLen = *pkt->bufOffset;279 uint32_t keyExDataLen = *pkt->bufOffset;
280 uint16_t signAlgorithm = ctx->negotiatedInfo.cipherSuiteInfo.signScheme;280 uint16_t signAlgorithm = ctx->negotiatedInfo.cipherSuiteInfo.signScheme;
281 281 
282- if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP11) {282+ if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP_DTLCP11) {
283 ret = ParseSignAlgorithm(pkt, &signAlgorithm);283 ret = ParseSignAlgorithm(pkt, &signAlgorithm);
284 if (ret != HITLS_SUCCESS) {284 if (ret != HITLS_SUCCESS) {
285 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17015, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,285 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17015, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
Mtls/handshake/recv/src/hs_state_recv.c+10-4
@@ -85,7 +85,7 @@ static int32_t ProcessHandshakeMsg(TLS_Ctx *ctx, HS_Msg *hsMsg)
85#ifdef HITLS_TLS_HOST_SERVER85#ifdef HITLS_TLS_HOST_SERVER
86 case TRY_RECV_CLIENT_HELLO:86 case TRY_RECV_CLIENT_HELLO:
87#ifdef HITLS_TLS_PROTO_DTLS1287#ifdef HITLS_TLS_PROTO_DTLS12
88- if (version == HITLS_VERSION_DTLS12) {88+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
89 return DtlsServerRecvClientHelloProcess(ctx, hsMsg);89 return DtlsServerRecvClientHelloProcess(ctx, hsMsg);
90 }90 }
91#endif /* HITLS_TLS_PROTO_DTLS12 */91#endif /* HITLS_TLS_PROTO_DTLS12 */
@@ -121,7 +121,7 @@ static int32_t ProcessHandshakeMsg(TLS_Ctx *ctx, HS_Msg *hsMsg)
121#ifdef HITLS_TLS_HOST_CLIENT121#ifdef HITLS_TLS_HOST_CLIENT
122 if (ctx->isClient) {122 if (ctx->isClient) {
123#ifdef HITLS_TLS_PROTO_DTLS12123#ifdef HITLS_TLS_PROTO_DTLS12
124- if (version == HITLS_VERSION_DTLS12) {124+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
125 return DtlsClientRecvFinishedProcess(ctx, hsMsg);125 return DtlsClientRecvFinishedProcess(ctx, hsMsg);
126 }126 }
127#endif /* HITLS_TLS_PROTO_DTLS12 */127#endif /* HITLS_TLS_PROTO_DTLS12 */
@@ -132,7 +132,7 @@ static int32_t ProcessHandshakeMsg(TLS_Ctx *ctx, HS_Msg *hsMsg)
132#endif /* HITLS_TLS_HOST_CLIENT */132#endif /* HITLS_TLS_HOST_CLIENT */
133#ifdef HITLS_TLS_HOST_SERVER133#ifdef HITLS_TLS_HOST_SERVER
134#ifdef HITLS_TLS_PROTO_DTLS12134#ifdef HITLS_TLS_PROTO_DTLS12
135- if (version == HITLS_VERSION_DTLS12) {135+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
136 return DtlsServerRecvFinishedProcess(ctx, hsMsg);136 return DtlsServerRecvFinishedProcess(ctx, hsMsg);
137 }137 }
138#endif /* HITLS_TLS_PROTO_DTLS12 */138#endif /* HITLS_TLS_PROTO_DTLS12 */
@@ -542,7 +542,13 @@ int32_t HS_RecvMsgProcess(TLS_Ctx *ctx)
542#ifdef HITLS_TLS_PROTO_TLS542#ifdef HITLS_TLS_PROTO_TLS
543 case HITLS_VERSION_TLS12:543 case HITLS_VERSION_TLS12:
544#ifdef HITLS_TLS_PROTO_TLCP11544#ifdef HITLS_TLS_PROTO_TLCP11
545- case HITLS_VERSION_TLCP11:545+ case HITLS_VERSION_TLCP_DTLCP11:
546+#if defined(HITLS_TLS_PROTO_DTLS12)
547+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
548+ ret = DtlsTryRecvHandShakeMsg(ctx);
549+ break;
550+ }
551+#endif
546#endif /* HITLS_TLS_PROTO_TLCP11 */552#endif /* HITLS_TLS_PROTO_TLCP11 */
547#ifdef HITLS_TLS_PROTO_TLS_BASIC553#ifdef HITLS_TLS_PROTO_TLS_BASIC
548 ret = Tls12TryRecvHandShakeMsg(ctx);554 ret = Tls12TryRecvHandShakeMsg(ctx);
Mtls/handshake/recv/src/recv_certificate.c+4-4
@@ -131,7 +131,7 @@ static int32_t ClientCheckCert(TLS_Ctx *ctx, CERT_Pair *peerCert)
131#ifdef HITLS_TLS_PROTO_TLCP11131#ifdef HITLS_TLS_PROTO_TLCP11
132 /* The encryption certificate is required for TLS of TLCP. Both ECDHE and ECC of the client depend on the encryption132 /* The encryption certificate is required for TLS of TLCP. Both ECDHE and ECC of the client depend on the encryption
133 * certificate. */133 * certificate. */
134- if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11) {134+ if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
135 HITLS_CERT_Key *cert = SAL_CERT_GetTlcpEncCert(peerCert);135 HITLS_CERT_Key *cert = SAL_CERT_GetTlcpEncCert(peerCert);
136 if (cert == NULL) {136 if (cert == NULL) {
137 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16225, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,137 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16225, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
@@ -163,7 +163,7 @@ static int32_t ServerCheckCert(TLS_Ctx *ctx, CERT_Pair *peerCert)
163 }163 }
164#ifdef HITLS_TLS_PROTO_TLCP11164#ifdef HITLS_TLS_PROTO_TLCP11
165 /* Service processing logic. The ECDHE exchange algorithm logic requires the encryption certificate */165 /* Service processing logic. The ECDHE exchange algorithm logic requires the encryption certificate */
166- if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11 &&166+ if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11 &&
167 ctx->negotiatedInfo.cipherSuiteInfo.kxAlg == HITLS_KEY_EXCH_ECDHE) {167 ctx->negotiatedInfo.cipherSuiteInfo.kxAlg == HITLS_KEY_EXCH_ECDHE) {
168 HITLS_CERT_Key *cert = SAL_CERT_GetTlcpEncCert(peerCert);168 HITLS_CERT_Key *cert = SAL_CERT_GetTlcpEncCert(peerCert);
169 if (cert == NULL) {169 if (cert == NULL) {
@@ -209,7 +209,7 @@ static bool CheckCertKeyUsage(TLS_Ctx *ctx, CERT_Pair *peerCert)
209 case HITLS_KEY_EXCH_ECC:209 case HITLS_KEY_EXCH_ECC:
210 case HITLS_KEY_EXCH_RSA_PSK:210 case HITLS_KEY_EXCH_RSA_PSK:
211#ifdef HITLS_TLS_PROTO_TLCP11211#ifdef HITLS_TLS_PROTO_TLCP11
212- if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11) {212+ if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
213 checkUsageRec = SAL_CERT_CheckCertKeyUsage(ctx, cert, CERT_KEY_CTRL_IS_DIGITAL_SIGN_USAGE) &&213 checkUsageRec = SAL_CERT_CheckCertKeyUsage(ctx, cert, CERT_KEY_CTRL_IS_DIGITAL_SIGN_USAGE) &&
214 SAL_CERT_CheckCertKeyUsage(ctx, encCert, CERT_KEY_CTRL_IS_KEYENC_USAGE);214 SAL_CERT_CheckCertKeyUsage(ctx, encCert, CERT_KEY_CTRL_IS_KEYENC_USAGE);
215 break;215 break;
@@ -292,7 +292,7 @@ static int32_t VerifyCertChain(TLS_Ctx *ctx)
292 return ret;292 return ret;
293 }293 }
294#ifdef HITLS_TLS_PROTO_TLCP11294#ifdef HITLS_TLS_PROTO_TLCP11
295- if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP11) {295+ if (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP_DTLCP11) {
296 return ret;296 return ret;
297 }297 }
298 if (ctx->isClient) {298 if (ctx->isClient) {
Mtls/handshake/recv/src/recv_client_hello.c+11-11
@@ -159,7 +159,7 @@ static int32_t HsServerSelectCert(TLS_Ctx *ctx, const ClientHelloMsg *clientHell
159 159 
160 /* For TLCP1.1, ignore the signature extension of client hello */160 /* For TLCP1.1, ignore the signature extension of client hello */
161 if (clientHello->extension.content.signatureAlgorithms != NULL &&161 if (clientHello->extension.content.signatureAlgorithms != NULL &&
162- (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP11)) {162+ (ctx->negotiatedInfo.version != HITLS_VERSION_TLCP_DTLCP11)) {
163 expectCertInfo.signSchemeList = clientHello->extension.content.signatureAlgorithms;163 expectCertInfo.signSchemeList = clientHello->extension.content.signatureAlgorithms;
164 expectCertInfo.signSchemeNum = clientHello->extension.content.signatureAlgorithmsSize;164 expectCertInfo.signSchemeNum = clientHello->extension.content.signatureAlgorithmsSize;
165 } else {165 } else {
@@ -209,7 +209,7 @@ static int32_t ProcessEcdheCipherSuite(TLS_Ctx *ctx, const ClientHelloMsg *clien
209 return HITLS_MSG_HANDLE_UNSUPPORT_CIPHER_SUITE;209 return HITLS_MSG_HANDLE_UNSUPPORT_CIPHER_SUITE;
210 }210 }
211#ifdef HITLS_TLS_PROTO_TLCP11211#ifdef HITLS_TLS_PROTO_TLCP11
212- if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11) {212+ if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
213 if (CheckLocalContainCurveType(ctx->config.tlsConfig.groups,213 if (CheckLocalContainCurveType(ctx->config.tlsConfig.groups,
214 ctx->config.tlsConfig.groupsSize, HITLS_EC_GROUP_SM2) != true) {214 ctx->config.tlsConfig.groupsSize, HITLS_EC_GROUP_SM2) != true) {
215 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16231, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,215 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16231, BSL_LOG_LEVEL_INFO, BSL_LOG_BINLOG_TYPE_RUN,
@@ -436,11 +436,11 @@ int32_t ServerSelectCipherSuite(TLS_Ctx *ctx, const ClientHelloMsg *clientHello)
436static int32_t ServerSelectNegoVersion(TLS_Ctx *ctx, const ClientHelloMsg *clientHello)436static int32_t ServerSelectNegoVersion(TLS_Ctx *ctx, const ClientHelloMsg *clientHello)
437{437{
438 uint16_t legacyVersion = clientHello->version;438 uint16_t legacyVersion = clientHello->version;
439- if (legacyVersion > HITLS_VERSION_TLS13 && !IS_DTLS_VERSION(HS_GetVersion(ctx))) {439+ if (legacyVersion > HITLS_VERSION_TLS13 && !IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
440 legacyVersion = HITLS_VERSION_TLS12;440 legacyVersion = HITLS_VERSION_TLS12;
441 }441 }
442 /* Check whether DTLS is used */442 /* Check whether DTLS is used */
443- if (IS_DTLS_VERSION(legacyVersion)) {443+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
444 if (legacyVersion > ctx->config.tlsConfig.minVersion) {444 if (legacyVersion > ctx->config.tlsConfig.minVersion) {
445 /** The DTLS version supported by the client is too early and the negotiation cannot be continued */445 /** The DTLS version supported by the client is too early and the negotiation cannot be continued */
446 BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_VERSION);446 BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
@@ -734,7 +734,7 @@ static int32_t DealResumeServerName(TLS_Ctx *ctx, const ClientHelloMsg *clientHe
734 734 
735static int32_t ServerCheckResumeSni(TLS_Ctx *ctx, const ClientHelloMsg *clientHello, HITLS_Session **sess)735static int32_t ServerCheckResumeSni(TLS_Ctx *ctx, const ClientHelloMsg *clientHello, HITLS_Session **sess)
736{736{
737- if (*sess == NULL || ctx->config.tlsConfig.maxVersion == HITLS_VERSION_TLCP11) {737+ if (*sess == NULL || ctx->config.tlsConfig.maxVersion == HITLS_VERSION_TLCP_DTLCP11) {
738 return HITLS_SUCCESS;738 return HITLS_SUCCESS;
739 }739 }
740 int32_t ret = HITLS_SUCCESS;740 int32_t ret = HITLS_SUCCESS;
@@ -825,7 +825,7 @@ offering to resume a known previous session, it behaves as follows:
825*/825*/
826static int32_t ResumeCheckExtendedMasterScret(TLS_Ctx *ctx, const ClientHelloMsg *clientHello, HITLS_Session **sess)826static int32_t ResumeCheckExtendedMasterScret(TLS_Ctx *ctx, const ClientHelloMsg *clientHello, HITLS_Session **sess)
827{827{
828- if (*sess == NULL || ctx->config.tlsConfig.maxVersion == HITLS_VERSION_TLCP11) {828+ if (*sess == NULL || ctx->config.tlsConfig.maxVersion == HITLS_VERSION_TLCP_DTLCP11) {
829 return HITLS_SUCCESS;829 return HITLS_SUCCESS;
830 }830 }
831 (void)clientHello;831 (void)clientHello;
@@ -1120,7 +1120,7 @@ static int32_t ServerCheckAndProcessClientHello(TLS_Ctx *ctx, const ClientHelloM
1120 }1120 }
1121 /* TLCP does not pay attention to the extension */1121 /* TLCP does not pay attention to the extension */
1122#ifdef HITLS_TLS_PROTO_TLCP111122#ifdef HITLS_TLS_PROTO_TLCP11
1123- if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11) {1123+ if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11) {
1124 return HITLS_SUCCESS;1124 return HITLS_SUCCESS;
1125 }1125 }
1126#endif1126#endif
@@ -1907,13 +1907,13 @@ static int32_t Tls13ServerCheckClientHello(TLS_Ctx *ctx, ClientHelloMsg *clientH
1907 return Tls13ServerSelectCert(ctx, clientHello);1907 return Tls13ServerSelectCert(ctx, clientHello);
1908}1908}
1909 1909 
1910-static int32_t CheckVersion(uint16_t version, uint16_t minVersion, uint16_t maxVersion, uint16_t *selectVersion)1910+static int32_t CheckVersion(TLS_Ctx *ctx, uint16_t version, uint16_t minVersion, uint16_t maxVersion, uint16_t *selectVersion)
1911{1911{
1912- if (version >= HITLS_VERSION_TLS13 && !IS_DTLS_VERSION(maxVersion)) {1912+ if (version >= HITLS_VERSION_TLS13 && !IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
1913 version = HITLS_VERSION_TLS12;1913 version = HITLS_VERSION_TLS12;
1914 }1914 }
1915#ifdef HITLS_TLS_PROTO_TLCP111915#ifdef HITLS_TLS_PROTO_TLCP11
1916- if (((version > HITLS_VERSION_SSL30) || (version == HITLS_VERSION_TLCP11)) &&1916+ if (((version > HITLS_VERSION_SSL30) || (version == HITLS_VERSION_TLCP_DTLCP11)) &&
1917#else1917#else
1918 if ((version > HITLS_VERSION_SSL30) &&1918 if ((version > HITLS_VERSION_SSL30) &&
1919#endif /* HITLS_TLS_PROTO_TLCP11 */1919#endif /* HITLS_TLS_PROTO_TLCP11 */
@@ -1969,7 +1969,7 @@ static int32_t SelectVersion(TLS_Ctx *ctx, const ClientHelloMsg *clientHello, ui
1969 * Then the server must negotiate TLS 1.2 or earlier as specified in rfc5246.1969 * Then the server must negotiate TLS 1.2 or earlier as specified in rfc5246.
1970 */1970 */
1971 if (clientHello->extension.content.supportedVersionsCount == 0) {1971 if (clientHello->extension.content.supportedVersionsCount == 0) {
1972- ret = CheckVersion(version, minVersion, maxVersion, selectVersion);1972+ ret = CheckVersion(ctx, version, minVersion, maxVersion, selectVersion);
1973 if (ret != HITLS_SUCCESS) {1973 if (ret != HITLS_SUCCESS) {
1974 BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_VERSION);1974 BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_VERSION);
1975 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16134, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,1975 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16134, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
Mtls/handshake/recv/src/recv_server_hello.c+1-1
@@ -484,7 +484,7 @@ static int32_t ClientCheckVersion(TLS_Ctx *ctx, const ServerHelloMsg *serverHell
484 uint16_t clientMaxVersion = ctx->config.tlsConfig.maxVersion;484 uint16_t clientMaxVersion = ctx->config.tlsConfig.maxVersion;
485 uint16_t serverVersion = serverHello->version;485 uint16_t serverVersion = serverHello->version;
486 486 
487- if (IS_DTLS_VERSION(serverVersion)) {487+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
488 if ((serverVersion > clientMinVersion) || (serverVersion < clientMaxVersion)) {488 if ((serverVersion > clientMinVersion) || (serverVersion < clientMaxVersion)) {
489 /* The DTLS version selected by the server is too early and the negotiation cannot be continued */489 /* The DTLS version selected by the server is too early and the negotiation cannot be continued */
490 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15267, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,490 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15267, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
Mtls/handshake/send/src/hs_state_send.c+3-6
@@ -67,13 +67,10 @@ static int32_t Tls13SendKeyUpdateProcess(TLS_Ctx *ctx)
67#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)67#if defined(HITLS_TLS_PROTO_TLS_BASIC) || defined(HITLS_TLS_PROTO_DTLS12)
68static int32_t SendFinishedProcess(TLS_Ctx *ctx)68static int32_t SendFinishedProcess(TLS_Ctx *ctx)
69{69{
70-#ifdef HITLS_TLS_PROTO_DTLS12
71- uint32_t version = HS_GetVersion(ctx);
72-#endif
73#ifdef HITLS_TLS_HOST_CLIENT70#ifdef HITLS_TLS_HOST_CLIENT
74 if (ctx->isClient) {71 if (ctx->isClient) {
75#ifdef HITLS_TLS_PROTO_DTLS1272#ifdef HITLS_TLS_PROTO_DTLS12
76- if (version == HITLS_VERSION_DTLS12) {73+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
77 return DtlsClientSendFinishedProcess(ctx);74 return DtlsClientSendFinishedProcess(ctx);
78 }75 }
79#endif76#endif
@@ -84,7 +81,7 @@ static int32_t SendFinishedProcess(TLS_Ctx *ctx)
84#endif /* HITLS_TLS_HOST_CLIENT */81#endif /* HITLS_TLS_HOST_CLIENT */
85#ifdef HITLS_TLS_HOST_SERVER82#ifdef HITLS_TLS_HOST_SERVER
86#ifdef HITLS_TLS_PROTO_DTLS1283#ifdef HITLS_TLS_PROTO_DTLS12
87- if (version == HITLS_VERSION_DTLS12) {84+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
88 return DtlsServerSendFinishedProcess(ctx);85 return DtlsServerSendFinishedProcess(ctx);
89 }86 }
90#endif87#endif
@@ -212,7 +209,7 @@ int32_t HS_SendMsgProcess(TLS_Ctx *ctx)
212#ifdef HITLS_TLS_PROTO_TLS_BASIC209#ifdef HITLS_TLS_PROTO_TLS_BASIC
213 case HITLS_VERSION_TLS12:210 case HITLS_VERSION_TLS12:
214#ifdef HITLS_TLS_PROTO_TLCP11211#ifdef HITLS_TLS_PROTO_TLCP11
215- case HITLS_VERSION_TLCP11:212+ case HITLS_VERSION_TLCP_DTLCP11:
216#endif213#endif
217 return ProcessSendHandshakeMsg(ctx);214 return ProcessSendHandshakeMsg(ctx);
218#endif /* HITLS_TLS_PROTO_TLS_BASIC */215#endif /* HITLS_TLS_PROTO_TLS_BASIC */
Mtls/handshake/send/src/send_client_hello.c+1-1
@@ -90,7 +90,7 @@ static int32_t ClientPrepareSession(TLS_Ctx *ctx)
90static int32_t ClientChangeStateAfterSendClientHello(TLS_Ctx *ctx)90static int32_t ClientChangeStateAfterSendClientHello(TLS_Ctx *ctx)
91{91{
92#ifdef HITLS_TLS_FEATURE_SESSION92#ifdef HITLS_TLS_FEATURE_SESSION
93- if (ctx->session != NULL && IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion)) {93+ if (ctx->session != NULL && IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
94 /* In the DTLS scenario, enable the receiving of CCS messages to prevent CCS message disorder during session94 /* In the DTLS scenario, enable the receiving of CCS messages to prevent CCS message disorder during session
95 * resumption */95 * resumption */
96 ctx->method.ctrlCCS(ctx, CCS_CMD_RECV_READY);96 ctx->method.ctrlCCS(ctx, CCS_CMD_RECV_READY);
Mtls/handshake/send/src/send_common.c+6-1
@@ -179,7 +179,12 @@ int32_t HS_SendMsg(TLS_Ctx *ctx)
179 case HITLS_VERSION_TLS12:179 case HITLS_VERSION_TLS12:
180 case HITLS_VERSION_TLS13:180 case HITLS_VERSION_TLS13:
181#ifdef HITLS_TLS_PROTO_TLCP11181#ifdef HITLS_TLS_PROTO_TLCP11
182- case HITLS_VERSION_TLCP11:182+ case HITLS_VERSION_TLCP_DTLCP11:
183+#if defined(HITLS_TLS_PROTO_DTLCP11)
184+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
185+ return DtlsSendHandShakeMsg(ctx);
186+ }
187+#endif
183#endif188#endif
184 return TlsSendHandShakeMsg(ctx);189 return TlsSendHandShakeMsg(ctx);
185#endif /* HITLS_TLS_PROTO_TLS */190#endif /* HITLS_TLS_PROTO_TLS */
Mtls/handshake/send/src/send_server_key_exchange.c+1-1
@@ -271,7 +271,7 @@ int32_t ServerSendServerKeyExchangeProcess(TLS_Ctx *ctx)
271 /* Make sure the client will always send a certificate message, because ECDHE relies on the client's encrypted271 /* Make sure the client will always send a certificate message, because ECDHE relies on the client's encrypted
272 * certificate, even if the client does not require authentication (isSupportClientVerify equals false). */272 * certificate, even if the client does not require authentication (isSupportClientVerify equals false). */
273#ifdef HITLS_TLS_PROTO_TLCP11273#ifdef HITLS_TLS_PROTO_TLCP11
274- if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP11 &&274+ if (ctx->negotiatedInfo.version == HITLS_VERSION_TLCP_DTLCP11 &&
275 ctx->negotiatedInfo.cipherSuiteInfo.cipherSuite == HITLS_ECDHE_SM4_CBC_SM3) {275 ctx->negotiatedInfo.cipherSuiteInfo.cipherSuite == HITLS_ECDHE_SM4_CBC_SM3) {
276 return HS_ChangeState(ctx, TRY_SEND_CERTIFICATE_REQUEST);276 return HS_ChangeState(ctx, TRY_SEND_CERTIFICATE_REQUEST);
277 }277 }
Mtls/include/tls.h+4-0
@@ -40,6 +40,10 @@ extern "C" {
40 40 
41#define IS_DTLS_VERSION(version) (((version) & 0x8u) == 0x8u)41#define IS_DTLS_VERSION(version) (((version) & 0x8u) == 0x8u)
42 42 
43+#define IS_SUPPORT_STREAM(versionBits) (((versionBits) & STREAM_VERSION_BITS) != 0x0u)
44+#define IS_SUPPORT_DATAGRAM(versionBits) (((versionBits) & DATAGRAM_VERSION_BITS) != 0x0u)
45+#define IS_SUPPORT_TLCP(versionBits) (((versionBits) & TLCP_VERSION_BITS) != 0x0u)
46+ 
43#define DTLS_COOKIE_LEN 25547#define DTLS_COOKIE_LEN 255
44 48 
45#define MAC_KEY_LEN 32u /* the length of mac key */49#define MAC_KEY_LEN 32u /* the length of mac key */
Mtls/record/src/rec_alert.c+1-1
@@ -37,7 +37,7 @@ int32_t RecordSendAlertMsg(TLS_Ctx *ctx, ALERT_Level level, ALERT_Description de
37{37{
38 /* RFC6347 4.1.2.7. Handling Invalid Records:38 /* RFC6347 4.1.2.7. Handling Invalid Records:
39 We choose to discard invalid dtls record message and do not generate alerts. */39 We choose to discard invalid dtls record message and do not generate alerts. */
40- if (IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion)) {40+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
41 return HITLS_REC_NORMAL_RECV_BUF_EMPTY;41 return HITLS_REC_NORMAL_RECV_BUF_EMPTY;
42 } else {42 } else {
43 ctx->method.sendAlert(ctx, level, description);43 ctx->method.sendAlert(ctx, level, description);
Mtls/record/src/rec_read.c+6-5
@@ -49,7 +49,7 @@ static bool IsNeedtoRead(const TLS_Ctx *ctx, const RecBuf *inBuf)
49 (void)ctx;49 (void)ctx;
50 uint32_t headLen = REC_TLS_RECORD_HEADER_LEN;50 uint32_t headLen = REC_TLS_RECORD_HEADER_LEN;
51#ifdef HITLS_TLS_PROTO_DTLS1251#ifdef HITLS_TLS_PROTO_DTLS12
52- if (IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion)) {52+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
53 headLen = REC_DTLS_RECORD_HEADER_LEN;53 headLen = REC_DTLS_RECORD_HEADER_LEN;
54 }54 }
55#endif55#endif
@@ -126,7 +126,7 @@ static int32_t ProcessDecryptedRecord(TLS_Ctx *ctx, uint32_t dataLen,
126 return RecordSendAlertMsg(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);126 return RecordSendAlertMsg(ctx, ALERT_LEVEL_FATAL, ALERT_UNEXPECTED_MESSAGE);
127 }127 }
128 128 
129- if (!IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion) &&129+ if (!IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask) &&
130 ctx->negotiatedInfo.version != HITLS_VERSION_TLS13 &&130 ctx->negotiatedInfo.version != HITLS_VERSION_TLS13 &&
131 ctx->method.isRecvCCS(ctx) &&131 ctx->method.isRecvCCS(ctx) &&
132 encryptedMsg->type != REC_TYPE_HANDSHAKE) {132 encryptedMsg->type != REC_TYPE_HANDSHAKE) {
@@ -192,7 +192,7 @@ static int32_t RecordDecrypt(TLS_Ctx *ctx, RecBuf *decryptBuf, REC_TextInput *en
192 if (ret != HITLS_SUCCESS) {192 if (ret != HITLS_SUCCESS) {
193 goto ERR;193 goto ERR;
194 }194 }
195- if (!IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion)) {195+ if (!IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
196 ret = funcs->decryptPostProcess(ctx, state->suiteInfo, encryptedMsg, decryptBuf->buf, &decryptBuf->end);196 ret = funcs->decryptPostProcess(ctx, state->suiteInfo, encryptedMsg, decryptBuf->buf, &decryptBuf->end);
197 if (ret != HITLS_SUCCESS) {197 if (ret != HITLS_SUCCESS) {
198 goto ERR;198 goto ERR;
@@ -255,7 +255,8 @@ int32_t DtlsCheckVersionField(const TLS_Ctx *ctx, uint16_t version, uint8_t type
255 /* Tolerate alerts with non-negotiated version. For example, after the server sends server hello, the client255 /* Tolerate alerts with non-negotiated version. For example, after the server sends server hello, the client
256 * replies with an earlier version alert */256 * replies with an earlier version alert */
257 if (ctx->negotiatedInfo.version == 0u || type == (uint8_t)REC_TYPE_ALERT) {257 if (ctx->negotiatedInfo.version == 0u || type == (uint8_t)REC_TYPE_ALERT) {
258- if ((version != HITLS_VERSION_DTLS10) && (version != HITLS_VERSION_DTLS12)) {258+ if ((version != HITLS_VERSION_DTLS10) && (version != HITLS_VERSION_DTLS12) &&
259+ (version != HITLS_VERSION_TLCP_DTLCP11)) {
259 BSL_ERR_PUSH_ERROR(HITLS_REC_INVALID_PROTOCOL_VERSION);260 BSL_ERR_PUSH_ERROR(HITLS_REC_INVALID_PROTOCOL_VERSION);
260 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15436, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,261 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID15436, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
261 "get a record with illegal version(0x%x).", version, 0, 0, 0);262 "get a record with illegal version(0x%x).", version, 0, 0, 0);
@@ -683,7 +684,7 @@ int32_t TlsCheckVersionField(TLS_Ctx *ctx, uint16_t version, uint8_t type)
683{684{
684 if (ctx->negotiatedInfo.version == 0u) {685 if (ctx->negotiatedInfo.version == 0u) {
685#ifdef HITLS_TLS_PROTO_TLCP11686#ifdef HITLS_TLS_PROTO_TLCP11
686- if (((version >> 8u) != HITLS_VERSION_TLS_MAJOR) && (version != HITLS_VERSION_TLCP11)) {687+ if (((version >> 8u) != HITLS_VERSION_TLS_MAJOR) && (version != HITLS_VERSION_TLCP_DTLCP11)) {
687#else688#else
688 if ((version >> 8u) != HITLS_VERSION_TLS_MAJOR) {689 if ((version >> 8u) != HITLS_VERSION_TLS_MAJOR) {
689#endif690#endif
Mtls/record/src/rec_write.c+1-1
@@ -302,7 +302,7 @@ static void TlsPlainMsgGenerate(REC_TextInput *plainMsg, const TLS_Ctx *ctx,
302 ctx->hsCtx->haveHrr == false &&302 ctx->hsCtx->haveHrr == false &&
303#endif303#endif
304#ifdef HITLS_TLS_PROTO_TLCP11304#ifdef HITLS_TLS_PROTO_TLCP11
305- ctx->config.tlsConfig.maxVersion != HITLS_VERSION_TLCP11 &&305+ ctx->config.tlsConfig.maxVersion != HITLS_VERSION_TLCP_DTLCP11 &&
306#endif306#endif
307 ctx->config.tlsConfig.maxVersion > HITLS_VERSION_TLS10) {307 ctx->config.tlsConfig.maxVersion > HITLS_VERSION_TLS10) {
308 plainMsg->version = HITLS_VERSION_TLS10;308 plainMsg->version = HITLS_VERSION_TLS10;
Mtls/record/src/record.c+5-5
@@ -55,13 +55,13 @@ static uint32_t RecGetDefaultBufferSize(bool isDtls, bool isRead)
55 55 
56static uint32_t RecGetReadBufferSize(const TLS_Ctx *ctx)56static uint32_t RecGetReadBufferSize(const TLS_Ctx *ctx)
57{57{
58- uint32_t recSize = RecGetDefaultBufferSize(IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion), true);58+ uint32_t recSize = RecGetDefaultBufferSize(IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask), true);
59 return recSize;59 return recSize;
60}60}
61 61 
62static uint32_t RecGetWriteBufferSize(const TLS_Ctx *ctx)62static uint32_t RecGetWriteBufferSize(const TLS_Ctx *ctx)
63{63{
64- uint32_t recSize = RecGetDefaultBufferSize(IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion), false);64+ uint32_t recSize = RecGetDefaultBufferSize(IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask), false);
65 return recSize;65 return recSize;
66}66}
67 67 
@@ -90,7 +90,7 @@ static int32_t InnerRecRead(TLS_Ctx *ctx, REC_Type recordType, uint8_t *data, ui
90#endif90#endif
91 91 
92#ifdef HITLS_TLS_PROTO_DTLS1292#ifdef HITLS_TLS_PROTO_DTLS12
93- if (IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion)) {93+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
94 return DtlsRecordRead(ctx, recordType, data, readLen, num);94 return DtlsRecordRead(ctx, recordType, data, readLen, num);
95 }95 }
96#endif96#endif
@@ -123,7 +123,7 @@ static int32_t InnerRecWrite(TLS_Ctx *ctx, REC_Type recordType, const uint8_t *d
123 }123 }
124 124 
125#ifdef HITLS_TLS_PROTO_DTLS12125#ifdef HITLS_TLS_PROTO_DTLS12
126- if (IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion)) {126+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
127 /* DTLS */127 /* DTLS */
128 return DtlsRecordWrite(ctx, recordType, data, num);128 return DtlsRecordWrite(ctx, recordType, data, num);
129 }129 }
@@ -435,7 +435,7 @@ int32_t REC_ActivePendingState(TLS_Ctx *ctx, bool isOut)
435 RecConnSetSeqNum(states->currentState, 0);435 RecConnSetSeqNum(states->currentState, 0);
436 436 
437#ifdef HITLS_TLS_PROTO_DTLS12437#ifdef HITLS_TLS_PROTO_DTLS12
438- if (IS_DTLS_VERSION(ctx->config.tlsConfig.maxVersion)) {438+ if (IS_SUPPORT_DATAGRAM(ctx->config.tlsConfig.originVersionMask)) {
439 if (isOut) {439 if (isOut) {
440 ++recordCtx->writeEpoch;440 ++recordCtx->writeEpoch;
441 RecConnSetEpoch(states->currentState, recordCtx->writeEpoch);441 RecConnSetEpoch(states->currentState, recordCtx->writeEpoch);