1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "hc_alg_test.h"
17
18 #include <alg_loader.h>
19 #include <device_auth.h>
20 #include <hal_error.h>
21 #include <hctest.h>
22 #include <stdlib.h>
23 #include <string_util.h>
24 #include <unistd.h>
25
26 #include "hc_alg_test_case.h"
27 #include "print_log.h"
28 #include "test_timer.h"
29
30 #define LOG_ERROR_IF_POINTER_NULL(pointer) LOGE("Pointer %s is %s", #pointer, ((pointer) == NULL ? "NULL" : "not NULL"))
31
32 #ifdef __cplusplus
33 extern "C" {
34 #endif
35
CountZero(const uint8_t * buffer,uint32_t length)36 static uint32_t CountZero(const uint8_t *buffer, uint32_t length)
37 {
38 uint32_t zeroCount = 0;
39 for (uint32_t i = 0; i < length; ++i) {
40 if (buffer[i] == 0) {
41 ++zeroCount;
42 }
43 }
44 return zeroCount;
45 }
46
FillRandom(uint8_t * msg,uint32_t setZeroLength,uint32_t randomLength)47 static void FillRandom(uint8_t *msg, uint32_t setZeroLength, uint32_t randomLength)
48 {
49 if (randomLength < 1) {
50 return;
51 }
52 int res;
53 res = memset_s(msg, setZeroLength, 0, setZeroLength);
54 TEST_ASSERT_EQUAL(EOK, res);
55
56 msg[0] = rand() % (UINT8_MAX - 1) + 1;
57 for (uint32_t i = 1; i < randomLength; ++i) {
58 msg[i] = rand() % UINT8_MAX;
59 }
60 enum {
61 // ignore rand correctness if the random length is equal or less than 3
62 RANDOM_CONSECUTIVE_ZERO_LENGTH_LIMIT = 3,
63 };
64 if (randomLength <= RANDOM_CONSECUTIVE_ZERO_LENGTH_LIMIT + 1) {
65 return;
66 }
67 TEST_ASSERT_NOT_EQUAL(randomLength - 1, CountZero(msg + 1, randomLength - 1));
68 }
69
70 // Note: sha256 and sha256Compare will be set to all zero
TestSha256Inner(const AlgLoader * loader,Uint8Buff * msg,Uint8Buff * sha256,Uint8Buff * sha256Compare)71 static void TestSha256Inner(
72 const AlgLoader *loader, Uint8Buff *msg, Uint8Buff *sha256, Uint8Buff *sha256Compare)
73 {
74 int res;
75 res = memset_s(sha256->val, SHA256_LEN, 0, SHA256_LEN);
76 TEST_ASSERT_EQUAL(EOK, res);
77 res = memset_s(sha256Compare->val, SHA256_LEN, 0, SHA256_LEN);
78 TEST_ASSERT_EQUAL(EOK, res);
79
80 RUN_AND_PRINT_ELAPSED_TIME(res, loader->sha256(msg, sha256));
81 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
82 TEST_ASSERT_EQUAL((uint32_t)SHA256_LEN, sha256->length);
83 RUN_AND_PRINT_ELAPSED_TIME(res, loader->sha256(msg, sha256Compare));
84 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
85 TEST_ASSERT_EQUAL((uint32_t)SHA256_LEN, sha256Compare->length);
86
87 uint32_t zeroCount = CountZero(sha256->val, sha256->length);
88 TEST_ASSERT_NOT_EQUAL_MESSAGE((uint32_t)SHA256_LEN, zeroCount, "invalid all zero sha256");
89 TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(sha256->val, sha256Compare->val, SHA256_LEN,
90 "different sha256 against the same message");
91 }
92
TestSha256(const AlgLoader * loader)93 static void TestSha256(const AlgLoader *loader)
94 {
95 TEST_ASSERT_NOT_NULL(loader->sha256);
96 if (loader->sha256 == NULL) {
97 LOGE("sha256 pointer is NULL! will not test!");
98 return;
99 }
100
101 Uint8Buff msg = { (uint8_t *)malloc(SHA256_MSG_MAX_SIZE), SHA256_MSG_MAX_SIZE };
102 TEST_ASSERT_NOT_NULL(msg.val);
103 Uint8Buff sha256 = { (uint8_t *)malloc(SHA256_LEN), SHA256_LEN };
104 TEST_ASSERT_NOT_NULL(sha256.val);
105 Uint8Buff sha256Compare = { (uint8_t *)malloc(SHA256_LEN), SHA256_LEN };
106 TEST_ASSERT_NOT_NULL(sha256Compare.val);
107
108 for (int i = 1; i <= SHA256_TEST_MIN_LIMIT; ++i) {
109 msg.length = i;
110 LOGI("test sha256 with msg length %d", msg.length);
111 FillRandom(msg.val, SHA256_MSG_MAX_SIZE, msg.length);
112 TestSha256Inner(loader, &msg, &sha256, &sha256Compare);
113 }
114
115 msg.length = SHA256_MSG_MAX_SIZE;
116 LOGI("test sha256 with max msg length %d", msg.length);
117 FillRandom(msg.val, SHA256_MSG_MAX_SIZE, msg.length);
118 TestSha256Inner(loader, &msg, &sha256, &sha256Compare);
119
120 for (int i = 0; i < SHA256_TEST_TIMES; ++i) {
121 msg.length = rand() % SHA256_MSG_MAX_SIZE + 1;
122 LOGI("test sha256 with random msg length %d", msg.length);
123 FillRandom(msg.val, SHA256_MSG_MAX_SIZE, msg.length);
124 TestSha256Inner(loader, &msg, &sha256, &sha256Compare);
125 }
126
127 msg.val = (uint8_t *)(SHA256_EXAMPLE_MESSAGE);
128 msg.length = strlen(SHA256_EXAMPLE_MESSAGE);
129 TestSha256Inner(loader, &msg, &sha256, &sha256Compare);
130 TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(sha256.val, SHA256_EXAMPLE_RESULT, SHA256_LEN,
131 "incorrect sha256 result");
132 PrintBuffer(SHA256_EXAMPLE_MESSAGE, sha256.val, sha256.length);
133
134 free(msg.val);
135 free(sha256.val);
136 free(sha256Compare.val);
137 }
138
TestGenerateRandomInner(const AlgLoader * loader,Uint8Buff * random)139 static void TestGenerateRandomInner(const AlgLoader *loader, Uint8Buff *random)
140 {
141 uint32_t randomLength = random->length;
142 int res;
143 res = memset_s(random->val, GEN_RANDOM_MAX_SIZE, 0, GEN_RANDOM_MAX_SIZE);
144 TEST_ASSERT_EQUAL(EOK, res);
145
146 RUN_AND_PRINT_ELAPSED_TIME(res, loader->generateRandom(random));
147 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
148 TEST_ASSERT_EQUAL(randomLength, random->length);
149
150 uint32_t zeroCount = CountZero(random->val, random->length);
151 TEST_ASSERT_NOT_EQUAL_MESSAGE(random->length, zeroCount, "random all zero");
152 }
153
TestGenerateRandomNoPeriodicRepetition(const AlgLoader * loader,Uint8Buff * previous,Uint8Buff * current)154 static void TestGenerateRandomNoPeriodicRepetition(const AlgLoader *loader,
155 Uint8Buff *previous,
156 Uint8Buff *current)
157 {
158 int res;
159 res = memset_s(previous->val, GEN_RANDOM_TEST_REPEAT_SIZE, 0, GEN_RANDOM_TEST_REPEAT_SIZE);
160 TEST_ASSERT_EQUAL(EOK, res);
161 for (int i = 0; i < GEN_RANDOM_TEST_REPEAT_TIMES; ++i) {
162 res = memset_s(current->val, GEN_RANDOM_TEST_REPEAT_SIZE, 0, GEN_RANDOM_TEST_REPEAT_SIZE);
163 TEST_ASSERT_EQUAL(EOK, res);
164 RUN_AND_PRINT_ELAPSED_TIME(res, loader->generateRandom(current));
165 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
166 TEST_ASSERT_EQUAL(GEN_RANDOM_TEST_REPEAT_SIZE, current->length);
167 int equalCount = 0;
168 for (int j = 0; j < GEN_RANDOM_TEST_REPEAT_SIZE; ++j) {
169 if (previous->val[j] == current->val[j]) {
170 ++equalCount;
171 }
172 }
173 TEST_ASSERT_NOT_EQUAL_MESSAGE(GEN_RANDOM_TEST_REPEAT_SIZE, equalCount,
174 "random is the same as previous generated");
175 res = memcpy_s(previous->val, GEN_RANDOM_TEST_REPEAT_SIZE, current->val, GEN_RANDOM_TEST_REPEAT_SIZE);
176 TEST_ASSERT_EQUAL(EOK, res);
177 }
178 }
179
TestGenerateRandom(const AlgLoader * loader)180 static void TestGenerateRandom(const AlgLoader *loader)
181 {
182 TEST_ASSERT_NOT_NULL(loader->generateRandom);
183 if (loader->generateRandom == NULL) {
184 LOGE("generateRandom pointer is NULL! will not test!");
185 return;
186 }
187
188 Uint8Buff random = { (uint8_t *)malloc(GEN_RANDOM_MAX_SIZE), GEN_RANDOM_MAX_SIZE };
189 TEST_ASSERT_NOT_NULL(random.val);
190
191 for (int i = 1; i <= GEN_RANDOM_MIN_LIMIT; ++i) {
192 random.length = i;
193 LOGI("test generate random with length %d", random.length);
194 TestGenerateRandomInner(loader, &random);
195 }
196
197 random.length = GEN_RANDOM_MAX_SIZE;
198 LOGI("test generate random with max length %d", random.length);
199 TestGenerateRandomInner(loader, &random);
200
201 for (int i = 0; i < GEN_RANDOM_TEST_TIMES; ++i) {
202 random.length = rand() % GEN_RANDOM_MAX_SIZE + 1;
203 LOGI("test generate random with random length %d", random.length);
204 TestGenerateRandomInner(loader, &random);
205 }
206
207 // test whether the random number is repeated
208 Uint8Buff previousUint8Buff = { (uint8_t *)malloc(GEN_RANDOM_TEST_REPEAT_SIZE), GEN_RANDOM_TEST_REPEAT_SIZE };
209 TEST_ASSERT_NOT_NULL(previousUint8Buff.val);
210 Uint8Buff currentUint8Buff = { (uint8_t *)malloc(GEN_RANDOM_TEST_REPEAT_SIZE), GEN_RANDOM_TEST_REPEAT_SIZE };
211 TEST_ASSERT_NOT_NULL(currentUint8Buff.val);
212
213 TestGenerateRandomNoPeriodicRepetition(loader, &previousUint8Buff, ¤tUint8Buff);
214
215 free(currentUint8Buff.val);
216 free(previousUint8Buff.val);
217 free(random.val);
218 }
219
220 // key will not be modified
221 // message will be malloced if message->val is NULL
222 // hmac will be clear with zero
TestComputeHmacInner(const AlgLoader * loader,const Uint8Buff * key,Uint8Buff * msg,Uint8Buff * hmac,bool isAlias)223 static void TestComputeHmacInner(
224 const AlgLoader *loader, const Uint8Buff *key, Uint8Buff *msg, Uint8Buff *hmac, bool isAlias)
225 {
226 int32_t res;
227 bool allocMemory = false;
228 if (msg->val == NULL) {
229 msg->val = (uint8_t *)malloc(msg->length);
230 TEST_ASSERT_NOT_NULL(msg->val);
231 allocMemory = true;
232 res = memset_s(msg->val, msg->length, 0, msg->length);
233 TEST_ASSERT_EQUAL(EOK, res);
234 FillRandom(msg->val, msg->length, msg->length);
235 }
236 res = memset_s(hmac->val, hmac->length, 0, hmac->length);
237 TEST_ASSERT_EQUAL(EOK, res);
238 RUN_AND_PRINT_ELAPSED_TIME(res, loader->computeHmac(key, msg, hmac, isAlias));
239 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
240
241 uint32_t zeroCount = CountZero(hmac->val, hmac->length);
242 TEST_ASSERT_NOT_EQUAL_MESSAGE(hmac->length, zeroCount, "invalid all zero hmac");
243
244 if (allocMemory && msg->val != NULL) {
245 free(msg->val);
246 msg->val = NULL;
247 }
248 }
249
TestComputeHmacWithIsAliasTrue(const AlgLoader * loader,Uint8Buff * msg,Uint8Buff * hmacKeyBuff,Uint8Buff * outHmacBuff)250 static void TestComputeHmacWithIsAliasTrue(const AlgLoader *loader,
251 Uint8Buff *msg, Uint8Buff *hmacKeyBuff, Uint8Buff *outHmacBuff)
252 #if TEST_COMPUTEHMAC_WITH_ISALIAS_TRUE
253 {
254 TEST_ASSERT_NOT_NULL(loader->importSymmetricKey);
255 if (!loader->importSymmetricKey) {
256 LOGE("importSymmetricKey is NULL, can not test computeHmac with isAlias true");
257 return;
258 }
259 LOGI("test hmac for isAlias true");
260 msg->val = (uint8_t *)NULL;
261 msg->length = TEST_HMAC_ISALIAS_TRUE_MSG_LENGTH;
262 FillRandom(hmacKeyBuff->val, hmacKeyBuff->length, hmacKeyBuff->length);
263 // write key with specified alias first, then do the test
264 const ExtraInfo info = {
265 .authId = *hmacKeyBuff,
266 .userType = DEVICE_TYPE_ACCESSORY,
267 .pairType = PAIR_TYPE_BIND,
268 };
269 int res = loader->importSymmetricKey(hmacKeyBuff, hmacKeyBuff, KEY_PURPOSE_MAC, &info);
270 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
271 TestComputeHmacInner(loader, hmacKeyBuff, msg, outHmacBuff, true);
272 // delete key after the test
273 if (loader->deleteKey) {
274 LOGD("test deleteKey");
275 res = loader->deleteKey(hmacKeyBuff);
276 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
277 }
278 }
279 #else // TEST_COMPUTEHMAC_WITH_ISALIAS_TRUE
280 {
281 LOGE("no TEST_COMPUTEHMAC_WITH_ISALIAS_TRUE, do not test computeHmac with isAlias true");
282 #if (defined(DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY) && DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY)
283 (void)(loader);
284 #else // DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY
285 TEST_ASSERT_NULL(loader->importSymmetricKey);
286 #endif // DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY
287 (void)(msg);
288 (void)(hmacKeyBuff);
289 (void)(outHmacBuff);
290 }
291 #endif // TEST_COMPUTEHMAC_WITH_ISALIAS_TRUE
292
TestComputeHmac(const AlgLoader * loader)293 static void TestComputeHmac(const AlgLoader *loader)
294 {
295 TEST_ASSERT_NOT_NULL(loader->computeHmac);
296 if (loader->computeHmac == NULL) {
297 LOGE("computeHmac pointer is NULL! will not test!");
298 return;
299 }
300
301 Uint8Buff hmacKeyBuff = { (uint8_t *)malloc(TEST_HMAC_KEY_LEN), TEST_HMAC_KEY_LEN };
302 TEST_ASSERT_NOT_NULL(hmacKeyBuff.val);
303 Uint8Buff msg = { (uint8_t *)NULL, 0 };
304 uint8_t *outHmac = (uint8_t *)malloc(HMAC_LEN);
305 TEST_ASSERT_NOT_NULL(outHmac);
306 Uint8Buff outHmacBuff = { (uint8_t *)outHmac, HMAC_LEN };
307
308 TestComputeHmacWithIsAliasTrue(loader, &msg, &hmacKeyBuff, &outHmacBuff);
309
310 LOGI("test hmac for isAlias false");
311 for (uint32_t i = 0; i < ARRAY_SIZE(TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_ARRAY); ++i) {
312 msg.val = (uint8_t *)NULL;
313 msg.length = TEST_HMAC_ISALIAS_FALSE_MSG_LENGTH_ARRAY[i];
314 LOGI("test hmac for msg length %d", msg.length);
315 FillRandom(hmacKeyBuff.val, hmacKeyBuff.length, hmacKeyBuff.length);
316 TestComputeHmacInner(loader, &hmacKeyBuff, &msg, &outHmacBuff, false);
317 }
318
319 free(hmacKeyBuff.val);
320 hmacKeyBuff.val = (uint8_t *)NULL;
321
322 LOGI("test the correctness of hmac");
323 hmacKeyBuff.val = (uint8_t *)(HMAC_EXAMPLE_KEY),
324 hmacKeyBuff.length = sizeof(HMAC_EXAMPLE_KEY);
325 msg.val = (uint8_t *)(HMAC_EXAMPLE_MESSAGE),
326 msg.length = strlen(HMAC_EXAMPLE_MESSAGE);
327 TestComputeHmacInner(loader, &hmacKeyBuff, &msg, &outHmacBuff, false);
328 TEST_ASSERT_EQUAL(sizeof(HMAC_EXAMPLE_RESULT), outHmacBuff.length);
329 TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(HMAC_EXAMPLE_RESULT, outHmacBuff.val, sizeof(HMAC_EXAMPLE_RESULT),
330 "incorrect hmac result");
331 PrintBuffer("hmac", outHmacBuff.val, outHmacBuff.length);
332
333 free(outHmac);
334 outHmac = NULL;
335 outHmacBuff.val = (uint8_t *)NULL;
336 }
337
338 struct HkdfArgument {
339 Uint8Buff baseKey;
340 Uint8Buff salt;
341 Uint8Buff keyInfo;
342 Uint8Buff outHkdf;
343 bool isAlias;
344 };
345
346 // baseKey, salt will be malloced and fill random if NULL
347 // keyInfo, isAlias will not be modified
348 // outHkdf will be clear with zero
TestComputeHkdfInner(const AlgLoader * loader,struct HkdfArgument * arg)349 static void TestComputeHkdfInner(
350 const AlgLoader *loader, struct HkdfArgument *arg)
351 {
352 bool baseAlloced = false, saltAlloced = false;
353 if (arg->baseKey.val == NULL) {
354 arg->baseKey.val = (uint8_t *)malloc(arg->baseKey.length);
355 TEST_ASSERT_NOT_NULL(arg->baseKey.val);
356 baseAlloced = true;
357 FillRandom(arg->baseKey.val, arg->baseKey.length, arg->baseKey.length);
358 }
359 if (arg->salt.val == NULL) {
360 arg->salt.val = (uint8_t *)malloc(arg->salt.length);
361 TEST_ASSERT_NOT_NULL(arg->salt.val);
362 saltAlloced = true;
363 FillRandom(arg->salt.val, arg->salt.length, arg->salt.length);
364 }
365 int32_t res;
366 res = memset_s(arg->outHkdf.val, arg->outHkdf.length, 0, arg->outHkdf.length);
367 TEST_ASSERT_EQUAL(EOK, res);
368 RUN_AND_PRINT_ELAPSED_TIME(
369 res,
370 loader->computeHkdf(
371 &arg->baseKey, &arg->salt, &arg->keyInfo, &arg->outHkdf, arg->isAlias));
372 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
373 if (saltAlloced && arg->salt.val != NULL) {
374 free(arg->salt.val);
375 arg->salt.val = (uint8_t *)NULL;
376 }
377 if (baseAlloced && arg->baseKey.val != NULL) {
378 free(arg->baseKey.val);
379 arg->baseKey.val = (uint8_t *)NULL;
380 }
381
382 uint32_t zeroCount = CountZero(arg->outHkdf.val, arg->outHkdf.length);
383 TEST_ASSERT_NOT_EQUAL_MESSAGE(arg->outHkdf.length, zeroCount, "invalid all zero hkdf result");
384 }
385
386 #if TEST_HKDF_WITH_KEY_ALIAS_TRUE // {
TestComputeHkdfWithKeyAliasTrueFirstAndSecondStep(const AlgLoader * loader,Uint8Buff * privKeyPairAlias,Uint8Buff * pubKeyPairAlias,ExtraInfo * extraInfo,Uint8Buff * sharedKeyAlias)387 static void TestComputeHkdfWithKeyAliasTrueFirstAndSecondStep(
388 const AlgLoader *loader,
389 Uint8Buff *privKeyPairAlias,
390 Uint8Buff *pubKeyPairAlias,
391 ExtraInfo *extraInfo,
392 Uint8Buff *sharedKeyAlias)
393 {
394 LOGI("First, generate two pairs of public-private key pairs");
395 TEST_ASSERT_EQUAL(HAL_SUCCESS,
396 loader->generateKeyPairWithStorage(privKeyPairAlias,
397 TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH, ED25519, extraInfo));
398 TEST_ASSERT_EQUAL(HAL_SUCCESS,
399 loader->generateKeyPairWithStorage(pubKeyPairAlias,
400 TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH, ED25519, extraInfo));
401
402 LOGI("Second, agree shared key with privateKey and publicKey");
403 KeyBuff privKeyBuff = { privKeyPairAlias->val, privKeyPairAlias->length, true };
404 KeyBuff pubKeyBuff = { pubKeyPairAlias->val, pubKeyPairAlias->length, true };
405 TEST_ASSERT_EQUAL(HAL_SUCCESS,
406 loader->agreeSharedSecretWithStorage(&privKeyBuff, &pubKeyBuff, ED25519,
407 TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_SHARED_KEY_LENGTH, sharedKeyAlias));
408 }
409
TestComputeHkdfWithKeyAliasTrueThirdStep(const AlgLoader * loader,struct HkdfArgument * argument,Uint8Buff * sharedKeyAlias)410 static void TestComputeHkdfWithKeyAliasTrueThirdStep(
411 const AlgLoader *loader,
412 struct HkdfArgument *argument,
413 Uint8Buff *sharedKeyAlias)
414 {
415 LOGI("Third, compute hkdf with shared key");
416 argument->baseKey = *sharedKeyAlias;
417 argument->salt.val = (uint8_t *)NULL;
418 argument->salt.length = HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_SALT_LEN;
419 argument->keyInfo.val = (uint8_t *)(TMP_AUTH_KEY_FACTOR);
420 argument->keyInfo.length = strlen(TMP_AUTH_KEY_FACTOR);
421 argument->outHkdf.val = (uint8_t *)malloc(HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_OUTKEY_LEN);
422 TEST_ASSERT_NOT_NULL(argument->outHkdf.val);
423 argument->outHkdf.length = HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_OUTKEY_LEN;
424 argument->isAlias = true;
425 TestComputeHkdfInner(loader, argument);
426 free(argument->outHkdf.val);
427 argument->outHkdf.val = (uint8_t *)NULL;
428 }
429
TestComputeHkdfWithKeyAliasTrue(const AlgLoader * loader,struct HkdfArgument * argument)430 static void TestComputeHkdfWithKeyAliasTrue(
431 const AlgLoader *loader,
432 struct HkdfArgument *argument)
433 {
434 LOGI("pake psk derive secret keyAlias true");
435 TEST_ASSERT_NOT_NULL(loader->generateKeyPairWithStorage);
436 TEST_ASSERT_NOT_NULL(loader->agreeSharedSecretWithStorage);
437 if (!loader->generateKeyPairWithStorage || !loader->agreeSharedSecretWithStorage) {
438 LOGE("generateKeyPairWithStorage or agreeSharedSecretWithStorage pointer is NULL! "
439 "can not test hkdf with alias true!");
440 return;
441 }
442
443 Uint8Buff privKeyPairAlias = { (uint8_t *)malloc(TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH),
444 TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH };
445 Uint8Buff pubKeyPairAlias = { (uint8_t *)malloc(TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH),
446 TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_KEY_PAIR_KEY_ALIAS_LENGTH };
447 ExtraInfo extraInfo = { { (uint8_t *)malloc(TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_AUTH_ID_LENGTH),
448 TEST_COMPUTE_HKDF_WITH_KEY_ALIAS_TRUE_AUTH_ID_LENGTH },
449 DEVICE_TYPE_ACCESSORY, PAIR_TYPE_BIND };
450 TEST_ASSERT_NOT_NULL(privKeyPairAlias.val);
451 TEST_ASSERT_NOT_NULL(pubKeyPairAlias.val);
452 TEST_ASSERT_NOT_NULL(extraInfo.authId.val);
453 FillRandom(privKeyPairAlias.val, privKeyPairAlias.length, privKeyPairAlias.length);
454 FillRandom(pubKeyPairAlias.val, pubKeyPairAlias.length, pubKeyPairAlias.length);
455 FillRandom(extraInfo.authId.val, extraInfo.authId.length, extraInfo.authId.length);
456 Uint8Buff sharedKeyAlias = { (uint8_t *)malloc(HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_BASEKEY_LEN),
457 HKDF_PAKE_PSK_DERIVE_SECRET_ALIAS_BASEKEY_LEN };
458 TEST_ASSERT_NOT_NULL(sharedKeyAlias.val);
459 FillRandom(sharedKeyAlias.val, sharedKeyAlias.length, sharedKeyAlias.length);
460
461 TestComputeHkdfWithKeyAliasTrueFirstAndSecondStep(
462 loader, &privKeyPairAlias, &pubKeyPairAlias, &extraInfo, &sharedKeyAlias);
463 TestComputeHkdfWithKeyAliasTrueThirdStep(
464 loader, argument, &sharedKeyAlias);
465 if (loader->deleteKey) {
466 LOGD("test deleteKey");
467 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->deleteKey(&privKeyPairAlias));
468 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->deleteKey(&pubKeyPairAlias));
469 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->deleteKey(&sharedKeyAlias));
470 }
471
472 LOGD("At last, free all memories allocated");
473 free(privKeyPairAlias.val);
474 privKeyPairAlias.val = (uint8_t *)NULL;
475 free(pubKeyPairAlias.val);
476 pubKeyPairAlias.val = (uint8_t *)NULL;
477 free(extraInfo.authId.val);
478 extraInfo.authId.val = (uint8_t *)NULL;
479 free(sharedKeyAlias.val);
480 sharedKeyAlias.val = (uint8_t *)NULL;
481 }
482 #else // TEST_HKDF_WITH_KEY_ALIAS_TRUE // } {
TestComputeHkdfWithKeyAliasTrue(const AlgLoader * loader,struct HkdfArgument * argument)483 static void TestComputeHkdfWithKeyAliasTrue(
484 const AlgLoader *loader,
485 struct HkdfArgument *argument)
486 {
487 LOGE("no TEST_HKDF_WITH_KEY_ALIAS_TRUE, do not test hkdf with key alias true");
488 TEST_ASSERT_TRUE(loader->generateKeyPairWithStorage == NULL || loader->agreeSharedSecretWithStorage == NULL);
489 LOG_ERROR_IF_POINTER_NULL(loader->generateKeyPairWithStorage);
490 LOG_ERROR_IF_POINTER_NULL(loader->agreeSharedSecretWithStorage);
491 (void)(argument);
492 }
493 #endif // TEST_HKDF_WITH_KEY_ALIAS_TRUE // }
494
TestComputeHkdfCorrectness(const AlgLoader * loader,struct HkdfArgument * argument)495 static void TestComputeHkdfCorrectness(
496 const AlgLoader *loader,
497 struct HkdfArgument *argument)
498 {
499 LOGI("test the correctness of hkdf");
500 argument->baseKey.val = (uint8_t *)(HKDF_EXAMPLE_MESSAGE);
501 argument->baseKey.length = strlen(HKDF_EXAMPLE_MESSAGE);
502 argument->salt.val = (uint8_t *)(HKDF_EXAMPLE_SALT);
503 argument->salt.length = sizeof(HKDF_EXAMPLE_SALT);
504 argument->keyInfo.val = (uint8_t *)(HKDF_EXAMPLE_INFO);
505 argument->keyInfo.length = strlen(HKDF_EXAMPLE_INFO);
506 argument->outHkdf.val = (uint8_t *)malloc(sizeof(HKDF_EXAMPLE_RESULT_KEY));
507 TEST_ASSERT_NOT_NULL(argument->outHkdf.val);
508 argument->outHkdf.length = sizeof(HKDF_EXAMPLE_RESULT_KEY);
509 argument->isAlias = false;
510 TestComputeHkdfInner(loader, argument);
511 TEST_ASSERT_EQUAL(sizeof(HKDF_EXAMPLE_RESULT_KEY), argument->outHkdf.length);
512 TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(HKDF_EXAMPLE_RESULT_KEY, argument->outHkdf.val,
513 sizeof(HKDF_EXAMPLE_RESULT_KEY), "incorrect hkdf result");
514 PrintBuffer("hkdf result", argument->outHkdf.val, argument->outHkdf.length);
515 free(argument->outHkdf.val);
516 argument->outHkdf.val = (uint8_t *)NULL;
517 }
518
TestComputeHkdf(const AlgLoader * loader)519 static void TestComputeHkdf(const AlgLoader *loader)
520 {
521 TEST_ASSERT_NOT_NULL(loader->computeHkdf);
522 if (loader->computeHkdf == NULL) {
523 LOGE("computeHkdf pointer is NULL! will not test!");
524 return;
525 }
526
527 struct HkdfArgument argument;
528 int res;
529 res = memset_s(&argument, sizeof(argument), 0, sizeof(argument));
530 TEST_ASSERT_EQUAL(EOK, res);
531
532 for (uint32_t i = 0; i < ARRAY_SIZE(g_hkdfTestCase); ++i) {
533 LOGI("test case for: \"%s\"", g_hkdfTestCase[i].caseName);
534 LOGI("test case for: baseKeyLength = %d, saltLength = %d, keyInfo = \"%s\", outKeyLength = %d",
535 g_hkdfTestCase[i].baseKeyLength, g_hkdfTestCase[i].saltLength,
536 g_hkdfTestCase[i].keyInfo, g_hkdfTestCase[i].outKeyLength);
537 argument.baseKey.val = (uint8_t *)NULL;
538 argument.baseKey.length = g_hkdfTestCase[i].baseKeyLength;
539 argument.salt.val = (uint8_t *)NULL;
540 argument.salt.length = g_hkdfTestCase[i].saltLength;
541 argument.keyInfo.val = (uint8_t *)(g_hkdfTestCase[i].keyInfo);
542 argument.keyInfo.length = strlen(g_hkdfTestCase[i].keyInfo);
543 argument.outHkdf.val = (uint8_t *)malloc(g_hkdfTestCase[i].outKeyLength);
544 TEST_ASSERT_NOT_NULL(argument.outHkdf.val);
545 argument.outHkdf.length = g_hkdfTestCase[i].outKeyLength;
546 argument.isAlias = false;
547 TestComputeHkdfInner(loader, &argument);
548 free(argument.outHkdf.val);
549 argument.outHkdf.val = (uint8_t *)NULL;
550 }
551
552 TestComputeHkdfWithKeyAliasTrue(loader, &argument);
553
554 TestComputeHkdfCorrectness(loader, &argument);
555 }
556
557 #if TEST_IMPORT_SYMMETRIC_KEY // {
558 enum {
559 WAIT_FOR_WATCH_DOG = 1,
560 };
TestImportSymmetricKey(const AlgLoader * loader)561 static void TestImportSymmetricKey(const AlgLoader *loader)
562 {
563 TEST_ASSERT_NOT_NULL(loader->importSymmetricKey);
564 if (loader->importSymmetricKey == NULL) {
565 LOGE("importSymmetricKey pointer is NULL! will not test!");
566 return;
567 }
568
569 int res;
570 const uint32_t authIdLenArray[] = { TEST_IMPORT_SYMMETRIC_KEY_AUTH_ID_LENGTH_32,
571 TEST_IMPORT_SYMMETRIC_KEY_AUTH_ID_LENGTH_64 };
572 for (uint32_t i = 0; i < ARRAY_SIZE(authIdLenArray); ++i) {
573 for (
574 uint32_t j = IMPORT_SYMMETRIC_KEY_KEYALIAS_LEN_MIN;
575 j <= IMPORT_SYMMETRIC_KEY_KEYALIAS_LEN_MAX;
576 ++j) {
577 LOGD("auth id length = %u, msg length = %u", authIdLenArray[i], j);
578 Uint8Buff keyAlias = { (uint8_t *)malloc(j), j };
579 Uint8Buff authToken = { (uint8_t *)malloc(IMPORT_SYMMETRIC_KEY_AUTHTOKEN_LEN),
580 IMPORT_SYMMETRIC_KEY_AUTHTOKEN_LEN };
581 ExtraInfo extraInfo = { { (uint8_t *)malloc(authIdLenArray[i]), authIdLenArray[i] },
582 DEVICE_TYPE_ACCESSORY, PAIR_TYPE_BIND };
583 TEST_ASSERT_NOT_NULL(keyAlias.val);
584 TEST_ASSERT_NOT_NULL(authToken.val);
585 TEST_ASSERT_NOT_NULL(extraInfo.authId.val);
586 FillRandom(keyAlias.val, keyAlias.length, keyAlias.length);
587 FillRandom(authToken.val, authToken.length, authToken.length);
588 FillRandom(extraInfo.authId.val, extraInfo.authId.length, extraInfo.authId.length);
589 RUN_AND_PRINT_ELAPSED_TIME(res,
590 loader->importSymmetricKey(&keyAlias, &authToken, KEY_PURPOSE_MAC, &extraInfo));
591 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
592 if (loader->checkKeyExist) {
593 LOGD("test checkKeyExist");
594 RUN_AND_PRINT_ELAPSED_TIME(res, loader->checkKeyExist(&keyAlias));
595 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
596 }
597 if (loader->deleteKey) {
598 LOGD("test delete");
599 RUN_AND_PRINT_ELAPSED_TIME(res, loader->deleteKey(&keyAlias));
600 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
601 }
602 free(keyAlias.val);
603 keyAlias.val = (uint8_t *)NULL;
604 free(authToken.val);
605 authToken.val = (uint8_t *)NULL;
606 free(extraInfo.authId.val);
607 extraInfo.authId.val = (uint8_t *)NULL;
608 }
609 LOGI("sleep for %d seconds, waiting for watch dog", WAIT_FOR_WATCH_DOG);
610 sleep(WAIT_FOR_WATCH_DOG);
611 }
612 }
613 #else // TEST_IMPORT_SYMMETRIC_KEY // } {
TestImportSymmetricKey(const AlgLoader * loader)614 static void TestImportSymmetricKey(const AlgLoader *loader)
615 {
616 LOGE("no TEST_IMPORT_SYMMETRIC_KEY, do not test importSymmetricKey");
617 TEST_ASSERT_NULL(loader->importSymmetricKey);
618 }
619 #endif // TEST_IMPORT_SYMMETRIC_KEY // }
620
TestCheckKeyExist(const AlgLoader * loader)621 static void TestCheckKeyExist(const AlgLoader *loader)
622 #if TEST_CHECK_KEY_EXIST
623 {
624 TEST_ASSERT_NOT_NULL(loader->checkKeyExist);
625 if (loader->checkKeyExist == NULL) {
626 LOGE("checkKeyExist pointer is NULL! will not test!");
627 return;
628 }
629
630 const char bufferKeyAlias[] = "A non-existent key";
631 Uint8Buff keyAlias = {
632 .val = (uint8_t *)bufferKeyAlias,
633 .length = strlen(bufferKeyAlias),
634 };
635 int32_t res;
636 RUN_AND_PRINT_ELAPSED_TIME(res, loader->checkKeyExist(&keyAlias));
637 TEST_ASSERT_NOT_EQUAL(HAL_SUCCESS, res);
638 }
639 #else // TEST_CHECK_KEY_EXIST
640 {
641 LOGE("no TEST_CHECK_KEY_EXIST, do not test checkKeyExist");
642 TEST_ASSERT_NULL(loader->checkKeyExist);
643 }
644 #endif // TEST_CHECK_KEY_EXIST
645
TestDeleteKey(const AlgLoader * loader)646 static void TestDeleteKey(const AlgLoader *loader)
647 #if TEST_DELETE_KEY
648 {
649 TEST_ASSERT_NOT_NULL(loader->deleteKey);
650 if (loader->deleteKey == NULL) {
651 LOGE("deleteKey pointer is NULL! will not test!");
652 return;
653 }
654
655 const char bufferKeyAlias[] = "A non-existent key";
656 Uint8Buff keyAlias = {
657 .val = (uint8_t *)bufferKeyAlias,
658 .length = strlen(bufferKeyAlias),
659 };
660 int32_t res;
661 RUN_AND_PRINT_ELAPSED_TIME(res, loader->deleteKey(&keyAlias));
662 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
663 }
664 #else // TEST_DELETE_KEY
665 {
666 LOGE("no TEST_DELETE_KEY, do not test deleteKey");
667 TEST_ASSERT_NULL(loader->deleteKey);
668 }
669 #endif // TEST_DELETE_KEY
670
TestAesGcmEncrypt(const AlgLoader * loader)671 static void TestAesGcmEncrypt(const AlgLoader *loader)
672 #if TEST_AES_GCM_ENCRYPT
673 {
674 LOGI("begin to test the AES-GCM algorithm encryption");
675 TEST_ASSERT_NOT_NULL(loader->aesGcmEncrypt);
676 if (loader->aesGcmEncrypt == NULL) {
677 LOGE("aesGcmEncrypt pointer is NULL! will not test!");
678 return;
679 }
680 const Uint8Buff key = { (uint8_t *)AES_GCM_TEST_KEY, AES_GCM_KEY_LEN };
681 const Uint8Buff plainBuffer = { (uint8_t *)PLAIN_CASE, PLAIN_LEN };
682
683 uint8_t *nonce = (uint8_t *)malloc(NONCE_SIZE);
684 TEST_ASSERT_NOT_NULL(nonce);
685 TEST_ASSERT_EQUAL(EOK, memset_s(nonce, NONCE_SIZE, 0, NONCE_SIZE));
686
687 GcmParam gcmParams;
688 gcmParams.aad = (uint8_t *)EXCHANGE_AAD;
689 gcmParams.aadLen = (uint32_t)strlen(EXCHANGE_AAD);
690 gcmParams.nonce = nonce;
691 gcmParams.nonceLen = NONCE_SIZE;
692
693 uint8_t *cipher = (uint8_t *)malloc(CIPHER_LEN);
694 TEST_ASSERT_NOT_NULL(cipher);
695 TEST_ASSERT_EQUAL(EOK, memset_s(cipher, CIPHER_LEN, 0, CIPHER_LEN));
696 Uint8Buff cipherBuffer = { cipher, CIPHER_LEN };
697
698 int ret;
699 RUN_AND_PRINT_ELAPSED_TIME(ret, loader->aesGcmEncrypt(&key, &plainBuffer, &gcmParams, false, &cipherBuffer));
700 TEST_ASSERT_EQUAL(HAL_SUCCESS, ret);
701 PrintBuffer("AES-GCM cipher", cipher, CIPHER_LEN);
702 TEST_ASSERT_EQUAL_HEX8_ARRAY(AES_GCM_CIPHER_CASE, cipher, CIPHER_LEN);
703
704 free(nonce);
705 free(cipher);
706 }
707 #else // TEST_AES_GCM_ENCRYPT
708 {
709 LOGE("no TEST_AES_GCM_ENCRYPT, do not test aesGcmEncrypt");
710 TEST_ASSERT_NULL(loader->aesGcmEncrypt);
711 }
712 #endif // TEST_AES_GCM_ENCRYPT
713
TestAesGcmDecrypt(const AlgLoader * loader)714 static void TestAesGcmDecrypt(const AlgLoader *loader)
715 #if TEST_AES_GCM_DECRYPT
716 {
717 LOGI("begin to test the AES-GCM algorithm decryption");
718 TEST_ASSERT_NOT_NULL(loader->aesGcmDecrypt);
719 if (loader->aesGcmDecrypt == NULL) {
720 LOGE("aesGcmDecrypt pointer is NULL! will not test!");
721 return;
722 }
723 const Uint8Buff key = { (uint8_t *)AES_GCM_TEST_KEY, AES_GCM_KEY_LEN };
724 const Uint8Buff cipherBuffer = { (uint8_t *)AES_GCM_CIPHER_CASE, CIPHER_LEN };
725
726 uint8_t *nonce = (uint8_t *)malloc(NONCE_SIZE);
727 TEST_ASSERT_NOT_NULL(nonce);
728 TEST_ASSERT_EQUAL(EOK, memset_s(nonce, NONCE_SIZE, 0, NONCE_SIZE));
729
730 GcmParam gcmParams;
731 gcmParams.aad = (uint8_t *)EXCHANGE_AAD;
732 gcmParams.aadLen = (uint32_t)strlen(EXCHANGE_AAD);
733 gcmParams.nonce = nonce;
734 gcmParams.nonceLen = NONCE_SIZE;
735
736 uint8_t *plain = (uint8_t *)malloc(PLAIN_LEN);
737 TEST_ASSERT_NOT_NULL(plain);
738 TEST_ASSERT_EQUAL(EOK, memset_s(plain, PLAIN_LEN, 0, PLAIN_LEN));
739 Uint8Buff plainBuffer = { plain, PLAIN_LEN };
740
741 int ret;
742 RUN_AND_PRINT_ELAPSED_TIME(ret, loader->aesGcmDecrypt(&key, &cipherBuffer, &gcmParams, false, &plainBuffer));
743 TEST_ASSERT_EQUAL(HAL_SUCCESS, ret);
744 PrintBuffer("AES-GCM plain", plain, PLAIN_LEN);
745 TEST_ASSERT_EQUAL_HEX8_ARRAY(PLAIN_CASE, plain, PLAIN_LEN);
746
747 free(nonce);
748 free(plain);
749 }
750 #else // TEST_AES_GCM_DECRYPT
751 {
752 LOGE("no TEST_AES_GCM_DECRYPT, do not test aesGcmDecrypt");
753 TEST_ASSERT_NULL(loader->aesGcmDecrypt);
754 }
755 #endif // TEST_AES_GCM_DECRYPT
756
TestHashToPoint(const AlgLoader * loader)757 static void TestHashToPoint(const AlgLoader *loader)
758 #if TEST_HASH_TO_POINT
759 {
760 TEST_ASSERT_NOT_NULL(loader->hashToPoint);
761 if (loader->hashToPoint == NULL) {
762 LOGE("hashToPoint pointer is NULL! will not test!");
763 return;
764 }
765 const Uint8Buff hash = { (uint8_t *)HASH_TO_POINT_CASE, SHA256_LEN };
766 uint8_t *point = (uint8_t *)malloc(SHA256_LEN);
767 TEST_ASSERT_NOT_NULL(point);
768 TEST_ASSERT_EQUAL(EOK, memset_s(point, SHA256_LEN, 0, SHA256_LEN));
769 Uint8Buff pointBuffer = { point, SHA256_LEN };
770
771 int ret;
772 RUN_AND_PRINT_ELAPSED_TIME(ret, loader->hashToPoint(&hash, X25519, &pointBuffer));
773 TEST_ASSERT_EQUAL(HAL_SUCCESS, ret);
774 PrintBuffer("hashToPoint", point, SHA256_LEN);
775 TEST_ASSERT_EQUAL_HEX8_ARRAY(HASH_TO_POINT_RESULT, point, PLAIN_LEN);
776
777 free(point);
778 }
779 #else // TEST_HASH_TO_POINT
780 {
781 LOGE("no TEST_HASH_TO_POINT, do not test loader->hashToPoint!");
782 TEST_ASSERT_NULL(loader->hashToPoint);
783 }
784 #endif // TEST_HASH_TO_POINT
785
786 #if TEST_AGREE_SHARED_SECRET_WITH_STORAGE
VerifyAgreeSharedSecretWithStorage(const AlgLoader * loader,const Uint8Buff * key1,const Uint8Buff * key2)787 static void VerifyAgreeSharedSecretWithStorage(const AlgLoader *loader, const Uint8Buff *key1, const Uint8Buff *key2)
788 {
789 const Uint8Buff keyInfo = { (uint8_t *)HKDF_EXAMPLE_INFO, strlen(HKDF_EXAMPLE_INFO) };
790 const Uint8Buff salt = { (uint8_t *)HKDF_EXAMPLE_SALT, sizeof(HKDF_EXAMPLE_SALT) };
791 Uint8Buff outHkdf1 = { (uint8_t *)malloc(ED25519_KEY_BYTE_LEN), ED25519_KEY_BYTE_LEN };
792 Uint8Buff outHkdf2 = { (uint8_t *)malloc(ED25519_KEY_BYTE_LEN), ED25519_KEY_BYTE_LEN };
793 TEST_ASSERT_NOT_NULL(outHkdf1.val);
794 TEST_ASSERT_NOT_NULL(outHkdf2.val);
795
796 TEST_ASSERT_EQUAL(EOK, memset_s(outHkdf1.val, ED25519_KEY_BYTE_LEN, 0, ED25519_KEY_BYTE_LEN));
797 TEST_ASSERT_EQUAL(EOK, memset_s(outHkdf2.val, ED25519_KEY_BYTE_LEN, 0, ED25519_KEY_BYTE_LEN));
798
799 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->computeHkdf(key1, &salt, &keyInfo, &outHkdf1, true));
800 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->computeHkdf(key2, &salt, &keyInfo, &outHkdf2, true));
801 TEST_ASSERT_EQUAL_HEX8_ARRAY(outHkdf1.val, outHkdf2.val, ED25519_KEY_BYTE_LEN);
802
803 free(outHkdf1.val);
804 free(outHkdf2.val);
805 }
806
GenerateKeyPairWithStorage(const AlgLoader * loader,const Uint8Buff * keyAlias)807 static int32_t GenerateKeyPairWithStorage(const AlgLoader *loader, const Uint8Buff *keyAlias)
808 {
809 const ExtraInfo extraInfo = {
810 .authId = {
811 .val = (uint8_t *)malloc(TEST_GENERATE_KEY_PAIR_WITH_STORAGE_AUTH_ID_LENGTH),
812 .length = TEST_GENERATE_KEY_PAIR_WITH_STORAGE_AUTH_ID_LENGTH,
813 },
814 .userType = DEVICE_TYPE_ACCESSORY,
815 .pairType = PAIR_TYPE_BIND,
816 };
817 TEST_ASSERT_NOT_NULL(extraInfo.authId.val);
818 TEST_ASSERT_EQUAL(EOK, memset_s(extraInfo.authId.val, extraInfo.authId.length, 0, extraInfo.authId.length));
819
820 int32_t ret = loader->generateKeyPairWithStorage(keyAlias, ED25519_KEY_BYTE_LEN, ED25519, &extraInfo);
821 free(extraInfo.authId.val);
822 return ret;
823 }
824
TestAgreeSharedSecretWithStorage(const AlgLoader * loader)825 static void TestAgreeSharedSecretWithStorage(const AlgLoader *loader)
826 {
827 TEST_ASSERT_NOT_NULL(loader->agreeSharedSecretWithStorage);
828 TEST_ASSERT_NOT_NULL(loader->computeHkdf);
829 TEST_ASSERT_NOT_NULL(loader->generateKeyPairWithStorage);
830 if (!loader->agreeSharedSecretWithStorage || !loader->computeHkdf
831 || !loader->generateKeyPairWithStorage) {
832 LOGE("one of required function pointer is NULL! will not test!");
833 return;
834 }
835
836 Uint8Buff keyAliasA = { (uint8_t *)KEY_PAIR_ALIAS_1, strlen(KEY_PAIR_ALIAS_1) };
837 Uint8Buff keyAliasB = { (uint8_t *)KEY_PAIR_ALIAS_2, strlen(KEY_PAIR_ALIAS_2) };
838
839 int ret;
840 ret = GenerateKeyPairWithStorage(loader, &keyAliasA);
841 TEST_ASSERT_EQUAL(HAL_SUCCESS, ret);
842
843 ret = GenerateKeyPairWithStorage(loader, &keyAliasB);
844 TEST_ASSERT_EQUAL(HAL_SUCCESS, ret);
845
846 if (ret != HAL_SUCCESS) {
847 LOGE("GenerateKeyPair failed! will not test!");
848 return;
849 }
850
851 KeyBuff keyA = { keyAliasA.val, keyAliasA.length, true };
852 KeyBuff keyB = { keyAliasB.val, keyAliasB.length, true };
853
854 Uint8Buff sharedKeyAlias1 = { (uint8_t *)SHARED_KEY_ALIAS_1, strlen(SHARED_KEY_ALIAS_1) };
855 Uint8Buff sharedKeyAlias2 = { (uint8_t *)SHARED_KEY_ALIAS_2, strlen(SHARED_KEY_ALIAS_1) };
856
857 Algorithm alg = ED25519;
858 const uint32_t keyLength = ED25519_KEY_BYTE_LEN;
859
860 RUN_AND_PRINT_ELAPSED_TIME(ret, loader->agreeSharedSecretWithStorage(&keyA,
861 &keyB, alg, keyLength, &sharedKeyAlias1));
862 TEST_ASSERT_EQUAL(HAL_SUCCESS, ret);
863
864 RUN_AND_PRINT_ELAPSED_TIME(ret, loader->agreeSharedSecretWithStorage(&keyB,
865 &keyA, alg, keyLength, &sharedKeyAlias2));
866 TEST_ASSERT_EQUAL(HAL_SUCCESS, ret);
867
868 VerifyAgreeSharedSecretWithStorage(loader, &sharedKeyAlias1, &sharedKeyAlias2);
869 if (loader->deleteKey) {
870 LOGD("test deleteKey");
871 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->deleteKey(&sharedKeyAlias1));
872 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->deleteKey(&sharedKeyAlias2));
873 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->deleteKey(&keyAliasA));
874 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->deleteKey(&keyAliasB));
875 }
876 }
877 #else // TEST_AGREE_SHARED_SECRET_WITH_STORAGE
TestAgreeSharedSecretWithStorage(const AlgLoader * loader)878 static void TestAgreeSharedSecretWithStorage(const AlgLoader *loader)
879 {
880 LOGE("no TEST_AGREE_SHARED_SECRET_WITH_STORAGE, do not test loader->agreeSharedSecretWithStorage!");
881 TEST_ASSERT_TRUE(loader->agreeSharedSecretWithStorage == NULL ||
882 loader->computeHkdf == NULL ||
883 loader->generateKeyPairWithStorage == NULL);
884 LOG_ERROR_IF_POINTER_NULL(loader->agreeSharedSecretWithStorage);
885 LOG_ERROR_IF_POINTER_NULL(loader->computeHkdf);
886 LOG_ERROR_IF_POINTER_NULL(loader->generateKeyPairWithStorage);
887 }
888 #endif // TEST_AGREE_SHARED_SECRET_WITH_STORAGE
889
TestAgreeSharedSecret(const AlgLoader * loader)890 static void TestAgreeSharedSecret(const AlgLoader *loader)
891 #if TEST_AGREE_SHARED_SECRET
892 {
893 TEST_ASSERT_NOT_NULL(loader->agreeSharedSecret);
894 if (!loader->agreeSharedSecret) {
895 LOGE("agreeSharedSecret pointer is NULL! will not test!");
896 return;
897 }
898
899 Algorithm alg = X25519;
900 const uint32_t keyLength = X25519_KEY_BYTE_LEN;
901
902 KeyBuff privateKeyA = { (uint8_t *)X25519_PRIVATE_KEY_A, keyLength, false };
903 KeyBuff publicKeyA = { (uint8_t *)X25519_PUBLIC_KEY_A, keyLength, false };
904
905 KeyBuff privateKeyB = { (uint8_t *)X25519_PRIVATE_KEY_B, keyLength, false };
906 KeyBuff publicKeyB = { (uint8_t *)X25519_PUBLIC_KEY_B, keyLength, false };
907
908 Uint8Buff sharedKey1 = { (uint8_t *)malloc(keyLength), keyLength };
909 Uint8Buff sharedKey2 = { (uint8_t *)malloc(keyLength), keyLength };
910
911 TEST_ASSERT_NOT_NULL(sharedKey1.val);
912 TEST_ASSERT_NOT_NULL(sharedKey2.val);
913 TEST_ASSERT_EQUAL(EOK, memset_s(sharedKey1.val, keyLength, 0, keyLength));
914 TEST_ASSERT_EQUAL(EOK, memset_s(sharedKey2.val, keyLength, 0, keyLength));
915
916 int ret;
917 RUN_AND_PRINT_ELAPSED_TIME(ret, loader->agreeSharedSecret(&privateKeyA, &publicKeyB, alg, &sharedKey1));
918 TEST_ASSERT_EQUAL(HAL_SUCCESS, ret);
919 RUN_AND_PRINT_ELAPSED_TIME(ret, loader->agreeSharedSecret(&privateKeyB, &publicKeyA, alg, &sharedKey2));
920 TEST_ASSERT_EQUAL(HAL_SUCCESS, ret);
921 PrintBuffer("shared key 1", sharedKey1.val, keyLength);
922 PrintBuffer("shared key 2", sharedKey2.val, keyLength);
923 TEST_ASSERT_EQUAL_HEX8_ARRAY(sharedKey1.val, sharedKey2.val, ED25519_KEY_BYTE_LEN);
924
925 free(sharedKey1.val);
926 free(sharedKey2.val);
927 }
928 #else // TEST_AGREE_SHARED_SECRET
929 {
930 LOGE("no TEST_AGREE_SHARED_SECRET, do not test loader->agreeSharedSecret");
931 TEST_ASSERT_NULL(loader->agreeSharedSecret);
932 }
933 #endif // TEST_AGREE_SHARED_SECRET
934
TestGenerateKeyPairWithStorage(const AlgLoader * loader)935 static void TestGenerateKeyPairWithStorage(const AlgLoader *loader)
936 #if TEST_GENERATE_KEY_PAIR_WITH_STORAGE
937 {
938 TEST_ASSERT_NOT_NULL(loader->generateKeyPairWithStorage);
939 if (!loader->generateKeyPairWithStorage) {
940 LOGE("generateKeyPairWithStorage pointer is NULL! will not test!");
941 return;
942 }
943
944 Uint8Buff keyAlias = { (uint8_t *)KEY_PAIR_ALIAS_1, strlen(KEY_PAIR_ALIAS_1) };
945 const ExtraInfo extraInfo = {
946 .authId = {
947 .val = (uint8_t *)malloc(TEST_GENERATE_KEY_PAIR_WITH_STORAGE_AUTH_ID_LENGTH),
948 .length = TEST_GENERATE_KEY_PAIR_WITH_STORAGE_AUTH_ID_LENGTH,
949 },
950 .userType = DEVICE_TYPE_ACCESSORY,
951 .pairType = PAIR_TYPE_BIND,
952 };
953 TEST_ASSERT_NOT_NULL(extraInfo.authId.val);
954 TEST_ASSERT_EQUAL(EOK, memset_s(extraInfo.authId.val, extraInfo.authId.length, 0, extraInfo.authId.length));
955
956 int ret;
957 RUN_AND_PRINT_ELAPSED_TIME(ret,
958 loader->generateKeyPairWithStorage(&keyAlias, ED25519_KEY_BYTE_LEN, ED25519, &extraInfo));
959 TEST_ASSERT_EQUAL(HAL_SUCCESS, ret);
960 if (loader->checkKeyExist) {
961 LOGD("test checkKeyExist");
962 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->checkKeyExist(&keyAlias));
963 }
964 if (loader->deleteKey) {
965 LOGD("test deleteKey");
966 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->deleteKey(&keyAlias));
967 }
968
969 free(extraInfo.authId.val);
970 }
971 #else // TEST_GENERATE_KEY_PAIR_WITH_STORAGE
972 {
973 LOGE("no TEST_GENERATE_KEY_PAIR_WITH_STORAGE, do not test loader->generateKeyPairWithStorage!");
974 TEST_ASSERT_NULL(loader->generateKeyPairWithStorage);
975 }
976 #endif // TEST_GENERATE_KEY_PAIR_WITH_STORAGE
977
TestBigNumExpMod(const AlgLoader * loader)978 static void TestBigNumExpMod(const AlgLoader *loader)
979 #if TEST_BIG_NUM_EXP_MOD
980 {
981 TEST_ASSERT_NOT_NULL(loader->bigNumExpMod);
982 if (loader->bigNumExpMod == NULL) {
983 LOGE("bigNumExpMod pointer is NULL! will not test!");
984 return;
985 }
986
987 for (uint32_t i = 0; i < ARRAY_SIZE(BIG_NUM_TEST_CASES); ++i) {
988 uint32_t baseLength = BIG_NUM_TEST_CASES[i].baseLength;
989 uint32_t expLength = BIG_NUM_TEST_CASES[i].expLength;
990 uint32_t primeLength = strlen(BIG_NUM_TEST_CASES[i].prime) >> 1;
991
992 const Uint8Buff base = { (uint8_t *)BIG_NUM_TEST_CASES[i].base, baseLength };
993 const Uint8Buff exp = { (uint8_t *)BIG_NUM_TEST_CASES[i].exp, expLength };
994 Uint8Buff modResult = { (uint8_t *)malloc(primeLength), primeLength };
995 TEST_ASSERT_NOT_NULL(modResult.val);
996 TEST_ASSERT_EQUAL(EOK, memset_s(modResult.val, primeLength, 0, primeLength));
997
998 int ret;
999 LOGI("test the big num case: base = %u, exp = %u, prime = %u", baseLength, expLength, primeLength);
1000 RUN_AND_PRINT_ELAPSED_TIME(ret, loader->bigNumExpMod(&base, &exp, BIG_NUM_TEST_CASES[i].prime, &modResult));
1001 TEST_ASSERT_EQUAL(HAL_SUCCESS, ret);
1002 TEST_ASSERT_EQUAL_HEX8_ARRAY(BIG_NUM_TEST_CASES[i].result, modResult.val, primeLength);
1003 PrintBuffer("mod result", modResult.val, modResult.length);
1004 free(modResult.val);
1005 }
1006 }
1007 #else // TEST_BIG_NUM_EXP_MOD
1008 {
1009 LOGE("no TEST_BIG_NUM_EXP_MOD, do not test loader->bigNumExpMod!");
1010 TEST_ASSERT_NULL(loader->bigNumExpMod);
1011 }
1012 #endif // TEST_BIG_NUM_EXP_MOD
1013
TestGenerateKeyPair(const AlgLoader * loader)1014 static void TestGenerateKeyPair(const AlgLoader *loader)
1015 #if TEST_GENERATE_KEY_PAIR
1016 {
1017 TEST_ASSERT_NOT_NULL(loader->generateKeyPair);
1018 LOGE("nobody use generateKeyPair, do not test");
1019 }
1020 #else // TEST_GENERATE_KEY_PAIR
1021 {
1022 TEST_ASSERT_NULL(loader->generateKeyPair);
1023 LOGE("no TEST_GENERATE_KEY_PAIR, do not test generateKeyPair");
1024 }
1025 #endif // TEST_GENERATE_KEY_PAIR
1026
1027 #if (TEST_EXPORT_PUBLIC_KEY || TEST_IMPORT_PUBLIC_KEY || TEST_ALGORITHM_SIGN || TEST_ALGORITHM_VERIFY)
1028 struct TestExportImportSignVerifyParam {
1029 ExtraInfo extInfo;
1030 Uint8Buff keyAlias;
1031 Uint8Buff outPubKey;
1032 Uint8Buff anotherKeyAlias;
1033 Uint8Buff messages[ARRAY_SIZE(TEST_SIGN_MSG_LENGTHES)];
1034 Uint8Buff signatures[ARRAY_SIZE(TEST_SIGN_MSG_LENGTHES)];
1035 Uint8Buff anotherOutPk;
1036 };
1037
TestExportImportSignVerifyPrepareResources(struct TestExportImportSignVerifyParam * param)1038 static void TestExportImportSignVerifyPrepareResources(struct TestExportImportSignVerifyParam *param)
1039 {
1040 param->extInfo.authId.length = TEST_EX_IM_SN_VF_EXTRA_INFO_AUTH_ID_LENGTH;
1041 param->extInfo.authId.val = (uint8_t *)malloc(param->extInfo.authId.length);
1042 param->extInfo.userType = DEVICE_TYPE_ACCESSORY;
1043 param->extInfo.pairType = PAIR_TYPE_BIND;
1044 TEST_ASSERT_NOT_NULL(param->extInfo.authId.val);
1045 FillRandom(param->extInfo.authId.val, param->extInfo.authId.length, param->extInfo.authId.length);
1046
1047 param->keyAlias.length = TEST_EX_IM_SN_VF_KEY_ALIAS_LENGTH;
1048 param->keyAlias.val = (uint8_t *)malloc(param->keyAlias.length);
1049 TEST_ASSERT_NOT_NULL(param->keyAlias.val);
1050 FillRandom(param->keyAlias.val, param->keyAlias.length, param->keyAlias.length);
1051
1052 param->outPubKey.length = TEST_EX_IM_SN_VF_OUT_PUB_KEY_LENGTH;
1053 param->outPubKey.val = (uint8_t *)malloc(param->outPubKey.length);
1054 TEST_ASSERT_NOT_NULL(param->outPubKey.val);
1055 TEST_ASSERT_EQUAL(EOK, memset_s(param->outPubKey.val, param->outPubKey.length, 0, param->outPubKey.length));
1056
1057 param->anotherKeyAlias.length = TEST_EX_IM_SN_VF_KEY_ALIAS_LENGTH;
1058 param->anotherKeyAlias.val = (uint8_t *)malloc(param->anotherKeyAlias.length);
1059 TEST_ASSERT_NOT_NULL(param->anotherKeyAlias.val);
1060 do {
1061 FillRandom(param->anotherKeyAlias.val, param->anotherKeyAlias.length, param->anotherKeyAlias.length);
1062 } while (memcmp(param->keyAlias.val, param->anotherKeyAlias.val, TEST_EX_IM_SN_VF_KEY_ALIAS_LENGTH) == 0);
1063
1064 for (uint32_t i = 0; i < ARRAY_SIZE(TEST_SIGN_MSG_LENGTHES); ++i) {
1065 param->messages[i].length = TEST_SIGN_MSG_LENGTHES[i];
1066 param->messages[i].val = (uint8_t *)malloc(param->messages[i].length);
1067 TEST_ASSERT_NOT_NULL(param->messages[i].val);
1068 FillRandom(param->messages[i].val, param->messages[i].length, param->messages[i].length);
1069 param->signatures[i].length = TEST_SIGN_SIGNATURE_LENGTH;
1070 param->signatures[i].val = (uint8_t *)malloc(param->signatures[i].length);
1071 TEST_ASSERT_NOT_NULL(param->signatures[i].val);
1072 TEST_ASSERT_EQUAL(EOK,
1073 memset_s(param->signatures[i].val, param->signatures[i].length, 0, param->signatures[i].length));
1074 }
1075
1076 param->anotherOutPk.length = TEST_EX_IM_SN_VF_OUT_PUB_KEY_LENGTH;
1077 param->anotherOutPk.val = (uint8_t *)malloc(param->anotherOutPk.length);
1078 TEST_ASSERT_NOT_NULL(param->anotherOutPk.val);
1079 TEST_ASSERT_EQUAL(EOK,
1080 memset_s(param->anotherOutPk.val, param->anotherOutPk.length, 0, param->anotherOutPk.length));
1081 }
1082
TestExportImportSignVerifyInnerVerfiyNormalAndAbnormalCases(const AlgLoader * loader,const Algorithm alg,struct TestExportImportSignVerifyParam * param)1083 static void TestExportImportSignVerifyInnerVerfiyNormalAndAbnormalCases(
1084 const AlgLoader *loader, const Algorithm alg, struct TestExportImportSignVerifyParam *param)
1085 {
1086 int res;
1087 for (uint32_t i = 0; i < ARRAY_SIZE(TEST_SIGN_MSG_LENGTHES); ++i) {
1088 // test normal case
1089 RUN_AND_PRINT_ELAPSED_TIME(res,
1090 loader->verify(¶m->anotherOutPk, ¶m->messages[i], alg, ¶m->signatures[i], false));
1091 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
1092 // test tamper message
1093 uint8_t originMsg = param->messages[i].val[0];
1094 param->messages[i].val[0] = ((originMsg == UINT8_MAX) ? 0 : (originMsg + 1));
1095 TEST_ASSERT_NOT_EQUAL(originMsg, param->messages[i].val[0]);
1096 RUN_AND_PRINT_ELAPSED_TIME(res,
1097 loader->verify(¶m->anotherOutPk, ¶m->messages[i], alg, ¶m->signatures[i], false));
1098 TEST_ASSERT_NOT_EQUAL(HAL_SUCCESS, res);
1099 param->messages[i].val[0] = originMsg;
1100 // test normal case
1101 RUN_AND_PRINT_ELAPSED_TIME(res,
1102 loader->verify(¶m->anotherOutPk, ¶m->messages[i], alg, ¶m->signatures[i], false));
1103 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
1104 // test tamper signature
1105 uint8_t originSig = param->signatures[i].val[0];
1106 param->signatures[i].val[0] = ((originSig == UINT8_MAX) ? 0 : (originSig + 1));
1107 TEST_ASSERT_NOT_EQUAL(originSig, param->signatures[i].val[0]);
1108 RUN_AND_PRINT_ELAPSED_TIME(res,
1109 loader->verify(¶m->anotherOutPk, ¶m->messages[i], alg, ¶m->signatures[i], false));
1110 TEST_ASSERT_NOT_EQUAL(HAL_SUCCESS, res);
1111 param->signatures[i].val[0] = originSig;
1112 // test normal case
1113 RUN_AND_PRINT_ELAPSED_TIME(res,
1114 loader->verify(¶m->anotherOutPk, ¶m->messages[i], alg, ¶m->signatures[i], false));
1115 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
1116 }
1117 }
1118
TestExportImportSignVerifyInner(const AlgLoader * loader,const Algorithm alg,struct TestExportImportSignVerifyParam * param)1119 static void TestExportImportSignVerifyInner(
1120 const AlgLoader *loader, const Algorithm alg, struct TestExportImportSignVerifyParam *param)
1121 {
1122 int res;
1123 // 1. generate one public private key pair
1124 TEST_ASSERT_EQUAL(HAL_SUCCESS,
1125 loader->generateKeyPairWithStorage(¶m->keyAlias, TEST_EX_IM_SN_VF_KEY_LENGTH, alg, ¶m->extInfo));
1126
1127 // 2. export the public key which is generated in the first step
1128 RUN_AND_PRINT_ELAPSED_TIME(res, loader->exportPublicKey(¶m->keyAlias, ¶m->outPubKey));
1129 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
1130
1131 // 3. import the public key which is exported in the second step with a different name
1132 RUN_AND_PRINT_ELAPSED_TIME(res,
1133 loader->importPublicKey(¶m->anotherKeyAlias, ¶m->outPubKey, alg, ¶m->extInfo));
1134 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
1135
1136 // 4. sign with the public key which is generated in the first step
1137 for (uint32_t i = 0; i < ARRAY_SIZE(TEST_SIGN_MSG_LENGTHES); ++i) {
1138 RUN_AND_PRINT_ELAPSED_TIME(res,
1139 loader->sign(¶m->keyAlias, ¶m->messages[i], alg, ¶m->signatures[i], true));
1140 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
1141 TEST_ASSERT_GREATER_THAN(0u, param->signatures[i].length);
1142 TEST_ASSERT_LESS_OR_EQUAL(TEST_SIGN_SIGNATURE_LENGTH, param->signatures[i].length);
1143 TEST_ASSERT_NOT_EQUAL(param->signatures[i].length,
1144 CountZero(param->signatures[i].val, param->signatures[i].length));
1145 }
1146
1147 // 5. export the public key which is imported in the third step
1148 RUN_AND_PRINT_ELAPSED_TIME(res, loader->exportPublicKey(¶m->anotherKeyAlias, ¶m->anotherOutPk));
1149 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
1150
1151 // 6. verify the signature that is signed in the fourth step with the public key that is imported in the fifth step
1152 TestExportImportSignVerifyInnerVerfiyNormalAndAbnormalCases(loader, alg, param);
1153
1154 // 7. compare the public keys which are exported in the second and fifth step
1155 PrintBuffer("exported public key", param->outPubKey.val, param->outPubKey.length);
1156 TEST_ASSERT_GREATER_THAN(0u, param->outPubKey.length);
1157 TEST_ASSERT_LESS_OR_EQUAL(TEST_EX_IM_SN_VF_OUT_PUB_KEY_LENGTH, param->outPubKey.length);
1158 TEST_ASSERT_NOT_EQUAL(param->outPubKey.length, CountZero(param->outPubKey.val, param->outPubKey.length));
1159 TEST_ASSERT_EQUAL_MESSAGE(param->outPubKey.length, param->anotherOutPk.length,
1160 TEST_EXPORT_DIFFERENT_ERROR_MESSAGE);
1161 TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(param->outPubKey.val, param->anotherOutPk.val, param->outPubKey.length,
1162 TEST_EXPORT_DIFFERENT_ERROR_MESSAGE);
1163
1164 if (loader->deleteKey) {
1165 LOGD("test deleteKey");
1166
1167 // 8. delete the key pair which is generated in the first step
1168 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->deleteKey(¶m->keyAlias));
1169
1170 // 9. delete the public key which is imported in the third step
1171 TEST_ASSERT_EQUAL(HAL_SUCCESS, loader->deleteKey(¶m->anotherKeyAlias));
1172 }
1173 }
1174
TestExportImportSignVerifyReleaseResources(struct TestExportImportSignVerifyParam * param)1175 static void TestExportImportSignVerifyReleaseResources(struct TestExportImportSignVerifyParam *param)
1176 {
1177 free(param->extInfo.authId.val);
1178 param->extInfo.authId.val = NULL;
1179 free(param->keyAlias.val);
1180 param->keyAlias.val = NULL;
1181 free(param->outPubKey.val);
1182 param->outPubKey.val = NULL;
1183 free(param->anotherKeyAlias.val);
1184 param->anotherKeyAlias.val = NULL;
1185 for (uint32_t i = 0; i < ARRAY_SIZE(TEST_SIGN_MSG_LENGTHES); ++i) {
1186 free(param->messages[i].val);
1187 param->messages[i].val = NULL;
1188 free(param->signatures[i].val);
1189 param->signatures[i].val = NULL;
1190 }
1191 free(param->anotherOutPk.val);
1192 param->anotherOutPk.val = NULL;
1193 }
1194
TestExportImportSignVerify(const AlgLoader * loader,const Algorithm alg)1195 static void TestExportImportSignVerify(const AlgLoader *loader, const Algorithm alg)
1196 {
1197 TEST_ASSERT_NOT_NULL(loader->generateKeyPairWithStorage);
1198 // only two test cases for exportPublicKey, P256 and ED25519, outKey length is 32
1199 TEST_ASSERT_NOT_NULL(loader->exportPublicKey);
1200 TEST_ASSERT_NOT_NULL(loader->importPublicKey);
1201 // sign message length varies from min 1 to max 1024
1202 TEST_ASSERT_NOT_NULL(loader->sign);
1203 TEST_ASSERT_NOT_NULL(loader->verify);
1204 TEST_ASSERT_TRUE((alg == ED25519) || (alg == P256));
1205 if (((alg != ED25519) && (alg != P256)) || !loader->generateKeyPairWithStorage ||
1206 !loader->exportPublicKey || !loader->importPublicKey || !loader->sign || !loader->verify) {
1207 LOGE("one of requested pointer is NULL or alg is invalid, can not test!");
1208 return;
1209 }
1210
1211 struct TestExportImportSignVerifyParam param;
1212
1213 TestExportImportSignVerifyPrepareResources(¶m);
1214
1215 TestExportImportSignVerifyInner(loader, alg, ¶m);
1216
1217 TestExportImportSignVerifyReleaseResources(¶m);
1218 }
1219
TestExportImportSignVerifyP256AndEd25519(const AlgLoader * loader)1220 static void TestExportImportSignVerifyP256AndEd25519(const AlgLoader *loader)
1221 {
1222 #if TEST_EXPORT_IMPORT_SIGN_VERIFY_ED25519
1223 LOGI("test export import sign verify ED25519");
1224 TestExportImportSignVerify(loader, ED25519);
1225 #else // TEST_EXPORT_IMPORT_SIGN_VERIFY_ED25519
1226 LOGE("no TEST_EXPORT_IMPORT_SIGN_VERIFY_ED25519, do not test ED25519");
1227 #endif // TEST_EXPORT_IMPORT_SIGN_VERIFY_ED25519
1228
1229 #if TEST_EXPORT_IMPORT_SIGN_VERIFY_P256
1230 LOGI("test export import sign verify P256");
1231 TestExportImportSignVerify(loader, P256);
1232 #else // TEST_EXPORT_IMPORT_SIGN_VERIFY_P256
1233 LOGE("no TEST_EXPORT_IMPORT_SIGN_VERIFY_P256, do not test P256");
1234 #endif // TEST_EXPORT_IMPORT_SIGN_VERIFY_P256
1235 }
1236 #endif // (TEST_EXPORT_PUBLIC_KEY || TEST_IMPORT_PUBLIC_KEY || TEST_ALGORITHM_SIGN || TEST_ALGORITHM_VERIFY)
1237
TestExportPublicKey(const AlgLoader * loader)1238 static void TestExportPublicKey(const AlgLoader *loader)
1239 #if TEST_EXPORT_PUBLIC_KEY
1240 {
1241 TEST_ASSERT_NOT_NULL(loader->exportPublicKey);
1242 if (!loader->exportPublicKey) {
1243 LOGE("exportPublicKey pointer is NULL, can not test!");
1244 return;
1245 }
1246
1247 TestExportImportSignVerifyP256AndEd25519(loader);
1248 }
1249 #else // TEST_EXPORT_PUBLIC_KEY
1250 {
1251 TEST_ASSERT_NULL(loader->exportPublicKey);
1252 LOGE("no TEST_EXPORT_PUBLIC_KEY, do not test exportPublicKey");
1253 }
1254 #endif // TEST_EXPORT_PUBLIC_KEY
1255
TestSign(const AlgLoader * loader)1256 static void TestSign(const AlgLoader *loader)
1257 #if TEST_ALGORITHM_SIGN
1258 {
1259 TEST_ASSERT_NOT_NULL(loader->sign);
1260 if (!loader->sign) {
1261 LOGE("sign pointer is NULL, can not test!");
1262 return;
1263 }
1264
1265 TestExportImportSignVerifyP256AndEd25519(loader);
1266 }
1267 #else // TEST_ALGORITHM_SIGN
1268 {
1269 TEST_ASSERT_NULL(loader->sign);
1270 LOGE("no TEST_ALGORITHM_SIGN, do not test sign");
1271 }
1272 #endif // TEST_ALGORITHM_SIGN
1273
TestVerify(const AlgLoader * loader)1274 static void TestVerify(const AlgLoader *loader)
1275 #if TEST_ALGORITHM_VERIFY
1276 {
1277 TEST_ASSERT_NOT_NULL(loader->verify);
1278 if (!loader->verify) {
1279 LOGE("verify pointer is NULL, can not test!");
1280 return;
1281 }
1282
1283 TestExportImportSignVerifyP256AndEd25519(loader);
1284 }
1285 #else // TEST_ALGORITHM_VERIFY
1286 {
1287 TEST_ASSERT_NULL(loader->verify);
1288 LOGE("no TEST_ALGORITHM_VERIFY, do not test verify");
1289 }
1290 #endif // TEST_ALGORITHM_VERIFY
1291
TestImportPublicKey(const AlgLoader * loader)1292 static void TestImportPublicKey(const AlgLoader *loader)
1293 #if TEST_IMPORT_PUBLIC_KEY
1294 {
1295 TEST_ASSERT_NOT_NULL(loader->importPublicKey);
1296 if (!loader->importPublicKey) {
1297 LOGE("importPublicKey pointer is NULL, can not test!");
1298 return;
1299 }
1300
1301 TestExportImportSignVerifyP256AndEd25519(loader);
1302 }
1303 #else // TEST_IMPORT_PUBLIC_KEY
1304 {
1305 TEST_ASSERT_NULL(loader->importPublicKey);
1306 LOGE("no TEST_IMPORT_PUBLIC_KEY, do not test importPublicKey");
1307 }
1308 #endif // TEST_IMPORT_PUBLIC_KEY
1309
1310 #if TEST_CHECK_DL_PUBLIC_KEY // {
TestCheckDlPublicKeyInner(const AlgLoader * loader,Uint8Buff * key,const char * primeHex)1311 static void TestCheckDlPublicKeyInner(const AlgLoader *loader,
1312 Uint8Buff *key, const char *primeHex)
1313 {
1314 bool res;
1315 int randIndex;
1316
1317 // 1. all zero
1318 TEST_ASSERT_EQUAL(EOK, memset_s(key->val, key->length, 0, key->length));
1319 RUN_AND_PRINT_ELAPSED_TIME(res, loader->checkDlPublicKey(key, primeHex));
1320 TEST_ASSERT_EQUAL(false, res);
1321
1322 // 2. value is 1
1323 TEST_ASSERT_EQUAL(EOK, memset_s(key->val, key->length, 0, key->length));
1324 key->val[key->length - 1] = TEST_CHECK_DL_VALUE_ONE;
1325 RUN_AND_PRINT_ELAPSED_TIME(res, loader->checkDlPublicKey(key, primeHex));
1326 TEST_ASSERT_EQUAL(false, res);
1327
1328 // 3. value is 2
1329 TEST_ASSERT_EQUAL(EOK, memset_s(key->val, key->length, 0, key->length));
1330 key->val[key->length - 1] = TEST_CHECK_DL_VALUE_TWO;
1331 RUN_AND_PRINT_ELAPSED_TIME(res, loader->checkDlPublicKey(key, primeHex));
1332 TEST_ASSERT_EQUAL(true, res);
1333
1334 // 4. value is between 2 and primeHex - 2
1335 // first, init value with 2
1336 TEST_ASSERT_EQUAL(EOK, memset_s(key->val, key->length, 0, key->length));
1337 key->val[key->length - 1] = TEST_CHECK_DL_VALUE_TWO;
1338 // then add 1 on rand byte
1339 randIndex = rand() % key->length;
1340 key->val[randIndex] += TEST_CHECK_DL_VALUE_ONE;
1341 PrintBuffer("rand key", key->val, key->length);
1342 RUN_AND_PRINT_ELAPSED_TIME(res, loader->checkDlPublicKey(key, primeHex));
1343 TEST_ASSERT_EQUAL(true, res);
1344 // first, init value with primeHex - 2
1345 TEST_ASSERT_EQUAL(EOK, memset_s(key->val, key->length, 0, key->length));
1346 TEST_ASSERT_EQUAL(HAL_SUCCESS, HexStringToByte(primeHex, key->val, key->length));
1347 TEST_ASSERT_GREATER_OR_EQUAL(TEST_CHECK_DL_VALUE_TWO, key->val[key->length - 1]);
1348 key->val[key->length - 1] -= TEST_CHECK_DL_VALUE_TWO;
1349 // then sub 1 on rand byte
1350 do {
1351 randIndex = rand() % key->length;
1352 } while (key->val[randIndex] < TEST_CHECK_DL_VALUE_ONE);
1353 key->val[randIndex] -= TEST_CHECK_DL_VALUE_ONE;
1354 PrintBuffer("rand key", key->val, key->length);
1355 RUN_AND_PRINT_ELAPSED_TIME(res, loader->checkDlPublicKey(key, primeHex));
1356 TEST_ASSERT_EQUAL(true, res);
1357
1358 // 5. value is primeHex - 2
1359 TEST_ASSERT_EQUAL(EOK, memset_s(key->val, key->length, 0, key->length));
1360 TEST_ASSERT_EQUAL(HAL_SUCCESS, HexStringToByte(primeHex, key->val, key->length));
1361 TEST_ASSERT_GREATER_OR_EQUAL(TEST_CHECK_DL_VALUE_TWO, key->val[key->length - 1]);
1362 key->val[key->length - 1] -= TEST_CHECK_DL_VALUE_TWO;
1363 RUN_AND_PRINT_ELAPSED_TIME(res, loader->checkDlPublicKey(key, primeHex));
1364 TEST_ASSERT_EQUAL(true, res);
1365
1366 // 6. value is primeHex - 1
1367 TEST_ASSERT_EQUAL(EOK, memset_s(key->val, key->length, 0, key->length));
1368 TEST_ASSERT_EQUAL(HAL_SUCCESS, HexStringToByte(primeHex, key->val, key->length));
1369 TEST_ASSERT_GREATER_OR_EQUAL(TEST_CHECK_DL_VALUE_ONE, key->val[key->length - 1]);
1370 key->val[key->length - 1] -= TEST_CHECK_DL_VALUE_ONE;
1371 RUN_AND_PRINT_ELAPSED_TIME(res, loader->checkDlPublicKey(key, primeHex));
1372 TEST_ASSERT_EQUAL(false, res);
1373
1374 // 7. value is primeHex
1375 TEST_ASSERT_EQUAL(EOK, memset_s(key->val, key->length, 0, key->length));
1376 TEST_ASSERT_EQUAL(HAL_SUCCESS, HexStringToByte(primeHex, key->val, key->length));
1377 RUN_AND_PRINT_ELAPSED_TIME(res, loader->checkDlPublicKey(key, primeHex));
1378 TEST_ASSERT_EQUAL(false, res);
1379 }
1380
TestCheckDlPublicKey(const AlgLoader * loader)1381 static void TestCheckDlPublicKey(const AlgLoader *loader)
1382 {
1383 TEST_ASSERT_NOT_NULL(loader->checkDlPublicKey);
1384 if (!loader->checkDlPublicKey) {
1385 LOGE("checkDlPublicKey pointer is NULL, can not test!");
1386 return;
1387 }
1388
1389 Uint8Buff key;
1390
1391 key.length = PAKE_DL_PRIME_LEN_256;
1392 key.val = (uint8_t *)malloc(key.length);
1393 TEST_ASSERT_NOT_NULL(key.val);
1394 TestCheckDlPublicKeyInner(loader, &key, LARGE_PRIME_NUM_HEX_256);
1395 free(key.val);
1396
1397 key.length = PAKE_DL_PRIME_LEN_384;
1398 key.val = (uint8_t *)malloc(key.length);
1399 TEST_ASSERT_NOT_NULL(key.val);
1400 TestCheckDlPublicKeyInner(loader, &key, LARGE_PRIME_NUM_HEX_384);
1401 free(key.val);
1402 }
1403 #else // TEST_CHECK_DL_PUBLIC_KEY // } {
TestCheckDlPublicKey(const AlgLoader * loader)1404 static void TestCheckDlPublicKey(const AlgLoader *loader)
1405 {
1406 TEST_ASSERT_NULL(loader->checkDlPublicKey);
1407 LOGE("no TEST_CHECK_DL_PUBLIC_KEY, do not test checkDlPublicKey");
1408 }
1409 #endif // TEST_CHECK_DL_PUBLIC_KEY // }
1410
TestCheckEcPublicKey(const AlgLoader * loader)1411 static void TestCheckEcPublicKey(const AlgLoader *loader)
1412 {
1413 TEST_ASSERT_NULL(loader->checkEcPublicKey);
1414 LOGE("loader->checkEcPublicKey is NULL, and nobody use it, do not test!");
1415 }
1416
1417 #if TEST_BIG_NUM_COMPARE // {
TestBigNumCompareInnerMinMax(const AlgLoader * loader,Uint8Buff * x,Uint8Buff * y)1418 static void TestBigNumCompareInnerMinMax(const AlgLoader *loader,
1419 Uint8Buff *x, Uint8Buff *y)
1420 {
1421 // 0. 0xFFFFFF > 0x000000
1422 int res;
1423 TEST_ASSERT_EQUAL(EOK, memset_s(x->val, x->length, UINT8_MAX, x->length));
1424 TEST_ASSERT_EQUAL(EOK, memset_s(y->val, y->length, 0, y->length));
1425 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(x, y));
1426 TEST_ASSERT_EQUAL(1, res);
1427 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(y, x));
1428 TEST_ASSERT_EQUAL(-1, res);
1429 }
1430
TestBigNumCompareInnerFull(const AlgLoader * loader,Uint8Buff * x,Uint8Buff * y)1431 static void TestBigNumCompareInnerFull(const AlgLoader *loader,
1432 Uint8Buff *x, Uint8Buff *y)
1433 {
1434 int previous, res;
1435
1436 // 1. 0x123456 > 0x123455
1437 TEST_ASSERT_EQUAL(EOK, memcpy_s(x->val, x->length,
1438 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL)));
1439 TEST_ASSERT_EQUAL(EOK, memcpy_s(y->val, y->length,
1440 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL)));
1441 TEST_ASSERT_EQUAL_HEX8_ARRAY(x->val, y->val, TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL);
1442 previous = y->val[y->length - 1];
1443 y->val[y->length - 1] -= 1;
1444 TEST_ASSERT_LESS_THAN(previous, y->val[y->length - 1]);
1445 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(x, y));
1446 TEST_ASSERT_EQUAL(1, res);
1447 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(y, x));
1448 TEST_ASSERT_EQUAL(-1, res);
1449
1450 // 2. 0x123456 = 0x123456
1451 TEST_ASSERT_EQUAL(EOK, memcpy_s(x->val, x->length,
1452 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL)));
1453 TEST_ASSERT_EQUAL(EOK, memcpy_s(y->val, y->length,
1454 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL)));
1455 TEST_ASSERT_EQUAL_HEX8_ARRAY(x->val, y->val, TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL);
1456 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(x, y));
1457 TEST_ASSERT_EQUAL(0, res);
1458 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(y, x));
1459 TEST_ASSERT_EQUAL(0, res);
1460
1461 // 3. 0x123456 < 0x123457
1462 TEST_ASSERT_EQUAL(EOK, memcpy_s(x->val, x->length,
1463 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL)));
1464 TEST_ASSERT_EQUAL(EOK, memcpy_s(y->val, y->length,
1465 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_FULL)));
1466 TEST_ASSERT_EQUAL_HEX8_ARRAY(x->val, y->val, TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL);
1467 previous = y->val[y->length - 1];
1468 y->val[y->length - 1] += 1;
1469 TEST_ASSERT_GREATER_THAN(previous, y->val[y->length - 1]);
1470 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(x, y));
1471 TEST_ASSERT_EQUAL(-1, res);
1472 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(y, x));
1473 TEST_ASSERT_EQUAL(1, res);
1474 }
1475
TestBigNumCompareInnerHalf(const AlgLoader * loader,Uint8Buff * x,Uint8Buff * y)1476 static void TestBigNumCompareInnerHalf(const AlgLoader *loader,
1477 Uint8Buff *x, Uint8Buff *y)
1478 {
1479 int previous, res;
1480
1481 // 4. 0x003456 > 0x3455
1482 TEST_ASSERT_EQUAL(EOK,
1483 memset_s(x->val, x->length, 0, TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF));
1484 TEST_ASSERT_EQUAL(EOK, memcpy_s(
1485 x->val + TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF, x->length - TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF,
1486 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF)));
1487 TEST_ASSERT_EQUAL(EOK, memcpy_s(y->val, y->length,
1488 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF)));
1489 TEST_ASSERT_EQUAL_HEX8_ARRAY(x->val + TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF, y->val,
1490 TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF);
1491 previous = y->val[y->length - 1];
1492 y->val[y->length - 1] -= 1;
1493 TEST_ASSERT_LESS_THAN(previous, y->val[y->length - 1]);
1494 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(x, y));
1495 TEST_ASSERT_EQUAL(1, res);
1496 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(y, x));
1497 TEST_ASSERT_EQUAL(-1, res);
1498
1499 // 5. 0x003456 = 0x3456
1500 TEST_ASSERT_EQUAL(EOK,
1501 memset_s(x->val, x->length, 0, TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF));
1502 TEST_ASSERT_EQUAL(EOK, memcpy_s(
1503 x->val + TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF, x->length - TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF,
1504 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF)));
1505 TEST_ASSERT_EQUAL(EOK, memcpy_s(y->val, y->length,
1506 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF)));
1507 TEST_ASSERT_EQUAL_HEX8_ARRAY(x->val + TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF, y->val,
1508 TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF);
1509 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(x, y));
1510 TEST_ASSERT_EQUAL(0, res);
1511 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(y, x));
1512 TEST_ASSERT_EQUAL(0, res);
1513
1514 // 6. 0x003456 < 0x3457
1515 TEST_ASSERT_EQUAL(EOK,
1516 memset_s(x->val, x->length, 0, TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF));
1517 TEST_ASSERT_EQUAL(EOK, memcpy_s(
1518 x->val + TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF, x->length - TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF,
1519 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF)));
1520 TEST_ASSERT_EQUAL(EOK, memcpy_s(y->val, y->length,
1521 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF)));
1522 TEST_ASSERT_EQUAL_HEX8_ARRAY(x->val + TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF, y->val,
1523 TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF);
1524 previous = y->val[y->length - 1];
1525 y->val[y->length - 1] += 1;
1526 TEST_ASSERT_GREATER_THAN(previous, y->val[y->length - 1]);
1527 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(x, y));
1528 TEST_ASSERT_EQUAL(-1, res);
1529 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(y, x));
1530 TEST_ASSERT_EQUAL(1, res);
1531 }
1532
TestBigNumCompareInnerCompareFullAgainstHalf(const AlgLoader * loader,Uint8Buff * x,Uint8Buff * y)1533 static void TestBigNumCompareInnerCompareFullAgainstHalf(const AlgLoader *loader,
1534 Uint8Buff *x, Uint8Buff *y)
1535 {
1536 int res;
1537
1538 // 7. 0x123456 > 0x3456
1539 TEST_ASSERT_EQUAL(EOK, memcpy_s(
1540 x->val, x->length,
1541 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF)));
1542 TEST_ASSERT_EQUAL(EOK, memcpy_s(
1543 x->val + TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF, x->length - TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF,
1544 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF)));
1545 TEST_ASSERT_EQUAL(EOK, memcpy_s(y->val, y->length,
1546 TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF, sizeof(TEST_BIG_NUM_COMPARE_NUM_EXAMPLE_HALF)));
1547 TEST_ASSERT_EQUAL_HEX8_ARRAY(x->val + TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF, y->val,
1548 TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF);
1549 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(x, y));
1550 TEST_ASSERT_EQUAL(1, res);
1551 RUN_AND_PRINT_ELAPSED_TIME(res, loader->bigNumCompare(y, x));
1552 TEST_ASSERT_EQUAL(-1, res);
1553 }
1554
TestBigNumCompare(const AlgLoader * loader)1555 static void TestBigNumCompare(const AlgLoader *loader)
1556 {
1557 TEST_ASSERT_NOT_NULL(loader->bigNumCompare);
1558 if (!loader->bigNumCompare) {
1559 LOGE("bigNumCompare pointer is NULL, can not test!");
1560 return;
1561 }
1562
1563 Uint8Buff x = { (uint8_t *)malloc(TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL), TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL };
1564 TEST_ASSERT_NOT_NULL(x.val);
1565 Uint8Buff y = { (uint8_t *)malloc(TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL), TEST_BIG_NUM_COMPARE_NUM_LENGTH_FULL };
1566 TEST_ASSERT_NOT_NULL(y.val);
1567
1568 TestBigNumCompareInnerMinMax(loader, &x, &y);
1569
1570 TestBigNumCompareInnerFull(loader, &x, &y);
1571
1572 free(y.val);
1573
1574 y.length = TEST_BIG_NUM_COMPARE_NUM_LENGTH_HALF;
1575 y.val = (uint8_t *)malloc(y.length);
1576 TEST_ASSERT_NOT_NULL(y.val);
1577
1578 TestBigNumCompareInnerHalf(loader, &x, &y);
1579
1580 TestBigNumCompareInnerCompareFullAgainstHalf(loader, &x, &y);
1581
1582 free(x.val);
1583 free(y.val);
1584 }
1585 #else // TEST_BIG_NUM_COMPARE // } {
TestBigNumCompare(const AlgLoader * loader)1586 static void TestBigNumCompare(const AlgLoader *loader)
1587 {
1588 TEST_ASSERT_NULL(loader->bigNumCompare);
1589 LOGE("no TEST_BIG_NUM_COMPARE, do not test loader->bigNumCompare");
1590 }
1591 #endif // TEST_BIG_NUM_COMPARE // {
1592
TestHcAlg(void)1593 void TestHcAlg(void)
1594 {
1595 const AlgLoader *loader = GetLoaderInstance();
1596 TEST_ASSERT_NOT_NULL(loader);
1597 if (loader == NULL) {
1598 LOGE("alg loader instance is NULL");
1599 return;
1600 }
1601
1602 int32_t res;
1603 RUN_AND_PRINT_ELAPSED_TIME(res, loader->initAlg());
1604 TEST_ASSERT_EQUAL(HAL_SUCCESS, res);
1605
1606 TestSha256(loader);
1607
1608 TestGenerateRandom(loader);
1609
1610 TestComputeHmac(loader);
1611
1612 TestComputeHkdf(loader);
1613
1614 #if (defined(DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY) && DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY)
1615 (void)(TestImportSymmetricKey);
1616 #else // DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY
1617 TestImportSymmetricKey(loader);
1618 #endif // DO_NOT_TEST_DEPRECATED_IMPORT_SYMMETRIC_KEY
1619
1620 TestCheckKeyExist(loader);
1621
1622 TestDeleteKey(loader);
1623
1624 TestAesGcmEncrypt(loader);
1625
1626 TestAesGcmDecrypt(loader);
1627
1628 TestHashToPoint(loader);
1629
1630 TestGenerateKeyPairWithStorage(loader);
1631
1632 TestAgreeSharedSecretWithStorage(loader);
1633
1634 TestAgreeSharedSecret(loader);
1635
1636 TestBigNumExpMod(loader);
1637
1638 TestGenerateKeyPair(loader);
1639
1640 TestExportPublicKey(loader);
1641
1642 TestSign(loader);
1643
1644 TestVerify(loader);
1645
1646 TestImportPublicKey(loader);
1647
1648 TestCheckDlPublicKey(loader);
1649
1650 TestCheckEcPublicKey(loader);
1651
1652 TestBigNumCompare(loader);
1653 }
1654
1655 #ifdef __cplusplus
1656 }
1657 #endif
1658