1 /*
2 * This file is part of the openHiTLS project.
3 *
4 * openHiTLS is licensed under the Mulan PSL v2.
5 * You can use this software according to the terms and conditions of the Mulan PSL v2.
6 * You may obtain a copy of Mulan PSL v2 at:
7 *
8 * http://license.coscl.org.cn/MulanPSL2
9 *
10 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
11 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
12 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
13 * See the Mulan PSL v2 for more details.
14 */
15
16 #include "bsl_sal.h"
17 #include "bsl_list.h"
18 #include "crypt_errno.h"
19 #include "crypt_params_key.h"
20 #include "crypt_eal_provider.h"
21 #include "crypt_eal_implprovider.h"
22 #include "crypt_eal_codecs.h"
23 #include "crypt_eal_pkey.h"
24 #include "bsl_types.h"
25 #include "crypt_types.h"
26 #include "provider_test_utils.h"
27 #include <stdlib.h>
28 #include <string.h>
29
30 #define RSA_MAX_MODULUS_BITS 16384
31 #define RSA_MAX_MODULUS_LEN (RSA_MAX_MODULUS_BITS / 8)
32
33 #define PARAMISNULL(a) ((a) == NULL || (a)->value == NULL)
34 #define PARAMISNULLLENIS0(a) ((a) == NULL || (a)->value == NULL || (a)->valueLen == 0)
35
36 /* JSON to PEM decoder context */
37 typedef struct {
38 const char *outFormat;
39 const char *outType;
40 } JSON_PEM_DecoderCtx;
41
42 /* JSON to PEM decoder implementation */
JSON_PEM_NewCtx(void * provCtx)43 static void *JSON_PEM_NewCtx(void *provCtx)
44 {
45 (void)provCtx;
46 JSON_PEM_DecoderCtx *ctx = calloc(1, sizeof(JSON_PEM_DecoderCtx));
47 if (ctx == NULL) {
48 return NULL;
49 }
50 ctx->outFormat = "PEM";
51 ctx->outType = NULL;
52 return ctx;
53 }
54
JSON_PEM_SetParam(void * ctx,const BSL_Param * param)55 static int32_t JSON_PEM_SetParam(void *ctx, const BSL_Param *param)
56 {
57 if (ctx == NULL || param == NULL) {
58 return CRYPT_NULL_INPUT;
59 }
60 return CRYPT_SUCCESS;
61 }
62
JSON_PEM_GetParam(void * ctx,BSL_Param * param)63 static int32_t JSON_PEM_GetParam(void *ctx, BSL_Param *param)
64 {
65 if (ctx == NULL || param == NULL) {
66 return CRYPT_NULL_INPUT;
67 }
68 JSON_PEM_DecoderCtx *decoderCtx = (JSON_PEM_DecoderCtx *)ctx;
69 BSL_Param *param1 = TestFindParam(param, CRYPT_PARAM_DECODE_OUTPUT_TYPE);
70 if (param1 != NULL) {
71 if (param1->valueType != BSL_PARAM_TYPE_OCTETS_PTR) {
72 return CRYPT_INVALID_ARG;
73 }
74 param1->value = (void *)(uintptr_t)decoderCtx->outType;
75 }
76 BSL_Param *param2 = TestFindParam(param, CRYPT_PARAM_DECODE_OUTPUT_FORMAT);
77 if (param2 != NULL) {
78 if (param2->valueType != BSL_PARAM_TYPE_OCTETS_PTR) {
79 return CRYPT_INVALID_ARG;
80 }
81 param2->value = (void *)(uintptr_t)decoderCtx->outFormat;
82 }
83 return CRYPT_SUCCESS;
84 }
85
JSON_PEM_Decode(void * ctx,const BSL_Param * inParam,BSL_Param ** outParam)86 static int32_t JSON_PEM_Decode(void *ctx, const BSL_Param *inParam, BSL_Param **outParam)
87 {
88 if (ctx == NULL || inParam == NULL || outParam == NULL) {
89 return CRYPT_NULL_INPUT;
90 }
91 uint8_t *pemData = NULL;
92 uint32_t pemLen = 0;
93 uint8_t *jsonData = NULL;
94 BSL_Param *resultParam = NULL;
95 JSON_PEM_DecoderCtx *decoderCtx = (JSON_PEM_DecoderCtx *)ctx;
96 const BSL_Param *param1 = TestFindConstParam(inParam, CRYPT_PARAM_DECODE_BUFFER_DATA);
97 if (param1 == NULL) {
98 return CRYPT_NULL_INPUT;
99 }
100 /* Get input data */
101 if (param1->valueType != BSL_PARAM_TYPE_OCTETS || param1->value == NULL || param1->valueLen == 0) {
102 return CRYPT_INVALID_ARG;
103 }
104 jsonData = (uint8_t *)(uintptr_t)param1->value;
105 uint8_t *pemHeader = strstr(jsonData, "{");
106 if (pemHeader == NULL) {
107 return CRYPT_INVALID_ARG;
108 }
109 uint8_t *pemFooter = strstr(pemHeader, "}");
110 if (pemFooter == NULL) {
111 return CRYPT_INVALID_ARG;
112 }
113 /* Convert JSON to PEM format */
114 pemLen = pemFooter - pemHeader + 1;
115 pemData = (uint8_t *)malloc(pemLen);
116 if (pemData == NULL) {
117 return CRYPT_MEM_ALLOC_FAIL;
118 }
119 memcpy(pemData, pemHeader, pemLen);
120 pemData[pemLen - 1] = '\0';
121 /* Create output parameter */
122 resultParam = calloc(2, sizeof(BSL_Param));
123 if (resultParam == NULL) {
124 free(pemData);
125 return CRYPT_MEM_ALLOC_FAIL;
126 }
127 resultParam[0].key = CRYPT_PARAM_DECODE_BUFFER_DATA;
128 resultParam[0].valueType = BSL_PARAM_TYPE_OCTETS;
129 resultParam[0].value = pemData;
130 resultParam[0].valueLen = pemLen;
131 *outParam = resultParam;
132 return CRYPT_SUCCESS;
133 }
134
JSON_PEM_FreeOutData(void * ctx,BSL_Param * outData)135 static void JSON_PEM_FreeOutData(void *ctx, BSL_Param *outData)
136 {
137 if (ctx == NULL || outData == NULL) {
138 return;
139 }
140 free(outData->value);
141 free(outData);
142 }
143
JSON_PEM_FreeCtx(void * ctx)144 static void JSON_PEM_FreeCtx(void *ctx)
145 {
146 if (ctx == NULL) {
147 return;
148 }
149 free(ctx);
150 }
151
152 /* RSA key management context */
153 typedef struct {
154 uint32_t bits; // RSA key length
155 uint8_t e[RSA_MAX_MODULUS_LEN]; // Public key
156 uint8_t eLen; // Public key length
157 uint8_t n[RSA_MAX_MODULUS_LEN]; // Public key
158 uint32_t nLen; // Public key length
159 uint8_t d[RSA_MAX_MODULUS_LEN]; // Private key
160 uint32_t dLen; // Private key length
161 uint8_t p[RSA_MAX_MODULUS_LEN]; // Private key
162 uint32_t pLen; // Private key length
163 uint8_t q[RSA_MAX_MODULUS_LEN]; // Private key
164 uint32_t qLen; // Private key length
165 uint8_t dp[RSA_MAX_MODULUS_LEN]; // Private key
166 uint32_t dpLen; // Private key length
167 uint8_t dq[RSA_MAX_MODULUS_LEN]; // Private key
168 uint32_t dqLen; // Private key length
169 uint8_t qInv[RSA_MAX_MODULUS_LEN]; // Private key
170 uint32_t qInvLen; // Private key length
171 int32_t mdId; // MD ID
172 int32_t mgf1Id; // MGF1 ID
173 int32_t saltLen; // Salt length
174 } TestRsaCtx;
175
176 /* RSA key management implementation */
TestPkeyMgmtRsaNewCtx(void * provCtx)177 static void *TestPkeyMgmtRsaNewCtx(void *provCtx)
178 {
179 (void)provCtx;
180 TestRsaCtx *ctx = calloc(1, sizeof(TestRsaCtx));
181 if (ctx == NULL) {
182 return NULL;
183 }
184 return ctx;
185 }
186
TestRsaFreeCtx(void * ctx)187 static void TestRsaFreeCtx(void *ctx)
188 {
189 if (ctx == NULL) {
190 return;
191 }
192 free(ctx);
193 }
194
TestRsaSetParam(void * ctx,const BSL_Param * param)195 static int32_t TestRsaSetParam(void *ctx, const BSL_Param *param)
196 {
197 if (ctx == NULL || param == NULL) {
198 return CRYPT_NULL_INPUT;
199 }
200 const BSL_Param *e = TestFindConstParam(param, CRYPT_PARAM_RSA_E);
201 const BSL_Param *bits = TestFindConstParam(param, CRYPT_PARAM_RSA_BITS);
202 if (PARAMISNULL(e) || PARAMISNULL(bits)) {
203 return CRYPT_NULL_INPUT;
204 }
205 if (e->valueType != BSL_PARAM_TYPE_OCTETS || bits->valueType != BSL_PARAM_TYPE_UINT32) {
206 return CRYPT_INVALID_ARG;
207 }
208 TestRsaCtx *rsaCtx = (TestRsaCtx *)ctx;
209 rsaCtx->bits = *(uint32_t *)bits->value;
210 memcpy(rsaCtx->e, e->value, e->valueLen);
211 rsaCtx->eLen = e->valueLen;
212 return CRYPT_SUCCESS;
213 }
214
TestRsaSetPubKey(void * ctx,const BSL_Param * param)215 static int32_t TestRsaSetPubKey(void *ctx, const BSL_Param *param)
216 {
217 if (ctx == NULL || param == NULL) {
218 return CRYPT_NULL_INPUT;
219 }
220 const BSL_Param *e = TestFindConstParam(param, CRYPT_PARAM_RSA_E);
221 const BSL_Param *n = TestFindConstParam(param, CRYPT_PARAM_RSA_N);
222 if (PARAMISNULL(e) || PARAMISNULL(n)) {
223 return CRYPT_NULL_INPUT;
224 }
225 TestRsaCtx *rsaCtx = (TestRsaCtx *)ctx;
226 memcpy(rsaCtx->e, e->value, e->valueLen);
227 memcpy(rsaCtx->n, n->value, n->valueLen);
228 rsaCtx->eLen = e->valueLen;
229 rsaCtx->nLen = n->valueLen;
230 return CRYPT_SUCCESS;
231 }
232
TestRsaSetPrvKey(void * ctx,const BSL_Param * param)233 static int32_t TestRsaSetPrvKey(void *ctx, const BSL_Param *param)
234 {
235 if (ctx == NULL || param == NULL) {
236 return CRYPT_NULL_INPUT;
237 }
238 const BSL_Param *n = TestFindConstParam(param, CRYPT_PARAM_RSA_N);
239 const BSL_Param *d = TestFindConstParam(param, CRYPT_PARAM_RSA_D);
240 const BSL_Param *p = TestFindConstParam(param, CRYPT_PARAM_RSA_P);
241 const BSL_Param *q = TestFindConstParam(param, CRYPT_PARAM_RSA_Q);
242 const BSL_Param *dp = TestFindConstParam(param, CRYPT_PARAM_RSA_DP);
243 const BSL_Param *dq = TestFindConstParam(param, CRYPT_PARAM_RSA_DQ);
244 const BSL_Param *qInv = TestFindConstParam(param, CRYPT_PARAM_RSA_QINV);
245 if (PARAMISNULLLENIS0(n) || PARAMISNULLLENIS0(d) || n->valueType != BSL_PARAM_TYPE_OCTETS ||
246 d->valueType != BSL_PARAM_TYPE_OCTETS) {
247 return CRYPT_NULL_INPUT;
248 }
249 if (n->valueLen > RSA_MAX_MODULUS_LEN) {
250 return CRYPT_RSA_ERR_KEY_BITS;
251 }
252 // prv->p\q and prv->dP\dQ\qInv must be both empty or not.
253 // If prv->p is empty, prv->dP must be empty.
254 if ((PARAMISNULL(p) != PARAMISNULL(q)) || (PARAMISNULL(p) && !PARAMISNULL(dp))) {
255 return CRYPT_RSA_NO_KEY_INFO;
256 }
257 if ((PARAMISNULL(dp) || PARAMISNULL(dq) || PARAMISNULL(qInv)) &&
258 (!PARAMISNULL(dp) || !PARAMISNULL(dq) || !PARAMISNULL(qInv))) {
259 return CRYPT_RSA_NO_KEY_INFO;
260 }
261 TestRsaCtx *rsaCtx = (TestRsaCtx *)ctx;
262 memcpy(rsaCtx->n, n->value, n->valueLen);
263 rsaCtx->nLen = n->valueLen;
264 memcpy(rsaCtx->d, d->value, d->valueLen);
265 rsaCtx->dLen = d->valueLen;
266 if (!PARAMISNULL(p)) {
267 memcpy(rsaCtx->p, p->value, p->valueLen);
268 rsaCtx->pLen = p->valueLen;
269 }
270 if (!PARAMISNULL(q)) {
271 memcpy(rsaCtx->q, q->value, q->valueLen);
272 rsaCtx->qLen = q->valueLen;
273 }
274 if (!PARAMISNULL(dp)) {
275 memcpy(rsaCtx->dp, dp->value, dp->valueLen);
276 rsaCtx->dpLen = dp->valueLen;
277 }
278 if (!PARAMISNULL(dq)) {
279 memcpy(rsaCtx->dq, dq->value, dq->valueLen);
280 rsaCtx->dqLen = dq->valueLen;
281 }
282 if (!PARAMISNULL(qInv)) {
283 memcpy(rsaCtx->qInv, qInv->value, qInv->valueLen);
284 rsaCtx->qInvLen = qInv->valueLen;
285 }
286 return CRYPT_SUCCESS;
287 }
288
TestRsaImport(void * ctx,const BSL_Param * param)289 static int32_t TestRsaImport(void *ctx, const BSL_Param *param)
290 {
291 if (ctx == NULL || param == NULL) {
292 return CRYPT_NULL_INPUT;
293 }
294 int32_t ret = CRYPT_SUCCESS;
295 TestRsaCtx *rsaCtx = (TestRsaCtx *)ctx;
296 const BSL_Param *e = TestFindConstParam(param, CRYPT_PARAM_RSA_E);
297 const BSL_Param *n = TestFindConstParam(param, CRYPT_PARAM_RSA_N);
298 if (!PARAMISNULL(e) && !PARAMISNULL(n)) {
299 ret = TestRsaSetPubKey(ctx, param);
300 if (ret != CRYPT_SUCCESS) {
301 return ret;
302 }
303 }
304
305 const BSL_Param *d = TestFindConstParam(param, CRYPT_PARAM_RSA_D);
306 const BSL_Param *p = TestFindConstParam(param, CRYPT_PARAM_RSA_P);
307 const BSL_Param *q = TestFindConstParam(param, CRYPT_PARAM_RSA_Q);
308 const BSL_Param *dp = TestFindConstParam(param, CRYPT_PARAM_RSA_DP);
309 const BSL_Param *dq = TestFindConstParam(param, CRYPT_PARAM_RSA_DQ);
310 const BSL_Param *qInv = TestFindConstParam(param, CRYPT_PARAM_RSA_QINV);
311 if (!PARAMISNULL(n) && !PARAMISNULL(d) && (PARAMISNULL(p) == PARAMISNULL(q)) &&
312 (PARAMISNULL(dp) == PARAMISNULL(dq)) && PARAMISNULL(dq) == PARAMISNULL(qInv)) {
313 ret = TestRsaSetPrvKey(ctx, param);
314 if (ret != CRYPT_SUCCESS) {
315 return ret;
316 }
317 }
318 const BSL_Param *mdIdParam = TestFindConstParam(param, CRYPT_PARAM_RSA_MD_ID);
319 const BSL_Param *mgf1IdParam = TestFindConstParam(param, CRYPT_PARAM_RSA_MGF1_ID);
320 const BSL_Param *saltLenParam = TestFindConstParam(param, CRYPT_PARAM_RSA_SALTLEN);
321 if (mdIdParam != NULL && mdIdParam->valueType == BSL_PARAM_TYPE_INT32 && mdIdParam->valueLen == sizeof(int32_t) &&
322 mgf1IdParam != NULL && mgf1IdParam->valueType == BSL_PARAM_TYPE_INT32 &&
323 mgf1IdParam->valueLen == sizeof(int32_t) &&
324 saltLenParam != NULL && saltLenParam->valueType == BSL_PARAM_TYPE_INT32 &&
325 saltLenParam->valueLen == sizeof(int32_t)) {
326 rsaCtx->mdId = *(int32_t *)mdIdParam->value;
327 rsaCtx->mgf1Id = *(int32_t *)mgf1IdParam->value;
328 rsaCtx->saltLen = *(int32_t *)saltLenParam->value;
329 } else if (mdIdParam != NULL && mdIdParam->valueType == BSL_PARAM_TYPE_INT32 && mdIdParam->valueLen == sizeof(int32_t)) {
330 rsaCtx->mdId = *(int32_t *)mdIdParam->value;
331 }
332 if (ret != CRYPT_SUCCESS) {
333 return ret;
334 }
335 return CRYPT_SUCCESS;
336 }
337
338 /* Provider implementation */
339 static const CRYPT_EAL_Func g_jsonPemDecoderFuncs[] = {
340 {CRYPT_DECODER_IMPL_NEWCTX, (void *)JSON_PEM_NewCtx},
341 {CRYPT_DECODER_IMPL_SETPARAM, (void *)JSON_PEM_SetParam},
342 {CRYPT_DECODER_IMPL_GETPARAM, (void *)JSON_PEM_GetParam},
343 {CRYPT_DECODER_IMPL_DECODE, (void *)JSON_PEM_Decode},
344 {CRYPT_DECODER_IMPL_FREEOUTDATA, (void *)JSON_PEM_FreeOutData},
345 {CRYPT_DECODER_IMPL_FREECTX, (void *)JSON_PEM_FreeCtx},
346 {0, NULL}
347 };
348
349 /* Provider registration */
350 static const CRYPT_EAL_AlgInfo g_testDecode[] = {
351 {BSL_CID_DECODE_UNKNOWN, g_jsonPemDecoderFuncs, "provider=test_decoder, inFormat=JSON, outFormat=PEM"},
352
353 CRYPT_EAL_ALGINFO_END
354 };
355
356 /* SM2 key management context */
357 typedef struct {
358 uint8_t prvKey[32]; // Private key
359 uint32_t prvKeyLen; // Private key length
360 uint8_t pubKey[72]; // Public key
361 uint32_t pubKeyLen; // Public key length
362 } TestSm2OrEd25519Ctx;
363
364 /* SM2 key management implementation */
TestPkeyMgmtSm2OrEd25519NewCtx(void * provCtx)365 static void *TestPkeyMgmtSm2OrEd25519NewCtx(void *provCtx)
366 {
367 (void)provCtx;
368 TestSm2OrEd25519Ctx *ctx = calloc(1, sizeof(TestSm2OrEd25519Ctx));
369 if (ctx == NULL) {
370 return NULL;
371 }
372 return ctx;
373 }
374
TestSm2OrEd25519FreeCtx(void * ctx)375 static void TestSm2OrEd25519FreeCtx(void *ctx)
376 {
377 if (ctx == NULL) {
378 return;
379 }
380 free(ctx);
381 }
382
TestSm2SetPubKey(void * ctx,const BSL_Param * param)383 static int32_t TestSm2SetPubKey(void *ctx, const BSL_Param *param)
384 {
385 if (ctx == NULL || param == NULL) {
386 return CRYPT_NULL_INPUT;
387 }
388 const BSL_Param *pubKey = TestFindConstParam(param, CRYPT_PARAM_EC_PUBKEY);
389 if (PARAMISNULL(pubKey)) {
390 return CRYPT_NULL_INPUT;
391 }
392 if (pubKey->valueType != BSL_PARAM_TYPE_OCTETS || pubKey->valueLen < 65) {
393 return CRYPT_INVALID_ARG;
394 }
395 TestSm2OrEd25519Ctx *sm2Ctx = (TestSm2OrEd25519Ctx *)ctx;
396 memcpy(sm2Ctx->pubKey, pubKey->value, pubKey->valueLen);
397 sm2Ctx->pubKeyLen = pubKey->valueLen;
398 return CRYPT_SUCCESS;
399 }
400
TestSm2SetPrvKey(void * ctx,const BSL_Param * param)401 static int32_t TestSm2SetPrvKey(void *ctx, const BSL_Param *param)
402 {
403 if (ctx == NULL || param == NULL) {
404 return CRYPT_NULL_INPUT;
405 }
406 const BSL_Param *prvKey = TestFindConstParam(param, CRYPT_PARAM_EC_PRVKEY);
407 if (PARAMISNULL(prvKey)) {
408 return CRYPT_NULL_INPUT;
409 }
410 if (prvKey->valueType != BSL_PARAM_TYPE_OCTETS || prvKey->valueLen != 32) {
411 return CRYPT_INVALID_ARG;
412 }
413 TestSm2OrEd25519Ctx *sm2Ctx = (TestSm2OrEd25519Ctx *)ctx;
414 memcpy(sm2Ctx->prvKey, prvKey->value, prvKey->valueLen);
415 sm2Ctx->prvKeyLen = prvKey->valueLen;
416 return CRYPT_SUCCESS;
417 }
418
TestSm2Import(void * ctx,const BSL_Param * param)419 static int32_t TestSm2Import(void *ctx, const BSL_Param *param)
420 {
421 if (ctx == NULL || param == NULL) {
422 return CRYPT_NULL_INPUT;
423 }
424 int32_t ret;
425 TestSm2OrEd25519Ctx *sm2Ctx = (TestSm2OrEd25519Ctx *)ctx;
426
427 const BSL_Param *pubKey = TestFindConstParam(param, CRYPT_PARAM_EC_PUBKEY);
428 if (!PARAMISNULL(pubKey)) {
429 ret = TestSm2SetPubKey(ctx, param);
430 if (ret != CRYPT_SUCCESS) {
431 return ret;
432 }
433 }
434
435 const BSL_Param *prvKey = TestFindConstParam(param, CRYPT_PARAM_EC_PRVKEY);
436 if (!PARAMISNULL(prvKey)) {
437 ret = TestSm2SetPrvKey(ctx, param);
438 if (ret != CRYPT_SUCCESS) {
439 return ret;
440 }
441 }
442
443 return CRYPT_SUCCESS;
444 }
445
446 /* ED25519 key management context */
TestEd25519SetPubKey(void * ctx,const BSL_Param * param)447 static int32_t TestEd25519SetPubKey(void *ctx, const BSL_Param *param)
448 {
449 if (ctx == NULL || param == NULL) {
450 return CRYPT_NULL_INPUT;
451 }
452 const BSL_Param *pubKey = TestFindConstParam(param, CRYPT_PARAM_CURVE25519_PUBKEY);
453 if (PARAMISNULL(pubKey)) {
454 return CRYPT_NULL_INPUT;
455 }
456 if (pubKey->valueType != BSL_PARAM_TYPE_OCTETS || pubKey->valueLen != 32) {
457 return CRYPT_INVALID_ARG;
458 }
459 TestSm2OrEd25519Ctx *ed25519Ctx = (TestSm2OrEd25519Ctx *)ctx;
460 memcpy(ed25519Ctx->pubKey, pubKey->value, pubKey->valueLen);
461 ed25519Ctx->pubKeyLen = pubKey->valueLen;
462 return CRYPT_SUCCESS;
463 }
464
TestEd25519SetPrvKey(void * ctx,const BSL_Param * param)465 static int32_t TestEd25519SetPrvKey(void *ctx, const BSL_Param *param)
466 {
467 if (ctx == NULL || param == NULL) {
468 return CRYPT_NULL_INPUT;
469 }
470 const BSL_Param *prvKey = TestFindConstParam(param, CRYPT_PARAM_CURVE25519_PRVKEY);
471 if (PARAMISNULL(prvKey)) {
472 return CRYPT_NULL_INPUT;
473 }
474 if (prvKey->valueType != BSL_PARAM_TYPE_OCTETS || prvKey->valueLen != 32) {
475 return CRYPT_INVALID_ARG;
476 }
477 TestSm2OrEd25519Ctx *ed25519Ctx = (TestSm2OrEd25519Ctx *)ctx;
478 memcpy(ed25519Ctx->prvKey, prvKey->value, prvKey->valueLen);
479 ed25519Ctx->prvKeyLen = prvKey->valueLen;
480 return CRYPT_SUCCESS;
481 }
482
TestEd25519Import(void * ctx,const BSL_Param * param)483 static int32_t TestEd25519Import(void *ctx, const BSL_Param *param)
484 {
485 if (ctx == NULL || param == NULL) {
486 return CRYPT_NULL_INPUT;
487 }
488 int32_t ret;
489 TestSm2OrEd25519Ctx *ed25519Ctx = (TestSm2OrEd25519Ctx *)ctx;
490
491 const BSL_Param *pubKey = TestFindConstParam(param, CRYPT_PARAM_CURVE25519_PUBKEY);
492 if (!PARAMISNULL(pubKey)) {
493 ret = TestEd25519SetPubKey(ctx, param);
494 if (ret != CRYPT_SUCCESS) {
495 return ret;
496 }
497 }
498
499 const BSL_Param *prvKey = TestFindConstParam(param, CRYPT_PARAM_CURVE25519_PRVKEY);
500 if (!PARAMISNULL(prvKey)) {
501 ret = TestEd25519SetPrvKey(ctx, param);
502 if (ret != CRYPT_SUCCESS) {
503 return ret;
504 }
505 }
506 return CRYPT_SUCCESS;
507 }
508
509 const CRYPT_EAL_Func g_testKeyMgmtRsa[] = {
510 {CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)TestPkeyMgmtRsaNewCtx},
511 {CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)TestRsaSetParam},
512 {CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)TestRsaSetPrvKey},
513 {CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)TestRsaSetPubKey},
514 {CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)TestRsaFreeCtx},
515 {CRYPT_EAL_IMPLPKEYMGMT_IMPORT, (CRYPT_EAL_ImplPkeyMgmtImport)TestRsaImport},
516 CRYPT_EAL_FUNC_END,
517 };
518
519 const CRYPT_EAL_Func g_testKeyMgmtSm2[] = {
520 {CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)TestPkeyMgmtSm2OrEd25519NewCtx},
521 {CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)TestSm2SetPrvKey},
522 {CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)TestSm2SetPubKey},
523 {CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)TestSm2OrEd25519FreeCtx},
524 {CRYPT_EAL_IMPLPKEYMGMT_IMPORT, (CRYPT_EAL_ImplPkeyMgmtImport)TestSm2Import},
525 CRYPT_EAL_FUNC_END,
526 };
527
528 const CRYPT_EAL_Func g_testKeyMgmtEd25519[] = {
529 {CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)TestPkeyMgmtSm2OrEd25519NewCtx},
530 {CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)TestEd25519SetPrvKey},
531 {CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)TestEd25519SetPubKey},
532 {CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)TestSm2OrEd25519FreeCtx},
533 {CRYPT_EAL_IMPLPKEYMGMT_IMPORT, (CRYPT_EAL_ImplPkeyMgmtImport)TestEd25519Import},
534 CRYPT_EAL_FUNC_END,
535 };
536
537 static const CRYPT_EAL_AlgInfo g_testKeyMgmt[] = {
538 {CRYPT_PKEY_RSA, g_testKeyMgmtRsa, "provider=test_decoder"},
539 {CRYPT_PKEY_SM2, g_testKeyMgmtSm2, "provider=test_decoder"},
540 {CRYPT_PKEY_ED25519, g_testKeyMgmtEd25519, "provider=test_decoder"},
541
542 CRYPT_EAL_ALGINFO_END
543 };
544
TestProvQuery(void * provCtx,int32_t operaId,CRYPT_EAL_AlgInfo ** algInfos)545 static int32_t TestProvQuery(void *provCtx, int32_t operaId, CRYPT_EAL_AlgInfo **algInfos)
546 {
547 (void)provCtx;
548 int32_t ret = CRYPT_SUCCESS;
549 switch (operaId) {
550 case CRYPT_EAL_OPERAID_KEYMGMT:
551 *algInfos = (CRYPT_EAL_AlgInfo *)(uintptr_t)g_testKeyMgmt;
552 break;
553 case CRYPT_EAL_OPERAID_DECODER:
554 *algInfos = (CRYPT_EAL_AlgInfo *)(uintptr_t)g_testDecode;
555 break;
556 default:
557 return CRYPT_NOT_SUPPORT;
558 }
559
560 return CRYPT_SUCCESS;
561 }
562
TestProvFree(void * provCtx)563 static int32_t TestProvFree(void *provCtx)
564 {
565 if (provCtx != NULL) {
566 free(provCtx);
567 }
568 return CRYPT_SUCCESS;
569 }
570
571 static CRYPT_EAL_Func g_testProvOutFuncs[] = {
572 {CRYPT_EAL_PROVCB_QUERY, TestProvQuery},
573 {CRYPT_EAL_PROVCB_FREE, TestProvFree},
574 {CRYPT_EAL_PROVCB_CTRL, NULL},
575 {CRYPT_EAL_PROVCB_GETCAPS, NULL},
576 CRYPT_EAL_FUNC_END
577 };
578
CRYPT_EAL_ProviderInit(CRYPT_EAL_ProvMgrCtx * mgrCtx,BSL_Param * param,CRYPT_EAL_Func * capFuncs,CRYPT_EAL_Func ** outFuncs,void ** provCtx)579 int32_t CRYPT_EAL_ProviderInit(CRYPT_EAL_ProvMgrCtx *mgrCtx, BSL_Param *param,
580 CRYPT_EAL_Func *capFuncs, CRYPT_EAL_Func **outFuncs, void **provCtx)
581 {
582 *outFuncs = g_testProvOutFuncs;
583 return CRYPT_SUCCESS;
584 }
585