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 "crypt_encode_decode_key.h"
18 #include "crypt_encode_internal.h"
19 #include "crypt_sm2.h"
20 #include "crypt_bn.h"
21 #include "crypt_errno.h"
22
23 #define MAX_ENCODE_LEN 1024
24 #define SM2_POINT_COORDINATE_LEN 65
25 #define SM2_POINT_SINGLE_COORDINATE_LEN 32
26 #define SM3_MD_SIZE 32
27 #define MAX_BN_BITS 2048
28 #define BITS_IN_A_BYTE 8
29
30 /* END_HEADER */
31
32 /**
33 * @test SDV_ENCODE_SIGN_BN_FUNC_TC001
34 * @title Test CRYPT_EAL_EncodeSign normal encode function
35 */
36 /* BEGIN_CASE */
SDV_ENCODE_SIGN_BN_FUNC_TC001(Hex * r,Hex * s,Hex * expect)37 void SDV_ENCODE_SIGN_BN_FUNC_TC001(Hex *r, Hex *s, Hex *expect)
38 {
39 uint8_t encode[MAX_ENCODE_LEN] = {0};
40 uint32_t encodeLen = sizeof(encode);
41 BN_BigNum *bnR = NULL;
42 BN_BigNum *bnS = NULL;
43
44 ASSERT_TRUE((bnR = BN_Create(MAX_BN_BITS)) != NULL);
45 ASSERT_TRUE((bnS = BN_Create(MAX_BN_BITS)) != NULL);
46
47 ASSERT_TRUE(r->len * BITS_IN_A_BYTE <= MAX_BN_BITS);
48 ASSERT_TRUE(s->len * BITS_IN_A_BYTE <= MAX_BN_BITS);
49
50 ASSERT_EQ(BN_Bin2Bn(bnR, r->x, r->len), CRYPT_SUCCESS);
51 ASSERT_EQ(BN_SetSign(bnR, false), CRYPT_SUCCESS);
52
53 ASSERT_EQ(BN_Bin2Bn(bnS, s->x, s->len), CRYPT_SUCCESS);
54 ASSERT_EQ(BN_SetSign(bnS, false), CRYPT_SUCCESS);
55
56 ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_SUCCESS);
57 ASSERT_EQ(encodeLen, expect->len);
58 ASSERT_TRUE(memcmp(encode, expect->x, expect->len) == 0);
59
60 EXIT:
61 BN_Destroy(bnR);
62 BN_Destroy(bnS);
63 }
64 /* END_CASE */
65
66 /**
67 * @test SDV_ENCODE_SIGN_BN_API_TC001
68 * @title Test CRYPT_EAL_EncodeSign abnormal input parameter
69 */
70 /* BEGIN_CASE */
SDV_ENCODE_SIGN_BN_API_TC001(Hex * r,Hex * s)71 void SDV_ENCODE_SIGN_BN_API_TC001(Hex *r, Hex *s)
72 {
73 uint8_t encode[MAX_ENCODE_LEN] = {0};
74 uint32_t encodeLen = sizeof(encode);
75 BN_BigNum *bnR = NULL;
76 BN_BigNum *bnS = NULL;
77
78 ASSERT_TRUE((bnR = BN_Create(MAX_BN_BITS)) != NULL);
79 ASSERT_TRUE((bnS = BN_Create(MAX_BN_BITS)) != NULL);
80
81 // Test big number is zero
82 ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_INVALID_ARG);
83 ASSERT_TRUE(BN_Bin2Bn(bnR, r->x, r->len) == CRYPT_SUCCESS);
84 ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_INVALID_ARG);
85 ASSERT_TRUE(BN_Bin2Bn(bnS, s->x, s->len) == CRYPT_SUCCESS);
86
87 // Test null pointer
88 ASSERT_EQ(CRYPT_EAL_EncodeSign(NULL, bnS, encode, &encodeLen), CRYPT_NULL_INPUT);
89 ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, NULL, encode, &encodeLen), CRYPT_NULL_INPUT);
90 ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, NULL, &encodeLen), CRYPT_NULL_INPUT);
91 ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, NULL), CRYPT_NULL_INPUT);
92
93 // Test big number is negative
94 ASSERT_EQ(BN_SetSign(bnR, true), CRYPT_SUCCESS);
95 ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_INVALID_ARG);
96 ASSERT_EQ(BN_SetSign(bnR, false), CRYPT_SUCCESS);
97 ASSERT_EQ(BN_SetSign(bnS, true), CRYPT_SUCCESS);
98 ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_INVALID_ARG);
99 ASSERT_EQ(BN_SetSign(bnS, false), CRYPT_SUCCESS);
100
101 // Test buffer length is not enough
102 encodeLen = 1;
103 ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_ENCODE_BUFF_NOT_ENOUGH);
104
105 EXIT:
106 BN_Destroy(bnR);
107 BN_Destroy(bnS);
108 }
109 /* END_CASE */
110
111 /**
112 * @test SDV_DECODE_SIGN_BN_FUNC_TC001
113 * @title Test CRYPT_EAL_DecodeSign normal decode function
114 */
115 /* BEGIN_CASE */
SDV_DECODE_SIGN_BN_FUNC_TC001(Hex * encode,Hex * expectR,Hex * expectS,int ret)116 void SDV_DECODE_SIGN_BN_FUNC_TC001(Hex *encode, Hex *expectR, Hex *expectS, int ret)
117 {
118 BN_BigNum *bnR = NULL;
119 BN_BigNum *bnS = NULL;
120 uint8_t rBuf[MAX_ENCODE_LEN] = {0};
121 uint8_t sBuf[MAX_ENCODE_LEN] = {0};
122 uint32_t rLen = sizeof(rBuf);
123 uint32_t sLen = sizeof(sBuf);
124
125 ASSERT_TRUE((bnR = BN_Create(MAX_BN_BITS)) != NULL);
126 ASSERT_TRUE((bnS = BN_Create(MAX_BN_BITS)) != NULL);
127
128 ASSERT_EQ(CRYPT_EAL_DecodeSign(encode->x, encode->len, bnR, bnS), ret);
129
130 if (ret == CRYPT_SUCCESS) {
131 ASSERT_TRUE(!BN_IsNegative(bnR));
132 ASSERT_TRUE(!BN_IsNegative(bnS));
133 ASSERT_EQ(BN_Bn2Bin(bnR, rBuf, &rLen), CRYPT_SUCCESS);
134 ASSERT_EQ(BN_Bn2Bin(bnS, sBuf, &sLen), CRYPT_SUCCESS);
135
136 ASSERT_EQ(rLen, expectR->len);
137 ASSERT_EQ(sLen, expectS->len);
138 ASSERT_TRUE(memcmp(rBuf, expectR->x, rLen) == 0);
139 ASSERT_TRUE(memcmp(sBuf, expectS->x, sLen) == 0);
140 }
141
142 EXIT:
143 BN_Destroy(bnR);
144 BN_Destroy(bnS);
145 }
146 /* END_CASE */
147
148 /**
149 * @test SDV_DECODE_SIGN_BN_API_TC001
150 * @title Test CRYPT_EAL_DecodeSign abnormal input parameter
151 */
152 /* BEGIN_CASE */
SDV_DECODE_SIGN_BN_API_TC001(Hex * encode)153 void SDV_DECODE_SIGN_BN_API_TC001(Hex *encode)
154 {
155 BN_BigNum *bnR = NULL;
156 BN_BigNum *bnS = NULL;
157
158 ASSERT_TRUE((bnR = BN_Create(MAX_BN_BITS)) != NULL);
159 ASSERT_TRUE((bnS = BN_Create(MAX_BN_BITS)) != NULL);
160
161 // Test null pointer
162 ASSERT_EQ(CRYPT_EAL_DecodeSign(NULL, encode->len, bnR, bnS), CRYPT_NULL_INPUT);
163 ASSERT_EQ(CRYPT_EAL_DecodeSign(encode->x, 0, bnR, bnS), CRYPT_NULL_INPUT);
164 ASSERT_EQ(CRYPT_EAL_DecodeSign(encode->x, encode->len, NULL, bnS), CRYPT_NULL_INPUT);
165 ASSERT_EQ(CRYPT_EAL_DecodeSign(encode->x, encode->len, bnR, NULL), CRYPT_NULL_INPUT);
166
167 EXIT:
168 BN_Destroy(bnR);
169 BN_Destroy(bnS);
170 }
171 /* END_CASE */
172
173 /**
174 * @test SDV_ENCODE_SM2_ENCRYPT_DATA_FUNC_TC001
175 * @title Test CRYPT_EAL_EncodeSm2EncryptData normal encode function
176 */
177 /* BEGIN_CASE */
SDV_ENCODE_SM2_ENCRYPT_DATA_FUNC_TC001(Hex * x,Hex * y,Hex * hash,Hex * cipher,Hex * expect,int ret)178 void SDV_ENCODE_SM2_ENCRYPT_DATA_FUNC_TC001(Hex *x, Hex *y, Hex *hash, Hex *cipher, Hex *expect, int ret)
179 {
180 uint8_t encode[MAX_ENCODE_LEN] = {0};
181 uint32_t encodeLen = sizeof(encode);
182 CRYPT_SM2_EncryptData data = {
183 .x = x->x, .xLen = x->len,
184 .y = y->x, .yLen = y->len,
185 .hash = hash->x, .hashLen = hash->len,
186 .cipher = cipher->x, .cipherLen = cipher->len
187 };
188
189 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), ret);
190 if (ret == CRYPT_SUCCESS) {
191 ASSERT_EQ(encodeLen, expect->len);
192 ASSERT_TRUE(memcmp(encode, expect->x, expect->len) == 0);
193 }
194
195 EXIT:
196 return;
197 }
198 /* END_CASE */
199
200 /**
201 * @test SDV_ENCODE_SM2_ENCRYPT_DATA_API_TC001
202 * @title Test CRYPT_EAL_EncodeSm2EncryptData abnormal input parameter
203 */
204 /* BEGIN_CASE */
SDV_ENCODE_SM2_ENCRYPT_DATA_API_TC001(Hex * x,Hex * y,Hex * hash,Hex * cipher)205 void SDV_ENCODE_SM2_ENCRYPT_DATA_API_TC001(Hex *x, Hex *y, Hex *hash, Hex *cipher)
206 {
207 uint8_t encode[MAX_ENCODE_LEN] = {0};
208 uint32_t encodeLen = sizeof(encode);
209 CRYPT_SM2_EncryptData data = {
210 .x = x->x, .xLen = x->len,
211 .y = y->x, .yLen = y->len,
212 .hash = hash->x, .hashLen = hash->len,
213 .cipher = cipher->x, .cipherLen = cipher->len
214 };
215
216 // Test null pointer
217 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(NULL, encode, &encodeLen), CRYPT_NULL_INPUT);
218 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, NULL, &encodeLen), CRYPT_NULL_INPUT);
219 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, NULL), CRYPT_NULL_INPUT);
220
221 // Test invalid x
222 data.x = NULL;
223 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
224 data.x = x->x;
225 data.xLen = 0;
226 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
227 data.xLen = x->len;
228 // Test invalid y
229 data.y = NULL;
230 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
231 data.y = y->x;
232 data.yLen = 0;
233 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
234 data.yLen = y->len;
235
236 // Test invalid hash
237 data.hash = NULL;
238 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
239 data.hash = hash->x;
240 data.hashLen = 0;
241 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
242 data.hashLen = hash->len;
243
244 // Test invalid cipher
245 data.cipher = NULL;
246 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
247 data.cipher = cipher->x;
248 data.cipherLen = 0;
249 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_INVALID_ARG);
250 data.cipherLen = cipher->len;
251
252 // Test buffer length is not enough
253 data.xLen = x->len;
254 encodeLen = 1;
255 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_ENCODE_BUFF_NOT_ENOUGH);
256
257 EXIT:
258 return;
259 }
260 /* END_CASE */
261
262 /**
263 * @test SDV_DECODE_SM2_ENCRYPT_DATA_FUNC_TC001
264 * @title Test CRYPT_EAL_DecodeSm2EncryptData normal decode function
265 */
266 /* BEGIN_CASE */
SDV_DECODE_SM2_ENCRYPT_DATA_FUNC_TC001(Hex * encode,Hex * expectX,Hex * expectY,Hex * expectHash,Hex * expectCipher,int ret)267 void SDV_DECODE_SM2_ENCRYPT_DATA_FUNC_TC001(Hex *encode, Hex *expectX, Hex *expectY, Hex *expectHash, Hex *expectCipher,
268 int ret)
269 {
270 uint8_t decode[MAX_ENCODE_LEN] = {0};
271 CRYPT_SM2_EncryptData data = {
272 .x = decode,
273 .xLen = SM2_POINT_SINGLE_COORDINATE_LEN,
274 .y = decode + SM2_POINT_SINGLE_COORDINATE_LEN,
275 .yLen = SM2_POINT_SINGLE_COORDINATE_LEN,
276 .hash = decode + SM2_POINT_COORDINATE_LEN,
277 .hashLen = SM3_MD_SIZE,
278 .cipher = decode + SM2_POINT_COORDINATE_LEN + SM3_MD_SIZE,
279 .cipherLen = sizeof(decode) - SM2_POINT_COORDINATE_LEN - SM3_MD_SIZE
280 };
281
282 ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(encode->x, encode->len, &data), ret);
283
284 if (ret == CRYPT_SUCCESS) {
285 ASSERT_EQ(data.hashLen, expectHash->len);
286 ASSERT_EQ(data.cipherLen, expectCipher->len);
287 ASSERT_TRUE(memcmp(data.x + (data.xLen - expectX->len), expectX->x, expectX->len) == 0);
288 ASSERT_TRUE(memcmp(data.y + (data.yLen - expectY->len), expectY->x, expectY->len) == 0);
289 ASSERT_TRUE(memcmp(data.hash, expectHash->x, data.hashLen) == 0);
290 ASSERT_TRUE(memcmp(data.cipher, expectCipher->x, data.cipherLen) == 0);
291 }
292
293 EXIT:
294 return;
295 }
296 /* END_CASE */
297
298 /**
299 * @test SDV_DECODE_SM2_ENCRYPT_DATA_API_TC001
300 * @title Test CRYPT_EAL_DecodeSm2EncryptData abnormal input parameter
301 */
302 /* BEGIN_CASE */
SDV_DECODE_SM2_ENCRYPT_DATA_API_TC001(Hex * encode)303 void SDV_DECODE_SM2_ENCRYPT_DATA_API_TC001(Hex *encode)
304 {
305 uint8_t x;
306 uint8_t y;
307 uint8_t hash;
308 uint8_t cipher;
309 CRYPT_SM2_EncryptData data = {
310 .x = &x, .xLen = 1,
311 .y = &y, .yLen = 1,
312 .hash = &hash, .hashLen = 1,
313 .cipher = &cipher, .cipherLen = 1
314 };
315
316 // Test null pointer
317 ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(NULL, encode->len, &data), CRYPT_NULL_INPUT);
318 ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(encode->x, encode->len, NULL), CRYPT_NULL_INPUT);
319
320 // Test invlaid data
321 data.x = NULL;
322 ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(encode->x, encode->len, &data), CRYPT_INVALID_ARG);
323 data.x = &x;
324 data.xLen = 0;
325 ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(encode->x, encode->len, &data), CRYPT_INVALID_ARG);
326 data.xLen = 1;
327
328 // Test buffer length is not enough
329 ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(encode->x, encode->len, &data), CRYPT_DECODE_BUFF_NOT_ENOUGH);
330
331 EXIT:
332 return;
333 }
334 /* END_CASE */
335
336 /**
337 * @test SDV_ENCODE_GET_SIGN_LEN_API_TC001
338 * @title Test CRYPT_EAL_GetSignEncodeLen
339 */
340 /* BEGIN_CASE */
SDV_ENCODE_GET_SIGN_LEN_API_TC001(void)341 void SDV_ENCODE_GET_SIGN_LEN_API_TC001(void)
342 {
343 uint32_t maxLen = 0;
344 // Normal case test
345 ASSERT_EQ(CRYPT_SUCCESS, CRYPT_EAL_GetSignEncodeLen(32, 32, &maxLen));
346 ASSERT_EQ(72, maxLen); // (32 + 1(leading 0x00) + 1(len) + 1(tag)) * 2(r,s) + 1(tag) + 1(len) = 72
347
348 // Invalid parameter test
349 ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(0, 32, &maxLen), CRYPT_INVALID_ARG);
350 ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(32, 0, &maxLen), CRYPT_INVALID_ARG);
351 ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(32, 32, NULL), CRYPT_INVALID_ARG);
352
353 // Overflow test
354 ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(UINT32_MAX, 32, &maxLen), CRYPT_INVALID_ARG);
355 ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(32, UINT32_MAX, &maxLen), CRYPT_INVALID_ARG);
356 ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(UINT32_MAX - 1, 32, &maxLen), BSL_ASN1_ERR_LEN_OVERFLOW);
357 ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(32, UINT32_MAX - 1, &maxLen), BSL_ASN1_ERR_LEN_OVERFLOW);
358
359 // 1(tag) + 1(len) + 1(integer)
360 // Indefinite form: 1(tag) + 1 + 1(lenNum) + 1(len)
361 ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(1, UINT32_MAX - (1 + 1 + 1) - (1 + 1 + 4), &maxLen),
362 CRYPT_ENCODE_ERR_SIGN_LEN_OVERFLOW);
363
364 EXIT:
365 return;
366 }
367 /* END_CASE */
368
369 /**
370 * @test SDV_ENCODE_GET_SM2_ENC_LEN_API_TC001
371 * @title Test CRYPT_EAL_GetSm2EncryptDataEncodeLen
372 */
373 /* BEGIN_CASE */
SDV_ENCODE_GET_SM2_ENC_LEN_API_TC001(void)374 void SDV_ENCODE_GET_SM2_ENC_LEN_API_TC001(void)
375 {
376 uint32_t encodeLen = 0;
377 // Normal case test
378 ASSERT_EQ(CRYPT_EAL_GetSm2EncryptDataEncodeLen(32, 32, 32, 64, &encodeLen), CRYPT_SUCCESS);
379 ASSERT_EQ(encodeLen, 173); // (32 + 1 + 1 + 1) * 2 + (32+1+1) + (64+1+1) + 2(length > 127) + 1 = 173
380
381 // Minimum valid input test
382 ASSERT_EQ(CRYPT_EAL_GetSm2EncryptDataEncodeLen(1, 1, 1, 1, &encodeLen), CRYPT_SUCCESS);
383 ASSERT_EQ(encodeLen, 16); // (1 + 1 + 1 + 1) * 2 + (1+1+1) + (1+1+1) + 1 + 1 = 16
384
385 // Invalid parameter test
386 ASSERT_EQ(CRYPT_INVALID_ARG, CRYPT_EAL_GetSm2EncryptDataEncodeLen(32, 32, 32, 32, NULL));
387
388 // Overflow test
389 ASSERT_EQ(CRYPT_EAL_GetSm2EncryptDataEncodeLen(UINT32_MAX - 1, UINT32_MAX - 1, 32, 32, &encodeLen),
390 BSL_ASN1_ERR_LEN_OVERFLOW);
391
392 ASSERT_EQ(CRYPT_EAL_GetSm2EncryptDataEncodeLen(1000, 1000, UINT32_MAX - 2000, 32, &encodeLen),
393 CRYPT_ENCODE_ERR_SM2_ENCRYPT_DATA_LEN_OVERFLOW);
394
395 ASSERT_EQ(CRYPT_EAL_GetSm2EncryptDataEncodeLen(1000, 1000, 1000, UINT32_MAX - 3000, &encodeLen),
396 CRYPT_ENCODE_ERR_SM2_ENCRYPT_DATA_LEN_OVERFLOW);
397
398 EXIT:
399 return;
400 }
401 /* END_CASE */
402
403 /**
404 * @test SDV_ENCODE_DECODE_SIGN_COMBO_TC001
405 * @title Test combined encode and decode for signature
406 */
407 /* BEGIN_CASE */
SDV_ENCODE_DECODE_SIGN_COMBO_TC001(Hex * r,Hex * s)408 void SDV_ENCODE_DECODE_SIGN_COMBO_TC001(Hex *r, Hex *s)
409 {
410 uint32_t maxLen = 0;
411 uint8_t *encode = NULL;
412 BN_BigNum *bnR = NULL;
413 BN_BigNum *bnS = NULL;
414 BN_BigNum *decR = NULL;
415 BN_BigNum *decS = NULL;
416 uint8_t rBuf[MAX_ENCODE_LEN] = {0};
417 uint8_t sBuf[MAX_ENCODE_LEN] = {0};
418 uint32_t rLen = sizeof(rBuf);
419 uint32_t sLen = sizeof(sBuf);
420
421 // Create big numbers
422 ASSERT_TRUE((bnR = BN_Create(MAX_BN_BITS)) != NULL);
423 ASSERT_TRUE((bnS = BN_Create(MAX_BN_BITS)) != NULL);
424 ASSERT_TRUE((decR = BN_Create(MAX_BN_BITS)) != NULL);
425 ASSERT_TRUE((decS = BN_Create(MAX_BN_BITS)) != NULL);
426
427 // Convert input hex to big numbers
428 ASSERT_TRUE(r->len * BITS_IN_A_BYTE <= MAX_BN_BITS);
429 ASSERT_TRUE(s->len * BITS_IN_A_BYTE <= MAX_BN_BITS);
430 ASSERT_EQ(BN_Bin2Bn(bnR, r->x, r->len), CRYPT_SUCCESS);
431 ASSERT_EQ(BN_SetSign(bnR, false), CRYPT_SUCCESS);
432 ASSERT_EQ(BN_Bin2Bn(bnS, s->x, s->len), CRYPT_SUCCESS);
433 ASSERT_EQ(BN_SetSign(bnS, false), CRYPT_SUCCESS);
434
435 // Get encode length and allocate buffer
436 ASSERT_EQ(CRYPT_EAL_GetSignEncodeLen(r->len, s->len, &maxLen), CRYPT_SUCCESS);
437 ASSERT_TRUE((encode = (uint8_t *)BSL_SAL_Malloc(maxLen)) != NULL);
438
439 // Encode signature
440 uint32_t encodeLen = maxLen;
441 ASSERT_EQ(CRYPT_EAL_EncodeSign(bnR, bnS, encode, &encodeLen), CRYPT_SUCCESS);
442
443 // Decode signature
444 ASSERT_EQ(CRYPT_EAL_DecodeSign(encode, encodeLen, decR, decS), CRYPT_SUCCESS);
445
446 // Convert decoded big numbers back to binary and compare
447 ASSERT_EQ(BN_Bn2Bin(decR, rBuf, &rLen), CRYPT_SUCCESS);
448 ASSERT_EQ(BN_Bn2Bin(decS, sBuf, &sLen), CRYPT_SUCCESS);
449 ASSERT_COMPARE("Compare r", rBuf, rLen, r->x, r->len);
450 ASSERT_COMPARE("Compare s", sBuf, sLen, s->x, s->len);
451
452 EXIT:
453 BSL_SAL_Free(encode);
454 BN_Destroy(bnR);
455 BN_Destroy(bnS);
456 BN_Destroy(decR);
457 BN_Destroy(decS);
458 }
459 /* END_CASE */
460
461 /**
462 * @test SDV_ENCODE_DECODE_SM2_ENCRYPT_COMBO_TC001
463 * @title Test combined encode and decode for SM2 encryption data
464 */
465 /* BEGIN_CASE */
SDV_ENCODE_DECODE_SM2_ENCRYPT_COMBO_TC001(Hex * x,Hex * y,Hex * hash,Hex * cipher)466 void SDV_ENCODE_DECODE_SM2_ENCRYPT_COMBO_TC001(Hex *x, Hex *y, Hex *hash, Hex *cipher)
467 {
468 uint32_t maxLen = 0;
469 uint8_t *encode = NULL;
470 uint8_t decBuf[MAX_ENCODE_LEN] = {0};
471
472 // Original data
473 CRYPT_SM2_EncryptData data = {
474 .x = x->x, .xLen = x->len,
475 .y = y->x, .yLen = y->len,
476 .hash = hash->x, .hashLen = hash->len,
477 .cipher = cipher->x, .cipherLen = cipher->len
478 };
479
480 // Prepare decode buffer
481 decBuf[0] = 0x04;
482 CRYPT_SM2_EncryptData decData = {
483 .x = decBuf + 1, .xLen = SM2_POINT_SINGLE_COORDINATE_LEN,
484 .y = decBuf + 1 + SM2_POINT_SINGLE_COORDINATE_LEN, .yLen = SM2_POINT_SINGLE_COORDINATE_LEN,
485 .hash = decBuf + SM2_POINT_COORDINATE_LEN, .hashLen = SM3_MD_SIZE,
486 .cipher = decBuf + SM2_POINT_COORDINATE_LEN + hash->len, .cipherLen = sizeof(decBuf) - SM3_MD_SIZE - SM2_POINT_COORDINATE_LEN
487 };
488
489 // Get encode length and allocate buffer
490 ASSERT_EQ(CRYPT_EAL_GetSm2EncryptDataEncodeLen(x->len, y->len, hash->len, cipher->len, &maxLen), CRYPT_SUCCESS);
491 ASSERT_TRUE((encode = (uint8_t *)BSL_SAL_Malloc(maxLen)) != NULL);
492
493 // Encode SM2 encryption data
494 uint32_t encodeLen = maxLen;
495 ASSERT_EQ(CRYPT_EAL_EncodeSm2EncryptData(&data, encode, &encodeLen), CRYPT_SUCCESS);
496
497 // Decode SM2 encryption data
498 ASSERT_EQ(CRYPT_EAL_DecodeSm2EncryptData(encode, encodeLen, &decData), CRYPT_SUCCESS);
499
500 // Compare decoded data with original data
501 ASSERT_COMPARE("Compare x", decData.x + (decData.xLen - x->len), x->len, x->x, x->len);
502 ASSERT_COMPARE("Compare y", decData.y + (decData.yLen - y->len), y->len, y->x, y->len);
503 ASSERT_COMPARE("Compare hash", decData.hash, decData.hashLen, hash->x, hash->len);
504 ASSERT_COMPARE("Compare cipher", decData.cipher, decData.cipherLen, cipher->x, cipher->len);
505
506 EXIT:
507 BSL_SAL_Free(encode);
508 }
509 /* END_CASE */
510