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