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