1 /*
2 * Copyright (c) 2025 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 #include <stdlib.h>
16 #include <stdio.h>
17 #include <pthread.h>
18 #include <string.h>
19
20 #include "crypto_framework_asym_key_test.h"
21 #include "blob.h"
22 #include "log.h"
23
24 #include <gtest/gtest.h>
25
26 using namespace testing::ext;
27 namespace Unittest::CryptoFrameworkAsymKeyNapiTest {
28 class OHCryptoFrameworkAsymKeyNapiTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31
32 static void TearDownTestCase(void);
33
34 void SetUp();
35
36 void TearDown();
37 };
38
SetUpTestCase(void)39 void OHCryptoFrameworkAsymKeyNapiTest::SetUpTestCase(void)
40 {
41 }
42
TearDownTestCase(void)43 void OHCryptoFrameworkAsymKeyNapiTest::TearDownTestCase(void)
44 {
45 }
46
SetUp()47 void OHCryptoFrameworkAsymKeyNapiTest::SetUp()
48 {
49 }
50
TearDown()51 void OHCryptoFrameworkAsymKeyNapiTest::TearDown()
52 {
53 }
54
55 class ASYMKEY_TEST : public testing::TestWithParam<AsymKeySpec> {
56 public:
SetUpTestCase()57 static void SetUpTestCase() {}
TearDownTestCase()58 static void TearDownTestCase() {}
59 };
60
61 class ASYMKEY_PRIV_TEST : public testing::TestWithParam<AsymPrivKeySpec> {
62 public:
SetUpTestCase()63 static void SetUpTestCase() {}
TearDownTestCase()64 static void TearDownTestCase() {}
65 };
66
67 class ASYMKEY_ECC_KEYPAIR_TEST : public testing::TestWithParam<CommonECCSpec> {
68 public:
SetUpTestCase()69 static void SetUpTestCase() {}
TearDownTestCase()70 static void TearDownTestCase() {}
71 };
72
73 class ASYMKEY_RSA_KEYPAIR_TEST : public testing::TestWithParam<CommonRSASpec> {
74 public:
SetUpTestCase()75 static void SetUpTestCase() {}
TearDownTestCase()76 static void TearDownTestCase() {}
77 };
78
79 class ASYMKEY_DH_KEYPAIR_TEST : public testing::TestWithParam<CommonDHSpec> {
80 public:
SetUpTestCase()81 static void SetUpTestCase() {}
TearDownTestCase()82 static void TearDownTestCase() {}
83 };
84
85 class ASYMKEY_DSA_KEYPAIR_TEST : public testing::TestWithParam<CommonDSASpec> {
86 public:
SetUpTestCase()87 static void SetUpTestCase() {}
TearDownTestCase()88 static void TearDownTestCase() {}
89 };
90
91 class ASYMKEY_KEYPAIR_TEST : public testing::TestWithParam<CommonSpec> {
92 public:
SetUpTestCase()93 static void SetUpTestCase() {}
TearDownTestCase()94 static void TearDownTestCase() {}
95 };
96
97 class ASYMKEY_EC_POINT_TEST : public testing::TestWithParam<ECPointSpec> {
98 public:
SetUpTestCase()99 static void SetUpTestCase() {}
TearDownTestCase()100 static void TearDownTestCase() {}
101 };
102
103 AsymKeySpec g_asymKeyData[] = {
104 {(uint8_t *)"DSA1024", "DSA"},
105 {(uint8_t *)"DSA2048", "DSA"},
106 {(uint8_t *)"DSA3072", "DSA"},
107 {(uint8_t *)"Ed25519", "Ed25519"},
108 {(uint8_t *)"X25519", "X25519"},
109 {(uint8_t *)"DH_modp1536", "DH"},
110 {(uint8_t *)"DH_modp2048", "DH"},
111 {(uint8_t *)"DH_modp3072", "DH"},
112 {(uint8_t *)"DH_modp4096", "DH"},
113 {(uint8_t *)"DH_modp6144", "DH"},
114 {(uint8_t *)"DH_modp8192", "DH"},
115 {(uint8_t *)"DH_ffdhe2048", "DH"},
116 {(uint8_t *)"DH_ffdhe3072", "DH"},
117 {(uint8_t *)"DH_ffdhe4096", "DH"},
118 {(uint8_t *)"DH_ffdhe6144", "DH"},
119 {(uint8_t *)"DH_ffdhe8192", "DH"},
120 {(uint8_t *)"RSA512|PRIMES_2", "RSA"},
121 {(uint8_t *)"RSA768|PRIMES_2", "RSA"},
122 {(uint8_t *)"RSA1024|PRIMES_2", "RSA"},
123 {(uint8_t *)"RSA1024|PRIMES_3", "RSA"},
124 {(uint8_t *)"RSA2048|PRIMES_2", "RSA"},
125 {(uint8_t *)"RSA2048|PRIMES_3", "RSA"},
126 {(uint8_t *)"RSA3072|PRIMES_2", "RSA"},
127 {(uint8_t *)"RSA3072|PRIMES_3", "RSA"},
128 {(uint8_t *)"RSA4096|PRIMES_2", "RSA"},
129 {(uint8_t *)"RSA4096|PRIMES_3", "RSA"},
130 {(uint8_t *)"RSA4096|PRIMES_4", "RSA"},
131 {(uint8_t *)"RSA8192|PRIMES_2", "RSA"},
132 {(uint8_t *)"RSA8192|PRIMES_3", "RSA"},
133 {(uint8_t *)"RSA8192|PRIMES_4", "RSA"},
134 {(uint8_t *)"RSA8192|PRIMES_5", "RSA"},
135 {(uint8_t *)"SM2_256", "SM2"},
136 {(uint8_t *)"ECC224", "ECC"},
137 {(uint8_t *)"ECC256", "ECC"},
138 {(uint8_t *)"ECC384", "ECC"},
139 {(uint8_t *)"ECC521", "ECC"},
140 {(uint8_t *)"ECC_BrainPoolP160r1", "ECC"},
141 {(uint8_t *)"ECC_BrainPoolP160t1", "ECC"},
142 {(uint8_t *)"ECC_BrainPoolP192r1", "ECC"},
143 {(uint8_t *)"ECC_BrainPoolP192t1", "ECC"},
144 {(uint8_t *)"ECC_BrainPoolP224r1", "ECC"},
145 {(uint8_t *)"ECC_BrainPoolP224t1", "ECC"},
146 {(uint8_t *)"ECC_BrainPoolP256r1", "ECC"},
147 {(uint8_t *)"ECC_BrainPoolP256t1", "ECC"},
148 {(uint8_t *)"ECC_BrainPoolP320r1", "ECC"},
149 {(uint8_t *)"ECC_BrainPoolP320t1", "ECC"},
150 {(uint8_t *)"ECC_BrainPoolP384r1", "ECC"},
151 {(uint8_t *)"ECC_BrainPoolP384t1", "ECC"},
152 {(uint8_t *)"ECC_BrainPoolP512r1", "ECC"},
153 {(uint8_t *)"ECC_BrainPoolP512t1", "ECC"},
154 };
155
Rsa_PubkeyEncode(OH_CryptoAsymKeyGenerator * ctx,OH_CryptoPubKey * pubKey,OH_CryptoKeyPair ** dupKeyPair)156 static OH_Crypto_ErrCode Rsa_PubkeyEncode(OH_CryptoAsymKeyGenerator *ctx, OH_CryptoPubKey *pubKey, OH_CryptoKeyPair **dupKeyPair)
157 {
158 Crypto_DataBlob retBlob = { .data = nullptr, .len = 0 };
159 OH_Crypto_ErrCode ret = CRYPTO_SUCCESS;
160 ret = OH_CryptoPubKey_Encode(pubKey, CRYPTO_PEM, "PKCS1", &retBlob);
161 if (ret != CRYPTO_SUCCESS) {
162 return ret;
163 }
164
165 ret = OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_PEM, &retBlob, nullptr, dupKeyPair);
166 OH_Crypto_FreeDataBlob(&retBlob);
167 if (ret != CRYPTO_SUCCESS) {
168 return ret;
169 }
170 return ret;
171 }
172
Ecc_PubkeyEncode(OH_CryptoAsymKeyGenerator * ctx,OH_CryptoPubKey * pubKey,OH_CryptoKeyPair ** dupKeyPair)173 static OH_Crypto_ErrCode Ecc_PubkeyEncode(OH_CryptoAsymKeyGenerator *ctx, OH_CryptoPubKey *pubKey, OH_CryptoKeyPair **dupKeyPair)
174 {
175 Crypto_DataBlob retBlob = { .data = nullptr, .len = 0 };
176 OH_Crypto_ErrCode ret = CRYPTO_SUCCESS;
177 ret = OH_CryptoPubKey_Encode(pubKey, CRYPTO_DER, "X509|COMPRESSED", &retBlob);
178 if (ret != CRYPTO_SUCCESS) {
179 return ret;
180 }
181
182 ret = OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, &retBlob, nullptr, dupKeyPair);
183 OH_Crypto_FreeDataBlob(&retBlob);
184 if (ret != CRYPTO_SUCCESS) {
185 return ret;
186 }
187 return ret;
188 }
189
PubkeyEncode(OH_CryptoAsymKeyGenerator * ctx,OH_CryptoPubKey * pubKey,OH_CryptoKeyPair ** dupKeyPair)190 static OH_Crypto_ErrCode PubkeyEncode(OH_CryptoAsymKeyGenerator *ctx, OH_CryptoPubKey *pubKey, OH_CryptoKeyPair **dupKeyPair)
191 {
192 Crypto_DataBlob retBlob = { .data = nullptr, .len = 0 };
193 OH_Crypto_ErrCode ret = CRYPTO_SUCCESS;
194 ret = OH_CryptoPubKey_Encode(pubKey, CRYPTO_DER, nullptr, &retBlob);
195 if (ret != CRYPTO_SUCCESS) {
196 return ret;
197 }
198
199 ret = OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, &retBlob, nullptr, dupKeyPair);
200 OH_Crypto_FreeDataBlob(&retBlob);
201 if (ret != CRYPTO_SUCCESS) {
202 return ret;
203 }
204 return ret;
205 }
206
Ecc_GetEncode(OH_CryptoPubKey * pubKey,Crypto_DataBlob * value)207 static OH_Crypto_ErrCode Ecc_GetEncode(OH_CryptoPubKey *pubKey, Crypto_DataBlob *value)
208 {
209 OH_Crypto_ErrCode ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_FP_P_DATABLOB, value);
210 return ret;
211 }
212
Rsa_GetEncode(OH_CryptoPubKey * pubKey,Crypto_DataBlob * value)213 static OH_Crypto_ErrCode Rsa_GetEncode(OH_CryptoPubKey *pubKey, Crypto_DataBlob *value)
214 {
215 OH_Crypto_ErrCode ret = OH_CryptoPubKey_GetParam(pubKey, CRYPTO_RSA_N_DATABLOB, value);
216 return ret;
217 }
218
GetEncode(const char * name,OH_CryptoPubKey * pubKey,Crypto_DataBlob * value)219 static OH_Crypto_ErrCode GetEncode(const char *name, OH_CryptoPubKey *pubKey, Crypto_DataBlob *value)
220 {
221 CryptoAsymKey_ParamType item;
222 if (strcmp(name, "DH") == 0) {
223 item = CRYPTO_DH_P_DATABLOB;
224 } else if (strcmp(name, "Ed25519") == 0) {
225 item = CRYPTO_ED25519_PK_DATABLOB;
226 } else if (strcmp(name, "X25519") == 0) {
227 item = CRYPTO_X25519_PK_DATABLOB;
228 } else if (strcmp(name, "DSA") == 0) {
229 item = CRYPTO_DSA_P_DATABLOB;
230 } else {
231 item = CRYPTO_ECC_H_INT;
232 }
233
234 OH_Crypto_ErrCode ret = OH_CryptoPubKey_GetParam(pubKey, item, value);
235 return ret;
236 }
237
238 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkAsymKeyNapiTest, ASYMKEY_TEST, ::testing::ValuesIn(g_asymKeyData));
239
240 /**
241 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0100
242 * @tc.name OHCryptoFrameworkAsymKeyNapiTest/ASYMKEY_TEST.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0100/x
243 * @tc.desc algorithm is Asym Key
244 * @tc.size Medium
245 * @tc.type Func
246 * @tc.level Level0
247 */
248 HWTEST_P(ASYMKEY_TEST, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0100, TestSize.Level0)
249 {
250 AsymKeySpec AsymKeyData = GetParam();
251 OH_CryptoAsymKeyGenerator *ctx = nullptr;
252 OH_CryptoKeyPair *keyPair = nullptr;
253 OH_Crypto_ErrCode ret;
254
255 ret = OH_CryptoAsymKeyGenerator_Create((const char *)AsymKeyData.algName, &ctx);
256 ASSERT_EQ(ret, CRYPTO_SUCCESS);
257
258 ret = OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair);
259 ASSERT_EQ(ret, CRYPTO_SUCCESS);
260
261 const char *algoName = OH_CryptoAsymKeyGenerator_GetAlgoName(ctx);
262 EXPECT_NE(algoName, nullptr);
263
264 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
265 ASSERT_EQ(ret, CRYPTO_SUCCESS);
266
267 OH_CryptoKeyPair *dupKeyPair = nullptr;
268 Crypto_DataBlob dataBlob = { .data = nullptr, .len = 0 };
269 if (strcmp(AsymKeyData.name, "RSA") == 0) {
270 ret = Rsa_PubkeyEncode(ctx, pubKey, &dupKeyPair);
271 ASSERT_EQ(ret, CRYPTO_SUCCESS);
272 OH_CryptoPubKey *pubKey1 = OH_CryptoKeyPair_GetPubKey(dupKeyPair);
273 ASSERT_EQ(ret, CRYPTO_SUCCESS);
274 ret = Rsa_GetEncode(pubKey1, &dataBlob);
275 ASSERT_EQ(ret, CRYPTO_SUCCESS);
276 } else if (strcmp(AsymKeyData.name, "ECC") == 0) {
277 ret = Ecc_PubkeyEncode(ctx, pubKey, &dupKeyPair);
278 ASSERT_EQ(ret, CRYPTO_SUCCESS);
279 OH_CryptoPubKey *pubKey1 = OH_CryptoKeyPair_GetPubKey(dupKeyPair);
280 ASSERT_EQ(ret, CRYPTO_SUCCESS);
281 ret = Ecc_GetEncode(pubKey1, &dataBlob);
282 ASSERT_EQ(ret, CRYPTO_SUCCESS);
283 } else {
284 ret = PubkeyEncode(ctx, pubKey, &dupKeyPair);
285 ASSERT_EQ(ret, CRYPTO_SUCCESS);
286 OH_CryptoPubKey *pubKey1 = OH_CryptoKeyPair_GetPubKey(dupKeyPair);
287 ASSERT_EQ(ret, CRYPTO_SUCCESS);
288 ret = GetEncode(AsymKeyData.name, pubKey1, &dataBlob);
289 ASSERT_EQ(ret, CRYPTO_SUCCESS);
290 }
291
292 ASSERT_NE(dataBlob.data, nullptr);
293 ASSERT_NE(dataBlob.len, 0);
294 OH_Crypto_FreeDataBlob(&dataBlob);
295
296 OH_CryptoAsymKeyGenerator_Destroy(ctx);
297 OH_CryptoKeyPair_Destroy(keyPair);
298 OH_CryptoKeyPair_Destroy(dupKeyPair);
299 }
300
301 /**
302 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0200
303 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0200
304 * @tc.desc algorithm is Asym Key
305 * @tc.size Medium
306 * @tc.type Func
307 * @tc.level Level0
308 */
309 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0200, TestSize.Level0)
310 {
311 OH_CryptoAsymKeyGenerator *ctx = nullptr;
312 OH_Crypto_ErrCode ret;
313 ret = OH_CryptoAsymKeyGenerator_Create("SM9", &ctx);
314 EXPECT_NE(ret, CRYPTO_SUCCESS);
315 OH_CryptoAsymKeyGenerator_Destroy(ctx);
316 }
317
318 /**
319 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0300
320 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0300
321 * @tc.desc algorithm is Asym Key
322 * @tc.size Medium
323 * @tc.type Func
324 * @tc.level Level0
325 */
326 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0300, TestSize.Level0)
327 {
328 OH_CryptoAsymKeyGenerator *ctx = nullptr;
329 OH_Crypto_ErrCode ret;
330 ret = OH_CryptoAsymKeyGenerator_Create("SM", &ctx);
331 EXPECT_NE(ret, CRYPTO_SUCCESS);
332 OH_CryptoAsymKeyGenerator_Destroy(ctx);
333 }
334
335 /**
336 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0400
337 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0400
338 * @tc.desc algorithm is Asym Key
339 * @tc.size Medium
340 * @tc.type Func
341 * @tc.level Level0
342 */
343 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0400, TestSize.Level0)
344 {
345 OH_CryptoAsymKeyGenerator *ctx = nullptr;
346 OH_CryptoKeyPair *dupKeyPair = nullptr;
347 OH_Crypto_ErrCode ret;
348 ret = OH_CryptoAsymKeyGenerator_Create("ECC224", &ctx);
349 EXPECT_EQ(ret, CRYPTO_SUCCESS);
350 uint8_t array[] = {48, 50, 48, 16, 6, 7, 42, 134, 72, 206, 61, 2, 1, 6, 5, 43, 129, 4, 0,
351 33, 3, 30, 0, 2, 62, 18, 146, 41, 146, 160, 136, 78, 124, 38, 148, 1, 204, 24, 45, 172,
352 101, 234, 253, 74, 133, 28, 184, 168, 153, 170, 203, 134};
353 Crypto_DataBlob dataBlob = { .data = array, .len = sizeof(array) };
354 ret = OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, &dataBlob, nullptr, &dupKeyPair);
355 ASSERT_EQ(ret, CRYPTO_SUCCESS);
356 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(dupKeyPair);
357 ASSERT_NE(pubKey, nullptr);
358
359 OH_CryptoAsymKeyGenerator_Destroy(ctx);
360 OH_CryptoKeyPair_Destroy(dupKeyPair);
361 }
362
363 /**
364 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0500
365 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0500
366 * @tc.desc algorithm is Asym Key
367 * @tc.size Medium
368 * @tc.type Func
369 * @tc.level Level0
370 */
371 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0500, TestSize.Level0)
372 {
373 OH_CryptoAsymKeyGenerator *ctx = nullptr;
374 OH_CryptoKeyPair *dupKeyPair = nullptr;
375 OH_Crypto_ErrCode ret;
376 ret = OH_CryptoAsymKeyGenerator_Create("ECC521", &ctx);
377 EXPECT_EQ(ret, CRYPTO_SUCCESS);
378 uint8_t array[] = { 48, 90, 48, 20, 6, 7, 42, 134, 72, 206, 61, 2, 1, 6, 9, 43, 36, 3,
379 3, 2, 8, 1, 1, 7, 3, 66, 0, 4, 143, 39, 57, 249, 145, 50, 63, 222, 35, 70, 178, 121,
380 202, 154, 21, 146, 129, 75, 76, 63, 8, 195, 157, 111, 40, 217, 215, 148, 120, 224,
381 205, 82, 83, 92, 185, 21, 211, 184, 5, 19, 114, 33, 86, 85, 228, 123, 242, 206, 200,
382 98, 178, 184, 130, 35, 232, 45, 5, 202, 189, 11, 46, 163, 156, 152};
383 Crypto_DataBlob dataBlob = { .data = array, .len = sizeof(array) };
384 ret = OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, &dataBlob, nullptr, &dupKeyPair);
385 ASSERT_EQ(ret, CRYPTO_SUCCESS);
386 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(dupKeyPair);
387 ASSERT_NE(pubKey, nullptr);
388
389 OH_CryptoAsymKeyGenerator_Destroy(ctx);
390 OH_CryptoKeyPair_Destroy(dupKeyPair);
391 }
392
393 /**
394 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0600
395 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0600
396 * @tc.desc algorithm is Asym Key
397 * @tc.size Medium
398 * @tc.type Func
399 * @tc.level Level0
400 */
401 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0600, TestSize.Level0)
402 {
403 OH_CryptoAsymKeyGenerator *ctx = nullptr;
404 OH_CryptoKeyPair *keyPair = nullptr;
405 Crypto_DataBlob dsaPBlob = { .data = nullptr, .len = 0 };
406 Crypto_DataBlob dsaQBlob = { .data = nullptr, .len = 0 };
407 Crypto_DataBlob dsaGBlob = { .data = nullptr, .len = 0 };
408 Crypto_DataBlob dsaPKBlob = { .data = nullptr, .len = 0 };
409 Crypto_DataBlob dsaSKBlob = { .data = nullptr, .len = 0 };
410
411 ASSERT_EQ(OH_CryptoAsymKeyGenerator_Create((const char *)"DSA1024", &ctx), CRYPTO_SUCCESS);
412 ASSERT_EQ(OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair), CRYPTO_SUCCESS);
413 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
414
415 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DSA_P_DATABLOB, &dsaPBlob), CRYPTO_SUCCESS);
416 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DSA_Q_DATABLOB, &dsaQBlob), CRYPTO_SUCCESS);
417 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DSA_G_DATABLOB, &dsaGBlob), CRYPTO_SUCCESS);
418 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DSA_SK_DATABLOB, &dsaSKBlob), CRYPTO_INVALID_PARAMS);
419 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DSA_PK_DATABLOB, &dsaPKBlob), CRYPTO_SUCCESS);
420
421 OH_Crypto_FreeDataBlob(&dsaPBlob);
422 OH_Crypto_FreeDataBlob(&dsaQBlob);
423 OH_Crypto_FreeDataBlob(&dsaGBlob);
424 OH_Crypto_FreeDataBlob(&dsaPKBlob);
425 OH_Crypto_FreeDataBlob(&dsaSKBlob);
426 OH_CryptoAsymKeyGenerator_Destroy(ctx);
427 OH_CryptoKeyPair_Destroy(keyPair);
428 }
429
430 /**
431 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0700
432 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0700
433 * @tc.desc algorithm is Asym Key
434 * @tc.size Medium
435 * @tc.type Func
436 * @tc.level Level0
437 */
438 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0700, TestSize.Level0)
439 {
440 OH_CryptoAsymKeyGenerator *ctx = nullptr;
441 OH_CryptoKeyPair *keyPair = nullptr;
442 Crypto_DataBlob ecc_FP_PBlob = { .data = nullptr, .len = 0 };
443 Crypto_DataBlob ecc_ABlob = { .data = nullptr, .len = 0 };
444 Crypto_DataBlob ecc_BBlob = { .data = nullptr, .len = 0 };
445 Crypto_DataBlob ecc_G_XBlob = { .data = nullptr, .len = 0 };
446 Crypto_DataBlob ecc_G_YBlob = { .data = nullptr, .len = 0 };
447 Crypto_DataBlob ecc_NBlob = { .data = nullptr, .len = 0 };
448 Crypto_DataBlob ecc_SKBlob = { .data = nullptr, .len = 0 };
449 Crypto_DataBlob ecc_PK_XBlob = { .data = nullptr, .len = 0 };
450 Crypto_DataBlob ecc_PK_YBlob = { .data = nullptr, .len = 0 };
451 Crypto_DataBlob ecc_HBlob = { .data = nullptr, .len = 0 };
452 Crypto_DataBlob ecc_FIELD_TYPEBlob = { .data = nullptr, .len = 0 };
453 Crypto_DataBlob ecc_FELD_SIZEBlob = { .data = nullptr, .len = 0 };
454 Crypto_DataBlob ecc_NAMEBlob = { .data = nullptr, .len = 0 };
455
456 ASSERT_EQ(OH_CryptoAsymKeyGenerator_Create((const char *)"ECC224", &ctx), CRYPTO_SUCCESS);
457 ASSERT_EQ(OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair), CRYPTO_SUCCESS);
458 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
459 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_FP_P_DATABLOB, &ecc_FP_PBlob), CRYPTO_SUCCESS);
460 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_A_DATABLOB, &ecc_ABlob), CRYPTO_SUCCESS);
461 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_B_DATABLOB, &ecc_BBlob), CRYPTO_SUCCESS);
462 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_G_X_DATABLOB, &ecc_G_XBlob), CRYPTO_SUCCESS);
463 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_G_Y_DATABLOB, &ecc_G_YBlob), CRYPTO_SUCCESS);
464 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_N_DATABLOB, &ecc_NBlob), CRYPTO_SUCCESS);
465 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_H_INT, &ecc_HBlob), CRYPTO_SUCCESS);
466 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_SK_DATABLOB, &ecc_SKBlob), CRYPTO_INVALID_PARAMS);
467 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_PK_X_DATABLOB, &ecc_PK_XBlob), CRYPTO_SUCCESS);
468 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_PK_Y_DATABLOB, &ecc_PK_YBlob), CRYPTO_SUCCESS);
469 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_FIELD_TYPE_STR, &ecc_FIELD_TYPEBlob), CRYPTO_SUCCESS);
470 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_FIELD_SIZE_INT, &ecc_FELD_SIZEBlob), CRYPTO_SUCCESS);
471 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_CURVE_NAME_STR, &ecc_NAMEBlob), CRYPTO_SUCCESS);
472
473 OH_Crypto_FreeDataBlob(&ecc_FP_PBlob);
474 OH_Crypto_FreeDataBlob(&ecc_ABlob);
475 OH_Crypto_FreeDataBlob(&ecc_BBlob);
476 OH_Crypto_FreeDataBlob(&ecc_G_XBlob);
477 OH_Crypto_FreeDataBlob(&ecc_G_YBlob);
478 OH_Crypto_FreeDataBlob(&ecc_NBlob);
479 OH_Crypto_FreeDataBlob(&ecc_SKBlob);
480 OH_Crypto_FreeDataBlob(&ecc_PK_XBlob);
481 OH_Crypto_FreeDataBlob(&ecc_PK_YBlob);
482 OH_Crypto_FreeDataBlob(&ecc_HBlob);
483 OH_Crypto_FreeDataBlob(&ecc_NAMEBlob);
484 OH_Crypto_FreeDataBlob(&ecc_FIELD_TYPEBlob);
485 OH_Crypto_FreeDataBlob(&ecc_FELD_SIZEBlob);
486 OH_CryptoAsymKeyGenerator_Destroy(ctx);
487 OH_CryptoKeyPair_Destroy(keyPair);
488 }
489
490 /**
491 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0800
492 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0800
493 * @tc.desc algorithm is Asym Key
494 * @tc.size Medium
495 * @tc.type Func
496 * @tc.level Level0
497 */
498 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0800, TestSize.Level0)
499 {
500 OH_CryptoAsymKeyGenerator *ctx = nullptr;
501 OH_CryptoKeyPair *keyPair = nullptr;
502 Crypto_DataBlob rsaNBlob = { .data = nullptr, .len = 0 };
503 Crypto_DataBlob rsaDBlob = { .data = nullptr, .len = 0 };
504 Crypto_DataBlob rsaEBlob = { .data = nullptr, .len = 0 };
505
506 ASSERT_EQ(OH_CryptoAsymKeyGenerator_Create((const char *)"RSA512", &ctx), CRYPTO_SUCCESS);
507 ASSERT_EQ(OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair), CRYPTO_SUCCESS);
508 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
509 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_RSA_N_DATABLOB, &rsaNBlob), CRYPTO_SUCCESS);
510 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_RSA_D_DATABLOB, &rsaDBlob), CRYPTO_INVALID_PARAMS);
511 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_RSA_E_DATABLOB, &rsaEBlob), CRYPTO_SUCCESS);
512
513 OH_Crypto_FreeDataBlob(&rsaNBlob);
514 OH_Crypto_FreeDataBlob(&rsaDBlob);
515 OH_Crypto_FreeDataBlob(&rsaEBlob);
516 OH_CryptoAsymKeyGenerator_Destroy(ctx);
517 OH_CryptoKeyPair_Destroy(keyPair);
518 }
519
520 /**
521 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0900
522 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0900
523 * @tc.desc algorithm is Asym Key
524 * @tc.size Medium
525 * @tc.type Func
526 * @tc.level Level0
527 */
528 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_0900, TestSize.Level0)
529 {
530 OH_CryptoAsymKeyGenerator *ctx = nullptr;
531 OH_CryptoKeyPair *keyPair = nullptr;
532 Crypto_DataBlob dhPBlob = { .data = nullptr, .len = 0 };
533 Crypto_DataBlob dhGBlob = { .data = nullptr, .len = 0 };
534 Crypto_DataBlob dhLBlob = { .data = nullptr, .len = 0 };
535 Crypto_DataBlob dhSKBlob = { .data = nullptr, .len = 0 };
536 Crypto_DataBlob dhPKBlob = { .data = nullptr, .len = 0 };
537
538 ASSERT_EQ(OH_CryptoAsymKeyGenerator_Create((const char *)"DH_modp1536", &ctx), CRYPTO_SUCCESS);
539 ASSERT_EQ(OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair), CRYPTO_SUCCESS);
540 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
541 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DH_P_DATABLOB, &dhPBlob), CRYPTO_SUCCESS);
542 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DH_G_DATABLOB, &dhGBlob), CRYPTO_SUCCESS);
543 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DH_L_INT, &dhLBlob), CRYPTO_NOT_SUPPORTED);
544 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DH_SK_DATABLOB, &dhSKBlob), CRYPTO_INVALID_PARAMS);
545 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DH_PK_DATABLOB, &dhPKBlob), CRYPTO_SUCCESS);
546
547 OH_Crypto_FreeDataBlob(&dhPBlob);
548 OH_Crypto_FreeDataBlob(&dhGBlob);
549 OH_Crypto_FreeDataBlob(&dhLBlob);
550 OH_Crypto_FreeDataBlob(&dhSKBlob);
551 OH_Crypto_FreeDataBlob(&dhPKBlob);
552 OH_CryptoAsymKeyGenerator_Destroy(ctx);
553 OH_CryptoKeyPair_Destroy(keyPair);
554 }
555
556 /**
557 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1000
558 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1000
559 * @tc.desc algorithm is Asym Key
560 * @tc.size Medium
561 * @tc.type Func
562 * @tc.level Level0
563 */
564 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1000, TestSize.Level0)
565 {
566 OH_CryptoAsymKeyGenerator *ctx = nullptr;
567 OH_CryptoKeyPair *keyPair = nullptr;
568 Crypto_DataBlob ed25519SKBlob = { .data = nullptr, .len = 0 };
569 Crypto_DataBlob ed25519PKBlob = { .data = nullptr, .len = 0 };
570
571 ASSERT_EQ(OH_CryptoAsymKeyGenerator_Create((const char *)"Ed25519", &ctx), CRYPTO_SUCCESS);
572 ASSERT_EQ(OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair), CRYPTO_SUCCESS);
573 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
574 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ED25519_SK_DATABLOB, &ed25519SKBlob), CRYPTO_INVALID_PARAMS);
575 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ED25519_PK_DATABLOB, &ed25519PKBlob), CRYPTO_SUCCESS);
576
577 OH_Crypto_FreeDataBlob(&ed25519SKBlob);
578 OH_Crypto_FreeDataBlob(&ed25519PKBlob);
579 OH_CryptoAsymKeyGenerator_Destroy(ctx);
580 OH_CryptoKeyPair_Destroy(keyPair);
581 }
582
583 /**
584 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1100
585 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1100
586 * @tc.desc algorithm is Asym Key
587 * @tc.size Medium
588 * @tc.type Func
589 * @tc.level Level0
590 */
591 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1100, TestSize.Level0)
592 {
593 OH_CryptoAsymKeyGenerator *ctx = nullptr;
594 OH_CryptoKeyPair *keyPair = nullptr;
595 Crypto_DataBlob x25519SKBlob = { .data = nullptr, .len = 0 };
596 Crypto_DataBlob x25519PKBlob = { .data = nullptr, .len = 0 };
597
598 ASSERT_EQ(OH_CryptoAsymKeyGenerator_Create((const char *)"X25519", &ctx), CRYPTO_SUCCESS);
599 ASSERT_EQ(OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair), CRYPTO_SUCCESS);
600 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
601 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_X25519_SK_DATABLOB, &x25519SKBlob), CRYPTO_INVALID_PARAMS);
602 ASSERT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_X25519_PK_DATABLOB, &x25519PKBlob), CRYPTO_SUCCESS);
603
604 OH_Crypto_FreeDataBlob(&x25519SKBlob);
605 OH_Crypto_FreeDataBlob(&x25519PKBlob);
606 OH_CryptoAsymKeyGenerator_Destroy(ctx);
607 OH_CryptoKeyPair_Destroy(keyPair);
608 }
609
OHTEST_GenerateKeyPair(const char * algoName,const char * algKeyName)610 static OH_CryptoKeyPair *OHTEST_GenerateKeyPair(const char *algoName, const char *algKeyName)
611 {
612 OH_CryptoAsymKeyGenerator *ctx = nullptr;
613 OH_CryptoKeyPair *keyPair = nullptr;
614
615 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Create(algKeyName, &ctx), CRYPTO_SUCCESS);
616 if (strcmp(algoName, "RSA8192") == 0) {
617 Crypto_DataBlob pubKeyBlob = { .data = g_rsa8192pubKey, .len = sizeof(g_rsa8192pubKey) };
618 Crypto_DataBlob priKeyBlob = { .data = g_rsa8192priKey, .len = sizeof(g_rsa8192priKey) };
619 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, &pubKeyBlob, &priKeyBlob, &keyPair), CRYPTO_SUCCESS);
620 } else if (strcmp(algoName, "RSA4096") == 0) {
621 Crypto_DataBlob pubKeyBlob = { .data = g_rsa4096pubKey, .len = sizeof(g_rsa4096pubKey) };
622 Crypto_DataBlob priKeyBlob = { .data = g_rsa4096priKey, .len = sizeof(g_rsa4096priKey) };
623 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, &pubKeyBlob, &priKeyBlob, &keyPair), CRYPTO_SUCCESS);
624 } else if (strcmp(algoName, "RSA3072") == 0) {
625 Crypto_DataBlob pubKeyBlob = { .data = g_rsa3072pubKey, .len = sizeof(g_rsa3072pubKey) };
626 Crypto_DataBlob priKeyBlob = { .data = g_rsa3072priKey, .len = sizeof(g_rsa3072priKey) };
627 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, &pubKeyBlob, &priKeyBlob, &keyPair), CRYPTO_SUCCESS);
628 } else {
629 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair), CRYPTO_SUCCESS);
630 }
631
632 OH_CryptoAsymKeyGenerator_Destroy(ctx);
633 return keyPair;
634 }
635
OHTEST_ConvertKeyPair(const char * algoName,Crypto_EncodingType type,Crypto_DataBlob * privKey,Crypto_DataBlob * pubKey,Crypto_DataBlob * password)636 static OH_CryptoKeyPair *OHTEST_ConvertKeyPair(const char *algoName, Crypto_EncodingType type,
637 Crypto_DataBlob *privKey, Crypto_DataBlob *pubKey, Crypto_DataBlob *password)
638 {
639 OH_CryptoAsymKeyGenerator *ctx = nullptr;
640 OH_CryptoKeyPair *keyPair = nullptr;
641 OH_Crypto_ErrCode ret = CRYPTO_SUCCESS;
642
643 ret = OH_CryptoAsymKeyGenerator_Create(algoName, &ctx);
644 if (ret != CRYPTO_SUCCESS) {
645 goto EXIT;
646 }
647 if (password != nullptr && password->data != nullptr) {
648 ret = OH_CryptoAsymKeyGenerator_SetPassword(ctx, password->data, password->len);
649 if (ret != CRYPTO_SUCCESS) {
650 goto EXIT;
651 }
652 }
653 ret = OH_CryptoAsymKeyGenerator_Convert(ctx, type, pubKey, privKey, &keyPair);
654
655 EXIT:
656 OH_CryptoAsymKeyGenerator_Destroy(ctx);
657 return keyPair;
658 }
659
OHTEST_SetParam(Crypto_DataBlob * password,Crypto_DataBlob * cipher)660 static OH_CryptoPrivKeyEncodingParams *OHTEST_SetParam(Crypto_DataBlob *password, Crypto_DataBlob *cipher)
661 {
662 OH_CryptoPrivKeyEncodingParams *params = nullptr;
663 OH_Crypto_ErrCode ret = CRYPTO_SUCCESS;
664
665 ret = OH_CryptoPrivKeyEncodingParams_Create(¶ms);
666 if (params == nullptr || ret != CRYPTO_SUCCESS) {
667 goto EXIT;
668 }
669 ret = OH_CryptoPrivKeyEncodingParams_SetParam(params, CRYPTO_PRIVATE_KEY_ENCODING_PASSWORD_STR, password);
670 if (ret != CRYPTO_SUCCESS) {
671 OH_CryptoPrivKeyEncodingParams_Destroy(params);
672 params = nullptr;
673 goto EXIT;
674 }
675 ret = OH_CryptoPrivKeyEncodingParams_SetParam(params, CRYPTO_PRIVATE_KEY_ENCODING_SYMMETRIC_CIPHER_STR, cipher);
676 if (ret != CRYPTO_SUCCESS) {
677 OH_CryptoPrivKeyEncodingParams_Destroy(params);
678 params = nullptr;
679 goto EXIT;
680 }
681
682 EXIT:
683 return params;
684 }
685
686
687 AsymPrivKeySpec g_asymPrivKeyData[] = {
688 /* RSA privKey format not support der type，RSA privKey support der type */
689 /* RSA512*/
690 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 0
691 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 1
692 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 2
693 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 3
694 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 4
695 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 5
696 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 6
697 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 7
698 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 8
699 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 9
700 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 10
701 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 11
702 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 12
703 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 13
704 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 14
705 {"PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 15
706 /* RSA768 */
707 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
708 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
709 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
710 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
711 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
712 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
713 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
714 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
715 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
716 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
717 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
718 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
719 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
720 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
721 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
722 {"PKCS1", (uint8_t *)"RSA768", (uint8_t *)"RSA768|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
723 /* RSA1024 */
724 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
725 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
726 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
727 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
728 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
729 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
730 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
731 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
732 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
733 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
734 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
735 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
736 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
737 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
738 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
739 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
740 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
741 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
742 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
743 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
744 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
745 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
746 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
747 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
748 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
749 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
750 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
751 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
752 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
753 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
754 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
755 {"PKCS1", (uint8_t *)"RSA1024", (uint8_t *)"RSA1024|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
756 /* RSA2048 */
757 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
758 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
759 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
760 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
761 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
762 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
763 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
764 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
765 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
766 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
767 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
768 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
769 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
770 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
771 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
772 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
773 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
774 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
775 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
776 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
777 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
778 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
779 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
780 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
781 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
782 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
783 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
784 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
785 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
786 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
787 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
788 {"PKCS1", (uint8_t *)"RSA2048", (uint8_t *)"RSA2048|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
789 /* RSA3072 */
790 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
791 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
792 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
793 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
794 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
795 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
796 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
797 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
798 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
799 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
800 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
801 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
802 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
803 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
804 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
805 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
806 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
807 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
808 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
809 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
810 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
811 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
812 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
813 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
814 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
815 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
816 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
817 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
818 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
819 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
820 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
821 {"PKCS1", (uint8_t *)"RSA3072", (uint8_t *)"RSA3072|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
822 /* RSA4096 */
823 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
824 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
825 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
826 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
827 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
828 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
829 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
830 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
831 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
832 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
833 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
834 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
835 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
836 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
837 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
838 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
839 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
840 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
841 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
842 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
843 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
844 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
845 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
846 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
847 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
848 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
849 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
850 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
851 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
852 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
853 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
854 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
855 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
856 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
857 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
858 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
859 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
860 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
861 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
862 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
863 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
864 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
865 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
866 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
867 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
868 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
869 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
870 {"PKCS1", (uint8_t *)"RSA4096", (uint8_t *)"RSA4096|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
871 /* RSA8192 */
872 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
873 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
874 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
875 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
876 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
877 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
878 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
879 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
880 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
881 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
882 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
883 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
884 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
885 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
886 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
887 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_2", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
888 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
889 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
890 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
891 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
892 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
893 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
894 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
895 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
896 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
897 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
898 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
899 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
900 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
901 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
902 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
903 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_3", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
904 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
905 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
906 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
907 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
908 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
909 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
910 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
911 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
912 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
913 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
914 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
915 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
916 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
917 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
918 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
919 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_4", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
920 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 16
921 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 17
922 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 18
923 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 19
924 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 20
925 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 21
926 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 22
927 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 23
928 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 24
929 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 25
930 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 26
931 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_PEM}, // 27
932 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 28
933 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 29
934 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 30
935 {"PKCS1", (uint8_t *)"RSA8192", (uint8_t *)"RSA8192|PRIMES_5", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS1", CRYPTO_PEM}, // 31
936 /* ECC privKey not support pem、pkcs1 type */
937 /* ECC224 */
938 {"X509|UNCOMPRESSED", (uint8_t *)"ECC224", (uint8_t *)"ECC224", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
939 {"X509|UNCOMPRESSED", (uint8_t *)"ECC224", (uint8_t *)"ECC224", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
940 {"X509|UNCOMPRESSED", (uint8_t *)"ECC224", (uint8_t *)"ECC224", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
941 {"X509|UNCOMPRESSED", (uint8_t *)"ECC224", (uint8_t *)"ECC224", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
942 /* ECC256 */
943 {"X509|COMPRESSED", (uint8_t *)"ECC256", (uint8_t *)"ECC256", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
944 {"X509|COMPRESSED", (uint8_t *)"ECC256", (uint8_t *)"ECC256", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
945 {"X509|COMPRESSED", (uint8_t *)"ECC256", (uint8_t *)"ECC256", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
946 {"X509|COMPRESSED", (uint8_t *)"ECC256", (uint8_t *)"ECC256", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
947 /* ECC384 */
948 {"X509|COMPRESSED", (uint8_t *)"ECC384", (uint8_t *)"ECC384", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
949 {"X509|COMPRESSED", (uint8_t *)"ECC384", (uint8_t *)"ECC384", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
950 {"X509|COMPRESSED", (uint8_t *)"ECC384", (uint8_t *)"ECC384", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
951 {"X509|COMPRESSED", (uint8_t *)"ECC384", (uint8_t *)"ECC384", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
952 /* ECC521 */
953 {"X509|COMPRESSED", (uint8_t *)"ECC521", (uint8_t *)"ECC521", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
954 {"X509|COMPRESSED", (uint8_t *)"ECC521", (uint8_t *)"ECC521", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
955 {"X509|COMPRESSED", (uint8_t *)"ECC521", (uint8_t *)"ECC521", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
956 {"X509|COMPRESSED", (uint8_t *)"ECC521", (uint8_t *)"ECC521", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
957 /* ECC_BrainPoolP160r1 */
958 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP160r1", (uint8_t *)"ECC_BrainPoolP160r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
959 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP160r1", (uint8_t *)"ECC_BrainPoolP160r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
960 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP160r1", (uint8_t *)"ECC_BrainPoolP160r1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
961 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP160r1", (uint8_t *)"ECC_BrainPoolP160r1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
962 /* ECC_BrainPoolP160t1 */
963 {"X509|UNCOMPRESSED", (uint8_t *)"ECC_BrainPoolP160t1", (uint8_t *)"ECC_BrainPoolP160t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
964 {"X509|UNCOMPRESSED", (uint8_t *)"ECC_BrainPoolP160t1", (uint8_t *)"ECC_BrainPoolP160t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
965 {"X509|UNCOMPRESSED", (uint8_t *)"ECC_BrainPoolP160t1", (uint8_t *)"ECC_BrainPoolP160t1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
966 {"X509|UNCOMPRESSED", (uint8_t *)"ECC_BrainPoolP160t1", (uint8_t *)"ECC_BrainPoolP160t1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
967 /* ECC_BrainPoolP192r1 */
968 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP192r1", (uint8_t *)"ECC_BrainPoolP192r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
969 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP192r1", (uint8_t *)"ECC_BrainPoolP192r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
970 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP192r1", (uint8_t *)"ECC_BrainPoolP192r1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
971 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP192r1", (uint8_t *)"ECC_BrainPoolP192r1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
972 /* ECC_BrainPoolP192t1 */
973 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP192t1", (uint8_t *)"ECC_BrainPoolP192t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
974 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP192t1", (uint8_t *)"ECC_BrainPoolP192t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
975 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP192t1", (uint8_t *)"ECC_BrainPoolP192t1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
976 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP192t1", (uint8_t *)"ECC_BrainPoolP192t1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
977 /* ECC_BrainPoolP224r1 */
978 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP224r1", (uint8_t *)"ECC_BrainPoolP224r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
979 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP224r1", (uint8_t *)"ECC_BrainPoolP224r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
980 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP224r1", (uint8_t *)"ECC_BrainPoolP224r1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
981 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP224r1", (uint8_t *)"ECC_BrainPoolP224r1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
982 /* ECC_BrainPoolP224t1 */
983 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP224t1", (uint8_t *)"ECC_BrainPoolP224t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
984 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP224t1", (uint8_t *)"ECC_BrainPoolP224t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
985 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP224t1", (uint8_t *)"ECC_BrainPoolP224t1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
986 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP224t1", (uint8_t *)"ECC_BrainPoolP224t1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
987 /* ECC_BrainPoolP256r1 */
988 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP256r1", (uint8_t *)"ECC_BrainPoolP256r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
989 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP256r1", (uint8_t *)"ECC_BrainPoolP256r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
990 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP256r1", (uint8_t *)"ECC_BrainPoolP256r1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
991 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP256r1", (uint8_t *)"ECC_BrainPoolP256r1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
992 /* ECC_BrainPoolP256t1 */
993 {"X509|UNCOMPRESSED", (uint8_t *)"ECC_BrainPoolP256t1", (uint8_t *)"ECC_BrainPoolP256t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
994 {"X509|UNCOMPRESSED", (uint8_t *)"ECC_BrainPoolP256t1", (uint8_t *)"ECC_BrainPoolP256t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
995 {"X509|UNCOMPRESSED", (uint8_t *)"ECC_BrainPoolP256t1", (uint8_t *)"ECC_BrainPoolP256t1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
996 {"X509|UNCOMPRESSED", (uint8_t *)"ECC_BrainPoolP256t1", (uint8_t *)"ECC_BrainPoolP256t1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
997 /* ECC_BrainPoolP320r1 */
998 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP320r1", (uint8_t *)"ECC_BrainPoolP320r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
999 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP320r1", (uint8_t *)"ECC_BrainPoolP320r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
1000 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP320r1", (uint8_t *)"ECC_BrainPoolP320r1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
1001 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP320r1", (uint8_t *)"ECC_BrainPoolP320r1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1002 /* ECC_BrainPoolP320t1 */
1003 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP320t1", (uint8_t *)"ECC_BrainPoolP320t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1004 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP320t1", (uint8_t *)"ECC_BrainPoolP320t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
1005 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP320t1", (uint8_t *)"ECC_BrainPoolP320t1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
1006 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP320t1", (uint8_t *)"ECC_BrainPoolP320t1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1007 /* ECC_BrainPoolP384r1 */
1008 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP384r1", (uint8_t *)"ECC_BrainPoolP384r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1009 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP384r1", (uint8_t *)"ECC_BrainPoolP384r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
1010 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP384r1", (uint8_t *)"ECC_BrainPoolP384r1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
1011 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP384r1", (uint8_t *)"ECC_BrainPoolP384r1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1012 /* ECC_BrainPoolP384t1 */
1013 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP384t1", (uint8_t *)"ECC_BrainPoolP384t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1014 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP384t1", (uint8_t *)"ECC_BrainPoolP384t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
1015 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP384t1", (uint8_t *)"ECC_BrainPoolP384t1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
1016 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP384t1", (uint8_t *)"ECC_BrainPoolP384t1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1017 /* ECC_BrainPoolP512r1 */
1018 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP512r1", (uint8_t *)"ECC_BrainPoolP512r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1019 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP512r1", (uint8_t *)"ECC_BrainPoolP512r1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
1020 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP512r1", (uint8_t *)"ECC_BrainPoolP512r1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
1021 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP512r1", (uint8_t *)"ECC_BrainPoolP512r1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1022 /* ECC_BrainPoolP512t1 */
1023 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP512t1", (uint8_t *)"ECC_BrainPoolP512t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1024 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP512t1", (uint8_t *)"ECC_BrainPoolP512t1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
1025 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP512t1", (uint8_t *)"ECC_BrainPoolP512t1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
1026 {"X509|COMPRESSED", (uint8_t *)"ECC_BrainPoolP512t1", (uint8_t *)"ECC_BrainPoolP512t1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1027 /* ECC_Secp256k1 */
1028 {"X509|COMPRESSED", (uint8_t *)"ECC_Secp256k1", (uint8_t *)"ECC_Secp256k1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-192-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1029 {"X509|COMPRESSED", (uint8_t *)"ECC_Secp256k1", (uint8_t *)"ECC_Secp256k1", (uint8_t *)"0123456789", 10, (uint8_t *)"AES-256-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_DER}, // 18
1030 {"X509|COMPRESSED", (uint8_t *)"ECC_Secp256k1", (uint8_t *)"ECC_Secp256k1", (uint8_t *)"0123456789", 10, (uint8_t *)"DES-EDE3-CBC", 12, (uint8_t *)"PKCS8", CRYPTO_DER}, // 19
1031 {"X509|COMPRESSED", (uint8_t *)"ECC_Secp256k1", (uint8_t *)"ECC_Secp256k1", nullptr, 0, nullptr, 0, (uint8_t *)"PKCS8", CRYPTO_DER}, // 17
1032 /* DSA not format not support pem、der */
1033 {nullptr, (uint8_t *)"DSA1024", (uint8_t *)"DSA1024", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1034 {nullptr, (uint8_t *)"DSA2048", (uint8_t *)"DSA2048", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1035 {nullptr, (uint8_t *)"DSA3072", (uint8_t *)"DSA3072", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1036 /* SM2 not format not support pem、der */
1037 {nullptr, (uint8_t *)"SM2_256", (uint8_t *)"SM2_256", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1038 /* Ed25519 not format not support pem、der */
1039 {nullptr, (uint8_t *)"Ed25519", (uint8_t *)"Ed25519", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1040 /* X25519 not format not support pem、der */
1041 {nullptr, (uint8_t *)"X25519", (uint8_t *)"X25519", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1042 /* DH not format not support pem、der */
1043 {nullptr, (uint8_t *)"DH_modp1536", (uint8_t *)"DH_modp1536", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1044 {nullptr, (uint8_t *)"DH_modp2048", (uint8_t *)"DH_modp2048", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1045 {nullptr, (uint8_t *)"DH_modp3072", (uint8_t *)"DH_modp3072", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1046 {nullptr, (uint8_t *)"DH_modp4096", (uint8_t *)"DH_modp4096", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1047 {nullptr, (uint8_t *)"DH_modp6144", (uint8_t *)"DH_modp6144", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1048 {nullptr, (uint8_t *)"DH_modp8192", (uint8_t *)"DH_modp8192", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1049 {nullptr, (uint8_t *)"DH_ffdhe2048", (uint8_t *)"DH_ffdhe2048", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1050 {nullptr, (uint8_t *)"DH_ffdhe3072", (uint8_t *)"DH_ffdhe3072", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1051 {nullptr, (uint8_t *)"DH_ffdhe4096", (uint8_t *)"DH_ffdhe4096", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1052 {nullptr, (uint8_t *)"DH_ffdhe6144", (uint8_t *)"DH_ffdhe6144", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1053 {nullptr, (uint8_t *)"DH_ffdhe8192", (uint8_t *)"DH_ffdhe8192", nullptr, 0, nullptr, 0, nullptr, CRYPTO_DER}, // 17
1054 };
1055
1056 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkAsymKeyNapiTest, ASYMKEY_PRIV_TEST, ::testing::ValuesIn(g_asymPrivKeyData));
1057
1058 /**
1059 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1200
1060 * @tc.name OHCryptoFrameworkAsymKeyNapiTest/ASYMKEY_PRIV_TEST.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1200/x
1061 * @tc.desc algorithm is Asym Key
1062 * @tc.size Medium
1063 * @tc.type Func
1064 * @tc.level Level0
1065 */
1066 HWTEST_P(ASYMKEY_PRIV_TEST, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1200, TestSize.Level0)
1067 {
1068 AsymPrivKeySpec asymInfo = GetParam();
1069 Crypto_DataBlob pwBlob = {.data = asymInfo.password, .len = asymInfo.pwLen};
1070 Crypto_DataBlob cipherBlob = {.data = asymInfo.cipher, .len = asymInfo.cipherLen};
1071 Crypto_DataBlob out = { .data = nullptr, .len = 0 };
1072 Crypto_DataBlob outPub = { .data = nullptr, .len = 0 };
1073 Crypto_DataBlob new_out = { .data = nullptr, .len = 0 };
1074 OH_CryptoPrivKeyEncodingParams *params = nullptr;
1075 uint8_t *type = nullptr;
1076
1077 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair((const char *)asymInfo.algName, (const char *)asymInfo.algKeyName);
1078 ASSERT_TRUE(keyPair != nullptr);
1079 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1080 ASSERT_TRUE(privKey != nullptr);
1081 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1082 ASSERT_TRUE(pubKey != nullptr);
1083 if (asymInfo.password != nullptr) {
1084 params = OHTEST_SetParam(&pwBlob, &cipherBlob);
1085 ASSERT_TRUE(params != nullptr);
1086 }
1087 type = asymInfo.type ? asymInfo.type : nullptr;
1088 ASSERT_EQ(OH_CryptoPrivKey_Encode(privKey, asymInfo.encoding, (const char *)type, params, &out), CRYPTO_SUCCESS);
1089 ASSERT_EQ(OH_CryptoPubKey_Encode(pubKey, asymInfo.encoding, asymInfo.pubType, &outPub), CRYPTO_SUCCESS);
1090 OH_CryptoKeyPair *new_keyPair = OHTEST_ConvertKeyPair((const char *)asymInfo.algName, asymInfo.encoding, &out, &outPub, &pwBlob);
1091 ASSERT_TRUE(new_keyPair != nullptr);
1092 OH_CryptoPrivKey *new_privKey = OH_CryptoKeyPair_GetPrivKey(new_keyPair);
1093 ASSERT_TRUE(new_privKey != nullptr);
1094 ASSERT_EQ(OH_CryptoPrivKey_Encode(new_privKey, asymInfo.encoding, (const char *)type, params, &new_out), CRYPTO_SUCCESS);
1095 EXPECT_TRUE(new_out.len == out.len);
1096
1097 OH_Crypto_FreeDataBlob(&out);
1098 OH_Crypto_FreeDataBlob(&new_out);
1099 OH_Crypto_FreeDataBlob(&outPub);
1100 OH_CryptoPrivKeyEncodingParams_Destroy(params);
1101 OH_CryptoKeyPair_Destroy(keyPair);
1102 OH_CryptoKeyPair_Destroy(new_keyPair);
1103 }
1104
OHTEST_GenEcCommonParamsSpec(OH_CryptoPubKey * pubKey)1105 static OH_CryptoAsymKeySpec *OHTEST_GenEcCommonParamsSpec(OH_CryptoPubKey *pubKey)
1106 {
1107 OH_CryptoAsymKeySpec *specCtx = nullptr;
1108 Crypto_DataBlob fp = { .data = nullptr, .len = 0};
1109 Crypto_DataBlob a = { .data = nullptr, .len = 0};
1110 Crypto_DataBlob b = { .data = nullptr, .len = 0};
1111 Crypto_DataBlob g_x = { .data = nullptr, .len = 0};
1112 Crypto_DataBlob g_y = { .data = nullptr, .len = 0};
1113 Crypto_DataBlob n = { .data = nullptr, .len = 0};
1114 Crypto_DataBlob h = { .data = nullptr, .len = 0};
1115 Crypto_DataBlob gh = { .data = nullptr, .len = 0};
1116
1117 EXPECT_EQ(OH_CryptoAsymKeySpec_Create("ECC", CRYPTO_ASYM_KEY_COMMON_PARAMS_SPEC, &specCtx), CRYPTO_SUCCESS);
1118 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_FP_P_DATABLOB, &fp), CRYPTO_SUCCESS);
1119 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_A_DATABLOB, &a), CRYPTO_SUCCESS);
1120 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_B_DATABLOB, &b), CRYPTO_SUCCESS);
1121 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_G_X_DATABLOB, &g_x), CRYPTO_SUCCESS);
1122 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_G_Y_DATABLOB, &g_y), CRYPTO_SUCCESS);
1123 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_N_DATABLOB, &n), CRYPTO_SUCCESS);
1124 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_H_INT, &h), CRYPTO_SUCCESS);
1125 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_ECC_FP_P_DATABLOB, &fp), CRYPTO_SUCCESS);
1126 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_ECC_A_DATABLOB, &a), CRYPTO_SUCCESS);
1127 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_ECC_B_DATABLOB, &b), CRYPTO_SUCCESS);
1128 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_ECC_G_X_DATABLOB, &g_x), CRYPTO_SUCCESS);
1129 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_ECC_G_Y_DATABLOB, &g_y), CRYPTO_SUCCESS);
1130 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_ECC_N_DATABLOB, &n), CRYPTO_SUCCESS);
1131 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_ECC_H_INT, &h), CRYPTO_SUCCESS);
1132 EXPECT_EQ(OH_CryptoAsymKeySpec_GetParam(specCtx, CRYPTO_ECC_H_INT, &gh), CRYPTO_SUCCESS);
1133
1134 OH_Crypto_FreeDataBlob(&g_x);
1135 OH_Crypto_FreeDataBlob(&g_y);
1136 OH_Crypto_FreeDataBlob(&a);
1137 OH_Crypto_FreeDataBlob(&b);
1138 OH_Crypto_FreeDataBlob(&n);
1139 OH_Crypto_FreeDataBlob(&h);
1140 OH_Crypto_FreeDataBlob(&gh);
1141 OH_Crypto_FreeDataBlob(&fp);
1142 return specCtx;
1143 }
1144
OHTEST_GenDhCommonParamsSpec(OH_CryptoPubKey * pubKey)1145 static OH_CryptoAsymKeySpec *OHTEST_GenDhCommonParamsSpec(OH_CryptoPubKey *pubKey)
1146 {
1147 OH_CryptoAsymKeySpec *specCtx = nullptr;
1148 Crypto_DataBlob p = { .data = nullptr, .len = 0};
1149 Crypto_DataBlob g = { .data = nullptr, .len = 0};
1150 Crypto_DataBlob l = { .data = nullptr, .len = 0};
1151
1152 EXPECT_EQ(OH_CryptoAsymKeySpec_Create("DH", CRYPTO_ASYM_KEY_COMMON_PARAMS_SPEC, &specCtx), CRYPTO_SUCCESS);
1153 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DH_P_DATABLOB, &p), CRYPTO_SUCCESS);
1154 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DH_G_DATABLOB, &g), CRYPTO_SUCCESS);
1155 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DH_L_INT, &l), CRYPTO_NOT_SUPPORTED);
1156 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DH_P_DATABLOB, &p), CRYPTO_SUCCESS);
1157 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DH_G_DATABLOB, &g), CRYPTO_SUCCESS);
1158 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DH_L_INT, &l), CRYPTO_PARAMETER_CHECK_FAILED);
1159
1160 OH_Crypto_FreeDataBlob(&g);
1161 OH_Crypto_FreeDataBlob(&p);
1162 OH_Crypto_FreeDataBlob(&l);
1163 return specCtx;
1164 }
1165
1166 CommonECCSpec g_commonEccSpec[] = {
1167 {"ECC224", "ECC", "NID_secp224r1", false},
1168 {"ECC256", "ECC", "NID_X9_62_prime256v1", false},
1169 {"ECC384", "ECC", "NID_secp384r1", false},
1170 {"ECC521", "ECC", "NID_secp521r1", false},
1171 {"ECC_BrainPoolP160r1", "ECC", "NID_brainpoolP160r1", false},
1172 {"ECC_BrainPoolP160t1", "ECC", "NID_brainpoolP160t1", false},
1173 {"ECC_BrainPoolP192r1", "ECC", "NID_brainpoolP192r1", false},
1174 {"ECC_BrainPoolP192t1", "ECC", "NID_brainpoolP192t1", false},
1175 {"ECC_BrainPoolP224r1", "ECC", "NID_brainpoolP224r1", false},
1176 {"ECC_BrainPoolP224t1", "ECC", "NID_brainpoolP224t1", false},
1177 {"ECC_BrainPoolP256r1", "ECC", "NID_brainpoolP256r1", false},
1178 {"ECC_BrainPoolP256t1", "ECC", "NID_brainpoolP256t1", false},
1179 {"ECC_BrainPoolP320r1", "ECC", "NID_brainpoolP320r1", false},
1180 {"ECC_BrainPoolP320t1", "ECC", "NID_brainpoolP320t1", false},
1181 {"ECC_BrainPoolP384r1", "ECC", "NID_brainpoolP384r1", false},
1182 {"ECC_BrainPoolP384t1", "ECC", "NID_brainpoolP384t1", false},
1183 {"ECC_BrainPoolP512r1", "ECC", "NID_brainpoolP512r1", false},
1184 {"ECC_BrainPoolP512t1", "ECC", "NID_brainpoolP512t1", false},
1185 {"ECC_Secp256k1", "ECC", "NID_secp256k1", false},
1186 {"ECC224", "ECC", "NID_secp224r1", true},
1187 {"ECC256", "ECC", "NID_X9_62_prime256v1", true},
1188 {"ECC384", "ECC", "NID_secp384r1", true},
1189 {"ECC521", "ECC", "NID_secp521r1", true},
1190 {"ECC_BrainPoolP160r1", "ECC", "NID_brainpoolP160r1", true},
1191 {"ECC_BrainPoolP160t1", "ECC", "NID_brainpoolP160t1", true},
1192 {"ECC_BrainPoolP192r1", "ECC", "NID_brainpoolP192r1", true},
1193 {"ECC_BrainPoolP192t1", "ECC", "NID_brainpoolP192t1", true},
1194 {"ECC_BrainPoolP224r1", "ECC", "NID_brainpoolP224r1", true},
1195 {"ECC_BrainPoolP224t1", "ECC", "NID_brainpoolP224t1", true},
1196 {"ECC_BrainPoolP256r1", "ECC", "NID_brainpoolP256r1", true},
1197 {"ECC_BrainPoolP256t1", "ECC", "NID_brainpoolP256t1", true},
1198 {"ECC_BrainPoolP320r1", "ECC", "NID_brainpoolP320r1", true},
1199 {"ECC_BrainPoolP320t1", "ECC", "NID_brainpoolP320t1", true},
1200 {"ECC_BrainPoolP384r1", "ECC", "NID_brainpoolP384r1", true},
1201 {"ECC_BrainPoolP384t1", "ECC", "NID_brainpoolP384t1", true},
1202 {"ECC_BrainPoolP512r1", "ECC", "NID_brainpoolP512r1", true},
1203 {"ECC_BrainPoolP512t1", "ECC", "NID_brainpoolP512t1", true},
1204 {"ECC_Secp256k1", "ECC", "NID_secp256k1", true},
1205 {"SM2_256", "SM2", "NID_sm2", false},
1206 {"SM2_256", "SM2", "NID_sm2", true},
1207 };
1208
1209 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkAsymKeyNapiTest, ASYMKEY_ECC_KEYPAIR_TEST, ::testing::ValuesIn(g_commonEccSpec));
1210
1211 /**
1212 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1300
1213 * @tc.name OHCryptoFrameworkAsymKeyNapiTest/ASYMKEY_COMMON_TEST.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1300
1214 * @tc.desc algorithm is Asym Key
1215 * @tc.size Medium
1216 * @tc.type Func
1217 * @tc.level Level0
1218 */
1219 HWTEST_P(ASYMKEY_ECC_KEYPAIR_TEST, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1300, TestSize.Level0)
1220 {
1221 CommonECCSpec asymInfo = GetParam();
1222 const char *algoName = asymInfo.algoName;
1223 const char *curve = asymInfo.curve;
1224 const char *curveNid = asymInfo.curveNid;
1225 OH_CryptoAsymKeySpec *commonSpec = nullptr;
1226 OH_CryptoAsymKeySpec *specCtx = nullptr;
1227 OH_CryptoAsymKeyGeneratorWithSpec *generator = nullptr;
1228 OH_CryptoKeyPair *newKeyPair = nullptr;
1229 Crypto_DataBlob sk = { .data = nullptr, .len = 0};
1230 Crypto_DataBlob pk_x = { .data = nullptr, .len = 0};
1231 Crypto_DataBlob pk_y = { .data = nullptr, .len = 0};
1232 Crypto_DataBlob new_sk = { .data = nullptr, .len = 0};
1233 Crypto_DataBlob new_pk_x = { .data = nullptr, .len = 0};
1234 Crypto_DataBlob new_pk_y = { .data = nullptr, .len = 0};
1235
1236 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair(algoName, algoName);
1237 EXPECT_TRUE(keyPair != nullptr);
1238 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1239 EXPECT_TRUE(privKey != nullptr);
1240 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1241 EXPECT_TRUE(pubKey != nullptr);
1242 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_PK_X_DATABLOB, &pk_x), CRYPTO_SUCCESS);
1243 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_PK_Y_DATABLOB, &pk_y), CRYPTO_SUCCESS);
1244 EXPECT_EQ(OH_CryptoPrivKey_GetParam(privKey, CRYPTO_ECC_SK_DATABLOB, &sk), CRYPTO_SUCCESS);
1245 EXPECT_EQ(OH_CryptoAsymKeySpec_Create(curve, CRYPTO_ASYM_KEY_KEY_PAIR_SPEC, &specCtx), CRYPTO_SUCCESS);
1246 if (asymInfo.isGetCommonSpec) {
1247 commonSpec = OHTEST_GenEcCommonParamsSpec(pubKey);
1248 } else {
1249 EXPECT_EQ(OH_CryptoAsymKeySpec_GenEcCommonParamsSpec(curveNid, &commonSpec), CRYPTO_SUCCESS);
1250 }
1251 EXPECT_TRUE(commonSpec != nullptr);
1252 EXPECT_EQ(OH_CryptoAsymKeySpec_SetCommonParamsSpec(specCtx, commonSpec), CRYPTO_SUCCESS);
1253 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_ECC_SK_DATABLOB, &sk), CRYPTO_SUCCESS);
1254 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_ECC_PK_X_DATABLOB, &pk_x), CRYPTO_SUCCESS);
1255 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_ECC_PK_Y_DATABLOB, &pk_y), CRYPTO_SUCCESS);
1256 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_Create(specCtx, &generator), CRYPTO_SUCCESS);
1257 EXPECT_TRUE(generator != nullptr);
1258 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_GenKeyPair(generator, &newKeyPair), CRYPTO_SUCCESS);
1259 EXPECT_TRUE(newKeyPair != nullptr);
1260 OH_CryptoPrivKey *new_privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1261 EXPECT_TRUE(new_privKey != nullptr);
1262 OH_CryptoPubKey *new_pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1263 EXPECT_TRUE(new_pubKey != nullptr);
1264 EXPECT_EQ(OH_CryptoPubKey_GetParam(new_pubKey, CRYPTO_ECC_PK_X_DATABLOB, &new_pk_x), CRYPTO_SUCCESS);
1265 EXPECT_EQ(OH_CryptoPubKey_GetParam(new_pubKey, CRYPTO_ECC_PK_Y_DATABLOB, &new_pk_y), CRYPTO_SUCCESS);
1266 EXPECT_EQ(OH_CryptoPrivKey_GetParam(new_privKey, CRYPTO_ECC_SK_DATABLOB, &new_sk), CRYPTO_SUCCESS);
1267 EXPECT_TRUE(memcmp(new_pk_x.data, pk_x.data, new_pk_x.len) == 0);
1268 EXPECT_TRUE(memcmp(new_pk_y.data, pk_y.data, new_pk_y.len) == 0);
1269 EXPECT_TRUE(memcmp(new_sk.data, sk.data, new_sk.len) == 0);
1270
1271 OH_Crypto_FreeDataBlob(&sk);
1272 OH_Crypto_FreeDataBlob(&pk_x);
1273 OH_Crypto_FreeDataBlob(&pk_y);
1274 OH_Crypto_FreeDataBlob(&new_sk);
1275 OH_Crypto_FreeDataBlob(&new_pk_x);
1276 OH_Crypto_FreeDataBlob(&new_pk_y);
1277 OH_CryptoKeyPair_Destroy(keyPair);
1278 OH_CryptoKeyPair_Destroy(newKeyPair);
1279 OH_CryptoAsymKeyGeneratorWithSpec_Destroy(generator);
1280 OH_CryptoAsymKeySpec_Destroy(specCtx);
1281 OH_CryptoAsymKeySpec_Destroy(commonSpec);
1282 }
1283
1284 CommonDHSpec g_commonDhSpec[] = {
1285 {"DH_modp1536", "DH", 0, 0, false},
1286 {"DH_modp2048", "DH", 0, 0, false},
1287 {"DH_modp3072", "DH", 0, 0, false},
1288 {"DH_modp4096", "DH", 0, 0, false},
1289 {"DH_modp6144", "DH", 0, 0, false},
1290 {"DH_modp8192", "DH", 0, 0, false},
1291 {"DH_ffdhe2048", "DH", 0, 0, false},
1292 {"DH_ffdhe3072", "DH", 0, 0, false},
1293 {"DH_ffdhe4096", "DH", 0, 0, false},
1294 {"DH_ffdhe6144", "DH", 0, 0, false},
1295 {"DH_ffdhe8192", "DH", 0, 0, false},
1296 {"DH_modp1536", "DH", 1536, 200, true},
1297 {"DH_modp2048", "DH", 2048, 1024, true},
1298 {"DH_modp3072", "DH", 3072, 1536, true},
1299 {"DH_modp4096", "DH", 4096, 1536, true},
1300 {"DH_modp6144", "DH", 6144, 1536, true},
1301 {"DH_modp8192", "DH", 8192, 1536, true},
1302 {"DH_ffdhe2048", "DH", 2048, 1536, true},
1303 {"DH_ffdhe3072", "DH", 3072, 1536, true},
1304 {"DH_ffdhe4096", "DH", 4096, 1536, true},
1305 {"DH_ffdhe6144", "DH", 6144, 1536, true},
1306 {"DH_ffdhe8192", "DH", 8192, 1536, true},
1307 };
1308
1309 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkAsymKeyNapiTest, ASYMKEY_DH_KEYPAIR_TEST, ::testing::ValuesIn(g_commonDhSpec));
1310
1311 /**
1312 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1400
1313 * @tc.name OHCryptoFrameworkAsymKeyNapiTest/ASYMKEY_DH_KEYPAIR_TEST.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1400
1314 * @tc.desc algorithm is Asym Key
1315 * @tc.size Medium
1316 * @tc.type Func
1317 * @tc.level Level0
1318 */
1319 HWTEST_P(ASYMKEY_DH_KEYPAIR_TEST, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1400, TestSize.Level0)
1320 {
1321 CommonDHSpec asymInfo = GetParam();
1322 const char *algoName = asymInfo.algoName;
1323 const char *curve = asymInfo.curve;
1324 OH_CryptoAsymKeySpec *commonSpec = nullptr;
1325 OH_CryptoAsymKeySpec *specCtx = nullptr;
1326 OH_CryptoAsymKeyGeneratorWithSpec *generator = nullptr;
1327 OH_CryptoKeyPair *newKeyPair = nullptr;
1328 Crypto_DataBlob sk = { .data = nullptr, .len = 0};
1329 Crypto_DataBlob pk = { .data = nullptr, .len = 0};
1330 Crypto_DataBlob new_sk = { .data = nullptr, .len = 0};
1331 Crypto_DataBlob new_pk = { .data = nullptr, .len = 0};
1332
1333 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair(algoName, algoName);
1334 EXPECT_TRUE(keyPair != nullptr);
1335 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1336 EXPECT_TRUE(privKey != nullptr);
1337 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1338 EXPECT_TRUE(pubKey != nullptr);
1339 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DH_PK_DATABLOB, &pk), CRYPTO_SUCCESS);
1340 EXPECT_EQ(OH_CryptoPrivKey_GetParam(privKey, CRYPTO_DH_SK_DATABLOB, &sk), CRYPTO_SUCCESS);
1341 EXPECT_EQ(OH_CryptoAsymKeySpec_Create(curve, CRYPTO_ASYM_KEY_KEY_PAIR_SPEC, &specCtx), CRYPTO_SUCCESS);
1342 if (!asymInfo.isGetCommonSpec) {
1343 commonSpec = OHTEST_GenDhCommonParamsSpec(pubKey);
1344 } else {
1345 EXPECT_EQ(OH_CryptoAsymKeySpec_GenDhCommonParamsSpec(asymInfo.pLen, asymInfo.skLen, &commonSpec), CRYPTO_SUCCESS);
1346 }
1347 EXPECT_TRUE(commonSpec != nullptr);
1348 EXPECT_EQ(OH_CryptoAsymKeySpec_SetCommonParamsSpec(specCtx, commonSpec), CRYPTO_SUCCESS);
1349 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DH_SK_DATABLOB, &sk), CRYPTO_SUCCESS);
1350 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DH_PK_DATABLOB, &pk), CRYPTO_SUCCESS);
1351 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_Create(specCtx, &generator), CRYPTO_SUCCESS);
1352 EXPECT_TRUE(generator != nullptr);
1353 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_GenKeyPair(generator, &newKeyPair), CRYPTO_SUCCESS);
1354 EXPECT_TRUE(newKeyPair != nullptr);
1355 OH_CryptoPrivKey *new_privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1356 EXPECT_TRUE(new_privKey != nullptr);
1357 OH_CryptoPubKey *new_pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1358 EXPECT_TRUE(new_pubKey != nullptr);
1359 EXPECT_EQ(OH_CryptoPubKey_GetParam(new_pubKey, CRYPTO_DH_PK_DATABLOB, &new_pk), CRYPTO_SUCCESS);
1360 EXPECT_EQ(OH_CryptoPrivKey_GetParam(new_privKey, CRYPTO_DH_SK_DATABLOB, &new_sk), CRYPTO_SUCCESS);
1361 EXPECT_TRUE(memcmp(new_pk.data, pk.data, new_pk.len) == 0);
1362 EXPECT_TRUE(memcmp(new_sk.data, sk.data, new_sk.len) == 0);
1363
1364 OH_Crypto_FreeDataBlob(&sk);
1365 OH_Crypto_FreeDataBlob(&pk);
1366 OH_Crypto_FreeDataBlob(&new_sk);
1367 OH_Crypto_FreeDataBlob(&new_pk);
1368 OH_CryptoKeyPair_Destroy(keyPair);
1369 OH_CryptoKeyPair_Destroy(newKeyPair);
1370 OH_CryptoAsymKeyGeneratorWithSpec_Destroy(generator);
1371 OH_CryptoAsymKeySpec_Destroy(specCtx);
1372 OH_CryptoAsymKeySpec_Destroy(commonSpec);
1373 }
1374
1375 CommonRSASpec g_commonRsaSpec[] = {
1376 {"RSA", "RSA512", "RSA512|PRIMES_2"},
1377 {"RSA", "RSA768", "RSA768|PRIMES_2"},
1378 {"RSA", "RSA1024", "RSA1024|PRIMES_2"},
1379 {"RSA", "RSA1024", "RSA1024|PRIMES_3"},
1380 {"RSA", "RSA2048", "RSA2048|PRIMES_2"},
1381 {"RSA", "RSA2048", "RSA2048|PRIMES_3"},
1382 {"RSA", "RSA3072", "RSA3072|PRIMES_2"},
1383 {"RSA", "RSA3072", "RSA3072|PRIMES_3"},
1384 {"RSA", "RSA4096", "RSA4096|PRIMES_2"},
1385 {"RSA", "RSA4096", "RSA4096|PRIMES_3"},
1386 {"RSA", "RSA4096", "RSA4096|PRIMES_4"},
1387 {"RSA", "RSA8192", "RSA8192|PRIMES_2"},
1388 {"RSA", "RSA8192", "RSA8192|PRIMES_3"},
1389 {"RSA", "RSA8192", "RSA8192|PRIMES_4"},
1390 {"RSA", "RSA8192", "RSA8192|PRIMES_5"},
1391 };
1392
1393 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkAsymKeyNapiTest, ASYMKEY_RSA_KEYPAIR_TEST, ::testing::ValuesIn(g_commonRsaSpec));
1394
1395 /**
1396 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1500
1397 * @tc.name OHCryptoFrameworkAsymKeyNapiTest/ASYMKEY_RSA_KEYPAIR_TEST.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1500
1398 * @tc.desc algorithm is Asym Key
1399 * @tc.size Medium
1400 * @tc.type Func
1401 * @tc.level Level0
1402 */
1403 HWTEST_P(ASYMKEY_RSA_KEYPAIR_TEST, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1500, TestSize.Level0)
1404 {
1405 CommonRSASpec asymInfo = GetParam();
1406 const char *algoName = asymInfo.algoName;
1407 const char *specName = asymInfo.specName;
1408 const char *algoKeyName = asymInfo.algoKeyName;
1409 OH_CryptoAsymKeySpec *specCtx = nullptr;
1410 OH_CryptoAsymKeyGeneratorWithSpec *generator = nullptr;
1411 OH_CryptoKeyPair *newKeyPair = nullptr;
1412 Crypto_DataBlob sk = { .data = nullptr, .len = 0};
1413 Crypto_DataBlob pk = { .data = nullptr, .len = 0};
1414 Crypto_DataBlob new_sk = { .data = nullptr, .len = 0};
1415 Crypto_DataBlob new_pk = { .data = nullptr, .len = 0};
1416 Crypto_DataBlob n = { .data = nullptr, .len = 0};
1417
1418 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair(algoName, algoKeyName);
1419 EXPECT_TRUE(keyPair != nullptr);
1420 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1421 EXPECT_TRUE(privKey != nullptr);
1422 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1423 EXPECT_TRUE(pubKey != nullptr);
1424 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_RSA_E_DATABLOB, &pk), CRYPTO_SUCCESS);
1425 EXPECT_EQ(OH_CryptoPrivKey_GetParam(privKey, CRYPTO_RSA_D_DATABLOB, &sk), CRYPTO_SUCCESS);
1426 EXPECT_EQ(OH_CryptoAsymKeySpec_Create(specName, CRYPTO_ASYM_KEY_KEY_PAIR_SPEC, &specCtx), CRYPTO_SUCCESS);
1427 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_RSA_N_DATABLOB, &n), CRYPTO_SUCCESS);
1428 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_RSA_N_DATABLOB, &n), CRYPTO_SUCCESS);
1429 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_RSA_D_DATABLOB, &sk), CRYPTO_SUCCESS);
1430 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_RSA_E_DATABLOB, &pk), CRYPTO_SUCCESS);
1431 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_Create(specCtx, &generator), CRYPTO_SUCCESS);
1432 EXPECT_TRUE(generator != nullptr);
1433 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_GenKeyPair(generator, &newKeyPair), CRYPTO_SUCCESS);
1434 EXPECT_TRUE(newKeyPair != nullptr);
1435 OH_CryptoPrivKey *new_privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1436 EXPECT_TRUE(new_privKey != nullptr);
1437 OH_CryptoPubKey *new_pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1438 EXPECT_TRUE(new_pubKey != nullptr);
1439 EXPECT_EQ(OH_CryptoPubKey_GetParam(new_pubKey, CRYPTO_RSA_E_DATABLOB, &new_pk), CRYPTO_SUCCESS);
1440 EXPECT_EQ(OH_CryptoPrivKey_GetParam(new_privKey, CRYPTO_RSA_D_DATABLOB, &new_sk), CRYPTO_SUCCESS);
1441 EXPECT_TRUE(memcmp(new_pk.data, pk.data, new_pk.len) == 0);
1442 EXPECT_TRUE(memcmp(new_sk.data, sk.data, new_sk.len) == 0);
1443
1444 OH_Crypto_FreeDataBlob(&sk);
1445 OH_Crypto_FreeDataBlob(&pk);
1446 OH_Crypto_FreeDataBlob(&new_sk);
1447 OH_Crypto_FreeDataBlob(&new_pk);
1448 OH_Crypto_FreeDataBlob(&n);
1449 OH_CryptoKeyPair_Destroy(keyPair);
1450 OH_CryptoKeyPair_Destroy(newKeyPair);
1451 OH_CryptoAsymKeyGeneratorWithSpec_Destroy(generator);
1452 OH_CryptoAsymKeySpec_Destroy(specCtx);
1453 }
1454
1455 CommonDSASpec g_commonDsaSpec[] = {
1456 {"DSA", "DSA1024"},
1457 {"DSA", "DSA2048"},
1458 {"DSA", "DSA3072"},
1459 };
1460
1461 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkAsymKeyNapiTest, ASYMKEY_DSA_KEYPAIR_TEST, ::testing::ValuesIn(g_commonDsaSpec));
1462
1463 /**
1464 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1600
1465 * @tc.name OHCryptoFrameworkAsymKeyNapiTest/ASYMKEY_DSA_KEYPAIR_TEST.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1600/x
1466 * @tc.desc algorithm is Asym Key
1467 * @tc.size Medium
1468 * @tc.type Func
1469 * @tc.level Level0
1470 */
1471 HWTEST_P(ASYMKEY_DSA_KEYPAIR_TEST, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1600, TestSize.Level0)
1472 {
1473 CommonDSASpec asymInfo = GetParam();
1474 const char *algoName = asymInfo.algoName;
1475 const char *specName = asymInfo.specName;
1476 OH_CryptoAsymKeySpec *specCtx = nullptr;
1477 OH_CryptoAsymKeyGeneratorWithSpec *generator = nullptr;
1478 OH_CryptoKeyPair *newKeyPair = nullptr;
1479 Crypto_DataBlob sk = { .data = nullptr, .len = 0};
1480 Crypto_DataBlob pk = { .data = nullptr, .len = 0};
1481 Crypto_DataBlob new_sk = { .data = nullptr, .len = 0};
1482 Crypto_DataBlob new_pk = { .data = nullptr, .len = 0};
1483 Crypto_DataBlob g = { .data = nullptr, .len = 0};
1484 Crypto_DataBlob p = { .data = nullptr, .len = 0};
1485 Crypto_DataBlob q = { .data = nullptr, .len = 0};
1486
1487 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair(algoName, algoName);
1488 EXPECT_TRUE(keyPair != nullptr);
1489 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1490 EXPECT_TRUE(privKey != nullptr);
1491 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1492 EXPECT_TRUE(pubKey != nullptr);
1493 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DSA_PK_DATABLOB, &pk), CRYPTO_SUCCESS);
1494 EXPECT_EQ(OH_CryptoPrivKey_GetParam(privKey, CRYPTO_DSA_SK_DATABLOB, &sk), CRYPTO_SUCCESS);
1495 EXPECT_EQ(OH_CryptoAsymKeySpec_Create(specName, CRYPTO_ASYM_KEY_KEY_PAIR_SPEC, &specCtx), CRYPTO_SUCCESS);
1496 EXPECT_TRUE(specCtx != nullptr);
1497 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DSA_P_DATABLOB, &p), CRYPTO_SUCCESS);
1498 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DSA_Q_DATABLOB, &q), CRYPTO_SUCCESS);
1499 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DSA_G_DATABLOB, &g), CRYPTO_SUCCESS);
1500 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DSA_P_DATABLOB, &p), CRYPTO_SUCCESS);
1501 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DSA_Q_DATABLOB, &q), CRYPTO_SUCCESS);
1502 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DSA_G_DATABLOB, &g), CRYPTO_SUCCESS);
1503 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DSA_SK_DATABLOB, &sk), CRYPTO_SUCCESS);
1504 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DSA_PK_DATABLOB, &pk), CRYPTO_SUCCESS);
1505 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_Create(specCtx, &generator), CRYPTO_SUCCESS);
1506 EXPECT_TRUE(generator != nullptr);
1507 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_GenKeyPair(generator, &newKeyPair), CRYPTO_SUCCESS);
1508 EXPECT_TRUE(newKeyPair != nullptr);
1509 OH_CryptoPrivKey *new_privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1510 EXPECT_TRUE(new_privKey != nullptr);
1511 OH_CryptoPubKey *new_pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1512 EXPECT_TRUE(new_pubKey != nullptr);
1513 EXPECT_EQ(OH_CryptoPubKey_GetParam(new_pubKey, CRYPTO_DSA_PK_DATABLOB, &new_pk), CRYPTO_SUCCESS);
1514 EXPECT_EQ(OH_CryptoPrivKey_GetParam(new_privKey, CRYPTO_DSA_SK_DATABLOB, &new_sk), CRYPTO_SUCCESS);
1515 EXPECT_TRUE(memcmp(new_pk.data, pk.data, new_pk.len) == 0);
1516 EXPECT_TRUE(memcmp(new_sk.data, sk.data, new_sk.len) == 0);
1517
1518 OH_Crypto_FreeDataBlob(&sk);
1519 OH_Crypto_FreeDataBlob(&pk);
1520 OH_Crypto_FreeDataBlob(&new_sk);
1521 OH_Crypto_FreeDataBlob(&new_pk);
1522 OH_Crypto_FreeDataBlob(&p);
1523 OH_Crypto_FreeDataBlob(&q);
1524 OH_Crypto_FreeDataBlob(&g);
1525 OH_CryptoKeyPair_Destroy(keyPair);
1526 OH_CryptoKeyPair_Destroy(newKeyPair);
1527 OH_CryptoAsymKeyGeneratorWithSpec_Destroy(generator);
1528 OH_CryptoAsymKeySpec_Destroy(specCtx);
1529 }
1530
1531 CommonSpec g_CommonSpec[] = {
1532 {"X25519", CRYPTO_X25519_SK_DATABLOB, CRYPTO_X25519_PK_DATABLOB},
1533 {"Ed25519", CRYPTO_ED25519_SK_DATABLOB, CRYPTO_ED25519_PK_DATABLOB},
1534 };
1535
1536 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkAsymKeyNapiTest, ASYMKEY_KEYPAIR_TEST, ::testing::ValuesIn(g_CommonSpec));
1537
1538 /**
1539 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1700
1540 * @tc.name OHCryptoFrameworkAsymKeyNapiTest/ASYMKEY_KEYPAIR_TEST.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1700/x
1541 * @tc.desc algorithm is Asym Key
1542 * @tc.size Medium
1543 * @tc.type Func
1544 * @tc.level Level0
1545 */
1546 HWTEST_P(ASYMKEY_KEYPAIR_TEST, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1700, TestSize.Level0)
1547 {
1548 CommonSpec asymInfo = GetParam();
1549 const char *algoName = asymInfo.algoName;
1550 OH_CryptoAsymKeySpec *specCtx = nullptr;
1551 OH_CryptoAsymKeyGeneratorWithSpec *generator = nullptr;
1552 OH_CryptoKeyPair *newKeyPair = nullptr;
1553 Crypto_DataBlob sk = { .data = nullptr, .len = 0};
1554 Crypto_DataBlob pk = { .data = nullptr, .len = 0};
1555 Crypto_DataBlob new_sk = { .data = nullptr, .len = 0};
1556 Crypto_DataBlob new_pk = { .data = nullptr, .len = 0};
1557
1558 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair(algoName, algoName);
1559 EXPECT_TRUE(keyPair != nullptr);
1560 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1561 EXPECT_TRUE(privKey != nullptr);
1562 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1563 EXPECT_TRUE(pubKey != nullptr);
1564 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, asymInfo.pk, &pk), CRYPTO_SUCCESS);
1565 EXPECT_EQ(OH_CryptoPrivKey_GetParam(privKey, asymInfo.sk, &sk), CRYPTO_SUCCESS);
1566 EXPECT_EQ(OH_CryptoAsymKeySpec_Create(algoName, CRYPTO_ASYM_KEY_KEY_PAIR_SPEC, &specCtx), CRYPTO_SUCCESS);
1567 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, asymInfo.sk, &sk), CRYPTO_SUCCESS);
1568 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, asymInfo.pk, &pk), CRYPTO_SUCCESS);
1569 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_Create(specCtx, &generator), CRYPTO_SUCCESS);
1570 EXPECT_TRUE(generator != nullptr);
1571 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_GenKeyPair(generator, &newKeyPair), CRYPTO_SUCCESS);
1572 EXPECT_TRUE(newKeyPair != nullptr);
1573 OH_CryptoPrivKey *new_privKey = OH_CryptoKeyPair_GetPrivKey(newKeyPair);
1574 EXPECT_TRUE(new_privKey != nullptr);
1575 OH_CryptoPubKey *new_pubKey = OH_CryptoKeyPair_GetPubKey(newKeyPair);
1576 EXPECT_TRUE(new_pubKey != nullptr);
1577 EXPECT_EQ(OH_CryptoPubKey_GetParam(new_pubKey, asymInfo.pk, &new_pk), CRYPTO_SUCCESS);
1578 EXPECT_EQ(OH_CryptoPrivKey_GetParam(new_privKey, asymInfo.sk, &new_sk), CRYPTO_SUCCESS);
1579 EXPECT_TRUE(memcmp(new_pk.data, pk.data, new_pk.len) == 0);
1580 EXPECT_TRUE(memcmp(new_sk.data, sk.data, new_sk.len) == 0);
1581
1582 OH_Crypto_FreeDataBlob(&sk);
1583 OH_Crypto_FreeDataBlob(&pk);
1584 OH_Crypto_FreeDataBlob(&new_sk);
1585 OH_Crypto_FreeDataBlob(&new_pk);
1586 OH_CryptoKeyPair_Destroy(keyPair);
1587 OH_CryptoKeyPair_Destroy(newKeyPair);
1588 OH_CryptoAsymKeyGeneratorWithSpec_Destroy(generator);
1589 OH_CryptoAsymKeySpec_Destroy(specCtx);
1590 }
1591
1592 /**
1593 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1800
1594 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1800
1595 * @tc.desc algorithm is Asym Key
1596 * @tc.size Medium
1597 * @tc.type Func
1598 * @tc.level Level0
1599 */
1600 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1800, TestSize.Level0)
1601 {
1602 Crypto_DataBlob password = {.data = (uint8_t *)"", .len = 0};
1603 Crypto_DataBlob cipher = {.data = (uint8_t *)"AES-128-CBC", .len = 11};
1604 Crypto_DataBlob out = { .data = nullptr, .len = 0 };
1605 OH_CryptoPrivKeyEncodingParams *params = nullptr;
1606
1607 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair((const char *)"RSA512", (const char *)"RSA512");
1608 ASSERT_TRUE(keyPair != nullptr);
1609 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1610 ASSERT_TRUE(privKey != nullptr);
1611 EXPECT_EQ(OH_CryptoPrivKeyEncodingParams_Create(¶ms), CRYPTO_SUCCESS);
1612 ASSERT_TRUE(params != nullptr);
1613 EXPECT_EQ(OH_CryptoPrivKeyEncodingParams_SetParam(params, CRYPTO_PRIVATE_KEY_ENCODING_PASSWORD_STR, &password), CRYPTO_PARAMETER_CHECK_FAILED);
1614 EXPECT_EQ(OH_CryptoPrivKeyEncodingParams_SetParam(params, CRYPTO_PRIVATE_KEY_ENCODING_SYMMETRIC_CIPHER_STR, &cipher), CRYPTO_SUCCESS);
1615 ASSERT_EQ(OH_CryptoPrivKey_Encode(privKey, CRYPTO_PEM, (const char *)"PKCS8", params, &out), CRYPTO_OPERTION_ERROR);
1616
1617 OH_Crypto_FreeDataBlob(&out);
1618 OH_CryptoPrivKeyEncodingParams_Destroy(params);
1619 OH_CryptoKeyPair_Destroy(keyPair);
1620 }
1621
1622 /**
1623 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1900
1624 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1900
1625 * @tc.desc algorithm is Asym Key
1626 * @tc.size Medium
1627 * @tc.type Func
1628 * @tc.level Level0
1629 */
1630 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_1900, TestSize.Level0)
1631 {
1632 Crypto_DataBlob password = {.data = (uint8_t *)"0123456789", .len = 10};
1633 Crypto_DataBlob cipher = {.data = (uint8_t *)"SM4-128-CBC", .len = 11};
1634 Crypto_DataBlob out = { .data = nullptr, .len = 0 };
1635 OH_CryptoPrivKeyEncodingParams *params = nullptr;
1636
1637 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair((const char *)"RSA512", (const char *)"RSA512");
1638 ASSERT_TRUE(keyPair != nullptr);
1639 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1640 ASSERT_TRUE(privKey != nullptr);
1641 EXPECT_EQ(OH_CryptoPrivKeyEncodingParams_Create(¶ms), CRYPTO_SUCCESS);
1642 ASSERT_TRUE(params != nullptr);
1643 EXPECT_EQ(OH_CryptoPrivKeyEncodingParams_SetParam(params, CRYPTO_PRIVATE_KEY_ENCODING_PASSWORD_STR, &password), CRYPTO_SUCCESS);
1644 EXPECT_EQ(OH_CryptoPrivKeyEncodingParams_SetParam(params, CRYPTO_PRIVATE_KEY_ENCODING_SYMMETRIC_CIPHER_STR, &cipher), CRYPTO_SUCCESS);
1645 ASSERT_EQ(OH_CryptoPrivKey_Encode(privKey, CRYPTO_PEM, (const char *)"PKCS8", params, &out), CRYPTO_NOT_SUPPORTED);
1646
1647 OH_Crypto_FreeDataBlob(&out);
1648 OH_CryptoPrivKeyEncodingParams_Destroy(params);
1649 OH_CryptoKeyPair_Destroy(keyPair);
1650 }
1651
1652 /**
1653 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2000
1654 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2000
1655 * @tc.desc algorithm is Asym Key
1656 * @tc.size Medium
1657 * @tc.type Func
1658 * @tc.level Level0
1659 */
1660 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2000, TestSize.Level0)
1661 {
1662 Crypto_DataBlob password = {.data = (uint8_t *)"0123456789", .len = 10};
1663 Crypto_DataBlob cipher = {.data = (uint8_t *)"AES-128-CBC", .len = 11};
1664 Crypto_DataBlob out = { .data = nullptr, .len = 0 };
1665 OH_CryptoPrivKeyEncodingParams *params = nullptr;
1666
1667 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair((const char *)"RSA512", (const char *)"RSA512");
1668 ASSERT_TRUE(keyPair != nullptr);
1669 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1670 ASSERT_TRUE(privKey != nullptr);
1671 EXPECT_EQ(OH_CryptoPrivKeyEncodingParams_Create(¶ms), CRYPTO_SUCCESS);
1672 ASSERT_TRUE(params != nullptr);
1673 EXPECT_EQ(OH_CryptoPrivKeyEncodingParams_SetParam(params, CRYPTO_PRIVATE_KEY_ENCODING_PASSWORD_STR, &password), CRYPTO_SUCCESS);
1674 EXPECT_EQ(OH_CryptoPrivKeyEncodingParams_SetParam(params, CRYPTO_PRIVATE_KEY_ENCODING_SYMMETRIC_CIPHER_STR, &cipher), CRYPTO_SUCCESS);
1675 ASSERT_EQ(OH_CryptoPrivKey_Encode(privKey, CRYPTO_PEM, (const char *)"X509", params, &out), CRYPTO_PARAMETER_CHECK_FAILED);
1676
1677 OH_Crypto_FreeDataBlob(&out);
1678 OH_CryptoPrivKeyEncodingParams_Destroy(params);
1679 OH_CryptoKeyPair_Destroy(keyPair);
1680 }
1681
1682 /**
1683 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2100
1684 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2100
1685 * @tc.desc algorithm is Asym Key
1686 * @tc.size Medium
1687 * @tc.type Func
1688 * @tc.level Level0
1689 */
1690 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2100, TestSize.Level0)
1691 {
1692 OH_CryptoAsymKeySpec *specCtx = nullptr;
1693 OH_CryptoAsymKeyGeneratorWithSpec *generator = nullptr;
1694
1695 EXPECT_EQ(OH_CryptoAsymKeySpec_Create("ECC", CRYPTO_ASYM_KEY_PRIVATE_KEY_SPEC, &specCtx), CRYPTO_SUCCESS);
1696 EXPECT_TRUE(specCtx != nullptr);
1697 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_Create(specCtx, &generator), CRYPTO_PARAMETER_CHECK_FAILED);
1698 EXPECT_TRUE(generator == nullptr);
1699
1700 OH_CryptoAsymKeyGeneratorWithSpec_Destroy(generator);
1701 OH_CryptoAsymKeySpec_Destroy(specCtx);
1702 }
1703
1704 /**
1705 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2200
1706 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2200
1707 * @tc.desc algorithm is Asym Key
1708 * @tc.size Medium
1709 * @tc.type Func
1710 * @tc.level Level0
1711 */
1712 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2200, TestSize.Level0)
1713 {
1714 OH_CryptoAsymKeySpec *specCtx = nullptr;
1715 OH_CryptoAsymKeySpec *commonSpec = nullptr;
1716 OH_CryptoAsymKeyGeneratorWithSpec *generator = nullptr;
1717 OH_CryptoKeyPair *keyPair = nullptr;
1718 uint8_t sk_data[] = {
1719 0xc1, 0xef, 0x9c, 0xd1, 0xb0, 0xd7, 0xf3, 0xcc, 0x99, 0xf7, 0x6d, 0x93, 0x07, 0x26, 0x9e, 0xcc,
1720 0xa9, 0x39, 0x09, 0x4f, 0x8a, 0x59, 0xbb, 0x1d, 0xb8, 0x61, 0xf6, 0xc1, 0x2f, 0x95, 0x6b, 0x60,
1721 0x61, 0xf9, 0x62, 0xaa, 0x3e, 0x22, 0x94, 0xee, 0x3d, 0x0a, 0x19, 0x46, 0x39, 0x96, 0xdf, 0x94,
1722 0x24, 0x10, 0xdf, 0x0a, 0x1c, 0x40, 0x55, 0x10, 0x5a, 0x89, 0x6a, 0x43, 0xd5, 0xe4, 0x47, 0x3c,
1723 0xf1, 0x40, 0xf1, 0xb9, 0x68, 0xa8, 0x63, 0x38, 0xbc, 0x97, 0xfa, 0x82, 0xb4, 0xdf, 0xf1, 0x51,
1724 0x31, 0x82, 0xb2, 0x05, 0xe4, 0x3f, 0x8a, 0xdc, 0xc3, 0xf3, 0xfa, 0xa4, 0x88, 0xd3, 0xca, 0x9b,
1725 0x5c, 0x03, 0x3b, 0x0a, 0x7c, 0xd9, 0xff, 0xc2, 0x3b, 0x36, 0xff, 0xfe, 0x06, 0xc9, 0x3b, 0x26,
1726 0x1d, 0xfe, 0xe7, 0x23, 0xde, 0xda, 0xe5, 0xa6, 0x91, 0x91, 0x64, 0xe3, 0x44, 0x4f, 0x75, 0x60,
1727 0x4b, 0x76, 0x59, 0x2b, 0x9e, 0x09, 0x87, 0xd4, 0x5c, 0xd9, 0x7a, 0x9d, 0x35, 0x94, 0x03, 0x23,
1728 0xeb, 0xe9, 0xea, 0x32, 0x4e, 0x3b, 0x4c, 0xa3, 0xce, 0x36, 0xac, 0xd4, 0x5e, 0x1c, 0xdc, 0x29,
1729 0xc4, 0x51, 0x98, 0xfa, 0x1f, 0xd4, 0x72, 0x30, 0x10, 0xd3, 0x77, 0x48, 0x43, 0x94, 0xa1, 0x96,
1730 0xc0, 0x63, 0x14, 0xc5, 0x83, 0x45, 0x00, 0xb4, 0xe5, 0x05, 0xe8, 0x1a, 0x99, 0x13, 0x1d
1731 };
1732 uint8_t pk_data[] = {
1733 0x09, 0x0a, 0xf6, 0x16, 0x5e, 0x80, 0x54, 0x1e, 0x61, 0x83, 0xeb, 0xb4, 0x1e, 0xb9, 0x7d, 0x5a,
1734 0x65, 0xac, 0x7b, 0x57, 0x7d, 0x4d, 0xeb, 0x3f
1735 };
1736 Crypto_DataBlob sk = { .data = sk_data, .len = sizeof(sk_data)};
1737 Crypto_DataBlob pk = { .data = pk_data, .len = sizeof(pk_data)};
1738 Crypto_DataBlob new_sk = { .data = nullptr, .len = 0};
1739 Crypto_DataBlob new_pk = { .data = nullptr, .len = 0};
1740
1741 EXPECT_EQ(OH_CryptoAsymKeySpec_Create("DH", CRYPTO_ASYM_KEY_KEY_PAIR_SPEC, &specCtx), CRYPTO_SUCCESS);
1742 EXPECT_TRUE(specCtx != nullptr);
1743 EXPECT_EQ(OH_CryptoAsymKeySpec_GenDhCommonParamsSpec(1536, 200, &commonSpec), CRYPTO_SUCCESS);
1744 EXPECT_TRUE(commonSpec != nullptr);
1745 EXPECT_EQ(OH_CryptoAsymKeySpec_SetCommonParamsSpec(specCtx, commonSpec), CRYPTO_SUCCESS);
1746 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DH_SK_DATABLOB, &sk), CRYPTO_SUCCESS);
1747 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DH_PK_DATABLOB, &pk), CRYPTO_SUCCESS);
1748 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_Create(specCtx, &generator), CRYPTO_SUCCESS);
1749 EXPECT_TRUE(generator != nullptr);
1750 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_GenKeyPair(generator, &keyPair), CRYPTO_SUCCESS);
1751 EXPECT_TRUE(keyPair != nullptr);
1752 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1753 EXPECT_TRUE(privKey != nullptr);
1754 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1755 EXPECT_TRUE(pubKey != nullptr);
1756 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_DH_PK_DATABLOB, &new_pk), CRYPTO_SUCCESS);
1757 EXPECT_EQ(OH_CryptoPrivKey_GetParam(privKey, CRYPTO_DH_SK_DATABLOB, &new_sk), CRYPTO_SUCCESS);
1758 EXPECT_TRUE(memcmp(new_pk.data, pk.data, new_pk.len) == 0);
1759 EXPECT_TRUE(memcmp(new_sk.data, sk.data, new_sk.len) == 0);
1760 EXPECT_EQ(new_pk.len, pk.len);
1761 EXPECT_EQ(new_sk.len, sk.len);
1762
1763 OH_Crypto_FreeDataBlob(&new_sk);
1764 OH_Crypto_FreeDataBlob(&new_pk);
1765 OH_CryptoKeyPair_Destroy(keyPair);
1766 OH_CryptoAsymKeyGeneratorWithSpec_Destroy(generator);
1767 OH_CryptoAsymKeySpec_Destroy(specCtx);
1768 OH_CryptoAsymKeySpec_Destroy(commonSpec);
1769 }
1770
1771 /**
1772 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2300
1773 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2300
1774 * @tc.desc algorithm is Asym Key
1775 * @tc.size Medium
1776 * @tc.type Func
1777 * @tc.level Level0
1778 */
1779 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2300, TestSize.Level0)
1780 {
1781 OH_CryptoAsymKeySpec *specCtx = nullptr;
1782 uint8_t pk_data[] = {
1783 0x09, 0x0a, 0xf6, 0x16, 0x5e, 0x80, 0x54, 0x1e, 0x61, 0x83, 0xeb, 0xb4, 0x1e, 0xb9, 0x7d, 0x5a,
1784 0x65, 0xac, 0x7b, 0x57, 0x7d, 0x4d, 0xeb, 0x3f, 0x61, 0x83, 0xeb, 0xb4, 0x1e, 0xb9, 0x7d, 0x5a
1785 };
1786 uint8_t sk_data[] = {
1787 0x09, 0x0a, 0xf6, 0x16, 0x5e, 0x80, 0x54, 0x1e, 0x61, 0x83, 0xeb, 0xb4, 0x1e, 0xb9, 0x7d, 0x5a,
1788 0x65, 0xac, 0x7b, 0x57, 0x7d, 0x4d, 0xeb, 0x3f, 0x61, 0x83, 0xeb, 0xb4, 0x1e, 0xb9, 0x7d, 0x5a
1789 };
1790 Crypto_DataBlob pk = { .data = pk_data, .len = sizeof(pk_data)};
1791 Crypto_DataBlob sk = { .data = sk_data, .len = sizeof(sk_data)};
1792
1793 EXPECT_EQ(OH_CryptoAsymKeySpec_Create("ECC", CRYPTO_ASYM_KEY_PRIVATE_KEY_SPEC, &specCtx), CRYPTO_SUCCESS);
1794 EXPECT_TRUE(specCtx != nullptr);
1795 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_ED25519_PK_DATABLOB, &pk), CRYPTO_PARAMETER_CHECK_FAILED);
1796 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_X25519_SK_DATABLOB, &sk), CRYPTO_PARAMETER_CHECK_FAILED);
1797
1798 OH_CryptoAsymKeySpec_Destroy(specCtx);
1799 }
1800
1801 /**
1802 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2400
1803 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2400
1804 * @tc.desc algorithm is Asym Key
1805 * @tc.size Medium
1806 * @tc.type Func
1807 * @tc.level Level0
1808 */
1809 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2400, TestSize.Level0)
1810 {
1811 OH_CryptoAsymKeySpec *specCtx1 = nullptr;
1812 OH_CryptoAsymKeySpec *specCtx2 = nullptr;
1813 uint8_t pk_x_data[] = {
1814 0x09, 0x0a, 0xf6, 0x16, 0x5e, 0x80, 0x54, 0x1e, 0x61, 0x83, 0xeb, 0xb4, 0x1e, 0xb9, 0x7d, 0x5a,
1815 0x65, 0xac, 0x7b, 0x57, 0x7d, 0x4d, 0xeb, 0x3f, 0x61, 0x83, 0xeb, 0xb4, 0x1e, 0xb9, 0x7d, 0x5a
1816 };
1817 uint8_t sk_data[] = {
1818 0x09, 0x0a, 0xf6, 0x16, 0x5e, 0x80, 0x54, 0x1e, 0x61, 0x83, 0xeb, 0xb4, 0x1e, 0xb9, 0x7d, 0x5a,
1819 0x65, 0xac, 0x7b, 0x57, 0x7d, 0x4d, 0xeb, 0x3f, 0x61, 0x83, 0xeb, 0xb4, 0x1e, 0xb9, 0x7d, 0x5a
1820 };
1821 Crypto_DataBlob pk_x = { .data = pk_x_data, .len = sizeof(pk_x_data)};
1822 Crypto_DataBlob sk = { .data = sk_data, .len = sizeof(sk_data)};
1823 EXPECT_EQ(OH_CryptoAsymKeySpec_Create("ECC", CRYPTO_ASYM_KEY_PUBLIC_KEY_SPEC, &specCtx1), CRYPTO_SUCCESS);
1824 EXPECT_EQ(OH_CryptoAsymKeySpec_Create("ECC", CRYPTO_ASYM_KEY_PRIVATE_KEY_SPEC, &specCtx2), CRYPTO_SUCCESS);
1825 EXPECT_TRUE(specCtx1 != nullptr && specCtx2 != nullptr);
1826 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx1, CRYPTO_ECC_SK_DATABLOB, &sk), CRYPTO_PARAMETER_CHECK_FAILED);
1827 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx2, CRYPTO_ECC_PK_X_DATABLOB, &pk_x), CRYPTO_PARAMETER_CHECK_FAILED);
1828
1829 OH_CryptoAsymKeySpec_Destroy(specCtx1);
1830 OH_CryptoAsymKeySpec_Destroy(specCtx2);
1831 }
1832
1833 /**
1834 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2500
1835 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2500
1836 * @tc.desc algorithm is Asym Key
1837 * @tc.size Medium
1838 * @tc.type Func
1839 * @tc.level Level0
1840 */
1841 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2500, TestSize.Level0)
1842 {
1843 OH_CryptoAsymKeySpec *specCtx = nullptr;
1844 OH_CryptoAsymKeySpec *commonSpec = nullptr;
1845 OH_CryptoAsymKeyGeneratorWithSpec *generator = nullptr;
1846 OH_CryptoKeyPair *keyPair = nullptr;
1847 uint8_t pk_data[] = {
1848 0x09, 0x0a, 0xf6, 0x16, 0x5e, 0x80, 0x54, 0x1e, 0x61, 0x83, 0xeb, 0xb4, 0x1e, 0xb9, 0x7d, 0x5a,
1849 0x65, 0xac, 0x7b, 0x57, 0x7d, 0x4d, 0xeb, 0x3f, 0x45
1850 };
1851 Crypto_DataBlob pk = { .data = pk_data, .len = sizeof(pk_data)};
1852
1853 EXPECT_EQ(OH_CryptoAsymKeySpec_Create("DH", CRYPTO_ASYM_KEY_PUBLIC_KEY_SPEC, &specCtx), CRYPTO_SUCCESS);
1854 EXPECT_TRUE(specCtx != nullptr);
1855 EXPECT_EQ(OH_CryptoAsymKeySpec_GenDhCommonParamsSpec(1536, 200, &commonSpec), CRYPTO_SUCCESS);
1856 EXPECT_TRUE(commonSpec != nullptr);
1857 EXPECT_EQ(OH_CryptoAsymKeySpec_SetCommonParamsSpec(specCtx, commonSpec), CRYPTO_SUCCESS);
1858 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DH_PK_DATABLOB, &pk), CRYPTO_SUCCESS);
1859 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_Create(specCtx, &generator), CRYPTO_SUCCESS);
1860 EXPECT_TRUE(generator != nullptr);
1861 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_GenKeyPair(generator, &keyPair), CRYPTO_SUCCESS);
1862 EXPECT_TRUE(keyPair != nullptr);
1863 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
1864 EXPECT_TRUE(privKey == nullptr);
1865
1866 OH_CryptoKeyPair_Destroy(keyPair);
1867 OH_CryptoAsymKeyGeneratorWithSpec_Destroy(generator);
1868 OH_CryptoAsymKeySpec_Destroy(specCtx);
1869 OH_CryptoAsymKeySpec_Destroy(commonSpec);
1870 }
1871
1872 /**
1873 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2600
1874 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2600
1875 * @tc.desc algorithm is Asym Key
1876 * @tc.size Medium
1877 * @tc.type Func
1878 * @tc.level Level0
1879 */
1880 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2600, TestSize.Level0)
1881 {
1882 OH_CryptoAsymKeySpec *specCtx = nullptr;
1883 OH_CryptoAsymKeySpec *commonSpec = nullptr;
1884 OH_CryptoAsymKeyGeneratorWithSpec *generator = nullptr;
1885 OH_CryptoKeyPair *keyPair = nullptr;
1886 uint8_t sk_data[] = {
1887 0xc1, 0xef, 0x9c, 0xd1, 0xb0, 0xd7, 0xf3, 0xcc, 0x99, 0xf7, 0x6d, 0x93, 0x07, 0x26, 0x9e, 0xcc,
1888 0xa9, 0x39, 0x09, 0x4f, 0x8a, 0x59, 0xbb, 0x1d, 0xb8, 0x61, 0xf6, 0xc1, 0x2f, 0x95, 0x6b, 0x60,
1889 0x61, 0xf9, 0x62, 0xaa, 0x3e, 0x22, 0x94, 0xee, 0x3d, 0x0a, 0x19, 0x46, 0x39, 0x96, 0xdf, 0x94,
1890 0x24, 0x10, 0xdf, 0x0a, 0x1c, 0x40, 0x55, 0x10, 0x5a, 0x89, 0x6a, 0x43, 0xd5, 0xe4, 0x47, 0x3c,
1891 0xf1, 0x40, 0xf1, 0xb9, 0x68, 0xa8, 0x63, 0x38, 0xbc, 0x97, 0xfa, 0x82, 0xb4, 0xdf, 0xf1, 0x51,
1892 0x31, 0x82, 0xb2, 0x05, 0xe4, 0x3f, 0x8a, 0xdc, 0xc3, 0xf3, 0xfa, 0xa4, 0x88, 0xd3, 0xca, 0x9b,
1893 0x5c, 0x03, 0x3b, 0x0a, 0x7c, 0xd9, 0xff, 0xc2, 0x3b, 0x36, 0xff, 0xfe, 0x06, 0xc9, 0x3b, 0x26,
1894 0x1d, 0xfe, 0xe7, 0x23, 0xde, 0xda, 0xe5, 0xa6, 0x91, 0x91, 0x64, 0xe3, 0x44, 0x4f, 0x75, 0x60,
1895 0x4b, 0x76, 0x59, 0x2b, 0x9e, 0x09, 0x87, 0xd4, 0x5c, 0xd9, 0x7a, 0x9d, 0x35, 0x94, 0x03, 0x23,
1896 0xeb, 0xe9, 0xea, 0x32, 0x4e, 0x3b, 0x4c, 0xa3, 0xce, 0x36, 0xac, 0xd4, 0x5e, 0x1c, 0xdc, 0x29,
1897 0xc4, 0x51, 0x98, 0xfa, 0x1f, 0xd4, 0x72, 0x30, 0x10, 0xd3, 0x77, 0x48, 0x43, 0x94, 0xa1, 0x96,
1898 0xc0, 0x63, 0x14, 0xc5, 0x83, 0x45, 0x00, 0xb4, 0xe5, 0x05, 0xe8, 0x1a, 0x99, 0x13, 0x1d, 0xd9
1899 };
1900 Crypto_DataBlob sk = { .data = sk_data, .len = sizeof(sk_data)};
1901
1902 EXPECT_EQ(OH_CryptoAsymKeySpec_Create("DH", CRYPTO_ASYM_KEY_PRIVATE_KEY_SPEC, &specCtx), CRYPTO_SUCCESS);
1903 EXPECT_TRUE(specCtx != nullptr);
1904 EXPECT_EQ(OH_CryptoAsymKeySpec_GenDhCommonParamsSpec(1536, 200, &commonSpec), CRYPTO_SUCCESS);
1905 EXPECT_TRUE(commonSpec != nullptr);
1906 EXPECT_EQ(OH_CryptoAsymKeySpec_SetCommonParamsSpec(specCtx, commonSpec), CRYPTO_SUCCESS);
1907 EXPECT_EQ(OH_CryptoAsymKeySpec_SetParam(specCtx, CRYPTO_DH_SK_DATABLOB, &sk), CRYPTO_SUCCESS);
1908 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_Create(specCtx, &generator), CRYPTO_SUCCESS);
1909 EXPECT_TRUE(generator != nullptr);
1910 EXPECT_EQ(OH_CryptoAsymKeyGeneratorWithSpec_GenKeyPair(generator, &keyPair), CRYPTO_SUCCESS);
1911 EXPECT_TRUE(keyPair != nullptr);
1912 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1913 EXPECT_TRUE(pubKey == nullptr);
1914
1915 OH_CryptoKeyPair_Destroy(keyPair);
1916 OH_CryptoAsymKeyGeneratorWithSpec_Destroy(generator);
1917 OH_CryptoAsymKeySpec_Destroy(specCtx);
1918 OH_CryptoAsymKeySpec_Destroy(commonSpec);
1919 }
1920
1921 ECPointSpec g_ecPointSpec[] = {
1922 {"ECC224", "NID_secp224r1", "UNCOMPRESSED"},
1923 {"ECC256", "NID_X9_62_prime256v1", "UNCOMPRESSED"},
1924 {"ECC384", "NID_secp384r1", "UNCOMPRESSED"},
1925 {"ECC521", "NID_secp521r1", "UNCOMPRESSED"},
1926 {"ECC_BrainPoolP160r1", "NID_brainpoolP160r1", "UNCOMPRESSED"},
1927 {"ECC_BrainPoolP160t1", "NID_brainpoolP160t1", "UNCOMPRESSED"},
1928 {"ECC_BrainPoolP192r1", "NID_brainpoolP192r1", "UNCOMPRESSED"},
1929 {"ECC_BrainPoolP192t1", "NID_brainpoolP192t1", "UNCOMPRESSED"},
1930 {"ECC_BrainPoolP224r1", "NID_brainpoolP224r1", "UNCOMPRESSED"},
1931 {"ECC_BrainPoolP224t1", "NID_brainpoolP224t1", "UNCOMPRESSED"},
1932 {"ECC_BrainPoolP256r1", "NID_brainpoolP256r1", "UNCOMPRESSED"},
1933 {"ECC_BrainPoolP256t1", "NID_brainpoolP256t1", "UNCOMPRESSED"},
1934 {"ECC_BrainPoolP320r1", "NID_brainpoolP320r1", "UNCOMPRESSED"},
1935 {"ECC_BrainPoolP320t1", "NID_brainpoolP320t1", "UNCOMPRESSED"},
1936 {"ECC_BrainPoolP384r1", "NID_brainpoolP384r1", "UNCOMPRESSED"},
1937 {"ECC_BrainPoolP384t1", "NID_brainpoolP384t1", "UNCOMPRESSED"},
1938 {"ECC_BrainPoolP512r1", "NID_brainpoolP512r1", "UNCOMPRESSED"},
1939 {"ECC_BrainPoolP512t1", "NID_brainpoolP512t1", "UNCOMPRESSED"},
1940 {"ECC_Secp256k1", "NID_secp256k1", "UNCOMPRESSED"},
1941 {"SM2_256", "NID_sm2", "UNCOMPRESSED"},
1942 {"SM2_256", "NID_sm2", "COMPRESSED"},
1943 {"ECC224", "NID_secp224r1", "COMPRESSED"},
1944 {"ECC256", "NID_X9_62_prime256v1", "COMPRESSED"},
1945 {"ECC384", "NID_secp384r1", "COMPRESSED"},
1946 {"ECC521", "NID_secp521r1", "COMPRESSED"},
1947 {"ECC_BrainPoolP160r1", "NID_brainpoolP160r1", "COMPRESSED"},
1948 {"ECC_BrainPoolP160t1", "NID_brainpoolP160t1", "COMPRESSED"},
1949 {"ECC_BrainPoolP192r1", "NID_brainpoolP192r1", "COMPRESSED"},
1950 {"ECC_BrainPoolP192t1", "NID_brainpoolP192t1", "COMPRESSED"},
1951 {"ECC_BrainPoolP224r1", "NID_brainpoolP224r1", "COMPRESSED"},
1952 {"ECC_BrainPoolP224t1", "NID_brainpoolP224t1", "COMPRESSED"},
1953 {"ECC_BrainPoolP256r1", "NID_brainpoolP256r1", "COMPRESSED"},
1954 {"ECC_BrainPoolP256t1", "NID_brainpoolP256t1", "COMPRESSED"},
1955 {"ECC_BrainPoolP320r1", "NID_brainpoolP320r1", "COMPRESSED"},
1956 {"ECC_BrainPoolP320t1", "NID_brainpoolP320t1", "COMPRESSED"},
1957 {"ECC_BrainPoolP384r1", "NID_brainpoolP384r1", "COMPRESSED"},
1958 {"ECC_BrainPoolP384t1", "NID_brainpoolP384t1", "COMPRESSED"},
1959 {"ECC_BrainPoolP512r1", "NID_brainpoolP512r1", "COMPRESSED"},
1960 {"ECC_BrainPoolP512t1", "NID_brainpoolP512t1", "COMPRESSED"},
1961 {"ECC_Secp256k1", "NID_secp256k1", "COMPRESSED"},
1962 };
1963
1964 INSTANTIATE_TEST_CASE_P(OHCryptoFrameworkAsymKeyNapiTest, ASYMKEY_EC_POINT_TEST, ::testing::ValuesIn(g_ecPointSpec));
1965
1966 /**
1967 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2700
1968 * @tc.name OHCryptoFrameworkAsymKeyNapiTest/ASYMKEY_EC_POINT_TEST.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2700/x
1969 * @tc.desc algorithm is Asym Key
1970 * @tc.size Medium
1971 * @tc.type Func
1972 * @tc.level Level0
1973 */
1974 HWTEST_P(ASYMKEY_EC_POINT_TEST, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2700, TestSize.Level0)
1975 {
1976 ECPointSpec asymInfo = GetParam();
1977 OH_CryptoAsymKeyGenerator *ctx = nullptr;
1978 OH_CryptoKeyPair *keyPair = nullptr;
1979 OH_CryptoEcPoint *point = nullptr;
1980 Crypto_DataBlob ecKeyData = { .data = nullptr, .len = 0};
1981 Crypto_DataBlob pk_x = { .data = nullptr, .len = 0};
1982 Crypto_DataBlob pk_y = { .data = nullptr, .len = 0};
1983 Crypto_DataBlob new_pk_x = { .data = nullptr, .len = 0};
1984 Crypto_DataBlob new_pk_y = { .data = nullptr, .len = 0};
1985
1986 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Create(asymInfo.curve, &ctx), CRYPTO_SUCCESS);
1987 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Generate(ctx, &keyPair), CRYPTO_SUCCESS);
1988 EXPECT_TRUE(keyPair != nullptr);
1989 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
1990 EXPECT_TRUE(pubKey != nullptr);
1991 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_PK_X_DATABLOB, &pk_x), CRYPTO_SUCCESS);
1992 EXPECT_EQ(OH_CryptoPubKey_GetParam(pubKey, CRYPTO_ECC_PK_Y_DATABLOB, &pk_y), CRYPTO_SUCCESS);
1993 EXPECT_EQ(OH_CryptoEcPoint_Create(asymInfo.curveNid, nullptr, &point), CRYPTO_SUCCESS);
1994 EXPECT_TRUE(point != nullptr);
1995 EXPECT_EQ(OH_CryptoEcPoint_SetCoordinate(point, &pk_x, &pk_y), CRYPTO_SUCCESS);
1996 EXPECT_EQ(OH_CryptoEcPoint_Encode(point, asymInfo.format, &ecKeyData), CRYPTO_SUCCESS);
1997 OH_CryptoEcPoint_Destroy(point);
1998 point = nullptr;
1999 EXPECT_EQ(OH_CryptoEcPoint_Create(asymInfo.curveNid, &ecKeyData, &point), CRYPTO_SUCCESS);
2000 EXPECT_TRUE(point != nullptr);
2001 EXPECT_EQ(OH_CryptoEcPoint_GetCoordinate(point, &new_pk_x, &new_pk_y), CRYPTO_SUCCESS);
2002 EXPECT_TRUE(memcmp(new_pk_y.data, pk_y.data, new_pk_y.len) == 0);
2003 EXPECT_TRUE(memcmp(new_pk_x.data, new_pk_x.data, new_pk_x.len) == 0);
2004 EXPECT_EQ(new_pk_x.len, pk_x.len);
2005 EXPECT_EQ(pk_y.len, new_pk_y.len);
2006
2007 OH_CryptoAsymKeyGenerator_Destroy(ctx);
2008 OH_CryptoKeyPair_Destroy(keyPair);
2009 OH_CryptoEcPoint_Destroy(point);
2010 OH_Crypto_FreeDataBlob(&new_pk_x);
2011 OH_Crypto_FreeDataBlob(&new_pk_y);
2012 OH_Crypto_FreeDataBlob(&pk_x);
2013 OH_Crypto_FreeDataBlob(&pk_y);
2014 OH_Crypto_FreeDataBlob(&ecKeyData);
2015 }
2016
2017 /**
2018 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2800
2019 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2800
2020 * @tc.desc algorithm is Asym Key
2021 * @tc.size Medium
2022 * @tc.type Func
2023 * @tc.level Level0
2024 */
2025 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2800, TestSize.Level0)
2026 {
2027 const char *curveNid = "NID_X9_62_prime256v1";
2028 OH_CryptoEcPoint *point = nullptr;
2029 Crypto_DataBlob ecKeyData = { .data = nullptr, .len = 0};
2030 uint8_t x[] = {
2031 0x59, 0xfb, 0xf8, 0xce, 0xe6, 0xd1, 0xf3, 0xd6, 0xe0, 0x20, 0x9e, 0x88, 0xa9, 0x59, 0x22, 0xa4,
2032 0xd4, 0x23, 0xe2, 0x93, 0xfd, 0xd3, 0xcd, 0x11, 0xf1, 0x11, 0xa1, 0x9e, 0x9c, 0x81, 0x78, 0x27
2033 };
2034 uint8_t y[] = {
2035 0x03, 0xb0, 0x17, 0x54, 0x62, 0xb9, 0x38, 0x88, 0xc4, 0xca, 0x7e, 0x55, 0x50, 0xa7, 0x6d, 0xe6,
2036 0x0c, 0xc2, 0xd7, 0xd5, 0x07, 0x57, 0xa4, 0x4b, 0x22, 0x8e, 0xc5, 0x54, 0xbd, 0x24, 0xc4, 0x8a
2037 };
2038 Crypto_DataBlob pk_x = { .data = x, .len = sizeof(x)};
2039 Crypto_DataBlob pk_y = { .data = y, .len = sizeof(y)};
2040
2041 EXPECT_EQ(OH_CryptoEcPoint_Create(curveNid, nullptr, &point), CRYPTO_SUCCESS);
2042 EXPECT_TRUE(point != nullptr);
2043 EXPECT_EQ(OH_CryptoEcPoint_SetCoordinate(point, &pk_x, &pk_y), CRYPTO_SUCCESS);
2044 EXPECT_EQ(OH_CryptoEcPoint_Encode(point, "UNCOMPRESSED", &ecKeyData), CRYPTO_OPERTION_ERROR);
2045 EXPECT_EQ(OH_CryptoEcPoint_Encode(point, "COMPRESSED", &ecKeyData), CRYPTO_OPERTION_ERROR);
2046
2047 OH_CryptoEcPoint_Destroy(point);
2048 OH_Crypto_FreeDataBlob(&ecKeyData);
2049 }
2050
2051 /**
2052 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2900
2053 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2900
2054 * @tc.desc algorithm is Asym Key
2055 * @tc.size Medium
2056 * @tc.type Func
2057 * @tc.level Level0
2058 */
2059 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_2900, TestSize.Level0)
2060 {
2061 const char *curveNid = "NID_X9_62_prime256v1";
2062 OH_CryptoEcPoint *point = nullptr;
2063 Crypto_DataBlob ecKeyData = { .data = nullptr, .len = 0};
2064 uint8_t x[] = {
2065 0x59, 0xfb, 0xf8, 0xce, 0xe6, 0xd1, 0xf3, 0xd6, 0xe0, 0x20, 0x9e, 0x88, 0xa9, 0x59, 0x22, 0xa4,
2066 0xd4, 0x23, 0xe2, 0x93, 0xfd, 0xd3, 0xcd, 0x11, 0xf1, 0x11, 0xa1, 0x9e, 0x9c, 0x81, 0x78, 0x27
2067 };
2068 uint8_t y[] = {
2069 0x94, 0x73, 0x65, 0x53, 0x8b, 0xeb, 0x1f, 0x06, 0x80, 0x17, 0xc1, 0x08, 0xf6, 0x94, 0x7c, 0xf2,
2070 0x5a, 0x3e, 0x5e, 0x08, 0x2e, 0x6e, 0x42, 0xb2, 0x15, 0x18, 0x8d, 0x1f, 0x69, 0xac, 0xdf, 0x12
2071 };
2072 Crypto_DataBlob pk_x = { .data = x, .len = sizeof(x)};
2073 Crypto_DataBlob pk_y = { .data = y, .len = sizeof(y)};
2074
2075 EXPECT_EQ(OH_CryptoEcPoint_Create(curveNid, nullptr, &point), CRYPTO_SUCCESS);
2076 EXPECT_TRUE(point != nullptr);
2077 EXPECT_EQ(OH_CryptoEcPoint_SetCoordinate(point, &pk_x, &pk_y), CRYPTO_SUCCESS);
2078 EXPECT_EQ(OH_CryptoEcPoint_Encode(point, "UNCOMPRESSED", &ecKeyData), CRYPTO_OPERTION_ERROR);
2079 EXPECT_EQ(OH_CryptoEcPoint_Encode(point, "COMPRESSED", &ecKeyData), CRYPTO_OPERTION_ERROR);
2080
2081 OH_CryptoEcPoint_Destroy(point);
2082 OH_Crypto_FreeDataBlob(&ecKeyData);
2083 }
2084
2085 /**
2086 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3000
2087 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3000
2088 * @tc.desc algorithm is Asym Key
2089 * @tc.size Medium
2090 * @tc.type Func
2091 * @tc.level Level0
2092 */
2093 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3000, TestSize.Level0)
2094 {
2095 const char *curveNid = "NID_sm2";
2096 OH_CryptoEcPoint *point = nullptr;
2097 uint8_t ec[] = {
2098 0x03, 0x64, 0xaf, 0x65, 0x68, 0x6c, 0x49, 0xd6, 0xe3, 0x3d, 0x4e, 0x15, 0x74, 0xda, 0xc1, 0xbf,
2099 0xeb, 0x60, 0xc5, 0x03, 0x51, 0xd8, 0xd9, 0x96, 0xbf, 0xdc, 0x7d, 0xb2, 0xe8, 0x15, 0x65, 0xcc,
2100 0x05
2101 };
2102 Crypto_DataBlob ecKeyData = { .data = ec, .len = sizeof(ec)};
2103 Crypto_DataBlob new_ecKeyData = { .data = nullptr, .len = 0};
2104
2105 EXPECT_EQ(OH_CryptoEcPoint_Create(curveNid, &ecKeyData, &point), CRYPTO_SUCCESS);
2106 EXPECT_TRUE(point != nullptr);
2107 EXPECT_EQ(OH_CryptoEcPoint_Encode(point, "COMPRESSED", &new_ecKeyData), CRYPTO_SUCCESS);
2108 EXPECT_TRUE(memcmp(new_ecKeyData.data, ecKeyData.data, new_ecKeyData.len) == 0);
2109 EXPECT_EQ(new_ecKeyData.len, ecKeyData.len);
2110
2111 OH_CryptoEcPoint_Destroy(point);
2112 OH_Crypto_FreeDataBlob(&new_ecKeyData);
2113 }
2114
2115 /**
2116 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3100
2117 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3100
2118 * @tc.desc algorithm is Asym Key
2119 * @tc.size Medium
2120 * @tc.type Func
2121 * @tc.level Level0
2122 */
2123 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3100, TestSize.Level0)
2124 {
2125 const char *curveNid = "NID_X9_62_prime256v1";
2126 OH_CryptoEcPoint *point = nullptr;
2127 uint8_t ec[] = {
2128 0x02, 0x42, 0x7f, 0x7a, 0xa1, 0x7e, 0x79, 0x89, 0x77, 0x98, 0x77, 0x2f, 0xcc, 0xcb, 0x43, 0x65,
2129 0x8f, 0x77, 0xe8, 0xef, 0x26, 0xad, 0x76, 0x25, 0x0d, 0x12, 0x5e, 0xcf, 0x26, 0xf1, 0xfd, 0x0b,
2130 0x6f
2131 };
2132 Crypto_DataBlob ecKeyData = { .data = ec, .len = sizeof(ec)};
2133 Crypto_DataBlob new_ecKeyData = { .data = nullptr, .len = 0};
2134
2135 EXPECT_EQ(OH_CryptoEcPoint_Create(curveNid, &ecKeyData, &point), CRYPTO_SUCCESS);
2136 EXPECT_TRUE(point != nullptr);
2137 EXPECT_EQ(OH_CryptoEcPoint_Encode(point, "COMPRESSED", &new_ecKeyData), CRYPTO_SUCCESS);
2138 EXPECT_TRUE(memcmp(new_ecKeyData.data, ecKeyData.data, new_ecKeyData.len) == 0);
2139 EXPECT_EQ(new_ecKeyData.len, ecKeyData.len);
2140
2141 OH_CryptoEcPoint_Destroy(point);
2142 OH_Crypto_FreeDataBlob(&new_ecKeyData);
2143 }
2144
2145 /**
2146 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3200
2147 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3200
2148 * @tc.desc algorithm is Asym Key
2149 * @tc.size Medium
2150 * @tc.type Func
2151 * @tc.level Level0
2152 */
2153 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3200, TestSize.Level0)
2154 {
2155 const char *curveNid = "NID_X9_62_prime256v1";
2156 OH_CryptoEcPoint *point = nullptr;
2157 uint8_t ec[] = {
2158 0x06, 0xb4, 0x2d, 0x9f, 0xa7, 0x68, 0x6f, 0xed, 0x95, 0x1b, 0xf0, 0x02, 0x72, 0x89, 0x96, 0x95,
2159 0x1b, 0x39, 0x4c, 0x6e, 0xc6, 0x63, 0x86, 0xb7, 0x78, 0x49, 0xac, 0xc5, 0x30, 0x24, 0xb8, 0x4f,
2160 0x5a, 0xd7, 0xf3, 0x0e, 0x51, 0xe7, 0x6a, 0x9d, 0x12, 0x7a, 0x96, 0x00, 0x0a, 0xd1, 0xcb, 0xf3,
2161 0xd7, 0xf7, 0x69, 0xfd, 0x58, 0xd9, 0xac, 0x7d, 0xab, 0xac, 0xde, 0xf9, 0xbe, 0xb1, 0xc6, 0x5b,
2162 0xe7
2163 };
2164 Crypto_DataBlob ecKeyData = { .data = ec, .len = sizeof(ec)};
2165
2166 EXPECT_EQ(OH_CryptoEcPoint_Create(curveNid, &ecKeyData, &point), CRYPTO_OPERTION_ERROR);
2167 EXPECT_TRUE(point == nullptr);
2168
2169 OH_CryptoEcPoint_Destroy(point);
2170 }
2171
2172 /**
2173 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3300
2174 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3300
2175 * @tc.desc algorithm is Asym Key
2176 * @tc.size Medium
2177 * @tc.type Func
2178 * @tc.level Level0
2179 */
2180 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3300, TestSize.Level0)
2181 {
2182 const char *curveNid = "NID_X9_62_prime256v1";
2183 OH_CryptoEcPoint *point = nullptr;
2184 uint8_t ec_ge[] = {
2185 0x03, 0x42, 0x7f, 0x6a, 0xa1, 0x6e, 0x39, 0x89, 0xb7, 0x78, 0x77, 0x2f, 0xcc, 0xcb, 0x43, 0x65,
2186 0x8f, 0x77, 0xe8, 0xef, 0x26, 0xad, 0x76, 0x25, 0x0d, 0x12, 0x5e, 0xcf, 0x26, 0xf1, 0xfd, 0x0b,
2187 };
2188 uint8_t ec_le[] = {
2189 0x03, 0x42, 0x7f, 0x6a, 0xa1, 0x6e, 0x39, 0x89, 0xb7, 0x78, 0x77, 0x2f, 0xcc, 0xcb, 0x43, 0x65,
2190 0x8f, 0x77, 0xe8, 0xef, 0x26, 0xad, 0x76, 0x25, 0x0d, 0x12, 0x5e, 0xcf, 0x26, 0xf1, 0xfd, 0x0b,
2191 0x6f, 0x6f
2192 };
2193 uint8_t infinity_point[] = {
2194 0x00
2195 };
2196 Crypto_DataBlob ecKeyDataGe = { .data = ec_ge, .len = sizeof(ec_ge)};
2197 Crypto_DataBlob ecKeyDataLe = { .data = ec_le, .len = sizeof(ec_le)};
2198 Crypto_DataBlob ecKeyData = { .data = infinity_point, .len = sizeof(infinity_point)};
2199
2200 EXPECT_EQ(OH_CryptoEcPoint_Create(curveNid, &ecKeyDataGe, &point), CRYPTO_OPERTION_ERROR);
2201 EXPECT_TRUE(point == nullptr);
2202 EXPECT_EQ(OH_CryptoEcPoint_Create(curveNid, &ecKeyDataLe, &point), CRYPTO_OPERTION_ERROR);
2203 EXPECT_TRUE(point == nullptr);
2204 EXPECT_EQ(OH_CryptoEcPoint_Create(curveNid, &ecKeyData, &point), CRYPTO_OPERTION_ERROR);
2205 EXPECT_TRUE(point == nullptr);
2206
2207 OH_CryptoEcPoint_Destroy(point);
2208 }
2209
2210 /**
2211 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3400
2212 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3400
2213 * @tc.desc algorithm is Asym Key
2214 * @tc.size Medium
2215 * @tc.type Func
2216 * @tc.level Level0
2217 */
2218 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3400, TestSize.Level0)
2219 {
2220 const char *curveNid = "NID_X9_62_prime256v1";
2221 OH_CryptoEcPoint *point = nullptr;
2222 Crypto_DataBlob ecKeyData = { .data = nullptr, .len = 0};
2223 uint8_t x_le[] = {
2224 0xce, 0x9f, 0xee, 0x1b, 0xca, 0x74, 0x09, 0x8c, 0xef, 0x35, 0x01, 0x57, 0x0c, 0xb5, 0x16, 0x3a,
2225 0x73, 0x95, 0xb5, 0x94, 0x41, 0xc7, 0xc5, 0x81, 0xd4, 0x56, 0x8f, 0xa7, 0x29, 0xfe, 0x21, 0xc1,
2226 0xc1
2227 };
2228 uint8_t y_le[] = {
2229 0x94, 0x73, 0x65, 0x53, 0x8b, 0xeb, 0x1f, 0x06, 0x80, 0x17, 0xc1, 0x08, 0xf6, 0x94, 0x7c, 0xf2,
2230 0x5a, 0x3e, 0x5e, 0x08, 0x2e, 0x6e, 0x42, 0xb2, 0x15, 0x18, 0x8d, 0x1f, 0x69, 0xac, 0xdf, 0x12,
2231 0x12
2232 };
2233 uint8_t x_ge[] = {
2234 0xce, 0x9f, 0xee, 0x1b, 0xca, 0x74, 0x09, 0x8c, 0xef, 0x35, 0x01, 0x57, 0x0c, 0xb5, 0x16, 0x3a,
2235 0x73, 0x95, 0xb5, 0x94, 0x41, 0xc7, 0xc5, 0x81, 0xd4, 0x56, 0x8f, 0xa7, 0x29, 0xfe, 0x21,
2236 };
2237 uint8_t y_ge[] = {
2238 0x94, 0x73, 0x65, 0x53, 0x8b, 0xeb, 0x1f, 0x06, 0x80, 0x17, 0xc1, 0x08, 0xf6, 0x94, 0x7c, 0xf2,
2239 0x5a, 0x3e, 0x5e, 0x08, 0x2e, 0x6e, 0x42, 0xb2, 0x15, 0x18, 0x8d, 0x1f, 0x69, 0xac, 0xdf,
2240 };
2241 Crypto_DataBlob pk_x_le = { .data = x_le, .len = sizeof(x_le)};
2242 Crypto_DataBlob pk_y_le = { .data = y_le, .len = sizeof(y_le)};
2243 Crypto_DataBlob pk_x_ge = { .data = x_ge, .len = sizeof(x_ge)};
2244 Crypto_DataBlob pk_y_ge = { .data = y_ge, .len = sizeof(y_ge)};
2245
2246 EXPECT_EQ(OH_CryptoEcPoint_Create(curveNid, nullptr, &point), CRYPTO_SUCCESS);
2247 EXPECT_TRUE(point != nullptr);
2248 EXPECT_EQ(OH_CryptoEcPoint_SetCoordinate(point, &pk_x_le, &pk_y_le), CRYPTO_SUCCESS);
2249 EXPECT_EQ(OH_CryptoEcPoint_Encode(point, "UNCOMPRESSED", &ecKeyData), CRYPTO_OPERTION_ERROR);
2250 EXPECT_EQ(OH_CryptoEcPoint_Encode(point, "COMPRESSED", &ecKeyData), CRYPTO_OPERTION_ERROR);
2251 OH_CryptoEcPoint_Destroy(point);
2252 point = nullptr;
2253 EXPECT_EQ(OH_CryptoEcPoint_Create(curveNid, nullptr, &point), CRYPTO_SUCCESS);
2254 EXPECT_TRUE(point != nullptr);
2255 EXPECT_EQ(OH_CryptoEcPoint_SetCoordinate(point, &pk_x_ge, &pk_y_ge), CRYPTO_SUCCESS);
2256 EXPECT_EQ(OH_CryptoEcPoint_Encode(point, "UNCOMPRESSED", &ecKeyData), CRYPTO_OPERTION_ERROR);
2257 EXPECT_EQ(OH_CryptoEcPoint_Encode(point, "COMPRESSED", &ecKeyData), CRYPTO_OPERTION_ERROR);
2258
2259 OH_CryptoEcPoint_Destroy(point);
2260 OH_Crypto_FreeDataBlob(&ecKeyData);
2261 }
2262
2263 /**
2264 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3500
2265 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3500
2266 * @tc.desc algorithm is Asym Key
2267 * @tc.size Medium
2268 * @tc.type Func
2269 * @tc.level Level0
2270 */
2271 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3500, TestSize.Level0)
2272 {
2273 AsymPrivKeySpec asymInfo = {
2274 "PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", (uint8_t *)"0123456789",
2275 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM
2276 };
2277 Crypto_DataBlob pwBlob = {.data = asymInfo.password, .len = asymInfo.pwLen};
2278 Crypto_DataBlob cipherBlob = {.data = asymInfo.cipher, .len = asymInfo.cipherLen};
2279 Crypto_DataBlob out = { .data = nullptr, .len = 0 };
2280 OH_CryptoPrivKeyEncodingParams *params = nullptr;
2281 uint8_t new_password[] = "9876543210";
2282
2283 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair((const char *)asymInfo.algName, (const char *)asymInfo.algKeyName);
2284 ASSERT_TRUE(keyPair != nullptr);
2285 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
2286 ASSERT_TRUE(privKey != nullptr);
2287 if (asymInfo.password != nullptr) {
2288 params = OHTEST_SetParam(&pwBlob, &cipherBlob);
2289 ASSERT_TRUE(params != nullptr);
2290 }
2291 ASSERT_EQ(OH_CryptoPrivKey_Encode(privKey, asymInfo.encoding, (const char *)asymInfo.type, params, &out), CRYPTO_SUCCESS);
2292 pwBlob.data = new_password;
2293 OH_CryptoKeyPair *new_keyPair = OHTEST_ConvertKeyPair((const char *)asymInfo.algName, asymInfo.encoding, &out, nullptr, &pwBlob);
2294 ASSERT_TRUE(new_keyPair == nullptr);
2295
2296 OH_Crypto_FreeDataBlob(&out);
2297 OH_CryptoPrivKeyEncodingParams_Destroy(params);
2298 OH_CryptoKeyPair_Destroy(keyPair);
2299 }
2300
2301 /**
2302 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3600
2303 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3600
2304 * @tc.desc algorithm is Asym Key
2305 * @tc.size Medium
2306 * @tc.type Func
2307 * @tc.level Level0
2308 */
2309 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3600, TestSize.Level0)
2310 {
2311 AsymPrivKeySpec asymInfo = {
2312 "PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2",
2313 (uint8_t *)"0123456789", 10, (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM
2314 };
2315 Crypto_DataBlob pwBlob = {.data = asymInfo.password, .len = asymInfo.pwLen};
2316 Crypto_DataBlob cipherBlob = {.data = asymInfo.cipher, .len = asymInfo.cipherLen};
2317 Crypto_DataBlob out = { .data = nullptr, .len = 0 };
2318 OH_CryptoPrivKeyEncodingParams *params = nullptr;
2319
2320 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair((const char *)asymInfo.algName, (const char *)asymInfo.algKeyName);
2321 ASSERT_TRUE(keyPair != nullptr);
2322 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
2323 ASSERT_TRUE(privKey != nullptr);
2324 if (asymInfo.password != nullptr) {
2325 params = OHTEST_SetParam(&pwBlob, &cipherBlob);
2326 ASSERT_TRUE(params != nullptr);
2327 }
2328 ASSERT_EQ(OH_CryptoPrivKey_Encode(privKey, asymInfo.encoding, (const char *)asymInfo.type, params, &out), CRYPTO_SUCCESS);
2329 OH_CryptoKeyPair *new_keyPair = OHTEST_ConvertKeyPair((const char *)asymInfo.algName, asymInfo.encoding, &out, nullptr, nullptr);
2330 ASSERT_TRUE(new_keyPair == nullptr);
2331
2332 OH_Crypto_FreeDataBlob(&out);
2333 OH_CryptoPrivKeyEncodingParams_Destroy(params);
2334 OH_CryptoKeyPair_Destroy(keyPair);
2335 }
2336
2337 /**
2338 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3700
2339 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3700
2340 * @tc.desc algorithm is Asym Key
2341 * @tc.size Medium
2342 * @tc.type Func
2343 * @tc.level Level0
2344 */
2345 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3700, TestSize.Level0)
2346 {
2347 AsymPrivKeySpec asymInfo = {
2348 "PKCS1", (uint8_t *)"RSA512", (uint8_t *)"RSA512|PRIMES_2", (uint8_t *)"0123456789", 10,
2349 (uint8_t *)"AES-128-CBC", 11, (uint8_t *)"PKCS8", CRYPTO_PEM
2350 };
2351 Crypto_DataBlob pwBlob = {.data = asymInfo.password, .len = asymInfo.pwLen};
2352 Crypto_DataBlob cipherBlob = {.data = asymInfo.cipher, .len = asymInfo.cipherLen};
2353 Crypto_DataBlob out = { .data = nullptr, .len = 0 };
2354 OH_CryptoPrivKeyEncodingParams *params = nullptr;
2355
2356 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair((const char *)asymInfo.algName, (const char *)asymInfo.algKeyName);
2357 ASSERT_TRUE(keyPair != nullptr);
2358 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
2359 ASSERT_TRUE(privKey != nullptr);
2360 if (asymInfo.password != nullptr) {
2361 params = OHTEST_SetParam(&pwBlob, &cipherBlob);
2362 ASSERT_TRUE(params != nullptr);
2363 }
2364 ASSERT_EQ(OH_CryptoPrivKey_Encode(privKey, asymInfo.encoding, (const char *)asymInfo.type, params, &out), CRYPTO_SUCCESS);
2365 out.data[0]++;
2366 OH_CryptoKeyPair *new_keyPair1 = OHTEST_ConvertKeyPair((const char *)asymInfo.algName, asymInfo.encoding, &out, nullptr, &pwBlob);
2367 ASSERT_TRUE(new_keyPair1 == nullptr);
2368 out.data[0]--;
2369 out.data[160]++;
2370 OH_CryptoKeyPair *new_keyPair2 = OHTEST_ConvertKeyPair((const char *)asymInfo.algName, asymInfo.encoding, &out, nullptr, &pwBlob);
2371 ASSERT_TRUE(new_keyPair2 == nullptr);
2372
2373 OH_Crypto_FreeDataBlob(&out);
2374 OH_CryptoPrivKeyEncodingParams_Destroy(params);
2375 OH_CryptoKeyPair_Destroy(keyPair);
2376 }
2377
2378 /**
2379 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3800
2380 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3800
2381 * @tc.desc algorithm is Asym Key
2382 * @tc.size Medium
2383 * @tc.type Func
2384 * @tc.level Level0
2385 */
2386 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3800, TestSize.Level0)
2387 {
2388 const unsigned char *password = (const unsigned char *)"123456";
2389 const char *algoName = "RSA512";
2390 uint32_t passLen = 6;
2391 OH_CryptoAsymKeyGenerator *ctx = nullptr;
2392 OH_CryptoKeyPair *keyPair = nullptr;
2393 Crypto_DataBlob privBlob = { .data = g_privData, .len = sizeof(g_privData) };
2394
2395 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Create(algoName, &ctx), CRYPTO_SUCCESS);
2396 EXPECT_EQ(OH_CryptoAsymKeyGenerator_SetPassword(ctx, password, passLen), CRYPTO_SUCCESS);
2397 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_PEM, nullptr, &privBlob, &keyPair), CRYPTO_OPERTION_ERROR);
2398
2399 OH_CryptoAsymKeyGenerator_Destroy(ctx);
2400 OH_CryptoKeyPair_Destroy(keyPair);
2401 }
2402
2403 /**
2404 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3900
2405 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3900
2406 * @tc.desc algorithm is Asym Key
2407 * @tc.size Medium
2408 * @tc.type Func
2409 * @tc.level Level0
2410 */
2411 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_3900, TestSize.Level0)
2412 {
2413 const char *algoName = "RSA512";
2414 OH_CryptoAsymKeyGenerator *ctx = nullptr;
2415 OH_CryptoKeyPair *keyPair = nullptr;
2416 Crypto_DataBlob privBlob = { .data = g_privDerData, .len = sizeof(g_privDerData) };
2417
2418 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Create(algoName, &ctx), CRYPTO_SUCCESS);
2419 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_DER, nullptr, &privBlob, &keyPair), CRYPTO_SUCCESS);
2420
2421 OH_CryptoAsymKeyGenerator_Destroy(ctx);
2422 OH_CryptoKeyPair_Destroy(keyPair);
2423 }
2424
2425 /**
2426 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_4000
2427 * @tc.name OHCryptoFrameworkAsymKeyNapiTest/ASYMKEY_PRIV_TEST.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_4000/x
2428 * @tc.desc algorithm is Asym Key
2429 * @tc.size Medium
2430 * @tc.type Func
2431 * @tc.level Level0
2432 */
2433 HWTEST_P(ASYMKEY_PRIV_TEST, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_4000, TestSize.Level0)
2434 {
2435 AsymPrivKeySpec asymInfo = GetParam();
2436 Crypto_DataBlob out = { .data = nullptr, .len = 0 };
2437 Crypto_DataBlob outPub = { .data = nullptr, .len = 0 };
2438 Crypto_DataBlob new_out = { .data = nullptr, .len = 0 };
2439 uint8_t *type = nullptr;
2440
2441 OH_CryptoKeyPair *keyPair = OHTEST_GenerateKeyPair((const char *)asymInfo.algName, (const char *)asymInfo.algKeyName);
2442 ASSERT_TRUE(keyPair != nullptr);
2443 OH_CryptoPrivKey *privKey = OH_CryptoKeyPair_GetPrivKey(keyPair);
2444 ASSERT_TRUE(privKey != nullptr);
2445 OH_CryptoPubKey *pubKey = OH_CryptoKeyPair_GetPubKey(keyPair);
2446 ASSERT_TRUE(pubKey != nullptr);
2447 type = asymInfo.type ? asymInfo.type : nullptr;
2448 if (type != nullptr && strstr((const char *)type, "ECC") != nullptr) {
2449 ASSERT_EQ(OH_CryptoPrivKey_Encode(privKey, CRYPTO_DER, (const char *)type, nullptr, &out), CRYPTO_SUCCESS);
2450 ASSERT_EQ(OH_CryptoPubKey_Encode(pubKey, CRYPTO_DER, asymInfo.pubType, &outPub), CRYPTO_SUCCESS);
2451 } else {
2452 ASSERT_EQ(OH_CryptoPrivKey_Encode(privKey, CRYPTO_DER, nullptr, nullptr, &out), CRYPTO_SUCCESS);
2453 ASSERT_EQ(OH_CryptoPubKey_Encode(pubKey, CRYPTO_DER, nullptr, &outPub), CRYPTO_SUCCESS);
2454 }
2455 OH_CryptoKeyPair *new_keyPair = OHTEST_ConvertKeyPair((const char *)asymInfo.algName, CRYPTO_DER, &out, &outPub, nullptr);
2456 ASSERT_TRUE(new_keyPair != nullptr);
2457 OH_CryptoPrivKey *new_privKey = OH_CryptoKeyPair_GetPrivKey(new_keyPair);
2458 ASSERT_TRUE(new_privKey != nullptr);
2459 if (type != nullptr && strstr((const char *)type, "ECC") != nullptr) {
2460 ASSERT_EQ(OH_CryptoPrivKey_Encode(new_privKey, CRYPTO_DER, (const char *)type, nullptr, &new_out), CRYPTO_SUCCESS);
2461 } else {
2462 ASSERT_EQ(OH_CryptoPrivKey_Encode(new_privKey, CRYPTO_DER, nullptr, nullptr, &new_out), CRYPTO_SUCCESS);
2463 }
2464 if (new_out.len == out.len) {
2465 EXPECT_TRUE(memcmp(new_out.data, out.data, new_out.len) == 0);
2466 }
2467 EXPECT_TRUE(new_out.len == out.len);
2468
2469 OH_Crypto_FreeDataBlob(&out);
2470 OH_Crypto_FreeDataBlob(&new_out);
2471 OH_Crypto_FreeDataBlob(&outPub);
2472 OH_CryptoKeyPair_Destroy(keyPair);
2473 OH_CryptoKeyPair_Destroy(new_keyPair);
2474 }
2475
2476 /**
2477 * @tc.number SUB_Security_CryptoFramework_NAPI_AsymKey_Test_4100
2478 * @tc.name OHCryptoFrameworkAsymKeyNapiTest.SUB_Security_CryptoFramework_NAPI_AsymKey_Test_4100
2479 * @tc.desc algorithm is Asym Key
2480 * @tc.size Medium
2481 * @tc.type Func
2482 * @tc.level Level0
2483 */
2484 HWTEST_F(OHCryptoFrameworkAsymKeyNapiTest, SUB_Security_CryptoFramework_NAPI_AsymKey_Test_4100, TestSize.Level0)
2485 {
2486 const char *algoName = "RSA512";
2487 OH_CryptoAsymKeyGenerator *ctx = nullptr;
2488 OH_CryptoKeyPair *keyPair = nullptr;
2489 Crypto_DataBlob privBlob = { .data = g_privDerData, .len = sizeof(g_privDerData) };
2490
2491 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Create(algoName, &ctx), CRYPTO_SUCCESS);
2492 EXPECT_EQ(OH_CryptoAsymKeyGenerator_Convert(ctx, CRYPTO_PEM, nullptr, &privBlob, &keyPair), CRYPTO_OPERTION_ERROR);
2493
2494 OH_CryptoAsymKeyGenerator_Destroy(ctx);
2495 OH_CryptoKeyPair_Destroy(keyPair);
2496 }
2497
2498 } // namespace Unittest::CryptoFrameworkAsymKeyNapiTest
2499