1 /*
2 * Copyright (c) 2022 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_ed25519_sign_verify_test.h"
17
18 #include <gtest/gtest.h>
19
20 using namespace testing::ext;
21 namespace Unittest::Ed25519 {
22 class HksEd25519SignVerifyTest : public testing::Test {
23 public:
24 static void SetUpTestCase(void);
25
26 static void TearDownTestCase(void);
27
28 void SetUp();
29
30 void TearDown();
31 };
32
SetUpTestCase(void)33 void HksEd25519SignVerifyTest::SetUpTestCase(void)
34 {
35 }
36
TearDownTestCase(void)37 void HksEd25519SignVerifyTest::TearDownTestCase(void)
38 {
39 }
40
SetUp()41 void HksEd25519SignVerifyTest::SetUp()
42 {
43 }
44
TearDown()45 void HksEd25519SignVerifyTest::TearDown()
46 {
47 }
48
HksTestFreeParamSet(struct HksParamSet * paramSet1,struct HksParamSet * paramSet2,struct HksParamSet * paramSet3)49 void HksTestFreeParamSet(struct HksParamSet *paramSet1, struct HksParamSet *paramSet2,
50 struct HksParamSet *paramSet3)
51 {
52 HksFreeParamSet(¶mSet1);
53 HksFreeParamSet(¶mSet2);
54 HksFreeParamSet(¶mSet3);
55 }
56
HksTestSignVerify(struct HksBlob * keyAlias,struct HksParamSet * paramSet,const struct HksBlob * inData,struct HksBlob * outData,bool isSign)57 int32_t HksTestSignVerify(struct HksBlob *keyAlias, struct HksParamSet *paramSet, const struct HksBlob *inData,
58 struct HksBlob *outData, bool isSign)
59 {
60 uint8_t tmpHandle[sizeof(uint64_t)] = {0};
61 struct HksBlob handle = { sizeof(uint64_t), tmpHandle };
62 int32_t ret = HksInit(keyAlias, paramSet, &handle);
63 EXPECT_EQ(ret, HKS_SUCCESS) << "Init failed.";
64 if (ret != HKS_SUCCESS) {
65 return HKS_FAILURE;
66 }
67
68 struct HksParam *tmpParam = NULL;
69 ret = HksGetParam(paramSet, HKS_TAG_PURPOSE, &tmpParam);
70 if (ret != HKS_SUCCESS) {
71 HKS_LOG_E("get tag purpose failed.");
72 return HKS_FAILURE;
73 }
74
75 ret = TestUpdateFinish(&handle, paramSet, tmpParam->uint32Param, inData, outData);
76 EXPECT_EQ(ret, HKS_SUCCESS) << "TestUpdateFinish failed.";
77 if (ret != HKS_SUCCESS) {
78 return HKS_FAILURE;
79 }
80
81 if (isSign) {
82 uint8_t tmpOut[Unittest::Ed25519::ED25519_COMMON_SIZE] = {0};
83 struct HksBlob outData1 = { Unittest::Ed25519::ED25519_COMMON_SIZE, tmpOut };
84 ret = HksSign(keyAlias, paramSet, inData, &outData1);
85 EXPECT_EQ(ret, HKS_SUCCESS) << "HksSign failed.";
86 } else {
87 ret = HksVerify(keyAlias, paramSet, inData, outData);
88 EXPECT_EQ(ret, HKS_SUCCESS) << "HksVerify failed.";
89 }
90
91 return ret;
92 }
93
94 /**
95 * @tc.name: HksEd25519SignVerifyTest.HksEd25519SignVerifyTest001
96 * @tc.desc: alg-ED25519 pur-Sign.
97 * @tc.type: FUNC
98 */
99 HWTEST_F(HksEd25519SignVerifyTest, HksEd25519SignVerifyTest001, TestSize.Level0)
100 {
101 const char *keyAliasString = "HksED25519SignVerifyKeyAliasTest001";
102 struct HksParamSet *genParamSet = nullptr;
103 struct HksParamSet *signParamSet = nullptr;
104 struct HksParamSet *verifyParamSet = nullptr;
105 int32_t ret = HKS_FAILURE;
106
107 ret = InitParamSet(&genParamSet, Unittest::Ed25519::g_genParamsTest001,
108 sizeof(Unittest::Ed25519::g_genParamsTest001)/sizeof(HksParam));
109 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
110 ret = InitParamSet(&signParamSet, Unittest::Ed25519::g_signParamsTest001,
111 sizeof(Unittest::Ed25519::g_signParamsTest001)/sizeof(HksParam));
112 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
113 ret = InitParamSet(&verifyParamSet, Unittest::Ed25519::g_verifyParamsTest001,
114 sizeof(Unittest::Ed25519::g_verifyParamsTest001)/sizeof(HksParam));
115 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
116
117 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
118
119 /* 1. Generate Key */
120 ret = HksGenerateKey(&keyAlias, genParamSet, nullptr);
121 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey failed.";
122
123 /* 2. Sign Three Stage */
124 uint8_t outDataS[Unittest::Ed25519::ED25519_COMMON_SIZE] = {0};
125 struct HksBlob outDataSign = { Unittest::Ed25519::ED25519_COMMON_SIZE, outDataS };
126 ret = HksTestSignVerify(&keyAlias, signParamSet, &g_inData, &outDataSign, true);
127 EXPECT_EQ(ret, HKS_SUCCESS) << "Sign failed.";
128
129 /* 3. Export Public Key */
130 uint8_t pubKey[HKS_CURVE25519_KEY_SIZE_256] = {0};
131 struct HksBlob publicKey = { HKS_CURVE25519_KEY_SIZE_256, pubKey };
132 ret = HksExportPublicKey(&keyAlias, genParamSet, &publicKey);
133 EXPECT_EQ(ret, HKS_SUCCESS) << "ExportPublicKey failed.";
134
135 /* 4. Import Key */
136 char newKey[] = "ECC_Sign_Verify_Import_KeyAlias";
137 struct HksBlob newKeyAlias = { .size = strlen(newKey), .data = (uint8_t *)newKey };
138 ret = HksImportKey(&newKeyAlias, verifyParamSet, &publicKey);
139 EXPECT_EQ(ret, HKS_SUCCESS) << "ImportKey failed";
140
141 /* 5. Verify Three Stage */
142 ret = HksTestSignVerify(&newKeyAlias, verifyParamSet, &g_inData, &outDataSign, false);
143 EXPECT_EQ(ret, HKS_SUCCESS) << "Verify failed.";
144
145 /* 5. Delete Key */
146 EXPECT_EQ(HksDeleteKey(&keyAlias, genParamSet), HKS_SUCCESS) << "DeleteKey failed.";
147 EXPECT_EQ(HksDeleteKey(&newKeyAlias, verifyParamSet), HKS_SUCCESS) << "Delete ImportKey failed.";
148
149 HksTestFreeParamSet(genParamSet, signParamSet, verifyParamSet);
150 }
151
152 /**
153 * @tc.name: HksEd25519SignVerifyTest.HksEd25519SignVerifyTest002
154 * @tc.desc: alg-ED25519 pur-Sign. Verify-Abort
155 * @tc.type: FUNC
156 */
157 HWTEST_F(HksEd25519SignVerifyTest, HksEd25519SignVerifyTest002, TestSize.Level0)
158 {
159 const char *keyAliasString = "HksED25519SignVerifyKeyAliasTest002";
160 struct HksParamSet *genParamSet = nullptr;
161 struct HksParamSet *signParamSet = nullptr;
162 struct HksParamSet *verifyParamSet = nullptr;
163 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
164
165 int32_t ret = InitParamSet(&genParamSet, Unittest::Ed25519::g_genParamsTest002,
166 sizeof(Unittest::Ed25519::g_genParamsTest002)/sizeof(HksParam));
167 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
168 ret = InitParamSet(&signParamSet, Unittest::Ed25519::g_signParamsTest002,
169 sizeof(Unittest::Ed25519::g_signParamsTest002)/sizeof(HksParam));
170 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
171 ret = InitParamSet(&verifyParamSet, Unittest::Ed25519::g_verifyParamsTest002,
172 sizeof(Unittest::Ed25519::g_verifyParamsTest002)/sizeof(HksParam));
173 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
174
175 /* 1. Generate Key */
176 // Generate Key
177 ret = HksGenerateKey(&keyAlias, genParamSet, nullptr);
178 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey failed.";
179
180 /* 2. Sign Three Stage */
181 // Init
182 uint8_t handleS[sizeof(uint64_t)] = {0};
183 struct HksBlob handleSign = { sizeof(uint64_t), handleS };
184 ret = HksInit(&keyAlias, signParamSet, &handleSign);
185 EXPECT_EQ(ret, HKS_SUCCESS) << "Init failed.";
186 // Update loop
187 ret = HksTestUpdate(&handleSign, signParamSet, &Unittest::Ed25519::g_inData);
188 EXPECT_EQ(ret, HKS_SUCCESS) << "Update failed.";
189 // Finish
190 uint8_t outDataS[Unittest::Ed25519::ED25519_COMMON_SIZE] = {0};
191 struct HksBlob outDataSign = { Unittest::Ed25519::ED25519_COMMON_SIZE, outDataS };
192 ret = HksFinish(&handleSign, signParamSet, &Unittest::Ed25519::g_inData, &outDataSign);
193 EXPECT_EQ(ret, HKS_SUCCESS) << "Finish failed.";
194
195 /* 3. Export Public Key */
196 uint8_t pubKey[HKS_CURVE25519_KEY_SIZE_256] = {0};
197 struct HksBlob publicKey = { HKS_CURVE25519_KEY_SIZE_256, pubKey };
198 ret = HksExportPublicKey(&keyAlias, genParamSet, &publicKey);
199 EXPECT_EQ(ret, HKS_SUCCESS) << "ExportPublicKey failed.";
200
201 /* 4. Import Key */
202 char newKey[] = "ED25519_Sign_Verify_Import_KeyAlias";
203 struct HksBlob newKeyAlias = { .size = strlen(newKey), .data = (uint8_t *)newKey };
204 ret = HksImportKey(&newKeyAlias, verifyParamSet, &publicKey);
205 EXPECT_EQ(ret, HKS_SUCCESS) << "ImportKey failed";
206
207 /* 5. Verify Three Stage */
208 // Init
209 uint8_t handleV[sizeof(uint64_t)] = {0};
210 struct HksBlob handleVerify = { sizeof(uint64_t), handleV };
211 ret = HksInit(&newKeyAlias, verifyParamSet, &handleVerify);
212 EXPECT_EQ(ret, HKS_SUCCESS) << "Init failed.";
213 // Update loop
214 ret = HksTestUpdate(&handleVerify, verifyParamSet, &Unittest::Ed25519::g_inData);
215 EXPECT_EQ(ret, HKS_SUCCESS) << "Update failed.";
216 // Abort
217 ret = HksAbort(&handleVerify, verifyParamSet);
218 EXPECT_EQ(ret, HKS_SUCCESS) << "Abort failed.";
219
220 /* 5. Delete Key */
221 ret = HksDeleteKey(&keyAlias, genParamSet);
222 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
223 ret = HksDeleteKey(&newKeyAlias, verifyParamSet);
224 EXPECT_EQ(ret, HKS_SUCCESS) << "Delete ImportKey failed.";
225
226 HksTestFreeParamSet(genParamSet, signParamSet, verifyParamSet);
227 }
228
229 /**
230 * @tc.name: HksEd25519SignVerifyTest.HksEd25519SignVerifyTest003
231 * @tc.desc: alg-ED25519 pur-Sign. Sign-Abort
232 * @tc.type: FUNC
233 */
234 HWTEST_F(HksEd25519SignVerifyTest, HksEd25519SignVerifyTest003, TestSize.Level0)
235 {
236 const char *keyAliasString = "HksED25519SignVerifyKeyAliasTest003";
237 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
238 int32_t ret = HKS_FAILURE;
239
240 /* 1. Generate Key */
241 struct HksParamSet *genParamSet = nullptr;
242 ret = InitParamSet(&genParamSet, Unittest::Ed25519::g_genParamsTest003,
243 sizeof(Unittest::Ed25519::g_genParamsTest003)/sizeof(HksParam));
244 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
245 // Generate Key
246 ret = HksGenerateKey(&keyAlias, genParamSet, nullptr);
247 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey failed.";
248
249 /* 2. Sign Three Stage (Abort) */
250 struct HksParamSet *signParamSet = nullptr;
251 ret = InitParamSet(&signParamSet, Unittest::Ed25519::g_signParamsTest003,
252 sizeof(Unittest::Ed25519::g_signParamsTest003)/sizeof(HksParam));
253 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
254 // Init
255 uint8_t handleS[sizeof(uint64_t)] = {0};
256 struct HksBlob handleSign = { sizeof(uint64_t), handleS };
257 ret = HksInit(&keyAlias, signParamSet, &handleSign);
258 EXPECT_EQ(ret, HKS_SUCCESS) << "Init failed.";
259 // Update loop
260 ret = HksTestUpdate(&handleSign, signParamSet, &Unittest::Ed25519::g_inData);
261 EXPECT_EQ(ret, HKS_SUCCESS) << "Update failed.";
262 // Abort
263 ret = HksAbort(&handleSign, signParamSet);
264 EXPECT_EQ(ret, HKS_SUCCESS) << "Abort failed.";
265
266 /* 3. Delete Key */
267 ret = HksDeleteKey(&keyAlias, genParamSet);
268 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
269
270 HksFreeParamSet(&genParamSet);
271 HksFreeParamSet(&signParamSet);
272 }
273
274 /**
275 * @tc.name: HksEd25519SignVerifyTest.HksEd25519SignVerifyTest004
276 * @tc.desc: alg-ED25519 pur-Sign. abnormal
277 * @tc.type: FUNC
278 */
279 HWTEST_F(HksEd25519SignVerifyTest, HksEd25519SignVerifyTest004, TestSize.Level0)
280 {
281 const char *keyAliasString = "HksED25519SignVerifyKeyAliasTest004";
282 struct HksBlob keyAlias = { strlen(keyAliasString), (uint8_t *)keyAliasString };
283 int32_t ret = HKS_FAILURE;
284
285 /* 1. Generate Key */
286 struct HksParamSet *genParamSet = nullptr;
287 ret = InitParamSet(&genParamSet, Unittest::Ed25519::g_genParamsTest004,
288 sizeof(Unittest::Ed25519::g_genParamsTest004)/sizeof(HksParam));
289 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
290 // Generate Key
291 ret = HksGenerateKey(&keyAlias, genParamSet, nullptr);
292 EXPECT_EQ(ret, HKS_SUCCESS) << "GenerateKey failed.";
293
294 /* 2. Sign Three Stage */
295 struct HksParamSet *signParamSet = nullptr;
296 ret = InitParamSet(&signParamSet, Unittest::Ed25519::g_signParamsTest004,
297 sizeof(Unittest::Ed25519::g_signParamsTest004)/sizeof(HksParam));
298 EXPECT_EQ(ret, HKS_SUCCESS) << "InitParamSet failed.";
299 // Init
300 uint8_t handleS[sizeof(uint64_t)] = {0};
301 struct HksBlob handleSign = { sizeof(uint64_t), handleS };
302 ret = HksInit(NULL, signParamSet, &handleSign);
303 EXPECT_NE(ret, HKS_SUCCESS) << "Init should failed.";
304
305 /* 3. Delete Key */
306 ret = HksDeleteKey(&keyAlias, genParamSet);
307 EXPECT_EQ(ret, HKS_SUCCESS) << "DeleteKey failed.";
308
309 HksFreeParamSet(&genParamSet);
310 HksFreeParamSet(&signParamSet);
311 }
312 }