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 <stdlib.h>
19 #include <stdio.h>
20 #include <string.h>
21 #include "securec.h"
22 #include "hitls_build.h"
23 #include "bsl_err.h"
24 #include "bsl_sal.h"
25 #include "crypt_errno.h"
26 #include "crypt_eal_pkey.h"
27 #include "crypt_eal_rand.h"
28 #include "crypt_eal_md.h"
29 #include "crypt_util_rand.h"
30 /* END_HEADER */
31
32 static uint8_t gMlDsaRandBuf[3][32] = { 0 };
33 uint32_t gMlDsaRandNum = 0;
TEST_MLDSARandom(uint8_t * randNum,uint32_t randLen)34 static int32_t TEST_MLDSARandom(uint8_t *randNum, uint32_t randLen)
35 {
36 memcpy_s(randNum, randLen, gMlDsaRandBuf[gMlDsaRandNum], 32);
37 gMlDsaRandNum++;
38 return 0;
39 }
40
TEST_MLDSARandomEx(void * libCtx,uint8_t * randNum,uint32_t randLen)41 static int32_t TEST_MLDSARandomEx(void *libCtx, uint8_t *randNum, uint32_t randLen)
42 {
43 (void) libCtx;
44 return TEST_MLDSARandom(randNum, randLen);
45 }
46
47 /* @
48 * @test SDV_CRYPTO_MLDSA_API_TC001
49 * @spec -
50 * @title Test the MLDSA external interface.
51 * @precon nan
52 * @brief
53 * 1.Generate the context.
54 * 2.Call the copy and cmp interfaces.
55 * @expect
56 * 1.success
57 * 2.The result is same as expected.
58 * @prior nan
59 * @auto FALSE
60 @ */
61 /* BEGIN_CASE */
SDV_CRYPTO_MLDSA_API_TC001(int type,int setBits)62 void SDV_CRYPTO_MLDSA_API_TC001(int type, int setBits)
63 {
64 TestMemInit();
65 TestRandInit();
66 CRYPT_EAL_PkeyCtx *ctx1 = NULL;
67 CRYPT_EAL_PkeyCtx *ctx2 = NULL;
68 CRYPT_EAL_PkeyCtx *ctx3 = NULL;
69
70 #ifdef HITLS_CRYPTO_PROVIDER
71 ctx1 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
72 #else
73 ctx1 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
74 #endif
75 ASSERT_TRUE(ctx1 != NULL);
76 uint32_t val = (uint32_t)type;
77 int32_t ret = CRYPT_EAL_PkeyCtrl(ctx1, CRYPT_CTRL_SET_PARA_BY_ID, &val, sizeof(val));
78 ASSERT_EQ(ret, CRYPT_SUCCESS);
79 ret = CRYPT_EAL_PkeyGen(ctx1);
80 ASSERT_EQ(ret, CRYPT_SUCCESS);
81
82 #ifdef HITLS_CRYPTO_PROVIDER
83 ctx2 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
84 #else
85 ctx2 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
86 #endif
87 ASSERT_TRUE(ctx2 != NULL);
88 val = (uint32_t)type;
89 ret = CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_PARA_BY_ID, &val, sizeof(val));
90 ASSERT_EQ(ret, CRYPT_SUCCESS);
91 ret = CRYPT_EAL_PkeyGen(ctx2);
92 ASSERT_EQ(ret, CRYPT_SUCCESS);
93
94 ret = CRYPT_EAL_PkeyCmp(ctx1, ctx2);
95 ASSERT_NE(ret, CRYPT_SUCCESS);
96
97 ctx3 = CRYPT_EAL_PkeyDupCtx(ctx1);
98 ASSERT_TRUE(ctx3 != NULL);
99 ret = CRYPT_EAL_PkeyCmp(ctx1, ctx3);
100 ASSERT_EQ(ret, CRYPT_SUCCESS);
101
102 uint32_t secBits = CRYPT_EAL_PkeyGetSecurityBits(ctx1);
103 ASSERT_EQ(secBits, setBits);
104 EXIT:
105 CRYPT_EAL_PkeyFreeCtx(ctx1);
106 CRYPT_EAL_PkeyFreeCtx(ctx2);
107 CRYPT_EAL_PkeyFreeCtx(ctx3);
108 TestRandDeInit();
109 return;
110 }
111 /* END_CASE */
112
113 /* @
114 * @test SDV_CRYPTO_MLDSA_FUNC_KEYGEN_TC001
115 * @spec -
116 * @title Generate public and private key tests.
117 * @precon nan
118 * @brief
119 * 1.Registers a random number that returns the specified value.
120 * 2.Call the key generation interface.
121 * @expect
122 * 1.success
123 * 2.The public and private key is same as expected.
124 * @prior nan
125 * @auto FALSE
126 @ */
127 /* BEGIN_CASE */
SDV_CRYPTO_MLDSA_FUNC_KEYGEN_TC001(int type,Hex * d,Hex * testPubkey,Hex * testPrvKey)128 void SDV_CRYPTO_MLDSA_FUNC_KEYGEN_TC001(int type, Hex *d, Hex *testPubkey, Hex *testPrvKey)
129 {
130 TestMemInit();
131 gMlDsaRandNum = 0;
132 memcpy_s(gMlDsaRandBuf[0], 32, d->x, d->len);
133 CRYPT_RandRegist(TEST_MLDSARandom);
134 CRYPT_RandRegistEx(TEST_MLDSARandomEx);
135
136 CRYPT_EAL_PkeyPub pubKey = { 0 };
137 pubKey.id = CRYPT_PKEY_ML_DSA;
138 pubKey.key.mldsaPub.len = testPubkey->len;
139 pubKey.key.mldsaPub.data = BSL_SAL_Malloc(testPubkey->len);
140 ASSERT_TRUE(pubKey.key.mldsaPub.data != NULL);
141
142 CRYPT_EAL_PkeyPrv prvKey = { 0 };
143 prvKey.id = CRYPT_PKEY_ML_DSA;
144 prvKey.key.mldsaPrv.len = testPrvKey->len;
145 prvKey.key.mldsaPrv.data = BSL_SAL_Malloc(testPrvKey->len);
146 ASSERT_TRUE(prvKey.key.mldsaPrv.data != NULL);
147
148 CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
149 ASSERT_TRUE(ctx != NULL);
150 uint32_t val = (uint32_t)type;
151 int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
152 ASSERT_EQ(ret, CRYPT_SUCCESS);
153
154 pubKey.key.mldsaPub.len = testPubkey->len;
155 ret = CRYPT_EAL_PkeyGetPub(ctx, &pubKey);
156 ASSERT_EQ(ret, CRYPT_MLDSA_KEY_NOT_SET);
157
158 prvKey.key.mldsaPrv.len = testPrvKey->len;
159 ret = CRYPT_EAL_PkeyGetPrv(ctx, &prvKey);
160 ASSERT_EQ(ret, CRYPT_MLDSA_KEY_NOT_SET);
161
162 ret = CRYPT_EAL_PkeyGen(ctx);
163 ASSERT_EQ(ret, CRYPT_SUCCESS);
164
165 pubKey.key.mldsaPub.len = testPubkey->len - 1;
166 ret = CRYPT_EAL_PkeyGetPub(ctx, &pubKey);
167 ASSERT_EQ(ret, CRYPT_MLDSA_LEN_NOT_ENOUGH);
168
169 pubKey.key.mldsaPub.len = testPubkey->len;
170 ret = CRYPT_EAL_PkeyGetPub(ctx, &pubKey);
171 ASSERT_EQ(ret, CRYPT_SUCCESS);
172
173 prvKey.key.mldsaPrv.len = testPrvKey->len - 1;
174 ret = CRYPT_EAL_PkeyGetPrv(ctx, &prvKey);
175 ASSERT_EQ(ret, CRYPT_MLDSA_LEN_NOT_ENOUGH);
176
177 prvKey.key.mldsaPrv.len = testPrvKey->len;
178 ret = CRYPT_EAL_PkeyGetPrv(ctx, &prvKey);
179 ASSERT_EQ(ret, CRYPT_SUCCESS);
180
181 ASSERT_COMPARE("compare pubkey", pubKey.key.mldsaPub.data, pubKey.key.mldsaPub.len, testPubkey->x, testPubkey->len);
182 ASSERT_COMPARE("compare prvkey", prvKey.key.mldsaPrv.data, prvKey.key.mldsaPrv.len, testPrvKey->x, testPrvKey->len);
183 EXIT:
184 CRYPT_EAL_PkeyFreeCtx(ctx);
185 BSL_SAL_FREE(pubKey.key.mldsaPub.data);
186 BSL_SAL_FREE(prvKey.key.mldsaPrv.data);
187 return;
188 }
189 /* END_CASE */
190
191 /* @
192 * @test SDV_CRYPTO_MLDSA_FUNC_SIGNDATA_TC001
193 * @spec -
194 * @title Signature test.
195 * @precon nan
196 * @brief
197 * 1.Registers a random number that returns the specified value.
198 * 2.Set the private key.
199 * 3.Call the signature interface.
200 * @expect
201 * 1.success
202 * 2.success
203 * 3.The signature value is consistent with the test vector.
204 * @prior nan
205 * @auto FALSE
206 @ */
207 /* BEGIN_CASE */
SDV_CRYPTO_MLDSA_FUNC_SIGNDATA_TC001(int type,Hex * seed,Hex * testPrvKey,Hex * msg,Hex * sign)208 void SDV_CRYPTO_MLDSA_FUNC_SIGNDATA_TC001(int type, Hex *seed, Hex *testPrvKey, Hex *msg, Hex *sign)
209 {
210 TestMemInit();
211 gMlDsaRandNum = 0;
212 memcpy_s(gMlDsaRandBuf[0], 32, seed->x, seed->len);
213 CRYPT_RandRegist(TEST_MLDSARandom);
214 CRYPT_RandRegistEx(TEST_MLDSARandomEx);
215 CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
216 ASSERT_TRUE(ctx != NULL);
217 uint32_t val = (uint32_t)type;
218 int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
219 ASSERT_EQ(ret, CRYPT_SUCCESS);
220
221 val = 0;
222 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
223 ASSERT_EQ(ret, CRYPT_SUCCESS);
224
225 uint32_t outLen = CRYPT_EAL_PkeyGetSignLen(ctx);
226 ASSERT_EQ(outLen, sign->len);
227 uint8_t *out = BSL_SAL_Malloc(outLen);
228
229 CRYPT_EAL_PkeyPrv prvKey = { 0 };
230 prvKey.id = CRYPT_PKEY_ML_DSA;
231 prvKey.key.mldsaPrv.data = testPrvKey->x;
232 prvKey.key.mldsaPrv.len = testPrvKey->len - 1;
233 ret = CRYPT_EAL_PkeySetPrv(ctx, &prvKey);
234 ASSERT_EQ(ret, CRYPT_MLDSA_KEYLEN_ERROR);
235
236 prvKey.key.mldsaPrv.len = testPrvKey->len + 1;
237 ret = CRYPT_EAL_PkeySetPrv(ctx, &prvKey);
238 ASSERT_EQ(ret, CRYPT_MLDSA_KEYLEN_ERROR);
239
240 prvKey.key.mldsaPrv.len = testPrvKey->len;
241 ret = CRYPT_EAL_PkeySetPrv(ctx, &prvKey);
242 ASSERT_EQ(ret, CRYPT_SUCCESS);
243
244 ret = CRYPT_EAL_PkeySign(ctx, CRYPT_MD_MAX, msg->x, msg->len, out, &outLen);
245 ASSERT_EQ(ret, CRYPT_SUCCESS);
246 ASSERT_COMPARE("compare sign", out, outLen, sign->x, sign->len);
247 EXIT:
248 CRYPT_EAL_PkeyFreeCtx(ctx);
249 BSL_SAL_FREE(out);
250 CRYPT_RandRegist(NULL);
251 CRYPT_RandRegistEx(NULL);
252 return;
253 }
254 /* END_CASE */
255
256 /* @
257 * @test SDV_CRYPTO_MLDSA_FUNC_VERIFYDATA_TC001
258 * @spec -
259 * @title Verify test.
260 * @precon nan
261 * @brief
262 * 1.Set the public key.
263 * 2.Call the verify interface.
264 * @expect
265 * 1.success
266 * 2.The verify value is consistent with the test vector.
267 * @prior nan
268 * @auto FALSE
269 @ */
270 /* BEGIN_CASE */
SDV_CRYPTO_MLDSA_FUNC_VERIFYDATA_TC001(int type,Hex * testPubKey,Hex * msg,Hex * sign,int res)271 void SDV_CRYPTO_MLDSA_FUNC_VERIFYDATA_TC001(int type, Hex *testPubKey, Hex *msg, Hex *sign, int res)
272 {
273 TestMemInit();
274 CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
275 ASSERT_TRUE(ctx != NULL);
276 uint32_t val = (uint32_t)type;
277 int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
278 ASSERT_EQ(ret, CRYPT_SUCCESS);
279
280 val = 0;
281 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
282 ASSERT_EQ(ret, CRYPT_SUCCESS);
283
284 CRYPT_EAL_PkeyPub pubKey = { 0 };
285 pubKey.id = CRYPT_PKEY_ML_DSA;
286 pubKey.key.mldsaPub.data = testPubKey->x;
287
288 pubKey.key.mldsaPub.len = testPubKey->len - 1;
289 ret = CRYPT_EAL_PkeySetPub(ctx, &pubKey);
290 ASSERT_EQ(ret, CRYPT_MLDSA_KEYLEN_ERROR);
291
292 pubKey.key.mldsaPub.len = testPubKey->len + 1;
293 ret = CRYPT_EAL_PkeySetPub(ctx, &pubKey);
294 ASSERT_EQ(ret, CRYPT_MLDSA_KEYLEN_ERROR);
295
296 pubKey.key.mldsaPub.len = testPubKey->len;
297 ret = CRYPT_EAL_PkeySetPub(ctx, &pubKey);
298 ASSERT_EQ(ret, CRYPT_SUCCESS);
299
300 ret = CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_MAX, msg->x, msg->len, sign->x, sign->len);
301 if (res == 1) {
302 ASSERT_EQ(ret, CRYPT_SUCCESS);
303 } else {
304 ASSERT_NE(ret, CRYPT_SUCCESS);
305 }
306
307 EXIT:
308 CRYPT_EAL_PkeyFreeCtx(ctx);
309 return;
310 }
311 /* END_CASE */
312
313 /* @
314 * @test SDV_CRYPTO_MLDSA_FUNC_SIGNDATA_TC002
315 * @spec -
316 * @title Signature test.
317 * @precon nan
318 * @brief
319 * 1.Registers a random number that returns the specified value.
320 * 2.Set the private key and additional messages.
321 * 3.Call the signature interface.
322 * @expect
323 * 1.success
324 * 2.success
325 * 3.The signature value is consistent with the test vector.
326 * @prior nan
327 * @auto FALSE
328 @ */
329 /* BEGIN_CASE */
SDV_CRYPTO_MLDSA_FUNC_SIGNDATA_TC002(int type,Hex * seed,Hex * testPrvKey,Hex * msg,Hex * ctxText,Hex * sign,int deterministic,int externalMu,int encodeCtx)330 void SDV_CRYPTO_MLDSA_FUNC_SIGNDATA_TC002(int type, Hex *seed, Hex *testPrvKey, Hex *msg, Hex *ctxText,
331 Hex *sign, int deterministic, int externalMu, int encodeCtx)
332 {
333 TestMemInit();
334 gMlDsaRandNum = 0;
335 memcpy_s(gMlDsaRandBuf[0], 32, seed->x, seed->len);
336 CRYPT_RandRegist(TEST_MLDSARandom);
337 CRYPT_RandRegistEx(TEST_MLDSARandomEx);
338 CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
339 ASSERT_TRUE(ctx != NULL);
340 uint32_t val = (uint32_t)type;
341 int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
342 ASSERT_EQ(ret, CRYPT_SUCCESS);
343
344 val = (uint32_t)deterministic;
345 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_DETERMINISTIC_FLAG, &val, sizeof(val));
346 ASSERT_EQ(ret, CRYPT_SUCCESS);
347
348 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_CTX_INFO, ctxText->x, ctxText->len);
349 ASSERT_EQ(ret, CRYPT_SUCCESS);
350
351 val = (uint32_t)encodeCtx;
352 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
353 ASSERT_EQ(ret, CRYPT_SUCCESS);
354
355 val = (uint32_t)externalMu;
356 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_MUMSG_FLAG, &val, sizeof(val));
357 ASSERT_EQ(ret, CRYPT_SUCCESS);
358
359 uint32_t outLen = CRYPT_EAL_PkeyGetSignLen(ctx);
360 ASSERT_EQ(outLen, sign->len);
361 uint8_t *out = BSL_SAL_Malloc(outLen);
362
363 CRYPT_EAL_PkeyPrv prvKey = { 0 };
364 prvKey.id = CRYPT_PKEY_ML_DSA;
365 prvKey.key.mldsaPrv.data = testPrvKey->x;
366 prvKey.key.mldsaPrv.len = testPrvKey->len;
367 ret = CRYPT_EAL_PkeySetPrv(ctx, &prvKey);
368 ASSERT_EQ(ret, CRYPT_SUCCESS);
369
370 ret = CRYPT_EAL_PkeySign(ctx, CRYPT_MD_MAX, msg->x, msg->len, out, &outLen);
371 ASSERT_EQ(ret, CRYPT_SUCCESS);
372 ASSERT_COMPARE("compare sign", out, outLen, sign->x, sign->len);
373 EXIT:
374 CRYPT_EAL_PkeyFreeCtx(ctx);
375 BSL_SAL_FREE(out);
376 CRYPT_RandRegist(NULL);
377 CRYPT_RandRegistEx(NULL);
378 return;
379 }
380 /* END_CASE */
381
382 /* @
383 * @test SDV_CRYPTO_MLDSA_FUNC_VERIFYDATA_TC002
384 * @spec -
385 * @title Verify test.
386 * @precon nan
387 * @brief
388 * 1.Set the public key.
389 * 2.Call the verify interface.
390 * @expect
391 * 1.success
392 * 2.The verify value is consistent with the test vector.
393 * @prior nan
394 * @auto FALSE
395 @ */
396 /* BEGIN_CASE */
SDV_CRYPTO_MLDSA_FUNC_VERIFYDATA_TC002(int type,Hex * testPubKey,Hex * msg,Hex * sign,Hex * ctxText,int externalMu,int encodeCtx,int res)397 void SDV_CRYPTO_MLDSA_FUNC_VERIFYDATA_TC002(int type, Hex *testPubKey, Hex *msg, Hex *sign, Hex *ctxText, int externalMu, int encodeCtx, int res)
398 {
399 TestMemInit();
400 CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
401 ASSERT_TRUE(ctx != NULL);
402 uint32_t val = (uint32_t)type;
403 int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
404 ASSERT_EQ(ret, CRYPT_SUCCESS);
405
406 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_CTX_INFO, ctxText->x, ctxText->len);
407 ASSERT_EQ(ret, CRYPT_SUCCESS);
408
409 val = (uint32_t)encodeCtx;
410 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
411 ASSERT_EQ(ret, CRYPT_SUCCESS);
412
413 val = (uint32_t)externalMu;
414 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_MUMSG_FLAG, &val, sizeof(val));
415 ASSERT_EQ(ret, CRYPT_SUCCESS);
416
417 CRYPT_EAL_PkeyPub pubKey = { 0 };
418 pubKey.id = CRYPT_PKEY_ML_DSA;
419 pubKey.key.mldsaPub.data = testPubKey->x;
420 pubKey.key.mldsaPub.len = testPubKey->len;
421 ret = CRYPT_EAL_PkeySetPub(ctx, &pubKey);
422 ASSERT_EQ(ret, CRYPT_SUCCESS);
423
424 ret = CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_MAX, msg->x, msg->len, sign->x, sign->len);
425 if (res == 0) {
426 ASSERT_EQ(ret, CRYPT_SUCCESS);
427 } else {
428 ASSERT_NE(ret, CRYPT_SUCCESS);
429 }
430
431 EXIT:
432 CRYPT_EAL_PkeyFreeCtx(ctx);
433 return;
434 }
435 /* END_CASE */
436
437 /* @
438 * @test SDV_CRYPTO_MLDSA_FUNC_SIGN_TC001
439 * @spec -
440 * @title Signature test.
441 * @precon nan
442 * @brief
443 * 1.Registers a random number that returns the specified value.
444 * 2.Set the private key and additional messages.
445 * 3.Call the signature interface.
446 * @expect
447 * 1.success
448 * 2.success
449 * 3.The signature value is consistent with the test vector.
450 * @prior nan
451 * @auto FALSE
452 @ */
453 /* BEGIN_CASE */
SDV_CRYPTO_MLDSA_FUNC_SIGN_TC001(int type,int hashId,Hex * seed,Hex * testPrvKey,Hex * msg,Hex * ctxText,Hex * sign,int deterministic,int externalMu,int encodeCtx)454 void SDV_CRYPTO_MLDSA_FUNC_SIGN_TC001(int type, int hashId, Hex *seed, Hex *testPrvKey, Hex *msg, Hex *ctxText,
455 Hex *sign, int deterministic, int externalMu, int encodeCtx)
456 {
457 TestMemInit();
458 gMlDsaRandNum = 0;
459 memcpy_s(gMlDsaRandBuf[0], 32, seed->x, seed->len);
460 CRYPT_RandRegist(TEST_MLDSARandom);
461 CRYPT_RandRegistEx(TEST_MLDSARandomEx);
462 CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
463 ASSERT_TRUE(ctx != NULL);
464 uint32_t val = (uint32_t)type;
465 int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
466 ASSERT_EQ(ret, CRYPT_SUCCESS);
467
468 val = (uint32_t)deterministic;
469 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_DETERMINISTIC_FLAG, &val, sizeof(val));
470 ASSERT_EQ(ret, CRYPT_SUCCESS);
471
472 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_CTX_INFO, ctxText->x, ctxText->len);
473 ASSERT_EQ(ret, CRYPT_SUCCESS);
474
475 val = (uint32_t)encodeCtx;
476 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
477 ASSERT_EQ(ret, CRYPT_SUCCESS);
478
479 val = (uint32_t)externalMu;
480 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_MUMSG_FLAG, &val, sizeof(val));
481 ASSERT_EQ(ret, CRYPT_SUCCESS);
482
483 uint32_t outLen = CRYPT_EAL_PkeyGetSignLen(ctx);
484 ASSERT_EQ(outLen, sign->len);
485 uint8_t *out = BSL_SAL_Malloc(outLen);
486
487 CRYPT_EAL_PkeyPrv prvKey = { 0 };
488 prvKey.id = CRYPT_PKEY_ML_DSA;
489 prvKey.key.mldsaPrv.data = testPrvKey->x;
490 prvKey.key.mldsaPrv.len = testPrvKey->len;
491 ret = CRYPT_EAL_PkeySetPrv(ctx, &prvKey);
492 ASSERT_EQ(ret, CRYPT_SUCCESS);
493
494 val = 1;
495 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_PREHASH_FLAG, &val, sizeof(val));
496 ASSERT_EQ(ret, CRYPT_SUCCESS);
497 ret = CRYPT_EAL_PkeySign(ctx, hashId, msg->x, msg->len, out, &outLen);
498 ASSERT_EQ(ret, CRYPT_SUCCESS);
499 ASSERT_COMPARE("compare sign", out, outLen, sign->x, sign->len);
500 EXIT:
501 CRYPT_EAL_PkeyFreeCtx(ctx);
502 BSL_SAL_FREE(out);
503 CRYPT_RandRegist(NULL);
504 CRYPT_RandRegistEx(NULL);
505 return;
506 }
507 /* END_CASE */
508
509 /* @
510 * @test SDV_CRYPTO_MLDSA_FUNC_VERIFY_TC001
511 * @spec -
512 * @title Verify test.
513 * @precon nan
514 * @brief
515 * 1.Set the public key.
516 * 2.Call the verify interface.
517 * @expect
518 * 1.success
519 * 2.The verify value is consistent with the test vector.
520 * @prior nan
521 * @auto FALSE
522 @ */
523 /* BEGIN_CASE */
SDV_CRYPTO_MLDSA_FUNC_VERIFY_TC001(int type,int hashId,Hex * testPubKey,Hex * msg,Hex * sign,Hex * ctxText,int externalMu,int encodeCtx,int res)524 void SDV_CRYPTO_MLDSA_FUNC_VERIFY_TC001(int type, int hashId, Hex *testPubKey, Hex *msg, Hex *sign, Hex *ctxText, int externalMu, int encodeCtx, int res)
525 {
526 TestMemInit();
527 CRYPT_EAL_PkeyCtx *ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
528 ASSERT_TRUE(ctx != NULL);
529 uint32_t val = (uint32_t)type;
530 int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
531 ASSERT_EQ(ret, CRYPT_SUCCESS);
532
533 val = (int32_t)encodeCtx;
534 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_ENCODE_FLAG, &val, sizeof(val));
535 ASSERT_EQ(ret, CRYPT_SUCCESS);
536
537 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_CTX_INFO, ctxText->x, ctxText->len);
538 ASSERT_EQ(ret, CRYPT_SUCCESS);
539
540 val = (int32_t)externalMu;
541 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_MLDSA_MUMSG_FLAG, &val, sizeof(val));
542 ASSERT_EQ(ret, CRYPT_SUCCESS);
543
544 CRYPT_EAL_PkeyPub pubKey = { 0 };
545 pubKey.id = CRYPT_PKEY_ML_DSA;
546 pubKey.key.mldsaPub.data = testPubKey->x;
547 pubKey.key.mldsaPub.len = testPubKey->len;
548 ret = CRYPT_EAL_PkeySetPub(ctx, &pubKey);
549 ASSERT_EQ(ret, CRYPT_SUCCESS);
550
551 val = 1;
552 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_PREHASH_FLAG, &val, sizeof(val));
553 ASSERT_EQ(ret, CRYPT_SUCCESS);
554 ret = CRYPT_EAL_PkeyVerify(ctx, hashId, msg->x, msg->len, sign->x, sign->len);
555 if (res == 0) {
556 ASSERT_EQ(ret, CRYPT_SUCCESS);
557 } else {
558 ASSERT_NE(ret, CRYPT_SUCCESS);
559 }
560
561 EXIT:
562 CRYPT_EAL_PkeyFreeCtx(ctx);
563 return;
564 }
565 /* END_CASE */
566
567 /**
568 * @test SDV_CRYPTO_MLDSA_FUNC_PROVIDER_TC001
569 * @title To test the provisioner function.
570 * @precon Registering memory-related functions.
571 * @brief
572 * Invoke the signature and signature verification functions to test the function correctness.
573 * @expect
574 * Success, and contexts are not NULL.
575 */
576 /* BEGIN_CASE */
SDV_CRYPTO_MLDSA_FUNC_PROVIDER_TC001(int type,Hex * testPubKey,Hex * testPrvKey,Hex * msg,Hex * context,Hex * sign)577 void SDV_CRYPTO_MLDSA_FUNC_PROVIDER_TC001(int type, Hex *testPubKey, Hex *testPrvKey, Hex *msg, Hex *context, Hex *sign)
578 {
579 TestMemInit();
580 TestRandInit();
581 uint8_t *out = NULL;
582 CRYPT_EAL_PkeyCtx *ctx = NULL;
583 #ifdef HITLS_CRYPTO_PROVIDER
584 ctx = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
585 #else
586 ctx = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
587 #endif
588 ASSERT_TRUE(ctx != NULL);
589
590 uint32_t val = (uint32_t)type;
591 int32_t ret = CRYPT_EAL_PkeySetParaById(ctx, val);
592 ASSERT_EQ(ret, CRYPT_SUCCESS);
593
594 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_CTX_INFO, context->x, context->len);
595 ASSERT_EQ(ret, CRYPT_SUCCESS);
596
597 val = 1;
598 ret = CRYPT_EAL_PkeyCtrl(ctx, CRYPT_CTRL_SET_DETERMINISTIC_FLAG, &val, sizeof(val));
599 ASSERT_EQ(ret, CRYPT_SUCCESS);
600
601 uint32_t outLen = CRYPT_EAL_PkeyGetSignLen(ctx);
602 ASSERT_EQ(outLen, sign->len);
603 out = BSL_SAL_Malloc(outLen);
604 ASSERT_TRUE(out != NULL);
605
606 CRYPT_EAL_PkeyPrv prvKey = { 0 };
607 prvKey.id = CRYPT_PKEY_ML_DSA;
608 prvKey.key.mldsaPrv.data = testPrvKey->x;
609 prvKey.key.mldsaPrv.len = testPrvKey->len;
610 ret = CRYPT_EAL_PkeySetPrv(ctx, &prvKey);
611 ASSERT_EQ(ret, CRYPT_SUCCESS);
612
613 ret = CRYPT_EAL_PkeySign(ctx, CRYPT_MD_MAX, msg->x, msg->len, out, &outLen);
614 ASSERT_EQ(ret, CRYPT_SUCCESS);
615 ASSERT_COMPARE("compare sign", out, outLen, sign->x, sign->len);
616
617 CRYPT_EAL_PkeyPub pubKey = { 0 };
618 pubKey.id = CRYPT_PKEY_ML_DSA;
619 pubKey.key.mldsaPub.len = testPubKey->len;
620 pubKey.key.mldsaPub.data = testPubKey->x;
621 ret = CRYPT_EAL_PkeySetPub(ctx, &pubKey);
622 ASSERT_EQ(ret, CRYPT_SUCCESS);
623 ret = CRYPT_EAL_PkeyVerify(ctx, CRYPT_MD_MAX, msg->x, msg->len, sign->x, sign->len);
624 ASSERT_EQ(ret, CRYPT_SUCCESS);
625
626 CRYPT_EAL_PkeyCtx *ctx2 = NULL;
627 #ifdef HITLS_CRYPTO_PROVIDER
628 ctx2 = CRYPT_EAL_ProviderPkeyNewCtx(NULL, CRYPT_PKEY_ML_DSA, CRYPT_EAL_PKEY_SIGN_OPERATE, "provider=default");
629 #else
630 ctx2 = CRYPT_EAL_PkeyNewCtx(CRYPT_PKEY_ML_DSA);
631 #endif
632 ASSERT_TRUE(ctx2 != NULL);
633
634 val = (uint32_t)type;
635 ret = CRYPT_EAL_PkeySetParaById(ctx2, val);
636 ASSERT_EQ(ret, CRYPT_SUCCESS);
637 ret = CRYPT_EAL_PkeyGen(ctx2);
638 ASSERT_EQ(ret, CRYPT_SUCCESS);
639
640 ret = CRYPT_EAL_PkeyGetPub(ctx2, &pubKey);
641 ASSERT_EQ(ret, CRYPT_SUCCESS);
642 ASSERT_EQ(pubKey.key.mldsaPub.len, testPubKey->len);
643 ret = CRYPT_EAL_PkeyGetPrv(ctx2, &prvKey);
644 ASSERT_EQ(ret, CRYPT_SUCCESS);
645 ASSERT_EQ(prvKey.key.mldsaPrv.len, testPrvKey->len);
646
647 val = 1;
648 ret = CRYPT_EAL_PkeyCtrl(ctx2, CRYPT_CTRL_SET_PREHASH_FLAG, &val, sizeof(val));
649 ASSERT_EQ(ret, CRYPT_SUCCESS);
650 ret = CRYPT_EAL_PkeySign(ctx2, CRYPT_MD_SHA256, msg->x, msg->len, out, &outLen);
651 ASSERT_EQ(ret, CRYPT_SUCCESS);
652 ret = CRYPT_EAL_PkeyVerify(ctx2, CRYPT_MD_SHA256, msg->x, msg->len, out, outLen);
653 ASSERT_EQ(ret, CRYPT_SUCCESS);
654 ret = CRYPT_EAL_PkeyCmp(ctx, ctx2);
655 ASSERT_NE(ret, CRYPT_SUCCESS);
656
657 CRYPT_EAL_PkeyCtx *ctx3 = CRYPT_EAL_PkeyDupCtx(ctx);
658 ASSERT_TRUE(ctx3 != NULL);
659 ret = CRYPT_EAL_PkeyCmp(ctx, ctx3);
660 ASSERT_EQ(ret, CRYPT_SUCCESS);
661
662 EXIT:
663 CRYPT_EAL_PkeyFreeCtx(ctx);
664 CRYPT_EAL_PkeyFreeCtx(ctx2);
665 CRYPT_EAL_PkeyFreeCtx(ctx3);
666 BSL_SAL_Free(out);
667 TestRandDeInit();
668 }
669 /* END_CASE */
670