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 "huks_agree_x25519_test.h"
17
18 #include <gtest/gtest.h>
19
20 using namespace testing::ext;
21 namespace Unittest::X25519Agree {
22 class HuksAgreeX25519Test : 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 HuksAgreeX25519Test::SetUpTestCase(void)
34 {
35 }
36
TearDownTestCase(void)37 void HuksAgreeX25519Test::TearDownTestCase(void)
38 {
39 }
40
SetUp()41 void HuksAgreeX25519Test::SetUp()
42 {
43
44 }
45
TearDown()46 void HuksAgreeX25519Test::TearDown()
47 {
48 }
49
50 static struct OH_Huks_Blob g_keyAlias01001 = {
51 strlen("HksX25519AgreeKeyAliasTest001_1"),
52 (uint8_t *)"HksX25519AgreeKeyAliasTest001_1"
53 };
54 static struct OH_Huks_Blob g_keyAlias02001 = {
55 strlen("HksX25519AgreeKeyAliasTest001_2"),
56 (uint8_t *)"HksX25519AgreeKeyAliasTest001_2"
57 };
58 static struct OH_Huks_Blob g_keyAliasFinal1001 = {
59 strlen("HksX25519AgreeKeyAliasTest001_final"),
60 (uint8_t *)"HksX25519AgreeKeyAliasTest001_final"
61 };
62 static struct OH_Huks_Blob g_keyAliasFinal2001 = {
63 strlen("HksX25519AgreeKeyAliasTest002_final"),
64 (uint8_t *)"HksX25519AgreeKeyAliasTest002_final"
65 };
66
67 static struct OH_Huks_Param g_genParams001[] = {
68 {
69 .tag = OH_HUKS_TAG_ALGORITHM,
70 .uint32Param = OH_HUKS_ALG_X25519
71 }, {
72 .tag = OH_HUKS_TAG_PURPOSE,
73 .uint32Param = OH_HUKS_KEY_PURPOSE_AGREE
74 }, {
75 .tag = OH_HUKS_TAG_KEY_SIZE,
76 .uint32Param = OH_HUKS_CURVE25519_KEY_SIZE_256
77 }
78 };
79 static struct OH_Huks_Param g_agreeParams01Init001[] = {
80 {
81 .tag = OH_HUKS_TAG_ALGORITHM,
82 .uint32Param = OH_HUKS_ALG_X25519
83 }, {
84 .tag = OH_HUKS_TAG_PURPOSE,
85 .uint32Param = OH_HUKS_KEY_PURPOSE_AGREE
86 }, {
87 .tag = OH_HUKS_TAG_KEY_SIZE,
88 .uint32Param = OH_HUKS_CURVE25519_KEY_SIZE_256
89 }
90 };
91 static struct OH_Huks_Param g_agreeParams01Finish001[] = {
92 {
93 .tag = OH_HUKS_TAG_KEY_STORAGE_FLAG,
94 .uint32Param = OH_HUKS_STORAGE_PERSISTENT
95 }, {
96 .tag = OH_HUKS_TAG_IS_KEY_ALIAS, .boolParam = true
97 }, {
98 .tag = OH_HUKS_TAG_ALGORITHM,
99 .uint32Param = OH_HUKS_ALG_AES
100 }, {
101 .tag = OH_HUKS_TAG_KEY_SIZE,
102 .uint32Param = OH_HUKS_AES_KEY_SIZE_256
103 }, {
104 .tag = OH_HUKS_TAG_PURPOSE,
105 .uint32Param = OH_HUKS_KEY_PURPOSE_DERIVE
106 }, {
107 .tag = OH_HUKS_TAG_DIGEST,
108 .uint32Param = OH_HUKS_DIGEST_SHA256
109 }, {
110 .tag = OH_HUKS_TAG_KEY_ALIAS, .blob = g_keyAliasFinal1001
111 }, {
112 .tag = OH_HUKS_TAG_PADDING,
113 .uint32Param = OH_HUKS_PADDING_NONE
114 }, {
115 .tag = OH_HUKS_TAG_BLOCK_MODE,
116 .uint32Param = OH_HUKS_MODE_CBC
117 }
118 };
119 static struct OH_Huks_Param g_agreeParams02Init001[] = {
120 {
121 .tag = OH_HUKS_TAG_ALGORITHM,
122 .uint32Param = OH_HUKS_ALG_X25519
123 }, {
124 .tag = OH_HUKS_TAG_PURPOSE,
125 .uint32Param = OH_HUKS_KEY_PURPOSE_AGREE
126 }, {
127 .tag = OH_HUKS_TAG_KEY_SIZE,
128 .uint32Param = OH_HUKS_CURVE25519_KEY_SIZE_256
129 }
130 };
131 static struct OH_Huks_Param g_agreeParams02Finish001[] = {
132 {
133 .tag = OH_HUKS_TAG_KEY_STORAGE_FLAG,
134 .uint32Param = OH_HUKS_STORAGE_PERSISTENT
135 }, {
136 .tag = OH_HUKS_TAG_IS_KEY_ALIAS, .boolParam = true
137 }, {
138 .tag = OH_HUKS_TAG_ALGORITHM,
139 .uint32Param = OH_HUKS_ALG_AES
140 }, {
141 .tag = OH_HUKS_TAG_KEY_SIZE,
142 .uint32Param = OH_HUKS_AES_KEY_SIZE_256
143 }, {
144 .tag = OH_HUKS_TAG_PURPOSE,
145 .uint32Param = OH_HUKS_KEY_PURPOSE_DERIVE
146 }, {
147 .tag = OH_HUKS_TAG_DIGEST,
148 .uint32Param = OH_HUKS_DIGEST_SHA256
149 }, {
150 .tag = OH_HUKS_TAG_KEY_ALIAS, .blob = g_keyAliasFinal2001
151 }, {
152 .tag = OH_HUKS_TAG_PADDING,
153 .uint32Param = OH_HUKS_PADDING_NONE
154 }, {
155 .tag = OH_HUKS_TAG_BLOCK_MODE,
156 .uint32Param = OH_HUKS_MODE_CBC
157 }
158 };
159
HksX25519AgreeFinish(const struct OH_Huks_Blob * keyAlias,const struct OH_Huks_Blob * publicKey,const struct OH_Huks_ParamSet * initParamSet,const struct OH_Huks_ParamSet * finishParamSet,struct OH_Huks_Blob * outData)160 OH_Huks_Result HksX25519AgreeFinish(const struct OH_Huks_Blob *keyAlias, const struct OH_Huks_Blob *publicKey,
161 const struct OH_Huks_ParamSet *initParamSet, const struct OH_Huks_ParamSet *finishParamSet, struct OH_Huks_Blob *outData)
162 {
163 struct OH_Huks_Blob inData = {
164 g_inData.length(),
165 (uint8_t *)g_inData.c_str()
166 };
167
168 uint8_t handleU[sizeof(uint64_t)] = {0};
169 struct OH_Huks_Blob handle = { sizeof(uint64_t), handleU };
170 OH_Huks_Result ret = OH_Huks_InitSession(keyAlias, initParamSet, &handle, nullptr);
171 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "Init failed.";
172 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
173 return ret;
174 }
175
176 uint8_t outDataU[X25519_COMMON_SIZE] = {0};
177 struct OH_Huks_Blob outDataUpdate = { X25519_COMMON_SIZE, outDataU };
178 ret = OH_Huks_UpdateSession(&handle, initParamSet, publicKey, &outDataUpdate);
179 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "Update failed.";
180 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
181 return ret;
182 }
183
184 ret = OH_Huks_FinishSession(&handle, finishParamSet, &inData, outData);
185 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "Finish failed.";
186 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
187 return ret;
188 }
189 return ret;
190 }
191
HksX25519AgreeAbort(const struct OH_Huks_Blob * keyAlias,const struct OH_Huks_Blob * publicKey,const struct OH_Huks_ParamSet * initParamSet)192 OH_Huks_Result HksX25519AgreeAbort(const struct OH_Huks_Blob *keyAlias, const struct OH_Huks_Blob *publicKey,
193 const struct OH_Huks_ParamSet *initParamSet)
194 {
195 uint8_t handleU[sizeof(uint64_t)] = {0};
196 struct OH_Huks_Blob handle = { sizeof(uint64_t), handleU };
197 OH_Huks_Result ret = OH_Huks_InitSession(keyAlias, initParamSet, &handle, nullptr);
198 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "Init failed.";
199 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
200 return ret;
201 }
202
203 uint8_t outDataU[X25519_COMMON_SIZE] = {0};
204 struct OH_Huks_Blob outDataUpdate = { X25519_COMMON_SIZE, outDataU };
205 ret = OH_Huks_UpdateSession(&handle, initParamSet, publicKey, &outDataUpdate);
206 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "Update failed.";
207 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
208 return ret;
209 }
210
211 ret = OH_Huks_AbortSession(&handle, initParamSet);
212 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "Finish failed.";
213 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
214 return ret;
215 }
216 return ret;
217 }
218
HksX25519AgreeExport(const struct OH_Huks_Blob * keyAlias1,const struct OH_Huks_Blob * keyAlias2,struct OH_Huks_Blob * publicKey1,struct OH_Huks_Blob * publicKey2,const struct OH_Huks_ParamSet * genParamSet)219 OH_Huks_Result HksX25519AgreeExport(const struct OH_Huks_Blob *keyAlias1, const struct OH_Huks_Blob *keyAlias2,
220 struct OH_Huks_Blob *publicKey1, struct OH_Huks_Blob *publicKey2, const struct OH_Huks_ParamSet *genParamSet)
221 {
222 OH_Huks_Result ret = OH_Huks_ExportPublicKeyItem(keyAlias1, genParamSet, publicKey1);
223 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "ExportPublicKey01 failed.";
224 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
225 return ret;
226 }
227 ret = OH_Huks_ExportPublicKeyItem(keyAlias2, genParamSet, publicKey2);
228 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "ExportPublicKey02 failed.";
229 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
230 return ret;
231 }
232 return ret;
233 }
234
HksX25519AgreeFreeParamSet(struct OH_Huks_ParamSet * paramSet1,struct OH_Huks_ParamSet * paramSet2,struct OH_Huks_ParamSet * paramSet3)235 void HksX25519AgreeFreeParamSet(struct OH_Huks_ParamSet *paramSet1, struct OH_Huks_ParamSet *paramSet2,
236 struct OH_Huks_ParamSet *paramSet3)
237 {
238 OH_Huks_FreeParamSet(¶mSet1);
239 OH_Huks_FreeParamSet(¶mSet2);
240 OH_Huks_FreeParamSet(¶mSet3);
241 }
242
HksX25519AgreeFreeParamSet(struct OH_Huks_ParamSet * paramSet1,struct OH_Huks_ParamSet * paramSet2,struct OH_Huks_ParamSet * paramSet3,struct OH_Huks_ParamSet * paramSet4,struct OH_Huks_ParamSet * paramSet5)243 void HksX25519AgreeFreeParamSet(struct OH_Huks_ParamSet *paramSet1, struct OH_Huks_ParamSet *paramSet2,
244 struct OH_Huks_ParamSet *paramSet3, struct OH_Huks_ParamSet *paramSet4, struct OH_Huks_ParamSet *paramSet5)
245 {
246 OH_Huks_FreeParamSet(¶mSet1);
247 OH_Huks_FreeParamSet(¶mSet2);
248 OH_Huks_FreeParamSet(¶mSet3);
249 OH_Huks_FreeParamSet(¶mSet4);
250 OH_Huks_FreeParamSet(¶mSet5);
251 }
252
HksX25519AgreeFreeBlob(struct OH_Huks_Blob * blob1,struct OH_Huks_Blob * blob2)253 void HksX25519AgreeFreeBlob(struct OH_Huks_Blob *blob1, struct OH_Huks_Blob *blob2)
254 {
255 HksFree(blob1->data);
256 HksFree(blob2->data);
257 }
258
HksX25519AgreeFreeBlob(struct OH_Huks_Blob * blob1,struct OH_Huks_Blob * blob2,struct OH_Huks_Blob * blob3,struct OH_Huks_Blob * blob4)259 void HksX25519AgreeFreeBlob(struct OH_Huks_Blob *blob1, struct OH_Huks_Blob *blob2, struct OH_Huks_Blob *blob3, struct OH_Huks_Blob *blob4)
260 {
261 HksFree(blob1->data);
262 HksFree(blob2->data);
263 HksFree(blob3->data);
264 HksFree(blob4->data);
265 }
266
267 /**
268 * @tc.name: HuksAgreeX25519Test.Security_HUKS_NAPI_Agree_X25519_0100
269 * @tc.desc: alg-x25519, pur-AGREE
270 * @tc.type: FUNC
271 */
272 HWTEST_F(HuksAgreeX25519Test, Security_HUKS_NAPI_Agree_X25519_0100, TestSize.Level0)
273 {
274 struct OH_Huks_ParamSet *genParamSet = nullptr;
275 struct OH_Huks_ParamSet *initParamSet01 = nullptr;
276 struct OH_Huks_ParamSet *finishParamSet01 = nullptr;
277 struct OH_Huks_ParamSet *initParamSet02 = nullptr;
278 struct OH_Huks_ParamSet *finishParamSet02 = nullptr;
279 OH_Huks_Result ret = InitParamSet(&genParamSet, g_genParams001, sizeof(g_genParams001) / sizeof(OH_Huks_Param));
280 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "InitParamSet(gen) failed.";
281 ret = InitParamSet(&initParamSet01, g_agreeParams01Init001, sizeof(g_agreeParams01Init001) / sizeof(OH_Huks_Param));
282 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "InitParamSet(init & update)01 failed.";
283 ret = InitParamSet(&finishParamSet01, g_agreeParams01Finish001,
284 sizeof(g_agreeParams01Finish001) / sizeof(OH_Huks_Param));
285 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "InitParamSet(finish)01 failed.";
286 ret = InitParamSet(&initParamSet02, g_agreeParams02Init001, sizeof(g_agreeParams02Init001) / sizeof(OH_Huks_Param));
287 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "InitParamSet(init & update)02 failed.";
288 ret = InitParamSet(&finishParamSet02, g_agreeParams02Finish001,
289 sizeof(g_agreeParams02Finish001) / sizeof(OH_Huks_Param));
290 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "InitParamSet(finish)02 failed.";
291
292 ret = OH_Huks_GenerateKeyItem(&g_keyAlias01001, genParamSet, nullptr);
293 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "GenerateKey01 failed.";
294 ret = OH_Huks_GenerateKeyItem(&g_keyAlias02001, genParamSet, nullptr);
295 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "GenerateKey02 failed.";
296
297 struct OH_Huks_Blob publicKey01 = { .size = OH_HUKS_CURVE25519_KEY_SIZE_256, .data = nullptr };
298 struct OH_Huks_Blob publicKey02 = { .size = OH_HUKS_CURVE25519_KEY_SIZE_256, .data = nullptr };
299 EXPECT_EQ(MallocAndCheckBlobData(&publicKey01, publicKey01.size).errorCode, (int32_t)OH_HUKS_SUCCESS) << "Malloc publicKey01 failed.";
300 EXPECT_EQ(MallocAndCheckBlobData(&publicKey02, publicKey02.size).errorCode, (int32_t)OH_HUKS_SUCCESS) << "Malloc publicKey02 failed.";
301 ret = HksX25519AgreeExport(&g_keyAlias01001, &g_keyAlias02001, &publicKey01, &publicKey02, genParamSet);
302 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "ExportKey failed.";
303
304 struct OH_Huks_Blob outData01 = { .size = X25519_COMMON_SIZE, .data = nullptr };
305 struct OH_Huks_Blob outData02 = { .size = X25519_COMMON_SIZE, .data = nullptr };
306 EXPECT_EQ(MallocAndCheckBlobData(&outData01, outData01.size).errorCode, (int32_t)OH_HUKS_SUCCESS) << "Malloc outData01 failed.";
307 EXPECT_EQ(MallocAndCheckBlobData(&outData02, outData02.size).errorCode, (int32_t)OH_HUKS_SUCCESS) << "Malloc outData02 failed.";
308 ret = HksX25519AgreeFinish(&g_keyAlias01001, &publicKey02, initParamSet01, finishParamSet01, &outData01);
309 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "HksX25519AgreeFinish01 failed.";
310 ret = HksX25519AgreeFinish(&g_keyAlias02001, &publicKey01, initParamSet02, finishParamSet02, &outData02);
311 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "HksX25519AgreeFinish02 failed.";
312
313 OH_Huks_DeleteKeyItem(&g_keyAlias01001, genParamSet);
314 OH_Huks_DeleteKeyItem(&g_keyAlias02001, genParamSet);
315 OH_Huks_DeleteKeyItem(&g_keyAliasFinal1001, NULL);
316 OH_Huks_DeleteKeyItem(&g_keyAliasFinal2001, NULL);
317 HksX25519AgreeFreeParamSet(genParamSet, initParamSet01, finishParamSet01, initParamSet02, finishParamSet02);
318 HksX25519AgreeFreeBlob(&publicKey01, &publicKey02, &outData01, &outData02);
319 }
320 } // namespace Unittest::X25519Agree