1 /*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "securec.h"
18
19 #include "asy_key_generator.h"
20 #include "asy_key_generator_spi.h"
21 #include "blob.h"
22 #include "detailed_rsa_key_params.h"
23 #include "memory.h"
24 #include "openssl_class.h"
25 #include "openssl_common.h"
26 #include "rsa_common_param_spec.h"
27
28 using namespace std;
29 using namespace testing::ext;
30
31 namespace {
32 class CryptoRsa4096AsyKeyGeneratorBySpecTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase()40 void CryptoRsa4096AsyKeyGeneratorBySpecTest::SetUpTestCase() {}
41
TearDownTestCase()42 void CryptoRsa4096AsyKeyGeneratorBySpecTest::TearDownTestCase() {}
43
SetUp()44 void CryptoRsa4096AsyKeyGeneratorBySpecTest::SetUp() {}
45
TearDown()46 void CryptoRsa4096AsyKeyGeneratorBySpecTest::TearDown() {}
47
48 // basic generator create test
49 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest411, TestSize.Level0)
50 {
51 HcfRsaCommParamsSpec rsaCommSpec = {};
52 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
53 GenerateRsa4096CorrectCommonKeySpec(dataN, &rsaCommSpec);
54
55 HcfAsyKeyGeneratorBySpec *generator = nullptr;
56 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaCommSpec), &generator);
57 EXPECT_NE(res, HCF_SUCCESS);
58 EXPECT_EQ(generator, nullptr);
59
60 HcfObjDestroy(generator);
61 }
62
63 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest412, TestSize.Level0)
64 {
65 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
66 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
67 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
68 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
69
70 HcfAsyKeyGeneratorBySpec *generator = nullptr;
71 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
72 EXPECT_EQ(res, HCF_SUCCESS);
73 EXPECT_NE(generator, nullptr);
74
75 HcfObjDestroy(generator);
76 }
77
78 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest413, TestSize.Level0)
79 {
80 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
81 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
82 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
83 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
84 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
85
86 HcfAsyKeyGeneratorBySpec *generator = nullptr;
87 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
88 EXPECT_EQ(res, HCF_SUCCESS);
89 EXPECT_NE(generator, nullptr);
90
91 HcfObjDestroy(generator);
92 }
93
94 // test generator by spec genrate key funciton not null
95 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest414, TestSize.Level0)
96 {
97 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
98 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
99 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
100 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
101 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
102
103 HcfAsyKeyGeneratorBySpec *generator = nullptr;
104 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
105 EXPECT_EQ(res, HCF_SUCCESS);
106 EXPECT_NE(generator, nullptr);
107
108 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
109 HcfObjDestroy(generator);
110 }
111
112 // test generator by spec get class string test
113 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest415, TestSize.Level0)
114 {
115 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
116 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
117 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
118 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
119
120 HcfAsyKeyGeneratorBySpec *generator = nullptr;
121 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
122 EXPECT_EQ(res, HCF_SUCCESS);
123 EXPECT_NE(generator, nullptr);
124
125 const char *generatorBySpecClass = generator->base.getClass();
126 EXPECT_STREQ(generatorBySpecClass, g_asyKeyGeneratorBySpecClass);
127 HcfObjDestroy(generator);
128 }
129
130 // test generator by spec get getAlgName string test
131 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest416, TestSize.Level0)
132 {
133 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
134 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
135 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
136 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
137
138 HcfAsyKeyGeneratorBySpec *generator = nullptr;
139 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
140 EXPECT_EQ(res, HCF_SUCCESS);
141 EXPECT_NE(generator, nullptr);
142
143 const char *generatorBySpecAlgName = generator->getAlgName(generator);
144 EXPECT_STREQ(generatorBySpecAlgName, g_rsaAlgName);
145 HcfObjDestroy(generator);
146 }
147
148 // test generator by spec basic destroy
149 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest417, TestSize.Level0)
150 {
151 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
152 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
153 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
154 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
155
156
157 HcfAsyKeyGeneratorBySpec *generator = nullptr;
158 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
159 EXPECT_EQ(res, HCF_SUCCESS);
160 EXPECT_NE(generator, nullptr);
161
162 generator->base.destroy(&(generator->base));
163 }
164 // test correct spec and generate key pair, pri key, and pub key.
165 // pub spec
166 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest418, TestSize.Level0)
167 {
168 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
169 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
170 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
171 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
172
173 HcfAsyKeyGeneratorBySpec *generator = nullptr;
174 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
175 EXPECT_EQ(res, HCF_SUCCESS);
176 EXPECT_NE(generator, nullptr);
177
178 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
179 HcfKeyPair *keyPair = nullptr;
180 res = generator->generateKeyPair(generator, &keyPair);
181 EXPECT_EQ(res, HCF_INVALID_PARAMS);
182 EXPECT_EQ(keyPair, nullptr);
183
184 HcfObjDestroy(keyPair);
185 HcfObjDestroy(generator);
186 }
187
188 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest419, TestSize.Level0)
189 {
190 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
191 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
192 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
193 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
194
195 HcfAsyKeyGeneratorBySpec *generator = nullptr;
196 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
197 EXPECT_EQ(res, HCF_SUCCESS);
198 EXPECT_NE(generator, nullptr);
199
200 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
201 HcfPubKey *pubKey = nullptr;
202 res = generator->generatePubKey(generator, &pubKey);
203 EXPECT_EQ(res, HCF_SUCCESS);
204 EXPECT_NE(pubKey, nullptr);
205
206 HcfObjDestroy(pubKey);
207 HcfObjDestroy(generator);
208 }
209
210 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest420, TestSize.Level0)
211 {
212 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
213 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
214 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
215 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
216
217 HcfAsyKeyGeneratorBySpec *generator = nullptr;
218 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
219 EXPECT_EQ(res, HCF_SUCCESS);
220 EXPECT_NE(generator, nullptr);
221
222 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
223 HcfPriKey *priKey = nullptr;
224 res = generator->generatePriKey(generator, &priKey);
225 EXPECT_EQ(res, HCF_INVALID_PARAMS);
226 EXPECT_EQ(priKey, nullptr);
227
228 HcfObjDestroy(priKey);
229 HcfObjDestroy(generator);
230 }
231
232 // key pair spec
233 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest421, TestSize.Level0)
234 {
235 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
236 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
237 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
238 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
239 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
240
241 HcfAsyKeyGeneratorBySpec *generator = nullptr;
242 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
243 EXPECT_EQ(res, HCF_SUCCESS);
244 EXPECT_NE(generator, nullptr);
245
246 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
247 HcfKeyPair *keyPair = nullptr;
248 res = generator->generateKeyPair(generator, &keyPair);
249 EXPECT_EQ(res, HCF_SUCCESS);
250 EXPECT_NE(keyPair, nullptr);
251
252 HcfObjDestroy(keyPair);
253 HcfObjDestroy(generator);
254 }
255
256 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest422, TestSize.Level0)
257 {
258 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
259 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
260 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
261 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
262 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
263
264 HcfAsyKeyGeneratorBySpec *generator = nullptr;
265 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
266 EXPECT_EQ(res, HCF_SUCCESS);
267 EXPECT_NE(generator, nullptr);
268
269 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
270 HcfPubKey *pubKey = nullptr;
271 res = generator->generatePubKey(generator, &pubKey);
272 EXPECT_EQ(res, HCF_SUCCESS);
273 EXPECT_NE(pubKey, nullptr);
274
275 HcfObjDestroy(pubKey);
276 HcfObjDestroy(generator);
277 }
278
279 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest423, TestSize.Level0)
280 {
281 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
282 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
283 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
284 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
285 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
286
287 HcfAsyKeyGeneratorBySpec *generator = nullptr;
288 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
289 EXPECT_EQ(res, HCF_SUCCESS);
290 EXPECT_NE(generator, nullptr);
291
292 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
293 HcfPriKey *priKey = nullptr;
294 res = generator->generatePriKey(generator, &priKey);
295 EXPECT_EQ(res, HCF_SUCCESS);
296 EXPECT_NE(priKey, nullptr);
297
298 HcfObjDestroy(priKey);
299 HcfObjDestroy(generator);
300 }
301
302 // check normal key function from key pairs of key pair spec
303 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest424, TestSize.Level0)
304 {
305 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
306 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
307 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
308 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
309 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
310
311 HcfAsyKeyGeneratorBySpec *generator = nullptr;
312 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
313 EXPECT_EQ(res, HCF_SUCCESS);
314 EXPECT_NE(generator, nullptr);
315
316 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
317 HcfKeyPair *keyPair = nullptr;
318 res = generator->generateKeyPair(generator, &keyPair);
319 EXPECT_EQ(res, HCF_SUCCESS);
320 EXPECT_NE(keyPair, nullptr);
321
322 const char *keyPairClassName = keyPair->base.getClass();
323 EXPECT_STREQ(keyPairClassName, OPENSSL_RSA_KEYPAIR_CLASS);
324
325 HcfObjDestroy(keyPair);
326 HcfObjDestroy(generator);
327 }
328
329 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest425, TestSize.Level0)
330 {
331 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
332 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
333 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
334 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
335 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
336
337 HcfAsyKeyGeneratorBySpec *generator = nullptr;
338 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
339 EXPECT_EQ(res, HCF_SUCCESS);
340 EXPECT_NE(generator, nullptr);
341
342 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
343 HcfKeyPair *keyPair = nullptr;
344 res = generator->generateKeyPair(generator, &keyPair);
345 EXPECT_EQ(res, HCF_SUCCESS);
346 EXPECT_NE(keyPair, nullptr);
347
348 keyPair->base.destroy(&(keyPair->base));
349 HcfObjDestroy(generator);
350 }
351
352 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest426, TestSize.Level0)
353 {
354 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
355 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
356 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
357 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
358 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
359
360 HcfAsyKeyGeneratorBySpec *generator = nullptr;
361 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
362 EXPECT_EQ(res, HCF_SUCCESS);
363 EXPECT_NE(generator, nullptr);
364
365 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
366 HcfKeyPair *keyPair = nullptr;
367 res = generator->generateKeyPair(generator, &keyPair);
368 EXPECT_EQ(res, HCF_SUCCESS);
369 EXPECT_NE(keyPair, nullptr);
370
371 const char *pkClassName = keyPair->pubKey->base.base.getClass();
372 EXPECT_STREQ(pkClassName, OPENSSL_RSA_PUBKEY_CLASS);
373
374 HcfObjDestroy(keyPair);
375 HcfObjDestroy(generator);
376 }
377
378 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest427, TestSize.Level0)
379 {
380 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
381 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
382 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
383 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
384 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
385
386 HcfAsyKeyGeneratorBySpec *generator = nullptr;
387 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
388 EXPECT_EQ(res, HCF_SUCCESS);
389 EXPECT_NE(generator, nullptr);
390
391 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
392 HcfKeyPair *keyPair = nullptr;
393 res = generator->generateKeyPair(generator, &keyPair);
394 EXPECT_EQ(res, HCF_SUCCESS);
395 EXPECT_NE(keyPair, nullptr);
396
397 keyPair->pubKey->base.base.destroy(&(keyPair->pubKey->base.base));
398 keyPair->pubKey = nullptr;
399 HcfObjDestroy(keyPair);
400 HcfObjDestroy(generator);
401 }
402
403 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest428, TestSize.Level0)
404 {
405 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
406 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
407 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
408 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
409 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
410
411 HcfAsyKeyGeneratorBySpec *generator = nullptr;
412 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
413 EXPECT_EQ(res, HCF_SUCCESS);
414 EXPECT_NE(generator, nullptr);
415
416 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
417 HcfKeyPair *keyPair = nullptr;
418 res = generator->generateKeyPair(generator, &keyPair);
419 EXPECT_EQ(res, HCF_SUCCESS);
420 EXPECT_NE(keyPair, nullptr);
421
422 const char *alg = keyPair->pubKey->base.getAlgorithm(&(keyPair->pubKey->base));
423 EXPECT_STREQ(alg, OPENSSL_RSA_ALGORITHM);
424 HcfObjDestroy(keyPair);
425 HcfObjDestroy(generator);
426 }
427
428 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest429, TestSize.Level0)
429 {
430 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
431 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
432 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
433 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
434 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
435
436 HcfAsyKeyGeneratorBySpec *generator = nullptr;
437 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
438 EXPECT_EQ(res, HCF_SUCCESS);
439 EXPECT_NE(generator, nullptr);
440
441 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
442 HcfKeyPair *keyPair = nullptr;
443 res = generator->generateKeyPair(generator, &keyPair);
444 EXPECT_EQ(res, HCF_SUCCESS);
445 EXPECT_NE(keyPair, nullptr);
446
447 HcfBlob blob = { .data = nullptr, .len = 0 };
448 res = keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &blob);
449 EXPECT_EQ(res, HCF_SUCCESS);
450 EXPECT_NE(blob.data, nullptr);
451 EXPECT_NE(blob.len, 0);
452 HcfFree(blob.data);
453 HcfObjDestroy(keyPair);
454 HcfObjDestroy(generator);
455 }
456
457 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest430, TestSize.Level0)
458 {
459 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
460 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
461 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
462 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
463 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
464
465 HcfAsyKeyGeneratorBySpec *generator = nullptr;
466 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
467 EXPECT_EQ(res, HCF_SUCCESS);
468 EXPECT_NE(generator, nullptr);
469
470 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
471 HcfKeyPair *keyPair = nullptr;
472 res = generator->generateKeyPair(generator, &keyPair);
473 EXPECT_EQ(res, HCF_SUCCESS);
474 EXPECT_NE(keyPair, nullptr);
475
476 const char *pkFormat = keyPair->pubKey->base.getFormat(&(keyPair->pubKey->base));
477 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PUBKEY_FORMAT);
478 HcfObjDestroy(keyPair);
479 HcfObjDestroy(generator);
480 }
481
482 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest431, TestSize.Level0)
483 {
484 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
485 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
486 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
487 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
488 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
489
490 HcfAsyKeyGeneratorBySpec *generator = nullptr;
491 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
492 EXPECT_EQ(res, HCF_SUCCESS);
493 EXPECT_NE(generator, nullptr);
494
495 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
496 HcfKeyPair *keyPair = nullptr;
497 res = generator->generateKeyPair(generator, &keyPair);
498 EXPECT_EQ(res, HCF_SUCCESS);
499 EXPECT_NE(keyPair, nullptr);
500
501 HcfBigInteger n = { .data = nullptr, .len = 0 };
502 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, RSA_N_BN, &n);
503 EXPECT_EQ(res, HCF_SUCCESS);
504 EXPECT_NE(n.data, nullptr);
505 EXPECT_NE(n.len, 0);
506 res = memcmp(n.data, dataN, RSA_4096_N_BYTE_SIZE);
507 EXPECT_EQ(res, 0);
508
509 HcfFree(n.data);
510 HcfObjDestroy(keyPair);
511 HcfObjDestroy(generator);
512 }
513
514 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest432, TestSize.Level0)
515 {
516 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
517 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
518 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
519 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
520 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
521
522 HcfAsyKeyGeneratorBySpec *generator = nullptr;
523 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
524 EXPECT_EQ(res, HCF_SUCCESS);
525 EXPECT_NE(generator, nullptr);
526
527 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
528 HcfKeyPair *keyPair = nullptr;
529 res = generator->generateKeyPair(generator, &keyPair);
530 EXPECT_EQ(res, HCF_SUCCESS);
531 EXPECT_NE(keyPair, nullptr);
532
533 HcfBigInteger e = { .data = nullptr, .len = 0 };
534 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, RSA_PK_BN, &e);
535 EXPECT_EQ(res, HCF_SUCCESS);
536 EXPECT_NE(e.data, nullptr);
537 EXPECT_NE(e.len, 0);
538 res = memcmp(e.data, dataE, RSA_4096_E_BYTE_SIZE);
539 EXPECT_EQ(res, 0);
540
541 HcfFree(e.data);
542 HcfObjDestroy(keyPair);
543 HcfObjDestroy(generator);
544 }
545
546 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest433, TestSize.Level0)
547 {
548 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
549 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
550 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
551 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
552 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
553
554 HcfAsyKeyGeneratorBySpec *generator = nullptr;
555 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
556 EXPECT_EQ(res, HCF_SUCCESS);
557 EXPECT_NE(generator, nullptr);
558
559 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
560 HcfKeyPair *keyPair = nullptr;
561 res = generator->generateKeyPair(generator, &keyPair);
562 EXPECT_EQ(res, HCF_SUCCESS);
563 EXPECT_NE(keyPair, nullptr);
564
565 const char *skClassName = keyPair->priKey->base.base.getClass();
566 EXPECT_STREQ(skClassName, OPENSSL_RSA_PRIKEY_CLASS);
567 HcfObjDestroy(keyPair);
568 HcfObjDestroy(generator);
569 }
570
571 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest434, TestSize.Level0)
572 {
573 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
574 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
575 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
576 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
577 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
578
579 HcfAsyKeyGeneratorBySpec *generator = nullptr;
580 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
581 EXPECT_EQ(res, HCF_SUCCESS);
582 EXPECT_NE(generator, nullptr);
583
584 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
585 HcfKeyPair *keyPair = nullptr;
586 res = generator->generateKeyPair(generator, &keyPair);
587 EXPECT_EQ(res, HCF_SUCCESS);
588 EXPECT_NE(keyPair, nullptr);
589
590 keyPair->priKey->base.base.destroy(&(keyPair->priKey->base.base));
591 keyPair->priKey = nullptr;
592
593 HcfObjDestroy(keyPair);
594 HcfObjDestroy(generator);
595 }
596
597 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest435, TestSize.Level0)
598 {
599 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
600 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
601 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
602 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
603 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
604
605 HcfAsyKeyGeneratorBySpec *generator = nullptr;
606 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
607 EXPECT_EQ(res, HCF_SUCCESS);
608 EXPECT_NE(generator, nullptr);
609
610 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
611 HcfKeyPair *keyPair = nullptr;
612 res = generator->generateKeyPair(generator, &keyPair);
613 EXPECT_EQ(res, HCF_SUCCESS);
614 EXPECT_NE(keyPair, nullptr);
615
616 const char *alg = keyPair->priKey->base.getAlgorithm(&(keyPair->priKey->base));
617 EXPECT_STREQ(alg, OPENSSL_RSA_ALGORITHM);
618
619 HcfObjDestroy(keyPair);
620 HcfObjDestroy(generator);
621 }
622
623 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest436, TestSize.Level0)
624 {
625 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
626 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
627 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
628 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
629 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
630
631 HcfAsyKeyGeneratorBySpec *generator = nullptr;
632 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
633 EXPECT_EQ(res, HCF_SUCCESS);
634 EXPECT_NE(generator, nullptr);
635
636 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
637 HcfKeyPair *keyPair = nullptr;
638 res = generator->generateKeyPair(generator, &keyPair);
639 EXPECT_EQ(res, HCF_SUCCESS);
640 EXPECT_NE(keyPair, nullptr);
641
642 HcfBlob blob = { .data = nullptr, .len = 0 };
643 res = keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &blob);
644 EXPECT_EQ(res, HCF_NOT_SUPPORT);
645 EXPECT_EQ(blob.data, nullptr);
646 EXPECT_EQ(blob.len, 0);
647
648 HcfFree(blob.data);
649 HcfObjDestroy(keyPair);
650 HcfObjDestroy(generator);
651 }
652
653 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest437, TestSize.Level0)
654 {
655 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
656 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
657 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
658 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
659 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
660
661 HcfAsyKeyGeneratorBySpec *generator = nullptr;
662 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
663 EXPECT_EQ(res, HCF_SUCCESS);
664 EXPECT_NE(generator, nullptr);
665
666 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
667 HcfKeyPair *keyPair = nullptr;
668 res = generator->generateKeyPair(generator, &keyPair);
669 EXPECT_EQ(res, HCF_SUCCESS);
670 EXPECT_NE(keyPair, nullptr);
671
672 const char *pkFormat = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
673 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PRIKEY_FORMAT);
674
675 HcfObjDestroy(keyPair);
676 HcfObjDestroy(generator);
677 }
678
679 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest438, TestSize.Level0)
680 {
681 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
682 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
683 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
684 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
685 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
686
687 HcfAsyKeyGeneratorBySpec *generator = nullptr;
688 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
689 EXPECT_EQ(res, HCF_SUCCESS);
690 EXPECT_NE(generator, nullptr);
691
692 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
693 HcfKeyPair *keyPair = nullptr;
694 res = generator->generateKeyPair(generator, &keyPair);
695 EXPECT_EQ(res, HCF_SUCCESS);
696 EXPECT_NE(keyPair, nullptr);
697
698 const char *pkFormat = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
699 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PRIKEY_FORMAT);
700
701 HcfBigInteger n = { .data = nullptr, .len = 0 };
702 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, RSA_N_BN, &n);
703 EXPECT_EQ(res, HCF_SUCCESS);
704 EXPECT_NE(n.data, nullptr);
705 EXPECT_NE(n.len, 0);
706
707 HcfFree(n.data);
708 HcfObjDestroy(keyPair);
709 HcfObjDestroy(generator);
710 }
711
712 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest439, TestSize.Level0)
713 {
714 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
715 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
716 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
717 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
718 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
719
720 HcfAsyKeyGeneratorBySpec *generator = nullptr;
721 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
722 EXPECT_EQ(res, HCF_SUCCESS);
723 EXPECT_NE(generator, nullptr);
724
725 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
726 HcfKeyPair *keyPair = nullptr;
727 res = generator->generateKeyPair(generator, &keyPair);
728 EXPECT_EQ(res, HCF_SUCCESS);
729 EXPECT_NE(keyPair, nullptr);
730
731 const char *pkFormat = keyPair->priKey->base.getFormat(&(keyPair->priKey->base));
732 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PRIKEY_FORMAT);
733
734 HcfBigInteger d = { .data = nullptr, .len = 0 };
735 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, RSA_SK_BN, &d);
736 EXPECT_EQ(res, HCF_SUCCESS);
737 EXPECT_NE(d.data, nullptr);
738 EXPECT_NE(d.len, 0);
739
740 HcfFree(d.data);
741 HcfObjDestroy(keyPair);
742 HcfObjDestroy(generator);
743 }
744
745 // check key functions of pub key from key pair spec
746 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest440, TestSize.Level0)
747 {
748 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
749 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
750 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
751 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
752 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
753
754 HcfAsyKeyGeneratorBySpec *generator = nullptr;
755 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
756 EXPECT_EQ(res, HCF_SUCCESS);
757 EXPECT_NE(generator, nullptr);
758
759 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
760 HcfPubKey *pubKey = nullptr;
761 res = generator->generatePubKey(generator, &pubKey);
762 EXPECT_EQ(res, HCF_SUCCESS);
763 EXPECT_NE(pubKey, nullptr);
764
765 const char *pkClassName = pubKey->base.base.getClass();
766 EXPECT_STREQ(pkClassName, OPENSSL_RSA_PUBKEY_CLASS);
767
768 HcfObjDestroy(pubKey);
769 HcfObjDestroy(generator);
770 }
771
772 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest441, TestSize.Level0)
773 {
774 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
775 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
776 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
777 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
778 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
779
780 HcfAsyKeyGeneratorBySpec *generator = nullptr;
781 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
782 EXPECT_EQ(res, HCF_SUCCESS);
783 EXPECT_NE(generator, nullptr);
784
785 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
786 HcfPubKey *pubKey = nullptr;
787 res = generator->generatePubKey(generator, &pubKey);
788 EXPECT_EQ(res, HCF_SUCCESS);
789 EXPECT_NE(pubKey, nullptr);
790
791 pubKey->base.base.destroy(&(pubKey->base.base));
792 HcfObjDestroy(generator);
793 }
794
795 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest442, TestSize.Level0)
796 {
797 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
798 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
799 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
800 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
801 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
802
803 HcfAsyKeyGeneratorBySpec *generator = nullptr;
804 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
805 EXPECT_EQ(res, HCF_SUCCESS);
806 EXPECT_NE(generator, nullptr);
807
808 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
809 HcfPubKey *pubKey = nullptr;
810 res = generator->generatePubKey(generator, &pubKey);
811 EXPECT_EQ(res, HCF_SUCCESS);
812 EXPECT_NE(pubKey, nullptr);
813
814 const char *alg = pubKey->base.getAlgorithm(&(pubKey->base));
815 EXPECT_STREQ(alg, OPENSSL_RSA_ALGORITHM);
816 HcfObjDestroy(pubKey);
817 HcfObjDestroy(generator);
818 }
819
820 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest443, TestSize.Level0)
821 {
822 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
823 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
824 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
825 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
826 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
827
828 HcfAsyKeyGeneratorBySpec *generator = nullptr;
829 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
830 EXPECT_EQ(res, HCF_SUCCESS);
831 EXPECT_NE(generator, nullptr);
832
833 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
834 HcfPubKey *pubKey = nullptr;
835 res = generator->generatePubKey(generator, &pubKey);
836 EXPECT_EQ(res, HCF_SUCCESS);
837 EXPECT_NE(pubKey, nullptr);
838
839 HcfBlob blob = { .data = nullptr, .len = 0 };
840 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
841 EXPECT_EQ(res, HCF_SUCCESS);
842 EXPECT_NE(blob.data, nullptr);
843 EXPECT_NE(blob.len, 0);
844 HcfFree(blob.data);
845 HcfObjDestroy(pubKey);
846 HcfObjDestroy(generator);
847 }
848
849 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest444, TestSize.Level0)
850 {
851 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
852 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
853 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
854 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
855 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
856
857 HcfAsyKeyGeneratorBySpec *generator = nullptr;
858 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
859 EXPECT_EQ(res, HCF_SUCCESS);
860 EXPECT_NE(generator, nullptr);
861
862 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
863 HcfPubKey *pubKey = nullptr;
864 res = generator->generatePubKey(generator, &pubKey);
865 EXPECT_EQ(res, HCF_SUCCESS);
866 EXPECT_NE(pubKey, nullptr);
867
868 const char *pkFormat = pubKey->base.getFormat(&(pubKey->base));
869 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PUBKEY_FORMAT);
870 HcfObjDestroy(pubKey);
871 HcfObjDestroy(generator);
872 }
873
874 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest445, TestSize.Level0)
875 {
876 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
877 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
878 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
879 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
880 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
881
882 HcfAsyKeyGeneratorBySpec *generator = nullptr;
883 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
884 EXPECT_EQ(res, HCF_SUCCESS);
885 EXPECT_NE(generator, nullptr);
886
887 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
888 HcfPubKey *pubKey = nullptr;
889 res = generator->generatePubKey(generator, &pubKey);
890 EXPECT_EQ(res, HCF_SUCCESS);
891 EXPECT_NE(pubKey, nullptr);
892
893 HcfBigInteger n = { .data = nullptr, .len = 0 };
894 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_N_BN, &n);
895 EXPECT_EQ(res, HCF_SUCCESS);
896 EXPECT_NE(n.data, nullptr);
897 EXPECT_NE(n.len, 0);
898 res = memcmp(n.data, dataN, RSA_4096_N_BYTE_SIZE);
899 EXPECT_EQ(res, 0);
900
901 HcfFree(n.data);
902 HcfObjDestroy(pubKey);
903 HcfObjDestroy(generator);
904 }
905
906 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest446, TestSize.Level0)
907 {
908 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
909 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
910 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
911 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
912 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
913
914 HcfAsyKeyGeneratorBySpec *generator = nullptr;
915 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
916 EXPECT_EQ(res, HCF_SUCCESS);
917 EXPECT_NE(generator, nullptr);
918
919 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
920 HcfPubKey *pubKey = nullptr;
921 res = generator->generatePubKey(generator, &pubKey);
922 EXPECT_EQ(res, HCF_SUCCESS);
923 EXPECT_NE(pubKey, nullptr);
924
925 HcfBigInteger e = { .data = nullptr, .len = 0 };
926 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_PK_BN, &e);
927 EXPECT_EQ(res, HCF_SUCCESS);
928 EXPECT_NE(e.data, nullptr);
929 EXPECT_NE(e.len, 0);
930 res = memcmp(e.data, dataE, RSA_4096_E_BYTE_SIZE);
931 EXPECT_EQ(res, 0);
932
933 HcfFree(e.data);
934 HcfObjDestroy(pubKey);
935 HcfObjDestroy(generator);
936 }
937
938 // check key function of pri key generated by key pair spec
939 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest447, TestSize.Level0)
940 {
941 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
942 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
943 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
944 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
945 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
946
947 HcfAsyKeyGeneratorBySpec *generator = nullptr;
948 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
949 EXPECT_EQ(res, HCF_SUCCESS);
950 EXPECT_NE(generator, nullptr);
951
952 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
953 HcfPriKey *priKey = nullptr;
954 res = generator->generatePriKey(generator, &priKey);
955 EXPECT_EQ(res, HCF_SUCCESS);
956 EXPECT_NE(priKey, nullptr);
957
958 const char *pkClassName = priKey->base.base.getClass();
959 EXPECT_STREQ(pkClassName, OPENSSL_RSA_PRIKEY_CLASS);
960
961 HcfObjDestroy(priKey);
962 HcfObjDestroy(generator);
963 }
964
965 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest448, TestSize.Level0)
966 {
967 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
968 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
969 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
970 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
971 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
972
973 HcfAsyKeyGeneratorBySpec *generator = nullptr;
974 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
975 EXPECT_EQ(res, HCF_SUCCESS);
976 EXPECT_NE(generator, nullptr);
977
978 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
979 HcfPriKey *priKey = nullptr;
980 res = generator->generatePriKey(generator, &priKey);
981 EXPECT_EQ(res, HCF_SUCCESS);
982 EXPECT_NE(priKey, nullptr);
983
984 priKey->base.base.destroy(&(priKey->base.base));
985 HcfObjDestroy(generator);
986 }
987
988 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest449, TestSize.Level0)
989 {
990 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
991 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
992 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
993 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
994 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
995
996 HcfAsyKeyGeneratorBySpec *generator = nullptr;
997 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
998 EXPECT_EQ(res, HCF_SUCCESS);
999 EXPECT_NE(generator, nullptr);
1000
1001 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1002 HcfPriKey *priKey = nullptr;
1003 res = generator->generatePriKey(generator, &priKey);
1004 EXPECT_EQ(res, HCF_SUCCESS);
1005 EXPECT_NE(priKey, nullptr);
1006
1007 const char *alg = priKey->base.getAlgorithm(&(priKey->base));
1008 EXPECT_STREQ(alg, OPENSSL_RSA_ALGORITHM);
1009 HcfObjDestroy(priKey);
1010 HcfObjDestroy(generator);
1011 }
1012
1013 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest450, TestSize.Level0)
1014 {
1015 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1016 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1017 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1018 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1019 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1020
1021 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1022 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1023 EXPECT_EQ(res, HCF_SUCCESS);
1024 EXPECT_NE(generator, nullptr);
1025
1026 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1027 HcfPriKey *priKey = nullptr;
1028 res = generator->generatePriKey(generator, &priKey);
1029 EXPECT_EQ(res, HCF_SUCCESS);
1030 EXPECT_NE(priKey, nullptr);
1031
1032 HcfBlob blob = { .data = nullptr, .len = 0 };
1033 res = priKey->base.getEncoded(&(priKey->base), &blob);
1034 EXPECT_EQ(res, HCF_NOT_SUPPORT);
1035 EXPECT_EQ(blob.data, nullptr);
1036 EXPECT_EQ(blob.len, 0);
1037 HcfFree(blob.data);
1038 HcfObjDestroy(priKey);
1039 HcfObjDestroy(generator);
1040 }
1041
1042 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest451, TestSize.Level0)
1043 {
1044 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1045 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1046 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1047 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1048 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1049
1050 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1051 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1052 EXPECT_EQ(res, HCF_SUCCESS);
1053 EXPECT_NE(generator, nullptr);
1054
1055 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1056 HcfPriKey *priKey = nullptr;
1057 res = generator->generatePriKey(generator, &priKey);
1058 EXPECT_EQ(res, HCF_SUCCESS);
1059 EXPECT_NE(priKey, nullptr);
1060
1061 const char *pkFormat = priKey->base.getFormat(&(priKey->base));
1062 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PRIKEY_FORMAT);
1063 HcfObjDestroy(priKey);
1064 HcfObjDestroy(generator);
1065 }
1066
1067 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest452, TestSize.Level0)
1068 {
1069 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1070 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1071 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1072 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1073 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1074
1075 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1076 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1077 EXPECT_EQ(res, HCF_SUCCESS);
1078 EXPECT_NE(generator, nullptr);
1079
1080 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1081 HcfPriKey *priKey = nullptr;
1082 res = generator->generatePriKey(generator, &priKey);
1083 EXPECT_EQ(res, HCF_SUCCESS);
1084 EXPECT_NE(priKey, nullptr);
1085
1086 HcfBigInteger n = { .data = nullptr, .len = 0 };
1087 res = priKey->getAsyKeySpecBigInteger(priKey, RSA_N_BN, &n);
1088 EXPECT_EQ(res, HCF_SUCCESS);
1089 EXPECT_NE(n.data, nullptr);
1090 EXPECT_NE(n.len, 0);
1091 res = memcmp(n.data, dataN, RSA_4096_N_BYTE_SIZE);
1092 EXPECT_EQ(res, 0);
1093
1094 HcfFree(n.data);
1095 HcfObjDestroy(priKey);
1096 HcfObjDestroy(generator);
1097 }
1098
1099 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest453, TestSize.Level0)
1100 {
1101 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1102 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1103 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1104 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1105 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1106
1107 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1108 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1109 EXPECT_EQ(res, HCF_SUCCESS);
1110 EXPECT_NE(generator, nullptr);
1111
1112 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1113 HcfPriKey *priKey = nullptr;
1114 res = generator->generatePriKey(generator, &priKey);
1115 EXPECT_EQ(res, HCF_SUCCESS);
1116 EXPECT_NE(priKey, nullptr);
1117
1118 HcfBigInteger d = { .data = nullptr, .len = 0 };
1119 res = priKey->getAsyKeySpecBigInteger(priKey, RSA_SK_BN, &d);
1120 EXPECT_EQ(res, HCF_SUCCESS);
1121 EXPECT_NE(d.data, nullptr);
1122 EXPECT_NE(d.len, 0);
1123 res = memcmp(d.data, dataD, RSA_4096_D_BYTE_SIZE);
1124 EXPECT_EQ(res, 0);
1125
1126 HcfFree(d.data);
1127 HcfObjDestroy(priKey);
1128 HcfObjDestroy(generator);
1129 }
1130
1131 // check key functions of pub key from pub key spec
1132 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest454, TestSize.Level0)
1133 {
1134 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1135 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1136 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1137 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1138 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1139 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1140 EXPECT_EQ(res, HCF_SUCCESS);
1141 EXPECT_NE(generator, nullptr);
1142
1143 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1144 HcfPubKey *pubKey = nullptr;
1145 res = generator->generatePubKey(generator, &pubKey);
1146 EXPECT_EQ(res, HCF_SUCCESS);
1147 EXPECT_NE(pubKey, nullptr);
1148
1149 const char *pkClassName = pubKey->base.base.getClass();
1150 EXPECT_STREQ(pkClassName, OPENSSL_RSA_PUBKEY_CLASS);
1151
1152 HcfObjDestroy(pubKey);
1153 HcfObjDestroy(generator);
1154 }
1155
1156 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest455, TestSize.Level0)
1157 {
1158 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1159 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1160 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1161 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1162 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1163 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1164 EXPECT_EQ(res, HCF_SUCCESS);
1165 EXPECT_NE(generator, nullptr);
1166
1167 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1168 HcfPubKey *pubKey = nullptr;
1169 res = generator->generatePubKey(generator, &pubKey);
1170 EXPECT_EQ(res, HCF_SUCCESS);
1171 EXPECT_NE(pubKey, nullptr);
1172
1173 pubKey->base.base.destroy(&(pubKey->base.base));
1174 HcfObjDestroy(generator);
1175 }
1176
1177 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest456, TestSize.Level0)
1178 {
1179 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1180 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1181 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1182 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1183 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1184 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1185 EXPECT_EQ(res, HCF_SUCCESS);
1186 EXPECT_NE(generator, nullptr);
1187
1188 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1189 HcfPubKey *pubKey = nullptr;
1190 res = generator->generatePubKey(generator, &pubKey);
1191 EXPECT_EQ(res, HCF_SUCCESS);
1192 EXPECT_NE(pubKey, nullptr);
1193
1194 const char *alg = pubKey->base.getAlgorithm(&(pubKey->base));
1195 EXPECT_STREQ(alg, OPENSSL_RSA_ALGORITHM);
1196 HcfObjDestroy(pubKey);
1197 HcfObjDestroy(generator);
1198 }
1199
1200 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest457, TestSize.Level0)
1201 {
1202 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1203 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1204 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1205 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1206 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1207 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1208 EXPECT_EQ(res, HCF_SUCCESS);
1209 EXPECT_NE(generator, nullptr);
1210
1211 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1212 HcfPubKey *pubKey = nullptr;
1213 res = generator->generatePubKey(generator, &pubKey);
1214 EXPECT_EQ(res, HCF_SUCCESS);
1215 EXPECT_NE(pubKey, nullptr);
1216
1217 HcfBlob blob = { .data = nullptr, .len = 0 };
1218 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1219 EXPECT_EQ(res, HCF_SUCCESS);
1220 EXPECT_NE(blob.data, nullptr);
1221 EXPECT_NE(blob.len, 0);
1222 HcfFree(blob.data);
1223 HcfObjDestroy(pubKey);
1224 HcfObjDestroy(generator);
1225 }
1226
1227 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest458, TestSize.Level0)
1228 {
1229 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1230 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1231 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1232 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1233 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1234 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1235 EXPECT_EQ(res, HCF_SUCCESS);
1236 EXPECT_NE(generator, nullptr);
1237
1238 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1239 HcfPubKey *pubKey = nullptr;
1240 res = generator->generatePubKey(generator, &pubKey);
1241 EXPECT_EQ(res, HCF_SUCCESS);
1242 EXPECT_NE(pubKey, nullptr);
1243
1244 const char *pkFormat = pubKey->base.getFormat(&(pubKey->base));
1245 EXPECT_STREQ(pkFormat, OPENSSL_RSA_PUBKEY_FORMAT);
1246 HcfObjDestroy(pubKey);
1247 HcfObjDestroy(generator);
1248 }
1249
1250 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest459, TestSize.Level0)
1251 {
1252 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1253 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1254 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1255 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1256 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1257 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1258 EXPECT_EQ(res, HCF_SUCCESS);
1259 EXPECT_NE(generator, nullptr);
1260
1261 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1262 HcfPubKey *pubKey = nullptr;
1263 res = generator->generatePubKey(generator, &pubKey);
1264 EXPECT_EQ(res, HCF_SUCCESS);
1265 EXPECT_NE(pubKey, nullptr);
1266
1267 HcfBigInteger n = { .data = nullptr, .len = 0 };
1268 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_N_BN, &n);
1269 EXPECT_EQ(res, HCF_SUCCESS);
1270 EXPECT_NE(n.data, nullptr);
1271 EXPECT_NE(n.len, 0);
1272 res = memcmp(n.data, dataN, RSA_4096_N_BYTE_SIZE);
1273 EXPECT_EQ(res, 0);
1274
1275 HcfFree(n.data);
1276 HcfObjDestroy(pubKey);
1277 HcfObjDestroy(generator);
1278 }
1279
1280 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest460, TestSize.Level0)
1281 {
1282 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1283 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1284 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1285 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1286 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1287 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1288 EXPECT_EQ(res, HCF_SUCCESS);
1289 EXPECT_NE(generator, nullptr);
1290
1291 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1292 HcfPubKey *pubKey = nullptr;
1293 res = generator->generatePubKey(generator, &pubKey);
1294 EXPECT_EQ(res, HCF_SUCCESS);
1295 EXPECT_NE(pubKey, nullptr);
1296
1297 HcfBigInteger e = { .data = nullptr, .len = 0 };
1298 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_PK_BN, &e);
1299 EXPECT_EQ(res, HCF_SUCCESS);
1300 EXPECT_NE(e.data, nullptr);
1301 EXPECT_NE(e.len, 0);
1302 res = memcmp(e.data, dataE, RSA_4096_E_BYTE_SIZE);
1303 EXPECT_EQ(res, 0);
1304
1305 HcfFree(e.data);
1306 HcfObjDestroy(pubKey);
1307 HcfObjDestroy(generator);
1308 }
1309
1310 // check encoded key pair's pub key from key pair spec and convert to pub key object
1311 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest461, TestSize.Level0)
1312 {
1313 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1314 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1315 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1316 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1317 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1318
1319 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1320 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1321 EXPECT_EQ(res, HCF_SUCCESS);
1322 EXPECT_NE(generator, nullptr);
1323
1324 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1325 HcfKeyPair *keyPair = nullptr;
1326 res = generator->generateKeyPair(generator, &keyPair);
1327 EXPECT_EQ(res, HCF_SUCCESS);
1328 EXPECT_NE(keyPair, nullptr);
1329
1330 // encoded and convert key pair's pubKey
1331 HcfPubKey *pubKey = keyPair->pubKey;
1332 HcfBlob blob = { .data = nullptr, .len = 0 };
1333 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1334 EXPECT_EQ(res, HCF_SUCCESS);
1335 EXPECT_NE(blob.data, nullptr);
1336 EXPECT_NE(blob.len, 0);
1337
1338 HcfAsyKeyGenerator *generatorConvert = nullptr;
1339 res = HcfAsyKeyGeneratorCreate("RSA4096", &generatorConvert);
1340 EXPECT_EQ(res, HCF_SUCCESS);
1341 EXPECT_NE(generatorConvert, nullptr);
1342
1343 HcfKeyPair *dupKeyPair = nullptr;
1344 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1345 EXPECT_EQ(res, HCF_SUCCESS);
1346 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1347 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1348
1349 HcfFree(blob.data);
1350 HcfObjDestroy(keyPair);
1351 HcfObjDestroy(dupKeyPair);
1352 HcfObjDestroy(generator);
1353 HcfObjDestroy(generatorConvert);
1354 }
1355
1356 // check encoded pub key from key pair spec and convert to pub key object
1357 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest462, TestSize.Level0)
1358 {
1359 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1360 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1361 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1362 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1363 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1364
1365 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1366 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1367 EXPECT_EQ(res, HCF_SUCCESS);
1368 EXPECT_NE(generator, nullptr);
1369
1370 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1371 HcfPubKey *pubKey = nullptr;
1372 res = generator->generatePubKey(generator, &pubKey);
1373 EXPECT_EQ(res, HCF_SUCCESS);
1374 EXPECT_NE(pubKey, nullptr);
1375
1376 // encoded and convert pubKey
1377 HcfBlob blob = { .data = nullptr, .len = 0 };
1378 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1379 EXPECT_EQ(res, HCF_SUCCESS);
1380 EXPECT_NE(blob.data, nullptr);
1381 EXPECT_NE(blob.len, 0);
1382
1383 HcfAsyKeyGenerator *generatorConvert = nullptr;
1384 res = HcfAsyKeyGeneratorCreate("RSA4096", &generatorConvert);
1385 EXPECT_EQ(res, HCF_SUCCESS);
1386 EXPECT_NE(generatorConvert, nullptr);
1387
1388 HcfKeyPair *dupKeyPair = nullptr;
1389 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1390 EXPECT_EQ(res, HCF_SUCCESS);
1391 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1392 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1393
1394 HcfFree(blob.data);
1395 HcfObjDestroy(dupKeyPair);
1396 HcfObjDestroy(pubKey);
1397 HcfObjDestroy(generator);
1398 HcfObjDestroy(generatorConvert);
1399 }
1400
1401 // check encoded pub key from pub key spec and convert to pub key object
1402 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest463, TestSize.Level0)
1403 {
1404 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1405 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1406 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1407 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1408 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1409 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1410 EXPECT_EQ(res, HCF_SUCCESS);
1411 EXPECT_NE(generator, nullptr);
1412
1413 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1414 HcfPubKey *pubKey = nullptr;
1415 res = generator->generatePubKey(generator, &pubKey);
1416 EXPECT_EQ(res, HCF_SUCCESS);
1417 EXPECT_NE(pubKey, nullptr);
1418
1419 // encoded and convert pubKey
1420 HcfBlob blob = { .data = nullptr, .len = 0 };
1421 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1422 EXPECT_EQ(res, HCF_SUCCESS);
1423 EXPECT_NE(blob.data, nullptr);
1424 EXPECT_NE(blob.len, 0);
1425
1426 HcfAsyKeyGenerator *generatorConvert = nullptr;
1427 res = HcfAsyKeyGeneratorCreate("RSA4096", &generatorConvert);
1428 EXPECT_EQ(res, HCF_SUCCESS);
1429 EXPECT_NE(generatorConvert, nullptr);
1430
1431 HcfKeyPair *dupKeyPair = nullptr;
1432 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1433 EXPECT_EQ(res, HCF_SUCCESS);
1434 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1435 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1436
1437 HcfFree(blob.data);
1438 HcfObjDestroy(dupKeyPair);
1439 HcfObjDestroy(pubKey);
1440 HcfObjDestroy(generator);
1441 HcfObjDestroy(generatorConvert);
1442 }
1443
1444 // check encoded key pair's pub key from key pair spec, convert to pub key object and check the get function
1445 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest464, TestSize.Level0)
1446 {
1447 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1448 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1449 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1450 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1451 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1452
1453 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1454 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1455 EXPECT_EQ(res, HCF_SUCCESS);
1456 EXPECT_NE(generator, nullptr);
1457
1458 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1459 HcfKeyPair *keyPair = nullptr;
1460 res = generator->generateKeyPair(generator, &keyPair);
1461 EXPECT_EQ(res, HCF_SUCCESS);
1462 EXPECT_NE(keyPair, nullptr);
1463
1464 // encoded and convert key pair's pubKey
1465 HcfPubKey *pubKey = keyPair->pubKey;
1466 HcfBlob blob = { .data = nullptr, .len = 0 };
1467 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1468 EXPECT_EQ(res, HCF_SUCCESS);
1469 EXPECT_NE(blob.data, nullptr);
1470 EXPECT_NE(blob.len, 0);
1471
1472 HcfAsyKeyGenerator *generatorConvert = nullptr;
1473 res = HcfAsyKeyGeneratorCreate("RSA4096", &generatorConvert);
1474 EXPECT_EQ(res, HCF_SUCCESS);
1475 EXPECT_NE(generatorConvert, nullptr);
1476
1477 HcfKeyPair *dupKeyPair = nullptr;
1478 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1479 EXPECT_EQ(res, HCF_SUCCESS);
1480 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1481 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1482
1483 HcfBigInteger dupE = { .data = nullptr, .len = 0 };
1484 res = pubKey->getAsyKeySpecBigInteger(dupKeyPair->pubKey, RSA_PK_BN, &dupE);
1485 EXPECT_EQ(res, HCF_SUCCESS);
1486 EXPECT_NE(dupE.data, nullptr);
1487 EXPECT_NE(dupE.len, 0);
1488 res = memcmp(dupE.data, dataE, RSA_4096_E_BYTE_SIZE);
1489 EXPECT_EQ(res, 0);
1490
1491 HcfFree(blob.data);
1492 HcfFree(dupE.data);
1493 HcfObjDestroy(keyPair);
1494 HcfObjDestroy(dupKeyPair);
1495 HcfObjDestroy(generator);
1496 HcfObjDestroy(generatorConvert);
1497 }
1498
1499 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest465, TestSize.Level0)
1500 {
1501 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1502 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1503 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1504 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1505 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1506
1507 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1508 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1509 EXPECT_EQ(res, HCF_SUCCESS);
1510 EXPECT_NE(generator, nullptr);
1511
1512 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1513 HcfKeyPair *keyPair = nullptr;
1514 res = generator->generateKeyPair(generator, &keyPair);
1515 EXPECT_EQ(res, HCF_SUCCESS);
1516 EXPECT_NE(keyPair, nullptr);
1517
1518 // encoded and convert key pair's pubKey
1519 HcfPubKey *pubKey = keyPair->pubKey;
1520 HcfBlob blob = { .data = nullptr, .len = 0 };
1521 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1522 EXPECT_EQ(res, HCF_SUCCESS);
1523 EXPECT_NE(blob.data, nullptr);
1524 EXPECT_NE(blob.len, 0);
1525
1526 HcfAsyKeyGenerator *generatorConvert = nullptr;
1527 res = HcfAsyKeyGeneratorCreate("RSA4096", &generatorConvert);
1528 EXPECT_EQ(res, HCF_SUCCESS);
1529 EXPECT_NE(generatorConvert, nullptr);
1530
1531 HcfKeyPair *dupKeyPair = nullptr;
1532 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1533 EXPECT_EQ(res, HCF_SUCCESS);
1534 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1535 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1536
1537 HcfBigInteger dupN = { .data = nullptr, .len = 0 };
1538 res = pubKey->getAsyKeySpecBigInteger(dupKeyPair->pubKey, RSA_N_BN, &dupN);
1539 EXPECT_EQ(res, HCF_SUCCESS);
1540 EXPECT_NE(dupN.data, nullptr);
1541 EXPECT_NE(dupN.len, 0);
1542 res = memcmp(dupN.data, dataN, RSA_4096_N_BYTE_SIZE);
1543 EXPECT_EQ(res, 0);
1544
1545 HcfFree(blob.data);
1546 HcfFree(dupN.data);
1547 HcfObjDestroy(keyPair);
1548 HcfObjDestroy(dupKeyPair);
1549 HcfObjDestroy(generator);
1550 HcfObjDestroy(generatorConvert);
1551 }
1552
1553 // check encoded pub key from key pair spec, convert to pub key object and check the get function
1554 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest466, TestSize.Level0)
1555 {
1556 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1557 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1558 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1559 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1560 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1561
1562 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1563 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1564 EXPECT_EQ(res, HCF_SUCCESS);
1565 EXPECT_NE(generator, nullptr);
1566
1567 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1568 HcfPubKey *pubKey = nullptr;
1569 res = generator->generatePubKey(generator, &pubKey);
1570 EXPECT_EQ(res, HCF_SUCCESS);
1571 EXPECT_NE(pubKey, nullptr);
1572
1573 // encoded and convert key pair's pubKey
1574 HcfBlob blob = { .data = nullptr, .len = 0 };
1575 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1576 EXPECT_EQ(res, HCF_SUCCESS);
1577 EXPECT_NE(blob.data, nullptr);
1578 EXPECT_NE(blob.len, 0);
1579
1580 HcfAsyKeyGenerator *generatorConvert = nullptr;
1581 res = HcfAsyKeyGeneratorCreate("RSA4096", &generatorConvert);
1582 EXPECT_EQ(res, HCF_SUCCESS);
1583 EXPECT_NE(generatorConvert, nullptr);
1584
1585 HcfKeyPair *dupKeyPair = nullptr;
1586 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1587 EXPECT_EQ(res, HCF_SUCCESS);
1588 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1589 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1590
1591 HcfBigInteger dupE = { .data = nullptr, .len = 0 };
1592 res = pubKey->getAsyKeySpecBigInteger(dupKeyPair->pubKey, RSA_PK_BN, &dupE);
1593 EXPECT_EQ(res, HCF_SUCCESS);
1594 EXPECT_NE(dupE.data, nullptr);
1595 EXPECT_NE(dupE.len, 0);
1596 res = memcmp(dupE.data, dataE, RSA_4096_E_BYTE_SIZE);
1597 EXPECT_EQ(res, 0);
1598
1599 HcfFree(blob.data);
1600 HcfFree(dupE.data);
1601 HcfObjDestroy(pubKey);
1602 HcfObjDestroy(dupKeyPair);
1603 HcfObjDestroy(generator);
1604 HcfObjDestroy(generatorConvert);
1605 }
1606
1607 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest467, TestSize.Level0)
1608 {
1609 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1610 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1611 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1612 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1613 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1614
1615 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1616 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1617 EXPECT_EQ(res, HCF_SUCCESS);
1618 EXPECT_NE(generator, nullptr);
1619
1620 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1621 HcfPubKey *pubKey = nullptr;
1622 res = generator->generatePubKey(generator, &pubKey);
1623 EXPECT_EQ(res, HCF_SUCCESS);
1624 EXPECT_NE(pubKey, nullptr);
1625
1626 // encoded and convert key pair's pubKey
1627 HcfBlob blob = { .data = nullptr, .len = 0 };
1628 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1629 EXPECT_EQ(res, HCF_SUCCESS);
1630 EXPECT_NE(blob.data, nullptr);
1631 EXPECT_NE(blob.len, 0);
1632
1633 HcfAsyKeyGenerator *generatorConvert = nullptr;
1634 res = HcfAsyKeyGeneratorCreate("RSA4096", &generatorConvert);
1635 EXPECT_EQ(res, HCF_SUCCESS);
1636 EXPECT_NE(generatorConvert, nullptr);
1637
1638 HcfKeyPair *dupKeyPair = nullptr;
1639 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1640 EXPECT_EQ(res, HCF_SUCCESS);
1641 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1642 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1643
1644 HcfBigInteger dupN = { .data = nullptr, .len = 0 };
1645 res = pubKey->getAsyKeySpecBigInteger(dupKeyPair->pubKey, RSA_N_BN, &dupN);
1646 EXPECT_EQ(res, HCF_SUCCESS);
1647 EXPECT_NE(dupN.data, nullptr);
1648 EXPECT_NE(dupN.len, 0);
1649 res = memcmp(dupN.data, dataN, RSA_4096_N_BYTE_SIZE);
1650 EXPECT_EQ(res, 0);
1651
1652 HcfFree(blob.data);
1653 HcfFree(dupN.data);
1654 HcfObjDestroy(pubKey);
1655 HcfObjDestroy(dupKeyPair);
1656 HcfObjDestroy(generator);
1657 HcfObjDestroy(generatorConvert);
1658 }
1659
1660 // check encoded pub key from pubKey spec, convert to pub key object and check the get function
1661 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest468, TestSize.Level0)
1662 {
1663 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1664 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1665 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1666 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1667 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1668 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1669 EXPECT_EQ(res, HCF_SUCCESS);
1670 EXPECT_NE(generator, nullptr);
1671
1672 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1673 HcfPubKey *pubKey = nullptr;
1674 res = generator->generatePubKey(generator, &pubKey);
1675 EXPECT_EQ(res, HCF_SUCCESS);
1676 EXPECT_NE(pubKey, nullptr);
1677
1678 // encoded and convert pubKey
1679 HcfBlob blob = { .data = nullptr, .len = 0 };
1680 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1681 EXPECT_EQ(res, HCF_SUCCESS);
1682 EXPECT_NE(blob.data, nullptr);
1683 EXPECT_NE(blob.len, 0);
1684
1685 HcfAsyKeyGenerator *generatorConvert = nullptr;
1686 res = HcfAsyKeyGeneratorCreate("RSA4096", &generatorConvert);
1687 EXPECT_EQ(res, HCF_SUCCESS);
1688 EXPECT_NE(generatorConvert, nullptr);
1689
1690 HcfKeyPair *dupKeyPair = nullptr;
1691 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1692 EXPECT_EQ(res, HCF_SUCCESS);
1693 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1694 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1695
1696 HcfBigInteger dupE = { .data = nullptr, .len = 0 };
1697 res = pubKey->getAsyKeySpecBigInteger(dupKeyPair->pubKey, RSA_PK_BN, &dupE);
1698 EXPECT_EQ(res, HCF_SUCCESS);
1699 EXPECT_NE(dupE.data, nullptr);
1700 EXPECT_NE(dupE.len, 0);
1701 res = memcmp(dupE.data, dataE, RSA_4096_E_BYTE_SIZE);
1702 EXPECT_EQ(res, 0);
1703
1704 HcfFree(blob.data);
1705 HcfFree(dupE.data);
1706 HcfObjDestroy(dupKeyPair);
1707 HcfObjDestroy(pubKey);
1708 HcfObjDestroy(generator);
1709 HcfObjDestroy(generatorConvert);
1710 }
1711
1712 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest469, TestSize.Level0)
1713 {
1714 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1715 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1716 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1717 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1718 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1719 int32_t res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
1720 EXPECT_EQ(res, HCF_SUCCESS);
1721 EXPECT_NE(generator, nullptr);
1722
1723 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1724 HcfPubKey *pubKey = nullptr;
1725 res = generator->generatePubKey(generator, &pubKey);
1726 EXPECT_EQ(res, HCF_SUCCESS);
1727 EXPECT_NE(pubKey, nullptr);
1728
1729 // encoded and convert pubKey
1730 HcfBlob blob = { .data = nullptr, .len = 0 };
1731 res = pubKey->base.getEncoded(&(pubKey->base), &blob);
1732 EXPECT_EQ(res, HCF_SUCCESS);
1733 EXPECT_NE(blob.data, nullptr);
1734 EXPECT_NE(blob.len, 0);
1735
1736 HcfAsyKeyGenerator *generatorConvert = nullptr;
1737 res = HcfAsyKeyGeneratorCreate("RSA4096", &generatorConvert);
1738 EXPECT_EQ(res, HCF_SUCCESS);
1739 EXPECT_NE(generatorConvert, nullptr);
1740
1741 HcfKeyPair *dupKeyPair = nullptr;
1742 res = generatorConvert->convertKey(generatorConvert, nullptr, &blob, nullptr, &dupKeyPair);
1743 EXPECT_EQ(res, HCF_SUCCESS);
1744 EXPECT_EQ(dupKeyPair->priKey, nullptr);
1745 EXPECT_NE(dupKeyPair->pubKey, nullptr);
1746
1747 HcfBigInteger dupN = { .data = nullptr, .len = 0 };
1748 res = pubKey->getAsyKeySpecBigInteger(dupKeyPair->pubKey, RSA_N_BN, &dupN);
1749 EXPECT_EQ(res, HCF_SUCCESS);
1750 EXPECT_NE(dupN.data, nullptr);
1751 EXPECT_NE(dupN.len, 0);
1752 res = memcmp(dupN.data, dataN, RSA_4096_N_BYTE_SIZE);
1753 EXPECT_EQ(res, 0);
1754
1755 HcfFree(blob.data);
1756 HcfFree(dupN.data);
1757 HcfObjDestroy(dupKeyPair);
1758 HcfObjDestroy(pubKey);
1759 HcfObjDestroy(generator);
1760 HcfObjDestroy(generatorConvert);
1761 }
1762
1763 // check invalid get key functions of key pair's pub key from key pair spec
1764 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest470, TestSize.Level0)
1765 {
1766 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1767 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1768 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1769 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1770 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1771
1772 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1773 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1774 EXPECT_EQ(res, HCF_SUCCESS);
1775 EXPECT_NE(generator, nullptr);
1776
1777 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1778 HcfKeyPair *keyPair = nullptr;
1779 res = generator->generateKeyPair(generator, &keyPair);
1780 EXPECT_EQ(res, HCF_SUCCESS);
1781 EXPECT_NE(keyPair, nullptr);
1782
1783 EXPECT_NE(keyPair->pubKey->getAsyKeySpecInt, nullptr);
1784
1785 HcfObjDestroy(keyPair);
1786 HcfObjDestroy(generator);
1787 }
1788
1789 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest471, TestSize.Level0)
1790 {
1791 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1792 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1793 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1794 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1795 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1796
1797 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1798 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1799 EXPECT_EQ(res, HCF_SUCCESS);
1800 EXPECT_NE(generator, nullptr);
1801
1802 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1803 HcfKeyPair *keyPair = nullptr;
1804 res = generator->generateKeyPair(generator, &keyPair);
1805 EXPECT_EQ(res, HCF_SUCCESS);
1806 EXPECT_NE(keyPair, nullptr);
1807
1808 EXPECT_NE(keyPair->pubKey->getAsyKeySpecString, nullptr);
1809
1810 HcfObjDestroy(keyPair);
1811 HcfObjDestroy(generator);
1812 }
1813
1814 // check invalid get key functions of key pair's pri key from key pair spec
1815 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest472, TestSize.Level0)
1816 {
1817 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1818 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1819 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1820 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1821 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1822
1823 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1824 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1825 EXPECT_EQ(res, HCF_SUCCESS);
1826 EXPECT_NE(generator, nullptr);
1827
1828 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1829 HcfKeyPair *keyPair = nullptr;
1830 res = generator->generateKeyPair(generator, &keyPair);
1831 EXPECT_EQ(res, HCF_SUCCESS);
1832 EXPECT_NE(keyPair, nullptr);
1833
1834 EXPECT_NE(keyPair->priKey->getAsyKeySpecInt, nullptr);
1835
1836 keyPair->priKey->clearMem((HcfPriKey *)keyPair->pubKey);
1837 HcfObjDestroy(keyPair);
1838 HcfObjDestroy(generator);
1839 }
1840
1841 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest473, TestSize.Level0)
1842 {
1843 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1844 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1845 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1846 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1847 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1848
1849 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1850 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1851 EXPECT_EQ(res, HCF_SUCCESS);
1852 EXPECT_NE(generator, nullptr);
1853
1854 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1855 HcfKeyPair *keyPair = nullptr;
1856 res = generator->generateKeyPair(generator, &keyPair);
1857 EXPECT_EQ(res, HCF_SUCCESS);
1858 EXPECT_NE(keyPair, nullptr);
1859
1860 EXPECT_NE(keyPair->priKey->getAsyKeySpecString, nullptr);
1861
1862 keyPair->priKey->clearMem(keyPair->priKey);
1863 HcfObjDestroy(keyPair);
1864 HcfObjDestroy(generator);
1865 }
1866
1867 // check invalid get key functions of pub key from key pair spec
1868 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest474, TestSize.Level0)
1869 {
1870 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1871 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1872 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1873 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1874 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1875
1876 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1877 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1878 EXPECT_EQ(res, HCF_SUCCESS);
1879 EXPECT_NE(generator, nullptr);
1880
1881 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1882 HcfPubKey *pubKey = nullptr;
1883 res = generator->generatePubKey(generator, &pubKey);
1884 EXPECT_EQ(res, HCF_SUCCESS);
1885 EXPECT_NE(pubKey, nullptr);
1886
1887 EXPECT_NE(pubKey->getAsyKeySpecInt, nullptr);
1888
1889 HcfObjDestroy(pubKey);
1890 HcfObjDestroy(generator);
1891 }
1892
1893 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest475, TestSize.Level0)
1894 {
1895 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1896 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1897 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1898 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1899 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1900
1901 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1902 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1903 EXPECT_EQ(res, HCF_SUCCESS);
1904 EXPECT_NE(generator, nullptr);
1905
1906 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1907 HcfPubKey *pubKey = nullptr;
1908 res = generator->generatePubKey(generator, &pubKey);
1909 EXPECT_EQ(res, HCF_SUCCESS);
1910 EXPECT_NE(pubKey, nullptr);
1911
1912 EXPECT_NE(pubKey->getAsyKeySpecString, nullptr);
1913
1914 HcfObjDestroy(pubKey);
1915 HcfObjDestroy(generator);
1916 }
1917
1918 // check invalid get key functions of pri key from key pair spec
1919 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest476, TestSize.Level0)
1920 {
1921 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1922 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1923 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1924 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1925 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1926
1927 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1928 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1929 EXPECT_EQ(res, HCF_SUCCESS);
1930 EXPECT_NE(generator, nullptr);
1931
1932 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1933 HcfPriKey *priKey = nullptr;
1934 res = generator->generatePriKey(generator, &priKey);
1935 EXPECT_EQ(res, HCF_SUCCESS);
1936 EXPECT_NE(priKey, nullptr);
1937
1938 EXPECT_NE(priKey->getAsyKeySpecInt, nullptr);
1939
1940 priKey->clearMem(priKey);
1941 HcfObjDestroy(priKey);
1942 HcfObjDestroy(generator);
1943 }
1944
1945 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest477, TestSize.Level0)
1946 {
1947 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1948 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1949 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1950 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1951 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1952
1953 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1954 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1955 EXPECT_EQ(res, HCF_SUCCESS);
1956 EXPECT_NE(generator, nullptr);
1957
1958 EXPECT_EQ(CheckGeneratorBySpecKeyFunc(generator), true);
1959 HcfPriKey *priKey = nullptr;
1960 res = generator->generatePriKey(generator, &priKey);
1961 EXPECT_EQ(res, HCF_SUCCESS);
1962 EXPECT_NE(priKey, nullptr);
1963
1964 EXPECT_NE(priKey->getAsyKeySpecString, nullptr);
1965
1966 priKey->clearMem(priKey);
1967 HcfObjDestroy(priKey);
1968 HcfObjDestroy(generator);
1969 }
1970
1971 // HcfAsyKeyGeneratorCreate correct case: RSA 4096 generate keyPair get all big int
1972 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest478, TestSize.Level0)
1973 {
1974 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1975 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
1976 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
1977 unsigned char dataD[RSA_4096_D_BYTE_SIZE] = {0};
1978 GenerateRsa4096CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1979
1980 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1981 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec), &generator);
1982 EXPECT_EQ(res, HCF_SUCCESS);
1983 EXPECT_NE(generator, nullptr);
1984
1985 HcfKeyPair *keyPair = nullptr;
1986 // generator key type from generator's spec
1987 res = generator->generateKeyPair(generator, &keyPair);
1988 EXPECT_EQ(res, HCF_SUCCESS);
1989 EXPECT_NE(keyPair, nullptr);
1990 HcfPriKey *priKey = keyPair->priKey;
1991 HcfPubKey *pubKey = keyPair->pubKey;
1992
1993 HcfBigInteger returnPubN = { .data = nullptr, .len = 0 };
1994 HcfBigInteger returnPriN = { .data = nullptr, .len = 0 };
1995 HcfBigInteger returnE = { .data = nullptr, .len = 0 };
1996 HcfBigInteger returnD = { .data = nullptr, .len = 0 };
1997 res = priKey->getAsyKeySpecBigInteger(priKey, RSA_N_BN, &returnPriN);
1998 EXPECT_EQ(res, HCF_SUCCESS);
1999 res = priKey->getAsyKeySpecBigInteger(priKey, RSA_SK_BN, &returnD);
2000 EXPECT_EQ(res, HCF_SUCCESS);
2001 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_N_BN, &returnPubN);
2002 EXPECT_EQ(res, HCF_SUCCESS);
2003 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_PK_BN, &returnE);
2004 EXPECT_EQ(res, HCF_SUCCESS);
2005
2006 // check the array data
2007 int memRes = 0;
2008 memRes = memcmp(returnPubN.data, dataN, RSA_4096_N_BYTE_SIZE);
2009 EXPECT_EQ(memRes, 0);
2010 memRes = memcmp(returnPriN.data, dataN, RSA_4096_N_BYTE_SIZE);
2011 EXPECT_EQ(memRes, 0);
2012 memRes = memcmp(returnD.data, dataD, RSA_4096_D_BYTE_SIZE);
2013 EXPECT_EQ(memRes, 0);
2014 memRes = memcmp(returnE.data, dataE, RSA_4096_E_BYTE_SIZE);
2015 EXPECT_EQ(memRes, 0);
2016
2017 HcfFree(returnPubN.data);
2018 HcfFree(returnPriN.data);
2019 HcfFree(returnD.data);
2020 HcfFree(returnE.data);
2021 HcfObjDestroy(keyPair);
2022 HcfObjDestroy(generator);
2023 }
2024
2025 // HcfAsyKeyGeneratorCreate correct case: RSA 4096 generate pub key get
2026 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest479, TestSize.Level0)
2027 {
2028 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
2029 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
2030 unsigned char dataE[RSA_4096_E_BYTE_SIZE] = {0};
2031 GenerateRsa4096CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
2032 HcfAsyKeyGeneratorBySpec *generator = nullptr;
2033 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec), &generator);
2034 EXPECT_EQ(res, HCF_SUCCESS);
2035 EXPECT_NE(generator, nullptr);
2036
2037 HcfPubKey *pubKey = nullptr;
2038 res = generator->generatePubKey(generator, &pubKey);
2039 EXPECT_EQ(res, HCF_SUCCESS);
2040 EXPECT_NE(pubKey, nullptr);
2041
2042 HcfBigInteger returnPubN = { .data = nullptr, .len = 0 };
2043 HcfBigInteger returnE = { .data = nullptr, .len = 0 };
2044 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_N_BN, &returnPubN);
2045 EXPECT_EQ(res, HCF_SUCCESS);
2046 res = pubKey->getAsyKeySpecBigInteger(pubKey, RSA_PK_BN, &returnE);
2047 EXPECT_EQ(res, HCF_SUCCESS);
2048
2049 int memRes = 0;
2050 memRes = memcmp(returnPubN.data, dataN, RSA_4096_N_BYTE_SIZE);
2051 EXPECT_EQ(memRes, 0);
2052 memRes = memcmp(returnE.data, dataE, RSA_4096_E_BYTE_SIZE);
2053 EXPECT_EQ(memRes, 0);
2054 HcfFree(returnPubN.data);
2055 HcfFree(returnE.data);
2056 HcfObjDestroy(pubKey);
2057 HcfObjDestroy(generator);
2058 }
2059
2060 // HcfAsyKeyGeneratorCreate incorrect case: RSA 4096 generate common key spec (not support)
2061 HWTEST_F(CryptoRsa4096AsyKeyGeneratorBySpecTest, CryptoRsa4096AsyKeyGeneratorBySpecTest480, TestSize.Level0)
2062 {
2063 HcfRsaCommParamsSpec rsaCommSpec = {};
2064
2065 unsigned char dataN[RSA_4096_N_BYTE_SIZE] = {0};
2066 GenerateRsa4096CorrectCommonKeySpec(dataN, &rsaCommSpec);
2067
2068 HcfAsyKeyGeneratorBySpec *generator = nullptr;
2069 HcfResult res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaCommSpec), &generator);
2070 EXPECT_NE(res, HCF_SUCCESS);
2071 EXPECT_EQ(generator, nullptr);
2072 HcfObjDestroy(generator);
2073 }
2074 }