1 /*
2 * Copyright (c) 2024-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 "signature_tools_log.h"
18 #include "options.h"
19 #include "sign_tool_service_impl.h"
20 #include "localization_adapter.h"
21 #include "openssl/ssl.h"
22 #include "openssl/pem.h"
23 #include "openssl/err.h"
24 #include "p12_local.h"
25 #include "cmd_util.h"
26 #include "file_utils.h"
27 #include "params_run_tool.h"
28 #include "constant.h"
29 #include "params.h"
30 #include "params_trust_list.h"
31 #include "param_constants.h"
32
33 namespace OHOS {
34 namespace SignatureTools {
35
36 class GenerateKeyPairTest : public testing::Test {
37 public:
SetUpTestCase()38 static void SetUpTestCase()
39 {
40 };
TearDownTestCase()41 static void TearDownTestCase()
42 {
43 };
SetUp()44 void SetUp()
45 {
46 };
TearDown()47 void TearDown()
48 {
49 };
50 };
51
52 /*
53 * @tc.name: generate_keypair_test_001
54 * @tc.desc: Generate a key pair and load it into the keystore.
55 * @tc.type: FUNC
56 * @tc.require:
57 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_001, testing::ext::TestSize.Level1)58 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_001, testing::ext::TestSize.Level1)
59 {
60 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>();
61 std::shared_ptr<Options> params = std::make_shared<Options>();
62
63 std::string keyAlias = "oh-app1-key-v1";
64 char keyPwd[] = "123456";
65 std::string keyAlg = "ECC";
66 int keySize = 256;
67 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12";
68 char keystorePwd[] = "123456";
69
70 (*params)["keyAlias"] = keyAlias;
71 (*params)["keyPwd"] = keyPwd;
72 (*params)["keyAlg"] = keyAlg;
73 (*params)["keySize"] = keySize;
74 (*params)["keystoreFile"] = keystoreFile;
75 (*params)["keystorePwd"] = keystorePwd;
76
77 bool ret = api->GenerateKeyStore(params.get());
78 EXPECT_EQ(ret, false);
79 }
80
81 /*
82 * @tc.name: generate_keypair_test_002
83 * @tc.desc: If you search for a key pair in the keystore using an alias,
84 * @the key pair pointer is returned on success, and NULL is returned on failure.
85 * @tc.type: FUNC
86 * @tc.require:
87 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_002, testing::ext::TestSize.Level1)88 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_002, testing::ext::TestSize.Level1)
89 {
90 std::shared_ptr<Options> params = std::make_shared<Options>();
91
92 std::string keyAlias = "oh-app1-key-v1";
93 char keyPwd[] = "123456";
94 std::string keyAlg = "ECC";
95 int keySize = 256;
96 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12";
97 char keystorePwd[] = "123456";
98
99 (*params)["keyAlias"] = keyAlias;
100 (*params)["keyPwd"] = keyPwd;
101 (*params)["keyAlg"] = keyAlg;
102 (*params)["keySize"] = keySize;
103 (*params)["keystoreFile"] = keystoreFile;
104 (*params)["keystorePwd"] = keystorePwd;
105
106 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get());
107
108 int status = adaptePtr->IsAliasExist(adaptePtr->options->GetString(Options::KEY_ALIAS));
109 EXPECT_EQ(status, 0);
110 }
111
112 /*
113 * @tc.name: generate_keypair_test_003
114 * @tc.desc: Generate a key pair and load it into the keystore.
115 * @tc.type: FUNC
116 * @tc.require:
117 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_003, testing::ext::TestSize.Level1)118 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_003, testing::ext::TestSize.Level1)
119 {
120 std::shared_ptr<Options> params = std::make_shared<Options>();
121 std::string keyAlias = "oh-app1-key-v1";
122 char keyPwd[] = "123456";
123 std::string keyAlg = "ECC";
124 int keySize = 256;
125 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12";
126 char keystorePwd[] = "123456";
127 (*params)["keyAlias"] = keyAlias;
128 (*params)["keyPwd"] = keyPwd;
129 (*params)["keyAlg"] = keyAlg;
130 (*params)["keySize"] = keySize;
131 (*params)["keystoreFile"] = keystoreFile;
132 (*params)["keystorePwd"] = keystorePwd;
133 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get());
134 EVP_PKEY* keyPair = nullptr;
135 keyPair = adaptePtr->GetAliasKey(true);
136 EXPECT_NE(keyPair, nullptr);
137 }
138
139 /*
140 * @tc.name: generate_keypair_test_004
141 * @tc.desc: Generate key pair.
142 * @tc.type: FUNC
143 * @tc.require:
144 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_004, testing::ext::TestSize.Level1)145 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_004, testing::ext::TestSize.Level1)
146 {
147 std::shared_ptr<Options> params = std::make_shared<Options>();
148
149 std::string keyAlg = "ECC";
150 int keySize = 256;
151
152 (*params)["keyAlg"] = keyAlg;
153 (*params)["keySize"] = keySize;
154
155 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get());
156
157 EVP_PKEY* keyPair = nullptr;
158 std::string keyStorePath = adaptePtr->options->GetString(Options::KEY_STORE_FILE);
159 keyPair = adaptePtr->keyStoreHelper->GenerateKeyPair(adaptePtr->options->GetString(Options::KEY_ALG),
160 adaptePtr->options->GetInt(Options::KEY_SIZE));
161 EXPECT_NE(keyPair, nullptr);
162 }
163
164 /*
165 * @tc.name: generate_keypair_test_005
166 * @tc.desc: Load the key pair into the file.
167 * @tc.type: FUNC
168 * @tc.require:
169 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_005, testing::ext::TestSize.Level1)170 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_005, testing::ext::TestSize.Level1)
171 {
172 std::shared_ptr<Options> params = std::make_shared<Options>();
173
174 std::string keyAlias = "oh-app1-key-v1";
175 char keyPwd[] = "123456";
176 std::string keyAlg = "ECC";
177 int keySize = 256;
178 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12";
179 char keystorePwd[] = "123456";
180
181 (*params)["keyAlias"] = keyAlias;
182 (*params)["keyPwd"] = keyPwd;
183 (*params)["keyAlg"] = keyAlg;
184 (*params)["keySize"] = keySize;
185 (*params)["keystoreFile"] = keystoreFile;
186 (*params)["keystorePwd"] = keystorePwd;
187
188 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get());
189
190 EVP_PKEY* keyPair = nullptr;
191 std::string keyStorePath = adaptePtr->options->GetString(Options::KEY_STORE_FILE);
192 keyPair = adaptePtr->keyStoreHelper->GenerateKeyPair(adaptePtr->options->GetString(Options::KEY_ALG),
193 adaptePtr->options->GetInt(Options::KEY_SIZE));
194 int ret = adaptePtr->keyStoreHelper->WriteKeyStore(keyPair, keyStorePath,
195 adaptePtr->options->GetChars(Options::KEY_STORE_RIGHTS),
196 adaptePtr->options->GetString(Options::KEY_ALIAS),
197 adaptePtr->options->GetChars(Options::KEY_RIGHTS));
198 EXPECT_NE(ret, RET_FAILED);
199 }
200
201 /*
202 * @tc.name: generate_keypair_test_006
203 * @tc.desc: Read the key pair from the file by alias.
204 * @tc.type: FUNC
205 * @tc.require:
206 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_006, testing::ext::TestSize.Level1)207 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_006, testing::ext::TestSize.Level1)
208 {
209 std::shared_ptr<Options> params = std::make_shared<Options>();
210
211 std::string keyAlias = "oh-app1-key-v1";
212 char keyPwd[] = "123456";
213 std::string keyAlg = "ECC";
214 int keySize = 256;
215 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12";
216 char keystorePwd[] = "123456";
217
218 (*params)["keyAlias"] = keyAlias;
219 (*params)["keyPwd"] = keyPwd;
220 (*params)["keyAlg"] = keyAlg;
221 (*params)["keySize"] = keySize;
222 (*params)["keystoreFile"] = keystoreFile;
223 (*params)["keystorePwd"] = keystorePwd;
224
225 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get());
226
227 EVP_PKEY* keyPair = nullptr;
228 std::string keyStorePath = adaptePtr->options->GetString(Options::KEY_STORE_FILE);
229 adaptePtr->keyStoreHelper->ReadKeyStore(keyStorePath, adaptePtr->options->GetChars(Options::KEY_STORE_RIGHTS),
230 adaptePtr->options->GetString(Options::KEY_ALIAS),
231 adaptePtr->options->GetChars(Options::KEY_RIGHTS), &keyPair);
232 EXPECT_NE(keyPair, nullptr);
233 }
234
235 /*
236 * @tc.name: generate_keypair_test_007
237 * @tc.desc: reset passwords.
238 * @tc.type: FUNC
239 * @tc.require:
240 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_007, testing::ext::TestSize.Level1)241 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_007, testing::ext::TestSize.Level1)
242 {
243 std::shared_ptr<Options> params = std::make_shared<Options>();
244
245 char keyPwd[] = "123456";
246 char keystorePwd[] = "123456";
247 char issuerKeyPwd[] = "123456";
248 char issuerkeystorePwd[] = "123456";
249
250 (*params)["keyPwd"] = keyPwd;
251 (*params)["keystorePwd"] = keystorePwd;
252 (*params)["issuerKeyPwd"] = issuerKeyPwd;
253 (*params)["issuerKeystorePwd"] = issuerkeystorePwd;
254
255 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get());
256
257 std::string str = "";
258 adaptePtr->ResetPwd();
259 EXPECT_EQ(adaptePtr->options->GetChars(Options::KEY_RIGHTS), str);
260 EXPECT_EQ(adaptePtr->options->GetChars(Options::KEY_STORE_RIGHTS), str);
261 EXPECT_EQ(adaptePtr->options->GetChars(Options::ISSUER_KEY_RIGHTS), str);
262 EXPECT_EQ(adaptePtr->options->GetChars(Options::ISSUER_KEY_STORE_RIGHTS), str);
263 }
264
265 /*
266 * @tc.name: generate_keypair_test_008
267 * @tc.desc: Generate a key pair and load it into the keystore.
268 * @tc.type: FUNC
269 * @tc.require:
270 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_008, testing::ext::TestSize.Level1)271 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_008, testing::ext::TestSize.Level1)
272 {
273 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>();
274 std::shared_ptr<Options> params = std::make_shared<Options>();
275
276 std::string keyAlias = "aaa";
277 char keyPwd[] = "123456";
278 std::string keyAlg = "ECC";
279 int keySize = 385;
280 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12";
281 char keystorePwd[] = "123456";
282
283 (*params)["keyAlias"] = keyAlias;
284 (*params)["keyPwd"] = keyPwd;
285 (*params)["keyAlg"] = keyAlg;
286 (*params)["keySize"] = keySize;
287 (*params)["keystoreFile"] = keystoreFile;
288 (*params)["keystorePwd"] = keystorePwd;
289
290 bool ret = api->GenerateKeyStore(params.get());
291 EXPECT_EQ(ret, false);
292 }
293
294 /*
295 * @tc.name: generate_keypair_test_009
296 * @tc.desc: Generate a key pair and load it into the keystore.
297 * @tc.type: FUNC
298 * @tc.require:
299 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_009, testing::ext::TestSize.Level1)300 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_009, testing::ext::TestSize.Level1)
301 {
302 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>();
303 std::shared_ptr<Options> params = std::make_shared<Options>();
304
305 std::string keyAlias = "oh-app1-key-v1";
306 char keyPwd[] = "123456909";
307 std::string keyAlg = "ECC";
308 int keySize = 385;
309 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12";
310 char keystorePwd[] = "123456";
311
312 (*params)["keyAlias"] = keyAlias;
313 (*params)["keyPwd"] = keyPwd;
314 (*params)["keyAlg"] = keyAlg;
315 (*params)["keySize"] = keySize;
316 (*params)["keystoreFile"] = keystoreFile;
317 (*params)["keystorePwd"] = keystorePwd;
318
319 bool ret = api->GenerateKeyStore(params.get());
320 EXPECT_EQ(ret, false);
321 }
322
323 /*
324 * @tc.name: generate_keypair_test_010
325 * @tc.desc: Write the keypair to the keystore file.
326 * @tc.type: FUNC
327 * @tc.require:
328 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_010, testing::ext::TestSize.Level1)329 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_010, testing::ext::TestSize.Level1)
330 {
331 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>();
332 std::shared_ptr<Options> params = std::make_shared<Options>();
333 KeyStoreHelper keystorehelper;
334
335 std::string keyAlias = "oh-app1-key-v1";
336 char keyPwd[] = "123456";
337 std::string keyAlg = "ECC";
338 int keySize = 256;
339 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12";
340 char keystorePwd[] = "1234563333";
341
342 (*params)["keyAlias"] = keyAlias;
343 (*params)["keyPwd"] = keyPwd;
344 (*params)["keyAlg"] = keyAlg;
345 (*params)["keySize"] = keySize;
346 (*params)["keystoreFile"] = keystoreFile;
347 (*params)["keystorePwd"] = keystorePwd;
348
349 EVP_PKEY* keyPair = keystorehelper.GenerateKeyPair(keyAlg, keySize);
350
351 int ret = keystorehelper.WriteKeyStore(keyPair, keystoreFile, keystorePwd, keyAlias, keyPwd);
352 EXPECT_EQ(ret, RET_FAILED);
353 }
354
355 /*
356 * @tc.name: generate_keypair_test_011
357 * @tc.desc: The key pair is read from the P12 file by alias.
358 * @tc.type: FUNC
359 * @tc.require:
360 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_011, testing::ext::TestSize.Level1)361 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_011, testing::ext::TestSize.Level1)
362 {
363 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>();
364 std::shared_ptr<Options> params = std::make_shared<Options>();
365 KeyStoreHelper keystorehelper;
366
367 std::string keyAlias = "oh-app1-key-v1";
368 char keyPwd[] = "123456";
369 std::string keyAlg = "ECC";
370 int keySize = 256;
371 std::string keystoreFile = "./generateKeyPair/OpenHarmony99999.p12";
372 char keystorePwd[] = "123456";
373
374 (*params)["keyAlias"] = keyAlias;
375 (*params)["keyPwd"] = keyPwd;
376 (*params)["keyAlg"] = keyAlg;
377 (*params)["keySize"] = keySize;
378 (*params)["keystoreFile"] = keystoreFile;
379 (*params)["keystorePwd"] = keystorePwd;
380
381 EVP_PKEY* keyPair = nullptr;
382
383 int ret = keystorehelper.ReadKeyStore(keystoreFile, keystorePwd, keyAlias, keyPwd, &keyPair);
384 EXPECT_EQ(ret, RET_FAILED);
385 }
386
387 /*
388 * @tc.name: generate_keypair_test_012
389 * @tc.desc: Generate a key pair and load it into the keystore.
390 * @tc.type: FUNC
391 * @tc.require:
392 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_012, testing::ext::TestSize.Level1)393 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_012, testing::ext::TestSize.Level1)
394 {
395 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>();
396 std::shared_ptr<Options> params = std::make_shared<Options>();
397
398 std::string keyAlias = "oh-app1-key-v1";
399 std::string keyAlg = "ECC";
400 int keySize = 256;
401 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12";
402
403 (*params)["keyAlias"] = keyAlias;
404 (*params)["keyAlg"] = keyAlg;
405 (*params)["keySize"] = keySize;
406 (*params)["keystoreFile"] = keystoreFile;
407
408 bool ret = api->GenerateKeyStore(params.get());
409 EXPECT_EQ(ret, false);
410 }
411
412 /*
413 * @tc.name: generate_keypair_test_013
414 * @tc.desc: Generate a key pair and load it into the keystore.
415 * @tc.type: FUNC
416 * @tc.require:
417 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_013, testing::ext::TestSize.Level1)418 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_013, testing::ext::TestSize.Level1)
419 {
420 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>();
421 std::shared_ptr<Options> params = std::make_shared<Options>();
422
423 std::string keyAlias = "oh-app1-key-v1";
424 char keyPwd[] = "";
425 std::string keyAlg = "ECC";
426 int keySize = 256;
427 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12";
428 char keystorePwd[] = "";
429
430 (*params)["keyAlias"] = keyAlias;
431 (*params)["keyPwd"] = keyPwd;
432 (*params)["keyAlg"] = keyAlg;
433 (*params)["keySize"] = keySize;
434 (*params)["keystoreFile"] = keystoreFile;
435 (*params)["keystorePwd"] = keystorePwd;
436
437 bool ret = api->GenerateKeyStore(params.get());
438 EXPECT_EQ(ret, false);
439 }
440
441 /*
442 * @tc.name: generate_keypair_test_014
443 * @tc.desc: Generate a key pair and load it into the keystore.
444 * @tc.type: FUNC
445 * @tc.require:
446 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_014, testing::ext::TestSize.Level1)447 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_014, testing::ext::TestSize.Level1)
448 {
449 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>();
450 std::shared_ptr<Options> params = std::make_shared<Options>();
451
452 std::string keyAlias = "oh-app1-key-v1";
453 std::string keyAlg = "ECC";
454 int keySize = 256;
455 std::string keystoreFile = "./generateKeyPair/OpenHarmony1.p12";
456
457 (*params)["keyAlias"] = keyAlias;
458 (*params)["keyAlg"] = keyAlg;
459 (*params)["keySize"] = keySize;
460 (*params)["keystoreFile"] = keystoreFile;
461
462 bool ret = api->GenerateKeyStore(params.get());
463 EXPECT_EQ(ret, true);
464 }
465
466 /*
467 * @tc.name: generate_keypair_test_015
468 * @tc.desc: Create a p12 keystore.
469 * @tc.type: FUNC
470 * @tc.require:
471 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_015, testing::ext::TestSize.Level1)472 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_015, testing::ext::TestSize.Level1)
473 {
474 X509* cert = X509_new();
475 PKCS12* p12 = nullptr;
476 EVP_PKEY* keypair = nullptr;
477 KeyStoreHelper keyhelper;
478
479 std::string keyStorePath = "./generateKeyPair/OpenHarmony.p12";
480 char storePwd[] = "123456";
481 std::string alias = "oh-app1-key-v1";
482 char keyPwd[] = "123456";
483
484 keypair = keyhelper.GenerateKeyPair("ECC", 256);
485 keyhelper.InitX509(*cert, *keypair);
486
487 keyhelper.CreatePKCS12(&p12, keyStorePath.c_str(), storePwd, keyPwd, alias.c_str(), keypair, cert);
488 int ret = keyhelper.FindKeyPair(p12, "", nullptr, nullptr, nullptr, "");
489 EXPECT_EQ(ret, RET_FAILED);
490 }
491
492 /*
493 * @tc.name: generate_keypair_test_016
494 * @tc.desc: Generate a key pair and load it into the keystore.
495 * @tc.type: FUNC
496 * @tc.require:
497 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_016, testing::ext::TestSize.Level1)498 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_016, testing::ext::TestSize.Level1)
499 {
500 X509* cert = X509_new();
501 PKCS12* p12 = nullptr;
502 EVP_PKEY* keypair = nullptr;
503 KeyStoreHelper keyhelper;
504
505 std::string keyStorePath = "./generateKeyPair/OpenHarmony11.p12";
506 char storePwd[] = "123456";
507 std::string alias = "oh-app1-key-v1";
508 char keyPwd[] = "123456";
509
510 keypair = keyhelper.GenerateKeyPair("ECC", 256);
511 int ret = keyhelper.CreatePKCS12(&p12, keyStorePath.c_str(), storePwd, keyPwd, alias.c_str(), keypair, cert);
512 EXPECT_EQ(ret, RET_FAILED);
513 }
514
515 /*
516 * @tc.name: generate_keypair_test_017
517 * @tc.desc: Keystore password parsing.
518 * @tc.type: FUNC
519 * @tc.require:
520 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_017, testing::ext::TestSize.Level1)521 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_017, testing::ext::TestSize.Level1)
522 {
523 KeyStoreHelper keyhelper;
524 int ret = keyhelper.Pkcs12PasswordParse(nullptr, nullptr, "");
525 EXPECT_EQ(ret, RET_FAILED);
526 }
527
528 /*
529 * @tc.name: generate_keypair_test_018
530 * @tc.desc: Generate a key pair and load it into the keystore.
531 * @tc.type: FUNC
532 * @tc.require:
533 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_018, testing::ext::TestSize.Level1)534 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_018, testing::ext::TestSize.Level1)
535 {
536 X509* cert = X509_new();
537 PKCS12* p12 = nullptr;
538 EVP_PKEY* keypair = nullptr;
539 KeyStoreHelper keyhelper;
540
541 std::string keyStorePath = "./generateKeyPair/OpenHarmonyDamage.p12";
542 char storePwd[] = "123456";
543 std::string alias = "oh-app1-key-v1";
544 char keyPwd[] = "123456";
545
546 keypair = keyhelper.GenerateKeyPair("ECC", 256);
547 keyhelper.InitX509(*cert, *keypair);
548 int ret = keyhelper.CreatePKCS12(&p12, keyStorePath.c_str(), storePwd, keyPwd, alias.c_str(), keypair, cert);
549 EXPECT_EQ(ret, RET_FAILED);
550 }
551
552 /*
553 * @tc.name: generate_keypair_test_019
554 * @tc.desc: Keystore password parsing.
555 * @tc.type: FUNC
556 * @tc.require:
557 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_019, testing::ext::TestSize.Level1)558 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_019, testing::ext::TestSize.Level1)
559 {
560 X509* cert = X509_new();
561 PKCS12* p12 = nullptr;
562 EVP_PKEY* keypair = nullptr;
563 KeyStoreHelper keyhelper;
564
565 std::string keyStorePath = "./generateKeyPair/OpenHarmonyNullpwd.p12";
566 std::string alias = "oh-app1-key-v1";
567
568 keypair = keyhelper.GenerateKeyPair("ECC", 256);
569 keyhelper.InitX509(*cert, *keypair);
570 keyhelper.CreatePKCS12(&p12, keyStorePath.c_str(), nullptr, nullptr, alias.c_str(), keypair, cert);
571 int ret = keyhelper.Pkcs12PasswordParse(p12, nullptr, "");
572 EXPECT_EQ(ret, RET_OK);
573 }
574
575 /*
576 * @tc.name: generate_keypair_test_020
577 * @tc.desc: Keystore password parsing.
578 * @tc.type: FUNC
579 * @tc.require:
580 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_020, testing::ext::TestSize.Level1)581 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_020, testing::ext::TestSize.Level1)
582 {
583 X509* cert = X509_new();
584 PKCS12* p12 = nullptr;
585 EVP_PKEY* keypair = nullptr;
586 KeyStoreHelper keyhelper;
587
588 std::string keyStorePath = "./generateKeyPair/OpenHarmonyNullpwd.p12";
589 char storePwd[] = "";
590 std::string alias = "oh-app1-key-v1";
591 char keyPwd[] = "";
592
593 keypair = keyhelper.GenerateKeyPair("ECC", 256);
594 keyhelper.InitX509(*cert, *keypair);
595 keyhelper.CreatePKCS12(&p12, keyStorePath.c_str(), storePwd, keyPwd, alias.c_str(), keypair, cert);
596 int ret = keyhelper.Pkcs12PasswordParse(p12, nullptr, "");
597 EXPECT_EQ(ret, RET_OK);
598 }
599
600 /*
601 * @tc.name: generate_keypair_test_021
602 * @tc.desc: Generate a key pair.
603 * @tc.type: FUNC
604 * @tc.require:
605 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_021, testing::ext::TestSize.Level1)606 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_021, testing::ext::TestSize.Level1)
607 {
608 KeyStoreHelper keyhelper;
609 EVP_PKEY* keypair = keyhelper.GenerateKeyPair("", 256);
610 EXPECT_EQ(keypair, nullptr);
611 }
612
613 /*
614 * @tc.name: generate_keypair_test_022
615 * @tc.desc: Create a pkcs12 file.
616 * @tc.type: FUNC
617 * @tc.require:
618 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_022, testing::ext::TestSize.Level1)619 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_022, testing::ext::TestSize.Level1)
620 {
621 KeyStoreHelper keyhelper;
622 PKCS12* p12 = nullptr;
623 p12 = keyhelper.CreatePKCS12(nullptr, nullptr, nullptr, nullptr, nullptr, 0, 0, 0, 0, 0, nullptr);
624 EXPECT_EQ(p12, nullptr);
625 }
626
627 /*
628 * @tc.name: generate_keypair_test_023
629 * @tc.desc: Generate a key pair.
630 * @tc.type: FUNC
631 * @tc.require:
632 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_023, testing::ext::TestSize.Level1)633 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_023, testing::ext::TestSize.Level1)
634 {
635 KeyStoreHelper keyhelper;
636 EVP_PKEY* keypair = keyhelper.GenerateKeyPair("ECC", 0);
637 EXPECT_EQ(keypair, nullptr);
638 }
639
640 /*
641 * @tc.name: generate_keypair_test_024
642 * @tc.desc: Call the SetNidMac() function.
643 * @tc.type: FUNC
644 * @tc.require:
645 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_024, testing::ext::TestSize.Level1)646 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_024, testing::ext::TestSize.Level1)
647 {
648 int nidKey = 1;
649 int iter = 1;
650 int maIter = 1;
651 bool ret = true;
652 KeyStoreHelper keyhelper;
653 keyhelper.SetNidMac(nidKey, iter, maIter);
654 EXPECT_EQ(ret, true);
655 }
656
657 /*
658 * @tc.name: generate_keypair_test_025
659 * @tc.desc: Call the SetNidMac() function.
660 * @tc.type: FUNC
661 * @tc.require:
662 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_025, testing::ext::TestSize.Level1)663 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_025, testing::ext::TestSize.Level1)
664 {
665 int nidKey = 0;
666 int iter = 0;
667 int macIter = 0;
668 bool ret = true;
669 KeyStoreHelper keyhelper;
670 keyhelper.SetNidMac(nidKey, iter, macIter);
671 EXPECT_EQ(ret, true);
672 }
673
674 /*
675 * @tc.name: generate_keypair_test_026
676 * @tc.desc: Set the public key into the pkcs12 structure.
677 * @tc.type: FUNC
678 * @tc.require:
679 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_026, testing::ext::TestSize.Level1)680 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_026, testing::ext::TestSize.Level1)
681 {
682 KeyStoreHelper keyhelper;
683 int ret = keyhelper.SetCertPkcs12(nullptr, nullptr, nullptr, nullptr, 0, nullptr, nullptr, 0, 0, nullptr);
684 EXPECT_EQ(ret, RET_OK);
685 }
686
687 /*
688 * @tc.name: generate_keypair_test_027
689 * @tc.desc: Set the public key into the pkcs12 structure.
690 * @tc.type: FUNC
691 * @tc.require:
692 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_027, testing::ext::TestSize.Level1)693 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_027, testing::ext::TestSize.Level1)
694 {
695 KeyStoreHelper keyhelper;
696 X509* cert = X509_new();
697 int ret = keyhelper.SetCertPkcs12(cert, nullptr, nullptr, nullptr, -2, nullptr, nullptr, 0, 0, nullptr);
698 EXPECT_EQ(ret, RET_FAILED);
699 }
700
701 /*
702 * @tc.name: generate_keypair_test_028
703 * @tc.desc: Set the private key into the pkcs12 structure.
704 * @tc.type: FUNC
705 * @tc.require:
706 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_028, testing::ext::TestSize.Level1)707 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_028, testing::ext::TestSize.Level1)
708 {
709 KeyStoreHelper keyhelper;
710 int ret = keyhelper.SetPkeyPkcs12(nullptr, nullptr, nullptr, nullptr, nullptr, 0, nullptr, 0, 0, nullptr, 0);
711 EXPECT_EQ(ret, RET_OK);
712 }
713
714 /*
715 * @tc.name: generate_keypair_test_029
716 * @tc.desc: Create a p12 file.
717 * @tc.type: FUNC
718 * @tc.require:
719 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_029, testing::ext::TestSize.Level1)720 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_029, testing::ext::TestSize.Level1)
721 {
722 X509* cert = X509_new();
723 PKCS12* p12 = nullptr;
724 EVP_PKEY* keypair = nullptr;
725 KeyStoreHelper keyhelper;
726 STACK_OF(PKCS7)* safes = nullptr;
727
728 std::string keyStorePath = "./generateKeyPair/OpenHarmony.p12";
729 char storePwd1[] = "99999";
730 std::string alias = "oh-app1-key-v1";
731 char keyPwd[] = "";
732
733 keypair = keyhelper.GenerateKeyPair("ECC", 256);
734 keyhelper.InitX509(*cert, *keypair);
735 p12 = keyhelper.CreatePKCS12(storePwd1, keyPwd, nullptr, keypair, cert, 0, -2, -2, -1, 0, &safes);
736 EXPECT_EQ(p12, nullptr);
737 }
738
739 /*
740 * @tc.name: generate_keypair_test_030
741 * @tc.desc: Create a p12 file.
742 * @tc.type: FUNC
743 * @tc.require:
744 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_030, testing::ext::TestSize.Level1)745 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_030, testing::ext::TestSize.Level1)
746 {
747 X509* cert = X509_new();
748 PKCS12* p12 = nullptr;
749 EVP_PKEY* keypair = nullptr;
750 KeyStoreHelper keyhelper;
751 STACK_OF(PKCS7)* safes = nullptr;
752
753 std::string keyStorePath = "./generateKeyPair/OpenHarmony.p12";
754 char storePwd1[] = "99999";
755 std::string alias = "oh-app1-key-v1";
756 char keyPwd[] = "";
757
758 keypair = keyhelper.GenerateKeyPair("ECC", 256);
759 keyhelper.InitX509(*cert, *keypair);
760 p12 = keyhelper.CreatePKCS12(storePwd1, keyPwd, nullptr, keypair, cert, -2, 0, 0, -1, 0, &safes);
761 EXPECT_EQ(p12, nullptr);
762 }
763
764 /*
765 * @tc.name: generate_keypair_test_031
766 * @tc.desc: Find the key pair by alias.
767 * @tc.type: FUNC
768 * @tc.require:
769 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_031, testing::ext::TestSize.Level1)770 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_031, testing::ext::TestSize.Level1)
771 {
772 X509* cert = X509_new();
773 PKCS12* p12 = nullptr;
774 EVP_PKEY* keypair = nullptr;
775 KeyStoreHelper keyhelper;
776
777 std::string keyStorePath = "./generateKeyPair/OpenHarmony.p12";
778 char storePwd[] = "123456";
779 std::string alias = "oh-app1-key-v1";
780 char keyPwd[] = "123456";
781
782 keypair = keyhelper.GenerateKeyPair("ECC", 256);
783 keyhelper.InitX509(*cert, *keypair);
784
785 keyhelper.CreatePKCS12(&p12, keyStorePath.c_str(), storePwd, keyPwd, alias.c_str(), keypair, cert);
786 p12->authsafes = PKCS7_new();
787 int ret = keyhelper.FindKeyPair(p12, "", nullptr, nullptr, nullptr, "");
788 EXPECT_EQ(ret, RET_FAILED);
789 }
790
791 /*
792 * @tc.name: generate_keypair_test_032
793 * @tc.desc: Write the keypair to the keystore file.
794 * @tc.type: FUNC
795 * @tc.require:
796 */
HWTEST_F(GenerateKeyPairTest, generate_keypair_test_032, testing::ext::TestSize.Level1)797 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_032, testing::ext::TestSize.Level1)
798 {
799 KeyStoreHelper keyhelper;
800
801 std::string keyStorePath = "./generateKeyPair/OpenHarmony.p12";
802 char storePwd[] = "123456";
803 std::string alias = "oh-app1-key-v1";
804 char keyPwd[] = "123456";
805
806 int ret = keyhelper.WriteKeyStore(nullptr, keyStorePath, storePwd, alias, keyPwd);
807 EXPECT_EQ(ret, RET_FAILED);
808 }
809 } // namespace SignatureTools
810 } // namespace OHOS