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 #include "hitls_build.h"
16 #if defined(HITLS_TLS_HOST_CLIENT) && defined(HITLS_TLS_PROTO_TLS13)
17 #include "securec.h"
18 #include "tls_binlog_id.h"
19 #include "bsl_log_internal.h"
20 #include "bsl_log.h"
21 #include "bsl_sal.h"
22 #include "bsl_err_internal.h"
23 #include "bsl_bytes.h"
24 #include "hitls_error.h"
25 #include "tls.h"
26 #include "rec.h"
27 #include "hs.h"
28 #include "hs_extensions.h"
29 #include "hs_common.h"
30 #include "parse_extensions.h"
31 #include "parse_common.h"
32 #include "custom_extensions.h"
33
34 /**
35 * @brief Release the memory in the message structure.
36 *
37 * @param msg [IN] message structure
38 */
CleanEncryptedExtensions(EncryptedExtensions * msg)39 void CleanEncryptedExtensions(EncryptedExtensions *msg)
40 {
41 if (msg == NULL) {
42 return;
43 }
44 BSL_SAL_FREE(msg->supportedGroups);
45 #ifdef HITLS_TLS_FEATURE_ALPN
46 BSL_SAL_FREE(msg->alpnSelected);
47 #endif /* HITLS_TLS_FEATURE_ALPN */
48 return;
49 }
50
ParseEncryptedSupportGroups(ParsePacket * pkt,EncryptedExtensions * msg)51 static int32_t ParseEncryptedSupportGroups(ParsePacket *pkt, EncryptedExtensions *msg)
52 {
53 /* Has parsed extensions of the same type */
54 if (msg->haveSupportedGroups == true) {
55 return ParseErrorProcess(pkt->ctx, HITLS_PARSE_DUPLICATE_EXTENDED_MSG, BINLOG_ID15709,
56 BINGLOG_STR("ClientSupportGroups repeated"), ALERT_ILLEGAL_PARAMETER);
57 }
58
59 uint16_t groupLen = 0;
60 const char *logStr = BINGLOG_STR("parse supported groups len fail.");
61 int32_t ret = ParseBytesToUint16(pkt, &groupLen);
62 if (ret != HITLS_SUCCESS) {
63 return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15710, logStr, ALERT_DECODE_ERROR);
64 }
65 groupLen /= sizeof(uint16_t);
66
67 /* If the length of the message does not match the extended length, or the length is 0,
68 the handshake message error is returned */
69 if (((groupLen * sizeof(uint16_t)) != (pkt->bufLen - sizeof(uint16_t))) || (groupLen == 0)) {
70 return ParseErrorProcess(pkt->ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15711, logStr, ALERT_DECODE_ERROR);
71 }
72
73 BSL_SAL_FREE(msg->supportedGroups);
74 msg->supportedGroups = (uint16_t *)BSL_SAL_Malloc(groupLen * sizeof(uint16_t));
75 if (msg->supportedGroups == NULL) {
76 return ParseErrorProcess(pkt->ctx, HITLS_MEMALLOC_FAIL, BINLOG_ID15712,
77 BINGLOG_STR("supportedGroups malloc fail"), ALERT_UNKNOWN);
78 }
79
80 for (uint32_t i = 0; i < groupLen; i++) {
81 msg->supportedGroups[i] = BSL_ByteToUint16(&pkt->buf[*pkt->bufOffset]);
82 *pkt->bufOffset += sizeof(uint16_t);
83 }
84
85 msg->supportedGroupsSize = groupLen;
86 msg->haveSupportedGroups = true;
87
88 return HITLS_SUCCESS;
89 }
90
ParseEncryptedExBody(TLS_Ctx * ctx,uint16_t extMsgType,const uint8_t * buf,uint32_t extMsgLen,EncryptedExtensions * msg)91 static int32_t ParseEncryptedExBody(TLS_Ctx *ctx, uint16_t extMsgType, const uint8_t *buf, uint32_t extMsgLen,
92 EncryptedExtensions *msg)
93 {
94 uint32_t bufOffset = 0u;
95 ParsePacket pkt = {.ctx = ctx, .buf = buf, .bufLen = extMsgLen, .bufOffset = &bufOffset};
96 switch (extMsgType) {
97 case HS_EX_TYPE_SUPPORTED_GROUPS:
98 return ParseEncryptedSupportGroups(&pkt, msg);
99 case HS_EX_TYPE_EARLY_DATA:
100 return ParseEmptyExtension(ctx, HS_EX_TYPE_EARLY_DATA, extMsgLen, &msg->haveEarlyData);
101 case HS_EX_TYPE_SERVER_NAME:
102 return ParseEmptyExtension(ctx, HS_EX_TYPE_SERVER_NAME, extMsgLen, &msg->haveServerName);
103 case HS_EX_TYPE_SIGNATURE_ALGORITHMS:
104 case HS_EX_TYPE_KEY_SHARE:
105 case HS_EX_TYPE_PRE_SHARED_KEY:
106 case HS_EX_TYPE_STATUS_REQUEST:
107 case HS_EX_TYPE_STATUS_REQUEST_V2:
108 case HS_EX_TYPE_PSK_KEY_EXCHANGE_MODES:
109 case HS_EX_TYPE_COOKIE:
110 case HS_EX_TYPE_SUPPORTED_VERSIONS:
111 case HS_EX_TYPE_CERTIFICATE_AUTHORITIES:
112 case HS_EX_TYPE_POST_HS_AUTH:
113 case HS_EX_TYPE_SIGNATURE_ALGORITHMS_CERT:
114 return ParseErrorProcess(ctx, HITLS_PARSE_UNSUPPORTED_EXTENSION, BINLOG_ID16239,
115 BINGLOG_STR("Illegal extension received"), ALERT_ILLEGAL_PARAMETER);
116 #ifdef HITLS_TLS_FEATURE_ALPN
117 case HS_EX_TYPE_APP_LAYER_PROTOCOLS:
118 return ParseServerSelectedAlpnProtocol(
119 &pkt, &msg->haveSelectedAlpn, &msg->alpnSelected, &msg->alpnSelectedSize);
120 #endif /* HITLS_TLS_FEATURE_ALPN */
121 default:
122 break;
123 }
124 #ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
125 if (IsParseNeedCustomExtensions(CUSTOM_EXT_FROM_CTX(ctx), extMsgType, HITLS_EX_TYPE_ENCRYPTED_EXTENSIONS)) {
126 return ParseCustomExtensions(pkt.ctx, pkt.buf + *pkt.bufOffset, extMsgType, extMsgLen,
127 HITLS_EX_TYPE_ENCRYPTED_EXTENSIONS, NULL, 0);
128 }
129 #endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
130 return ParseErrorProcess(ctx, HITLS_PARSE_UNSUPPORTED_EXTENSION, BINLOG_ID16982,
131 "unknow extension received", ALERT_UNSUPPORTED_EXTENSION);
132 }
133
134 // Parse the EncryptedExtensions extension message
ParseEncryptedEx(TLS_Ctx * ctx,EncryptedExtensions * msg,const uint8_t * buf,uint32_t bufLen)135 int32_t ParseEncryptedEx(TLS_Ctx *ctx, EncryptedExtensions *msg, const uint8_t *buf, uint32_t bufLen)
136 {
137 uint32_t bufOffset = 0u;
138 int32_t ret;
139
140 while (bufOffset < bufLen) {
141 uint32_t extMsgLen = 0u;
142 uint16_t extMsgType = HS_EX_TYPE_END;
143 ret = ParseExHeader(ctx, &buf[bufOffset], bufLen - bufOffset, &extMsgType, &extMsgLen);
144 if (ret != HITLS_SUCCESS) {
145 return ret;
146 }
147 bufOffset += HS_EX_HEADER_LEN;
148
149 uint32_t extensionId = HS_GetExtensionTypeId(extMsgType);
150 ret = CheckForDuplicateExtension(msg->extensionTypeMask, extensionId, ctx);
151 if (ret != HITLS_SUCCESS) {
152 return ret;
153 }
154 if (extensionId != HS_EX_TYPE_ID_UNRECOGNIZED
155 #ifdef HITLS_TLS_FEATURE_CUSTOM_EXTENSION
156 || !IsParseNeedCustomExtensions(CUSTOM_EXT_FROM_CTX(ctx), extMsgType, HITLS_EX_TYPE_ENCRYPTED_EXTENSIONS)
157 #endif /* HITLS_TLS_FEATURE_CUSTOM_EXTENSION */
158 ) {
159 msg->extensionTypeMask |= 1ULL << extensionId;
160 /* check whether the extension that is not sent is received. */
161 if (!GetExtensionFlagValue(ctx, extensionId)) {
162 BSL_ERR_PUSH_ERROR(HITLS_MSG_HANDLE_UNSUPPORT_EXTENSION_TYPE);
163 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID17329, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN,
164 "client did not send but get extension type %u.", extensionId, 0, 0, 0);
165 ctx->method.sendAlert(ctx, ALERT_LEVEL_FATAL, ALERT_UNSUPPORTED_EXTENSION);
166 return HITLS_MSG_HANDLE_UNSUPPORT_EXTENSION_TYPE;
167 }
168 }
169
170 ret = ParseEncryptedExBody(ctx, extMsgType, &buf[bufOffset], extMsgLen, msg);
171 if (ret != HITLS_SUCCESS) {
172 return ret;
173 }
174 bufOffset += extMsgLen;
175 }
176
177 if (bufOffset != bufLen) {
178 return ParseErrorProcess(ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16239,
179 BINGLOG_STR("encrypted extensions len incorrect"), ALERT_DECODE_ERROR);
180 }
181
182 return HITLS_SUCCESS;
183 }
184
185 // Parse the EncryptedExtensions message.
ParseEncryptedExtensions(TLS_Ctx * ctx,const uint8_t * buf,uint32_t bufLen,HS_Msg * hsMsg)186 int32_t ParseEncryptedExtensions(TLS_Ctx *ctx, const uint8_t *buf, uint32_t bufLen, HS_Msg *hsMsg)
187 {
188 if ((buf == NULL) || (hsMsg == NULL)) {
189 BSL_LOG_BINLOG_FIXLEN(BINLOG_ID16983, BSL_LOG_LEVEL_ERR, BSL_LOG_BINLOG_TYPE_RUN, "input null", 0, 0, 0, 0);
190 BSL_ERR_PUSH_ERROR(HITLS_NULL_INPUT);
191 return HITLS_NULL_INPUT;
192 }
193
194 /* Parse the EncryptedExtensions extension message */
195 EncryptedExtensions *msg = &hsMsg->body.encryptedExtensions;
196 uint32_t bufOffset = 0u;
197 ParsePacket pkt = {.ctx = ctx, .buf = buf, .bufLen = bufLen, .bufOffset = &bufOffset};
198
199 /* Obtain the extended message length */
200 uint16_t exMsgLen = 0;
201 const char *logStr = BINGLOG_STR("parse encrypted Extensions len fail.");
202 int32_t ret = ParseBytesToUint16(&pkt, &exMsgLen);
203 if (ret != HITLS_SUCCESS) {
204 return ParseErrorProcess(pkt.ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID16128, logStr, ALERT_DECODE_ERROR);
205 }
206
207 if (pkt.bufLen - *pkt.bufOffset != exMsgLen) {
208 return ParseErrorProcess(pkt.ctx, HITLS_PARSE_INVALID_MSG_LEN, BINLOG_ID15715, logStr, ALERT_DECODE_ERROR);
209 }
210
211 return ParseEncryptedEx(pkt.ctx, msg, &pkt.buf[*pkt.bufOffset], exMsgLen);
212 }
213 #endif /* HITLS_TLS_HOST_CLIENT && HITLS_TLS_PROTO_TLS13 */
214