1 /*
2  * Copyright (C) 2021-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 <chrono>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <sys/time.h>
20 
21 #include "hks_api.h"
22 #include "hks_log.h"
23 #include "hks_mem.h"
24 #include "hks_param.h"
25 
26 #define HKS_VERIFY_FINISH_ECC_224_COMMON \
27 { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT }, \
28 { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC }, \
29 { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 }, \
30 { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY }, \
31 { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE }, \
32 { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true }, \
33 { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
34 
35 using namespace testing::ext;
36 namespace {
37 namespace {
38 const char GENERATE_KEY[] = "This is for generate key";
39 const char IMPORT_KEY[] = "This is for import key";
40 const uint32_t TEST_FREQUENCY = 1000;
41 const uint32_t MAX_SDK_VERSION_SIZE = 64;
42 const uint32_t IV_SIZE = 16;
43 const uint32_t COMPLEMENT_LEN = 16;
44 const uint32_t KEY_PARAMSET_SIZE = 1024;
45 const uint32_t MESSAGE_SIZE = 64;
46 const uint32_t TEST_KEY_SIZE = 512;
47 const uint32_t DERIVED_KEY_SIZE = 64;
48 
49 static const struct HksParam PARAMS_FOR_ENCRYPT[] = {
50     { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
51     { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
52     { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
53     { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
54     { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
55     { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
56     { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
57     { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
58     { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
59 };
60 
61 static const struct HksParam PARAMS_FOR_DECRYPT[] = {
62     { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
63     { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
64     { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
65     { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
66     { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
67     { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
68     { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
69     { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
70     { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
71 };
72 }  // namespace
73 class PressureTest : public testing::Test {
74 public:
75     int32_t LocalHksGenerate(const uint32_t keyLen, const struct HksBlob *authId, const struct HksParamSet *paramSetIn,
76         struct HksBlob *priKey, struct HksBlob *pubKey) const;
77 };
78 
LocalHksGenerate(const uint32_t keyLen,const struct HksBlob * authId,const struct HksParamSet * paramSetIn,struct HksBlob * priKey,struct HksBlob * pubKey) const79 int32_t PressureTest::LocalHksGenerate(const uint32_t keyLen, const struct HksBlob *authId,
80     const struct HksParamSet *paramSetIn, struct HksBlob *priKey, struct HksBlob *pubKey) const
81 {
82     struct HksParamSet *paramOutSet = nullptr;
83     HksInitParamSet(&paramOutSet);
84     struct HksParam localKey = {
85         .tag = HKS_TAG_SYMMETRIC_KEY_DATA,
86         .blob = { .size = keyLen, .data = (uint8_t *)HksMalloc(keyLen) }
87     };
88     if (localKey.blob.data == nullptr) {
89         HksFreeParamSet(&paramOutSet);
90         return HKS_FAILURE;
91     }
92     HksAddParams(paramOutSet, &localKey, 1);
93     HksBuildParamSet(&paramOutSet);
94 
95     if (HksGenerateKey(authId, paramSetIn, paramOutSet) != HKS_SUCCESS) {
96         HKS_FREE(localKey.blob.data);
97         HksFreeParamSet(&paramOutSet);
98         return HKS_SUCCESS;
99     }
100 
101     HksParam *priParam = nullptr;
102     HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA, &priParam);
103     priKey->size = priParam->blob.size;
104     (void)memcpy_s(priKey->data, priParam->blob.size, priParam->blob.data, priParam->blob.size);
105 
106     HksParam *pubParam = nullptr;
107     HksGetParam(paramOutSet, HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA, &pubParam);
108     pubKey->size = pubParam->blob.size;
109     (void)memcpy_s(pubKey->data, pubParam->blob.size, pubParam->blob.data, pubParam->blob.size);
110 
111     HKS_FREE(localKey.blob.data);
112     HksFreeParamSet(&paramOutSet);
113     return HKS_SUCCESS;
114 }
115 
116 /**
117  * @tc.number    : PressureTest.PressureTest00100
118  * @tc.name      : PressureTest00100
119  * @tc.desc      : HksGetSdkVersion
120  */
121 HWTEST_F(PressureTest, PressureTest00100, TestSize.Level1)
122 {
123     double programTimes = 0;
124 
125     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
126         struct HksBlob sdkVersion = { .size = MAX_SDK_VERSION_SIZE,
127             .data = (uint8_t *)HksMalloc(MAX_SDK_VERSION_SIZE) };
128         ASSERT_NE(sdkVersion.data, nullptr);
129         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
130         int32_t ret = HksGetSdkVersion(&sdkVersion);
131         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
132         EXPECT_EQ(ret, HKS_SUCCESS);
133         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
134         HKS_FREE(sdkVersion.data);
135     }
136     HKS_LOG_I("HksGetSdkVersion Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
137 }
138 
139 /**
140  * @tc.number    : PressureTest.PressureTest00200
141  * @tc.name      : PressureTest00200
142  * @tc.desc      : HksInitialize
143  */
144 HWTEST_F(PressureTest, PressureTest00200, TestSize.Level1)
145 {
146     double programTimes = 0;
147 
148     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
149         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
150         int32_t ret = HksInitialize();
151         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
152         EXPECT_EQ(ret, HKS_SUCCESS);
153         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
154     }
155     HKS_LOG_I("HksInitialize Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
156 }
157 
158 /**
159  * @tc.number    : PressureTest.PressureTest00300
160  * @tc.name      : PressureTest00300
161  * @tc.desc      : HksRefreshKeyInfo
162  */
163 HWTEST_F(PressureTest, PressureTest00300, TestSize.Level1)
164 {
165     double programTimes = 0;
166 
167     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
168         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
169         int32_t ret = HksRefreshKeyInfo();
170         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
171         EXPECT_EQ(ret, HKS_SUCCESS);
172         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
173     }
174     HKS_LOG_I("HksRefreshKeyInfo Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
175 }
176 
177 /**
178  * @tc.number    : PressureTest.PressureTest00400
179  * @tc.name      : PressureTest00400
180  * @tc.desc      : HksGenerateKey
181  */
182 HWTEST_F(PressureTest, PressureTest00400, TestSize.Level1)
183 {
184     double programTimes = 0;
185     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
186 
187     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
188         struct HksParamSet *paramInSet = nullptr;
189         HksInitParamSet(&paramInSet);
190 
191         struct HksParam tmpParams[] = {
192             HKS_VERIFY_FINISH_ECC_224_COMMON
193         };
194 
195         HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
196         HksBuildParamSet(&paramInSet);
197 
198         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
199         int32_t ret = HksGenerateKey(&authId, paramInSet, NULL);
200         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
201         EXPECT_EQ(ret, HKS_SUCCESS);
202         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
203 
204         HksDeleteKey(&authId, paramInSet);
205         HksFreeParamSet(&paramInSet);
206     }
207     HKS_LOG_I("HksGenerateKey Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
208 }
209 
210 /**
211  * @tc.number    : PressureTest.PressureTest00500
212  * @tc.name      : PressureTest00500
213  * @tc.desc      : HksImportKey
214  */
215 HWTEST_F(PressureTest, PressureTest00500, TestSize.Level1)
216 {
217     double programTimes = 0;
218     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
219 
220     struct HksParamSet *paramInSet = nullptr;
221     HksInitParamSet(&paramInSet);
222 
223     struct HksParam tmpParams[] = {
224         HKS_VERIFY_FINISH_ECC_224_COMMON
225     };
226 
227     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
228     HksBuildParamSet(&paramInSet);
229 
230     HksGenerateKey(&authId, paramInSet, NULL);
231 
232     struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
233     ASSERT_NE(pubKey.data, nullptr);
234     HksExportPublicKey(&authId, paramInSet, &pubKey);
235 
236     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
237         struct HksBlob importId = { strlen(IMPORT_KEY), (uint8_t *)IMPORT_KEY };
238         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
239         int32_t ret = HksImportKey(&importId, paramInSet, &pubKey);
240         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
241         EXPECT_EQ(ret, HKS_SUCCESS);
242         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
243         HksDeleteKey(&importId, paramInSet);
244     }
245     HksDeleteKey(&authId, paramInSet);
246     HKS_FREE(pubKey.data);
247     HksFreeParamSet(&paramInSet);
248     HKS_LOG_I("HksImportKey Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
249 }
250 
251 /**
252  * @tc.number    : PressureTest.PressureTest00600
253  * @tc.name      : PressureTest00600
254  * @tc.desc      : HksExportPublicKey
255  */
256 HWTEST_F(PressureTest, PressureTest00600, TestSize.Level1)
257 {
258     double programTimes = 0;
259     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
260 
261     struct HksParamSet *paramInSet = nullptr;
262     HksInitParamSet(&paramInSet);
263 
264     struct HksParam tmpParams[] = {
265         HKS_VERIFY_FINISH_ECC_224_COMMON
266     };
267 
268     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
269     HksBuildParamSet(&paramInSet);
270 
271     HksGenerateKey(&authId, paramInSet, NULL);
272 
273     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
274         struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
275         ASSERT_NE(pubKey.data, nullptr);
276         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
277         int32_t ret = HksExportPublicKey(&authId, paramInSet, &pubKey);
278         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
279         EXPECT_EQ(ret, HKS_SUCCESS);
280         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
281 
282         HKS_FREE(pubKey.data);
283     }
284     HksDeleteKey(&authId, paramInSet);
285     HksFreeParamSet(&paramInSet);
286     HKS_LOG_I("HksExportPublicKey Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
287 }
288 
289 /**
290  * @tc.number    : PressureTest.PressureTest00700
291  * @tc.name      : PressureTest00700
292  * @tc.desc      : HksDeleteKey
293  */
294 HWTEST_F(PressureTest, PressureTest00700, TestSize.Level1)
295 {
296     double programTimes = 0;
297 
298     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
299         struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
300 
301         struct HksParamSet *paramInSet = nullptr;
302         HksInitParamSet(&paramInSet);
303 
304         struct HksParam tmpParams[] = {
305             HKS_VERIFY_FINISH_ECC_224_COMMON
306         };
307 
308         HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
309         HksBuildParamSet(&paramInSet);
310 
311         HksGenerateKey(&authId, paramInSet, NULL);
312         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
313         int32_t ret = HksDeleteKey(&authId, paramInSet);
314         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
315         EXPECT_EQ(ret, HKS_SUCCESS);
316         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
317 
318         HksFreeParamSet(&paramInSet);
319     }
320     HKS_LOG_I("HksDeleteKey Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
321 }
322 
323 /**
324  * @tc.number    : PressureTest.PressureTest00800
325  * @tc.name      : PressureTest00800
326  * @tc.desc      : HksGetKeyParamSet
327  */
328 HWTEST_F(PressureTest, PressureTest00800, TestSize.Level1)
329 {
330     double programTimes = 0;
331     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
332 
333     struct HksParamSet *paramInSet = nullptr;
334     HksInitParamSet(&paramInSet);
335 
336     struct HksParam tmpParams[] = {
337         HKS_VERIFY_FINISH_ECC_224_COMMON
338     };
339 
340     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
341     HksBuildParamSet(&paramInSet);
342 
343     HksGenerateKey(&authId, paramInSet, NULL);
344 
345     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
346         struct HksParamSet *paramOutSet = nullptr;
347         HksInitParamSet(&paramOutSet);
348         struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA,
349             .blob = { .size = KEY_PARAMSET_SIZE, .data = (uint8_t *)HksMalloc(KEY_PARAMSET_SIZE) } };
350         ASSERT_NE(localKey.blob.data, nullptr);
351         HksAddParams(paramOutSet, &localKey, 1);
352 
353         HksBuildParamSet(&paramOutSet);
354         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
355         int32_t ret = HksGetKeyParamSet(&authId, paramInSet, paramOutSet);
356         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
357         EXPECT_EQ(ret, HKS_SUCCESS);
358         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
359 
360         HKS_FREE(localKey.blob.data);
361         HksFreeParamSet(&paramOutSet);
362     }
363     HksDeleteKey(&authId, paramInSet);
364     HksFreeParamSet(&paramInSet);
365     HKS_LOG_I("HksGetKeyParamSet Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
366 }
367 
368 /**
369  * @tc.number    : PressureTest.PressureTest00900
370  * @tc.name      : PressureTest00900
371  * @tc.desc      : HksKeyExist
372  */
373 HWTEST_F(PressureTest, PressureTest00900, TestSize.Level1)
374 {
375     double programTimes = 0;
376     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
377 
378     struct HksParamSet *paramInSet = nullptr;
379     HksInitParamSet(&paramInSet);
380 
381     struct HksParam tmpParams[] = {
382         HKS_VERIFY_FINISH_ECC_224_COMMON
383     };
384 
385     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
386     HksBuildParamSet(&paramInSet);
387 
388     HksGenerateKey(&authId, paramInSet, NULL);
389 
390     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
391         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
392         int32_t ret = HksKeyExist(&authId, paramInSet);
393         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
394         EXPECT_EQ(ret, HKS_SUCCESS);
395         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
396     }
397     HksDeleteKey(&authId, paramInSet);
398     HksFreeParamSet(&paramInSet);
399     HKS_LOG_I("HksKeyExist Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
400 }
401 
402 /**
403  * @tc.number    : PressureTest.PressureTest01000
404  * @tc.name      : PressureTest01000
405  * @tc.desc      : HksGenerateRandom
406  */
407 HWTEST_F(PressureTest, PressureTest01000, TestSize.Level1)
408 {
409     double programTimes = 0;
410 
411     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
412         struct HksParamSet *paramInSet = nullptr;
413         HksInitParamSet(&paramInSet);
414         struct HksBlob authId = { .size = TEST_KEY_SIZE, .data = (uint8_t *)HksMalloc(TEST_KEY_SIZE) };
415         ASSERT_NE(authId.data, nullptr);
416 
417         struct HksParam tmpParams[] = {
418             { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
419             { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
420             { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
421             { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
422         };
423 
424         HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
425         HksBuildParamSet(&paramInSet);
426 
427         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
428         int32_t ret = HksGenerateRandom(paramInSet, &authId);
429         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
430         EXPECT_EQ(ret, HKS_SUCCESS);
431         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
432 
433         HKS_FREE(authId.data);
434         HksFreeParamSet(&paramInSet);
435     }
436     HKS_LOG_I("HksGenerateRandom Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
437 }
438 
439 /**
440  * @tc.number    : PressureTest.PressureTest01100
441  * @tc.name      : PressureTest01100
442  * @tc.desc      : HksSign
443  */
444 HWTEST_F(PressureTest, PressureTest01100, TestSize.Level1)
445 {
446     double programTimes = 0;
447     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
448 
449     struct HksParamSet *paramInSet = nullptr;
450     HksInitParamSet(&paramInSet);
451 
452     struct HksParam tmpParams[] = {
453         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
454         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
455         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
456         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
457         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
458         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
459         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
460     };
461 
462     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
463     HksBuildParamSet(&paramInSet);
464 
465     HksGenerateKey(&authId, paramInSet, NULL);
466 
467     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
468         const char *hexData = "0123456789abcdef";
469         uint32_t dataLen = strlen(hexData);
470         HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData };
471         HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
472         ASSERT_NE(signature.data, nullptr);
473 
474         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
475         int32_t ret = HksSign(&authId, paramInSet, &message, &signature);
476         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
477         EXPECT_EQ(ret, HKS_SUCCESS);
478         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
479 
480         HKS_FREE(signature.data);
481     }
482     HksDeleteKey(&authId, paramInSet);
483     HksFreeParamSet(&paramInSet);
484     HKS_LOG_I("HksSign Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
485 }
486 
487 /**
488  * @tc.number    : PressureTest.PressureTest01200
489  * @tc.name      : PressureTest01200
490  * @tc.desc      : HksVerify
491  */
492 HWTEST_F(PressureTest, PressureTest01200, TestSize.Level1)
493 {
494     double programTimes = 0;
495     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
496 
497     struct HksParamSet *paramInSet = nullptr;
498     HksInitParamSet(&paramInSet);
499 
500     struct HksParam tmpParams[] = {
501         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
502         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
503         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
504         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
505         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
506         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
507         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
508     };
509 
510     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
511     HksBuildParamSet(&paramInSet);
512 
513     HksGenerateKey(&authId, paramInSet, NULL);
514     const char *hexData = "0123456789abcdef";
515     uint32_t dataLen = strlen(hexData);
516     HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData };
517     HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
518     ASSERT_NE(signature.data, nullptr);
519 
520     HksSign(&authId, paramInSet, &message, &signature);
521 
522     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
523 
524         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
525         int32_t ret = HksVerify(&authId, paramInSet, &message, &signature);
526         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
527         EXPECT_EQ(ret, HKS_SUCCESS);
528         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
529     }
530     HksDeleteKey(&authId, paramInSet);
531     HKS_FREE(signature.data);
532     HksFreeParamSet(&paramInSet);
533     HKS_LOG_I("HksVerify Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
534 }
535 
536 /**
537  * @tc.number    : PressureTest.PressureTest01300
538  * @tc.name      : PressureTest01300
539  * @tc.desc      : HksEncrypt
540  */
541 HWTEST_F(PressureTest, PressureTest01300, TestSize.Level1)
542 {
543     double programTimes = 0;
544     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
545 
546     struct HksParamSet *paramInSet = nullptr;
547     HksInitParamSet(&paramInSet);
548 
549     struct HksParam tmpParams[] = {
550         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
551         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
552         { .tag = HKS_TAG_KEY_SIZE,
553         .uint32Param = HKS_AES_KEY_SIZE_128 },
554         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
555         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
556         { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
557         { .tag = HKS_TAG_IS_KEY_ALIAS,
558         .boolParam = true },
559         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
560         { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
561     };
562 
563     uint8_t iv[IV_SIZE] = {0};
564     struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } };
565     HksAddParams(paramInSet, &tagIv, 1);
566 
567     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
568     HksBuildParamSet(&paramInSet);
569 
570     HksGenerateKey(&authId, paramInSet, NULL);
571 
572     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
573         const char *hexData = "0123456789abcdef";
574         uint32_t dataLen = strlen(hexData);
575         HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData };
576 
577         uint32_t inLen = dataLen + COMPLEMENT_LEN;
578         HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
579         ASSERT_NE(cipherText.data, nullptr);
580 
581         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
582         int32_t ret = HksEncrypt(&authId, paramInSet, &plainText, &cipherText);
583         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
584         EXPECT_EQ(ret, HKS_SUCCESS);
585         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
586 
587         HKS_FREE(cipherText.data);
588     }
589     HksDeleteKey(&authId, paramInSet);
590     HksFreeParamSet(&paramInSet);
591     HKS_LOG_I("HksEncrypt Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
592 }
593 
594 /**
595  * @tc.number    : PressureTest.PressureTest01400
596  * @tc.name      : PressureTest01400
597  * @tc.desc      : HksDecrypt
598  */
599 HWTEST_F(PressureTest, PressureTest01400, TestSize.Level1)
600 {
601     double programTimes = 0;
602     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
603     uint8_t iv[IV_SIZE] = {0};
604     struct HksParamSet *paramInSet = nullptr;
605     HksInitParamSet(&paramInSet);
606 
607     struct HksParam tmpParams[] = {
608         { .tag = HKS_TAG_KEY_STORAGE_FLAG,
609         .uint32Param = HKS_STORAGE_PERSISTENT },
610         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
611         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
612         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
613         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
614         { .tag = HKS_TAG_PADDING,
615         .uint32Param = HKS_PADDING_PKCS7 },
616         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
617         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
618         { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
619     };
620 
621     struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } };
622     HksAddParams(paramInSet, &tagIv, 1);
623 
624     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
625     HksBuildParamSet(&paramInSet);
626 
627     HksGenerateKey(&authId, paramInSet, NULL);
628 
629     const char *hexData = "0123456789abcdef";
630     uint32_t dataLen = strlen(hexData);
631     HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData };
632 
633     uint32_t inLen = dataLen + COMPLEMENT_LEN;
634     HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
635     ASSERT_NE(cipherText.data, nullptr);
636 
637     HksEncrypt(&authId, paramInSet, &plainText, &cipherText);
638 
639     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
640         HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
641         ASSERT_NE(plainTextDecrypt.data, nullptr);
642         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
643         int32_t ret = HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt);
644         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
645         EXPECT_EQ(ret, HKS_SUCCESS);
646         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
647 
648         HKS_FREE(plainTextDecrypt.data);
649     }
650     HksDeleteKey(&authId, paramInSet);
651     HKS_FREE(cipherText.data);
652     HksFreeParamSet(&paramInSet);
653     HKS_LOG_I("HksDecrypt Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
654 }
655 
656 /**
657  * @tc.number    : PressureTest.PressureTest01500
658  * @tc.name      : PressureTest01500
659  * @tc.desc      : HksAgreeKey
660  */
661 HWTEST_F(PressureTest, PressureTest01500, TestSize.Level1)
662 {
663     double programTimes = 0;
664     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
665 
666     struct HksParamSet *paramInSetForKey = nullptr;
667     HksInitParamSet(&paramInSetForKey);
668     struct HksParamSet *paramInSet = nullptr;
669     HksInitParamSet(&paramInSet);
670 
671     struct HksParam tmpParams[] = {
672         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
673         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
674         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
675         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
676         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
677     };
678 
679     HksAddParams(paramInSetForKey, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
680     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
681 
682     HksParam algForKey = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC };
683     HksParam alg = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH };
684 
685     HksAddParams(paramInSetForKey, &algForKey, 1);
686     HksAddParams(paramInSet, &alg, 1);
687     HksParam degistForKey = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE };
688     HksAddParams(paramInSetForKey, &degistForKey, 1);
689     HksBuildParamSet(&paramInSetForKey);
690     HksBuildParamSet(&paramInSet);
691 
692     HksGenerateKey(&authId, paramInSetForKey, NULL);
693 
694     struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
695     ASSERT_NE(pubKey.data, nullptr);
696     HksExportPublicKey(&authId, paramInSetForKey, &pubKey);
697 
698     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
699         HksBlob agreeKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
700         ASSERT_NE(agreeKey.data, nullptr);
701         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
702         int32_t ret = HksAgreeKey(paramInSet, &authId, &pubKey, &agreeKey);
703         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
704         EXPECT_EQ(ret, HKS_SUCCESS);
705         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
706 
707         HKS_FREE(agreeKey.data);
708     }
709     HksDeleteKey(&authId, paramInSet);
710     HKS_FREE(pubKey.data);
711     HksFreeParamSet(&paramInSetForKey);
712     HksFreeParamSet(&paramInSet);
713     HKS_LOG_I("HksAgreeKey Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
714 }
715 
716 /**
717  * @tc.number    : PressureTest.PressureTest01600
718  * @tc.name      : PressureTest01600
719  * @tc.desc      : HksDeriveKey
720  */
721 HWTEST_F(PressureTest, PressureTest01600, TestSize.Level1)
722 {
723     double programTimes = 0;
724 
725     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
726 
727     struct HksParamSet *paramInSet = nullptr;
728     HksInitParamSet(&paramInSet);
729 
730     struct HksParam tmpParams[] = {
731         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
732         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
733         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
734         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE },
735         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
736         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
737         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
738     };
739 
740     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
741     HksBuildParamSet(&paramInSet);
742 
743     HksGenerateKey(&authId, paramInSet, NULL);
744 
745     struct HksParamSet *paramInSetHkdf = nullptr;
746     HksInitParamSet(&paramInSetHkdf);
747     struct HksParam tmpParamsHkdf[] = {
748         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
749         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HKDF },
750         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = DERIVED_KEY_SIZE },
751         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE },
752         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
753         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
754         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
755     };
756 
757     HksAddParams(paramInSetHkdf, tmpParamsHkdf, sizeof(tmpParamsHkdf) / sizeof(tmpParamsHkdf[0]));
758     HksBuildParamSet(&paramInSetHkdf);
759 
760     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
761         HksBlob derivedKey = { .size = DERIVED_KEY_SIZE, .data = (uint8_t *)HksMalloc(DERIVED_KEY_SIZE) };
762         ASSERT_NE(derivedKey.data, nullptr);
763         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
764         int32_t ret = HksDeriveKey(paramInSetHkdf, &authId, &derivedKey);
765         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
766         EXPECT_EQ(ret, HKS_SUCCESS);
767         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
768 
769         HKS_FREE(derivedKey.data);
770     }
771     HksDeleteKey(&authId, paramInSet);
772     HksFreeParamSet(&paramInSet);
773     HksFreeParamSet(&paramInSetHkdf);
774     HKS_LOG_I("HksDeriveKey Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
775 }
776 
777 /**
778  * @tc.number    : PressureTest.PressureTest01700
779  * @tc.name      : PressureTest01700
780  * @tc.desc      : HksMac
781  */
782 HWTEST_F(PressureTest, PressureTest01700, TestSize.Level1)
783 {
784     double programTimes = 0;
785     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
786 
787     struct HksParamSet *paramInSet = nullptr;
788     HksInitParamSet(&paramInSet);
789 
790     struct HksParam tmpParams[] = {
791         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
792         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
793         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = TEST_KEY_SIZE },
794         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
795         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 },
796         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
797         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
798     };
799 
800     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
801     HksBuildParamSet(&paramInSet);
802 
803     HksGenerateKey(&authId, paramInSet, NULL);
804 
805     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
806         const char *hexData = "0123456789abcdef";
807         uint32_t dataLen = strlen(hexData);
808         HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData };
809         HksBlob macMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) };
810         ASSERT_NE(macMessage.data, nullptr);
811         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
812         int32_t ret = HksMac(&authId, paramInSet, &message, &macMessage);
813         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
814         EXPECT_EQ(ret, HKS_SUCCESS);
815         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
816 
817         HKS_FREE(macMessage.data);
818     }
819     HksDeleteKey(&authId, paramInSet);
820     HksFreeParamSet(&paramInSet);
821     HKS_LOG_I("HksMac Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
822 }
823 
824 /**
825  * @tc.number    : PressureTest.PressureTest01800
826  * @tc.name      : PressureTest01800
827  * @tc.desc      : HksHash
828  */
829 HWTEST_F(PressureTest, PressureTest01800, TestSize.Level1)
830 {
831     double programTimes = 0;
832 
833     struct HksParamSet *paramInSet = nullptr;
834     HksInitParamSet(&paramInSet);
835 
836     struct HksParam digest = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 };
837     HksAddParams(paramInSet, &digest, 1);
838     HksBuildParamSet(&paramInSet);
839 
840     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
841         const char *hexData = "0123456789abcdef";
842         uint32_t dataLen = strlen(hexData);
843         HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData };
844         HksBlob shaMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) };
845         ASSERT_NE(shaMessage.data, nullptr);
846         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
847         int32_t ret = HksHash(paramInSet, &message, &shaMessage);
848         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
849         EXPECT_EQ(ret, HKS_SUCCESS);
850         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
851 
852         HKS_FREE(shaMessage.data);
853     }
854     HksFreeParamSet(&paramInSet);
855     HKS_LOG_I("HksHash Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
856 }
857 
858 /**
859  * @tc.number    : PressureTest.PressureTest01900
860  * @tc.name      : PressureTest01900
861  * @tc.desc      : HksGenerateKey
862  */
863 HWTEST_F(PressureTest, PressureTest01900, TestSize.Level1)
864 {
865     double programTimes = 0;
866     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
867 
868     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
869         struct HksParamSet *paramInSet = nullptr;
870         HksInitParamSet(&paramInSet);
871 
872         struct HksParam tmpParams[] = {
873             { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
874             { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
875             { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
876             { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY },
877             { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
878             { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
879             { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
880         };
881 
882         HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
883         HksBuildParamSet(&paramInSet);
884 
885         struct HksParamSet *paramOutSet = nullptr;
886         HksInitParamSet(&paramOutSet);
887         struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA,
888             .blob = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) } };
889         ASSERT_NE(localKey.blob.data, nullptr);
890         HksAddParams(paramOutSet, &localKey, 1);
891 
892         HksBuildParamSet(&paramOutSet);
893         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
894         int32_t ret = HksGenerateKey(&authId, paramInSet, paramOutSet);
895         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
896         EXPECT_EQ(ret, HKS_SUCCESS);
897         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
898 
899         HKS_FREE(localKey.blob.data);
900         HksFreeParamSet(&paramInSet);
901         HksFreeParamSet(&paramOutSet);
902     }
903     HKS_LOG_I("Local HksGenerateKey Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
904 }
905 
906 /**
907  * @tc.number    : PressureTest.PressureTest02000
908  * @tc.name      : PressureTest02000
909  * @tc.desc      : HksSign
910  */
911 HWTEST_F(PressureTest, PressureTest02000, TestSize.Level1)
912 {
913     double programTimes = 0;
914     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
915 
916     struct HksParamSet *paramInSet = nullptr;
917     HksInitParamSet(&paramInSet);
918 
919     struct HksParam tmpParams[] = {
920         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
921         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
922         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
923         { .tag = HKS_TAG_PURPOSE,
924         .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
925         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
926         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
927         { .tag = HKS_TAG_KEY_GENERATE_TYPE,
928         .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
929     };
930 
931     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
932     HksBuildParamSet(&paramInSet);
933 
934     HksBlob priKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
935     ASSERT_NE(priKey.data, nullptr);
936     HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
937     ASSERT_NE(pubKey.data, nullptr);
938 
939     PressureTest::LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &authId, paramInSet, &priKey, &pubKey);
940 
941     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
942         const char *hexData = "0123456789abcdef";
943         uint32_t dataLen = strlen(hexData);
944         HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData };
945         HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
946         ASSERT_NE(signature.data, nullptr);
947 
948         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
949         int32_t ret = HksSign(&priKey, paramInSet, &message, &signature);
950         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
951         EXPECT_EQ(ret, HKS_SUCCESS);
952         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
953 
954         HKS_FREE(signature.data);
955     }
956     HKS_FREE(priKey.data);
957     HKS_FREE(pubKey.data);
958     HksFreeParamSet(&paramInSet);
959     HKS_LOG_I("Local HksSign Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
960 }
961 
962 /**
963  * @tc.number    : PressureTest.PressureTest02100
964  * @tc.name      : PressureTest02100
965  * @tc.desc      : HksVerify
966  */
967 HWTEST_F(PressureTest, PressureTest02100, TestSize.Level1)
968 {
969     double programTimes = 0;
970     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
971 
972     struct HksParamSet *paramInSet = nullptr;
973     HksInitParamSet(&paramInSet);
974 
975     struct HksParam tmpParams[] = {
976         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
977         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
978         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
979         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
980         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
981         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
982         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
983     };
984 
985     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
986     HksBuildParamSet(&paramInSet);
987 
988     HksBlob priKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
989     ASSERT_NE(priKey.data, nullptr);
990     HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
991     ASSERT_NE(pubKey.data, nullptr);
992 
993     PressureTest::LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &authId, paramInSet, &priKey, &pubKey);
994 
995     const char *hexData = "0123456789abcdef";
996     uint32_t dataLen = strlen(hexData);
997     HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData };
998     HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
999     ASSERT_NE(signature.data, nullptr);
1000 
1001     HksSign(&priKey, paramInSet, &message, &signature);
1002 
1003     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
1004 
1005         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
1006         int32_t ret = HksVerify(&pubKey, paramInSet, &message, &signature);
1007         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
1008         EXPECT_EQ(ret, HKS_SUCCESS);
1009         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
1010     }
1011     HKS_FREE(priKey.data);
1012     HKS_FREE(pubKey.data);
1013     HKS_FREE(signature.data);
1014     HksFreeParamSet(&paramInSet);
1015     HKS_LOG_I("Local HksVerify Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
1016 }
1017 
1018 /**
1019  * @tc.number    : PressureTest.PressureTest02200
1020  * @tc.name      : PressureTest02200
1021  * @tc.desc      : HksEncrypt
1022  */
1023 HWTEST_F(PressureTest, PressureTest02200, TestSize.Level1)
1024 {
1025     double programTimes = 0;
1026     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1027 
1028     struct HksParamSet *paramInSet = nullptr;
1029     HksInitParamSet(&paramInSet);
1030 
1031     uint8_t iv[IV_SIZE] = {0};
1032     struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } };
1033     HksAddParams(paramInSet, &tagIv, 1);
1034 
1035     HksAddParams(paramInSet, PARAMS_FOR_ENCRYPT, sizeof(PARAMS_FOR_ENCRYPT) / sizeof(PARAMS_FOR_ENCRYPT[0]));
1036     HksBuildParamSet(&paramInSet);
1037 
1038     struct HksParamSet *paramOutSet = nullptr;
1039     HksInitParamSet(&paramOutSet);
1040     struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA,
1041         .blob = { .size = HKS_AES_KEY_SIZE_128, .data = (uint8_t *)HksMalloc(HKS_AES_KEY_SIZE_128) } };
1042     ASSERT_NE(localKey.blob.data, nullptr);
1043     HksAddParams(paramOutSet, &localKey, 1);
1044     HksBuildParamSet(&paramOutSet);
1045 
1046     HksGenerateKey(&authId, paramInSet, paramOutSet);
1047 
1048     HksParam *paramOut = nullptr;
1049     HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &paramOut);
1050     HksBlob authKey = { .size = paramOut->blob.size, .data = (uint8_t *)HksMalloc(paramOut->blob.size) };
1051     ASSERT_NE(authKey.data, nullptr);
1052     (void)memcpy_s(authKey.data, paramOut->blob.size, paramOut->blob.data, paramOut->blob.size);
1053 
1054     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
1055         const char *hexData = "0123456789abcdef";
1056         uint32_t dataLen = strlen(hexData);
1057         HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData };
1058 
1059         uint32_t inLen = dataLen + COMPLEMENT_LEN;
1060         HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
1061         ASSERT_NE(cipherText.data, nullptr);
1062 
1063         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
1064         int32_t ret = HksEncrypt(&authKey, paramInSet, &plainText, &cipherText);
1065         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
1066         EXPECT_EQ(ret, HKS_SUCCESS);
1067         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
1068 
1069         HKS_FREE(cipherText.data);
1070     }
1071     HKS_FREE(localKey.blob.data);
1072     HKS_FREE(authKey.data);
1073     HksFreeParamSet(&paramInSet);
1074     HksFreeParamSet(&paramOutSet);
1075     HKS_LOG_I("Local HksEncrypt Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
1076 }
1077 
1078 /**
1079  * @tc.number    : PressureTest.PressureTest02300
1080  * @tc.name      : PressureTest02300
1081  * @tc.desc      : HksDecrypt
1082  */
1083 HWTEST_F(PressureTest, PressureTest02300, TestSize.Level1)
1084 {
1085     double programTimes = 0;
1086     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1087 
1088     struct HksParamSet *paramInSet = nullptr;
1089     HksInitParamSet(&paramInSet);
1090 
1091     uint8_t iv[IV_SIZE] = {0};
1092     struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } };
1093     HksAddParams(paramInSet, &tagIv, 1);
1094 
1095     HksAddParams(paramInSet, PARAMS_FOR_DECRYPT, sizeof(PARAMS_FOR_DECRYPT) / sizeof(PARAMS_FOR_DECRYPT[0]));
1096     HksBuildParamSet(&paramInSet);
1097 
1098     struct HksParamSet *paramOutSet = nullptr;
1099     HksInitParamSet(&paramOutSet);
1100     struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA,
1101         .blob = { .size = HKS_AES_KEY_SIZE_128, .data = (uint8_t *)HksMalloc(HKS_AES_KEY_SIZE_128) } };
1102     ASSERT_NE(localKey.blob.data, nullptr);
1103     HksAddParams(paramOutSet, &localKey, 1);
1104     HksBuildParamSet(&paramOutSet);
1105 
1106     HksGenerateKey(&authId, paramInSet, paramOutSet);
1107 
1108     HksParam *paramOut = nullptr;
1109     HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &paramOut);
1110     HksBlob authKey = { .size = paramOut->blob.size, .data = (uint8_t *)HksMalloc(paramOut->blob.size) };
1111     ASSERT_NE(authKey.data, nullptr);
1112     (void)memcpy_s(authKey.data, paramOut->blob.size, paramOut->blob.data, paramOut->blob.size);
1113 
1114     const char *hexData = "0123456789abcdef";
1115     uint32_t dataLen = strlen(hexData);
1116     HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData };
1117 
1118     uint32_t inLen = dataLen + COMPLEMENT_LEN;
1119     HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
1120     ASSERT_NE(cipherText.data, nullptr);
1121 
1122     HksEncrypt(&authKey, paramInSet, &plainText, &cipherText);
1123 
1124     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
1125         HksBlob plainTextDecrypt = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
1126         ASSERT_NE(plainTextDecrypt.data, nullptr);
1127         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
1128         int32_t ret = HksDecrypt(&authKey, paramInSet, &cipherText, &plainTextDecrypt);
1129         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
1130         EXPECT_EQ(ret, HKS_SUCCESS);
1131         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
1132 
1133         HKS_FREE(plainTextDecrypt.data);
1134     }
1135     HKS_FREE(localKey.blob.data);
1136     HKS_FREE(authKey.data);
1137     HKS_FREE(cipherText.data);
1138     HksFreeParamSet(&paramInSet);
1139     HksFreeParamSet(&paramOutSet);
1140     HKS_LOG_I("Local HksDecrypt Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
1141 }
1142 
1143 /**
1144  * @tc.number    : PressureTest.PressureTest02400
1145  * @tc.name      : PressureTest02400
1146  * @tc.desc      : HksAgreeKey
1147  */
1148 HWTEST_F(PressureTest, PressureTest02400, TestSize.Level1)
1149 {
1150     double programTimes = 0;
1151     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1152 
1153     struct HksParamSet *paramInSetForKey = nullptr;
1154     HksInitParamSet(&paramInSetForKey);
1155     struct HksParamSet *paramInSet = nullptr;
1156     HksInitParamSet(&paramInSet);
1157 
1158     struct HksParam tmpParams[] = {
1159         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
1160         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
1161         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
1162         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
1163         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1164     };
1165 
1166     HksAddParams(paramInSetForKey, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1167     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1168 
1169     HksParam algForKey = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC };
1170     HksParam alg = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH };
1171 
1172     HksAddParams(paramInSetForKey, &algForKey, 1);
1173     HksAddParams(paramInSet, &alg, 1);
1174     HksParam degistForKey = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE };
1175     HksAddParams(paramInSetForKey, &degistForKey, 1);
1176     HksBuildParamSet(&paramInSetForKey);
1177     HksBuildParamSet(&paramInSet);
1178 
1179     HksBlob priKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
1180     ASSERT_NE(priKey.data, nullptr);
1181     HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
1182     ASSERT_NE(pubKey.data, nullptr);
1183 
1184     PressureTest::LocalHksGenerate(HKS_ECC_KEY_SIZE_224, &authId, paramInSetForKey, &priKey, &pubKey);
1185 
1186     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
1187         HksBlob agreeKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
1188         ASSERT_NE(agreeKey.data, nullptr);
1189         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
1190         int32_t ret = HksAgreeKey(paramInSet, &priKey, &pubKey, &agreeKey);
1191         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
1192         EXPECT_EQ(ret, HKS_SUCCESS);
1193         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
1194 
1195         HKS_FREE(agreeKey.data);
1196     }
1197     HKS_FREE(priKey.data);
1198     HKS_FREE(pubKey.data);
1199     HksFreeParamSet(&paramInSetForKey);
1200     HksFreeParamSet(&paramInSet);
1201     HKS_LOG_I("Local HksAgreeKey Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
1202 }
1203 
1204 /**
1205  * @tc.number    : PressureTest.PressureTest02500
1206  * @tc.name      : PressureTest02500
1207  * @tc.desc      : HksDeriveKey
1208  */
1209 HWTEST_F(PressureTest, PressureTest02500, TestSize.Level1)
1210 {
1211     double programTimes = 0;
1212     struct HksBlob authId = { .size = TEST_KEY_SIZE, .data = (uint8_t *)HksMalloc(TEST_KEY_SIZE) };
1213     ASSERT_NE(authId.data, nullptr);
1214 
1215     struct HksParamSet *paramInSet = nullptr;
1216     HksInitParamSet(&paramInSet);
1217 
1218     struct HksParam tmpParams[] = {
1219         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
1220         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HKDF },
1221         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = DERIVED_KEY_SIZE },
1222         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE },
1223         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
1224         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
1225         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1226     };
1227 
1228     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1229     HksBuildParamSet(&paramInSet);
1230 
1231     HksGenerateRandom(paramInSet, &authId);
1232     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
1233         HksBlob derivedKey = { .size = DERIVED_KEY_SIZE, .data = (uint8_t *)HksMalloc(DERIVED_KEY_SIZE) };
1234         ASSERT_NE(derivedKey.data, nullptr);
1235         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
1236         int32_t ret = HksDeriveKey(paramInSet, &authId, &derivedKey);
1237         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
1238         EXPECT_EQ(ret, HKS_SUCCESS);
1239         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
1240 
1241         HKS_FREE(derivedKey.data);
1242     }
1243     HKS_FREE(authId.data);
1244     HksFreeParamSet(&paramInSet);
1245     HKS_LOG_I("Local HksDeriveKey Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
1246 }
1247 
1248 /**
1249  * @tc.number    : PressureTest.PressureTest02600
1250  * @tc.name      : PressureTest02600
1251  * @tc.desc      : HksMac
1252  */
1253 HWTEST_F(PressureTest, PressureTest02600, TestSize.Level1)
1254 {
1255     double programTimes = 0;
1256     struct HksBlob authId = { strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1257 
1258     struct HksParamSet *paramInSet = nullptr;
1259     HksInitParamSet(&paramInSet);
1260 
1261     struct HksParam tmpParams[] = {
1262         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_TEMP },
1263         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
1264         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = TEST_KEY_SIZE },
1265         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
1266         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 },
1267         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = false },
1268         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1269     };
1270 
1271     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1272     HksBuildParamSet(&paramInSet);
1273 
1274     struct HksParamSet *paramOutSet = nullptr;
1275     HksInitParamSet(&paramOutSet);
1276     struct HksParam localKey = { .tag = HKS_TAG_SYMMETRIC_KEY_DATA,
1277         .blob = { .size = HKS_AES_KEY_SIZE_128, .data = (uint8_t *)HksMalloc(HKS_AES_KEY_SIZE_128) } };
1278     ASSERT_NE(localKey.blob.data, nullptr);
1279     HksAddParams(paramOutSet, &localKey, 1);
1280     HksBuildParamSet(&paramOutSet);
1281 
1282     HksGenerateKey(&authId, paramInSet, paramOutSet);
1283 
1284     HksParam *paramOut = nullptr;
1285     HksGetParam(paramOutSet, HKS_TAG_SYMMETRIC_KEY_DATA, &paramOut);
1286     HksBlob authKey = { .size = paramOut->blob.size, .data = (uint8_t *)HksMalloc(paramOut->blob.size) };
1287     ASSERT_NE(authKey.data, nullptr);
1288     (void)memcpy_s(authKey.data, paramOut->blob.size, paramOut->blob.data, paramOut->blob.size);
1289 
1290     for (uint32_t ii = 0; ii < TEST_FREQUENCY; ii++) {
1291         const char *hexData = "0123456789abcdef";
1292         uint32_t dataLen = strlen(hexData);
1293         HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData };
1294         HksBlob macMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) };
1295         ASSERT_NE(macMessage.data, nullptr);
1296         auto start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
1297         int32_t ret = HksMac(&authKey, paramInSet, &message, &macMessage);
1298         auto end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now());
1299         EXPECT_EQ(ret, HKS_SUCCESS);
1300         programTimes += (end.time_since_epoch().count() - start.time_since_epoch().count());
1301 
1302         HKS_FREE(macMessage.data);
1303     }
1304     HKS_FREE(localKey.blob.data);
1305     HKS_FREE(authKey.data);
1306     HksFreeParamSet(&paramInSet);
1307     HksFreeParamSet(&paramOutSet);
1308     HKS_LOG_I("Local HksMac Interface Call Duration: %" LOG_PUBLIC "f", (programTimes / TEST_FREQUENCY));
1309 }
1310 }  // namespace