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 "crypt_eal_provider.h"
17 #include <stdio.h>
18 #include <stdint.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include "bsl_obj.h"
22 #include "bsl_err.h"
23 #include "bsl_params.h"
24 #include "crypt_errno.h"
25 #include "crypt_params_key.h"
26 #include "crypt_eal_implprovider.h"
27 #include "hitls_type.h"
28 #include "provider_test_utils.h"
29
30 #define NEW_PARA_ALGID (BSL_CID_MAX + 1)
31 #define NEW_PKEY_ALGID (BSL_CID_MAX + 2)
32
33 #define NEW_KEM_ALGID (BSL_CID_MAX + 5)
34 #define NEW_KEM_PARAM_ID (BSL_CID_MAX + 6)
35
36 #define NEW_SIGN_HASH_ALGID (BSL_CID_MAX + 3)
37 #define NEW_HASH_ALGID (BSL_CID_MAX + 4)
38 #define TEST_CRYPT_DEFAULT_SIGNLEN 70
39 #define UINT8_MAX_NUM 255
40
41 typedef struct {
42 CRYPT_EAL_ProvMgrCtx *mgrCtxHandle;
43 } TestProvCtx;
44
45 typedef struct {
46 uint8_t prvkey[72]; // Private key
47 uint32_t prvkeyLen; // Private key length
48 uint8_t pubkey[256]; // Public key
49 uint32_t pubkeyLen; // Public key length
50 int32_t paraId; // Parameter ID
51 } TestEccKeyCtx;
52
53 typedef struct {
54 uint8_t pubkey[20]; // Public key
55 uint32_t pubkeyLen; // Public key length
56 uint8_t shared[20];
57 uint32_t sharedLen;
58 int32_t paraId; // Parameter ID
59 } TestKemKeyCtx;
60
TestPkeyMgmtEcNewCtx(void * provCtx,int32_t algId)61 void *TestPkeyMgmtEcNewCtx(void *provCtx, int32_t algId)
62 {
63 (void)provCtx;
64 (void)algId;
65 TestEccKeyCtx *pkeyCtx = malloc(sizeof(TestEccKeyCtx));
66 if (pkeyCtx == NULL) {
67 return NULL;
68 }
69 return (void *)pkeyCtx;
70 }
71
TestEccSetPara(TestEccKeyCtx * ctx,const BSL_Param * param)72 static int32_t TestEccSetPara(TestEccKeyCtx *ctx, const BSL_Param *param)
73 {
74 if (ctx == NULL || param == NULL) {
75 return CRYPT_NULL_INPUT;
76 }
77 const BSL_Param *para = TestFindConstParam(param, CRYPT_PARAM_EC_CURVE_ID);
78 if (para != NULL) {
79 if (para->value == NULL || para->valueType != BSL_PARAM_TYPE_INT32 ||
80 para->valueLen != sizeof(int32_t)) {
81 return CRYPT_INVALID_ARG;
82 }
83 ctx->paraId = *((int32_t *)para->value);
84 }
85
86 return CRYPT_SUCCESS;
87 }
88
TestEccGetParaPara(TestEccKeyCtx * ctx,BSL_Param * param)89 static int32_t TestEccGetParaPara(TestEccKeyCtx *ctx, BSL_Param *param)
90 {
91 (void)ctx;
92 (void)param;
93 return CRYPT_SUCCESS;
94 }
95
RandFunc(uint8_t * randNum,uint32_t randLen)96 static void RandFunc(uint8_t *randNum, uint32_t randLen)
97 {
98 for (uint32_t i = 0; i < randLen; i++) {
99 randNum[i] = (uint8_t)(rand() % UINT8_MAX_NUM);
100 }
101 }
102
TestEccGenKey(TestEccKeyCtx * ctx)103 static int32_t TestEccGenKey(TestEccKeyCtx *ctx)
104 {
105 if (ctx == NULL) {
106 return CRYPT_NULL_INPUT;
107 }
108 if (ctx->paraId == BSL_CID_SECP384R1) {
109 ctx->prvkeyLen = 48;
110 ctx->pubkeyLen = 110;
111 } else if (ctx->paraId == NEW_PARA_ALGID) {
112 ctx->prvkeyLen = 66;
113 ctx->pubkeyLen = 143;
114 } else {
115 return CRYPT_INVALID_ARG;
116 }
117 RandFunc(ctx->prvkey, ctx->prvkeyLen);
118 RandFunc(ctx->pubkey, ctx->pubkeyLen);
119
120 return CRYPT_SUCCESS;
121 }
122
TestEccSetPrvKey(TestEccKeyCtx * ctx,const BSL_Param * para)123 static int32_t TestEccSetPrvKey(TestEccKeyCtx *ctx, const BSL_Param *para)
124 {
125 if (ctx == NULL || para == NULL) {
126 return CRYPT_NULL_INPUT;
127 }
128 const BSL_Param *prv = TestFindConstParam(para, CRYPT_PARAM_EC_PRVKEY);
129 if (prv == NULL || prv->value == NULL || prv->valueLen == 0) {
130 return CRYPT_NULL_INPUT;
131 }
132 (void)memcpy(ctx->prvkey, prv->value, prv->valueLen);
133 ctx->prvkeyLen = prv->valueLen;
134 return CRYPT_SUCCESS;
135 }
136
TestEccSetPubKey(TestEccKeyCtx * ctx,const BSL_Param * para)137 static int32_t TestEccSetPubKey(TestEccKeyCtx *ctx, const BSL_Param *para)
138 {
139 if (ctx == NULL || para == NULL) {
140 return CRYPT_NULL_INPUT;
141 }
142 const BSL_Param *pub = TestFindConstParam(para, CRYPT_PARAM_EC_PUBKEY);
143 if (pub == NULL) {
144 pub = TestFindConstParam(para, CRYPT_PARAM_PKEY_ENCODE_PUBKEY);
145 }
146 if (pub == NULL || pub->value == NULL || pub->valueLen == 0) {
147 return CRYPT_NULL_INPUT;
148 }
149 (void)memcpy(ctx->pubkey, pub->value, pub->valueLen);
150 ctx->pubkeyLen = pub->valueLen;
151 return CRYPT_SUCCESS;
152 }
153
TestEccGetPrvKey(TestEccKeyCtx * ctx,BSL_Param * para)154 static int32_t TestEccGetPrvKey(TestEccKeyCtx *ctx, BSL_Param *para)
155 {
156 if (ctx == NULL || para == NULL) {
157 return CRYPT_NULL_INPUT;
158 }
159 BSL_Param *prv = TestFindParam(para, CRYPT_PARAM_EC_PRVKEY);
160 if (prv == NULL || prv->value == NULL) {
161 return CRYPT_NULL_INPUT;
162 }
163 if (prv->valueLen < ctx->prvkeyLen) {
164 return CRYPT_ECDSA_BUFF_LEN_NOT_ENOUGH;
165 }
166 (void)memcpy(prv->value, ctx->prvkey, ctx->prvkeyLen);
167 prv->useLen = ctx->prvkeyLen;
168 return CRYPT_SUCCESS;
169 }
170
TestEccGetPubKey(TestEccKeyCtx * ctx,BSL_Param * para)171 static int32_t TestEccGetPubKey(TestEccKeyCtx *ctx, BSL_Param *para)
172 {
173 if (ctx == NULL || para == NULL) {
174 return CRYPT_NULL_INPUT;
175 }
176 BSL_Param *pub = TestFindParam(para, CRYPT_PARAM_EC_PUBKEY);
177 if (pub == NULL) {
178 pub = TestFindParam(para, CRYPT_PARAM_PKEY_ENCODE_PUBKEY);
179 }
180 if (pub == NULL || pub->value == NULL || pub->valueLen == 0) {
181 return CRYPT_NULL_INPUT;
182 }
183 if (ctx->pubkey == NULL) {
184 return CRYPT_ECC_PKEY_ERR_EMPTY_KEY;
185 }
186 (void)memcpy(para->value, ctx->pubkey, ctx->pubkeyLen);
187 para->useLen = ctx->pubkeyLen;
188 return CRYPT_SUCCESS;
189 }
190
TestEccDupCtx(const void * ctx)191 static void *TestEccDupCtx(const void *ctx)
192 {
193 void *dest = malloc(sizeof(TestEccKeyCtx));
194 if (dest == NULL) {
195 return NULL;
196 }
197 (void)memcpy(dest, ctx, sizeof(TestEccKeyCtx));
198 return dest;
199 }
200
TestEccCtrl(TestEccKeyCtx * ctx,int32_t cmd,void * val,uint32_t valLen)201 int32_t TestEccCtrl(TestEccKeyCtx *ctx, int32_t cmd, void *val, uint32_t valLen)
202 {
203 if (ctx == NULL || val == NULL || valLen == 0) {
204 return CRYPT_NULL_INPUT;
205 }
206 switch (cmd) {
207 case CRYPT_CTRL_GET_SECBITS:
208 *((uint32_t *)val) = ctx->paraId == BSL_CID_SECP384R1 ? 128 : 1024;
209 break;
210 case CRYPT_CTRL_GET_PARAID:
211 *((int32_t *)val) = ctx->paraId;
212 break;
213 case CRYPT_CTRL_SET_PARA_BY_ID:
214 if (*((int32_t *)val) != BSL_CID_SECP384R1 && *((int32_t *)val) != NEW_PARA_ALGID) {
215 return CRYPT_INVALID_ARG;
216 }
217 ctx->paraId = *((int32_t *)val);
218 break;
219 case CRYPT_CTRL_GET_SIGNLEN:
220 *((uint32_t *)val) = TEST_CRYPT_DEFAULT_SIGNLEN;
221 break;
222 default:
223 return CRYPT_NOT_SUPPORT;
224 }
225 return CRYPT_SUCCESS;
226 }
227
TestEccSign(const TestEccKeyCtx * ctx,int32_t algId,const uint8_t * data,uint32_t dataLen,uint8_t * sign,uint32_t * signLen)228 static int32_t TestEccSign(const TestEccKeyCtx *ctx, int32_t algId, const uint8_t *data, uint32_t dataLen,
229 uint8_t *sign, uint32_t *signLen)
230 {
231 (void)algId;
232 if (ctx == NULL || data == NULL || sign == NULL || signLen == NULL) {
233 return CRYPT_NULL_INPUT;
234 }
235 if (*signLen < TEST_CRYPT_DEFAULT_SIGNLEN) {
236 return CRYPT_INVALID_ARG;
237 }
238 sign[0] = 0x30;
239 sign[1] = 0x44;
240 sign[2] = 0x02;
241 sign[3] = 0x20;
242 for (size_t i = 0; i < 32; i++) {
243 sign[i + 4] = ctx->pubkey[i];
244 }
245 sign[36] = 0x02;
246 sign[37] = 0x20;
247 for (size_t i = 0; i < 32; i++) {
248 sign[i + 38] = ctx->pubkey[i + 32];
249 }
250 *signLen = TEST_CRYPT_DEFAULT_SIGNLEN;
251 return CRYPT_SUCCESS;
252 }
253
TestEccFreeCtx(TestEccKeyCtx * ctx)254 static void TestEccFreeCtx(TestEccKeyCtx *ctx)
255 {
256 if (ctx != NULL) {
257 free(ctx);
258 }
259 }
260
TestEccVerify(const TestEccKeyCtx * ctx,int32_t algId,const uint8_t * data,uint32_t dataLen,const uint8_t * sign,uint32_t signLen)261 static int32_t TestEccVerify(const TestEccKeyCtx *ctx, int32_t algId, const uint8_t *data, uint32_t dataLen,
262 const uint8_t *sign, uint32_t signLen)
263 {
264 (void)algId;
265 (void)data;
266 (void)dataLen;
267 if (ctx == NULL || sign == NULL || signLen == 0) {
268 return CRYPT_NULL_INPUT;
269 }
270 if (signLen < TEST_CRYPT_DEFAULT_SIGNLEN) {
271 return CRYPT_INVALID_ARG;
272 }
273 if (sign[0] != 0x30 || sign[1] != 0x44) {
274 return CRYPT_ECDSA_VERIFY_FAIL;
275 }
276 if (sign[2] != 0x02 || sign[3] != 0x20) {
277 return CRYPT_ECDSA_VERIFY_FAIL;
278 }
279 if (sign[36] != 0x02 || sign[37] != 0x20) {
280 return CRYPT_ECDSA_VERIFY_FAIL;
281 }
282 if (memcmp(ctx->pubkey, sign + 4, 32) != 0) {
283 return CRYPT_ECDSA_VERIFY_FAIL;
284 }
285 if (memcmp(ctx->pubkey + 32, sign + 38, 32) != 0) {
286 return CRYPT_ECDSA_VERIFY_FAIL;
287 }
288
289 return CRYPT_SUCCESS;
290 }
291
TestEccPkeyExch(const TestEccKeyCtx * ctx,const TestEccKeyCtx * pubCtx,uint8_t * out,uint32_t * outLen)292 static int32_t TestEccPkeyExch(const TestEccKeyCtx *ctx, const TestEccKeyCtx *pubCtx, uint8_t *out, uint32_t *outLen)
293 {
294 if (ctx == NULL || pubCtx == NULL || out == NULL || outLen == NULL) {
295 return CRYPT_NULL_INPUT;
296 }
297 int32_t len = pubCtx->pubkeyLen < ctx->pubkeyLen ? pubCtx->pubkeyLen : ctx->pubkeyLen;
298 for (uint32_t i = 0; i < len; i++) {
299 out[i] = (ctx->pubkey[i] + pubCtx->pubkey[i]) % 256;
300 }
301 *outLen = len;
302 return CRYPT_SUCCESS;
303 }
304
TestEccImport(void * ctx,const BSL_Param * params)305 int32_t TestEccImport(void *ctx, const BSL_Param *params)
306 {
307 if (ctx == NULL || params == NULL) {
308 return CRYPT_NULL_INPUT;
309 }
310 int32_t ret = CRYPT_SUCCESS;
311 const BSL_Param *curve = TestFindConstParam(params, CRYPT_PARAM_EC_CURVE_ID);
312 const BSL_Param *pub = TestFindConstParam(params, CRYPT_PARAM_EC_PUBKEY);
313 const BSL_Param *prv = TestFindConstParam(params, CRYPT_PARAM_EC_PRVKEY);
314 if (curve != NULL) {
315 ret = TestEccSetPara(ctx, params);
316 if (ret != CRYPT_SUCCESS) {
317 return ret;
318 }
319 }
320 if (pub != NULL) {
321 ret = TestEccSetPubKey(ctx, params);
322 if (ret != CRYPT_SUCCESS) {
323 return ret;
324 }
325 }
326 if (prv != NULL) {
327 ret = TestEccSetPrvKey(ctx, params);
328 if (ret != CRYPT_SUCCESS) {
329 return ret;
330 }
331 }
332 return ret;
333 }
334
TestEccExport(void * ctx,BSL_Param * params)335 int32_t TestEccExport(void *ctx, BSL_Param *params)
336 {
337 (void)ctx;
338 (void)params;
339 return CRYPT_SUCCESS;
340 }
341
TestPkeyMgmtKemNewCtx(void * provCtx,int32_t algId)342 void *TestPkeyMgmtKemNewCtx(void *provCtx, int32_t algId)
343 {
344 TestKemKeyCtx *ctx = NULL;
345 if (algId != NEW_KEM_ALGID) {
346 return NULL;
347 }
348 ctx = (TestKemKeyCtx *)malloc(sizeof(TestKemKeyCtx));
349 if (ctx == NULL) {
350 return NULL;
351 }
352 memset(ctx, 0, sizeof(TestKemKeyCtx));
353 return ctx;
354 }
355
TestKemGenKey(TestKemKeyCtx * ctx)356 static int32_t TestKemGenKey(TestKemKeyCtx *ctx)
357 {
358 if (ctx == NULL) {
359 return CRYPT_NULL_INPUT;
360 }
361 if (ctx->paraId == NEW_KEM_PARAM_ID) {
362 ctx->pubkeyLen = 20;
363 } else {
364 return CRYPT_INVALID_ARG;
365 }
366 RandFunc(ctx->pubkey, ctx->pubkeyLen);
367 return CRYPT_SUCCESS;
368 }
369
TestKemSetPubKey(TestKemKeyCtx * ctx,const BSL_Param * para)370 static int32_t TestKemSetPubKey(TestKemKeyCtx *ctx, const BSL_Param *para)
371 {
372 if (ctx == NULL || para == NULL) {
373 return CRYPT_NULL_INPUT;
374 }
375 const BSL_Param *pub = TestFindConstParam(para, CRYPT_PARAM_PKEY_ENCODE_PUBKEY);
376 if (pub == NULL || pub->value == NULL || pub->valueLen == 0) {
377 return CRYPT_NULL_INPUT;
378 }
379 (void)memcpy(ctx->pubkey, pub->value, pub->valueLen);
380 ctx->pubkeyLen = pub->valueLen;
381 return CRYPT_SUCCESS;
382 }
383
TestKemGetPubKey(const TestKemKeyCtx * ctx,BSL_Param * para)384 static int32_t TestKemGetPubKey(const TestKemKeyCtx *ctx, BSL_Param *para)
385 {
386 if (ctx == NULL || para == NULL) {
387 return CRYPT_NULL_INPUT;
388 }
389 BSL_Param *pub = (BSL_Param *)(uintptr_t)TestFindConstParam(para, CRYPT_PARAM_PKEY_ENCODE_PUBKEY);
390 if (pub == NULL || pub->value == NULL || pub->valueLen == 0) {
391 return CRYPT_NULL_INPUT;
392 }
393 (void)memcpy(pub->value, ctx->pubkey, ctx->pubkeyLen);
394 pub->useLen = ctx->pubkeyLen;
395 return CRYPT_SUCCESS;
396 }
397
TestKemCtrl(TestKemKeyCtx * ctx,int32_t cmd,void * val,uint32_t valLen)398 static int32_t TestKemCtrl(TestKemKeyCtx *ctx, int32_t cmd, void *val, uint32_t valLen)
399 {
400 if (ctx == NULL || val == NULL || valLen == 0) {
401 return CRYPT_NULL_INPUT;
402 }
403 switch (cmd) {
404 case CRYPT_CTRL_SET_PARA_BY_ID:
405 if (*((int32_t *)val) != NEW_KEM_PARAM_ID) {
406 return CRYPT_INVALID_ARG;
407 }
408 ctx->paraId = *((int32_t *)val);
409 break;
410 default:
411 return CRYPT_NOT_SUPPORT;
412 }
413 return CRYPT_SUCCESS;
414 }
415
TestKemFreeCtx(TestKemKeyCtx * ctx)416 static void TestKemFreeCtx(TestKemKeyCtx *ctx)
417 {
418 if (ctx != NULL) {
419 free(ctx);
420 }
421 }
422
423 const CRYPT_EAL_Func g_testKeyMgmtEcdsa[] = {
424 {CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)TestPkeyMgmtEcNewCtx},
425 {CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)TestEccSetPara},
426 {CRYPT_EAL_IMPLPKEYMGMT_GETPARAM, (CRYPT_EAL_ImplPkeyMgmtGetParam)TestEccGetParaPara},
427 {CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)TestEccGenKey},
428 {CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)TestEccSetPrvKey},
429 {CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)TestEccSetPubKey},
430 {CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)TestEccGetPrvKey},
431 {CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)TestEccGetPubKey},
432 {CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)TestEccDupCtx},
433 {CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)TestEccCtrl},
434 {CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)TestEccFreeCtx},
435 {CRYPT_EAL_IMPLPKEYMGMT_IMPORT, (CRYPT_EAL_ImplPkeyMgmtImport)TestEccImport},
436 {CRYPT_EAL_IMPLPKEYMGMT_EXPORT, (CRYPT_EAL_ImplPkeyMgmtExport)TestEccExport},
437 CRYPT_EAL_FUNC_END,
438 };
439
440 const CRYPT_EAL_Func g_testKeyMgmtEcdh[] = {
441 {CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)TestPkeyMgmtEcNewCtx},
442 {CRYPT_EAL_IMPLPKEYMGMT_SETPARAM, (CRYPT_EAL_ImplPkeyMgmtSetParam)TestEccSetPara},
443 {CRYPT_EAL_IMPLPKEYMGMT_GETPARAM, (CRYPT_EAL_ImplPkeyMgmtGetParam)TestEccGetParaPara},
444 {CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)TestEccGenKey},
445 {CRYPT_EAL_IMPLPKEYMGMT_SETPRV, (CRYPT_EAL_ImplPkeyMgmtSetPrv)TestEccSetPrvKey},
446 {CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)TestEccSetPubKey},
447 {CRYPT_EAL_IMPLPKEYMGMT_GETPRV, (CRYPT_EAL_ImplPkeyMgmtGetPrv)TestEccGetPrvKey},
448 {CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)TestEccGetPubKey},
449 {CRYPT_EAL_IMPLPKEYMGMT_DUPCTX, (CRYPT_EAL_ImplPkeyMgmtDupCtx)TestEccDupCtx},
450 {CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)TestEccCtrl},
451 {CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)TestEccFreeCtx},
452 CRYPT_EAL_FUNC_END,
453 };
454
455
456 const CRYPT_EAL_Func g_testKeyMgmtKem[] = {
457 {CRYPT_EAL_IMPLPKEYMGMT_NEWCTX, (CRYPT_EAL_ImplPkeyMgmtNewCtx)TestPkeyMgmtKemNewCtx},
458 {CRYPT_EAL_IMPLPKEYMGMT_GENKEY, (CRYPT_EAL_ImplPkeyMgmtGenKey)TestKemGenKey},
459 {CRYPT_EAL_IMPLPKEYMGMT_SETPUB, (CRYPT_EAL_ImplPkeyMgmtSetPub)TestKemSetPubKey},
460 {CRYPT_EAL_IMPLPKEYMGMT_GETPUB, (CRYPT_EAL_ImplPkeyMgmtGetPub)TestKemGetPubKey},
461 {CRYPT_EAL_IMPLPKEYMGMT_CTRL, (CRYPT_EAL_ImplPkeyMgmtCtrl)TestKemCtrl},
462 {CRYPT_EAL_IMPLPKEYMGMT_FREECTX, (CRYPT_EAL_ImplPkeyMgmtFreeCtx)TestKemFreeCtx},
463 CRYPT_EAL_FUNC_END,
464 };
465
466 const CRYPT_EAL_Func g_testEcdsaSign[] = {
467 {CRYPT_EAL_IMPLPKEYSIGN_SIGN, (CRYPT_EAL_ImplPkeySign)TestEccSign},
468 {CRYPT_EAL_IMPLPKEYSIGN_VERIFY, (CRYPT_EAL_ImplPkeyVerify)TestEccVerify},
469 CRYPT_EAL_FUNC_END,
470 };
471
472 const CRYPT_EAL_Func g_testExchDh[] = {
473 {CRYPT_EAL_IMPLPKEYEXCH_EXCH, (CRYPT_EAL_ImplPkeyExch)TestEccPkeyExch},
474 CRYPT_EAL_FUNC_END
475 };
476
TestKemEncapsulate(const void * pkey,uint8_t * cipher,uint32_t * cipherLen,uint8_t * out,uint32_t * outLen)477 static int32_t TestKemEncapsulate(const void *pkey, uint8_t *cipher, uint32_t *cipherLen, uint8_t *out, uint32_t *outLen)
478 {
479 TestKemKeyCtx *ctx = (TestKemKeyCtx *)(uintptr_t)pkey;
480 if (ctx == NULL || cipherLen == NULL || cipher == NULL) {
481 return CRYPT_NULL_INPUT;
482 }
483 if (*cipherLen < 40 || ctx->pubkeyLen != 20) {
484 return CRYPT_INVALID_ARG;
485 }
486 ctx->sharedLen = 20;
487 RandFunc(ctx->shared, ctx->sharedLen);
488 memcpy(cipher, ctx->pubkey, ctx->pubkeyLen);
489 memcpy(&cipher[ctx->pubkeyLen], ctx->shared, ctx->sharedLen);
490 memcpy(out, ctx->shared, ctx->sharedLen);
491 *outLen = ctx->sharedLen;
492 *cipherLen = ctx->pubkeyLen + ctx->sharedLen;
493 return CRYPT_SUCCESS;
494 }
495
TestKemDecapsulate(const void * pkey,uint8_t * data,uint32_t dataLen,uint8_t * out,uint32_t * outLen)496 static int32_t TestKemDecapsulate(const void *pkey, uint8_t *data, uint32_t dataLen, uint8_t *out, uint32_t *outLen)
497 {
498 const TestKemKeyCtx *ctx = pkey;
499 if (dataLen != 40 || ctx->pubkeyLen != 20 || *outLen < 20) {
500 return CRYPT_INVALID_ARG;
501 }
502 if (memcmp(data, ctx->pubkey, ctx->pubkeyLen) != 0) {
503 return CRYPT_INVALID_ARG;
504 }
505 memcpy(out, &data[ctx->pubkeyLen], dataLen - ctx->pubkeyLen);
506 *outLen = dataLen - ctx->pubkeyLen; // 20
507 return CRYPT_SUCCESS;
508 }
509
510 const CRYPT_EAL_Func g_testKemInfo[] = {
511 {CRYPT_EAL_IMPLPKEYKEM_ENCAPSULATE, (CRYPT_EAL_ImplPkeyKemEncapsulate)TestKemEncapsulate},
512 {CRYPT_EAL_IMPLPKEYKEM_DECAPSULATE, (CRYPT_EAL_ImplPkeyKemDecapsulate)TestKemDecapsulate},
513 CRYPT_EAL_FUNC_END
514 };
515
516 static CRYPT_EAL_AlgInfo g_testKeyMgmt[] = {
517 {CRYPT_PKEY_ECDSA, g_testKeyMgmtEcdsa, "provider=provider_get_cap_test1"}, // For computing sign
518 {NEW_PKEY_ALGID, g_testKeyMgmtEcdh, "provider=provider_get_cap_test1"}, // For computing the shared key
519 {NEW_KEM_ALGID, g_testKeyMgmtKem, "provider=provider_get_cap_test1"}, // For computing the shared key
520 CRYPT_EAL_ALGINFO_END
521 };
522
523 static CRYPT_EAL_AlgInfo g_testSign[] = {
524 {CRYPT_PKEY_ECDSA, g_testEcdsaSign, "provider=provider_get_cap_test1"}, // ecdsa nistp2516 sign
525 CRYPT_EAL_ALGINFO_END
526 };
527
528 static CRYPT_EAL_AlgInfo g_testKeyExch[] = {
529 {NEW_PKEY_ALGID, g_testExchDh, "provider=provider_get_cap_test1"}, // For computing the shared key
530 CRYPT_EAL_ALGINFO_END
531 };
532
TEST_DRBG_RandNewCtx(void * provCtx,int32_t algId,BSL_Param * param)533 void *TEST_DRBG_RandNewCtx(void *provCtx, int32_t algId, BSL_Param *param)
534 {
535 (void)provCtx;
536 (void)algId;
537 (void)param;
538 return malloc(1);
539 }
540
TEST_DRBG_Instantiate(void * ctx,const uint8_t * person,uint32_t persLen,BSL_Param * param)541 int32_t TEST_DRBG_Instantiate(void *ctx, const uint8_t *person, uint32_t persLen, BSL_Param *param)
542 {
543 (void)ctx;
544 (void)person;
545 (void)persLen;
546 (void)param;
547 return CRYPT_SUCCESS;
548 }
549
TEST_DRBG_Uninstantiate(void * ctx)550 int32_t TEST_DRBG_Uninstantiate(void *ctx)
551 {
552 (void)ctx;
553 return CRYPT_SUCCESS;
554 }
555
TEST_DRBG_Generate(void * ctx,uint8_t * out,uint32_t outLen,const uint8_t * adin,uint32_t adinLen,BSL_Param * param)556 int32_t TEST_DRBG_Generate(void *ctx, uint8_t *out, uint32_t outLen,
557 const uint8_t *adin, uint32_t adinLen, BSL_Param *param)
558 {
559 (void)ctx;
560 (void)adin;
561 (void)adinLen;
562 (void)param;
563 RandFunc(out, outLen);
564 return CRYPT_SUCCESS;
565 }
566
TEST_DRBG_Reseed(void * ctx,const uint8_t * adin,uint32_t adinLen,BSL_Param * param)567 int32_t TEST_DRBG_Reseed(void *ctx, const uint8_t *adin, uint32_t adinLen, BSL_Param *param)
568 {
569 (void)ctx;
570 (void)adin;
571 (void)adinLen;
572 (void)param;
573 return CRYPT_SUCCESS;
574 }
575
TEST_DRBG_Ctrl(void * ctx,int32_t cmd,void * val,uint32_t valLen)576 int32_t TEST_DRBG_Ctrl(void *ctx, int32_t cmd, void *val, uint32_t valLen)
577 {
578 (void)ctx;
579 (void)cmd;
580 (void)val;
581 (void)valLen;
582 return CRYPT_SUCCESS;
583 }
584
TEST_DRBG_Free(void * ctx)585 void TEST_DRBG_Free(void *ctx)
586 {
587 free(ctx);
588 }
589
590 const CRYPT_EAL_Func g_testRand[] = {
591 {CRYPT_EAL_IMPLRAND_DRBGNEWCTX, (CRYPT_EAL_ImplRandDrbgNewCtx)TEST_DRBG_RandNewCtx},
592 {CRYPT_EAL_IMPLRAND_DRBGINST, (CRYPT_EAL_ImplRandDrbgInst)TEST_DRBG_Instantiate},
593 {CRYPT_EAL_IMPLRAND_DRBGUNINST, (CRYPT_EAL_ImplRandDrbgUnInst)TEST_DRBG_Uninstantiate},
594 {CRYPT_EAL_IMPLRAND_DRBGGEN, (CRYPT_EAL_ImplRandDrbgGen)TEST_DRBG_Generate},
595 {CRYPT_EAL_IMPLRAND_DRBGRESEED, (CRYPT_EAL_ImplRandDrbgReSeed)TEST_DRBG_Reseed},
596 {CRYPT_EAL_IMPLRAND_DRBGCTRL, (CRYPT_EAL_ImplRandDrbgCtrl)TEST_DRBG_Ctrl},
597 {CRYPT_EAL_IMPLRAND_DRBGFREECTX, (CRYPT_EAL_ImplRandDrbgFreeCtx)TEST_DRBG_Free},
598 CRYPT_EAL_FUNC_END,
599 };
600
601 static CRYPT_EAL_AlgInfo g_testRands[] = {
602 {CRYPT_RAND_SHA1, g_testRand, "provider=provider_get_cap_test1"},
603 {CRYPT_RAND_SHA224, g_testRand, "provider=provider_get_cap_test1"},
604 {CRYPT_RAND_SHA256, g_testRand, "provider=provider_get_cap_test1"},
605 {CRYPT_RAND_SHA384, g_testRand, "provider=provider_get_cap_test1"},
606 {CRYPT_RAND_SHA512, g_testRand, "provider=provider_get_cap_test1"},
607 {CRYPT_RAND_HMAC_SHA1, g_testRand, "provider=provider_get_cap_test1"},
608 {CRYPT_RAND_HMAC_SHA224, g_testRand, "provider=provider_get_cap_test1"},
609 {CRYPT_RAND_HMAC_SHA256, g_testRand, "provider=provider_get_cap_test1"},
610 {CRYPT_RAND_HMAC_SHA384, g_testRand, "provider=provider_get_cap_test1"},
611 {CRYPT_RAND_HMAC_SHA512, g_testRand, "provider=provider_get_cap_test1"},
612 {CRYPT_RAND_AES128_CTR, g_testRand, "provider=provider_get_cap_test1"},
613 {CRYPT_RAND_AES192_CTR, g_testRand, "provider=provider_get_cap_test1"},
614 {CRYPT_RAND_AES256_CTR, g_testRand, "provider=provider_get_cap_test1"},
615 {CRYPT_RAND_AES128_CTR_DF, g_testRand, "provider=provider_get_cap_test1"},
616 {CRYPT_RAND_AES192_CTR_DF, g_testRand, "provider=provider_get_cap_test1"},
617 {CRYPT_RAND_AES256_CTR_DF, g_testRand, "provider=provider_get_cap_test1"},
618 CRYPT_EAL_ALGINFO_END
619 };
620
621 static CRYPT_EAL_AlgInfo g_testKem[] = {
622 {NEW_KEM_ALGID, g_testKemInfo, "provider=provider_get_cap_test1"}, // For computing the shared key
623 CRYPT_EAL_ALGINFO_END
624 };
625
TestProvQuery(void * provCtx,int32_t operaId,CRYPT_EAL_AlgInfo ** algInfos)626 static int32_t TestProvQuery(void *provCtx, int32_t operaId, CRYPT_EAL_AlgInfo **algInfos)
627 {
628 (void)provCtx;
629 int32_t ret = CRYPT_SUCCESS;
630 switch (operaId) {
631 case CRYPT_EAL_OPERAID_KEYMGMT:
632 *algInfos = g_testKeyMgmt;
633 break;
634 case CRYPT_EAL_OPERAID_SIGN:
635 *algInfos = g_testSign;
636 break;
637 case CRYPT_EAL_OPERAID_KEYEXCH:
638 *algInfos = g_testKeyExch;
639 break;
640 case CRYPT_EAL_OPERAID_RAND:
641 *algInfos = g_testRands;
642 break;
643 case CRYPT_EAL_OPERAID_KEM:
644 *algInfos = g_testKem;
645 break;
646 default:
647 return CRYPT_NOT_SUPPORT;
648 }
649
650 return CRYPT_SUCCESS;
651 }
652
TestProvFree(void * provCtx)653 static int32_t TestProvFree(void *provCtx)
654 {
655 if (provCtx != NULL) {
656 free(provCtx);
657 }
658 return CRYPT_SUCCESS;
659 }
660
TestCryptGetSigAlgCaps(CRYPT_EAL_ProcessFuncCb cb,void * args)661 static int32_t TestCryptGetSigAlgCaps(CRYPT_EAL_ProcessFuncCb cb, void *args)
662 {
663 if (cb == NULL) {
664 return CRYPT_NULL_INPUT;
665 }
666 uint16_t signatureScheme = 23333;
667 int32_t keyType = CRYPT_PKEY_ECDSA;
668 int32_t paraId = BSL_CID_SECP384R1;
669 int32_t signHashAlgId = NEW_SIGN_HASH_ALGID;
670 int32_t signAlgId = CRYPT_PKEY_ECDSA;
671 int32_t hashAlgId = NEW_HASH_ALGID;
672 int32_t secBits = 1024;
673 uint32_t certVersionBits = TLS12_VERSION_BIT | TLS13_VERSION_BIT;
674 uint32_t chainVersionBits = TLS12_VERSION_BIT | TLS13_VERSION_BIT;
675 BSL_Param param[] = {
676 {
677 CRYPT_PARAM_CAP_TLS_SIGNALG_IANA_SIGN_NAME,
678 BSL_PARAM_TYPE_OCTETS_PTR,
679 (void *)(uintptr_t)"test_new_sign_alg_name",
680 (uint32_t)strlen("test_new_sign_alg_name")
681 },
682 {
683 CRYPT_PARAM_CAP_TLS_SIGNALG_IANA_SIGN_ID,
684 BSL_PARAM_TYPE_UINT16,
685 (void *)(uintptr_t)&(signatureScheme),
686 sizeof(uint16_t)
687 },
688 {
689 CRYPT_PARAM_CAP_TLS_SIGNALG_KEY_TYPE,
690 BSL_PARAM_TYPE_INT32,
691 (void *)(uintptr_t)&(keyType),
692 sizeof(keyType)
693 },
694 {
695 CRYPT_PARAM_CAP_TLS_SIGNALG_PARA_ID,
696 BSL_PARAM_TYPE_INT32,
697 (void *)(uintptr_t)&(paraId),
698 sizeof(paraId)
699 },
700 {
701 CRYPT_PARAM_CAP_TLS_SIGNALG_SIGNWITHMD_ID,
702 BSL_PARAM_TYPE_INT32,
703 (void *)(uintptr_t)&(signHashAlgId),
704 sizeof(signHashAlgId)
705 },
706 {
707 CRYPT_PARAM_CAP_TLS_SIGNALG_SIGNWITHMD_OID,
708 BSL_PARAM_TYPE_OCTETS_PTR,
709 (void *)(uintptr_t)"\150\40\66\77\55", // 68 20 36 3F 2D
710 (uint32_t)strlen("\150\40\66\77\55")
711 },
712 {
713 CRYPT_PARAM_CAP_TLS_SIGNALG_SIGNWITHMD_NAME,
714 BSL_PARAM_TYPE_OCTETS_PTR,
715 (void *)(uintptr_t)"test_new_sign_with_md_name",
716 (uint32_t)strlen("test_new_sign_with_md_name")
717 },
718 {
719 CRYPT_PARAM_CAP_TLS_SIGNALG_SIGN_ID,
720 BSL_PARAM_TYPE_INT32,
721 (void *)(uintptr_t)&(signAlgId),
722 sizeof(signAlgId)
723 },
724 {
725 CRYPT_PARAM_CAP_TLS_SIGNALG_MD_ID,
726 BSL_PARAM_TYPE_INT32,
727 (void *)(uintptr_t)&(hashAlgId),
728 sizeof(hashAlgId)
729 },
730 {
731 CRYPT_PARAM_CAP_TLS_SIGNALG_MD_OID,
732 BSL_PARAM_TYPE_OCTETS_PTR,
733 (void *)(uintptr_t)"\150\40\66\71\55",
734 (uint32_t)strlen("\150\40\66\71\55")
735 },
736 {
737 CRYPT_PARAM_CAP_TLS_SIGNALG_MD_NAME,
738 BSL_PARAM_TYPE_OCTETS_PTR,
739 (void *)(uintptr_t)"test_new_md_name",
740 (uint32_t)strlen("test_new_md_name")
741 },
742 {
743 CRYPT_PARAM_CAP_TLS_SIGNALG_SEC_BITS,
744 BSL_PARAM_TYPE_INT32,
745 (void *)(uintptr_t)&(secBits),
746 sizeof(secBits)
747 },
748 {
749 CRYPT_PARAM_CAP_TLS_SIGNALG_CHAIN_VERSION_BITS,
750 BSL_PARAM_TYPE_UINT32,
751 (void *)(uintptr_t)&(chainVersionBits),
752 sizeof(chainVersionBits)
753 },
754 {
755 CRYPT_PARAM_CAP_TLS_SIGNALG_CERT_VERSION_BITS,
756 BSL_PARAM_TYPE_UINT32,
757 (void *)(uintptr_t)&(certVersionBits),
758 sizeof(certVersionBits)
759 }
760 };
761 return cb(param, args);
762 }
763
764 static const Provider_Group g_tlsGroupInfo[] = {
765 {
766 "test_new_group",
767 NEW_PARA_ALGID, // paraId
768 NEW_PKEY_ALGID, // algId
769 1024, // secBits
770 477, // groupId
771 143, // pubkeyLen
772 143, // sharedkeyLen
773 0, // ciphertextLen
774 TLS12_VERSION_BIT | TLS13_VERSION_BIT, // versionBits
775 false // isKem
776 },
777 {
778 "test_new_group_kem",
779 NEW_KEM_PARAM_ID, // paraId
780 NEW_KEM_ALGID, // algId
781 1024, // secBits
782 478, // groupId
783 20, // pubkeyLen
784 20, // sharedkeyLen
785 40, // ciphertextLen
786 TLS13_VERSION_BIT, // versionBits
787 true // isKem
788 }
789 };
790
TestProvGetCaps(void * provCtx,int32_t cmd,CRYPT_EAL_ProcessFuncCb cb,void * args)791 static int32_t TestProvGetCaps(void *provCtx, int32_t cmd, CRYPT_EAL_ProcessFuncCb cb, void *args)
792 {
793 switch (cmd) {
794 case CRYPT_EAL_GET_GROUP_CAP:
795 return TestCryptGetGroupCaps(g_tlsGroupInfo, sizeof(g_tlsGroupInfo) / sizeof(g_tlsGroupInfo[0]), cb, args);
796 case CRYPT_EAL_GET_SIGALG_CAP:
797 return TestCryptGetSigAlgCaps(cb, args);
798 default:
799 return CRYPT_NOT_SUPPORT;
800 }
801 }
802
803 static CRYPT_EAL_Func g_testProvOutFuncs[] = {
804 {CRYPT_EAL_PROVCB_QUERY, TestProvQuery},
805 {CRYPT_EAL_PROVCB_FREE, TestProvFree},
806 {CRYPT_EAL_PROVCB_CTRL, NULL},
807 {CRYPT_EAL_PROVCB_GETCAPS, TestProvGetCaps},
808 CRYPT_EAL_FUNC_END
809 };
810
CRYPT_EAL_ProviderInit(CRYPT_EAL_ProvMgrCtx * mgrCtx,BSL_Param * param,CRYPT_EAL_Func * capFuncs,CRYPT_EAL_Func ** outFuncs,void ** provCtx)811 int32_t CRYPT_EAL_ProviderInit(CRYPT_EAL_ProvMgrCtx *mgrCtx, BSL_Param *param,
812 CRYPT_EAL_Func *capFuncs, CRYPT_EAL_Func **outFuncs, void **provCtx)
813 {
814 *outFuncs = g_testProvOutFuncs;
815 return CRYPT_SUCCESS;
816 }
817