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 <unistd.h>
19 #include <stdlib.h>
20 #include <pthread.h>
21 #include <string.h>
22 #include "bsl_sal.h"
23 #include "bsl_asn1.h"
24 #include "bsl_err.h"
25 #include "bsl_log.h"
26 #include "sal_time.h"
27 #include "sal_file.h"
28 #include "bsl_obj_internal.h"
29 #include "hitls_x509_local.h"
30
31 /* END_HEADER */
32
33 /* They are placed in their respective implementations and belong to specific applications, not asn1 modules */
34 #define BSL_ASN1_CTX_SPECIFIC_TAG_VER 0
35 #define BSL_ASN1_CTX_SPECIFIC_TAG_ISSUERID 1
36 #define BSL_ASN1_CTX_SPECIFIC_TAG_SUBJECTID 2
37 #define BSL_ASN1_CTX_SPECIFIC_TAG_EXTENSION 3
38
39 BSL_ASN1_TemplateItem certTempl[] = {
40 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}, /* x509 */
41 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1}, /* tbs */
42 /* 2: version */
43 {BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_CTX_SPECIFIC_TAG_VER, BSL_ASN1_FLAG_DEFAULT, 2},
44 {BSL_ASN1_TAG_INTEGER, 0, 3},
45 /* 2: serial number */
46 {BSL_ASN1_TAG_INTEGER, 0, 2},
47 /* 2: signature info */
48 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
49 {BSL_ASN1_TAG_OBJECT_ID, 0, 3},
50 {BSL_ASN1_TAG_ANY, BSL_ASN1_FLAG_OPTIONAL, 3}, // 8
51 /* 2: issuer */
52 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 2},
53 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SET, BSL_ASN1_FLAG_SAME, 3},
54 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 4},
55 {BSL_ASN1_TAG_OBJECT_ID, 0, 5},
56 {BSL_ASN1_TAG_ANY, 0, 5},
57 /* 2: validity */
58 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
59 {BSL_ASN1_TAG_CHOICE, 0, 3},
60 {BSL_ASN1_TAG_CHOICE, 0, 3}, // 16
61 /* 2: subject ref: issuer */
62 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 2},
63 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SET, BSL_ASN1_FLAG_SAME, 3},
64 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 4},
65 {BSL_ASN1_TAG_OBJECT_ID, 0, 5},
66 {BSL_ASN1_TAG_ANY, 0, 5},
67 /* 2: subject public key info ref signature info */
68 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
69 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 3},
70 {BSL_ASN1_TAG_OBJECT_ID, 0, 4},
71 {BSL_ASN1_TAG_ANY, BSL_ASN1_FLAG_OPTIONAL, 4}, // 25
72 {BSL_ASN1_TAG_BITSTRING, 0, 3},
73 /* 2: issuer id, subject id */
74 {BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_CTX_SPECIFIC_TAG_ISSUERID, BSL_ASN1_FLAG_OPTIONAL, 2},
75 {BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_CTX_SPECIFIC_TAG_SUBJECTID, BSL_ASN1_FLAG_OPTIONAL, 2},
76 /* 2: extension */
77 {BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_CTX_SPECIFIC_TAG_EXTENSION,
78 BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 2},
79 {BSL_ASN1_TAG_OBJECT_ID, 0, 3},
80 {BSL_ASN1_TAG_BOOLEAN, BSL_ASN1_FLAG_DEFAULT, 3},
81 {BSL_ASN1_TAG_OCTETSTRING, 0, 3},
82 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1}, /* signAlg */
83 {BSL_ASN1_TAG_OBJECT_ID, 0, 2},
84 {BSL_ASN1_TAG_ANY, BSL_ASN1_FLAG_OPTIONAL, 2}, // 35
85 {BSL_ASN1_TAG_BITSTRING, 0, 1} /* sig */
86 };
87
88 BSL_ASN1_TemplateItem maxDepthTempl[] = {
89 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 7},
90 };
91
92 #ifdef HITLS_BSL_SAL_FILE
93 static BSL_ASN1_TemplateItem g_rsaPub[] = {
94 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}, /* ignore seq */
95 {BSL_ASN1_TAG_INTEGER, 0, 1}, /* n */
96 {BSL_ASN1_TAG_INTEGER, 0, 1}, /* e */
97 };
98
99 static BSL_ASN1_TemplateItem g_rsaPrv[] = {
100 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}, /* ignore seq header */
101 {BSL_ASN1_TAG_INTEGER, 0, 1}, /* version */
102 {BSL_ASN1_TAG_INTEGER, 0, 1}, /* n */
103 {BSL_ASN1_TAG_INTEGER, 0, 1}, /* e */
104 {BSL_ASN1_TAG_INTEGER, 0, 1}, /* d */
105 {BSL_ASN1_TAG_INTEGER, 0, 1}, /* p */
106 {BSL_ASN1_TAG_INTEGER, 0, 1}, /* q */
107 {BSL_ASN1_TAG_INTEGER, 0, 1}, /* d mod (p-1) */
108 {BSL_ASN1_TAG_INTEGER, 0, 1}, /* d mod (q-1) */
109 {BSL_ASN1_TAG_INTEGER, 0, 1}, /* q^-1 mod p */
110 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE,
111 BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY | BSL_ASN1_FLAG_SAME, 1}, /* OtherPrimeInfos OPTIONAL */
112 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2}, /* OtherPrimeInfo */
113 {BSL_ASN1_TAG_INTEGER, 0, 3}, /* ri */
114 {BSL_ASN1_TAG_INTEGER, 0, 3}, /* di */
115 {BSL_ASN1_TAG_INTEGER, 0, 3} /* ti */
116 };
117
118 typedef struct {
119 BSL_ASN1_TemplateItem *items;
120 uint32_t itemNum;
121 uint32_t asnNum;
122 } TestAsn1Param;
123
124 static TestAsn1Param g_tests[] = {
125 {g_rsaPub, sizeof(g_rsaPub) / sizeof(g_rsaPub[0]), 2},
126 {g_rsaPrv, sizeof(g_rsaPrv) / sizeof(g_rsaPrv[0]), 10},
127 };
128 #endif
129
130 typedef enum {
131 BSL_ASN1_TAG_VERSION_IDX = 0,
132 BSL_ASN1_TAG_SERIAL_IDX = 1,
133 BSL_ASN1_TAG_SIGNINFO_OID_IDX = 2,
134 BSL_ASN1_TAG_SIGNINFO_ANY_IDX = 3,
135 BSL_ASN1_TAG_ISSUER_IDX = 4,
136 BSL_ASN1_TAG_BEFORE_VALID_IDX = 5,
137 BSL_ASN1_TAG_AFTER_VALID_IDX = 6,
138 BSL_ASN1_TAG_SUBJECT_IDX = 7,
139 BSL_ASN1_TAG_SUBKEYINFO_IDX = 8,
140 BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX = 9,
141 BSL_ASN1_TAG_SUBKEYINFO_BITSTRING_IDX = 10,
142 BSL_ASN1_TAG_ISSUERID_IDX = 11,
143 BSL_ASN1_TAG_SUBJECTID_IDX = 12,
144 BSL_ASN1_TAG_EXT_IDX = 13,
145 BSL_ASN1_TAG_SIGNALG_IDX = 14,
146 BSL_ASN1_TAG_SIGNALG_ANY_IDX = 15,
147 BSL_ASN1_TAG_SIGN_IDX = 16
148 } CERT_TEMPL_IDX;
149
150 #define BSL_ASN1_TIME_UTC_1 14
151 #define BSL_ASN1_TIME_UTC_2 15
152
153 #define BSL_ASN1_ID_ANY_1 7
154 #define BSL_ASN1_ID_ANY_2 24
155 #define BSL_ASN1_ID_ANY_3 34
156
157 char *g_oidEcc = "\x2a\x86\x48\xce\x3d\x02\01";
158 char *g_oidRsaPss = "\x2a\x86\x48\x86\xf7\x0d\x01\x01\x0a";
159
BSL_ASN1_CertTagGetOrCheck(int32_t type,uint32_t idx,void * data,void * expVal)160 int32_t BSL_ASN1_CertTagGetOrCheck(int32_t type, uint32_t idx, void *data, void *expVal)
161 {
162 BSL_ASN1_Buffer *param = NULL;
163 uint32_t len = 0;
164 switch (type) {
165 case BSL_ASN1_TYPE_CHECK_CHOICE_TAG:
166 if (idx == BSL_ASN1_TIME_UTC_1 || idx == BSL_ASN1_TIME_UTC_2) {
167 uint8_t tag = *(uint8_t *) data;
168 if ((tag & BSL_ASN1_TAG_UTCTIME) || (tag & BSL_ASN1_TAG_GENERALIZEDTIME)) {
169 *(uint8_t *) expVal = tag;
170 return BSL_SUCCESS;
171 }
172 }
173 return BSL_ASN1_FAIL;
174 case BSL_ASN1_TYPE_GET_ANY_TAG:
175 param = (BSL_ASN1_Buffer *) data;
176 len = param->len;
177 if (idx == BSL_ASN1_ID_ANY_1 || idx == BSL_ASN1_ID_ANY_3) {
178 if (strlen(g_oidRsaPss) == len && memcmp(param->buff, g_oidRsaPss, len) == 0) {
179 // note: any It can be encoded empty or it can be null
180 *(uint8_t *) expVal = BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE;
181 return BSL_SUCCESS;
182 } else {
183 *(uint8_t *) expVal = BSL_ASN1_TAG_NULL; // is null
184 return BSL_SUCCESS;
185 }
186 }
187 if (idx == BSL_ASN1_ID_ANY_2) {
188 if (strlen(g_oidEcc) == len && memcmp(param->buff, g_oidEcc, len) == 0) {
189 // note: any It can be encoded empty or it can be null
190 *(uint8_t *) expVal = BSL_ASN1_TAG_OBJECT_ID;
191 return BSL_SUCCESS;
192 } else { //
193 *(uint8_t *) expVal = BSL_ASN1_TAG_NULL; // is null
194 return BSL_SUCCESS;
195 }
196 }
197 return BSL_ASN1_FAIL;
198 default:
199 break;
200 }
201 return BSL_ASN1_FAIL;
202 }
203
204 #ifdef HITLS_BSL_SAL_FILE
ReadCert(const char * path,uint8_t ** buff,uint32_t * len)205 static int32_t ReadCert(const char *path, uint8_t **buff, uint32_t *len)
206 {
207 size_t readLen;
208 size_t fileLen = 0;
209 int32_t ret = BSL_SAL_FileLength(path, &fileLen);
210 if (ret != BSL_SUCCESS) {
211 return ret;
212 }
213 bsl_sal_file_handle stream = NULL;
214 ret = BSL_SAL_FileOpen(&stream, path, "rb");
215 if (ret != BSL_SUCCESS) {
216 return ret;
217 }
218
219 uint8_t *fileBuff = BSL_SAL_Malloc(fileLen);
220 if (fileBuff == NULL) {
221 BSL_SAL_FileClose(stream);
222 return BSL_MALLOC_FAIL;
223 }
224 do {
225 ret = BSL_SAL_FileRead(stream, fileBuff, 1, fileLen, &readLen);
226 BSL_SAL_FileClose(stream);
227 if (ret != BSL_SUCCESS) {
228 break;
229 }
230
231 *buff = fileBuff;
232 *len = (uint32_t)fileLen;
233 return ret;
234 } while (0);
235 BSL_SAL_FREE(fileBuff);
236 return ret;
237 }
238 #else
ReadCert(const char * path,uint8_t ** buff,uint32_t * len)239 static int32_t ReadCert(const char *path, uint8_t **buff, uint32_t *len)
240 {
241 (void)path;
242 (void)buff;
243 (void)len;
244 return BSL_INTERNAL_EXCEPTION;
245 }
246 #endif
247
248 #ifdef HITLS_BSL_LOG
BinLogFixLenFunc(uint32_t logId,uint32_t logLevel,uint32_t logType,void * format,void * para1,void * para2,void * para3,void * para4)249 void BinLogFixLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
250 void *format, void *para1, void *para2, void *para3, void *para4)
251 {
252 (void)logLevel;
253 (void)logType;
254 printf("logId:%u\t", logId);
255 printf(format, para1, para2, para3, para4);
256 printf("\n");
257 }
258
BinLogVarLenFunc(uint32_t logId,uint32_t logLevel,uint32_t logType,void * format,void * para)259 void BinLogVarLenFunc(uint32_t logId, uint32_t logLevel, uint32_t logType,
260 void *format, void *para)
261 {
262 (void)logLevel;
263 (void)logType;
264 printf("logId:%u\t", logId);
265 printf(format, para);
266 printf("\n");
267 }
268 #endif
269
270 /* BEGIN_CASE */
SDV_BSL_ASN1_DecodeTemplate_TC001(char * path)271 void SDV_BSL_ASN1_DecodeTemplate_TC001(char *path)
272 {
273 #ifndef HITLS_BSL_SAL_FILE
274 SKIP_TEST();
275 #endif
276 #ifdef HITLS_BSL_LOG
277 BSL_LOG_BinLogFuncs func = {0};
278 func.fixLenFunc = BinLogFixLenFunc;
279 func.varLenFunc = BinLogVarLenFunc;
280 ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
281 #endif
282
283 uint32_t fileLen = 0;
284 uint8_t *fileBuff = NULL;
285 int32_t ret = ReadCert(path, &fileBuff, &fileLen);
286 ASSERT_EQ(ret, BSL_SUCCESS);
287 uint8_t *rawBuff = fileBuff;
288 BSL_ASN1_Buffer asnArr[BSL_ASN1_TAG_SIGN_IDX + 1] = {0};
289 BSL_ASN1_Template templ = {certTempl, sizeof(certTempl) / sizeof(certTempl[0])};
290 ret = BSL_ASN1_DecodeTemplate(NULL, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
291 ASSERT_EQ(ret, BSL_NULL_INPUT);
292 ret = BSL_ASN1_DecodeTemplate(&templ, NULL, &fileBuff, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
293 ASSERT_EQ(ret, BSL_ASN1_ERR_NO_CALLBACK);
294 ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, NULL, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
295 ASSERT_EQ(ret, BSL_NULL_INPUT);
296 ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, NULL, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
297 ASSERT_EQ(ret, BSL_NULL_INPUT);
298 ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, NULL, BSL_ASN1_TAG_SIGN_IDX + 1);
299 ASSERT_EQ(ret, BSL_NULL_INPUT);
300 ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, asnArr, 0);
301 ASSERT_EQ(ret, BSL_NULL_INPUT);
302 EXIT:
303 BSL_SAL_FREE(rawBuff);
304 }
305 /* END_CASE */
306
307 /* BEGIN_CASE */
SDV_BSL_ASN1_DECODE_TEMPLATE_TC002(char * path)308 void SDV_BSL_ASN1_DECODE_TEMPLATE_TC002(char *path)
309 {
310 #ifndef HITLS_BSL_SAL_FILE
311 SKIP_TEST();
312 #endif
313 #ifdef HITLS_BSL_LOG
314 BSL_LOG_BinLogFuncs func = {0};
315 func.fixLenFunc = BinLogFixLenFunc;
316 func.varLenFunc = BinLogVarLenFunc;
317 ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
318 #endif
319
320 uint32_t fileLen = 0;
321 uint8_t *fileBuff = NULL;
322 int32_t ret = ReadCert(path, &fileBuff, &fileLen);
323 ASSERT_EQ(ret, BSL_SUCCESS);
324 uint8_t *rawBuff = fileBuff;
325 BSL_ASN1_Buffer asnArr[BSL_ASN1_TAG_SIGN_IDX + 1] = {0};
326 BSL_ASN1_Template templ = {maxDepthTempl, sizeof(maxDepthTempl) / sizeof(maxDepthTempl[0])};
327 ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck, &fileBuff, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
328 ASSERT_EQ(ret, BSL_ASN1_ERR_MAX_DEPTH);
329 EXIT:
330 BSL_SAL_FREE(rawBuff);
331 }
332 /* END_CASE */
333
334 /* BEGIN_CASE */
SDV_BSL_ASN1_PARSE_CERT_FUNC_TC001(char * path,Hex * version,Hex * serial,Hex * algId,Hex * anyAlgId,Hex * issuer,Hex * before,Hex * after,Hex * subject,Hex * pubId,Hex * pubAny,Hex * pubKey,Hex * issuerId,Hex * subjectId,Hex * ext,Hex * signAlg,Hex * signAlgAny,Hex * sign)335 void SDV_BSL_ASN1_PARSE_CERT_FUNC_TC001(char *path, Hex *version, Hex *serial, Hex *algId, Hex *anyAlgId,
336 Hex *issuer, Hex *before, Hex *after, Hex *subject, Hex *pubId, Hex *pubAny, Hex *pubKey, Hex *issuerId,
337 Hex *subjectId, Hex *ext, Hex *signAlg, Hex *signAlgAny, Hex *sign)
338 {
339 #ifndef HITLS_BSL_SAL_FILE
340 SKIP_TEST();
341 #endif
342 #ifdef HITLS_BSL_LOG
343 BSL_LOG_BinLogFuncs func = {0};
344 func.fixLenFunc = BinLogFixLenFunc;
345 func.varLenFunc = BinLogVarLenFunc;
346 ASSERT_TRUE(BSL_LOG_RegBinLogFunc(&func) == BSL_SUCCESS);
347 #endif
348
349 uint32_t fileLen = 0;
350 uint8_t *fileBuff = NULL;
351 int32_t ret = ReadCert(path, &fileBuff, &fileLen);
352 ASSERT_EQ(ret, BSL_SUCCESS);
353 uint8_t *rawBuff = fileBuff;
354 BSL_ASN1_Buffer asnArr[BSL_ASN1_TAG_SIGN_IDX + 1] = {0};
355 BSL_ASN1_Template templ = {certTempl, sizeof(certTempl) / sizeof(certTempl[0])};
356 ret = BSL_ASN1_DecodeTemplate(&templ, BSL_ASN1_CertTagGetOrCheck,
357 &fileBuff, &fileLen, asnArr, BSL_ASN1_TAG_SIGN_IDX + 1);
358 ASSERT_EQ(ret, BSL_SUCCESS);
359 ASSERT_EQ(fileLen, 0);
360 // 证书对比
361 if (version->len != 0) {
362 ASSERT_EQ_LOG("version compare tag", asnArr[BSL_ASN1_TAG_VERSION_IDX].tag, BSL_ASN1_TAG_INTEGER);
363 ASSERT_COMPARE("version compare", version->x, version->len,
364 asnArr[BSL_ASN1_TAG_VERSION_IDX].buff, asnArr[BSL_ASN1_TAG_VERSION_IDX].len);
365 }
366
367 ASSERT_EQ_LOG("serial compare tag", asnArr[BSL_ASN1_TAG_SERIAL_IDX].tag, BSL_ASN1_TAG_INTEGER);
368 ASSERT_COMPARE("serial compare", serial->x, serial->len,
369 asnArr[BSL_ASN1_TAG_SERIAL_IDX].buff, asnArr[BSL_ASN1_TAG_SERIAL_IDX].len);
370
371 ASSERT_EQ_LOG("algid compare tag", asnArr[BSL_ASN1_TAG_SIGNINFO_OID_IDX].tag, BSL_ASN1_TAG_OBJECT_ID);
372 ASSERT_COMPARE("algid compare", algId->x, algId->len,
373 asnArr[BSL_ASN1_TAG_SIGNINFO_OID_IDX].buff, asnArr[BSL_ASN1_TAG_SIGNINFO_OID_IDX].len);
374
375 if (anyAlgId->len != 0) {
376 ASSERT_COMPARE("any algid compare", anyAlgId->x, anyAlgId->len,
377 asnArr[BSL_ASN1_TAG_SIGNINFO_ANY_IDX].buff, asnArr[BSL_ASN1_TAG_SIGNINFO_ANY_IDX].len);
378 } else {
379 ASSERT_EQ(asnArr[BSL_ASN1_TAG_SIGNINFO_ANY_IDX].buff, NULL);
380 ASSERT_EQ(asnArr[BSL_ASN1_TAG_SIGNINFO_ANY_IDX].len, 0);
381 }
382
383 ASSERT_EQ_LOG("issuer compare tag", asnArr[BSL_ASN1_TAG_ISSUER_IDX].tag,
384 BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE);
385 ASSERT_COMPARE("issuer compare", issuer->x, issuer->len,
386 asnArr[BSL_ASN1_TAG_ISSUER_IDX].buff, asnArr[BSL_ASN1_TAG_ISSUER_IDX].len);
387
388 ASSERT_COMPARE("before compare", before->x, before->len,
389 asnArr[BSL_ASN1_TAG_BEFORE_VALID_IDX].buff, asnArr[BSL_ASN1_TAG_BEFORE_VALID_IDX].len);
390
391 ASSERT_COMPARE("after compare", after->x, after->len,
392 asnArr[BSL_ASN1_TAG_AFTER_VALID_IDX].buff, asnArr[BSL_ASN1_TAG_AFTER_VALID_IDX].len);
393
394 ASSERT_EQ_LOG("subject compare tag", asnArr[BSL_ASN1_TAG_SUBJECT_IDX].tag,
395 BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE);
396 ASSERT_COMPARE("subject compare", subject->x, subject->len,
397 asnArr[BSL_ASN1_TAG_SUBJECT_IDX].buff, asnArr[BSL_ASN1_TAG_SUBJECT_IDX].len);
398
399 ASSERT_EQ_LOG("subject pub key compare tag", asnArr[BSL_ASN1_TAG_SUBKEYINFO_IDX].tag, BSL_ASN1_TAG_OBJECT_ID);
400 ASSERT_COMPARE("subject pub key id compare", pubId->x, pubId->len,
401 asnArr[BSL_ASN1_TAG_SUBKEYINFO_IDX].buff, asnArr[BSL_ASN1_TAG_SUBKEYINFO_IDX].len);
402
403 if (pubAny->len != 0) {
404 ASSERT_COMPARE("any pub key compare", pubAny->x, pubAny->len,
405 asnArr[BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX].buff, asnArr[BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX].len);
406 } else {
407 ASSERT_EQ(asnArr[BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX].buff, NULL);
408 ASSERT_EQ(asnArr[BSL_ASN1_TAG_SUBKEYINFO_ANY_IDX].len, 0);
409 }
410
411 ASSERT_EQ_LOG("subject pub key compare tag", asnArr[BSL_ASN1_TAG_SUBKEYINFO_BITSTRING_IDX].tag,
412 BSL_ASN1_TAG_BITSTRING);
413 ASSERT_COMPARE("subject pub key compare", pubKey->x, pubKey->len,
414 asnArr[BSL_ASN1_TAG_SUBKEYINFO_BITSTRING_IDX].buff, asnArr[BSL_ASN1_TAG_SUBKEYINFO_BITSTRING_IDX].len);
415
416 if (issuerId->len != 0) {
417 ASSERT_COMPARE("issuerId compare", issuerId->x, issuerId->len,
418 asnArr[BSL_ASN1_TAG_ISSUERID_IDX].buff, asnArr[BSL_ASN1_TAG_ISSUERID_IDX].len);
419 } else {
420 ASSERT_EQ(asnArr[BSL_ASN1_TAG_ISSUERID_IDX].buff, NULL);
421 ASSERT_EQ(asnArr[BSL_ASN1_TAG_ISSUERID_IDX].len, 0);
422 }
423 if (subjectId->len != 0) {
424 ASSERT_COMPARE("subjectId compare", subjectId->x, subjectId->len,
425 asnArr[BSL_ASN1_TAG_SUBJECTID_IDX].buff, asnArr[BSL_ASN1_TAG_SUBJECTID_IDX].len);
426 } else {
427 ASSERT_EQ(asnArr[BSL_ASN1_TAG_SUBJECTID_IDX].buff, NULL);
428 ASSERT_EQ(asnArr[BSL_ASN1_TAG_SUBJECTID_IDX].len, 0);
429 }
430
431 if (ext->len != 0) { // v1 没有ext
432 ASSERT_EQ_LOG("ext compare tag", asnArr[BSL_ASN1_TAG_EXT_IDX].tag,
433 BSL_ASN1_CLASS_CTX_SPECIFIC | BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_CTX_SPECIFIC_TAG_EXTENSION);
434 ASSERT_COMPARE("ext compare", ext->x, ext->len,
435 asnArr[BSL_ASN1_TAG_EXT_IDX].buff, asnArr[BSL_ASN1_TAG_EXT_IDX].len);
436 }
437
438 ASSERT_EQ_LOG("signAlg compare tag", asnArr[BSL_ASN1_TAG_SIGNALG_IDX].tag, BSL_ASN1_TAG_OBJECT_ID);
439 ASSERT_COMPARE("signAlg compare", signAlg->x, signAlg->len,
440 asnArr[BSL_ASN1_TAG_SIGNALG_IDX].buff, asnArr[BSL_ASN1_TAG_SIGNALG_IDX].len);
441
442 if (signAlgAny->len != 0) {
443 ASSERT_COMPARE("signAlgAny compare", signAlgAny->x, signAlgAny->len,
444 asnArr[BSL_ASN1_TAG_SIGNALG_ANY_IDX].buff, asnArr[BSL_ASN1_TAG_SIGNALG_ANY_IDX].len);
445 } else {
446 ASSERT_EQ(asnArr[BSL_ASN1_TAG_SIGNALG_ANY_IDX].buff, NULL);
447 ASSERT_EQ(asnArr[BSL_ASN1_TAG_SIGNALG_ANY_IDX].len, 0);
448 }
449
450 ASSERT_EQ_LOG("sign compare tag", asnArr[BSL_ASN1_TAG_SIGN_IDX].tag, BSL_ASN1_TAG_BITSTRING);
451 ASSERT_COMPARE("sign compare", sign->x, sign->len,
452 asnArr[BSL_ASN1_TAG_SIGN_IDX].buff, asnArr[BSL_ASN1_TAG_SIGN_IDX].len);
453 EXIT:
454 BSL_SAL_FREE(rawBuff);
455 }
456 /* END_CASE */
457
458
459 /* BEGIN_CASE */
SDV_BSL_ASN1_DecodePrimitiveItem_FUNC_TC001(Hex * val)460 void SDV_BSL_ASN1_DecodePrimitiveItem_FUNC_TC001(Hex *val)
461 {
462 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BOOLEAN, val->len, val->x};
463 bool res;
464 int32_t ret = BSL_ASN1_DecodePrimitiveItem(NULL, &res);
465 ASSERT_EQ(ret, BSL_NULL_INPUT);
466 ret = BSL_ASN1_DecodePrimitiveItem(&asn, NULL);
467 ASSERT_EQ(ret, BSL_NULL_INPUT);
468 EXIT:
469 return;
470 }
471 /* END_CASE */
472
473 /* BEGIN_CASE */
SDV_BSL_ASN1_DecodePrimitiveItem_FUNC_TC002(int tag,Hex * val)474 void SDV_BSL_ASN1_DecodePrimitiveItem_FUNC_TC002(int tag, Hex *val)
475 {
476 BSL_ASN1_Buffer asn = {(uint8_t)tag, val->len, val->x};
477 int32_t res;
478 int32_t ret = BSL_ASN1_DecodePrimitiveItem(NULL, &res);
479 ASSERT_EQ(ret, BSL_NULL_INPUT);
480 ret = BSL_ASN1_DecodePrimitiveItem(&asn, NULL);
481 ASSERT_EQ(ret, BSL_NULL_INPUT);
482 EXIT:
483 return;
484 }
485 /* END_CASE */
486
487 /* BEGIN_CASE */
SDV_BSL_ASN1_DecodePrimitiveItem_FUNC_TC003(Hex * val)488 void SDV_BSL_ASN1_DecodePrimitiveItem_FUNC_TC003(Hex *val)
489 {
490 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BITSTRING, val->len, val->x};
491 BSL_ASN1_BitString res;
492 int32_t ret = BSL_ASN1_DecodePrimitiveItem(NULL, &res);
493 ASSERT_EQ(ret, BSL_NULL_INPUT);
494 ret = BSL_ASN1_DecodePrimitiveItem(&asn, NULL);
495 ASSERT_EQ(ret, BSL_NULL_INPUT);
496 EXIT:
497 return;
498 }
499 /* END_CASE */
500
501 /* BEGIN_CASE */
SDV_BSL_ASN1_PARSE_BOOL_PRIMITIVEITEM_FUNC(Hex * val,int expectVal)502 void SDV_BSL_ASN1_PARSE_BOOL_PRIMITIVEITEM_FUNC(Hex *val, int expectVal)
503 {
504 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BOOLEAN, val->len, val->x};
505 bool res;
506 int32_t ret = BSL_ASN1_DecodePrimitiveItem(&asn, &res);
507 ASSERT_EQ(ret, BSL_SUCCESS);
508 ASSERT_EQ((bool)expectVal, res);
509 EXIT:
510 return;
511 }
512 /* END_CASE */
513
514 /* BEGIN_CASE */
SDV_BSL_ASN1_PARSE_INT_PRIMITIVEITEM_FUNC(int tag,Hex * val,int result,int expectVal)515 void SDV_BSL_ASN1_PARSE_INT_PRIMITIVEITEM_FUNC(int tag, Hex *val, int result, int expectVal)
516 {
517 BSL_ASN1_Buffer asn = {(uint8_t)tag, val->len, val->x};
518 int32_t res;
519 int32_t ret = BSL_ASN1_DecodePrimitiveItem(&asn, &res);
520 ASSERT_EQ(ret, result);
521 if (ret == BSL_SUCCESS) {
522 ASSERT_EQ((uint32_t)expectVal, res);
523 }
524
525 EXIT:
526 return;
527 }
528 /* END_CASE */
529
530 /* BEGIN_CASE */
SDV_BSL_ASN1_PARSE_BITSTRING_PRIMITIVEITEM_FUNC(Hex * val,int result,int unusedBits)531 void SDV_BSL_ASN1_PARSE_BITSTRING_PRIMITIVEITEM_FUNC(Hex *val, int result, int unusedBits)
532 {
533 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BITSTRING, val->len, val->x};
534 BSL_ASN1_BitString res;
535 int32_t ret = BSL_ASN1_DecodePrimitiveItem(&asn, &res);
536 ASSERT_EQ(ret, result);
537 if (ret == BSL_SUCCESS) {
538 ASSERT_EQ((uint32_t)unusedBits, res.unusedBits);
539 ASSERT_EQ(val->len - 1, res.len);
540 ASSERT_COMPARE("bit string", res.buff, res.len, val->x + 1, val->len - 1);
541 }
542
543 EXIT:
544 return;
545 }
546 /* END_CASE */
547
548 /* BEGIN_CASE */
SDV_BSL_ASN1_PARSE_TIME_PRIMITIVEITEM_FUNC(int tag,Hex * val,int result,int year,int month,int day,int hour,int minute,int second)549 void SDV_BSL_ASN1_PARSE_TIME_PRIMITIVEITEM_FUNC(int tag, Hex *val, int result,
550 int year, int month, int day, int hour, int minute, int second)
551 {
552 BSL_ASN1_Buffer asn = {tag, val->len, val->x};
553 BSL_TIME res = {0};
554 int32_t ret = BSL_ASN1_DecodePrimitiveItem(&asn, &res);
555 ASSERT_EQ(ret, result);
556 if (ret == BSL_SUCCESS) {
557 ASSERT_EQ(res.year, year);
558 ASSERT_EQ(res.month, month);
559 ASSERT_EQ(res.day, day);
560 ASSERT_EQ(res.hour, hour);
561 ASSERT_EQ(res.minute, minute);
562 ASSERT_EQ(res.second, second);
563 }
564 EXIT:
565 return;
566 }
567 /* END_CASE */
568
569 /* BEGIN_CASE */
SDV_BSL_ASN1_DECODELEN_FUNC(int flag,Hex * val,int res)570 void SDV_BSL_ASN1_DECODELEN_FUNC(int flag, Hex *val, int res)
571 {
572 uint8_t *encode = val->x;
573 uint32_t encodeLen = val->len;
574 uint32_t len = 0;
575 ASSERT_EQ(BSL_ASN1_DecodeLen(&encode, &encodeLen, flag, &len), res);
576 EXIT:
577 return;
578 }
579 /* END_CASE */
580
581 /* BEGIN_CASE */
SDV_BSL_ASN1_DECODE_WRONG_INPUT_FUNC()582 void SDV_BSL_ASN1_DECODE_WRONG_INPUT_FUNC()
583 {
584 uint8_t *encode = NULL;
585 uint32_t encodeLen = 0;
586 uint32_t valueLen = 0;
587 bool completeLen = 0;
588 uint8_t tag = 0x30;
589 BSL_ASN1_Buffer asnItem = {0};
590 ASSERT_EQ(BSL_ASN1_DecodeLen(&encode, &encodeLen, completeLen, &valueLen), BSL_NULL_INPUT);
591 ASSERT_EQ(BSL_ASN1_DecodeTagLen(tag, &encode, &encodeLen, &valueLen), BSL_NULL_INPUT);
592 ASSERT_EQ(BSL_ASN1_DecodeItem(&encode, &encodeLen, &asnItem), BSL_NULL_INPUT);
593 BSL_ASN1_TemplateItem listTempl = {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0};
594 BSL_ASN1_Template templ = {&listTempl, 1};
595 ASSERT_EQ(BSL_ASN1_DecodeTemplate(&templ, NULL, &encode, &encodeLen, &asnItem, 1), BSL_NULL_INPUT);
596 EXIT:
597 return;
598 }
599 /* END_CASE */
600
601 /* BEGIN_CASE */
SDV_BSL_ASN1_DECODECOMPLETELEN_FUNC(Hex * val,int ecpLen,int res)602 void SDV_BSL_ASN1_DECODECOMPLETELEN_FUNC(Hex *val, int ecpLen, int res)
603 {
604 uint8_t *encode = val->x;
605 uint32_t encodeLen = val->len;
606 ASSERT_EQ(BSL_ASN1_GetCompleteLen(encode, &encodeLen), res);
607 if (res == BSL_SUCCESS) {
608 ASSERT_EQ(encodeLen, ecpLen);
609 }
610 EXIT:
611 return;
612 }
613 /* END_CASE */
614
615 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_TEMPLATE_API_TC001(void)616 void SDV_BSL_ASN1_ENCODE_TEMPLATE_API_TC001(void)
617 {
618 BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0}};
619 BSL_ASN1_Template templ = {item, 1};
620 BSL_ASN1_Buffer asnArr[1] = {0};
621 uint8_t *encode = NULL;
622 uint32_t encodeLen = 0;
623
624 /* templ */
625 ASSERT_EQ(BSL_ASN1_EncodeTemplate(NULL, asnArr, 1, &encode, &encodeLen), BSL_INVALID_ARG);
626 templ.templItems = NULL;
627 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, &encodeLen), BSL_INVALID_ARG);
628 templ.templItems = item;
629 templ.templNum = 0;
630 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, &encodeLen), BSL_INVALID_ARG);
631 templ.templNum = 1;
632
633 /* asnArr */
634 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, NULL, 1, &encode, &encodeLen), BSL_INVALID_ARG);
635 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 0, &encode, &encodeLen), BSL_INVALID_ARG);
636
637 /* encode */
638 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, NULL, &encodeLen), BSL_INVALID_ARG);
639 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, NULL), BSL_INVALID_ARG);
640 encode = (uint8_t*)&encodeLen;
641 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, &encodeLen), BSL_INVALID_ARG);
642
643 EXIT:
644 return;
645 }
646 /* END_CASE */
647
648 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC001(void)649 void SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC001(void)
650 {
651 BSL_ASN1_Template templ = {maxDepthTempl, sizeof(maxDepthTempl) / sizeof(maxDepthTempl[0])};
652 BSL_ASN1_Buffer asnArr[1] = {0};
653 uint8_t *encode = NULL;
654 uint32_t encodeLen = 0;
655 TestMemInit();
656 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asnArr, 1, &encode, &encodeLen), BSL_ASN1_ERR_MAX_DEPTH);
657 EXIT:
658 return;
659 }
660 /* END_CASE */
661
662 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC002(int tag,int len,int ret)663 void SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC002(int tag, int len, int ret)
664 {
665 BSL_ASN1_TemplateItem item[] = {{tag, 0, 0}};
666 BSL_ASN1_Template templ = {item, 1};
667 uint8_t data = 1;
668 BSL_ASN1_Buffer asn = {tag, len, &data};
669 uint8_t *encode = NULL;
670 uint32_t encodeLen = 0;
671
672 TestMemInit();
673 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), ret);
674 EXIT:
675 return;
676 }
677 /* END_CASE */
678
679 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC003(Hex * data)680 void SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC003(Hex *data)
681 {
682 BSL_ASN1_TemplateItem items[] = {
683 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
684 {BSL_ASN1_TAG_INTEGER, 0, 1},
685 {BSL_ASN1_TAG_ANY, 0, 1},
686 {BSL_ASN1_TAG_CHOICE, 0, 1}
687 };
688 BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
689 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_INTEGER, data->len, data->x};
690 BSL_ASN1_Buffer asns[] = {asn, asn, asn, asn};
691 uint8_t *encode = NULL;
692 uint32_t encodeLen = 0;
693 uint32_t expectAsnNum = 3;
694
695 TestMemInit();
696 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, expectAsnNum - 1, &encode, &encodeLen),
697 BSL_ASN1_ERR_ENCODE_ASN_LACK);
698 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, expectAsnNum + 1, &encode, &encodeLen),
699 BSL_ASN1_ERR_ENCODE_ASN_TOO_MUCH);
700 EXIT:
701 return;
702 }
703 /* END_CASE */
704
705 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC004(void)706 void SDV_BSL_ASN1_ENCODE_TEMPLATE_ERROR_TC004(void)
707 {
708 BSL_ASN1_TemplateItem items[] = {
709 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
710 {BSL_ASN1_TAG_INTEGER, 0, 1},
711 };
712 BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
713 int iData = 256;
714 BSL_ASN1_Buffer asn[] = {{BSL_ASN1_TAG_ENUMERATED, sizeof(int), (uint8_t *)&iData}};
715 uint8_t *encode = NULL;
716 uint32_t encodeLen = 0;
717
718 TestMemInit();
719 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asn, sizeof(asn) / sizeof(asn[0]), &encode, &encodeLen),
720 BSL_ASN1_ERR_TAG_EXPECTED);
721 EXIT:
722 return;
723 }
724 /* END_CASE */
725
726 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_BOOL_FUNC(int data,Hex * expect)727 void SDV_BSL_ASN1_ENCODE_BOOL_FUNC(int data, Hex *expect)
728 {
729 bool bData = (bool)data;
730 BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_BOOLEAN, 0, 0}};
731 BSL_ASN1_Template templ = {item, 1};
732 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BOOLEAN, 1, (uint8_t *)&bData};
733 uint8_t *encode = NULL;
734 uint32_t encodeLen = 0;
735
736 TestMemInit();
737 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);
738 ASSERT_EQ(encodeLen, expect->len);
739 ASSERT_COMPARE("Encode bool", expect->x, expect->len, encode, encodeLen);
740 EXIT:
741 BSL_SAL_Free(encode);
742 }
743 /* END_CASE */
744
745 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_INT_LIMB_FUNC(int ret,int data,Hex * expect)746 void SDV_BSL_ASN1_ENCODE_INT_LIMB_FUNC(int ret, int data, Hex *expect)
747 {
748 BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_INTEGER, 0, 0}};
749 BSL_ASN1_Template templ = {item, 1};
750 BSL_ASN1_Buffer asn = {0};
751 uint8_t *encode = NULL;
752 uint32_t encodeLen = 0;
753
754 TestMemInit();
755 ASSERT_EQ(BSL_ASN1_EncodeLimb(BSL_ASN1_TAG_INTEGER, data, &asn), BSL_SUCCESS);
756
757 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), ret);
758 ASSERT_EQ(encodeLen, expect->len);
759 ASSERT_COMPARE("Encode int", expect->x, expect->len, encode, encodeLen);
760 EXIT:
761 BSL_SAL_Free(asn.buff);
762 if (ret == BSL_SUCCESS) {
763 BSL_SAL_Free(encode);
764 }
765 }
766 /* END_CASE */
767
768 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_INT_BN_FUNC(Hex * bn,Hex * expect)769 void SDV_BSL_ASN1_ENCODE_INT_BN_FUNC(Hex *bn, Hex *expect)
770 {
771 BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_INTEGER, 0, 0}};
772 BSL_ASN1_Template templ = {item, 1};
773 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_INTEGER, bn->len, bn->x};
774 uint8_t *encode = NULL;
775 uint32_t encodeLen = 0;
776
777 TestMemInit();
778 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);
779 ASSERT_EQ(encodeLen, expect->len);
780 ASSERT_COMPARE("Encode int", expect->x, expect->len, encode, encodeLen);
781 EXIT:
782 BSL_SAL_Free(encode);
783 }
784 /* END_CASE */
785
786 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_BITSTRING_FUNC(int ret,Hex * data,int unusedBits,Hex * expect)787 void SDV_BSL_ASN1_ENCODE_BITSTRING_FUNC(int ret, Hex *data, int unusedBits, Hex *expect)
788 {
789 BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_BITSTRING, 0, 0}};
790 BSL_ASN1_Template templ = {item, 1};
791 BSL_ASN1_BitString bs = {data->x, data->len, unusedBits};
792 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BITSTRING,
793 data->len == 0 ? 0 : sizeof(BSL_ASN1_BitString),
794 data->len == 0 ? NULL : (uint8_t *)&bs};
795 uint8_t *encode = NULL;
796 uint32_t encodeLen = 0;
797
798 TestMemInit();
799 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), ret);
800 ASSERT_EQ(encodeLen, expect->len);
801 ASSERT_COMPARE("Encode bitstring", expect->x, expect->len, encode, encodeLen);
802 EXIT:
803 if (ret == BSL_SUCCESS) {
804 BSL_SAL_Free(encode);
805 }
806 }
807 /* END_CASE */
808
809 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_TIME_FUNC(int tag,int ret,int year,int month,int day,int hour,int minute,int second,Hex * expect)810 void SDV_BSL_ASN1_ENCODE_TIME_FUNC(int tag, int ret, int year, int month, int day, int hour, int minute, int second,
811 Hex *expect)
812 {
813 BSL_ASN1_TemplateItem item[] = {{tag, 0, 0}};
814 BSL_ASN1_Template templ = {item, 1};
815 BSL_TIME time = {year, month, day, hour, minute, 0, second, 0};
816 BSL_ASN1_Buffer asn = {tag, sizeof(BSL_TIME), (uint8_t *)&time};
817 uint8_t *encode = NULL;
818 uint32_t encodeLen = 0;
819
820 TestMemInit();
821 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), ret);
822 ASSERT_EQ(encodeLen, expect->len);
823 ASSERT_COMPARE("Encode time", expect->x, expect->len, encode, encodeLen);
824 EXIT:
825 if (ret == BSL_SUCCESS) {
826 BSL_SAL_Free(encode);
827 }
828 }
829 /* END_CASE */
830
831 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_NULL_FUNC_TC001(Hex * expect)832 void SDV_BSL_ASN1_ENCODE_NULL_FUNC_TC001(Hex *expect)
833 {
834 BSL_ASN1_TemplateItem item[] = {
835 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
836 {BSL_ASN1_TAG_NULL, 0, 1},
837 {BSL_ASN1_TAG_NULL, BSL_ASN1_FLAG_OPTIONAL, 1},
838 {BSL_ASN1_TAG_NULL, BSL_ASN1_FLAG_DEFAULT, 1},
839 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
840 {BSL_ASN1_TAG_NULL, 0, 2},
841 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL, 1},
842 {BSL_ASN1_TAG_NULL, 0, 2},
843 };
844 BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
845 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_NULL, 0, NULL};
846 BSL_ASN1_Buffer asns[] = {asn, asn, asn, asn, asn};
847 uint8_t *encode = NULL;
848 uint32_t encodeLen = 0;
849
850 TestMemInit();
851 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asn), &encode, &encodeLen), BSL_SUCCESS);
852 ASSERT_EQ(encodeLen, expect->len);
853 ASSERT_COMPARE("Encode null", expect->x, expect->len, encode, encodeLen);
854 EXIT:
855 BSL_SAL_Free(encode);
856 }
857 /* END_CASE */
858
859 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_NULL_FUNC_TC002(Hex * expect)860 void SDV_BSL_ASN1_ENCODE_NULL_FUNC_TC002(Hex *expect)
861 {
862 uint8_t data = 1;
863 BSL_ASN1_TemplateItem item[] = {{BSL_ASN1_TAG_NULL, 0, 0}};
864 BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
865 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_NULL, 1, &data};
866 uint8_t *encode = NULL;
867 uint32_t encodeLen = 0;
868
869 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, &asn, 1, &encode, &encodeLen), BSL_SUCCESS);
870 ASSERT_EQ(encodeLen, expect->len);
871 ASSERT_COMPARE("Encode null", expect->x, expect->len, encode, encodeLen);
872 EXIT:
873 BSL_SAL_Free(encode);
874 }
875 /* END_CASE */
876
877 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC001(Hex * expect)878 void SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC001(Hex *expect)
879 {
880 BSL_ASN1_TemplateItem items[] = {
881 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
882 {BSL_ASN1_TAG_INTEGER, 0, 1},
883 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY, 1},
884 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY, 1},
885 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL | BSL_ASN1_FLAG_HEADERONLY, 1},
886 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 2},
887 {BSL_ASN1_TAG_INTEGER, 0, 3},
888 {BSL_ASN1_TAG_INTEGER, 0, 3},
889 {BSL_ASN1_TAG_INTEGER, 0, 1},
890 };
891 BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
892 uint8_t iData[] = {0x01, 0x00};
893 uint8_t data = 0x12;
894 BSL_ASN1_Buffer asns[] = {
895 {BSL_ASN1_TAG_INTEGER, sizeof(iData) / sizeof(uint8_t), iData},
896 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 1, &data},
897 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, NULL},
898 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 1, &data},
899 {BSL_ASN1_TAG_INTEGER, sizeof(iData) / sizeof(uint8_t), iData},
900 };
901 uint8_t *encode = NULL;
902 uint32_t encodeLen = 0;
903
904 TestMemInit();
905 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asns[0]), &encode, &encodeLen), BSL_SUCCESS);
906 ASSERT_EQ(encodeLen, expect->len);
907 ASSERT_COMPARE("Encode headonly", expect->x, expect->len, encode, encodeLen);
908 EXIT:
909 BSL_SAL_Free(encode);
910 }
911 /* END_CASE */
912
913 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC002(Hex * data,Hex * expect)914 void SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC002(Hex *data, Hex *expect)
915 {
916 BSL_ASN1_TemplateItem items[] = {
917 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
918 {BSL_ASN1_TAG_INTEGER, 0, 1},
919 {BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_OPTIONAL, 1},
920 {BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_DEFAULT, 1},
921 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
922 {BSL_ASN1_TAG_INTEGER, 0, 2},
923 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_OPTIONAL, 1},
924 {BSL_ASN1_TAG_INTEGER, 0, 2},
925 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_DEFAULT, 1},
926 {BSL_ASN1_TAG_INTEGER, 0, 2},
927 };
928 BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
929 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_INTEGER, data->len, data->x};
930 BSL_ASN1_Buffer asns[] = {asn, asn, asn, asn, asn, asn};
931 uint8_t *encode = NULL;
932 uint32_t encodeLen = 0;
933
934 TestMemInit();
935 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, sizeof(asns) / sizeof(asn), &encode, &encodeLen), BSL_SUCCESS);
936 ASSERT_EQ(encodeLen, expect->len);
937 ASSERT_COMPARE("Encode optional|default", expect->x, expect->len, encode, encodeLen);
938 EXIT:
939 BSL_SAL_Free(encode);
940 }
941 /* END_CASE */
942
943 static BSL_ASN1_TemplateItem g_templItem1[] = {
944 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
945 {BSL_ASN1_TAG_INTEGER, 0, 1},
946 {BSL_ASN1_TAG_INTEGER, 0, 1},
947 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
948 {BSL_ASN1_TAG_INTEGER, 0, 2},
949 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
950 {BSL_ASN1_TAG_INTEGER, 0, 2},
951 };
952
953 static BSL_ASN1_TemplateItem g_templItem2[] = {
954 {BSL_ASN1_TAG_INTEGER, 0, 0},
955 {BSL_ASN1_TAG_INTEGER, 0, 0},
956 {BSL_ASN1_TAG_INTEGER, 0, 0},
957 {BSL_ASN1_TAG_INTEGER, 0, 0},
958 };
959
960 static BSL_ASN1_TemplateItem g_templItem3[] = {
961 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
962 {BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_OPTIONAL, 1},
963 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
964 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
965 {BSL_ASN1_TAG_INTEGER, 0, 2},
966 {BSL_ASN1_TAG_INTEGER, 0, 0},
967 {BSL_ASN1_TAG_INTEGER, BSL_ASN1_FLAG_OPTIONAL, 0},
968 };
969
970 static BSL_ASN1_Template g_templ[] = {
971 {g_templItem1, sizeof(g_templItem1) / sizeof(g_templItem1[0])},
972 {g_templItem2, sizeof(g_templItem2) / sizeof(g_templItem2[0])},
973 {g_templItem3, sizeof(g_templItem3) / sizeof(g_templItem3[0])},
974 };
975
976 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC003(Hex * data,int templIdx,Hex * expect)977 void SDV_BSL_ASN1_ENCODE_TEMPLATE_FUNC_TC003(Hex *data, int templIdx, Hex *expect)
978 {
979 #define MAX_INT_ASN_NUM 4
980 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_INTEGER, data->len, data->x};
981 BSL_ASN1_Buffer asns[MAX_INT_ASN_NUM] = {asn, asn, asn, asn};
982 uint8_t *encode = NULL;
983 uint32_t encodeLen = 0;
984
985 TestMemInit();
986 ASSERT_EQ(BSL_ASN1_EncodeTemplate(g_templ + templIdx, asns, MAX_INT_ASN_NUM, &encode, &encodeLen), BSL_SUCCESS);
987 ASSERT_EQ(encodeLen, expect->len);
988 ASSERT_COMPARE("Encode", expect->x, expect->len, encode, encodeLen);
989 EXIT:
990 BSL_SAL_Free(encode);
991 }
992 /* END_CASE */
993
994 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_LIST_API_TC001(void)995 void SDV_BSL_ASN1_ENCODE_LIST_API_TC001(void)
996 {
997 BSL_ASN1_TemplateItem item[] = {
998 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
999 {BSL_ASN1_TAG_NULL, 0, 1},
1000 {BSL_ASN1_TAG_NULL, 0, 1},
1001 };
1002 BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
1003 BSL_ASN1_Buffer asnArr[] = {
1004 {BSL_ASN1_TAG_NULL, 0, NULL},
1005 {BSL_ASN1_TAG_NULL, 0, NULL},
1006 };
1007 uint32_t arrNum = sizeof(asnArr) / sizeof(asnArr[0]);
1008 BSL_ASN1_Buffer out = {0};
1009
1010 /* tag */
1011 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_TIME, 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
1012
1013 /* listSize */
1014 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_TIME, 0, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
1015
1016 /* templ */
1017 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, NULL, asnArr, arrNum, &out), BSL_INVALID_ARG);
1018 templ.templItems = NULL;
1019 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SEQUENCE, 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
1020 templ.templItems = item;
1021 templ.templNum = 0;
1022 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
1023 templ.templNum = sizeof(item) / sizeof(item[0]);
1024
1025 /* asnArr */
1026 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, NULL, arrNum, &out), BSL_INVALID_ARG);
1027 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, 0, &out), BSL_INVALID_ARG);
1028 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, arrNum + 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
1029
1030 /* out */
1031 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, arrNum, NULL), BSL_INVALID_ARG);
1032 out.buff = (uint8_t *)&arrNum;
1033 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, arrNum, &out), BSL_INVALID_ARG);
1034 EXIT:
1035 return;
1036 }
1037 /* END_CASE */
1038
1039 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_LIST_ERROR_TC001(void)1040 void SDV_BSL_ASN1_ENCODE_LIST_ERROR_TC001(void)
1041 {
1042 BSL_ASN1_TemplateItem item[] = {
1043 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
1044 {BSL_ASN1_TAG_NULL, 0, 1},
1045 }; /* The expected number of asns in the current template is 1. */
1046 BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
1047 BSL_ASN1_Buffer asnArr[] = {{BSL_ASN1_TAG_INTEGER, 0, NULL}};
1048 BSL_ASN1_Buffer out = {0};
1049
1050 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, 1, &out), BSL_ASN1_ERR_TAG_EXPECTED);
1051 EXIT:
1052 return;
1053 }
1054 /* END_CASE */
1055
1056 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_LIST_ERROR_TC002(void)1057 void SDV_BSL_ASN1_ENCODE_LIST_ERROR_TC002(void)
1058 {
1059 BSL_ASN1_TemplateItem item[] = {
1060 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
1061 {BSL_ASN1_TAG_NULL, 0, 1},
1062 {BSL_ASN1_TAG_NULL, 0, 1},
1063 }; /* The expected number of asns in the current template is 2. */
1064 BSL_ASN1_Template templ = {item, sizeof(item) / sizeof(item[0])};
1065 BSL_ASN1_Buffer asnArr[] = {
1066 {BSL_ASN1_TAG_NULL, 0, NULL},
1067 {BSL_ASN1_TAG_NULL, 0, NULL},
1068 {BSL_ASN1_TAG_NULL, 0, NULL},
1069 };
1070 uint32_t arrNum = sizeof(asnArr) / sizeof(asnArr[0]);
1071 BSL_ASN1_Buffer out = {0};
1072
1073 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, 1, &out), BSL_ASN1_ERR_ENCODE_ASN_LACK);
1074
1075 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, asnArr, arrNum, &out),
1076 BSL_ASN1_ERR_ENCODE_ASN_TOO_MUCH);
1077 EXIT:
1078 return;
1079 }
1080 /* END_CASE */
1081
1082 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_LIST_ERROR_TC003(int tag,int ret)1083 void SDV_BSL_ASN1_ENCODE_LIST_ERROR_TC003(int tag, int ret)
1084 {
1085 BSL_ASN1_TemplateItem item[] = {{tag, 0, 0}};
1086 BSL_ASN1_Template templ = {item, 1};
1087 uint8_t data = 1;
1088 BSL_ASN1_Buffer asn = {tag, 1, &data};
1089 BSL_ASN1_Buffer out = {0};
1090
1091 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SET, 1, &templ, &asn, 1, &out), ret);
1092 EXIT:
1093 return;
1094 }
1095 /* END_CASE */
1096
1097 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_LIST_TC001(int listSize,Hex * encode)1098 void SDV_BSL_ASN1_ENCODE_LIST_TC001(int listSize, Hex *encode)
1099 {
1100 #ifndef HITLS_BSL_OBJ
1101 (void)listSize;
1102 (void)encode;
1103 SKIP_TEST();
1104 #else
1105 BSL_ASN1_TemplateItem x509Name[] = {
1106 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SET, 0, 0},
1107 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 1},
1108 {BSL_ASN1_TAG_OBJECT_ID, 0, 2},
1109 {BSL_ASN1_TAG_ANY, 0, 2}
1110 };
1111 BSL_ASN1_Template templ = {x509Name, sizeof(x509Name) / sizeof(x509Name[0])};
1112 BslOidString *o = BSL_OBJ_GetOID(BSL_CID_AT_ORGANIZATIONNAME);
1113 char *oName = "Energy TEST";
1114 BslOidString *cn = BSL_OBJ_GetOID(BSL_CID_AT_COMMONNAME);
1115 char *cnName = "Energy ECC Equipment Root CA 1";
1116 BSL_ASN1_Buffer in[] = {
1117 {BSL_ASN1_TAG_OBJECT_ID, o->octetLen, (uint8_t *)o->octs},
1118 {BSL_ASN1_TAG_PRINTABLESTRING, strlen(oName), (uint8_t *)oName},
1119 {BSL_ASN1_TAG_OBJECT_ID, cn->octetLen, (uint8_t *)cn->octs},
1120 {BSL_ASN1_TAG_PRINTABLESTRING, strlen(cnName), (uint8_t *)cnName},
1121 };
1122 BSL_ASN1_Buffer out = {0};
1123
1124 ASSERT_EQ(BSL_ASN1_EncodeListItem(BSL_ASN1_TAG_SEQUENCE, listSize, &templ, in, sizeof(in) / sizeof(in[0]), &out),
1125 BSL_SUCCESS);
1126 ASSERT_EQ(encode->len, out.len);
1127 ASSERT_COMPARE("Encode list", encode->x, encode->len, out.buff, out.len);
1128 EXIT:
1129 BSL_SAL_FREE(out.buff);
1130 #endif
1131 }
1132 /* END_CASE */
1133
1134 /* BEGIN_CASE */
SDV_BSL_ASN1_DECODE_THEN_ENCODE_FUNC_TC001(int testIdx,char * path)1135 void SDV_BSL_ASN1_DECODE_THEN_ENCODE_FUNC_TC001(int testIdx, char *path)
1136 {
1137 #ifndef HITLS_BSL_SAL_FILE
1138 (void)testIdx;
1139 (void)path;
1140 SKIP_TEST();
1141 #else
1142 BSL_ASN1_Template templ = {g_tests[testIdx].items, g_tests[testIdx].itemNum};
1143 uint32_t asnNum = g_tests[testIdx].asnNum;
1144 uint8_t *rawData = NULL;
1145 uint32_t dataLen = 0;
1146 uint8_t *encode = NULL;
1147 uint32_t encodeLen = 0;
1148
1149 BSL_ASN1_Buffer *decodeAsns = (BSL_ASN1_Buffer *)BSL_SAL_Calloc(asnNum, sizeof(BSL_ASN1_Buffer));
1150 ASSERT_TRUE(decodeAsns != NULL);
1151
1152 /* Decode */
1153 ASSERT_EQ(BSL_SAL_ReadFile(path, &rawData, &dataLen), BSL_SUCCESS);
1154 uint8_t *decode = rawData;
1155 uint32_t decodeLen = dataLen;
1156 ASSERT_EQ(BSL_ASN1_DecodeTemplate(&templ, NULL, &decode, &decodeLen, decodeAsns, asnNum),
1157 BSL_SUCCESS);
1158 ASSERT_EQ(decodeLen, 0);
1159
1160 /* Encode */
1161 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, decodeAsns, asnNum, &encode, &encodeLen), BSL_SUCCESS);
1162 ASSERT_EQ(encodeLen, dataLen);
1163 ASSERT_COMPARE("Decode then encode", rawData, dataLen, encode, encodeLen);
1164 EXIT:
1165 BSL_SAL_Free(decodeAsns);
1166 BSL_SAL_Free(rawData);
1167 BSL_SAL_Free(encode);
1168 #endif
1169 }
1170 /* END_CASE */
1171
1172 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_THEN_DECODE_FUNC_TC001(int boolData,int number,Hex * bitString,int unusedBits,Hex * utf8,int year,int month,int day,int hour,int minute,int second,Hex * headonly,Hex * expect)1173 void SDV_BSL_ASN1_ENCODE_THEN_DECODE_FUNC_TC001(int boolData, int number, Hex *bitString, int unusedBits, Hex *utf8,
1174 int year, int month, int day, int hour, int minute, int second, Hex *headonly, Hex *expect)
1175 {
1176 bool bData = (bool)boolData;
1177 BSL_ASN1_TemplateItem items[] = {
1178 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, 0, 0},
1179 {BSL_ASN1_TAG_BOOLEAN, 0, 1},
1180 {BSL_ASN1_TAG_INTEGER, 0, 1},
1181 {BSL_ASN1_TAG_BITSTRING, 0, 1},
1182 {BSL_ASN1_TAG_NULL, BSL_ASN1_FLAG_OPTIONAL, 1},
1183 {BSL_ASN1_TAG_UTF8STRING, 0, 1},
1184 {BSL_ASN1_TAG_UTCTIME, 0, 1},
1185 {BSL_ASN1_TAG_UTCTIME, BSL_ASN1_FLAG_OPTIONAL, 1},
1186 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, BSL_ASN1_FLAG_HEADERONLY, 1},
1187 {BSL_ASN1_TAG_NULL, 0, 2},
1188 };
1189 BSL_ASN1_Buffer integer = {0};
1190 ASSERT_EQ(BSL_ASN1_EncodeLimb(BSL_ASN1_TAG_INTEGER, number, &integer), BSL_SUCCESS);
1191 BSL_ASN1_BitString bs = {bitString->x, bitString->len, unusedBits};
1192 BSL_TIME time = {year, month, day, hour, minute, 0, second, 0};
1193 BSL_ASN1_Buffer asns[] = {
1194 {BSL_ASN1_TAG_BOOLEAN, sizeof(bool), (uint8_t *)&bData}, // 0
1195 integer, // 1
1196 {BSL_ASN1_TAG_BITSTRING, sizeof(BSL_ASN1_BitString), (uint8_t *)&bs}, // 2
1197 {BSL_ASN1_TAG_NULL, 0, NULL}, // 3
1198 {BSL_ASN1_TAG_UTF8STRING, utf8->len, utf8->x}, // 4
1199 {BSL_ASN1_TAG_UTCTIME, sizeof(BSL_TIME), (uint8_t *)&time}, // 5
1200 {BSL_ASN1_TAG_UTCTIME, 0, NULL}, // 6
1201 {BSL_ASN1_TAG_CONSTRUCTED | BSL_ASN1_TAG_SEQUENCE, headonly->len, headonly->x}, // 7
1202 };
1203 uint32_t asnNum = sizeof(asns) / sizeof(asns[0]);
1204 BSL_ASN1_Template templ = {items, sizeof(items) / sizeof(items[0])};
1205 uint8_t *encode = NULL;
1206 uint32_t encodeLen = 0;
1207
1208 ASSERT_EQ(BSL_ASN1_EncodeTemplate(&templ, asns, asnNum, &encode, &encodeLen), BSL_SUCCESS);
1209 ASSERT_EQ(encodeLen, expect->len);
1210 ASSERT_COMPARE("Encode", expect->x, expect->len, encode, encodeLen);
1211
1212 uint8_t *tmp = encode;
1213 uint32_t tmpLen = encodeLen;
1214 BSL_ASN1_Buffer decAns[8] = {0}; // 8 is asnNum
1215 ASSERT_EQ(BSL_ASN1_DecodeTemplate(&templ, NULL, &tmp, &tmpLen, decAns, asnNum), BSL_SUCCESS);
1216 ASSERT_EQ(tmpLen, 0);
1217
1218 bool bRes;
1219 ASSERT_EQ(BSL_ASN1_DecodePrimitiveItem(decAns + 0, &bRes), BSL_SUCCESS); // Check the decoded data with index 0.
1220 ASSERT_EQ(bRes, boolData);
1221
1222 int iRes;
1223 ASSERT_EQ(BSL_ASN1_DecodePrimitiveItem(decAns + 1, &iRes), BSL_SUCCESS); // Check the decoded data with index 1.
1224 ASSERT_EQ(iRes, number);
1225
1226 BSL_ASN1_BitString bs2 = {0};
1227 ASSERT_EQ(BSL_ASN1_DecodePrimitiveItem(decAns + 2, &bs2), BSL_SUCCESS); // Check the decoded data with index 2.
1228 ASSERT_EQ(bs.unusedBits, unusedBits);
1229
1230 BSL_TIME time2 = {0};
1231 ASSERT_EQ(BSL_ASN1_DecodePrimitiveItem(decAns + 5, &time2), BSL_SUCCESS); // Check the decoded data with index 5.
1232 ASSERT_EQ(time2.year, year);
1233 ASSERT_EQ(time2.month, month);
1234 ASSERT_EQ(time2.day, day);
1235 ASSERT_EQ(time2.hour, hour);
1236 ASSERT_EQ(time2.minute, minute);
1237 ASSERT_EQ(time2.second, second);
1238
1239 EXIT:
1240 BSL_SAL_Free(integer.buff);
1241 BSL_SAL_Free(encode);
1242 }
1243 /* END_CASE */
1244
1245 /**
1246 * For test bmpString.
1247 */
1248 /* BEGIN_CASE */
SDV_BSL_ASN1_ENCODE_BMPSTRING_TC001(Hex * enc,char * dec)1249 void SDV_BSL_ASN1_ENCODE_BMPSTRING_TC001(Hex *enc, char *dec)
1250 {
1251 int32_t ret;
1252 BSL_ASN1_Buffer asn = {BSL_ASN1_TAG_BMPSTRING, enc->len, enc->x};
1253 BSL_ASN1_Buffer decode = {BSL_ASN1_TAG_BMPSTRING, 0, NULL};
1254 BSL_ASN1_Buffer encode = {0};
1255 uint8_t tmp[10] = {0xff}; // select len 10.
1256 BSL_ASN1_Buffer wrong = {BSL_ASN1_TAG_BMPSTRING, 10, tmp};
1257
1258 TestMemInit();
1259 ret = BSL_ASN1_DecodePrimitiveItem(&asn, &decode);
1260 ASSERT_EQ(ret, BSL_SUCCESS);
1261 uint32_t decLen = (uint32_t)strlen(dec);
1262 ASSERT_COMPARE("Decode String", decode.buff, decode.len, dec, decLen);
1263
1264 BSL_ASN1_TemplateItem testTempl[] = {
1265 {BSL_ASN1_TAG_BMPSTRING, 0, 0}
1266 };
1267 BSL_ASN1_Template templ = {testTempl, sizeof(testTempl) / sizeof(testTempl[0])};
1268 ret = BSL_ASN1_EncodeTemplate(&templ, &decode, 1, &encode.buff, &encode.len);
1269 ASSERT_EQ(ret, BSL_SUCCESS);
1270 ASSERT_COMPARE("Encode String", encode.buff + 2, encode.len - 2, enc->x, enc->len); // skip 2 bytes header
1271
1272 BSL_SAL_FREE(encode.buff);
1273 ret = BSL_ASN1_EncodeTemplate(&templ, &wrong, 1, &encode.buff, &encode.len);
1274 ASSERT_EQ(ret, BSL_INVALID_ARG);
1275 EXIT:
1276 BSL_SAL_FREE(decode.buff);
1277 BSL_SAL_FREE(encode.buff);
1278 return;
1279 }
1280 /* END_CASE */
1281
1282 /**
1283 * @test SDV_BSL_ASN1_GET_ENCODE_LEN_FUNC_TC001
1284 * @title Test BSL_ASN1_GetEncodeLen function
1285 */
1286 /* BEGIN_CASE */
SDV_BSL_ASN1_GET_ENCODE_LEN_FUNC_TC001(int contentLen,int expectLen,int ret)1287 void SDV_BSL_ASN1_GET_ENCODE_LEN_FUNC_TC001(int contentLen, int expectLen, int ret)
1288 {
1289 uint32_t encodeLen = 0;
1290 ASSERT_EQ(BSL_ASN1_GetEncodeLen(contentLen, &encodeLen), ret);
1291 if (ret == BSL_SUCCESS) {
1292 ASSERT_EQ(encodeLen, expectLen);
1293 }
1294 EXIT:
1295 return;
1296 }
1297 /* END_CASE */
1298
1299 /**
1300 * @test SDV_BSL_ASN1_GET_ENCODE_LEN_API_TC001
1301 * @title Test BSL_ASN1_GetEncodeLen abnormal input parameter
1302 */
1303 /* BEGIN_CASE */
SDV_BSL_ASN1_GET_ENCODE_LEN_API_TC001(void)1304 void SDV_BSL_ASN1_GET_ENCODE_LEN_API_TC001(void)
1305 {
1306 uint32_t encodeLen = 0;
1307 // Test null pointer
1308 ASSERT_EQ(BSL_ASN1_GetEncodeLen(1, NULL), BSL_NULL_INPUT);
1309
1310 // Test length overflow
1311 ASSERT_EQ(BSL_ASN1_GetEncodeLen(UINT32_MAX, &encodeLen), BSL_ASN1_ERR_LEN_OVERFLOW);
1312 EXIT:
1313 return;
1314 }
1315 /* END_CASE */
1316