• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <mutex>
17 #include <random>
18 #include <string>
19 #include <thread>
20 #include "securec.h"
21 
22 #include <gtest/gtest.h>
23 
24 #include "hks_api.h"
25 #include "hks_config.h"
26 #include "hks_mem.h"
27 #include "hks_param.h"
28 
29 using namespace testing::ext;
30 namespace {
31 namespace {
32 const char GENERATE_KEY[] = "This is for generate key";
33 const char IMPORT_KEY[] = "This is for import key";
34 const uint32_t TEST_HOURS = 6;
35 const uint32_t DSA_KEY_SIZE = 1024;
36 const uint32_t THREADS_NUM = 15;
37 const uint32_t RANDOM_KEY_SIZE = 512;
38 const uint32_t MAX_SDK_VERSION_SIZE = 64;
39 const uint32_t DERIVE_KEY_SIZE = 64;
40 const uint32_t IV_SIZE = 16;
41 const uint32_t AAD_SIZE = 16;
42 const uint32_t RSA_MESSAGE_SIZE = 6;
43 const uint32_t AES_MESSAGE_SIZE = 16;
44 const uint32_t COMPLEMENT_LEN = 16;
45 const uint32_t KEY_PARAMSET_SIZE = 1024;
46 const uint32_t MESSAGE_SIZE = 64;
47 const uint32_t TEST_KEY_SIZE = 4096;
48 const uint32_t CIPHER_SIZE = 4096;
49 const uint32_t MAX_STRING_LENTH = 513;
50 
51 static const struct HksParam CIPHER_PARAMS[] = {
52     { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
53     { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
54     { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
55     { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
56 };
57 
58 const struct HksParam g_PARAM_ALGORITHM_AES = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES };
59 const struct HksParam g_PARAM_ALGORITHM_RSA = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_RSA };
60 const struct HksParam g_PARAM_ALGORITHM_ECC = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC };
61 #ifndef _USE_MBEDTLS_
62 const struct HksParam g_PARAM_ALGORITHM_DSA = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DSA };
63 #endif
64 #ifdef HKS_SUPPORT_DH_C
65 const struct HksParam g_PARAM_ALGORITHM_DH = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_DH };
66 #endif
67 const struct HksParam g_PARAM_ALGORITHM_ECDH = { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH };
68 
69 const struct HksParam g_PARAM_KEYSIZE_AES_128 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 };
70 const struct HksParam g_PARAM_KEYSIZE_AES_192 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_192 };
71 const struct HksParam g_PARAM_KEYSIZE_AES_256 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_256 };
72 const struct HksParam g_PARAM_KEYSIZE_RSA_512 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_512 };
73 const struct HksParam g_PARAM_KEYSIZE_RSA_768 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_768 };
74 const struct HksParam g_PARAM_KEYSIZE_RSA_1024 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_1024 };
75 const struct HksParam g_PARAM_KEYSIZE_RSA_2048 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_2048 };
76 const struct HksParam g_PARAM_KEYSIZE_RSA_3072 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_3072 };
77 const struct HksParam g_PARAM_KEYSIZE_RSA_4096 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_RSA_KEY_SIZE_4096 };
78 const struct HksParam g_PARAM_KEYSIZE_ECC_224 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 };
79 const struct HksParam g_PARAM_KEYSIZE_ECC_256 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_256 };
80 const struct HksParam g_PARAM_KEYSIZE_ECC_384 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_384 };
81 const struct HksParam g_PARAM_KEYSIZE_ECC_521 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_521 };
82 #ifdef HKS_SUPPORT_DH_C
83 const struct HksParam g_PARAM_KEYSIZE_DH_2048 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_2048 };
84 const struct HksParam g_PARAM_KEYSIZE_DH_3072 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_3072 };
85 const struct HksParam g_PARAM_KEYSIZE_DH_4096 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_DH_KEY_SIZE_4096 };
86 #endif
87 const struct HksParam g_PARAM_KEYSIZE_DSA_1024 = { .tag = HKS_TAG_KEY_SIZE, .uint32Param = DSA_KEY_SIZE };
88 
89 const struct HksParam g_PARAM_PADDING_NONE = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_NONE };
90 const struct HksParam g_PARAM_PADDING_OAEP = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_OAEP };
91 const struct HksParam g_PARAM_PADDING_PKCS1_V1_5 = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS1_V1_5 };
92 const struct HksParam g_PARAM_PADDING_PKCS7 = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 };
93 const struct HksParam g_PARAM_PADDING_PSS = { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PSS };
94 
95 const struct HksParam g_PARAM_MODE_CBC = { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC };
96 const struct HksParam g_PARAM_MODE_CTR = { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CTR };
97 const struct HksParam g_PARAM_MODE_ECB = { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_ECB };
98 const struct HksParam g_PARAM_MODE_GCM = { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_GCM };
99 
100 const struct HksParam g_PARAM_DIGEST_NONE = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE };
101 const struct HksParam g_PARAM_DIGEST_MD5 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_MD5 };
102 const struct HksParam g_PARAM_DIGEST_SHA1 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 };
103 const struct HksParam g_PARAM_DIGEST_SHA224 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA224 };
104 const struct HksParam g_PARAM_DIGEST_SHA256 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 };
105 const struct HksParam g_PARAM_DIGEST_SHA384 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA384 };
106 const struct HksParam g_PARAM_DIGEST_SHA512 = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA512 };
107 
GetRandom()108 inline uint32_t GetRandom()
109 {
110     std::random_device rd;
111     return rd();
112 }
113 
AESModeRandForCiper(struct HksParamSet * paramInSet)114 void AESModeRandForCiper(struct HksParamSet *paramInSet)
115 {
116     struct HksParam tagIv;
117     uint8_t iv[IV_SIZE] = {0};
118     const struct HksParam *paramMode[] = {
119         &g_PARAM_MODE_CBC,
120         &g_PARAM_MODE_CTR,
121         &g_PARAM_MODE_ECB,
122         &g_PARAM_MODE_GCM,
123     };
124     const struct HksParam *paramPadding[] = {
125         &g_PARAM_PADDING_NONE,
126         &g_PARAM_PADDING_PKCS7,
127     };
128     const uint32_t countOfMode = sizeof(paramMode) / sizeof(struct HksParam *);
129     const uint32_t countOfPadding = sizeof(paramPadding) / sizeof(struct HksParam *);
130     const uint32_t indexOfMode = GetRandom() % countOfMode;
131     HksAddParams(paramInSet, paramMode[indexOfMode], 1);
132     if (paramMode[indexOfMode]->uint32Param == HKS_MODE_CBC) {
133         tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } };
134         HksAddParams(paramInSet, &tagIv, 1);
135         HksAddParams(paramInSet, paramPadding[GetRandom() % countOfPadding], 1);
136     } else if (paramMode[indexOfMode]->uint32Param == HKS_MODE_CTR) {
137         HksAddParams(paramInSet, &g_PARAM_PADDING_NONE, 1);
138         tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } };
139         HksAddParams(paramInSet, &tagIv, 1);
140     } else if (paramMode[indexOfMode]->uint32Param == HKS_MODE_ECB) {
141         tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } };
142         HksAddParams(paramInSet, &tagIv, 1);
143 #ifndef _USE_MBEDTLS_
144         HksAddParams(paramInSet, paramPadding[GetRandom() % countOfPadding], 1);
145 #else
146         HksAddParams(paramInSet, &g_PARAM_PADDING_NONE, 1);
147 #endif
148     } else if (paramMode[indexOfMode]->uint32Param == HKS_MODE_GCM) {
149         HksAddParams(paramInSet, &g_PARAM_PADDING_NONE, 1);
150         uint8_t aadData[AAD_SIZE] = { 'a', 'a', 'd' };
151         struct HksParam aad = { .tag = HKS_TAG_ASSOCIATED_DATA, .blob = { .size = sizeof(aadData), .data = aadData } };
152         HksAddParams(paramInSet, &aad, 1);
153         tagIv = { .tag = HKS_TAG_NONCE, .blob = { .size = IV_SIZE, .data = iv } };
154         HksAddParams(paramInSet, &tagIv, 1);
155     }
156 }
157 
ParamForAESCipher(struct HksParamSet * paramInSet)158 void ParamForAESCipher(struct HksParamSet *paramInSet)
159 {
160     const struct HksParam *paramKeySize[] = {
161         &g_PARAM_KEYSIZE_AES_128,
162         &g_PARAM_KEYSIZE_AES_192,
163         &g_PARAM_KEYSIZE_AES_256,
164     };
165     const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *);
166     HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1);
167     AESModeRandForCiper(paramInSet);
168 }
169 
RSAKeySizeRand(struct HksParamSet * paramInSet)170 void RSAKeySizeRand(struct HksParamSet *paramInSet)
171 {
172     const struct HksParam *paramKeySize[] = {
173         &g_PARAM_KEYSIZE_RSA_512,
174         &g_PARAM_KEYSIZE_RSA_768,
175         &g_PARAM_KEYSIZE_RSA_1024,
176         &g_PARAM_KEYSIZE_RSA_2048,
177         &g_PARAM_KEYSIZE_RSA_3072,
178         &g_PARAM_KEYSIZE_RSA_4096,
179     };
180     const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *);
181     HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1);
182 }
183 
RSAKeySizeWithout512(struct HksParamSet * paramInSet)184 void RSAKeySizeWithout512(struct HksParamSet *paramInSet)
185 {
186     const struct HksParam *paramKeySize[] = {
187         &g_PARAM_KEYSIZE_RSA_768,
188         &g_PARAM_KEYSIZE_RSA_1024,
189         &g_PARAM_KEYSIZE_RSA_2048,
190         &g_PARAM_KEYSIZE_RSA_3072,
191         &g_PARAM_KEYSIZE_RSA_4096,
192     };
193     const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *);
194     HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1);
195 }
196 
RSAKeySizeWithout768(struct HksParamSet * paramInSet)197 void RSAKeySizeWithout768(struct HksParamSet *paramInSet)
198 {
199     const struct HksParam *paramKeySize[] = {
200         &g_PARAM_KEYSIZE_RSA_1024,
201         &g_PARAM_KEYSIZE_RSA_2048,
202         &g_PARAM_KEYSIZE_RSA_3072,
203         &g_PARAM_KEYSIZE_RSA_4096,
204     };
205     const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *);
206     HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1);
207 }
208 
OaepSha512KeySize(struct HksParamSet * paramInSet)209 void OaepSha512KeySize(struct HksParamSet *paramInSet)
210 {
211     const struct HksParam *paramKeySize[] = {
212         &g_PARAM_KEYSIZE_RSA_2048,
213         &g_PARAM_KEYSIZE_RSA_3072,
214         &g_PARAM_KEYSIZE_RSA_4096,
215     };
216     const uint32_t count = sizeof(paramKeySize) / sizeof(struct HksParam *);
217     HksAddParams(paramInSet, paramKeySize[GetRandom() % count], 1);
218 }
219 
ParamForRSACipher(struct HksParamSet * paramInSet)220 void ParamForRSACipher(struct HksParamSet *paramInSet)
221 {
222     const struct HksParam *paramPadding[] = {
223 #ifndef _USE_MBEDTLS_
224         &g_PARAM_PADDING_NONE,
225 #endif
226         &g_PARAM_PADDING_PKCS1_V1_5,
227         &g_PARAM_PADDING_OAEP,
228     };
229     const struct HksParam *paramDigest[] = {
230         &g_PARAM_DIGEST_NONE,
231         &g_PARAM_DIGEST_SHA1,
232         &g_PARAM_DIGEST_SHA224,
233         &g_PARAM_DIGEST_SHA256,
234         &g_PARAM_DIGEST_SHA384,
235         &g_PARAM_DIGEST_SHA512,
236     };
237     const uint32_t countOfPadding = sizeof(paramPadding) / sizeof(struct HksParam *);
238     const uint32_t countOfDigest = sizeof(paramDigest) / sizeof(struct HksParam *);
239     const uint32_t indexOfPadding = GetRandom() % countOfPadding;
240     HksAddParams(paramInSet, paramPadding[indexOfPadding], 1);
241     if ((paramPadding[indexOfPadding]->uint32Param == HKS_PADDING_NONE) ||
242         (paramPadding[indexOfPadding]->uint32Param == HKS_PADDING_PKCS1_V1_5)) {
243         RSAKeySizeRand(paramInSet);
244         HksAddParams(paramInSet, &g_PARAM_DIGEST_NONE, 1);
245     } else if (paramPadding[indexOfPadding]->uint32Param == HKS_PADDING_OAEP) {
246         const uint32_t indexOfDigest = GetRandom() % countOfDigest;
247         HksAddParams(paramInSet, paramDigest[indexOfDigest], 1);
248         if (paramDigest[indexOfDigest]->uint32Param == HKS_DIGEST_SHA256) {
249             RSAKeySizeWithout512(paramInSet);
250         } else if (paramDigest[indexOfDigest]->uint32Param == HKS_DIGEST_SHA384) {
251             RSAKeySizeWithout768(paramInSet);
252         } else if (paramDigest[indexOfDigest]->uint32Param == HKS_DIGEST_SHA512) {
253             OaepSha512KeySize(paramInSet);
254         } else {
255             RSAKeySizeRand(paramInSet);
256         }
257     }
258 }
259 
ParamForCipher(struct HksParamSet * paramInSet)260 void ParamForCipher(struct HksParamSet *paramInSet)
261 {
262     const struct HksParam *paramAlgorithm[] = {
263         &g_PARAM_ALGORITHM_AES,
264         &g_PARAM_ALGORITHM_RSA,
265     };
266     const uint32_t count = sizeof(paramAlgorithm) / sizeof(struct HksParam *);
267     const uint32_t index = GetRandom() % count;
268     HksAddParams(paramInSet, paramAlgorithm[index], 1);
269     if (paramAlgorithm[index]->uint32Param == HKS_ALG_AES) {
270         ParamForAESCipher(paramInSet);
271     } else if (paramAlgorithm[index]->uint32Param == HKS_ALG_RSA) {
272         HksAddParams(paramInSet, &g_PARAM_MODE_ECB, 1);
273         ParamForRSACipher(paramInSet);
274     }
275 }
276 
ShaForPkcs1(struct HksParamSet * paramInSet)277 void ShaForPkcs1(struct HksParamSet *paramInSet)
278 {
279     const struct HksParam *paramDigest[] = {
280         &g_PARAM_DIGEST_NONE,
281         &g_PARAM_DIGEST_MD5,
282         &g_PARAM_DIGEST_SHA1,
283         &g_PARAM_DIGEST_SHA224,
284         &g_PARAM_DIGEST_SHA256,
285         &g_PARAM_DIGEST_SHA384,
286         &g_PARAM_DIGEST_SHA512,
287     };
288     const uint32_t count = sizeof(paramDigest) / sizeof(struct HksParam *);
289     const uint32_t index = GetRandom() % count;
290     HksAddParams(paramInSet, paramDigest[index], 1);
291     if ((paramDigest[index]->uint32Param == HKS_DIGEST_SHA384) ||
292         (paramDigest[index]->uint32Param == HKS_DIGEST_SHA512)) {
293         RSAKeySizeWithout512(paramInSet);
294     } else {
295         RSAKeySizeRand(paramInSet);
296     }
297 }
298 
ShaForPss(struct HksParamSet * paramInSet)299 void ShaForPss(struct HksParamSet *paramInSet)
300 {
301     const struct HksParam *paramDigest[] = {
302         &g_PARAM_DIGEST_NONE,
303         &g_PARAM_DIGEST_MD5,
304         &g_PARAM_DIGEST_SHA1,
305         &g_PARAM_DIGEST_SHA224,
306         &g_PARAM_DIGEST_SHA256,
307         &g_PARAM_DIGEST_SHA384,
308         &g_PARAM_DIGEST_SHA512,
309     };
310     const uint32_t count = sizeof(paramDigest) / sizeof(struct HksParam *);
311     const uint32_t index = GetRandom() % count;
312     HksAddParams(paramInSet, paramDigest[index], 1);
313     if (paramDigest[index]->uint32Param == HKS_DIGEST_SHA384) {
314 #ifndef _USE_MBEDTLS_
315         RSAKeySizeRand(paramInSet);
316 #else
317         RSAKeySizeWithout512(paramInSet);
318 #endif
319     } else if (paramDigest[index]->uint32Param == HKS_DIGEST_SHA512) {
320 #ifndef _USE_MBEDTLS_
321         RSAKeySizeWithout512(paramInSet);
322 #else
323         RSAKeySizeWithout768(paramInSet);
324 #endif
325     } else {
326         RSAKeySizeRand(paramInSet);
327     }
328 }
329 
ParamForRSASign(struct HksParamSet * paramInSet)330 void ParamForRSASign(struct HksParamSet *paramInSet)
331 {
332     const struct HksParam *paramPadding[] = {
333         &g_PARAM_PADDING_PKCS1_V1_5,
334         &g_PARAM_PADDING_PSS,
335     };
336     const uint32_t count = sizeof(paramPadding) / sizeof(struct HksParam *);
337     const uint32_t index = GetRandom() % count;
338     HksAddParams(paramInSet, paramPadding[index], 1);
339     if (paramPadding[index]->uint32Param == HKS_PADDING_PKCS1_V1_5) {
340         ShaForPkcs1(paramInSet);
341     } else if (paramPadding[index]->uint32Param == HKS_PADDING_PSS) {
342         ShaForPss(paramInSet);
343     }
344 }
345 
ParamForECCSign(struct HksParamSet * paramInSet)346 void ParamForECCSign(struct HksParamSet *paramInSet)
347 {
348     const struct HksParam *paramKeySize[] = {
349         &g_PARAM_KEYSIZE_ECC_224,
350         &g_PARAM_KEYSIZE_ECC_256,
351         &g_PARAM_KEYSIZE_ECC_384,
352         &g_PARAM_KEYSIZE_ECC_521,
353     };
354     const uint32_t countOfKeySize = sizeof(paramKeySize) / sizeof(struct HksParam *);
355     HksAddParams(paramInSet, paramKeySize[GetRandom() % countOfKeySize], 1);
356 
357     const struct HksParam *paramDigest[] = {
358         &g_PARAM_DIGEST_NONE,
359         &g_PARAM_DIGEST_SHA1,
360         &g_PARAM_DIGEST_SHA224,
361         &g_PARAM_DIGEST_SHA256,
362         &g_PARAM_DIGEST_SHA384,
363         &g_PARAM_DIGEST_SHA512,
364     };
365     const uint32_t countOfDigest = sizeof(paramDigest) / sizeof(struct HksParam *);
366     HksAddParams(paramInSet, paramDigest[GetRandom() % countOfDigest], 1);
367 }
368 
ParamForDSASign(struct HksParamSet * paramInSet)369 void ParamForDSASign(struct HksParamSet *paramInSet)
370 {
371     HksAddParams(paramInSet, &g_PARAM_PADDING_PKCS1_V1_5, 1);
372     HksAddParams(paramInSet, &g_PARAM_KEYSIZE_DSA_1024, 1);
373     const struct HksParam *paramDigest[] = {
374         &g_PARAM_DIGEST_SHA1,
375         &g_PARAM_DIGEST_SHA224,
376         &g_PARAM_DIGEST_SHA256,
377         &g_PARAM_DIGEST_SHA384,
378         &g_PARAM_DIGEST_SHA512,
379     };
380     const uint32_t countOfDigest = sizeof(paramDigest) / sizeof(struct HksParam *);
381     HksAddParams(paramInSet, paramDigest[GetRandom() % countOfDigest], 1);
382 }
383 
ParamForSign(struct HksParamSet * paramInSet)384 void ParamForSign(struct HksParamSet *paramInSet)
385 {
386     const struct HksParam *paramAlgorithm[] = {
387         &g_PARAM_ALGORITHM_RSA,
388         &g_PARAM_ALGORITHM_ECC,
389 #ifndef _USE_MBEDTLS_
390         &g_PARAM_ALGORITHM_DSA,
391 #endif
392     };
393     const uint32_t count = sizeof(paramAlgorithm) / sizeof(struct HksParam *);
394     const uint32_t index = GetRandom() % count;
395     HksAddParams(paramInSet, paramAlgorithm[index], 1);
396     if (paramAlgorithm[index]->uint32Param == HKS_ALG_RSA) {
397         ParamForRSASign(paramInSet);
398     } else if (paramAlgorithm[index]->uint32Param == HKS_ALG_ECC) {
399         ParamForECCSign(paramInSet);
400     } else if (paramAlgorithm[index]->uint32Param == HKS_ALG_DSA) {
401         ParamForDSASign(paramInSet);
402     }
403 }
404 
ParamForAgree(struct HksParamSet * generateKeyParam,struct HksParamSet * agreeKeyParam)405 void ParamForAgree(struct HksParamSet *generateKeyParam, struct HksParamSet *agreeKeyParam)
406 {
407     const struct HksParam *paramAlg[] = {
408         &g_PARAM_ALGORITHM_ECDH,
409 #ifdef HKS_SUPPORT_DH_C
410         &g_PARAM_ALGORITHM_DH,
411 #endif
412     };
413     const uint32_t countOfAlg = sizeof(paramAlg) / sizeof(struct HksParam *);
414     const uint32_t indexOfAlg = GetRandom() % countOfAlg;
415 
416     HksAddParams(agreeKeyParam, paramAlg[indexOfAlg], 1);
417     if (paramAlg[indexOfAlg]->uint32Param == HKS_ALG_ECDH) {
418         HksAddParams(generateKeyParam, &g_PARAM_ALGORITHM_ECC, 1);
419         const struct HksParam *paramKeySize[] = {
420             &g_PARAM_KEYSIZE_ECC_224,
421             &g_PARAM_KEYSIZE_ECC_256,
422             &g_PARAM_KEYSIZE_ECC_384,
423             &g_PARAM_KEYSIZE_ECC_521,
424         };
425         const uint32_t countOfKeySize = sizeof(paramKeySize) / sizeof(struct HksParam *);
426         const uint32_t indexOfKeySize = GetRandom() % countOfKeySize;
427         HksAddParams(generateKeyParam, paramKeySize[indexOfKeySize], 1);
428         HksAddParams(agreeKeyParam, paramKeySize[indexOfKeySize], 1);
429         HksAddParams(generateKeyParam, &g_PARAM_DIGEST_NONE, 1);
430     }
431 #ifdef HKS_SUPPORT_DH_C
432     if (paramAlg[indexOfAlg]->uint32Param == HKS_ALG_DH) {
433         HksAddParams(generateKeyParam, &g_PARAM_ALGORITHM_DH, 1);
434         const struct HksParam *paramKeySize[] = {
435             &g_PARAM_KEYSIZE_DH_2048,
436             &g_PARAM_KEYSIZE_DH_3072,
437             &g_PARAM_KEYSIZE_DH_4096,
438         };
439         const uint32_t countOfKeySize = sizeof(paramKeySize) / sizeof(struct HksParam *);
440         const uint32_t indexOfKeySize = GetRandom() % countOfKeySize;
441         HksAddParams(generateKeyParam, paramKeySize[indexOfKeySize], 1);
442         HksAddParams(agreeKeyParam, paramKeySize[indexOfKeySize], 1);
443     }
444 #endif
445 }
446 }  // namespace
447 
448 class ApiPressureTest : public testing::Test {
449 public:
SetThreadState(bool threadState)450     void SetThreadState(bool threadState)
451     {
452         std::lock_guard<std::mutex> lock(mutex_);
453 
454         threadState_ = threadState;
455     }
GetThreadState()456     bool GetThreadState()
457     {
458         std::lock_guard<std::mutex> lock(mutex_);
459 
460         return threadState_;
461     }
462     void GetSdkVersionTest();
463     void InitializeTest();
464     void RefreshKeyInfoTest();
465     void GenerateKeyTest();
466     void ImportKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet);
467     void ExportPublicKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet);
468     void DeleteKeyTest(uint32_t ii);
469     void GetKeyParamSetTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet);
470     void KeyExistTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet);
471     void GenerateRandomTest();
472     void SignTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet, const struct HksBlob *message);
473     void VerifyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet, const struct HksBlob *message,
474         const struct HksBlob *signature);
475     void EncryptTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet);
476     void DecryptTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet,
477         const struct HksBlob *cipherText, uint32_t *inLen);
478     void AgreeKeyTest(const struct HksBlob *authId);
479     void DeriveKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet);
480     void MacTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet);
481     void HashTest();
482     void CipherScene(uint32_t ii);
483     void SignScene(uint32_t ii);
484     void AgreeScene(uint32_t ii);
485 
486 private:
487     bool threadState_ = false;
488     std::mutex mutex_;
489 };
490 
GetSdkVersionTest()491 void ApiPressureTest::GetSdkVersionTest()
492 {
493     do {
494         if (!GetThreadState()) {
495             break;
496         }
497         struct HksBlob sdkVersion = {
498             .size = MAX_SDK_VERSION_SIZE,
499             .data = (uint8_t *)HksMalloc(MAX_SDK_VERSION_SIZE)
500         };
501         ASSERT_NE(sdkVersion.data, nullptr);
502 
503         EXPECT_EQ(HksGetSdkVersion(&sdkVersion), HKS_SUCCESS);
504 
505         HksFree(sdkVersion.data);
506     } while (1);
507 }
508 
InitializeTest()509 void ApiPressureTest::InitializeTest()
510 {
511     do {
512         if (!GetThreadState()) {
513             break;
514         }
515         EXPECT_EQ(HksInitialize(), HKS_SUCCESS);
516     } while (1);
517 }
518 
RefreshKeyInfoTest()519 void ApiPressureTest::RefreshKeyInfoTest()
520 {
521     do {
522         if (!GetThreadState()) {
523             break;
524         }
525         EXPECT_EQ(HksRefreshKeyInfo(), HKS_SUCCESS);
526     } while (1);
527 }
528 
GenerateKeyTest()529 void ApiPressureTest::GenerateKeyTest()
530 {
531     do {
532         if (!GetThreadState()) {
533             break;
534         }
535         struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
536         struct HksParamSet *paramInSet = nullptr;
537         HksInitParamSet(&paramInSet);
538         struct HksParam tmpParams[] = {
539             { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
540             { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
541             { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
542             { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY },
543             { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
544             { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
545             { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
546         };
547         HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
548         HksBuildParamSet(&paramInSet);
549         EXPECT_EQ(HksGenerateKey(&authId, paramInSet, NULL), HKS_SUCCESS);
550         HksFreeParamSet(&paramInSet);
551     } while (1);
552 }
553 
ImportKeyTest(const struct HksBlob * authId,const struct HksParamSet * paramInSet)554 void ApiPressureTest::ImportKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet)
555 {
556     struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
557     ASSERT_NE(pubKey.data, nullptr);
558     HksExportPublicKey(authId, paramInSet, &pubKey);
559     do {
560         if (!GetThreadState()) {
561             break;
562         }
563         struct HksBlob importId = { (uint32_t)strlen(IMPORT_KEY), (uint8_t *)IMPORT_KEY };
564         EXPECT_EQ(HksImportKey(&importId, paramInSet, &pubKey), HKS_SUCCESS);
565     } while (1);
566     HksFree(pubKey.data);
567 }
568 
ExportPublicKeyTest(const struct HksBlob * authId,const struct HksParamSet * paramInSet)569 void ApiPressureTest::ExportPublicKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet)
570 {
571     do {
572         if (!GetThreadState()) {
573             break;
574         }
575         struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
576         ASSERT_NE(pubKey.data, nullptr);
577 
578         EXPECT_EQ(HksExportPublicKey(authId, paramInSet, &pubKey), HKS_SUCCESS);
579 
580         HksFree(pubKey.data);
581     } while (1);
582 }
583 
DeleteKeyTest(uint32_t ii)584 void ApiPressureTest::DeleteKeyTest(uint32_t ii)
585 {
586     do {
587         if (!GetThreadState()) {
588             break;
589         }
590         std::string key = "KeyForThread" + std::to_string(ii);
591         struct HksBlob authId = { .size = (uint32_t)key.length(), .data = (uint8_t *)&key[0] };
592         struct HksParamSet *paramInSet = nullptr;
593         HksInitParamSet(&paramInSet);
594         struct HksParam tmpParams[] = {
595             { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
596             { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
597             { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
598             { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY },
599             { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
600             { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
601             { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
602         };
603         HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
604         HksBuildParamSet(&paramInSet);
605         HksGenerateKey(&authId, paramInSet, NULL);
606         EXPECT_EQ(HksDeleteKey(&authId, paramInSet), HKS_SUCCESS);
607         HksFreeParamSet(&paramInSet);
608     } while (1);
609 }
610 
GetKeyParamSetTest(const struct HksBlob * authId,const struct HksParamSet * paramInSet)611 void ApiPressureTest::GetKeyParamSetTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet)
612 {
613     do {
614         struct HksParamSet *paramOutSet = nullptr;
615         HksInitParamSet(&paramOutSet);
616         struct HksParam localKey = {
617             .tag = HKS_TAG_SYMMETRIC_KEY_DATA,
618             .blob = { .size = KEY_PARAMSET_SIZE, .data = (uint8_t *)HksMalloc(KEY_PARAMSET_SIZE) }
619         };
620         ASSERT_NE(localKey.blob.data, nullptr);
621         HksAddParams(paramOutSet, &localKey, 1);
622         HksBuildParamSet(&paramOutSet);
623         if (!GetThreadState()) {
624             break;
625         }
626         EXPECT_EQ(HksGetKeyParamSet(authId, paramInSet, paramOutSet), HKS_SUCCESS);
627         HksFree(localKey.blob.data);
628         HksFreeParamSet(&paramOutSet);
629     } while (1);
630 }
631 
KeyExistTest(const struct HksBlob * authId,const struct HksParamSet * paramInSet)632 void ApiPressureTest::KeyExistTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet)
633 {
634     do {
635         if (!GetThreadState()) {
636             break;
637         }
638         EXPECT_EQ(HksKeyExist(authId, paramInSet), HKS_SUCCESS);
639     } while (1);
640 }
641 
GenerateRandomTest()642 void ApiPressureTest::GenerateRandomTest()
643 {
644     struct HksBlob authId = { .size = RANDOM_KEY_SIZE, .data = (uint8_t *)HksMalloc(RANDOM_KEY_SIZE) };
645     ASSERT_NE(authId.data, nullptr);
646     struct HksParamSet *paramInSet = nullptr;
647     HksInitParamSet(&paramInSet);
648     struct HksParam tmpParams[] = {
649         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
650         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
651         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
652         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
653     };
654     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
655     HksBuildParamSet(&paramInSet);
656     do {
657         if (!GetThreadState()) {
658             break;
659         }
660         EXPECT_EQ(HksGenerateRandom(paramInSet, &authId), HKS_SUCCESS);
661     } while (1);
662     HksFree(authId.data);
663     HksFreeParamSet(&paramInSet);
664 }
665 
SignTest(const struct HksBlob * authId,const struct HksParamSet * paramInSet,const struct HksBlob * message)666 void ApiPressureTest::SignTest(
667     const struct HksBlob *authId, const struct HksParamSet *paramInSet, const struct HksBlob *message)
668 {
669     do {
670         if (!GetThreadState()) {
671             break;
672         }
673         HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
674         ASSERT_NE(signature.data, nullptr);
675         EXPECT_EQ(HksSign(authId, paramInSet, message, &signature), HKS_SUCCESS);
676         HksFree(signature.data);
677     } while (1);
678 }
679 
VerifyTest(const struct HksBlob * authId,const struct HksParamSet * paramInSet,const struct HksBlob * message,const struct HksBlob * signature)680 void ApiPressureTest::VerifyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet,
681     const struct HksBlob *message, const struct HksBlob *signature)
682 {
683     do {
684         if (!GetThreadState()) {
685             break;
686         }
687         EXPECT_EQ(HksVerify(authId, paramInSet, message, signature), HKS_SUCCESS);
688     } while (1);
689 }
690 
EncryptTest(const struct HksBlob * authId,const struct HksParamSet * paramInSet)691 void ApiPressureTest::EncryptTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet)
692 {
693     const char *hexData = "0123456789abcdef";
694     uint32_t dataLen = strlen(hexData);
695     HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData };
696     uint32_t inLen = dataLen + COMPLEMENT_LEN;
697     do {
698         if (!GetThreadState()) {
699             break;
700         }
701         HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
702         ASSERT_NE(cipherText.data, nullptr);
703         EXPECT_EQ(HksEncrypt(authId, paramInSet, &plainText, &cipherText), HKS_SUCCESS);
704         HksFree(cipherText.data);
705     } while (1);
706 }
707 
DecryptTest(const struct HksBlob * authId,const struct HksParamSet * paramInSet,const struct HksBlob * cipherText,uint32_t * inLen)708 void ApiPressureTest::DecryptTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet,
709     const struct HksBlob *cipherText, uint32_t *inLen)
710 {
711     do {
712         if (!GetThreadState()) {
713             break;
714         }
715         HksBlob plainTextDecrypt = { .size = *inLen, .data = (uint8_t *)HksMalloc(*inLen) };
716         ASSERT_NE(plainTextDecrypt.data, nullptr);
717         EXPECT_EQ(HksDecrypt(authId, paramInSet, cipherText, &plainTextDecrypt), HKS_SUCCESS);
718         HksFree(plainTextDecrypt.data);
719     } while (1);
720 }
721 
AgreeKeyTest(const struct HksBlob * authId)722 void ApiPressureTest::AgreeKeyTest(const struct HksBlob *authId)
723 {
724     struct HksBlob pubKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
725     ASSERT_NE(pubKey.data, nullptr);
726     HksExportPublicKey(authId, NULL, &pubKey);
727     struct HksParamSet *paramInSet = nullptr;
728     HksInitParamSet(&paramInSet);
729     struct HksParam tmpParams[] = {
730         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
731         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECDH },
732         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
733         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
734         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
735         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
736     };
737     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
738     HksBuildParamSet(&paramInSet);
739     do {
740         if (!GetThreadState()) {
741             break;
742         }
743         HksBlob agreeKey = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
744         ASSERT_NE(agreeKey.data, nullptr);
745         EXPECT_EQ(HksAgreeKey(paramInSet, authId, &pubKey, &agreeKey), HKS_SUCCESS);
746         HksFree(agreeKey.data);
747     } while (1);
748     HksFree(pubKey.data);
749     HksFreeParamSet(&paramInSet);
750 }
751 
DeriveKeyTest(const struct HksBlob * authId,const struct HksParamSet * paramInSet)752 void ApiPressureTest::DeriveKeyTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet)
753 {
754     do {
755         if (!GetThreadState()) {
756             break;
757         }
758         HksBlob derivedKey = { .size = DERIVE_KEY_SIZE, .data = (uint8_t *)HksMalloc(DERIVE_KEY_SIZE) };
759         ASSERT_NE(derivedKey.data, nullptr);
760         EXPECT_EQ(HksDeriveKey(paramInSet, authId, &derivedKey), HKS_SUCCESS);
761         HksFree(derivedKey.data);
762     } while (1);
763 }
764 
MacTest(const struct HksBlob * authId,const struct HksParamSet * paramInSet)765 void ApiPressureTest::MacTest(const struct HksBlob *authId, const struct HksParamSet *paramInSet)
766 {
767     const char *hexData = "0123456789abcdef";
768     uint32_t dataLen = strlen(hexData);
769     HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData };
770     do {
771         if (!GetThreadState()) {
772             break;
773         }
774         HksBlob macMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) };
775         ASSERT_NE(macMessage.data, nullptr);
776         EXPECT_EQ(HksMac(authId, paramInSet, &message, &macMessage), HKS_SUCCESS);
777         HksFree(macMessage.data);
778     } while (1);
779 }
780 
HashTest()781 void ApiPressureTest::HashTest()
782 {
783     struct HksParamSet *paramInSet = nullptr;
784     HksInitParamSet(&paramInSet);
785     struct HksParam digest = { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 };
786     HksAddParams(paramInSet, &digest, 1);
787     HksBuildParamSet(&paramInSet);
788     const char *hexData = "0123456789abcdef";
789     uint32_t dataLen = strlen(hexData);
790     HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData };
791     do {
792         if (!GetThreadState()) {
793             break;
794         }
795         HksBlob shaMessage = { .size = MESSAGE_SIZE, .data = (uint8_t *)HksMalloc(MESSAGE_SIZE) };
796         ASSERT_NE(shaMessage.data, nullptr);
797         EXPECT_EQ(HksHash(paramInSet, &message, &shaMessage), HKS_SUCCESS);
798         HksFree(shaMessage.data);
799     } while (1);
800     HksFreeParamSet(&paramInSet);
801 }
802 
CipherScene(uint32_t ii)803 void ApiPressureTest::CipherScene(uint32_t ii)
804 {
805     std::string key = "KeyForThread" + std::to_string(ii);
806     struct HksBlob authId = { .size = (uint32_t)key.length(), .data = (uint8_t *)&key[0] };
807     do {
808         if (!GetThreadState()) {
809             break;
810         }
811         struct HksParamSet *paramInSet = nullptr;
812         HksInitParamSet(&paramInSet);
813         HksAddParams(paramInSet, CIPHER_PARAMS, sizeof(CIPHER_PARAMS) / sizeof(CIPHER_PARAMS[0]));
814         ParamForCipher(paramInSet);
815         HksBuildParamSet(&paramInSet);
816         HksGenerateKey(&authId, paramInSet, NULL);
817         struct HksParam *padding = nullptr;
818         HksGetParam(paramInSet, HKS_TAG_PADDING, &padding);
819         char hexData[MAX_STRING_LENTH] = {0};
820         uint32_t dataLen;
821         struct HksParam *algorithm = nullptr;
822         HksGetParam(paramInSet, HKS_TAG_ALGORITHM, &algorithm);
823         if (algorithm->uint32Param == HKS_ALG_RSA) {
824             if (padding->uint32Param == HKS_PADDING_NONE) {
825                 struct HksParam *keySize = nullptr;
826                 HksGetParam(paramInSet, HKS_TAG_KEY_SIZE, &keySize);
827                 dataLen = HKS_KEY_BYTES(keySize->uint32Param);
828             } else {
829                 dataLen = RSA_MESSAGE_SIZE;
830             }
831         } else {
832             dataLen = AES_MESSAGE_SIZE;
833         }
834         HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData };
835         HksBlob cipherText = { .size = CIPHER_SIZE, .data = (uint8_t *)HksMalloc(CIPHER_SIZE) };
836         ASSERT_NE(cipherText.data, nullptr);
837         HksEncrypt(&authId, paramInSet, &plainText, &cipherText);
838         HksBlob plainTextDecrypt = { .size = CIPHER_SIZE, .data = (uint8_t *)HksMalloc(CIPHER_SIZE) };
839         ASSERT_NE(plainTextDecrypt.data, nullptr);
840         EXPECT_EQ(HksDecrypt(&authId, paramInSet, &cipherText, &plainTextDecrypt), HKS_SUCCESS);
841         (void)HksDeleteKey(&authId, nullptr);
842         HksFree(plainTextDecrypt.data);
843         HksFree(cipherText.data);
844         HksFreeParamSet(&paramInSet);
845     } while (1);
846 }
847 
SignScene(uint32_t ii)848 void ApiPressureTest::SignScene(uint32_t ii)
849 {
850     std::string key = "KeyForThread" + std::to_string(ii);
851     struct HksBlob authId = { .size = (uint32_t)key.length(), .data = (uint8_t *)&key[0] };
852     do {
853         if (!GetThreadState()) {
854             break;
855         }
856         struct HksParamSet *paramInSet = nullptr;
857         HksInitParamSet(&paramInSet);
858         struct HksParam tmpParams[] = {
859             { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
860             { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
861             { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
862             { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
863         };
864         HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
865         ParamForSign(paramInSet);
866         HksBuildParamSet(&paramInSet);
867         HksGenerateKey(&authId, paramInSet, NULL);
868         const char *hexData = "0123456789abcdef";
869         uint32_t dataLen = strlen(hexData);
870         HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData };
871         HksBlob signature = { .size = CIPHER_SIZE, .data = (uint8_t *)HksMalloc(CIPHER_SIZE) };
872         ASSERT_NE(signature.data, nullptr);
873         HksSign(&authId, paramInSet, &message, &signature);
874         EXPECT_EQ(HksVerify(&authId, paramInSet, &message, &signature), HKS_SUCCESS);
875         (void)HksDeleteKey(&authId, nullptr);
876         HksFree(signature.data);
877         HksFreeParamSet(&paramInSet);
878     } while (1);
879 }
880 
AgreeScene(uint32_t ii)881 void ApiPressureTest::AgreeScene(uint32_t ii)
882 {
883     std::string key = "KeyForThread" + std::to_string(ii);
884     struct HksBlob authId = { .size = (uint32_t)key.length(), .data = (uint8_t *)&key[0] };
885     do {
886         if (!GetThreadState()) {
887             break;
888         }
889         struct HksParamSet *generateKeyParam = nullptr;
890         HksInitParamSet(&generateKeyParam);
891         struct HksParamSet *agreeKeyParam = nullptr;
892         HksInitParamSet(&agreeKeyParam);
893         struct HksParam tmpParams[] = {
894             { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
895             { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
896             { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
897             { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
898         };
899         HksAddParams(generateKeyParam, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
900         HksAddParams(agreeKeyParam, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
901         ParamForAgree(generateKeyParam, agreeKeyParam);
902         HksBuildParamSet(&generateKeyParam);
903         HksBuildParamSet(&agreeKeyParam);
904         HksGenerateKey(&authId, generateKeyParam, NULL);
905         struct HksBlob pubKey = { .size = TEST_KEY_SIZE, .data = (uint8_t *)HksMalloc(TEST_KEY_SIZE) };
906         ASSERT_NE(pubKey.data, nullptr);
907         HksExportPublicKey(&authId, generateKeyParam, &pubKey);
908         HksBlob agreeKey = { .size = TEST_KEY_SIZE, .data = (uint8_t *)HksMalloc(TEST_KEY_SIZE) };
909         ASSERT_NE(agreeKey.data, nullptr);
910         EXPECT_EQ(HksAgreeKey(agreeKeyParam, &authId, &pubKey, &agreeKey), HKS_SUCCESS);
911         (void)HksDeleteKey(&authId, nullptr);
912         HksFree(agreeKey.data);
913         HksFree(pubKey.data);
914         HksFreeParamSet(&generateKeyParam);
915         HksFreeParamSet(&agreeKeyParam);
916     } while (1);
917 }
918 
919 /**
920  * @tc.number    : ApiPressureTest.ApiPressureTest00100
921  * @tc.name      : ApiPressureTest00100
922  * @tc.desc      : HksGetSdkVersion
923  */
924 HWTEST_F(ApiPressureTest, ApiPressureTest00100, TestSize.Level1)
925 {
926     std::vector<std::thread> threads;
927     SetThreadState(true);
928     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
929         threads.emplace_back(std::thread(&ApiPressureTest::GetSdkVersionTest, this));
930     }
931     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
932     SetThreadState(false);
933     for (auto &t : threads) {
934         t.join();
935     }
936 }
937 
938 /**
939  * @tc.number    : ApiPressureTest.ApiPressureTest00200
940  * @tc.name      : ApiPressureTest00200
941  * @tc.desc      : HksInitialize
942  */
943 HWTEST_F(ApiPressureTest, ApiPressureTest00200, TestSize.Level1)
944 {
945     std::vector<std::thread> threads;
946     SetThreadState(true);
947     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
948         threads.emplace_back(std::thread(&ApiPressureTest::InitializeTest, this));
949     }
950     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
951     SetThreadState(false);
952     for (auto &t : threads) {
953         t.join();
954     }
955 }
956 
957 /**
958  * @tc.number    : ApiPressureTest.ApiPressureTest00300
959  * @tc.name      : ApiPressureTest00300
960  * @tc.desc      : HksRefreshKeyInfo
961  */
962 HWTEST_F(ApiPressureTest, ApiPressureTest00300, TestSize.Level1)
963 {
964     std::vector<std::thread> threads;
965     SetThreadState(true);
966     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
967         threads.emplace_back(std::thread(&ApiPressureTest::RefreshKeyInfoTest, this));
968     }
969     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
970     SetThreadState(false);
971     for (auto &t : threads) {
972         t.join();
973     }
974 }
975 
976 /**
977  * @tc.number    : ApiPressureTest.ApiPressureTest00400
978  * @tc.name      : ApiPressureTest00400
979  * @tc.desc      : HksGenerateKey
980  */
981 HWTEST_F(ApiPressureTest, ApiPressureTest00400, TestSize.Level1)
982 {
983     std::vector<std::thread> threads;
984     SetThreadState(true);
985     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
986         threads.emplace_back(std::thread(&ApiPressureTest::GenerateKeyTest, this));
987     }
988     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
989     SetThreadState(false);
990     for (auto &t : threads) {
991         t.join();
992     }
993 
994     struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
995     (void)HksDeleteKey(&authId, nullptr);
996 }
997 
998 /**
999  * @tc.number    : ApiPressureTest.ApiPressureTest00500
1000  * @tc.name      : ApiPressureTest00500
1001  * @tc.desc      : HksImportKey
1002  */
1003 HWTEST_F(ApiPressureTest, ApiPressureTest00500, TestSize.Level1)
1004 {
1005     std::vector<std::thread> threads;
1006     struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1007     struct HksParamSet *paramInSet = nullptr;
1008     HksInitParamSet(&paramInSet);
1009     struct HksParam tmpParams[] = {
1010         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
1011         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
1012         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
1013         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY },
1014         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
1015         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
1016         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1017     };
1018     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1019     HksBuildParamSet(&paramInSet);
1020     HksGenerateKey(&authId, paramInSet, NULL);
1021     SetThreadState(true);
1022     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1023         threads.emplace_back(std::thread(&ApiPressureTest::ImportKeyTest, this, &authId, paramInSet));
1024     }
1025     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1026     SetThreadState(false);
1027     for (auto &t : threads) {
1028         t.join();
1029     }
1030     (void)HksDeleteKey(&authId, nullptr);
1031     HksFreeParamSet(&paramInSet);
1032 }
1033 
1034 /**
1035  * @tc.number    : ApiPressureTest.ApiPressureTest00600
1036  * @tc.name      : ApiPressureTest00600
1037  * @tc.desc      : HksExportPublicKey
1038  */
1039 HWTEST_F(ApiPressureTest, ApiPressureTest00600, TestSize.Level1)
1040 {
1041     std::vector<std::thread> threads;
1042     struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1043     struct HksParamSet *paramInSet = nullptr;
1044     HksInitParamSet(&paramInSet);
1045     struct HksParam tmpParams[] = {
1046         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
1047         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
1048         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
1049         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY },
1050         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
1051         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
1052         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1053     };
1054     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1055     HksBuildParamSet(&paramInSet);
1056     HksGenerateKey(&authId, paramInSet, NULL);
1057     SetThreadState(true);
1058     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1059         threads.emplace_back(std::thread(&ApiPressureTest::ExportPublicKeyTest, this, &authId, paramInSet));
1060     }
1061     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1062     SetThreadState(false);
1063     for (auto &t : threads) {
1064         t.join();
1065     }
1066     (void)HksDeleteKey(&authId, nullptr);
1067     HksFreeParamSet(&paramInSet);
1068 }
1069 
1070 /**
1071  * @tc.number    : ApiPressureTest.ApiPressureTest00700
1072  * @tc.name      : ApiPressureTest00700
1073  * @tc.desc      : HksDeleteKey
1074  */
1075 HWTEST_F(ApiPressureTest, ApiPressureTest00700, TestSize.Level1)
1076 {
1077     std::vector<std::thread> threads;
1078     SetThreadState(true);
1079     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1080         threads.emplace_back(std::thread(&ApiPressureTest::DeleteKeyTest, this, ii));
1081     }
1082     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1083     SetThreadState(false);
1084     for (auto &t : threads) {
1085         t.join();
1086     }
1087 }
1088 
1089 /**
1090  * @tc.number    : ApiPressureTest.ApiPressureTest00800
1091  * @tc.name      : ApiPressureTest00800
1092  * @tc.desc      : HksGetKeyParamSet
1093  */
1094 HWTEST_F(ApiPressureTest, ApiPressureTest00800, TestSize.Level1)
1095 {
1096     std::vector<std::thread> threads;
1097     struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1098     struct HksParamSet *paramInSet = nullptr;
1099     HksInitParamSet(&paramInSet);
1100     struct HksParam tmpParams[] = {
1101         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
1102         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
1103         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
1104         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY },
1105         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
1106         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
1107         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1108     };
1109     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1110     HksBuildParamSet(&paramInSet);
1111     HksGenerateKey(&authId, paramInSet, NULL);
1112     SetThreadState(true);
1113     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1114         threads.emplace_back(std::thread(&ApiPressureTest::GetKeyParamSetTest, this, &authId, paramInSet));
1115     }
1116     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1117     SetThreadState(false);
1118     for (auto &t : threads) {
1119         t.join();
1120     }
1121     (void)HksDeleteKey(&authId, nullptr);
1122     HksFreeParamSet(&paramInSet);
1123 }
1124 
1125 /**
1126  * @tc.number    : ApiPressureTest.ApiPressureTest00900
1127  * @tc.name      : ApiPressureTest00900
1128  * @tc.desc      : HksKeyExist
1129  */
1130 HWTEST_F(ApiPressureTest, ApiPressureTest00900, TestSize.Level1)
1131 {
1132     std::vector<std::thread> threads;
1133     struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1134     struct HksParamSet *paramInSet = nullptr;
1135     HksInitParamSet(&paramInSet);
1136     struct HksParam tmpParams[] = {
1137         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
1138         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
1139         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
1140         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_VERIFY },
1141         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
1142         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
1143         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1144     };
1145     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1146     HksBuildParamSet(&paramInSet);
1147     HksGenerateKey(&authId, paramInSet, NULL);
1148     SetThreadState(true);
1149     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1150         threads.emplace_back(std::thread(&ApiPressureTest::KeyExistTest, this, &authId, paramInSet));
1151     }
1152     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1153     SetThreadState(false);
1154     for (auto &t : threads) {
1155         t.join();
1156     }
1157     (void)HksDeleteKey(&authId, nullptr);
1158     HksFreeParamSet(&paramInSet);
1159 }
1160 
1161 /**
1162  * @tc.number    : ApiPressureTest.ApiPressureTest01000
1163  * @tc.name      : ApiPressureTest01000
1164  * @tc.desc      : HksGenerateRandom
1165  */
1166 HWTEST_F(ApiPressureTest, ApiPressureTest01000, TestSize.Level1)
1167 {
1168     std::vector<std::thread> threads;
1169     SetThreadState(true);
1170     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1171         threads.emplace_back(std::thread(&ApiPressureTest::GenerateRandomTest, this));
1172     }
1173     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1174     SetThreadState(false);
1175     for (auto &t : threads) {
1176         t.join();
1177     }
1178 }
1179 
1180 /**
1181  * @tc.number    : ApiPressureTest.ApiPressureTest01100
1182  * @tc.name      : ApiPressureTest01100
1183  * @tc.desc      : HksSign
1184  */
1185 HWTEST_F(ApiPressureTest, ApiPressureTest01100, TestSize.Level1)
1186 {
1187     std::vector<std::thread> threads;
1188     struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1189     struct HksParamSet *paramInSet = nullptr;
1190     HksInitParamSet(&paramInSet);
1191     struct HksParam tmpParams[] = {
1192         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
1193         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
1194         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
1195         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
1196         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
1197         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
1198         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1199     };
1200     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1201     HksBuildParamSet(&paramInSet);
1202     HksGenerateKey(&authId, paramInSet, NULL);
1203     const char *hexData = "0123456789abcdef";
1204     uint32_t dataLen = strlen(hexData);
1205     HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData };
1206     SetThreadState(true);
1207     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1208         threads.emplace_back(std::thread(&ApiPressureTest::SignTest, this, &authId, paramInSet, &message));
1209     }
1210     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1211     SetThreadState(false);
1212     for (auto &t : threads) {
1213         t.join();
1214     }
1215     (void)HksDeleteKey(&authId, nullptr);
1216     HksFreeParamSet(&paramInSet);
1217 }
1218 
1219 /**
1220  * @tc.number    : ApiPressureTest.ApiPressureTest01200
1221  * @tc.name      : ApiPressureTest01200
1222  * @tc.desc      : HksVerify
1223  */
1224 HWTEST_F(ApiPressureTest, ApiPressureTest01200, TestSize.Level1)
1225 {
1226     std::vector<std::thread> threads;
1227     struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1228     struct HksParamSet *paramInSet = nullptr;
1229     HksInitParamSet(&paramInSet);
1230     struct HksParam tmpParams[] = {
1231         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
1232         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
1233         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
1234         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_SIGN | HKS_KEY_PURPOSE_VERIFY },
1235         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
1236         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
1237         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1238     };
1239     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1240     HksBuildParamSet(&paramInSet);
1241     HksGenerateKey(&authId, paramInSet, NULL);
1242     const char *hexData = "0123456789abcdef";
1243     uint32_t dataLen = strlen(hexData);
1244     HksBlob message = { .size = dataLen, .data = (uint8_t *)hexData };
1245     HksBlob signature = { .size = HKS_ECC_KEY_SIZE_224, .data = (uint8_t *)HksMalloc(HKS_ECC_KEY_SIZE_224) };
1246     ASSERT_NE(signature.data, nullptr);
1247     HksSign(&authId, paramInSet, &message, &signature);
1248     SetThreadState(true);
1249     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1250         threads.emplace_back(
1251             std::thread(&ApiPressureTest::VerifyTest, this, &authId, paramInSet, &message, &signature));
1252     }
1253     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1254     SetThreadState(false);
1255     for (auto &t : threads) {
1256         t.join();
1257     }
1258     (void)HksDeleteKey(&authId, nullptr);
1259     HksFree(signature.data);
1260     HksFreeParamSet(&paramInSet);
1261 }
1262 
1263 /**
1264  * @tc.number    : ApiPressureTest.ApiPressureTest01300
1265  * @tc.name      : ApiPressureTest01300
1266  * @tc.desc      : HksEncrypt
1267  */
1268 HWTEST_F(ApiPressureTest, ApiPressureTest01300, TestSize.Level1)
1269 {
1270     std::vector<std::thread> threads;
1271     struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1272     struct HksParamSet *paramInSet = nullptr;
1273     HksInitParamSet(&paramInSet);
1274     struct HksParam tmpParams[] = {
1275         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
1276         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
1277         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
1278         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
1279         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
1280         { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
1281         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
1282         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1283         { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
1284     };
1285     uint8_t iv[IV_SIZE] = {0};
1286     struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } };
1287     HksAddParams(paramInSet, &tagIv, 1);
1288     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1289     HksBuildParamSet(&paramInSet);
1290     HksGenerateKey(&authId, paramInSet, NULL);
1291     SetThreadState(true);
1292     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1293         threads.emplace_back(std::thread(&ApiPressureTest::EncryptTest, this, &authId, paramInSet));
1294     }
1295     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1296     SetThreadState(false);
1297     for (auto &t : threads) {
1298         t.join();
1299     }
1300     (void)HksDeleteKey(&authId, nullptr);
1301     HksFreeParamSet(&paramInSet);
1302 }
1303 
1304 /**
1305  * @tc.number    : ApiPressureTest.ApiPressureTest01400
1306  * @tc.name      : ApiPressureTest01400
1307  * @tc.desc      : HksDecrypt
1308  */
1309 HWTEST_F(ApiPressureTest, ApiPressureTest01400, TestSize.Level1)
1310 {
1311     std::vector<std::thread> threads;
1312     struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1313     struct HksParamSet *paramInSet = nullptr;
1314     HksInitParamSet(&paramInSet);
1315     struct HksParam tmpParams[] = {
1316         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
1317         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
1318         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
1319         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT },
1320         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
1321         { .tag = HKS_TAG_PADDING, .uint32Param = HKS_PADDING_PKCS7 },
1322         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
1323         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1324         { .tag = HKS_TAG_BLOCK_MODE, .uint32Param = HKS_MODE_CBC },
1325     };
1326     uint8_t iv[IV_SIZE] = {0};
1327     struct HksParam tagIv = { .tag = HKS_TAG_IV, .blob = { .size = IV_SIZE, .data = iv } };
1328     HksAddParams(paramInSet, &tagIv, 1);
1329     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1330     HksBuildParamSet(&paramInSet);
1331     HksGenerateKey(&authId, paramInSet, NULL);
1332     const char *hexData = "0123456789abcdef";
1333     uint32_t dataLen = strlen(hexData);
1334     HksBlob plainText = { .size = dataLen, .data = (uint8_t *)hexData };
1335     uint32_t inLen = dataLen + COMPLEMENT_LEN;
1336     HksBlob cipherText = { .size = inLen, .data = (uint8_t *)HksMalloc(inLen) };
1337     ASSERT_NE(cipherText.data, nullptr);
1338     HksEncrypt(&authId, paramInSet, &plainText, &cipherText);
1339     SetThreadState(true);
1340     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1341         threads.emplace_back(
1342             std::thread(&ApiPressureTest::DecryptTest, this, &authId, paramInSet, &cipherText, &inLen));
1343     }
1344     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1345     SetThreadState(false);
1346     for (auto &t : threads) {
1347         t.join();
1348     }
1349     (void)HksDeleteKey(&authId, nullptr);
1350     HksFree(cipherText.data);
1351     HksFreeParamSet(&paramInSet);
1352 }
1353 
1354 /**
1355  * @tc.number    : ApiPressureTest.ApiPressureTest01500
1356  * @tc.name      : ApiPressureTest01500
1357  * @tc.desc      : HksAgreeKey
1358  */
1359 HWTEST_F(ApiPressureTest, ApiPressureTest01500, TestSize.Level1)
1360 {
1361     std::vector<std::thread> threads;
1362     struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1363     struct HksParamSet *paramInSet = nullptr;
1364     HksInitParamSet(&paramInSet);
1365     struct HksParam tmpParams[] = {
1366         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
1367         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_ECC },
1368         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_ECC_KEY_SIZE_224 },
1369         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_AGREE },
1370         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_NONE },
1371         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
1372         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1373     };
1374     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1375     HksBuildParamSet(&paramInSet);
1376     HksGenerateKey(&authId, paramInSet, NULL);
1377     SetThreadState(true);
1378     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1379         threads.emplace_back(std::thread(&ApiPressureTest::AgreeKeyTest, this, &authId));
1380     }
1381     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1382     SetThreadState(false);
1383     for (auto &t : threads) {
1384         t.join();
1385     }
1386     (void)HksDeleteKey(&authId, nullptr);
1387     HksFreeParamSet(&paramInSet);
1388 }
1389 
1390 /**
1391  * @tc.number    : ApiPressureTest.ApiPressureTest01600
1392  * @tc.name      : ApiPressureTest01600
1393  * @tc.desc      : HksDeriveKey
1394  */
1395 HWTEST_F(ApiPressureTest, ApiPressureTest01600, TestSize.Level1)
1396 {
1397     std::vector<std::thread> threads;
1398     struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1399     struct HksParamSet *paramInSet = nullptr;
1400     HksInitParamSet(&paramInSet);
1401     struct HksParam tmpParams[] = {
1402         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
1403         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_AES },
1404         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = HKS_AES_KEY_SIZE_128 },
1405         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE },
1406         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
1407         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
1408         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1409     };
1410     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1411     HksBuildParamSet(&paramInSet);
1412     HksGenerateKey(&authId, paramInSet, NULL);
1413     struct HksParamSet *paramInSetHkdf = nullptr;
1414     HksInitParamSet(&paramInSetHkdf);
1415     struct HksParam tmpParamsHkdf[] = {
1416         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
1417         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HKDF },
1418         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_DERIVE },
1419         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA256 },
1420         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
1421         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1422     };
1423     HksAddParams(paramInSetHkdf, tmpParamsHkdf, sizeof(tmpParamsHkdf) / sizeof(tmpParamsHkdf[0]));
1424     HksBuildParamSet(&paramInSetHkdf);
1425     SetThreadState(true);
1426     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1427         threads.emplace_back(std::thread(&ApiPressureTest::DeriveKeyTest, this, &authId, paramInSetHkdf));
1428     }
1429     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1430     SetThreadState(false);
1431     for (auto &t : threads) {
1432         t.join();
1433     }
1434     (void)HksDeleteKey(&authId, nullptr);
1435     HksFreeParamSet(&paramInSet);
1436     HksFreeParamSet(&paramInSetHkdf);
1437 }
1438 
1439 /**
1440  * @tc.number    : ApiPressureTest.ApiPressureTest01700
1441  * @tc.name      : ApiPressureTest01700
1442  * @tc.desc      : HksMac
1443  */
1444 HWTEST_F(ApiPressureTest, ApiPressureTest01700, TestSize.Level1)
1445 {
1446     std::vector<std::thread> threads;
1447     struct HksBlob authId = { (uint32_t)strlen(GENERATE_KEY), (uint8_t *)GENERATE_KEY };
1448     struct HksParamSet *paramInSet = nullptr;
1449     HksInitParamSet(&paramInSet);
1450     struct HksParam tmpParams[] = {
1451         { .tag = HKS_TAG_KEY_STORAGE_FLAG, .uint32Param = HKS_STORAGE_PERSISTENT },
1452         { .tag = HKS_TAG_ALGORITHM, .uint32Param = HKS_ALG_HMAC },
1453         { .tag = HKS_TAG_KEY_SIZE, .uint32Param = TEST_KEY_SIZE },
1454         { .tag = HKS_TAG_PURPOSE, .uint32Param = HKS_KEY_PURPOSE_MAC },
1455         { .tag = HKS_TAG_DIGEST, .uint32Param = HKS_DIGEST_SHA1 },
1456         { .tag = HKS_TAG_IS_KEY_ALIAS, .boolParam = true },
1457         { .tag = HKS_TAG_KEY_GENERATE_TYPE, .uint32Param = HKS_KEY_GENERATE_TYPE_DEFAULT },
1458     };
1459     HksAddParams(paramInSet, tmpParams, sizeof(tmpParams) / sizeof(tmpParams[0]));
1460     HksBuildParamSet(&paramInSet);
1461     HksGenerateKey(&authId, paramInSet, NULL);
1462     SetThreadState(true);
1463     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1464         threads.emplace_back(std::thread(&ApiPressureTest::MacTest, this, &authId, paramInSet));
1465     }
1466     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1467     SetThreadState(false);
1468     for (auto &t : threads) {
1469         t.join();
1470     }
1471     (void)HksDeleteKey(&authId, nullptr);
1472     HksFreeParamSet(&paramInSet);
1473 }
1474 
1475 /**
1476  * @tc.number    : ApiPressureTest.ApiPressureTest01800
1477  * @tc.name      : ApiPressureTest01800
1478  * @tc.desc      : HksHash
1479  */
1480 HWTEST_F(ApiPressureTest, ApiPressureTest01800, TestSize.Level1)
1481 {
1482     std::vector<std::thread> threads;
1483     SetThreadState(true);
1484     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1485         threads.emplace_back(std::thread(&ApiPressureTest::HashTest, this));
1486     }
1487     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1488     SetThreadState(false);
1489     for (auto &t : threads) {
1490         t.join();
1491     }
1492 }
1493 
1494 /**
1495  * @tc.number    : ApiPressureTest.ApiPressureTest01900
1496  * @tc.name      : ApiPressureTest01900
1497  * @tc.desc      : Scenario 1: generate key and encrypt / decrypt
1498  */
1499 HWTEST_F(ApiPressureTest, ApiPressureTest01900, TestSize.Level1)
1500 {
1501     std::vector<std::thread> threads;
1502     SetThreadState(true);
1503     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1504         threads.emplace_back(std::thread(&ApiPressureTest::CipherScene, this, ii));
1505     }
1506     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1507     SetThreadState(false);
1508     for (auto &t : threads) {
1509         t.join();
1510     }
1511 }
1512 
1513 /**
1514  * @tc.number    : ApiPressureTest.ApiPressureTest02000
1515  * @tc.name      : ApiPressureTest02000
1516  * @tc.desc      : Scenario 2: generate key and sign / verify
1517  */
1518 HWTEST_F(ApiPressureTest, ApiPressureTest02000, TestSize.Level1)
1519 {
1520     std::vector<std::thread> threads;
1521     SetThreadState(true);
1522     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1523         threads.emplace_back(std::thread(&ApiPressureTest::SignScene, this, ii));
1524     }
1525     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1526     SetThreadState(false);
1527     for (auto &t : threads) {
1528         t.join();
1529     }
1530 }
1531 
1532 /**
1533  * @tc.number    : ApiPressureTest.ApiPressureTest02100
1534  * @tc.name      : ApiPressureTest02100
1535  * @tc.desc      : Scenario 3: generate key and agree
1536  */
1537 HWTEST_F(ApiPressureTest, ApiPressureTest02100, TestSize.Level1)
1538 {
1539     std::vector<std::thread> threads;
1540     SetThreadState(true);
1541     for (uint32_t ii = 0; ii < THREADS_NUM; ii++) {
1542         threads.emplace_back(std::thread(&ApiPressureTest::AgreeScene, this, ii));
1543     }
1544     std::this_thread::sleep_for(std::chrono::hours(TEST_HOURS));
1545     SetThreadState(false);
1546     for (auto &t : threads) {
1547         t.join();
1548     }
1549 }
1550 }  // namespace
1551