1 /*
2 * Copyright (c) 2023 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 "hks_test_curve25519_c.h"
17
TestGenerateEd25519Key(struct HksBlob alias)18 int32_t TestGenerateEd25519Key(struct HksBlob alias)
19 {
20 HKS_TEST_LOG_I("Test_GenerateEd25519!\n");
21 struct HksParamSet *paramSet = NULL;
22 int32_t ret = HksInitParamSet(¶mSet);
23 HKS_TEST_ASSERT(ret == 0);
24 struct HksParam algParam = {0};
25 algParam.tag = HKS_TAG_ALGORITHM;
26 algParam.uint32Param = HKS_ALG_ED25519;
27 ret = HksAddParams(paramSet, &algParam, 1);
28 HKS_TEST_ASSERT(ret == 0);
29 struct HksParam keySizeParam = {0};
30 keySizeParam.tag = HKS_TAG_KEY_SIZE;
31 keySizeParam.uint32Param = TEST_CURVE_256;
32 ret = HksAddParams(paramSet, &keySizeParam, 1);
33 HKS_TEST_ASSERT(ret == 0);
34 struct HksParam purposeParam = {0};
35 purposeParam.tag = HKS_TAG_PURPOSE;
36 purposeParam.uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY;
37 ret = HksAddParams(paramSet, &purposeParam, 1);
38 HKS_TEST_ASSERT(ret == 0);
39 struct HksParam digestParam = {0};
40 digestParam.tag = HKS_TAG_DIGEST;
41 digestParam.uint32Param = HKS_DIGEST_SHA512;
42 ret = HksAddParams(paramSet, &digestParam, 1);
43 HKS_TEST_ASSERT(ret == 0);
44 struct HksParam paddingParam = {0};
45 paddingParam.tag = HKS_TAG_PADDING;
46 paddingParam.uint32Param = HKS_PADDING_NONE;
47 ret = HksAddParams(paramSet, &paddingParam, 1);
48 HKS_TEST_ASSERT(ret == 0);
49 ret = HksBuildParamSet(¶mSet);
50 HKS_TEST_ASSERT(ret == 0);
51 ret = HksGenerateKey(&alias, paramSet, NULL);
52 HKS_TEST_ASSERT(ret == 0);
53 HksFreeParamSet(¶mSet);
54 return ret;
55 }
56
TestSignEd25519(struct HksBlob alias)57 int32_t TestSignEd25519(struct HksBlob alias)
58 {
59 struct HksBlob msg = {strlen(TEST_PLAIN_TEST_ED25519), (uint8_t *)TEST_PLAIN_TEST_ED25519};
60
61 struct HksParamSet *paramSet = NULL;
62 int32_t ret = HksInitParamSet(¶mSet);
63 HKS_TEST_ASSERT(ret == 0);
64 struct HksParam algParam = {0};
65 algParam.tag = HKS_TAG_ALGORITHM;
66 algParam.uint32Param = HKS_ALG_ED25519;
67 ret = HksAddParams(paramSet, &algParam, 1);
68 HKS_TEST_ASSERT(ret == 0);
69 struct HksParam purposeParam = {0};
70 purposeParam.tag = HKS_TAG_PURPOSE;
71 purposeParam.uint32Param = HKS_KEY_PURPOSE_SIGN;
72 ret = HksAddParams(paramSet, &purposeParam, 1);
73 HKS_TEST_ASSERT(ret == 0);
74 struct HksParam digestParam = {0};
75 digestParam.tag = HKS_TAG_DIGEST;
76 digestParam.uint32Param = HKS_DIGEST_SHA512;
77 ret = HksAddParams(paramSet, &digestParam, 1);
78 HKS_TEST_ASSERT(ret == 0);
79 struct HksParam paddingParam = {0};
80 paddingParam.tag = HKS_TAG_PADDING;
81 paddingParam.uint32Param = HKS_PADDING_NONE;
82 ret = HksAddParams(paramSet, &paddingParam, 1);
83 HKS_TEST_ASSERT(ret == 0);
84 ret = HksBuildParamSet(¶mSet);
85 HKS_TEST_ASSERT(ret == 0);
86 struct HksBlob signature = { TEST_CURVE_256, g_buffer };
87 ret = HksSign(&alias, paramSet, &msg, &signature);
88 HKS_TEST_ASSERT(ret == 0);
89 g_bufferSize = signature.size;
90 HKS_TEST_LOG_I("TestSignEd25519 signature size is %u", signature.size);
91 HksFreeParamSet(¶mSet);
92 return ret;
93 }
94
TestVerifyEd25519(struct HksBlob alias)95 int32_t TestVerifyEd25519(struct HksBlob alias)
96 {
97 struct HksBlob msg = {strlen(TEST_PLAIN_TEST_ED25519), (uint8_t *)TEST_PLAIN_TEST_ED25519};
98
99 HKS_TEST_LOG_I("TestVerifyEd25519!\n");
100 struct HksParamSet *paramSet = NULL;
101 int32_t ret = HksInitParamSet(¶mSet);
102 HKS_TEST_ASSERT(ret == 0);
103
104 struct HksParam algParam = {0};
105 algParam.tag = HKS_TAG_ALGORITHM;
106 algParam.uint32Param = HKS_ALG_ED25519;
107 ret = HksAddParams(paramSet, &algParam, 1);
108 HKS_TEST_ASSERT(ret == 0);
109
110 struct HksParam purposeParam = {0};
111 purposeParam.tag = HKS_TAG_PURPOSE;
112 purposeParam.uint32Param = HKS_KEY_PURPOSE_VERIFY;
113 ret = HksAddParams(paramSet, &purposeParam, 1);
114 HKS_TEST_ASSERT(ret == 0);
115
116 struct HksParam digestParam = {0};
117 digestParam.tag = HKS_TAG_DIGEST;
118 digestParam.uint32Param = HKS_DIGEST_SHA512;
119 ret = HksAddParams(paramSet, &digestParam, 1);
120 HKS_TEST_ASSERT(ret == 0);
121
122 struct HksParam paddingParam = {0};
123 paddingParam.tag = HKS_TAG_PADDING;
124 paddingParam.uint32Param = HKS_PADDING_NONE;
125 ret = HksAddParams(paramSet, &paddingParam, 1);
126 HKS_TEST_ASSERT(ret == 0);
127
128 ret = HksBuildParamSet(¶mSet);
129 HKS_TEST_ASSERT(ret == 0);
130
131 struct HksBlob signature = { g_bufferSize, g_buffer };
132 ret = HksVerify(&alias, paramSet, &msg, &signature);
133 HKS_TEST_ASSERT(ret == 0);
134 HksFreeParamSet(¶mSet);
135 return ret;
136 }
137
TestImportEd25519(struct HksBlob alias,struct HksBlob * pubKeyInfo)138 int32_t TestImportEd25519(struct HksBlob alias, struct HksBlob *pubKeyInfo)
139 {
140 HKS_TEST_LOG_I("TestImportEd25519!\n");
141 struct HksParamSet *paramSet = NULL;
142 int32_t ret = HksInitParamSet(¶mSet);
143 HKS_TEST_ASSERT(ret == 0);
144
145 struct HksParam algParam = {0};
146 algParam.tag = HKS_TAG_ALGORITHM;
147 algParam.uint32Param = HKS_ALG_ED25519;
148 ret = HksAddParams(paramSet, &algParam, 1);
149 HKS_TEST_ASSERT(ret == 0);
150
151 struct HksParam keySizeParam = {0};
152 keySizeParam.tag = HKS_TAG_KEY_SIZE;
153 keySizeParam.uint32Param = TEST_CURVE_256;
154 ret = HksAddParams(paramSet, &keySizeParam, 1);
155 HKS_TEST_ASSERT(ret == 0);
156
157 struct HksParam purposeParam = {0};
158 purposeParam.tag = HKS_TAG_PURPOSE;
159 purposeParam.uint32Param = HKS_KEY_PURPOSE_VERIFY;
160 ret = HksAddParams(paramSet, &purposeParam, 1);
161 HKS_TEST_ASSERT(ret == 0);
162
163 struct HksParam digestParam = {0};
164 digestParam.tag = HKS_TAG_DIGEST;
165 digestParam.uint32Param = HKS_DIGEST_SHA512;
166 ret = HksAddParams(paramSet, &digestParam, 1);
167 HKS_TEST_ASSERT(ret == 0);
168
169 struct HksParam paddingParam = {0};
170 paddingParam.tag = HKS_TAG_PADDING;
171 paddingParam.uint32Param = HKS_PADDING_NONE;
172 ret = HksAddParams(paramSet, &paddingParam, 1);
173 HKS_TEST_ASSERT(ret == 0);
174
175 ret = HksBuildParamSet(¶mSet);
176 HKS_TEST_ASSERT(ret == 0);
177
178 ret = HksImportKey(&alias, paramSet, pubKeyInfo);
179 HKS_TEST_ASSERT(ret == 0);
180 HksFreeParamSet(¶mSet);
181 return ret;
182 }
183
TestExportImportEd25519SignVerify(struct HksBlob alias)184 int32_t TestExportImportEd25519SignVerify(struct HksBlob alias)
185 {
186 uint8_t pubKey[32] = {0};
187 uint32_t pubKeyLen = 32;
188 struct HksBlob pubKeyInfo = { pubKeyLen, pubKey };
189 int32_t ret = TestGenerateEd25519Key(alias);
190 HKS_TEST_ASSERT(ret == 0);
191
192 ret = HksExportPublicKey(&alias, NULL, &pubKeyInfo);
193 HKS_TEST_ASSERT(ret == 0);
194
195 ret = TestSignEd25519(alias);
196 HKS_TEST_ASSERT(ret == 0);
197
198 ret = HksDeleteKey(&alias, NULL);
199 HKS_TEST_ASSERT(ret == 0);
200
201 struct HksBlob newAlias = { strlen("test_ed25519_2"), (uint8_t *)"test_ed25519_2" };
202 ret = TestImportEd25519(newAlias, &pubKeyInfo);
203 HKS_TEST_ASSERT(ret == 0);
204 ret = TestVerifyEd25519(newAlias);
205 HKS_TEST_ASSERT(ret == 0);
206
207 ret = HksDeleteKey(&newAlias, NULL);
208 HKS_TEST_ASSERT(ret == 0);
209 return ret;
210 }
211
TestCurve25519All()212 int32_t TestCurve25519All()
213 {
214 struct HksBlob ed25519Alias = { strlen(TEST_ALIAS_ED25519), (uint8_t *)TEST_ALIAS_ED25519 };
215 int32_t ret = TestGenerateEd25519Key(ed25519Alias);
216 HKS_TEST_ASSERT(ret == 0);
217 ret = TestSignEd25519(ed25519Alias);
218 HKS_TEST_ASSERT(ret == 0);
219 ret = TestVerifyEd25519(ed25519Alias);
220 HKS_TEST_ASSERT(ret == 0);
221 ret = HksDeleteKey(&ed25519Alias, NULL);
222 HKS_TEST_ASSERT(ret == 0);
223
224 ret = TestExportImportEd25519SignVerify(ed25519Alias);
225 HKS_TEST_ASSERT(ret == 0);
226 return ret;
227 }
228
BuildTeeSignParamSet(struct HksParamSet ** paramSet)229 int32_t BuildTeeSignParamSet(struct HksParamSet **paramSet)
230 {
231 int32_t ret = HksInitParamSet(paramSet);
232 HKS_TEST_ASSERT(ret == 0);
233
234 struct HksParam algParam = {0};
235 algParam.tag = HKS_TAG_ALGORITHM;
236 algParam.uint32Param = HKS_ALG_ED25519;
237 ret = HksAddParams(*paramSet, &algParam, 1);
238 HKS_TEST_ASSERT(ret == 0);
239
240 struct HksParam purposeParam = {0};
241 purposeParam.tag = HKS_TAG_PURPOSE;
242 purposeParam.uint32Param = HKS_KEY_PURPOSE_SIGN;
243 ret = HksAddParams(*paramSet, &purposeParam, 1);
244 HKS_TEST_ASSERT(ret == 0);
245
246 struct HksParam digestParam = {0};
247 digestParam.tag = HKS_TAG_DIGEST;
248 digestParam.uint32Param = HKS_DIGEST_SHA512;
249 ret = HksAddParams(*paramSet, &digestParam, 1);
250 HKS_TEST_ASSERT(ret == 0);
251
252 struct HksParam paddingParam = {0};
253 paddingParam.tag = HKS_TAG_PADDING;
254 paddingParam.uint32Param = HKS_PADDING_NONE;
255 ret = HksAddParams(*paramSet, &paddingParam, 1);
256 HKS_TEST_ASSERT(ret == 0);
257
258 ret = HksBuildParamSet(paramSet);
259 HKS_TEST_ASSERT(ret == 0);
260 return ret;
261 }
262
BuildLocalVerifyParamSet(struct HksParamSet ** paramSet)263 int32_t BuildLocalVerifyParamSet(struct HksParamSet **paramSet)
264 {
265 int32_t ret = HksInitParamSet(paramSet);
266 HKS_TEST_ASSERT(ret == 0);
267
268 struct HksParam algParam = {0};
269 algParam.tag = HKS_TAG_ALGORITHM;
270 algParam.uint32Param = HKS_ALG_ED25519;
271 ret = HksAddParams(*paramSet, &algParam, 1);
272 HKS_TEST_ASSERT(ret == 0);
273
274 struct HksParam isKeyAlias = {0};
275 isKeyAlias.tag = HKS_TAG_IS_KEY_ALIAS;
276 isKeyAlias.boolParam = false;
277 ret = HksAddParams(*paramSet, &isKeyAlias, 1);
278 HKS_TEST_ASSERT(ret == 0);
279
280 struct HksParam keySizeParam = {0};
281 keySizeParam.tag = HKS_TAG_KEY_SIZE;
282 keySizeParam.uint32Param = TEST_CURVE_256;
283 ret = HksAddParams(*paramSet, &keySizeParam, 1);
284 HKS_TEST_ASSERT(ret == 0);
285
286 struct HksParam purposeParam = {0};
287 purposeParam.tag = HKS_TAG_PURPOSE;
288 purposeParam.uint32Param = HKS_KEY_PURPOSE_VERIFY;
289 ret = HksAddParams(*paramSet, &purposeParam, 1);
290 HKS_TEST_ASSERT(ret == 0);
291
292 struct HksParam digestParam = {0};
293 digestParam.tag = HKS_TAG_DIGEST;
294 digestParam.uint32Param = HKS_DIGEST_SHA512;
295 ret = HksAddParams(*paramSet, &digestParam, 1);
296 HKS_TEST_ASSERT(ret == 0);
297
298 ret = HksBuildParamSet(paramSet);
299 HKS_TEST_ASSERT(ret == 0);
300 return ret;
301 }
302
TestEd25519SignTeeVerifyLocal()303 int32_t TestEd25519SignTeeVerifyLocal()
304 {
305 HKS_TEST_LOG_D("TestEd25519SignTeeVerifyLocal enter!");
306
307 struct HksBlob ed25519Alias = { strlen(TEST_ALIAS_ED25519), (uint8_t *)TEST_ALIAS_ED25519 };
308 struct HksBlob msg = {strlen(TEST_PLAIN_TEST_ED25519), (uint8_t *)TEST_PLAIN_TEST_ED25519};
309 struct HksBlob signature = { TEST_CURVE_256, g_buffer };
310 struct HksParamSet *paramSetSign = NULL;
311 struct HksParamSet *paramSetVerify = NULL;
312 struct HksBlob pubKeyInfo = { g_pubKeyLen, g_pubKey };
313
314 int32_t ret = TestGenerateEd25519Key(ed25519Alias);
315 HKS_TEST_ASSERT(ret == 0);
316
317 ret = HksExportPublicKey(&ed25519Alias, NULL, &pubKeyInfo);
318 HKS_TEST_ASSERT(ret == 0);
319 HKS_TEST_LOG_I("HksExportPublicKey puKey size is %u", pubKeyInfo.size);
320
321 ret = BuildTeeSignParamSet(¶mSetSign);
322 HKS_TEST_ASSERT(ret == 0);
323 ret = HksSign(&ed25519Alias, paramSetSign, &msg, &signature);
324 HKS_TEST_ASSERT(ret == 0);
325 HKS_TEST_LOG_I("Test_Ed25519_Sign_TEE signature size is %u", signature.size);
326
327 ret = BuildLocalVerifyParamSet(¶mSetVerify);
328 HKS_TEST_ASSERT(ret == 0);
329 ret = HksVerify(&pubKeyInfo, paramSetVerify, &msg, &signature);
330 HKS_TEST_ASSERT(ret == 0);
331 HKS_TEST_LOG_I("Test_Ed25519_Verify_Local Success");
332
333 ret = HksDeleteKey(&ed25519Alias, NULL);
334 HKS_TEST_ASSERT(ret == 0);
335
336 HksFreeParamSet(¶mSetSign);
337 HksFreeParamSet(¶mSetVerify);
338 HKS_TEST_LOG_D("TestEd25519SignTeeVerifyLocal End!\n");
339 return ret;
340 }
341
TestSignEd25519Wrong(struct HksBlob alias)342 int32_t TestSignEd25519Wrong(struct HksBlob alias)
343 {
344 struct HksBlob msg = {strlen(TEST_PLAIN_TEST_ED25519), (uint8_t *)TEST_PLAIN_TEST_ED25519};
345
346 struct HksParamSet *paramSet = NULL;
347 int32_t ret = HksInitParamSet(¶mSet);
348 HKS_TEST_ASSERT(ret == 0);
349 struct HksParam algParam = {0};
350 algParam.tag = HKS_TAG_ALGORITHM;
351 algParam.uint32Param = HKS_ALG_ED25519;
352 ret = HksAddParams(paramSet, &algParam, 1);
353 HKS_TEST_ASSERT(ret == 0);
354 struct HksParam purposeParam = {0};
355 purposeParam.tag = HKS_TAG_PURPOSE;
356 purposeParam.uint32Param = HKS_KEY_PURPOSE_VERIFY;
357 ret = HksAddParams(paramSet, &purposeParam, 1);
358 HKS_TEST_ASSERT(ret == 0);
359 struct HksParam digestParam = {0};
360 digestParam.tag = HKS_TAG_DIGEST;
361 digestParam.uint32Param = HKS_DIGEST_SHA256;
362 ret = HksAddParams(paramSet, &digestParam, 1);
363 HKS_TEST_ASSERT(ret == 0);
364 struct HksParam paddingParam = {0};
365 paddingParam.tag = HKS_TAG_PADDING;
366 paddingParam.uint32Param = HKS_PADDING_PKCS5;
367 ret = HksAddParams(paramSet, &paddingParam, 1);
368 HKS_TEST_ASSERT(ret == 0);
369 ret = HksBuildParamSet(¶mSet);
370 HKS_TEST_ASSERT(ret == 0);
371 struct HksBlob signature = { TEST_CURVE_256, g_buffer };
372 ret = HksSign(&alias, paramSet, &msg, &signature);
373 HKS_TEST_ASSERT(ret != 0);
374 g_bufferSize = signature.size;
375 HKS_TEST_LOG_I("TestSignEd25519 signature size is %u", signature.size);
376 HksFreeParamSet(¶mSet);
377 return ret;
378 }
379
TestCurve25519SignWrong()380 int32_t TestCurve25519SignWrong()
381 {
382 struct HksBlob ed25519Alias = { strlen(TEST_ALIAS_ED25519), (uint8_t *)TEST_ALIAS_ED25519 };
383 int32_t ret = TestGenerateEd25519Key(ed25519Alias);
384 HKS_TEST_ASSERT(ret == 0);
385 ret = TestSignEd25519Wrong(ed25519Alias);
386 HKS_TEST_ASSERT(ret != 0);
387 int32_t retTwo = HksDeleteKey(&ed25519Alias, NULL);
388 HKS_TEST_ASSERT(retTwo == 0);
389 if ((ret != 0) && (retTwo == 0)) {
390 return 0;
391 }
392 return 1;
393 }
394
TestVerifyEd25519Wrong(struct HksBlob alias)395 int32_t TestVerifyEd25519Wrong(struct HksBlob alias)
396 {
397 struct HksBlob msg = {strlen(TEST_PLAIN_TEST_ED25519), (uint8_t *)TEST_PLAIN_TEST_ED25519};
398
399 HKS_TEST_LOG_I("TestVerifyEd25519!\n");
400 struct HksParamSet *paramSet = NULL;
401 int32_t ret = HksInitParamSet(¶mSet);
402 HKS_TEST_ASSERT(ret == 0);
403
404 struct HksParam algParam = {0};
405 algParam.tag = HKS_TAG_ALGORITHM;
406 algParam.uint32Param = HKS_ALG_ED25519;
407 ret = HksAddParams(paramSet, &algParam, 1);
408 HKS_TEST_ASSERT(ret == 0);
409
410 struct HksParam purposeParam = {0};
411 purposeParam.tag = HKS_TAG_PURPOSE;
412 purposeParam.uint32Param = HKS_KEY_PURPOSE_SIGN;
413 ret = HksAddParams(paramSet, &purposeParam, 1);
414 HKS_TEST_ASSERT(ret == 0);
415
416 struct HksParam digestParam = {0};
417 digestParam.tag = HKS_TAG_DIGEST;
418 digestParam.uint32Param = HKS_DIGEST_SHA256;
419 ret = HksAddParams(paramSet, &digestParam, 1);
420 HKS_TEST_ASSERT(ret == 0);
421
422 struct HksParam paddingParam = {0};
423 paddingParam.tag = HKS_TAG_PADDING;
424 paddingParam.uint32Param = HKS_PADDING_PKCS5;
425 ret = HksAddParams(paramSet, &paddingParam, 1);
426 HKS_TEST_ASSERT(ret == 0);
427
428 ret = HksBuildParamSet(¶mSet);
429 HKS_TEST_ASSERT(ret == 0);
430
431 struct HksBlob signature = { g_bufferSize, g_buffer };
432 ret = HksVerify(&alias, paramSet, &msg, &signature);
433 HKS_TEST_ASSERT(ret != 0);
434 HksFreeParamSet(¶mSet);
435 return ret;
436 }
437
TestCurve25519verifyWrong()438 int32_t TestCurve25519verifyWrong()
439 {
440 struct HksBlob ed25519Alias = { strlen(TEST_ALIAS_ED25519), (uint8_t *)TEST_ALIAS_ED25519 };
441 int32_t ret = TestGenerateEd25519Key(ed25519Alias);
442 HKS_TEST_ASSERT(ret == 0);
443 ret = TestSignEd25519(ed25519Alias);
444 HKS_TEST_ASSERT(ret == 0);
445 ret = TestVerifyEd25519Wrong(ed25519Alias);
446 HKS_TEST_ASSERT(ret != 0);
447 int32_t retTwo = HksDeleteKey(&ed25519Alias, NULL);
448 HKS_TEST_ASSERT(retTwo == 0);
449 if ((ret != 0) && (retTwo == 0)) {
450 return 0;
451 }
452 return 1;
453 }