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