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_signverify_sm2_test.h"
17
18 #include <gtest/gtest.h>
19
20 using namespace testing::ext;
21 namespace Unittest::Sm2SignVerify
22 {
23 class HuksSignVerifySM2Test : 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 HuksSignVerifySM2Test::SetUpTestCase(void) {}
36
TearDownTestCase(void)37 void HuksSignVerifySM2Test::TearDownTestCase(void) {}
38
SetUp()39 void HuksSignVerifySM2Test::SetUp() {}
40
TearDown()41 void HuksSignVerifySM2Test::TearDown() {}
42 const uint32_t SUCCESS_RETURN_INDEX = 0;
43
44 static const struct GenerateKeyCaseParam g_genParamsTest[] = {
45 {
46 0,
47 OH_HUKS_SUCCESS,
48 {{.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_SM2},
49 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = OH_HUKS_SM2_KEY_SIZE_256},
50 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_SIGN | OH_HUKS_KEY_PURPOSE_VERIFY},
51 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SM3},
52 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}},
53 },
54
55 {
56 1,
57 OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
58 {{.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_SM2},
59 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = OH_HUKS_AES_KEY_SIZE_512},
60 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_SIGN | OH_HUKS_KEY_PURPOSE_VERIFY},
61 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SM3},
62 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}},
63 },
64
65 {
66 2,
67 OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
68 {{.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_SM2},
69 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = OH_HUKS_SM2_KEY_SIZE_256},
70 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_SIGN | OH_HUKS_KEY_PURPOSE_VERIFY},
71 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SHA1},
72 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}},
73 },
74
75 {
76 3,
77 OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
78 {{.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_SM2},
79 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = OH_HUKS_SM2_KEY_SIZE_256},
80 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_ENCRYPT | OH_HUKS_KEY_PURPOSE_DECRYPT},
81 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SM3},
82 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}},
83 },
84 };
85 static const struct GenerateKeyCaseParam g_signParamsTest[] = {
86 {
87 0,
88 OH_HUKS_SUCCESS,
89 {{.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_SM2},
90 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = OH_HUKS_SM2_KEY_SIZE_256},
91 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_SIGN},
92 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SM3},
93 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}},
94 },
95
96 {
97 1,
98 OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
99 {{.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_SM2},
100 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = OH_HUKS_AES_KEY_SIZE_512},
101 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_SIGN},
102 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SM3},
103 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}},
104 },
105
106 {
107 2,
108 OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
109 {{.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_SM2},
110 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = OH_HUKS_SM2_KEY_SIZE_256},
111 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_SIGN},
112 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SHA1},
113 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}},
114 },
115
116 {
117 3,
118 OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
119 {{.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_SM2},
120 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = OH_HUKS_SM2_KEY_SIZE_256},
121 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_ENCRYPT},
122 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SM3},
123 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}},
124 },
125 };
126 static const struct GenerateKeyCaseParam g_verifyParamsTest[] = {
127 {
128 0,
129 OH_HUKS_SUCCESS,
130 {{.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_SM2},
131 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = OH_HUKS_SM2_KEY_SIZE_256},
132 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_VERIFY},
133 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SM3},
134 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}},
135 },
136
137 {
138 1,
139 OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
140 {{.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_SM2},
141 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = OH_HUKS_AES_KEY_SIZE_512},
142 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_VERIFY},
143 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SM3},
144 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}},
145 },
146
147 {
148 2,
149 OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
150 {{.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_SM2},
151 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = OH_HUKS_SM2_KEY_SIZE_256},
152 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_VERIFY},
153 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SHA1},
154 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}},
155 },
156
157 {
158 3,
159 OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT,
160 {{.tag = OH_HUKS_TAG_ALGORITHM, .uint32Param = OH_HUKS_ALG_SM2},
161 {.tag = OH_HUKS_TAG_KEY_SIZE, .uint32Param = OH_HUKS_SM2_KEY_SIZE_256},
162 {.tag = OH_HUKS_TAG_PURPOSE, .uint32Param = OH_HUKS_KEY_PURPOSE_DECRYPT},
163 {.tag = OH_HUKS_TAG_DIGEST, .uint32Param = OH_HUKS_DIGEST_SM3},
164 {.tag = OH_HUKS_TAG_AUTH_STORAGE_LEVEL, .uint32Param = OH_HUKS_AUTH_STORAGE_LEVEL_DE}},
165 },
166 };
167
HksTestSignVerify(const struct OH_Huks_Blob * keyAlias,const struct OH_Huks_ParamSet * paramSet,const struct OH_Huks_Blob * inData,struct OH_Huks_Blob * outData)168 static OH_Huks_Result HksTestSignVerify(const struct OH_Huks_Blob *keyAlias, const struct OH_Huks_ParamSet *paramSet,
169 const struct OH_Huks_Blob *inData, struct OH_Huks_Blob *outData)
170 {
171 uint8_t tmpHandle[sizeof(uint64_t)] = {0};
172 struct OH_Huks_Blob handle = {sizeof(uint64_t), tmpHandle};
173 OH_Huks_Result ret;
174
175 do {
176 ret = OH_Huks_InitSession(keyAlias, paramSet, &handle, nullptr);
177 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
178 break;
179 }
180
181 struct OH_Huks_Param *tmpParam = NULL;
182 ret = OH_Huks_GetParam(paramSet, OH_HUKS_TAG_PURPOSE, &tmpParam);
183 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
184 break;
185 }
186
187 ret = TestUpdateFinish(&handle, paramSet, tmpParam->uint32Param, inData, outData);
188 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
189 break;
190 }
191 ret.errorCode = (int32_t)OH_HUKS_SUCCESS;
192 } while (0);
193
194 (void)OH_Huks_AbortSession(&handle, paramSet);
195 return ret;
196 }
197
CreateImportKeyAlias(struct OH_Huks_Blob * importKeyAlias,const struct OH_Huks_Blob * keyAlias)198 static OH_Huks_Result CreateImportKeyAlias(struct OH_Huks_Blob *importKeyAlias, const struct OH_Huks_Blob *keyAlias)
199 {
200 OH_Huks_Result ret;
201 ret.errorCode = OH_HUKS_SUCCESS;
202 const char *tmp = "new";
203 importKeyAlias->size = keyAlias->size + strlen(tmp);
204 importKeyAlias->data = (uint8_t *)HksMalloc(importKeyAlias->size);
205 if (importKeyAlias->data == nullptr) {
206 ret.errorCode = OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT;
207 return ret;
208 }
209
210 if (memcpy_s(importKeyAlias->data, importKeyAlias->size, keyAlias->data, keyAlias->size) != EOK) {
211 HksFree(importKeyAlias->data);
212 ret.errorCode = OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT;
213 return ret;
214 }
215
216 if (memcpy_s(importKeyAlias->data + keyAlias->size, importKeyAlias->size - keyAlias->size, tmp, strlen(tmp)) !=
217 EOK) {
218 HksFree(importKeyAlias->data);
219 ret.errorCode = OH_HUKS_ERR_CODE_ILLEGAL_ARGUMENT;
220 return ret;
221 }
222 return ret;
223 }
224
FreeBuffAndDeleteKey(struct OH_Huks_ParamSet ** paramSet1,struct OH_Huks_ParamSet ** paramSet2,struct OH_Huks_ParamSet ** paramSet3,const struct OH_Huks_Blob * keyAlias1,const struct OH_Huks_Blob * keyAlias2)225 void static FreeBuffAndDeleteKey(struct OH_Huks_ParamSet **paramSet1, struct OH_Huks_ParamSet **paramSet2,
226 struct OH_Huks_ParamSet **paramSet3, const struct OH_Huks_Blob *keyAlias1,
227 const struct OH_Huks_Blob *keyAlias2)
228 {
229 (void)OH_Huks_DeleteKeyItem(keyAlias1, *paramSet1);
230 (void)OH_Huks_DeleteKeyItem(keyAlias2, *paramSet1);
231 OH_Huks_FreeParamSet(paramSet1);
232 OH_Huks_FreeParamSet(paramSet2);
233 OH_Huks_FreeParamSet(paramSet3);
234 }
235
HksSm2SignVerifyTestRun(const struct OH_Huks_Blob * keyAlias,const uint32_t genIndex,const uint32_t signIndex,const uint32_t verifyIndex,const bool isTestSignData)236 static OH_Huks_Result HksSm2SignVerifyTestRun(const struct OH_Huks_Blob *keyAlias, const uint32_t genIndex,
237 const uint32_t signIndex, const uint32_t verifyIndex,
238 const bool isTestSignData)
239 {
240 struct OH_Huks_ParamSet *genParamSet = nullptr;
241 struct OH_Huks_ParamSet *signParamSet = nullptr;
242 struct OH_Huks_ParamSet *verifyParamSet = nullptr;
243
244 struct OH_Huks_Blob inData = {g_inData.length(), (uint8_t *)g_inData.c_str()};
245 uint8_t outDataS[SM2_COMMON_SIZE] = {0};
246 struct OH_Huks_Blob outDataSign = {SM2_COMMON_SIZE, outDataS};
247
248 uint8_t pubKey[OH_HUKS_MAX_KEY_SIZE] = {0};
249 struct OH_Huks_Blob publicKey = {OH_HUKS_MAX_KEY_SIZE, pubKey};
250
251 struct OH_Huks_Blob importKeyAlias;
252 OH_Huks_Result ret = CreateImportKeyAlias(&importKeyAlias, keyAlias);
253 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "createImportKeyAlias failed.";
254
255 do {
256 /* 1. Generate Key */
257 ret = InitParamSet(&genParamSet, g_genParamsTest[genIndex].params,
258 sizeof(g_genParamsTest[genIndex].params) / sizeof(OH_Huks_Param));
259 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "InitGenParamSet failed.";
260 ret = OH_Huks_GenerateKeyItem(keyAlias, genParamSet, nullptr);
261 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
262 ret.errorCode =
263 ((ret.errorCode == g_genParamsTest[genIndex].result) ? (int32_t)OH_HUKS_SUCCESS : ret.errorCode);
264 break;
265 }
266
267 ret = OH_Huks_IsKeyItemExist(keyAlias, genParamSet);
268 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "isKeyExist failed.";
269
270 /* 2. Sign Three Stage */
271 ret = InitParamSet(&signParamSet, g_signParamsTest[signIndex].params,
272 sizeof(g_signParamsTest[signIndex].params) / sizeof(OH_Huks_Param));
273 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "InitSignParamSet failed.";
274 ret = HksTestSignVerify(keyAlias, signParamSet, &inData, &outDataSign);
275 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
276 ret.errorCode =
277 ((ret.errorCode == g_signParamsTest[signIndex].result) ? (int32_t)OH_HUKS_SUCCESS : ret.errorCode);
278 break;
279 }
280
281 /* 3. Export Public Key */
282 ret = OH_Huks_ExportPublicKeyItem(keyAlias, genParamSet, &publicKey);
283 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "ExportPublicKey failed.";
284
285 /* 4. Import Key */
286 ret = InitParamSet(&verifyParamSet, g_verifyParamsTest[verifyIndex].params,
287 sizeof(g_verifyParamsTest[verifyIndex].params) / sizeof(OH_Huks_Param));
288 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "InitVerifyParamSet failed.";
289 ret = OH_Huks_ImportKeyItem(&importKeyAlias, verifyParamSet, &publicKey);
290 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
291 ret.errorCode =
292 ((ret.errorCode == g_verifyParamsTest[verifyIndex].result) ? (int32_t)OH_HUKS_SUCCESS : ret.errorCode);
293 break;
294 }
295
296 /* 5. Verify Three Stage */
297 if (isTestSignData) {
298 (void)memset_s(outDataSign.data, outDataSign.size, 0, outDataSign.size);
299 }
300 ret = HksTestSignVerify(&importKeyAlias, verifyParamSet, &inData, &outDataSign);
301 if (ret.errorCode != (int32_t)OH_HUKS_SUCCESS) {
302 ret.errorCode =
303 ((ret.errorCode == g_verifyParamsTest[verifyIndex].result) ? (int32_t)OH_HUKS_SUCCESS : ret.errorCode);
304 }
305 } while (0);
306
307 FreeBuffAndDeleteKey(&genParamSet, &signParamSet, &verifyParamSet, keyAlias, &importKeyAlias);
308 HksFree(importKeyAlias.data);
309 return ret;
310 }
311
312 /**
313 * @tc.name: HuksSignVerifySM2Test.Security_HUKS_NAPI_SignVerify_SM2_0100
314 * @tc.desc: normal parameter test case : alg-SM2, pur-Sign/Verify, keySize-256 and dig-SM3.
315 * @tc.type: FUNC
316 */
317 HWTEST_F(HuksSignVerifySM2Test, Security_HUKS_NAPI_SignVerify_SM2_0100, TestSize.Level0)
318 {
319 const char *keyAliasString = "HksSM2SignVerifyKeyAliasTest001";
320 struct OH_Huks_Blob keyAlias = {strlen(keyAliasString), (uint8_t *)keyAliasString};
321 OH_Huks_Result ret =
322 HksSm2SignVerifyTestRun(&keyAlias, SUCCESS_RETURN_INDEX, SUCCESS_RETURN_INDEX, SUCCESS_RETURN_INDEX, false);
323 EXPECT_EQ(ret.errorCode, (int32_t)OH_HUKS_SUCCESS) << "sm2SignVerifyTest001 failed.";
324 }
325 } // namespace Unittest::Sm2SignVerify
326