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 #include <openssl/ssl.h>
16 #include <gtest/gtest.h>
17 #include "signature_tools_log.h"
18 #include "options.h"
19 #include "sign_tool_service_impl.h"
20 #include "cert_tools.h"
21 #include "params_run_tool.h"
22 #include "localization_adapter.h"
23 #include "fs_digest_utils.h"
24 #include "constant.h"
25 #include <cstdio>
26 #include <cstring>
27
28 namespace OHOS {
29 namespace SignatureTools {
30
31 class GenerateCaTest : public testing::Test {
32 public:
SetUpTestCase()33 static void SetUpTestCase()
34 {
35 };
TearDownTestCase()36 static void TearDownTestCase()
37 {
38 };
SetUp()39 void SetUp()
40 {
41 };
TearDown()42 void TearDown()
43 {
44 };
45 };
46
47
48 // rootCa
49 /**
50 * @tc.name: generate_ca_test_001
51 * @tc.desc: Test function of GenerateCa() generate a root certificate.
52 * @tc.type: FUNC
53 * @tc.require: SR000H63TL
54 */
HWTEST_F(GenerateCaTest, generate_ca_test_001, testing::ext::TestSize.Level1)55 HWTEST_F(GenerateCaTest, generate_ca_test_001, testing::ext::TestSize.Level1)
56 {
57 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
58 std::shared_ptr<Options> params = std::make_shared<Options>();
59 std::string keyAlias = "oh-app1-key-v1";
60 std::string keyAlg = "ECC";
61 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
62 std::string signAlg = "SHA384withECDSA";
63 int basicConstraintsPathLen = 0;
64 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
65 std::string outFile = "/data/test/generateCA/profile.cer";
66 int keySize = 384;
67 int validity = 3650;
68 char secret[] = "123456";
69 char ksPwd[] = "123456";
70 (*params)["keyPwd"] = secret;
71 (*params)["keystorePwd"] = ksPwd;
72 (*params)["keyAlias"] = keyAlias;
73 (*params)["keyAlg"] = keyAlg;
74 (*params)["keySize"] = keySize;
75 (*params)["subject"] = subject;
76 (*params)["signAlg"] = signAlg;
77 (*params)["keystoreFile"] = keystoreFile;
78 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
79 (*params)["outFile"] = outFile;
80 (*params)["validity"] = validity;
81
82 bool ret = api->GenerateCA(params.get());
83 EXPECT_EQ(ret, true);
84 }
85
86 // rootCa
87 /**
88 * @tc.name: generate_ca_test_002
89 * @tc.desc: Test function of GenerateCa() generate a root certificate.
90 * @tc.type: FUNC
91 * @tc.require: SR000H63TL
92 */
HWTEST_F(GenerateCaTest, generate_ca_test_002, testing::ext::TestSize.Level1)93 HWTEST_F(GenerateCaTest, generate_ca_test_002, testing::ext::TestSize.Level1)
94 {
95 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
96 std::shared_ptr<Options> params = std::make_shared<Options>();
97 std::string keyAlias = "oh-app1-key-v1";
98 std::string keyAlg = "ECC";
99 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
100 std::string signAlg = "SHA384withECDSA";
101 int basicConstraintsPathLen = 0;
102 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
103 std::string outFile = "/data/test/generateCA/root-ca-test.cer";
104 std::string issuerKeystoreFile = "/data/test/generateCA/ohtest.p12";
105 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
106 int keySize = 384;
107 char secret[] = "123456";
108 char ksPwd[] = "123456";
109 char isksPwd[] = "123456";
110 (*params)["keyPwd"] = secret;
111 (*params)["keystorePwd"] = ksPwd;
112 (*params)["issuerKeystorePwd"] = isksPwd;
113 (*params)["keyAlias"] = keyAlias;
114 (*params)["keyAlg"] = keyAlg;
115 (*params)["keySize"] = keySize;
116 (*params)["subject"] = subject;
117 (*params)["issuer"] = issuer;
118 (*params)["signAlg"] = signAlg;
119 (*params)["keystoreFile"] = keystoreFile;
120 (*params)["issuerKeystoreFile"] = issuerKeystoreFile;
121 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
122 (*params)["outFile"] = outFile;
123 bool ret = api->GenerateCA(params.get());
124 EXPECT_EQ(ret, true);
125 }
126
127 // rootCa
128 /**
129 * @tc.name: generate_ca_test_003
130 * @tc.desc: Test function of GenerateCa() FAILED to generate a root certificate.
131 * @tc.type: FUNC
132 * @tc.require: SR000H63TL
133 */
HWTEST_F(GenerateCaTest, generate_ca_test_003, testing::ext::TestSize.Level1)134 HWTEST_F(GenerateCaTest, generate_ca_test_003, testing::ext::TestSize.Level1)
135 {
136 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
137 std::shared_ptr<Options> params = std::make_shared<Options>();
138 std::string keyAlias = "oh-app1-key-v1";
139 std::string keyAlg = "ECC";
140 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
141 std::string signAlg = "SHA384withECDSA";
142 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
143 std::string outFile = "/data/test/generateCA/root-ca-test.cer";
144 int keySize = 384;
145 int validity = 365;
146 int basicConstraintsPathLen = 0;
147 (*params)["keyAlias"] = keyAlias;
148 (*params)["keyAlg"] = keyAlg;
149 (*params)["keySize"] = keySize;
150 (*params)["subject"] = subject;
151 (*params)["signAlg"] = signAlg;
152 (*params)["keystoreFile"] = keystoreFile;
153 (*params)["validity"] = validity;
154 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
155 (*params)["outFile"] = outFile;
156
157 bool ret = api->GenerateCA(params.get());
158 EXPECT_EQ(ret, false);
159 }
160
161 /**
162 * @tc.name: generate_ca_test_004
163 * @tc.desc: Test function of GenerateCa() FAILED to generate a root certificate without a subject.
164 * @tc.type: FUNC
165 * @tc.require: SR000H63TL
166 */
HWTEST_F(GenerateCaTest, generate_ca_test_004, testing::ext::TestSize.Level1)167 HWTEST_F(GenerateCaTest, generate_ca_test_004, testing::ext::TestSize.Level1)
168 {
169 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
170 std::shared_ptr<Options> params = std::make_shared<Options>();
171 std::string keyAlias = "oh-app1-key-v1";
172 std::string keyAlg = "ECC";
173 std::string signAlg = "SHA384withECDSA";
174 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
175 std::string outFile = "/data/test/generateCA/root-ca-test.cer";
176 int keySize = 384;
177 int validity = 365;
178 int basicConstraintsPathLen = 0;
179 (*params)["keyAlias"] = keyAlias;
180 (*params)["keyAlg"] = keyAlg;
181 (*params)["keySize"] = keySize;
182 (*params)["signAlg"] = signAlg;
183 (*params)["keystoreFile"] = keystoreFile;
184 (*params)["validity"] = validity;
185 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
186 (*params)["outFile"] = outFile;
187
188 bool ret = api->GenerateCA(params.get());
189 EXPECT_EQ(ret, false);
190 }
191
192 /**
193 * @tc.name: generate_ca_test_005
194 * @tc.desc: Test function of GenerateCa() FAILED to generate a root certificate without a keyalg.
195 * @tc.type: FUNC
196 * @tc.require: SR000H63TL
197 */
HWTEST_F(GenerateCaTest, generate_ca_test_005, testing::ext::TestSize.Level1)198 HWTEST_F(GenerateCaTest, generate_ca_test_005, testing::ext::TestSize.Level1)
199 {
200 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
201 std::shared_ptr<Options> params = std::make_shared<Options>();
202 std::string keyAlias = "oh-app1-key-v1";
203 std::string signAlg = "SHA384withECDSA";
204 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
205 std::string outFile = "/data/test/generateCA/root-ca-test.cer";
206 int keySize = 384;
207 int validity = 365;
208 int basicConstraintsPathLen = 0;
209 (*params)["keyAlias"] = keyAlias;
210 (*params)["keySize"] = keySize;
211 (*params)["signAlg"] = signAlg;
212 (*params)["keystoreFile"] = keystoreFile;
213 (*params)["validity"] = validity;
214 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
215 (*params)["outFile"] = outFile;
216
217 bool ret = api->GenerateCA(params.get());
218 EXPECT_EQ(ret, false);
219 }
220
221 /**
222 * @tc.name: generate_ca_test_006
223 * @tc.desc: Test function of GenerateCa() FAILED to generate a sub certificate with a error key password.
224 * @tc.type: FUNC
225 * @tc.require: SR000H63TL
226 */
HWTEST_F(GenerateCaTest, generate_ca_test_006, testing::ext::TestSize.Level1)227 HWTEST_F(GenerateCaTest, generate_ca_test_006, testing::ext::TestSize.Level1)
228 {
229 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
230 std::shared_ptr<Options> params = std::make_shared<Options>();
231 std::string keyAlias = "oh-app1-key-v1";
232 std::string issuerkeyAlias = "oh-app1-key-v1";
233 std::string keyAlg = "ECC";
234 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
235 int basicConstraintsPathLen = 0;
236 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
237 std::string outFile = "/data/test/generateCA/profile.cer";
238 std::string issuerKeystoreFile = "/data/test/generateCA/ohtest.p12";
239 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
240 int keySize = 384;
241 char secret[] = "adhjkljasjhdk";
242 char ksPwd[] = "123456";
243 char isksPwd[] = "123456";
244 (*params)["keyPwd"] = secret;
245 (*params)["keystorePwd"] = ksPwd;
246 (*params)["issuerKeystorePwd"] = isksPwd;
247 (*params)["keyAlias"] = keyAlias;
248 (*params)["issuerKeyAlias"] = issuerkeyAlias;
249 (*params)["keyAlg"] = keyAlg;
250 (*params)["keySize"] = keySize;
251 (*params)["subject"] = subject;
252 (*params)["issuer"] = issuer;
253 (*params)["keystoreFile"] = keystoreFile;
254 (*params)["issuerKeystoreFile"] = issuerKeystoreFile;
255 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
256 (*params)["outFile"] = outFile;
257
258 bool ret = api->GenerateCA(params.get());
259 EXPECT_EQ(ret, false);
260 }
261
262 /**
263 * @tc.name: generate_ca_test_007
264 * @tc.desc: Test function of GenerateCa() FAILED to generate a sub certificate with a error skystore password.
265 * @tc.type: FUNC
266 * @tc.require: SR000H63TL
267 */
HWTEST_F(GenerateCaTest, generate_ca_test_007, testing::ext::TestSize.Level1)268 HWTEST_F(GenerateCaTest, generate_ca_test_007, testing::ext::TestSize.Level1)
269 {
270 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
271 std::shared_ptr<Options> params = std::make_shared<Options>();
272 std::string keyAlias = "oh-app1-key-v1";
273 std::string issuerkeyAlias = "oh-app1-key-v1";
274 std::string keyAlg = "ECC";
275 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
276 std::string signAlg = "SHA384withECDSA";
277 int basicConstraintsPathLen = 0;
278 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
279 std::string outFile = "/data/test/generateCA/profile.cer";
280 std::string issuerKeystoreFile = "/data/test/generateCA/ohtest.p12";
281 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
282 int keySize = 384;
283 char secret[] = "adhjkljasjhdk";
284 char ksPwd[] = "123456";
285 char isksPwd[] = "554245";
286 (*params)["keyPwd"] = secret;
287 (*params)["keystorePwd"] = ksPwd;
288 (*params)["issuerKeystorePwd"] = isksPwd;
289 (*params)["keyAlias"] = keyAlias;
290 (*params)["issuerKeyAlias"] = issuerkeyAlias;
291 (*params)["keyAlg"] = keyAlg;
292 (*params)["keySize"] = keySize;
293 (*params)["subject"] = subject;
294 (*params)["issuer"] = issuer;
295 (*params)["signAlg"] = signAlg;
296 (*params)["keystoreFile"] = keystoreFile;
297 (*params)["issuerKeystoreFile"] = issuerKeystoreFile;
298 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
299 (*params)["outFile"] = outFile;
300
301 bool ret = api->GenerateCA(params.get());
302 EXPECT_EQ(ret, false);
303 }
304
305 /**
306 * @tc.name: generate_ca_test_008
307 * @tc.desc: Test function of GenerateCa() FAILED to generate a sub certificate with a error issuerkeystore password.
308 * @tc.type: FUNC
309 * @tc.require: SR000H63TL
310 */
HWTEST_F(GenerateCaTest, generate_ca_test_008, testing::ext::TestSize.Level1)311 HWTEST_F(GenerateCaTest, generate_ca_test_008, testing::ext::TestSize.Level1)
312 {
313 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
314 std::shared_ptr<Options> params = std::make_shared<Options>();
315 std::string keyAlias = "oh-app1-key-v1";
316 std::string issuerkeyAlias = "oh-app1-key-v1";
317 std::string keyAlg = "ECC";
318 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
319 std::string signAlg = "SHA384withECDSA";
320 int basicConstraintsPathLen = 0;
321 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
322 std::string outFile = "/data/test/generateCA/profile.cer";
323 std::string issuerKeystoreFile = "/data/test/generateCA/ohtest.pp12";
324 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
325 int keySize = 384;
326 char secret[] = "adhjkljasjhdk";
327 char ksPwd[] = "123456";
328 char isksPwd[] = "554245";
329 (*params)["keyPwd"] = secret;
330 (*params)["keystorePwd"] = ksPwd;
331 (*params)["issuerKeystorePwd"] = isksPwd;
332 (*params)["keyAlias"] = keyAlias;
333 (*params)["issuerKeyAlias"] = issuerkeyAlias;
334 (*params)["keyAlg"] = keyAlg;
335 (*params)["keySize"] = keySize;
336 (*params)["subject"] = subject;
337 (*params)["issuer"] = issuer;
338 (*params)["signAlg"] = signAlg;
339 (*params)["keystoreFile"] = keystoreFile;
340 (*params)["issuerKeystoreFile"] = issuerKeystoreFile;
341 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
342 (*params)["outFile"] = outFile;
343
344 bool ret = api->GenerateCA(params.get());
345 EXPECT_EQ(ret, false);
346 }
347
348 /**
349 * @tc.name: generate_ca_test_009
350 * @tc.desc: Test function of GenerateCa() FAILED to generate a sub certificate with a error keystorefile path.
351 * @tc.type: FUNC
352 * @tc.require: SR000H63TL
353 */
HWTEST_F(GenerateCaTest, generate_ca_test_009, testing::ext::TestSize.Level1)354 HWTEST_F(GenerateCaTest, generate_ca_test_009, testing::ext::TestSize.Level1)
355 {
356 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
357 std::shared_ptr<Options> params = std::make_shared<Options>();
358 std::string keyAlias = "oh-app1-key-v1";
359 std::string issuerkeyAlias = "oh-app1-key-v1";
360 std::string keyAlg = "ECC";
361 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
362 std::string signAlg = "SHA384withECDSA";
363 int basicConstraintsPathLen = 5;
364 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
365 std::string outFile = "/data/test/generateCA/profile.cer";
366 std::string issuerKeystoreFile = "/data/test/generateCA/ohtest.p12";
367 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
368 int keySize = 384;
369 char secret[] = "adhjkljasjhdk";
370 char ksPwd[] = "123456";
371 char isksPwd[] = "123456";
372 (*params)["keyPwd"] = secret;
373 (*params)["keystorePwd"] = ksPwd;
374 (*params)["issuerKeystorePwd"] = isksPwd;
375 (*params)["keyAlias"] = keyAlias;
376 (*params)["issuerKeyAlias"] = issuerkeyAlias;
377 (*params)["keyAlg"] = keyAlg;
378 (*params)["keySize"] = keySize;
379 (*params)["subject"] = subject;
380 (*params)["issuer"] = issuer;
381 (*params)["signAlg"] = signAlg;
382 (*params)["keystoreFile"] = keystoreFile;
383 (*params)["issuerKeystoreFile"] = issuerKeystoreFile;
384 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
385 (*params)["outFile"] = outFile;
386
387 bool ret = api->GenerateCA(params.get());
388 EXPECT_EQ(ret, false);
389 }
390
391 /**
392 * @tc.name: generate_ca_test_010
393 * @tc.desc: Test function of GenerateCa() SUCCESS to generate a root certificate.
394 * @tc.type: FUNC
395 * @tc.require: SR000H63TL
396 */
HWTEST_F(GenerateCaTest, generate_ca_test_010, testing::ext::TestSize.Level1)397 HWTEST_F(GenerateCaTest, generate_ca_test_010, testing::ext::TestSize.Level1)
398 {
399 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
400 std::shared_ptr<Options> params = std::make_shared<Options>();
401 std::string keyAlias = "oh-app1-key-v1";
402 std::string keyAlg = "ECC";
403 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
404 std::string signAlg = "SHA384withECDSA";
405 int basicConstraintsPathLen = 5;
406 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
407 std::string outFile = "/data/test/generateCA/root-ca-test.cer";
408 std::string issuerKeystoreFile = "/data/test/generateCA/ohtest.p12";
409 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
410 int keySize = 384;
411 char secret[] = "123456";
412 char ksPwd[] = "123456";
413 char isksPwd[] = "123456";
414 (*params)["keyPwd"] = secret;
415 (*params)["keystorePwd"] = ksPwd;
416 (*params)["issuerKeystorePwd"] = isksPwd;
417 (*params)["keyAlias"] = keyAlias;
418 (*params)["keyAlg"] = keyAlg;
419 (*params)["keySize"] = keySize;
420 (*params)["subject"] = subject;
421 (*params)["issuer"] = issuer;
422 (*params)["signAlg"] = signAlg;
423 (*params)["keystoreFile"] = keystoreFile;
424 (*params)["issuerKeystoreFile"] = issuerKeystoreFile;
425 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
426 (*params)["outFile"] = outFile;
427 bool ret = api->GenerateCA(params.get());
428 EXPECT_EQ(ret, true);
429 }
430
431 /**
432 * @tc.name: generate_ca_test_011
433 * @tc.desc: Test function of GenerateCa() FAILED to generate a root certificate without all pwd.
434 * @tc.type: FUNC
435 * @tc.require: SR000H63TL
436 */
HWTEST_F(GenerateCaTest, generate_ca_test_011, testing::ext::TestSize.Level1)437 HWTEST_F(GenerateCaTest, generate_ca_test_011, testing::ext::TestSize.Level1)
438 {
439 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
440 std::shared_ptr<Options> params = std::make_shared<Options>();
441 std::string keyAlias = "oh-app1-key-v1";
442 std::string keyAlg = "ECC";
443 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
444 std::string signAlg = "SHA384withECDSA";
445 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
446 std::string outFile = "/data/test/generateCA/root-ca-test.cer";
447 int keySize = 384;
448 int validity = 365;
449 int basicConstraintsPathLen = 5;
450 (*params)["keyAlias"] = keyAlias;
451 (*params)["keyAlg"] = keyAlg;
452 (*params)["keySize"] = keySize;
453 (*params)["subject"] = subject;
454 (*params)["signAlg"] = signAlg;
455 (*params)["keystoreFile"] = keystoreFile;
456 (*params)["validity"] = validity;
457 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
458 (*params)["outFile"] = outFile;
459
460 bool ret = api->GenerateCA(params.get());
461 EXPECT_EQ(ret, false);
462 }
463
464 /**
465 * @tc.name: generate_ca_test_012
466 * @tc.desc: Test function of GenerateCa() FAILED to generate a root certificate without a subject.
467 * @tc.type: FUNC
468 * @tc.require: SR000H63TL
469 */
HWTEST_F(GenerateCaTest, generate_ca_test_012, testing::ext::TestSize.Level1)470 HWTEST_F(GenerateCaTest, generate_ca_test_012, testing::ext::TestSize.Level1)
471 {
472 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
473 std::shared_ptr<Options> params = std::make_shared<Options>();
474 std::string keyAlias = "oh-app1-key-v1";
475 std::string keyAlg = "ECC";
476 std::string signAlg = "SHA384withECDSA";
477 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
478 std::string outFile = "/data/test/generateCA/root-ca-test.cer";
479 int keySize = 384;
480 int validity = 365;
481 int basicConstraintsPathLen = 5;
482 (*params)["keyAlias"] = keyAlias;
483 (*params)["keyAlg"] = keyAlg;
484 (*params)["keySize"] = keySize;
485 (*params)["signAlg"] = signAlg;
486 (*params)["keystoreFile"] = keystoreFile;
487 (*params)["validity"] = validity;
488 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
489 (*params)["outFile"] = outFile;
490
491 bool ret = api->GenerateCA(params.get());
492 EXPECT_EQ(ret, false);
493 }
494
495 /**
496 * @tc.name: generate_ca_test_013
497 * @tc.desc: Test function of GenerateCa() FAILED to generate a root certificate without a keyalg.
498 * @tc.type: FUNC
499 * @tc.require: SR000H63TL
500 */
HWTEST_F(GenerateCaTest, generate_ca_test_013, testing::ext::TestSize.Level1)501 HWTEST_F(GenerateCaTest, generate_ca_test_013, testing::ext::TestSize.Level1)
502 {
503 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
504 std::shared_ptr<Options> params = std::make_shared<Options>();
505 std::string keyAlias = "oh-app1-key-v1";
506 std::string signAlg = "SHA384withECDSA";
507 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
508 std::string outFile = "/data/test/generateCA/root-ca-test.cer";
509 int keySize = 384;
510 int validity = 365;
511 int basicConstraintsPathLen = 5;
512 (*params)["keyAlias"] = keyAlias;
513 (*params)["keySize"] = keySize;
514 (*params)["signAlg"] = signAlg;
515 (*params)["keystoreFile"] = keystoreFile;
516 (*params)["validity"] = validity;
517 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
518 (*params)["outFile"] = outFile;
519
520 bool ret = api->GenerateCA(params.get());
521 EXPECT_EQ(ret, false);
522 }
523
524 /**
525 * @tc.name: generate_ca_test_014
526 * @tc.desc: Test function of GenerateCa() FAILED to generate a sub certificate with a error outfile path.
527 * @tc.type: FUNC
528 * @tc.require: SR000H63TL
529 */
HWTEST_F(GenerateCaTest, generate_ca_test_014, testing::ext::TestSize.Level1)530 HWTEST_F(GenerateCaTest, generate_ca_test_014, testing::ext::TestSize.Level1)
531 {
532 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
533 std::shared_ptr<Options> params = std::make_shared<Options>();
534 std::string keyAlias = "oh-app1-key-v1";
535 std::string issuerkeyAlias = "oh-app1-key-v1";
536 std::string keyAlg = "ECC";
537 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
538 int basicConstraintsPathLen = 5;
539 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
540 std::string outFile = "/data/test/generateCA/profile.cer";
541 std::string issuerKeystoreFile = "/data/test/generateCA/ohtest.p12";
542 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
543 int keySize = 384;
544 char secret[] = "adhjkljasjhdk";
545 char ksPwd[] = "123456";
546 char isksPwd[] = "123456";
547 (*params)["keyPwd"] = secret;
548 (*params)["keystorePwd"] = ksPwd;
549 (*params)["issuerKeystorePwd"] = isksPwd;
550 (*params)["keyAlias"] = keyAlias;
551 (*params)["issuerKeyAlias"] = issuerkeyAlias;
552 (*params)["keyAlg"] = keyAlg;
553 (*params)["keySize"] = keySize;
554 (*params)["subject"] = subject;
555 (*params)["issuer"] = issuer;
556 (*params)["keystoreFile"] = keystoreFile;
557 (*params)["issuerKeystoreFile"] = issuerKeystoreFile;
558 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
559 (*params)["outFile"] = outFile;
560
561 bool ret = api->GenerateCA(params.get());
562 EXPECT_EQ(ret, false);
563 }
564
565 /**
566 * @tc.name: generate_ca_test_015
567 * @tc.desc: Test function of GenerateCa() SUCCESS to generate a root certificate.
568 * @tc.type: FUNC
569 * @tc.require: SR000H63TL
570 */
HWTEST_F(GenerateCaTest, generate_ca_test_015, testing::ext::TestSize.Level1)571 HWTEST_F(GenerateCaTest, generate_ca_test_015, testing::ext::TestSize.Level1)
572 {
573 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
574 std::shared_ptr<Options> params = std::make_shared<Options>();
575 std::string keyAlias = "oh-root-ca-key-v1";
576 std::string keyAlg = "ECC";
577 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Root CA";
578 std::string signAlg = "SHA384withECDSA";
579 int basicConstraintsPathLen = 0;
580 std::string keystoreFile = "/data/test/generateCA/OpenHarmony.p12";
581 std::string outFile = "/data/test/generateCA/root-ca1.cer";
582 int validity = 365;
583 int keySize = 384;
584 char keypwd[] = "123456";
585 char ksPwd[] = "123456";
586 (*params)["keyPwd"] = keypwd;
587 (*params)["keystorePwd"] = ksPwd;
588 (*params)["keyAlias"] = keyAlias;
589 (*params)["keyAlg"] = keyAlg;
590 (*params)["keySize"] = keySize;
591 (*params)["subject"] = subject;
592 (*params)["signAlg"] = signAlg;
593 (*params)["keystoreFile"] = keystoreFile;
594 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
595 (*params)["outFile"] = outFile;
596 (*params)["validity"] = validity;
597 bool ret = api->GenerateCA(params.get());
598 EXPECT_EQ(ret, true);
599 }
600
601 /**
602 * @tc.name: generate_ca_test_016
603 * @tc.desc: Test function of GenerateCa() FAILED to generate a sub certificate with a error keyalias.
604 * @tc.type: FUNC
605 * @tc.require: SR000H63TL
606 */
HWTEST_F(GenerateCaTest, generate_ca_test_016, testing::ext::TestSize.Level1)607 HWTEST_F(GenerateCaTest, generate_ca_test_016, testing::ext::TestSize.Level1)
608 {
609 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
610 std::shared_ptr<Options> params = std::make_shared<Options>();
611 std::string keyAlias = "oh-app-sign-srv-ca-key-v1";
612 std::string issuerkeyAlias = "oh-root-ca-key-v1";
613 std::string keyAlg = "ECC";
614 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Application Signature Service CA";
615 std::string issuer = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Root CA";
616 std::string signAlg = "SHA384withECDSA";
617 int basicConstraintsPathLen = 0;
618 std::string keystoreFile = "/data/test/generateCA/OpenHarmony.p12";
619 std::string outFile = "/data/test/generateCA/app-sign-srv-ca1.cer";
620 int validity = 365;
621 int keySize = 384;
622 char keypwd[] = "123456";
623 char ksPwd[] = "123456";
624 char issuerPwd[] = "123456";
625 (*params)["keyPwd"] = keypwd;
626 (*params)["keystorePwd"] = ksPwd;
627 (*params)["issuerKeyPwd"] = issuerPwd;
628 (*params)["keyAlias"] = keyAlias;
629 (*params)["issuerKeyAlias"] = issuerkeyAlias;
630 (*params)["keyAlg"] = keyAlg;
631 (*params)["keySize"] = keySize;
632 (*params)["subject"] = subject;
633 (*params)["issuer"] = issuer;
634 (*params)["signAlg"] = signAlg;
635 (*params)["keystoreFile"] = keystoreFile;
636 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
637 (*params)["outFile"] = outFile;
638 (*params)["validity"] = validity;
639 bool ret = api->GenerateCA(params.get());
640 EXPECT_EQ(ret, false);
641 }
642
643 /**
644 * @tc.name: generate_ca_test_017
645 * @tc.desc: Test function of GenerateCa() FAILED to generate a sub certificate with a error issuerkeyalias.
646 * @tc.type: FUNC
647 * @tc.require: SR000H63TL
648 */
HWTEST_F(GenerateCaTest, generate_ca_test_017, testing::ext::TestSize.Level1)649 HWTEST_F(GenerateCaTest, generate_ca_test_017, testing::ext::TestSize.Level1)
650 {
651 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
652 std::shared_ptr<Options> params = std::make_shared<Options>();
653 std::string keyAlias = "oh-profile-sign-srv-ca-key-v1";
654 std::string issuerkeyAlias = "oh-root-ca-key-v1";
655 std::string keyAlg = "ECC";
656 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Application Signature Service CA";
657 std::string issuer = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Root CA";
658 std::string signAlg = "SHA384withECDSA";
659 int basicConstraintsPathLen = 0;
660 std::string keystoreFile = "/data/test/generateCA/OpenHarmony.p12";
661 std::string outFile = "/data/test/generateCA/profile-sign-srv-ca1.cer";
662 int validity = 365;
663 int keySize = 384;
664 char keypwd[] = "123456";
665 char ksPwd[] = "123456";
666 char issuerPwd[] = "123456";
667 (*params)["keyPwd"] = keypwd;
668 (*params)["keystorePwd"] = ksPwd;
669 (*params)["issuerKeyPwd"] = issuerPwd;
670 (*params)["keyAlias"] = keyAlias;
671 (*params)["issuerKeyAlias"] = issuerkeyAlias;
672 (*params)["keyAlg"] = keyAlg;
673 (*params)["keySize"] = keySize;
674 (*params)["subject"] = subject;
675 (*params)["issuer"] = issuer;
676 (*params)["signAlg"] = signAlg;
677 (*params)["keystoreFile"] = keystoreFile;
678 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
679 (*params)["outFile"] = outFile;
680 (*params)["validity"] = validity;
681 bool ret = api->GenerateCA(params.get());
682 EXPECT_EQ(ret, false);
683 }
684
685
686 /**
687 * @tc.name: generate_sub_cert_test_001
688 * @tc.desc: Test function of GenerateCa() SUCCESS to generate a sub certificate.
689 * @tc.type: FUNC
690 * @tc.require: SR000H63TL
691 */
HWTEST_F(GenerateCaTest, generate_sub_cert_test_001, testing::ext::TestSize.Level1)692 HWTEST_F(GenerateCaTest, generate_sub_cert_test_001, testing::ext::TestSize.Level1)
693 {
694 std::shared_ptr<Options> params = std::make_shared<Options>();
695 std::string keyAlias = "alias";
696 std::string issuerkeyAlias = "oh-app1-key-v1";
697 char keyPwd[] = "123456";
698 std::string keyAlg = "ECC";
699 int keySize = 256;
700 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12";
701 char keystorePwd[] = "123456";
702 std::string signAlg = "SHA384withECDSA";
703 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
704 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
705 char isksPwd[] = "123456";
706 (*params)["keystorePwd"] = keystorePwd;
707 (*params)["issuerKeystorePwd"] = isksPwd;
708 (*params)["keyAlias"] = keyAlias;
709 (*params)["keyPwd"] = keyPwd;
710 (*params)["keyAlg"] = keyAlg;
711 (*params)["keySize"] = keySize;
712 (*params)["keystoreFile"] = keystoreFile;
713 (*params)["signAlg"] = signAlg;
714 (*params)["subject"] = subject;
715 (*params)["issuer"] = issuer;
716 (*params)["issuerKeyAlias"] = issuerkeyAlias;
717 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get());
718 EVP_PKEY* keyPair = nullptr;
719 keyPair = adaptePtr->GetAliasKey(true);
720 EXPECT_NE(keyPair, nullptr);
721 X509_REQ* csr = CertTools::GenerateCsr(keyPair, signAlg, subject);
722 EXPECT_NE(csr, nullptr);
723 bool ret = CertTools::GenerateSubCert(keyPair, csr, params.get());
724 EXPECT_EQ(ret, true);
725 }
726
727 /**
728 * @tc.name: generate_sub_cert_test_002
729 * @tc.desc: Test function of GenerateCa() FAILED to generate a sub certificate with a error keyalias.
730 * @tc.type: FUNC
731 * @tc.require: SR000H63TL
732 */
HWTEST_F(GenerateCaTest, generate_sub_cert_test_002, testing::ext::TestSize.Level1)733 HWTEST_F(GenerateCaTest, generate_sub_cert_test_002, testing::ext::TestSize.Level1)
734 {
735 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
736 std::shared_ptr<Options> params = std::make_shared<Options>();
737 std::string keyAlias = "alias";
738 std::string issuerkeyAlias = "oh-app1-key-v1";
739 std::string keyAlg = "ECC";
740 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
741 std::string signAlg = "SHA384withECDSA";
742 int basicConstraintsPathLen = 0;
743 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
744 std::string outFile = "/data/test/generateCA/subca.cer";
745 std::string issuerKeystoreFile = "/data/test/generateCA/ohtest.p12";
746 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
747 int keySize = 384;
748 char secret[] = "123456";
749 char ksPwd[] = "123456";
750 char isksPwd[] = "123456";
751 (*params)["keyPwd"] = secret;
752 (*params)["keystorePwd"] = ksPwd;
753 (*params)["issuerKeystorePwd"] = isksPwd;
754 (*params)["keyAlias"] = keyAlias;
755 (*params)["issuerKeyAlias"] = issuerkeyAlias;
756 (*params)["keyAlg"] = keyAlg;
757 (*params)["keySize"] = keySize;
758 (*params)["subject"] = subject;
759 (*params)["issuer"] = issuer;
760 (*params)["signAlg"] = signAlg;
761 (*params)["keystoreFile"] = keystoreFile;
762 (*params)["issuerKeystoreFile"] = issuerKeystoreFile;
763 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
764 (*params)["outFile"] = outFile;
765 std::shared_ptr<KeyStoreHelper> keyStoreHelper = std::make_shared<KeyStoreHelper>();
766 EVP_PKEY* keyPair = EVP_PKEY_new();
767 EXPECT_NE(keyPair, nullptr);
768 X509_REQ* csr = X509_REQ_new();
769 EXPECT_NE(csr, nullptr);
770 bool ret = CertTools::GenerateSubCert(keyPair, csr, params.get());
771 EXPECT_EQ(ret, false);
772 }
773
774
775 /**
776 * @tc.name: generate_sub_cert_test_003
777 * @tc.desc: Test function of GenerateCa() FAILED to generate a sub certificate with a empty signalg.
778 * @tc.type: FUNC
779 * @tc.require: SR000H63TL
780 */
HWTEST_F(GenerateCaTest, generate_sub_cert_test_003, testing::ext::TestSize.Level1)781 HWTEST_F(GenerateCaTest, generate_sub_cert_test_003, testing::ext::TestSize.Level1)
782 {
783 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
784 std::shared_ptr<Options> params = std::make_shared<Options>();
785 std::string keyAlias = "alias";
786 std::string issuerkeyAlias = "oh-app1-key-v1";
787 std::string keyAlg = "ECC";
788 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
789 std::string signAlg = "";
790 int basicConstraintsPathLen = 0;
791 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
792 std::string outFile = "/data/test/generateCA/subca.cer";
793 std::string issuerKeystoreFile = "/data/test/generateCA/ohtest.p12";
794 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
795 int keySize = 384;
796 char secret[] = "123456";
797 char ksPwd[] = "123456";
798 char isksPwd[] = "123456";
799 (*params)["keyPwd"] = secret;
800 (*params)["keystorePwd"] = ksPwd;
801 (*params)["issuerKeystorePwd"] = isksPwd;
802 (*params)["keyAlias"] = keyAlias;
803 (*params)["issuerKeyAlias"] = issuerkeyAlias;
804 (*params)["keyAlg"] = keyAlg;
805 (*params)["keySize"] = keySize;
806 (*params)["subject"] = subject;
807 (*params)["issuer"] = issuer;
808 (*params)["signAlg"] = signAlg;
809 (*params)["keystoreFile"] = keystoreFile;
810 (*params)["issuerKeystoreFile"] = issuerKeystoreFile;
811 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
812 (*params)["outFile"] = outFile;
813 std::shared_ptr<KeyStoreHelper> keyStoreHelper = std::make_shared<KeyStoreHelper>();
814 EVP_PKEY* keyPair = EVP_PKEY_new();
815 EXPECT_NE(keyPair, nullptr);
816 X509_REQ* csr = X509_REQ_new();
817 EXPECT_NE(csr, nullptr);
818 bool ret = CertTools::GenerateSubCert(keyPair, csr, params.get());
819 EXPECT_EQ(ret, false);
820 }
821
822 /**
823 * @tc.name: generate_sub_cert_test_004
824 * @tc.desc: Test function of GenerateCa() FAILED to generate a sub certificate with a error issuerkeystorefile.
825 * @tc.type: FUNC
826 * @tc.require: SR000H63TL
827 */
HWTEST_F(GenerateCaTest, generate_sub_cert_test_004, testing::ext::TestSize.Level1)828 HWTEST_F(GenerateCaTest, generate_sub_cert_test_004, testing::ext::TestSize.Level1)
829 {
830 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
831 std::shared_ptr<Options> params = std::make_shared<Options>();
832 std::string keyAlias = "alias";
833 std::string issuerkeyAlias = "oh-app1-key-v1";
834 std::string keyAlg = "ECC";
835 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
836 std::string signAlg = "SHA384withECDSA";
837 int basicConstraintsPathLen = 5;
838 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
839 std::string outFile = "/data/test/generateCA/subca.cer";
840 std::string issuerKeystoreFile = "/data/test/generateCA/ohtest.p12";
841 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
842 int keySize = 384;
843 char secret[] = "123456";
844 char ksPwd[] = "123456";
845 char isksPwd[] = "123456";
846 (*params)["keyPwd"] = secret;
847 (*params)["keystorePwd"] = ksPwd;
848 (*params)["issuerKeystorePwd"] = isksPwd;
849 (*params)["keyAlias"] = keyAlias;
850 (*params)["issuerKeyAlias"] = issuerkeyAlias;
851 (*params)["keyAlg"] = keyAlg;
852 (*params)["keySize"] = keySize;
853 (*params)["subject"] = subject;
854 (*params)["issuer"] = issuer;
855 (*params)["signAlg"] = signAlg;
856 (*params)["keystoreFile"] = keystoreFile;
857 (*params)["issuerKeystoreFile"] = issuerKeystoreFile;
858 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
859 (*params)["outFile"] = outFile;
860 std::shared_ptr<KeyStoreHelper> keyStoreHelper = std::make_shared<KeyStoreHelper>();
861 EVP_PKEY* keyPair = EVP_PKEY_new();
862 EXPECT_NE(keyPair, nullptr);
863 X509_REQ* csr = X509_REQ_new();
864 EXPECT_NE(csr, nullptr);
865 bool ret = CertTools::GenerateSubCert(keyPair, csr, params.get());
866 EXPECT_EQ(ret, false);
867 }
868
869 /**
870 * @tc.name: generate_sub_cert_test_005
871 * @tc.desc: Test function of GenerateCa() FAILED to generate a sub certificate with a error signalg.
872 * @tc.type: FUNC
873 * @tc.require: SR000H63TL
874 */
HWTEST_F(GenerateCaTest, generate_sub_cert_test_005, testing::ext::TestSize.Level1)875 HWTEST_F(GenerateCaTest, generate_sub_cert_test_005, testing::ext::TestSize.Level1)
876 {
877 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
878 std::shared_ptr<Options> params = std::make_shared<Options>();
879 std::string keyAlias = "alias";
880 std::string issuerkeyAlias = "oh-app1-key-v1";
881 std::string keyAlg = "ECC";
882 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
883 std::string signAlg = "";
884 int basicConstraintsPathLen = 5;
885 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
886 std::string outFile = "/data/test/generateCA/subca.cer";
887 std::string issuerKeystoreFile = "/data/test/generateCA/ohtest.p12";
888 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
889 int keySize = 384;
890 char secret[] = "123456";
891 char ksPwd[] = "123456";
892 char isksPwd[] = "123456";
893 (*params)["keyPwd"] = secret;
894 (*params)["keystorePwd"] = ksPwd;
895 (*params)["issuerKeystorePwd"] = isksPwd;
896 (*params)["keyAlias"] = keyAlias;
897 (*params)["issuerKeyAlias"] = issuerkeyAlias;
898 (*params)["keyAlg"] = keyAlg;
899 (*params)["keySize"] = keySize;
900 (*params)["subject"] = subject;
901 (*params)["issuer"] = issuer;
902 (*params)["signAlg"] = signAlg;
903 (*params)["keystoreFile"] = keystoreFile;
904 (*params)["issuerKeystoreFile"] = issuerKeystoreFile;
905 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
906 (*params)["outFile"] = outFile;
907 std::shared_ptr<KeyStoreHelper> keyStoreHelper = std::make_shared<KeyStoreHelper>();
908 EVP_PKEY* keyPair = EVP_PKEY_new();
909 EXPECT_NE(keyPair, nullptr);
910 X509_REQ* csr = X509_REQ_new();
911 EXPECT_NE(csr, nullptr);
912 bool ret = CertTools::GenerateSubCert(keyPair, csr, params.get());
913 EXPECT_EQ(ret, false);
914 }
915
916 /**
917 * @tc.name: generate_sub_cert_test_006
918 * @tc.desc: Test function of GenerateCa() FAILED to generate a sub certificate with a error keyalias.
919 * @tc.type: FUNC
920 * @tc.require: SR000H63TL
921 */
HWTEST_F(GenerateCaTest, generate_sub_cert_test_006, testing::ext::TestSize.Level1)922 HWTEST_F(GenerateCaTest, generate_sub_cert_test_006, testing::ext::TestSize.Level1)
923 {
924 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
925 std::shared_ptr<Options> params = std::make_shared<Options>();
926 std::string keyAlias = "alias";
927 std::string issuerkeyAlias = "oh-app1-key-v1";
928 std::string keyAlg = "ECC";
929 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
930 std::string signAlg = "SHA384withECDSA";
931 int basicConstraintsPathLen = 0;
932 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
933 std::string outFile = "/data/test/generateCA/subca.cer";
934 std::string issuerKeystoreFile = "/data/test/generateCA/ohtest.p12";
935 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
936 int keySize = 384;
937 char secret[] = "123456";
938 char ksPwd[] = "123456";
939 char isksPwd[] = "123456";
940 int validity = 365;
941 (*params)["keyPwd"] = secret;
942 (*params)["keystorePwd"] = ksPwd;
943 (*params)["issuerKeystorePwd"] = isksPwd;
944 (*params)["keyAlias"] = keyAlias;
945 (*params)["issuerKeyAlias"] = issuerkeyAlias;
946 (*params)["keyAlg"] = keyAlg;
947 (*params)["keySize"] = keySize;
948 (*params)["subject"] = subject;
949 (*params)["issuer"] = issuer;
950 (*params)["signAlg"] = signAlg;
951 (*params)["keystoreFile"] = keystoreFile;
952 (*params)["issuerKeystoreFile"] = issuerKeystoreFile;
953 (*params)["basicConstraintsPathLen"] = basicConstraintsPathLen;
954 (*params)["outFile"] = outFile;
955 (*params)["validity"] = validity;
956 std::shared_ptr<KeyStoreHelper> keyStoreHelper = std::make_shared<KeyStoreHelper>();
957 EVP_PKEY* keyPair = EVP_PKEY_new();
958 EXPECT_NE(keyPair, nullptr);
959 X509_REQ* csr = X509_REQ_new();
960 EXPECT_NE(csr, nullptr);
961 bool ret = CertTools::GenerateSubCert(keyPair, csr, params.get());
962 EXPECT_EQ(ret, false);
963 }
964
965
966 /**
967 * @tc.name: valid_file_type_test_001
968 * @tc.desc: Test function of ValidFileType() SUCCESS check file suffix
969 * @tc.type: FUNC
970 * @tc.require: SR000H63TL
971 */
HWTEST_F(GenerateCaTest, valid_file_type_test_001, testing::ext::TestSize.Level1)972 HWTEST_F(GenerateCaTest, valid_file_type_test_001, testing::ext::TestSize.Level1)
973 {
974 std::string issuerKeystoreFile = "ab.p12";
975 bool ret = FileUtils::ValidFileType(issuerKeystoreFile, { "p12", "jks" });
976 EXPECT_EQ(ret, true);
977 }
978
979 /**
980 * @tc.name: get_chars_test_001
981 * @tc.desc: Test function of Options::GetChars() interface for SUCCESS.
982 * @tc.type: FUNC
983 * @tc.require: SR000H63TL
984 */
HWTEST_F(GenerateCaTest, get_chars_test_001, testing::ext::TestSize.Level1)985 HWTEST_F(GenerateCaTest, get_chars_test_001, testing::ext::TestSize.Level1)
986 {
987 Options option;
988 const std::string test = "test";
989 char value[6] = "value";
990 option[test] = value;
991 char* tmp = option.GetChars(test);
992 EXPECT_EQ(std::strcmp("value", tmp), 0);
993 }
994
995 /**
996 * @tc.name: get_string_test_001
997 * @tc.desc: Test function of Options::GetString() interface for SUCCESS.
998 * @tc.type: FUNC
999 * @tc.require: SR000H63TL
1000 */
HWTEST_F(GenerateCaTest, get_string_test_001, testing::ext::TestSize.Level1)1001 HWTEST_F(GenerateCaTest, get_string_test_001, testing::ext::TestSize.Level1)
1002 {
1003 Options option;
1004 std::string test = "test";
1005 std::string value = "value";
1006 option[test] = value;
1007 std::string str = option.GetString(test);
1008 EXPECT_EQ(std::strcmp("value", str.c_str()), 0);
1009 }
1010
1011 /**
1012 * @tc.name: equals_test_001
1013 * @tc.desc: Test function of Options::Equals() interface for SUCCESS.
1014 * @tc.type: FUNC
1015 * @tc.require: SR000H63TL
1016 */
HWTEST_F(GenerateCaTest, equals_test_001, testing::ext::TestSize.Level1)1017 HWTEST_F(GenerateCaTest, equals_test_001, testing::ext::TestSize.Level1)
1018 {
1019 Options option;
1020 const std::string test1 = "test1";
1021 const std::string test2 = "test2";
1022 bool ret = option.Equals(test1, test2);
1023 EXPECT_EQ(ret, true);
1024 }
1025
1026 /**
1027 * @tc.name: is_empty_test_001
1028 * @tc.desc: Test function of Options::IsEmpty() interface for SUCCESS.
1029 * @tc.type: FUNC
1030 * @tc.require: SR000H63TL
1031 */
HWTEST_F(GenerateCaTest, is_empty_test_001, testing::ext::TestSize.Level1)1032 HWTEST_F(GenerateCaTest, is_empty_test_001, testing::ext::TestSize.Level1)
1033 {
1034 Options option;
1035 std::string test1 = "test1";
1036 bool ret = option.IsEmpty(test1);
1037 EXPECT_EQ(ret, false);
1038 }
1039
1040 // general cert
1041 /**
1042 * @tc.name: generate_cert_test_001
1043 * @tc.desc: Test function of GenerateCert() FAILED to generate a certificate with a error keyalias.
1044 * @tc.type: FUNC
1045 * @tc.require: SR000H63TL
1046 */
HWTEST_F(GenerateCaTest, generate_cert_test_001, testing::ext::TestSize.Level1)1047 HWTEST_F(GenerateCaTest, generate_cert_test_001, testing::ext::TestSize.Level1)
1048 {
1049 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
1050 std::shared_ptr<Options> params = std::make_shared<Options>();
1051 std::string keyAlias = "alias";
1052 std::string issuerkeyAlias = "oh-app1-key-v1";
1053 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12";
1054 std::string signAlg = "SHA384withECDSA";
1055 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
1056 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
1057 std::string keyUsage = "digitalSignature";
1058 std::string basicConstraints = "true";
1059 std::string basicConstraintsCritical = "true";
1060 std::string basicConstraintsCa = "true";
1061 bool keyUsageCritical = true;
1062 char secret[] = "123456";
1063 char isksPwd[] = "123456";
1064 char keystorePwd[] = "123456";
1065 char issuerkeypwd[] = "123456";
1066 int validity = 365;
1067 std::string outfile = "/data/test/generateCA/general.cer";
1068 (*params)["keyPwd"] = secret;
1069 (*params)["issuerKeystorePwd"] = isksPwd;
1070 (*params)["issuerKeyPwd"] = issuerkeypwd;
1071 (*params)["keyAlias"] = keyAlias;
1072 (*params)["keystoreFile"] = keystoreFile;
1073 (*params)["keystorePwd"] = keystorePwd;
1074 (*params)["signAlg"] = signAlg;
1075 (*params)["subject"] = subject;
1076 (*params)["issuer"] = issuer;
1077 (*params)["issuerKeyAlias"] = issuerkeyAlias;
1078 (*params)["keyUsage"] = keyUsage;
1079 (*params)["basicConstraints"] = basicConstraints;
1080 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1081 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1082 (*params)["keyUsageCritical"] = keyUsageCritical;
1083 (*params)["validity"] = validity;
1084 (*params)["outFile"] = outfile;
1085 bool ret = api->GenerateCert(params.get());
1086 EXPECT_EQ(ret, false);
1087 }
1088
1089 // general cert
1090 /**
1091 * @tc.name: generate_cert_test_002
1092 * @tc.desc: Test function of GenerateCert() FAILED to generate a certificate with a error keystorefile.
1093 * @tc.type: FUNC
1094 * @tc.require: SR000H63TL
1095 */
HWTEST_F(GenerateCaTest, generate_cert_test_002, testing::ext::TestSize.Level1)1096 HWTEST_F(GenerateCaTest, generate_cert_test_002, testing::ext::TestSize.Level1)
1097 {
1098 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
1099 std::shared_ptr<Options> params = std::make_shared<Options>();
1100 std::string keyAlias = "alias";
1101 std::string issuerkeyAlias = "oh-app1-key-v1";
1102 std::string keyAlg = "ECC";
1103 int keySize = 256;
1104 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12";
1105 std::string signAlg = "SHA384withECDSA";
1106 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
1107 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
1108 std::string keyUsage = "digitalSignature";
1109 std::string basicConstraints = "true";
1110 std::string basicConstraintsCritical = "true";
1111 std::string basicConstraintsCa = "true";
1112 bool keyUsageCritical = true;
1113 char secret[] = "123456";
1114 char isksPwd[] = "123456";
1115 char keystorePwd[] = "123456";
1116 char issuerkeypwd[] = "123456";
1117 std::string outFile = "/data/test/generateCA/rootCa.cer";
1118 (*params)["keyPwd"] = secret;
1119 (*params)["issuerKeystorePwd"] = isksPwd;
1120 (*params)["issuerKeyPwd"] = issuerkeypwd;
1121 (*params)["keyAlias"] = keyAlias;
1122 (*params)["keyAlg"] = keyAlg;
1123 (*params)["keySize"] = keySize;
1124 (*params)["keystoreFile"] = keystoreFile;
1125 (*params)["keystorePwd"] = keystorePwd;
1126 (*params)["signAlg"] = signAlg;
1127 (*params)["subject"] = subject;
1128 (*params)["issuer"] = issuer;
1129 (*params)["issuerkeyAlias"] = issuerkeyAlias;
1130 (*params)["keyUsage"] = keyUsage;
1131 (*params)["basicConstraints"] = basicConstraints;
1132 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1133 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1134 (*params)["keyUsageCritical"] = keyUsageCritical;
1135 (*params)["outFile"] = outFile;
1136 bool ret = api->GenerateCert(params.get());
1137 EXPECT_EQ(ret, false);
1138 }
1139
1140
1141 // general cert
1142 /**
1143 * @tc.name: generate_cert_test_003
1144 * @tc.desc: Test function of GenerateCert() FAILED to generate a certificate with a error keyusage.
1145 * @tc.type: FUNC
1146 * @tc.require: SR000H63TL
1147 */
HWTEST_F(GenerateCaTest, generate_cert_test_003, testing::ext::TestSize.Level1)1148 HWTEST_F(GenerateCaTest, generate_cert_test_003, testing::ext::TestSize.Level1)
1149 {
1150 SIGNATURE_TOOLS_LOGI(" welcome to test space !!! ");
1151 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
1152 std::shared_ptr<Options> params = std::make_shared<Options>();
1153 std::string keyAlias = "oh-app1-key-v1";
1154 std::string issuerKeyAlias = "oh-app1-key-v1";
1155 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
1156 std::string issuer = "C=CNA,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
1157 std::string signAlg = "SHA384withECDSA";
1158 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
1159 std::string keyUsage = "digitalSignature";
1160 std::string outFile = "general.cer";
1161 std::string basicConstraints = "true";
1162 std::string basicConstraintsCritical = "true";
1163 std::string basicConstraintsCa = "true";
1164 bool keyUsageCritical = true;
1165 char secret[] = "123456";
1166 char keystorePwd[] = "123456";
1167 int keySize = 384;
1168 (*params)["keyAlias"] = keyAlias;
1169 (*params)["issuerKeyAlias"] = issuerKeyAlias;
1170 (*params)["keySize"] = keySize;
1171 (*params)["subject"] = subject;
1172 (*params)["issuer"] = issuer;
1173 (*params)["signAlg"] = signAlg;
1174 (*params)["keystoreFile"] = keystoreFile;
1175 (*params)["keyUsage"] = keyUsage;
1176 (*params)["basicConstraints"] = basicConstraints;
1177 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1178 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1179 (*params)["keyUsageCritical"] = keyUsageCritical;
1180 (*params)["keyPwd"] = secret;
1181 (*params)["keystorePwd"] = keystorePwd;
1182
1183 (*params)["outFile"] = outFile;
1184 bool ret = api->GenerateCert(params.get());
1185 EXPECT_EQ(ret, false);
1186 }
1187
1188 // general cert
1189 /**
1190 * @tc.name: generate_cert_test_004
1191 * @tc.desc: Test function of GenerateCert() FAILED to generate a certificate with a empty signalg.
1192 * @tc.type: FUNC
1193 * @tc.require: SR000H63TL
1194 */
HWTEST_F(GenerateCaTest, generate_cert_test_004, testing::ext::TestSize.Level1)1195 HWTEST_F(GenerateCaTest, generate_cert_test_004, testing::ext::TestSize.Level1)
1196 {
1197 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
1198 std::shared_ptr<Options> params = std::make_shared<Options>();
1199 std::string keyAlias = "alias";
1200 std::string issuerkeyAlias = "oh-app1-key-v1";
1201 std::string keyAlg = "ECC";
1202 int keySize = 256;
1203 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12";
1204 std::string signAlg = "";
1205 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
1206 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
1207 std::string keyUsage = "digitalSignature";
1208 std::string basicConstraints = "true";
1209 std::string basicConstraintsCritical = "true";
1210 std::string basicConstraintsCa = "true";
1211 bool keyUsageCritical = true;
1212 char secret[] = "123456";
1213 char isksPwd[] = "123456";
1214 char keystorePwd[] = "123456";
1215 char issuerkeypwd[] = "123456";
1216 (*params)["keyPwd"] = secret;
1217 (*params)["issuerKeystorePwd"] = isksPwd;
1218 (*params)["issuerKeyPwd"] = issuerkeypwd;
1219 (*params)["keyAlias"] = keyAlias;
1220 (*params)["keyAlg"] = keyAlg;
1221 (*params)["keySize"] = keySize;
1222 (*params)["keystoreFile"] = keystoreFile;
1223 (*params)["keystorePwd"] = keystorePwd;
1224 (*params)["signAlg"] = signAlg;
1225 (*params)["subject"] = subject;
1226 (*params)["issuer"] = issuer;
1227 (*params)["issuerkeyAlias"] = issuerkeyAlias;
1228 (*params)["keyUsage"] = keyUsage;
1229 (*params)["basicConstraints"] = basicConstraints;
1230 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1231 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1232 (*params)["keyUsageCritical"] = keyUsageCritical;
1233
1234 bool ret = api->GenerateCert(params.get());
1235 EXPECT_EQ(ret, false);
1236 }
1237
1238 // general cert
1239 /**
1240 * @tc.name: generate_cert_test_005
1241 * @tc.desc: Test function of GenerateCert() FAILED to generate a certificate with a empty subject.
1242 * @tc.require: SR000H63TL
1243 */
HWTEST_F(GenerateCaTest, generate_cert_test_005, testing::ext::TestSize.Level1)1244 HWTEST_F(GenerateCaTest, generate_cert_test_005, testing::ext::TestSize.Level1)
1245 {
1246 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
1247 std::shared_ptr<Options> params = std::make_shared<Options>();
1248 std::string keyAlias = "alias";
1249 std::string issuerkeyAlias = "oh-app1-key-v1";
1250 int keySize = 256;
1251 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12";
1252 std::string signAlg = "";
1253 std::string subject = "";
1254 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
1255 std::string keyUsage = "digitalSignature";
1256 std::string basicConstraints = "true";
1257 std::string basicConstraintsCritical = "true";
1258 std::string basicConstraintsCa = "true";
1259 bool keyUsageCritical = true;
1260 char secret[] = "123456";
1261 char isksPwd[] = "123456";
1262 char keystorePwd[] = "123456";
1263 char issuerkeypwd[] = "123456";
1264 (*params)["keyPwd"] = secret;
1265 (*params)["issuerKeystorePwd"] = isksPwd;
1266 (*params)["issuerKeyPwd"] = issuerkeypwd;
1267 (*params)["keyAlias"] = keyAlias;
1268 (*params)["keySize"] = keySize;
1269 (*params)["keystoreFile"] = keystoreFile;
1270 (*params)["keystorePwd"] = keystorePwd;
1271 (*params)["signAlg"] = signAlg;
1272 (*params)["subject"] = subject;
1273 (*params)["issuer"] = issuer;
1274 (*params)["issuerkeyAlias"] = issuerkeyAlias;
1275 (*params)["keyUsage"] = keyUsage;
1276 (*params)["basicConstraints"] = basicConstraints;
1277 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1278 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1279 (*params)["keyUsageCritical"] = keyUsageCritical;
1280 bool ret = api->GenerateCert(params.get());
1281 EXPECT_EQ(ret, false);
1282 }
1283 // general cert
1284 /**
1285 * @tc.name: generate_cert_test_006
1286 * @tc.desc: Test function of GenerateCert() FAILED to generate a certificate without a keyalias.
1287 * @tc.type: FUNC
1288 * @tc.require: SR000H63TL
1289 */
HWTEST_F(GenerateCaTest, generate_cert_test_006, testing::ext::TestSize.Level1)1290 HWTEST_F(GenerateCaTest, generate_cert_test_006, testing::ext::TestSize.Level1)
1291 {
1292 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
1293 std::shared_ptr<Options> params = std::make_shared<Options>();
1294 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
1295 std::string signAlg = "SHA384withECDSA";
1296 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
1297 std::string keyUsage = "digitalSignature";
1298 std::string outFile = "/datamsge/test/generateCA/general.cer";
1299 std::string basicConstraints = "true";
1300 std::string basicConstraintsCritical = "true";
1301 std::string basicConstraintsCa = "true";
1302 bool keyUsageCritical = true;
1303 char secret[] = "123456";
1304 char keystorePwd[] = "123456";
1305 int keySize = 384;
1306 (*params)["keySize"] = keySize;
1307 (*params)["subject"] = subject;
1308 (*params)["signAlg"] = signAlg;
1309 (*params)["keystoreFile"] = keystoreFile;
1310 (*params)["keyUsage"] = keyUsage;
1311 (*params)["basicConstraints"] = basicConstraints;
1312 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1313 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1314 (*params)["keyUsageCritical"] = keyUsageCritical;
1315 (*params)["keyPwd"] = secret;
1316 (*params)["keystorePwd"] = keystorePwd;
1317
1318 (*params)["outFile"] = outFile;
1319 bool ret = api->GenerateCert(params.get());
1320 EXPECT_EQ(ret, false);
1321 }
1322
1323 /**
1324 * @tc.name: generate_cert_test_007
1325 * @tc.desc: Test function of GenerateCert() FAILED to generate a sub certificate without a keyalias.
1326 * @tc.type: FUNC
1327 * @tc.require: SR000H63TL
1328 */
HWTEST_F(GenerateCaTest, generate_cert_test_007, testing::ext::TestSize.Level1)1329 HWTEST_F(GenerateCaTest, generate_cert_test_007, testing::ext::TestSize.Level1)
1330 {
1331 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
1332 std::shared_ptr<Options> params = std::make_shared<Options>();
1333 std::string subject = "";
1334 std::string signAlg = "";
1335 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
1336 std::string keyUsage = "digitalSignature";
1337 std::string outFile = "general.cer";
1338 std::string basicConstraints = "true";
1339 std::string basicConstraintsCritical = "true";
1340 std::string basicConstraintsCa = "true";
1341 bool keyUsageCritical = true;
1342 char secret[] = "123456";
1343 char keystorePwd[] = "123456";
1344 int keySize = 384;
1345 (*params)["keySize"] = keySize;
1346 (*params)["subject"] = subject;
1347 (*params)["signAlg"] = signAlg;
1348 (*params)["keystoreFile"] = keystoreFile;
1349 (*params)["keyUsage"] = keyUsage;
1350 (*params)["basicConstraints"] = basicConstraints;
1351 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1352 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1353 (*params)["keyUsageCritical"] = keyUsageCritical;
1354 (*params)["keyPwd"] = secret;
1355 (*params)["keystorePwd"] = keystorePwd;
1356
1357 (*params)["outFile"] = outFile;
1358 bool ret = api->GenerateCert(params.get());
1359 EXPECT_EQ(ret, false);
1360 }
1361
1362 /**
1363 * @tc.name: generate_cert_test_008
1364 * @tc.desc: Test function of GenerateCert() FAILED to generate a certificate with a error keypwd.
1365 * @tc.type: FUNC
1366 * @tc.require: SR000H63TL
1367 */
HWTEST_F(GenerateCaTest, generate_cert_test_008, testing::ext::TestSize.Level1)1368 HWTEST_F(GenerateCaTest, generate_cert_test_008, testing::ext::TestSize.Level1)
1369 {
1370 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
1371 std::shared_ptr<Options> params = std::make_shared<Options>();
1372 std::string keyAlias = "oh-app1-key-v1";
1373 std::string issuerKeyAlias = "oh-app1-key-v1";
1374 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
1375 std::string issuer = "C=CNA,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
1376 std::string signAlg = "SHA256withRSA";
1377 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
1378 std::string keyUsage = "digitalSignature";
1379 std::string outFile = "general.cer";
1380 std::string basicConstraints = "true";
1381 std::string basicConstraintsCritical = "true";
1382 std::string basicConstraintsCa = "true";
1383 bool keyUsageCritical = true;
1384 char secret[] = "123456";
1385 char keystorePwd[] = "123456";
1386 int keySize = 384;
1387 (*params)["keyAlias"] = keyAlias;
1388 (*params)["issuerKeyAlias"] = issuerKeyAlias;
1389 (*params)["keySize"] = keySize;
1390 (*params)["subject"] = subject;
1391 (*params)["issuer"] = issuer;
1392 (*params)["signAlg"] = signAlg;
1393 (*params)["keystoreFile"] = keystoreFile;
1394 (*params)["keyUsage"] = keyUsage;
1395 (*params)["basicConstraints"] = basicConstraints;
1396 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1397 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1398 (*params)["keyUsageCritical"] = keyUsageCritical;
1399 (*params)["keyPwd"] = secret;
1400 (*params)["keystorePwd"] = keystorePwd;
1401
1402 (*params)["outFile"] = outFile;
1403 bool ret = api->GenerateCert(params.get());
1404 EXPECT_EQ(ret, false);
1405 }
1406
1407 /**
1408 * @tc.name: generate_cert_test_009
1409 * @tc.desc: Test function of GenerateCert() FAILED to generate a certificate with a error outfile.
1410 * @tc.type: FUNC
1411 * @tc.require: SR000H63TL
1412 */
HWTEST_F(GenerateCaTest, generate_cert_test_009, testing::ext::TestSize.Level1)1413 HWTEST_F(GenerateCaTest, generate_cert_test_009, testing::ext::TestSize.Level1)
1414 {
1415 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
1416 std::shared_ptr<Options> params = std::make_shared<Options>();
1417 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
1418 std::string signAlg = "SHA384withECDSA";
1419 std::string keystoreFile = "/data/test/generateCA/ohtest.p12";
1420 std::string keyUsage = "digitalSignature";
1421 std::string outFile = "/mjssngek/test/generateCA/general.cer";
1422 std::string basicConstraints = "true";
1423 std::string basicConstraintsCritical = "true";
1424 std::string basicConstraintsCa = "true";
1425 bool keyUsageCritical = true;
1426 char secret[] = "123456";
1427 char keystorePwd[] = "123456";
1428 int keySize = 384;
1429 (*params)["keySize"] = keySize;
1430 (*params)["subject"] = subject;
1431 (*params)["signAlg"] = signAlg;
1432 (*params)["keystoreFile"] = keystoreFile;
1433 (*params)["keyUsage"] = keyUsage;
1434 (*params)["basicConstraints"] = basicConstraints;
1435 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1436 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1437 (*params)["keyUsageCritical"] = keyUsageCritical;
1438 (*params)["keyPwd"] = secret;
1439 (*params)["keystorePwd"] = keystorePwd;
1440 (*params)["outFile"] = outFile;
1441 bool ret = api->GenerateCert(params.get());
1442 EXPECT_EQ(ret, false);
1443 }
1444
1445 // general cert
1446 /**
1447 * @tc.name: generate_cert_test_010
1448 * @tc.desc: Test function of GenerateCert() SUCCESS to generate a certificate.
1449 * @tc.type: FUNC
1450 * @tc.require: SR000H63TL
1451 */
HWTEST_F(GenerateCaTest, generate_cert_test_010, testing::ext::TestSize.Level1)1452 HWTEST_F(GenerateCaTest, generate_cert_test_010, testing::ext::TestSize.Level1)
1453 {
1454 std::shared_ptr<Options> params = std::make_shared<Options>();
1455 std::string keyAlias = "alias";
1456 std::string issuerkeyAlias = "oh-app1-key-v1";
1457 char keyPwd[] = "123456";
1458 std::string keyAlg = "ECC";
1459 int keySize = 256;
1460 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12";
1461 char keystorePwd[] = "123456";
1462 std::string signAlg = "SHA384withECDSA";
1463 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
1464 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
1465 std::string keyUsage = "digitalSignature";
1466 std::string basicConstraints = "true";
1467 std::string basicConstraintsCritical = "true";
1468 std::string basicConstraintsCa = "true";
1469 bool keyUsageCritical = true;
1470 char secret[] = "123456";
1471 char ksPwd[] = "123456";
1472 char isksPwd[] = "123456";
1473 (*params)["keyPwd"] = secret;
1474 (*params)["keystorePwd"] = ksPwd;
1475 (*params)["issuerKeystorePwd"] = isksPwd;
1476 (*params)["keyAlias"] = keyAlias;
1477 (*params)["keyPwd"] = keyPwd;
1478 (*params)["keyAlg"] = keyAlg;
1479 (*params)["keySize"] = keySize;
1480 (*params)["keystoreFile"] = keystoreFile;
1481 (*params)["keystorePwd"] = keystorePwd;
1482 (*params)["signAlg"] = signAlg;
1483 (*params)["subject"] = subject;
1484 (*params)["issuer"] = issuer;
1485 (*params)["issuerkeyAlias"] = issuerkeyAlias;
1486 (*params)["keyUsage"] = keyUsage;
1487 (*params)["basicConstraints"] = basicConstraints;
1488 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1489 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1490 (*params)["keyUsageCritical"] = keyUsageCritical;
1491 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get());
1492 EVP_PKEY* keyPair = nullptr;
1493 keyPair = adaptePtr->GetAliasKey(true);
1494 X509_REQ* csr = CertTools::GenerateCsr(keyPair, signAlg, subject);
1495 X509 *cert = CertTools::GenerateCert(keyPair, csr, params.get());
1496 EXPECT_NE(cert, nullptr);
1497 }
1498
1499 /**
1500 * @tc.name: generate_cert_test_015
1501 * @tc.desc: Test function of GenerateCert() FAILED to generate a certificate with a error keyusagecritial.
1502 * @tc.type: FUNC
1503 * @tc.require: SR000H63TL
1504 */
HWTEST_F(GenerateCaTest, generate_cert_test_015, testing::ext::TestSize.Level1)1505 HWTEST_F(GenerateCaTest, generate_cert_test_015, testing::ext::TestSize.Level1)
1506 {
1507 std::shared_ptr<Options> params = std::make_shared<Options>();
1508 std::string keyAlias = "alias";
1509 std::string issuerkeyAlias = "oh-app1-key-v1";
1510 char keyPwd[] = "123456";
1511 std::string keyAlg = "ECC";
1512 int keySize = 256;
1513 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12";
1514 char keystorePwd[] = "123456";
1515 std::string signAlg = "SHA384withECDSA";
1516 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
1517 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
1518 std::string keyUsage = "digitalSignature";
1519 std::string basicConstraints = "false";
1520 std::string basicConstraintsCritical = "false";
1521 std::string basicConstraintsCa = "false";
1522 bool keyUsageCritical = true;
1523 char secret[] = "123456";
1524 char ksPwd[] = "123456";
1525 char isksPwd[] = "123456";
1526 (*params)["keyPwd"] = secret;
1527 (*params)["keystorePwd"] = ksPwd;
1528 (*params)["issuerKeystorePwd"] = isksPwd;
1529 (*params)["keyAlias"] = keyAlias;
1530 (*params)["keyPwd"] = keyPwd;
1531 (*params)["keyAlg"] = keyAlg;
1532 (*params)["keySize"] = keySize;
1533 (*params)["keystoreFile"] = keystoreFile;
1534 (*params)["keystorePwd"] = keystorePwd;
1535 (*params)["signAlg"] = signAlg;
1536 (*params)["subject"] = subject;
1537 (*params)["issuer"] = issuer;
1538 (*params)["issuerkeyAlias"] = issuerkeyAlias;
1539 (*params)["keyUsage"] = keyUsage;
1540 (*params)["basicConstraints"] = basicConstraints;
1541 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1542 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1543 (*params)["keyUsageCritical"] = keyUsageCritical;
1544 EVP_PKEY* keyPair = EVP_PKEY_new();
1545 X509_REQ* csr = X509_REQ_new();
1546 X509 *cert = CertTools::GenerateCert(keyPair, csr, params.get());
1547 EXPECT_EQ(cert, nullptr);
1548 }
1549
1550 /**
1551 * @tc.name: generate_cert_test_016
1552 * @tc.desc: Test function of GenerateCert() FAILED to generate a certificate with a error keyusagecritial.
1553 * @tc.type: FUNC
1554 * @tc.require: SR000H63TL
1555 */
HWTEST_F(GenerateCaTest, generate_cert_test_016, testing::ext::TestSize.Level1)1556 HWTEST_F(GenerateCaTest, generate_cert_test_016, testing::ext::TestSize.Level1)
1557 {
1558 std::shared_ptr<Options> params = std::make_shared<Options>();
1559 std::string keyAlias = "alias";
1560 std::string issuerkeyAlias = "oh-app1-key-v1";
1561 char keyPwd[] = "123456";
1562 std::string keyAlg = "ECC";
1563 int keySize = 256;
1564 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12";
1565 char keystorePwd[] = "123456";
1566 std::string signAlg = "SHA384withECDSA";
1567 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
1568 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
1569 std::string keyUsage = "digitalSignature";
1570 std::string basicConstraints = "false";
1571 std::string basicConstraintsCritical = "false";
1572 std::string basicConstraintsCa = "false";
1573 bool keyUsageCritical = true;
1574 char secret[] = "123456";
1575 char ksPwd[] = "123456";
1576 char isksPwd[] = "123456";
1577 (*params)["keyPwd"] = secret;
1578 (*params)["keystorePwd"] = ksPwd;
1579 (*params)["issuerKeystorePwd"] = isksPwd;
1580 (*params)["keyAlias"] = keyAlias;
1581 (*params)["keyPwd"] = keyPwd;
1582 (*params)["keyAlg"] = keyAlg;
1583 (*params)["keySize"] = keySize;
1584 (*params)["keystoreFile"] = keystoreFile;
1585 (*params)["keystorePwd"] = keystorePwd;
1586 (*params)["signAlg"] = signAlg;
1587 (*params)["subject"] = subject;
1588 (*params)["issuer"] = issuer;
1589 (*params)["issuerkeyAlias"] = issuerkeyAlias;
1590 (*params)["keyUsage"] = keyUsage;
1591 (*params)["basicConstraints"] = basicConstraints;
1592 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1593 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1594 (*params)["keyUsageCritical"] = keyUsageCritical;
1595 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get());
1596 EVP_PKEY* keyPair = nullptr;
1597 keyPair = adaptePtr->GetAliasKey(true);
1598 X509_REQ* csr = X509_REQ_new();
1599 X509 *cert = CertTools::GenerateCert(keyPair, csr, params.get());
1600 EXPECT_EQ(cert, nullptr);
1601 }
1602
1603 /**
1604 * @tc.name: generate_cert_test_022
1605 * @tc.desc: Test function of GenerateCert() FAILED to generate a certificate with a error keyusagecritial.
1606 * @tc.type: FUNC
1607 * @tc.require: SR000H63TL
1608 */
HWTEST_F(GenerateCaTest, generate_cert_test_022, testing::ext::TestSize.Level1)1609 HWTEST_F(GenerateCaTest, generate_cert_test_022, testing::ext::TestSize.Level1)
1610 {
1611 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
1612 std::shared_ptr<Options> params = std::make_shared<Options>();
1613 std::string keyAlias = "alias";
1614 std::string issuerkeyAlias = "oh-app1-key-v1";
1615 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12";
1616 std::string signAlg = "SHA384withECDSA";
1617 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA";
1618 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA";
1619 std::string keyUsage = "digitalSignature";
1620 std::string basicConstraints = "true";
1621 std::string basicConstraintsCritical = "true";
1622 std::string basicConstraintsCa = "true";
1623 std::string keyUsageCritical = "true";
1624 char secret[] = "123456";
1625 char isksPwd[] = "123456";
1626 char keystorePwd[] = "123456";
1627 char issuerkeypwd[] = "123456";
1628 int validity = 365;
1629 std::string outfile = "/data/test/generateCA/general.cer";
1630 (*params)["keyPwd"] = secret;
1631 (*params)["issuerKeystorePwd"] = isksPwd;
1632 (*params)["issuerKeyPwd"] = issuerkeypwd;
1633 (*params)["keyAlias"] = keyAlias;
1634 (*params)["keystoreFile"] = keystoreFile;
1635 (*params)["keystorePwd"] = keystorePwd;
1636 (*params)["signAlg"] = signAlg;
1637 (*params)["subject"] = subject;
1638 (*params)["issuer"] = issuer;
1639 (*params)["issuerKeyAlias"] = issuerkeyAlias;
1640 (*params)["keyUsage"] = keyUsage;
1641 (*params)["basicConstraints"] = basicConstraints;
1642 (*params)["basicConstraintsCritical"] = basicConstraintsCritical;
1643 (*params)["basicConstraintsCa"] = basicConstraintsCa;
1644 (*params)["keyUsageCritical"] = keyUsageCritical;
1645 (*params)["validity"] = validity;
1646 (*params)["outFile"] = outfile;
1647 bool ret = api->GenerateCert(params.get());
1648 EXPECT_EQ(ret, false);
1649 }
1650 }
1651 }