• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *    http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include "securec.h"
18 #include "string"
19 
20 #include "cert_cms_generator.h"
21 #include "cf_blob.h"
22 #include "memory_mock.h"
23 #include "cf_object_base.h"
24 #include "cf_result.h"
25 #include "cf_memory.h"
26 #include "x509_cert_cms_generator_openssl.h"
27 
28 using namespace std;
29 using namespace testing::ext;
30 
31 namespace {
32 class CryptoX509CertCmsGeneratorTest : public testing::Test {
33 public:
34     static void SetUpTestCase();
35     static void TearDownTestCase();
36     void SetUp();
37     void TearDown();
38 };
39 
40 static char g_testRsaKeyPasswordPem[] =
41 "-----BEGIN RSA PRIVATE KEY-----\r\n"
42 "Proc-Type: 4,ENCRYPTED\r\n"
43 "DEK-Info: DES-EDE3-CBC,DB0AC6E3BEE16420\r\n\r\n"
44 "1N5xykdckthZnswMV7blxXm2RCqe/OByBfMwFI7JoXR8STtMiStd4xA3W405k1Ma\r\n"
45 "ExpsHgWwZaS23x+sQ1sL1dsqIPMrw1Vr+KrL20vQcCVjXPpGKauafVbtcWQ1r2PZ\r\n"
46 "QJ4KWP6FhUp+sGt2ItODW3dK+1GdqL22ZtANrgFzS42Wh8FSn0UMCf6RG62DK62J\r\n"
47 "z2jtf4XaorrGSjdTeY+fyyGfSyKidIMMBe+IXwlhCgAe7aHSaqXtMsv+BibB7PJ3\r\n"
48 "XmEp1D/0ptL3r46txyYcuy8jSNCkW8er93KKnlRN6KbuYZPvPNncWkzZBzV17t5d\r\n"
49 "QgtvVh32AKgqk5jm8YVnspOFiPrbrK9UN3IW15juFkfnhriM3IrKap4/kW+tfawZ\r\n"
50 "DmHkSyl8xqFK413Rv0UvYBTjOcGbs2BSJYEvp8CIjtA17SvLmNw70K2nXWuQYutY\r\n"
51 "+HyucPtHfEqUPQRzWTAMMntTru77u7dxo2WMMMxOtMJO5h7MAnZH9bAFiuO3ewcY\r\n"
52 "eEePg10d8Owcfh9G6kc0HIGT9MMLMi0mTXhpoQTuWPYuSx6uUZL1fsp1x2fuM0qn\r\n"
53 "bdf3+UnATYUu4tgvBHrMV7405Y6Y3PnqOFxVMeAHeOTo6UThtJ10mfeCPXGcUaHo\r\n"
54 "P5enw7h4145cha3+S4hNrUwj3skrtavld7tY74p4DvgZSlCMF3JAm3DhpnEMVcYP\r\n"
55 "Y6TkSevvxOpBvEHE41Y4VBCBwd9clcixI6cSBJKPUU4A/sc/kkNdGFcbzLQCg/zR\r\n"
56 "1m7YmBROb2qy4w3lv/uwVnPGLg/YV465irRaN3hgz7/1lm8STKQhmQ==\r\n"
57 "-----END RSA PRIVATE KEY-----\r\n";
58 
59 static char g_testRsaKeyPasswordPemError[] =
60 "-----BEGIN RSA PRIVATE KEY-----\r\n"
61 "Proc-Type: 4,ENCRYPTED\r\n"
62 "DEK-Info: DES-EDE3-CBC,DB0AC6E3BEE16420\r\n\r\n"
63 "1N5xykdckthZnswMV7blxXm2RCqe/OByBfMwFI7JoXR8STtMiStd4xA3W405k1Ma\r\n"
64 "ExpsHgWwZaS23x+sQ1sL1dsqIPMrw1Vr+KrL20vQcCVjXPpGKauafVbtcWQ1r2PZ\r\n"
65 "QJ4KWP6FhUp+sGt2ItODW3dK+1GdqL22ZtANrgFzS42Wh8FSn0UMCf6RG62DK62J\r\n"
66 "z2jtf4XaorrGSjdTeY+fyyGfSyKidIMMBe+IXwlhCgAe7aHSaqXtMsv+BibB7PJ3\r\n"
67 "XmEp1D/0ptL3r46txyYcuy8jSNCkW8er93KKnlRN6KbuYZPvPNncWkzZBzV17t5d\r\n"
68 "QgtvVh32AKgqk5jm8YVnspOFiPrbrK9UN3IW15juFkfnhriM3IrKap4/kW+tfawZ\r\n"
69 "DmHkSyl8xqFK413Rv0UvYBTjOcGbs2BSJYEvp8CIjtA17SvLmNw70K2nXWuQYutY\r\n"
70 "+HyucPtHfEqUPQRzWTAMMntTru77u7dxo2WMMMxOtMJO5h7MAnZH9bAFiuO3ewcY\r\n"
71 "eEePg10d8Owcfh9G6kc0HIGT9MMLMi0mTXhpoQTuWPYuSx6uUZL1fsp1x2fuM0qn\r\n"
72 "bdf3+UnATYUu4tgvBHrMV7405Y6Y3PnqOFxVMeAHeOTo6UThtJ10mfeCPXGcUaHo\r\n"
73 "P5enw7h4145cha3+S4hNrUwj3skrtavld7tY74p4DvgZSlCMF3JAm3DhpnEMVcYP\r\n"
74 "Y6TkSevvxOpBvEHE41Y4VBCBwd9clcixI6cSBJKPUU4A/sc/kkNdGFcbzLQCg/zR\r\n"
75 "1m7YmBROb2qy4w3lv/uwVnPGLg\r\n"
76 "-----END RSA PRIVATE KEY-----\r\n";
77 
78 static uint8_t g_testRsaKeyPasswordDer[] = {
79 0x30, 0x82, 0x02, 0xdd, 0x30, 0x57, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
80 0x0d, 0x30, 0x4a, 0x30, 0x29, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05, 0x0c,
81 0x30, 0x1c, 0x04, 0x08, 0x79, 0x08, 0x9d, 0xc0, 0xa8, 0x59, 0x4d, 0xc1, 0x02, 0x02, 0x08, 0x00,
82 0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x09, 0x05, 0x00, 0x30, 0x1d,
83 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x01, 0x02, 0x04, 0x10, 0x0e, 0xb7, 0x7d,
84 0x2b, 0x4b, 0x11, 0xc0, 0x40, 0x84, 0x62, 0xc9, 0xa9, 0x31, 0x29, 0x68, 0x2d, 0x04, 0x82, 0x02,
85 0x80, 0x78, 0xe4, 0xbd, 0x79, 0x77, 0x2e, 0xd7, 0x71, 0xce, 0xa0, 0x74, 0x0d, 0x2a, 0x8b, 0xcf,
86 0xa8, 0x37, 0x47, 0xbd, 0xe6, 0x4e, 0x47, 0xaa, 0x2c, 0xea, 0xcb, 0x2b, 0x5a, 0x1a, 0x9d, 0x4b,
87 0x38, 0x67, 0xec, 0xc1, 0xce, 0x10, 0x95, 0xb4, 0xba, 0x91, 0xa1, 0xa8, 0xa2, 0x17, 0x23, 0x33,
88 0x44, 0xc0, 0x3b, 0xc3, 0xa8, 0xc4, 0x7a, 0xcb, 0x9a, 0x8f, 0xa6, 0x07, 0x7e, 0x3e, 0xcc, 0xd8,
89 0xc7, 0x37, 0x4f, 0x14, 0xa8, 0xc0, 0x51, 0xe6, 0x6c, 0x7c, 0x01, 0x93, 0xcb, 0x0f, 0x65, 0x28,
90 0x4d, 0x94, 0xd1, 0xbd, 0xe3, 0x66, 0x6f, 0xf0, 0x82, 0x34, 0x82, 0x31, 0x30, 0xdb, 0x29, 0xa3,
91 0x9b, 0xca, 0xca, 0x43, 0xb6, 0xcd, 0x75, 0x0c, 0x6c, 0xd6, 0xd1, 0x7f, 0x2c, 0xff, 0x53, 0xb9,
92 0xa2, 0x79, 0x81, 0x35, 0xfd, 0x02, 0xe4, 0x2b, 0x1d, 0x83, 0x8c, 0xa3, 0x69, 0xf1, 0x64, 0x86,
93 0x41, 0x7d, 0xe0, 0x81, 0x50, 0x51, 0x85, 0xcd, 0x50, 0x23, 0xef, 0xeb, 0x8e, 0x1c, 0x38, 0x13,
94 0xd9, 0xb5, 0x7c, 0x40, 0x7d, 0x20, 0x69, 0x31, 0x74, 0x5f, 0x50, 0xb2, 0xb2, 0xbe, 0xce, 0xfc,
95 0x61, 0x37, 0x89, 0xc4, 0x2a, 0xed, 0x36, 0x57, 0xf6, 0x95, 0xc4, 0xc1, 0x9f, 0x76, 0x51, 0xe2,
96 0xef, 0x66, 0x90, 0x30, 0x40, 0x99, 0x73, 0xff, 0xe1, 0xaf, 0xaa, 0x95, 0x7f, 0x2f, 0x8f, 0x09,
97 0x16, 0x1b, 0x95, 0x5a, 0xdf, 0x02, 0x13, 0x5b, 0x1c, 0x27, 0x57, 0xb0, 0x7f, 0x88, 0xdd, 0x16,
98 0x3b, 0x35, 0x99, 0x5f, 0xdf, 0x03, 0xa0, 0x85, 0x45, 0x10, 0xc7, 0xa0, 0x4a, 0xe8, 0xa9, 0x57,
99 0xaf, 0x02, 0x16, 0x50, 0xac, 0xd8, 0x50, 0x5a, 0x68, 0x0d, 0x79, 0xe9, 0xee, 0x51, 0x24, 0x43,
100 0x63, 0xe3, 0x7c, 0x46, 0xe6, 0x8f, 0x0b, 0xfa, 0x84, 0xc5, 0xf6, 0xb5, 0x0a, 0x62, 0x8d, 0x6a,
101 0xf4, 0x25, 0xf9, 0x52, 0x12, 0x7f, 0x8b, 0xfb, 0x98, 0xe0, 0x57, 0x5a, 0x4e, 0x21, 0x1e, 0x99,
102 0x61, 0xc2, 0x8b, 0x32, 0xcd, 0xf4, 0x17, 0xa1, 0x70, 0xcc, 0xdf, 0xca, 0x1c, 0x3b, 0xbb, 0xca,
103 0xa1, 0xa1, 0x5c, 0x62, 0xc6, 0x24, 0xef, 0xb6, 0xcf, 0xba, 0xe9, 0xe7, 0x5a, 0x80, 0x30, 0x03,
104 0x08, 0x91, 0x7d, 0x80, 0x37, 0x86, 0xd5, 0x8f, 0x2c, 0x38, 0x3f, 0x1c, 0x7a, 0xef, 0xd9, 0x35,
105 0x78, 0x3f, 0xd5, 0xde, 0x9a, 0xd3, 0x00, 0x13, 0x56, 0x39, 0xe5, 0x45, 0x36, 0xe8, 0x5a, 0xb0,
106 0x08, 0x1b, 0xde, 0x95, 0x6d, 0x00, 0xb9, 0x90, 0x9f, 0xf0, 0x8a, 0x01, 0x91, 0xc5, 0x09, 0x40,
107 0xc1, 0xfd, 0x0c, 0xb3, 0xe4, 0xa5, 0xf5, 0xc4, 0xff, 0x27, 0xf4, 0x0a, 0xfc, 0x55, 0x3d, 0x1a,
108 0x69, 0x68, 0xc3, 0x63, 0xac, 0x68, 0x92, 0x5b, 0x88, 0xdf, 0xc3, 0x38, 0x22, 0x02, 0xa0, 0x6c,
109 0xb3, 0x93, 0xc7, 0x29, 0xdc, 0xbb, 0xf7, 0xac, 0x8d, 0xfe, 0x92, 0xfb, 0x28, 0x65, 0x2e, 0xbb,
110 0xbd, 0x0c, 0xa8, 0x80, 0x07, 0xf6, 0xac, 0xf5, 0x43, 0x03, 0x9a, 0xb9, 0xb9, 0x6d, 0xac, 0x5f,
111 0xc6, 0x48, 0x2c, 0x1a, 0xb9, 0xc8, 0x65, 0xd5, 0x43, 0x98, 0xf5, 0xeb, 0x15, 0xb7, 0xb7, 0xf4,
112 0x4b, 0xe8, 0xc8, 0x8e, 0x3d, 0x05, 0x9e, 0xda, 0x81, 0xdd, 0x41, 0x3d, 0x3b, 0xc1, 0xea, 0xc0,
113 0x03, 0x41, 0x46, 0xa8, 0x62, 0x05, 0x27, 0x99, 0xc5, 0x4f, 0xa3, 0x58, 0xff, 0x11, 0x4b, 0xfd,
114 0xe1, 0xae, 0x13, 0xc2, 0x28, 0xac, 0x9c, 0xe8, 0xb0, 0xbf, 0x77, 0x45, 0x03, 0x90, 0xca, 0xbf,
115 0xc2, 0xca, 0x9c, 0xdc, 0x00, 0x66, 0xd7, 0x56, 0x5b, 0x18, 0x2f, 0x88, 0x58, 0xc8, 0x2d, 0xf2,
116 0x85, 0x9b, 0x74, 0x2f, 0x79, 0x38, 0x2b, 0x0b, 0x2f, 0x1e, 0x8a, 0xa7, 0x57, 0xc3, 0x05, 0x94,
117 0x15, 0xc6, 0x60, 0x02, 0xe8, 0xf5, 0x6e, 0x1b, 0x3f, 0x42, 0x43, 0x44, 0xf1, 0xae, 0xad, 0xc6,
118 0xf3, 0xdd, 0xf8, 0xe0, 0x37, 0x65, 0xd8, 0x71, 0x0a, 0x87, 0x5e, 0x65, 0xb4, 0xe3, 0x11, 0x73,
119 0xab, 0xa3, 0x87, 0x8b, 0x9c, 0x6c, 0xc4, 0xea, 0xb2, 0xd6, 0x95, 0x7c, 0xd3, 0x82, 0xa7, 0xfd,
120 0x5d, 0x53, 0xe1, 0x22, 0x19, 0xfe, 0xfc, 0x02, 0x3e, 0x55, 0x8e, 0xb8, 0xd8, 0x4c, 0x79, 0xa8,
121 0xcd, 0x13, 0x74, 0xab, 0xca, 0xf2, 0x9b, 0xfe, 0xbc, 0xbe, 0x69, 0xff, 0x2d, 0x44, 0x62, 0x3a,
122 0xa0, 0x66, 0xbe, 0x7b, 0x22, 0xe7, 0x81, 0xc1, 0x58, 0xa5, 0x08, 0x0d, 0x1e, 0xdc, 0xb6, 0x77,
123 0xd1, 0xa3, 0xbc, 0x4b, 0x6a, 0x5d, 0x03, 0xd1, 0x05, 0x61, 0xd8, 0xac, 0xef, 0x2a, 0x9f, 0x3c,
124 0xc4, 0x9d, 0x80, 0xb3, 0x4a, 0x18, 0x23, 0x57, 0xa1, 0x5f, 0x7b, 0x28, 0x86, 0x09, 0x51, 0x71,
125 0xf4};
126 
127 static uint8_t g_testRsaKeyPasswordDerError[] = {
128 0x30, 0x82, 0x02, 0xdd, 0x30, 0x57, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05,
129 0x0d, 0x30, 0x4a, 0x30, 0x29, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x05, 0x0c,
130 0x30, 0x1c, 0x04, 0x08, 0x79, 0x08, 0x9d, 0xc0, 0xa8, 0x59, 0x4d, 0xc1, 0x02, 0x02, 0x08, 0x00,
131 0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x02, 0x09, 0x05, 0x00, 0x30, 0x1d,
132 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x01, 0x02, 0x04, 0x10, 0x0e, 0xb7, 0x7d,
133 0x2b, 0x4b, 0x11, 0xc0, 0x40, 0x84, 0x62, 0xc9, 0xa9, 0x31, 0x29, 0x68, 0x2d, 0x04, 0x82, 0x02,
134 0x80, 0x78, 0xe4, 0xbd, 0x79, 0x77, 0x2e, 0xd7, 0x71, 0xce, 0xa0, 0x74, 0x0d, 0x2a, 0x8b, 0xcf,
135 0xa8, 0x37, 0x47, 0xbd, 0xe6, 0x4e, 0x47, 0xaa, 0x2c, 0xea, 0xcb, 0x2b, 0x5a, 0x1a, 0x9d, 0x4b,
136 0x38, 0x67, 0xec, 0xc1, 0xce, 0x10, 0x95, 0xb4, 0xba, 0x91, 0xa1, 0xa8, 0xa2, 0x17, 0x23, 0x33,
137 0x44, 0xc0, 0x3b, 0xc3, 0xa8, 0xc4, 0x7a, 0xcb, 0x9a, 0x8f, 0xa6, 0x07, 0x7e, 0x3e, 0xcc, 0xd8,
138 0xc7, 0x37, 0x4f, 0x14, 0xa8, 0xc0, 0x51, 0xe6, 0x6c, 0x7c, 0x01, 0x93, 0xcb, 0x0f, 0x65, 0x28,
139 0x4d, 0x94, 0xd1, 0xbd, 0xe3, 0x66, 0x6f, 0xf0, 0x82, 0x34, 0x82, 0x31, 0x30, 0xdb, 0x29, 0xa3,
140 0x9b, 0xca, 0xca, 0x43, 0xb6, 0xcd, 0x75, 0x0c, 0x6c, 0xd6, 0xd1, 0x7f, 0x2c, 0xff, 0x53, 0xb9,
141 0xa2, 0x79, 0x81, 0x35, 0xfd, 0x02, 0xe4, 0x2b, 0x1d, 0x83, 0x8c, 0xa3, 0x69, 0xf1, 0x64, 0x86,
142 0x41, 0x7d, 0xe0, 0x81, 0x50, 0x51, 0x85, 0xcd, 0x50, 0x23, 0xef, 0xeb, 0x8e, 0x1c, 0x38, 0x13,
143 0xd9, 0xb5, 0x7c, 0x40, 0x7d, 0x20, 0x69, 0x31, 0x74, 0x5f, 0x50, 0xb2, 0xb2, 0xbe, 0xce, 0xfc,
144 0x61, 0x37, 0x89, 0xc4, 0x2a, 0xed, 0x36, 0x57, 0xf6, 0x95, 0xc4, 0xc1, 0x9f, 0x76, 0x51, 0xe2,
145 0xef, 0x66, 0x90, 0x30, 0x40, 0x99, 0x73, 0xff, 0xe1, 0xaf, 0xaa, 0x95, 0x7f, 0x2f, 0x8f, 0x09,
146 0x16, 0x1b, 0x95, 0x5a, 0xdf, 0x02, 0x13, 0x5b, 0x1c, 0x27, 0x57, 0xb0, 0x7f, 0x88, 0xdd, 0x16,
147 0x3b, 0x35, 0x99, 0x5f, 0xdf, 0x03, 0xa0, 0x85, 0x45, 0x10, 0xc7, 0xa0, 0x4a, 0xe8, 0xa9, 0x57,
148 0xaf, 0x02, 0x16, 0x50, 0xac, 0xd8, 0x50, 0x5a, 0x68, 0x0d, 0x79, 0xe9, 0xee, 0x51, 0x24, 0x43,
149 0x63, 0xe3, 0x7c, 0x46, 0xe6, 0x8f, 0x0b, 0xfa, 0x84, 0xc5, 0xf6, 0xb5, 0x0a, 0x62, 0x8d, 0x6a,
150 0xf4, 0x25, 0xf9, 0x52, 0x12, 0x7f, 0x8b, 0xfb, 0x98, 0xe0, 0x57, 0x5a, 0x4e, 0x21, 0x1e, 0x99,
151 0x61, 0xc2, 0x8b, 0x32, 0xcd, 0xf4, 0x17, 0xa1, 0x70, 0xcc, 0xdf, 0xca, 0x1c, 0x3b, 0xbb, 0xca,
152 0xa1, 0xa1, 0x5c, 0x62, 0xc6, 0x24, 0xef, 0xb6, 0xcf, 0xba, 0xe9, 0xe7, 0x5a, 0x80, 0x30, 0x03,
153 0x08, 0x91, 0x7d, 0x80, 0x37, 0x86, 0xd5, 0x8f, 0x2c, 0x38, 0x3f, 0x1c, 0x7a, 0xef, 0xd9, 0x35,
154 0x78, 0x3f, 0xd5, 0xde, 0x9a, 0xd3, 0x00, 0x13, 0x56, 0x39, 0xe5, 0x45, 0x36, 0xe8, 0x5a, 0xb0,
155 0x08, 0x1b, 0xde, 0x95, 0x6d, 0x00, 0xb9, 0x90, 0x9f, 0xf0, 0x8a, 0x01, 0x91, 0xc5, 0x09, 0x40,
156 0xc1, 0xfd, 0x0c, 0xb3, 0xe4, 0xa5, 0xf5, 0xc4, 0xff, 0x27, 0xf4, 0x0a, 0xfc, 0x55, 0x3d, 0x1a,
157 0x69, 0x68, 0xc3, 0x63, 0xac, 0x68, 0x92, 0x5b, 0x88, 0xdf, 0xc3, 0x38, 0x22, 0x02, 0xa0, 0x6c,
158 0xb3, 0x93, 0xc7, 0x29, 0xdc, 0xbb, 0xf7, 0xac, 0x8d, 0xfe, 0x92, 0xfb, 0x28, 0x65, 0x2e, 0xbb,
159 0xbd, 0x0c, 0xa8, 0x80, 0x07, 0xf6, 0xac, 0xf5, 0x43, 0x03, 0x9a, 0xb9, 0xb9, 0x6d, 0xac, 0x5f,
160 0xc6, 0x48, 0x2c, 0x1a, 0xb9, 0xc8, 0x65, 0xd5, 0x43, 0x98, 0xf5, 0xeb, 0x15, 0xb7, 0xb7, 0xf4,
161 0x4b, 0xe8, 0xc8, 0x8e, 0x3d, 0x05, 0x9e, 0xda, 0x81, 0xdd, 0x41, 0x3d, 0x3b, 0xc1, 0xea, 0xc0,
162 0x03, 0x41, 0x46, 0xa8, 0x62, 0x05, 0x27, 0x99, 0xc5, 0x4f, 0xa3, 0x58, 0xff, 0x11, 0x4b, 0xfd,
163 0xe1, 0xae, 0x13, 0xc2, 0x28, 0xac, 0x9c, 0xe8, 0xb0, 0xbf, 0x77, 0x45, 0x03, 0x90, 0xca, 0xbf,
164 0xc2, 0xca, 0x9c, 0xdc, 0x00, 0x66, 0xd7, 0x56, 0x5b, 0x18, 0x2f, 0x88, 0x58, 0xc8, 0x2d, 0xf2,
165 0x85, 0x9b, 0x74, 0x2f, 0x79, 0x38, 0x2b, 0x0b, 0x2f, 0x1e, 0x8a, 0xa7, 0x57, 0xc3, 0x05, 0x94,
166 0x15, 0xc6, 0x60, 0x02, 0xe8, 0xf5, 0x6e, 0x1b, 0x3f, 0x42, 0x43, 0x44, 0xf1, 0xae, 0xad, 0xc6,
167 0xf3, 0xdd, 0xf8, 0xe0, 0x37, 0x65, 0xd8, 0x71, 0x0a, 0x87, 0x5e, 0x65, 0xb4, 0xe3, 0x11, 0x73,
168 0xab, 0xa3, 0x87, 0x8b, 0x9c, 0x6c, 0xc4, 0xea, 0xb2, 0xd6, 0x95, 0x7c, 0xd3, 0x82, 0xa7, 0xfd,
169 0x5d, 0x53, 0xe1, 0x22, 0x19, 0xfe, 0xfc, 0x02, 0x3e, 0x55, 0x8e, 0xb8, 0xd8, 0x4c, 0x79, 0xa8,
170 0xcd, 0x13, 0x74, 0xab, 0xca, 0xf2, 0x9b, 0xfe, 0xbc, 0xbe, 0x69, 0xff, 0x2d, 0x44, 0x62, 0x3a,
171 0xa0, 0x66, 0xbe, 0x7b, 0x22, 0xe7, 0x81, 0xc1, 0x58, 0xa5, 0x08, 0x0d, 0x1e, 0xdc, 0xb6, 0x77,
172 0xd1, 0xa3, 0xbc, 0x4b, 0x6a, 0x5d, 0x03, 0xd1, 0x05, 0x61, 0xd8, 0xac, 0xef, 0x2a, 0x9f, 0x3c,
173 0xc4, 0x9d, 0x80, 0xb3, 0x4a, 0x18, 0x23, 0x57, 0xa1, 0x5f, 0x7b, 0x28, 0x86, 0x09, 0x51, 0x71};
174 
175 static char g_testRsaCertPasswordPem[] =
176 "-----BEGIN CERTIFICATE-----\r\n"
177 "MIICXjCCAcegAwIBAgIGAXKnJjrAMA0GCSqGSIb3DQEBCwUAMEgxCzAJBgNVBAYT\r\n"
178 "AkNOMQwwCgYDVQQIDANzaGExDTALBgNVBAcMBHhpYW4xDTALBgNVBAoMBHRlc3Qx\r\n"
179 "DTALBgNVBAMMBHRlc3QwHhcNMjQxMTIyMDkwNTIyWhcNMzQxMTIwMDkwNTIyWjBI\r\n"
180 "MQswCQYDVQQGEwJDTjEMMAoGA1UECAwDc2hhMQ0wCwYDVQQHDAR4aWFuMQ0wCwYD\r\n"
181 "VQQKDAR0ZXN0MQ0wCwYDVQQDDAR0ZXN0MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB\r\n"
182 "iQKBgQC6nCZTM16Rk2c4P/hwfVm++jqe6GCA/PXXGe4YL218q1dTKMHBGEw8kXi0\r\n"
183 "XLDcyyC2yUn8ywN2QSyly6ke9EE6PGfZywStLp4g2PTTWB04sS3aXT2y+fToiTXQ\r\n"
184 "3AxfFYRpB+EgSdSCkJs6jKXVwbzu54kEtQTfs8UdBQ9nVKaJLwIDAQABo1MwUTAd\r\n"
185 "BgNVHQ4EFgQU6QXnt1smb2HRSO/2zuRQnz/SDxowHwYDVR0jBBgwFoAU6QXnt1sm\r\n"
186 "b2HRSO/2zuRQnz/SDxowDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOB\r\n"
187 "gQBPR/+5xzFG1XlTdgwWVvqVxvhGUkbMTGW0IviJ+jbKsi57vnVsOtFzEA6y+bYx\r\n"
188 "xG/kEOcwLtzeVHOQA+ZU5SVcc+qc0dfFiWjL2PSAG4bpqSTjujpuUk+g8ugixbG1\r\n"
189 "a26pkDJhNeB/E3eBIbeydSY0A/dIGb6vbGo6BSq2KvnWAA==\r\n"
190 "-----END CERTIFICATE-----\r\n";
191 
192 static char g_testRsaCertPasswordPem2[] =
193 "-----BEGIN CERTIFICATE-----\r\n"
194 "MIICXjCCAcegAwIBAgIGAXKnJjrAMA0GCSqGSIb3DQEBCwUAMEgxCzAJBgNVBAYT\r\n"
195 "AkNOMQwwCgYDVQQIDANzaGExDTALBgNVBAcMBHhpYW4xDTALBgNVBAoMBHRlc3Qx\r\n"
196 "DTALBgNVBAMMBHRlc3QwHhcNMjQxMjA5MTE1NzE1WhcNMzQxMjA3MTE1NzE1WjBI\r\n"
197 "MQswCQYDVQQGEwJDTjEMMAoGA1UECAwDc2hhMQ0wCwYDVQQHDAR4aWFuMQ0wCwYD\r\n"
198 "VQQKDAR0ZXN0MQ0wCwYDVQQDDAR0ZXN0MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB\r\n"
199 "iQKBgQDCmmNbA+i6gUOk1I7LahJtZMtPv8La7rE865y9lbsBht9LcGOrN/tupRV+\r\n"
200 "dM5miEsk6RsA88755+3RQeZia0ziRP2O3iKE965atdJZBKRarc7e88uFJQR6SfM8\r\n"
201 "2L0xJXuypnA+piEzVs7joFxeNxuCALnI9iLlqjmgwWKGIVJxMwIDAQABo1MwUTAd\r\n"
202 "BgNVHQ4EFgQUEYJQ9alCQmT3vq/iDn+joQPkuPcwHwYDVR0jBBgwFoAUEYJQ9alC\r\n"
203 "QmT3vq/iDn+joQPkuPcwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOB\r\n"
204 "gQBQdnW51Ag5uoZcbJgHU9tfIS60CYq8tyfVcbL/CtG2x5vQszF+dqWBhMEWnaV4\r\n"
205 "5+IOSPOxizE838wP1L84CxmRxkCCBbKCt4w79ZKRa/RcGB7NOQijM87ywogRo3Z4\r\n"
206 "7G3YE3NrPWlFAFGB6olmUz/JRdfbdbWW9ftTM0g+P9dq0Q==\r\n"
207 "-----END CERTIFICATE-----\r\n";
208 
209 const CfEncodingBlob g_inCertPasswordPemStream = {
210     .data = reinterpret_cast<uint8_t *>(g_testRsaCertPasswordPem),
211     .len = strlen(g_testRsaCertPasswordPem) + 1,
212     .encodingFormat = CF_FORMAT_PEM
213 };
214 
215 const CfEncodingBlob g_inCertPasswordPemStream2 = {
216     .data = reinterpret_cast<uint8_t *>(g_testRsaCertPasswordPem2),
217     .len = strlen(g_testRsaCertPasswordPem2) + 1,
218     .encodingFormat = CF_FORMAT_PEM
219 };
220 
221 const CfEncodingBlob g_inKeyPasswordPemStream = {
222     .data = reinterpret_cast<uint8_t *>(g_testRsaKeyPasswordPem),
223     .len = strlen(g_testRsaKeyPasswordPem) + 1,
224     .encodingFormat = CF_FORMAT_PEM
225 };
226 
227 const CfEncodingBlob g_inKeyPasswordPemStreamError = {
228     .data = reinterpret_cast<uint8_t *>(g_testRsaKeyPasswordPemError),
229     .len = strlen(g_testRsaKeyPasswordPemError) + 1,
230     .encodingFormat = CF_FORMAT_PEM
231 };
232 
233 const CfEncodingBlob g_inKeyPasswordDerStream = {
234     .data = reinterpret_cast<uint8_t *>(g_testRsaKeyPasswordDer),
235     .len = sizeof(g_testRsaKeyPasswordDer),
236     .encodingFormat = CF_FORMAT_DER
237 };
238 
239 const CfEncodingBlob g_inKeyPasswordDerStreamError = {
240     .data = reinterpret_cast<uint8_t *>(g_testRsaKeyPasswordDerError),
241     .len = sizeof(g_testRsaKeyPasswordDerError),
242     .encodingFormat = CF_FORMAT_DER
243 };
244 
245 static char g_testRsaKeyNoPasswordPem[] =
246 "-----BEGIN RSA PRIVATE KEY-----\r\n"
247 "MIICXAIBAAKBgQC+T3StG1Xv82Hlc6GtiVm9HiMAdfeAix+rTSYhzyB7x2SrksKs\r\n"
248 "YqcJItDrIGjaes/F9znT+Xacuj4aNgaKqPaopDpDgPD0PS+lIwGdjLtQy0ogqs59\r\n"
249 "D+/KRhtD/p1RVrUNpL/mti0s0hWCjbZcLr9qFoQ6figJaXz2TILTMppaxwIDAQAB\r\n"
250 "AoGAN3U8EP34SxZnns/Ve5ac+gmANbAq0eC499hhllSfqLJwWbdI16df+b+Vlg85\r\n"
251 "vwEu7weeaHE36XA0jLrVqS6XwgfyG6Y/cxh4mHJWmNeFYSLNkZaLfMzZEsvh/Gtp\r\n"
252 "dxobHekcOKGQKEvlFnU3POLP5yGAFHLVKy6Eu7vrPdjX8TECQQDyj9RkA85gFwye\r\n"
253 "8Kud5Q6Ddl0ForJN2WEpV4kaTPZPON7bYVlBYslWtsQwnvW8+B96dp5NFdHPM4Dw\r\n"
254 "mS1md3BzAkEAyNqP0Lhenpu068bNVkNxiuTj12WZ6FGp1+9l42dnjgl3aM0d4TIr\r\n"
255 "IOXNlk5bgXODiIUZUwQ/3TQdcXsd7YQ7XQJAEISo8xKrSDHpox1CoqMJpPw3g327\r\n"
256 "5L9L9ZPHe2oIUAbQbmInwOMoUOZrX+BDXdYL1rwjNZ6pxhF802WrCNJTbwJBAKSR\r\n"
257 "N56bQaORDobUh6+zaNeVvPziWV1Zc+DiXMgbFGTzaqwqy92U3nOA9pa9swn43H/C\r\n"
258 "FkLHy4/xwGIXryjJ3F0CQA3ieCRmYxrLiYQkxYyjBE4s8vV55Ldz0qNJTG4NvtgS\r\n"
259 "uvZuFdOpke8LnfL4lCVzTitVsvHh4UT9XGrqhPDHIxU=\r\n"
260 "-----END RSA PRIVATE KEY-----\r\n";
261 
262 static uint8_t g_testRsaKeyNoPasswordDer[] = {
263 0x30, 0x82, 0x02, 0x5C, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xBE, 0x4F, 0x74, 0xAD, 0x1B,
264 0x55, 0xEF, 0xF3, 0x61, 0xE5, 0x73, 0xA1, 0xAD, 0x89, 0x59, 0xBD, 0x1E, 0x23, 0x00, 0x75, 0xF7,
265 0x80, 0x8B, 0x1F, 0xAB, 0x4D, 0x26, 0x21, 0xCF, 0x20, 0x7B, 0xC7, 0x64, 0xAB, 0x92, 0xC2, 0xAC,
266 0x62, 0xA7, 0x09, 0x22, 0xD0, 0xEB, 0x20, 0x68, 0xDA, 0x7A, 0xCF, 0xC5, 0xF7, 0x39, 0xD3, 0xF9,
267 0x76, 0x9C, 0xBA, 0x3E, 0x1A, 0x36, 0x06, 0x8A, 0xA8, 0xF6, 0xA8, 0xA4, 0x3A, 0x43, 0x80, 0xF0,
268 0xF4, 0x3D, 0x2F, 0xA5, 0x23, 0x01, 0x9D, 0x8C, 0xBB, 0x50, 0xCB, 0x4A, 0x20, 0xAA, 0xCE, 0x7D,
269 0x0F, 0xEF, 0xCA, 0x46, 0x1B, 0x43, 0xFE, 0x9D, 0x51, 0x56, 0xB5, 0x0D, 0xA4, 0xBF, 0xE6, 0xB6,
270 0x2D, 0x2C, 0xD2, 0x15, 0x82, 0x8D, 0xB6, 0x5C, 0x2E, 0xBF, 0x6A, 0x16, 0x84, 0x3A, 0x7E, 0x28,
271 0x09, 0x69, 0x7C, 0xF6, 0x4C, 0x82, 0xD3, 0x32, 0x9A, 0x5A, 0xC7, 0x02, 0x03, 0x01, 0x00, 0x01,
272 0x02, 0x81, 0x80, 0x37, 0x75, 0x3C, 0x10, 0xFD, 0xF8, 0x4B, 0x16, 0x67, 0x9E, 0xCF, 0xD5, 0x7B,
273 0x96, 0x9C, 0xFA, 0x09, 0x80, 0x35, 0xB0, 0x2A, 0xD1, 0xE0, 0xB8, 0xF7, 0xD8, 0x61, 0x96, 0x54,
274 0x9F, 0xA8, 0xB2, 0x70, 0x59, 0xB7, 0x48, 0xD7, 0xA7, 0x5F, 0xF9, 0xBF, 0x95, 0x96, 0x0F, 0x39,
275 0xBF, 0x01, 0x2E, 0xEF, 0x07, 0x9E, 0x68, 0x71, 0x37, 0xE9, 0x70, 0x34, 0x8C, 0xBA, 0xD5, 0xA9,
276 0x2E, 0x97, 0xC2, 0x07, 0xF2, 0x1B, 0xA6, 0x3F, 0x73, 0x18, 0x78, 0x98, 0x72, 0x56, 0x98, 0xD7,
277 0x85, 0x61, 0x22, 0xCD, 0x91, 0x96, 0x8B, 0x7C, 0xCC, 0xD9, 0x12, 0xCB, 0xE1, 0xFC, 0x6B, 0x69,
278 0x77, 0x1A, 0x1B, 0x1D, 0xE9, 0x1C, 0x38, 0xA1, 0x90, 0x28, 0x4B, 0xE5, 0x16, 0x75, 0x37, 0x3C,
279 0xE2, 0xCF, 0xE7, 0x21, 0x80, 0x14, 0x72, 0xD5, 0x2B, 0x2E, 0x84, 0xBB, 0xBB, 0xEB, 0x3D, 0xD8,
280 0xD7, 0xF1, 0x31, 0x02, 0x41, 0x00, 0xF2, 0x8F, 0xD4, 0x64, 0x03, 0xCE, 0x60, 0x17, 0x0C, 0x9E,
281 0xF0, 0xAB, 0x9D, 0xE5, 0x0E, 0x83, 0x76, 0x5D, 0x05, 0xA2, 0xB2, 0x4D, 0xD9, 0x61, 0x29, 0x57,
282 0x89, 0x1A, 0x4C, 0xF6, 0x4F, 0x38, 0xDE, 0xDB, 0x61, 0x59, 0x41, 0x62, 0xC9, 0x56, 0xB6, 0xC4,
283 0x30, 0x9E, 0xF5, 0xBC, 0xF8, 0x1F, 0x7A, 0x76, 0x9E, 0x4D, 0x15, 0xD1, 0xCF, 0x33, 0x80, 0xF0,
284 0x99, 0x2D, 0x66, 0x77, 0x70, 0x73, 0x02, 0x41, 0x00, 0xC8, 0xDA, 0x8F, 0xD0, 0xB8, 0x5E, 0x9E,
285 0x9B, 0xB4, 0xEB, 0xC6, 0xCD, 0x56, 0x43, 0x71, 0x8A, 0xE4, 0xE3, 0xD7, 0x65, 0x99, 0xE8, 0x51,
286 0xA9, 0xD7, 0xEF, 0x65, 0xE3, 0x67, 0x67, 0x8E, 0x09, 0x77, 0x68, 0xCD, 0x1D, 0xE1, 0x32, 0x2B,
287 0x20, 0xE5, 0xCD, 0x96, 0x4E, 0x5B, 0x81, 0x73, 0x83, 0x88, 0x85, 0x19, 0x53, 0x04, 0x3F, 0xDD,
288 0x34, 0x1D, 0x71, 0x7B, 0x1D, 0xED, 0x84, 0x3B, 0x5D, 0x02, 0x40, 0x10, 0x84, 0xA8, 0xF3, 0x12,
289 0xAB, 0x48, 0x31, 0xE9, 0xA3, 0x1D, 0x42, 0xA2, 0xA3, 0x09, 0xA4, 0xFC, 0x37, 0x83, 0x7D, 0xBB,
290 0xE4, 0xBF, 0x4B, 0xF5, 0x93, 0xC7, 0x7B, 0x6A, 0x08, 0x50, 0x06, 0xD0, 0x6E, 0x62, 0x27, 0xC0,
291 0xE3, 0x28, 0x50, 0xE6, 0x6B, 0x5F, 0xE0, 0x43, 0x5D, 0xD6, 0x0B, 0xD6, 0xBC, 0x23, 0x35, 0x9E,
292 0xA9, 0xC6, 0x11, 0x7C, 0xD3, 0x65, 0xAB, 0x08, 0xD2, 0x53, 0x6F, 0x02, 0x41, 0x00, 0xA4, 0x91,
293 0x37, 0x9E, 0x9B, 0x41, 0xA3, 0x91, 0x0E, 0x86, 0xD4, 0x87, 0xAF, 0xB3, 0x68, 0xD7, 0x95, 0xBC,
294 0xFC, 0xE2, 0x59, 0x5D, 0x59, 0x73, 0xE0, 0xE2, 0x5C, 0xC8, 0x1B, 0x14, 0x64, 0xF3, 0x6A, 0xAC,
295 0x2A, 0xCB, 0xDD, 0x94, 0xDE, 0x73, 0x80, 0xF6, 0x96, 0xBD, 0xB3, 0x09, 0xF8, 0xDC, 0x7F, 0xC2,
296 0x16, 0x42, 0xC7, 0xCB, 0x8F, 0xF1, 0xC0, 0x62, 0x17, 0xAF, 0x28, 0xC9, 0xDC, 0x5D, 0x02, 0x40,
297 0x0D, 0xE2, 0x78, 0x24, 0x66, 0x63, 0x1A, 0xCB, 0x89, 0x84, 0x24, 0xC5, 0x8C, 0xA3, 0x04, 0x4E,
298 0x2C, 0xF2, 0xF5, 0x79, 0xE4, 0xB7, 0x73, 0xD2, 0xA3, 0x49, 0x4C, 0x6E, 0x0D, 0xBE, 0xD8, 0x12,
299 0xBA, 0xF6, 0x6E, 0x15, 0xD3, 0xA9, 0x91, 0xEF, 0x0B, 0x9D, 0xF2, 0xF8, 0x94, 0x25, 0x73, 0x4E,
300 0x2B, 0x55, 0xB2, 0xF1, 0xE1, 0xE1, 0x44, 0xFD, 0x5C, 0x6A, 0xEA, 0x84, 0xF0, 0xC7, 0x23, 0x15
301 };
302 
303 static char g_testRsaCertNoPasswordPem[] =
304 "-----BEGIN CERTIFICATE-----\r\n"
305 "MIICXjCCAcegAwIBAgIGAXKnJjrAMA0GCSqGSIb3DQEBCwUAMEgxCzAJBgNVBAYT\r\n"
306 "AkNOMQwwCgYDVQQIDANzaGExDTALBgNVBAcMBHhpYW4xDTALBgNVBAoMBHRlc3Qx\r\n"
307 "DTALBgNVBAMMBHRlc3QwHhcNMjQxMTIzMDY0NTE0WhcNMzQxMTIxMDY0NTE0WjBI\r\n"
308 "MQswCQYDVQQGEwJDTjEMMAoGA1UECAwDc2hhMQ0wCwYDVQQHDAR4aWFuMQ0wCwYD\r\n"
309 "VQQKDAR0ZXN0MQ0wCwYDVQQDDAR0ZXN0MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB\r\n"
310 "iQKBgQC+T3StG1Xv82Hlc6GtiVm9HiMAdfeAix+rTSYhzyB7x2SrksKsYqcJItDr\r\n"
311 "IGjaes/F9znT+Xacuj4aNgaKqPaopDpDgPD0PS+lIwGdjLtQy0ogqs59D+/KRhtD\r\n"
312 "/p1RVrUNpL/mti0s0hWCjbZcLr9qFoQ6figJaXz2TILTMppaxwIDAQABo1MwUTAd\r\n"
313 "BgNVHQ4EFgQURGOFkFgbK+2zdxL1khm8NAK0AdQwHwYDVR0jBBgwFoAURGOFkFgb\r\n"
314 "K+2zdxL1khm8NAK0AdQwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOB\r\n"
315 "gQBXVFVq7FfRftZ/qAGh5MrBctO8kzLQkpz7DYi6JRy2WDbYSdVHVZ+yWILt9I9o\r\n"
316 "64MtVN/+ZQMtDKxBp8JC2WCSUBP7R3rK7fyAdgWu621ISNAtcvLYJRYhH8o6PIC8\r\n"
317 "ajM5uoFMMM6z35VMJwlfhq/7d7E8Kz5wghbYnAg2ZrYBKA==\r\n"
318 "-----END CERTIFICATE-----\r\n";
319 
320 const CfEncodingBlob g_inCertNoPasswordPemStream = {
321     .data = reinterpret_cast<uint8_t *>(g_testRsaCertNoPasswordPem),
322     .len = strlen(g_testRsaCertNoPasswordPem) + 1,
323     .encodingFormat = CF_FORMAT_PEM
324 };
325 
326 const CfEncodingBlob g_inKeyNoPasswordPemStream = {
327     .data = reinterpret_cast<uint8_t *>(g_testRsaKeyNoPasswordPem),
328     .len = strlen(g_testRsaKeyNoPasswordPem) + 1,
329     .encodingFormat = CF_FORMAT_PEM
330 };
331 
332 const CfEncodingBlob g_inKeyNoPasswordDerStream = {
333     .data = reinterpret_cast<uint8_t *>(g_testRsaKeyNoPasswordDer),
334     .len = sizeof(g_testRsaKeyNoPasswordDer),
335     .encodingFormat = CF_FORMAT_DER
336 };
337 
338 static char g_testEccKeyPem[] =
339 "-----BEGIN EC PARAMETERS-----\r\n"
340 "BggqhkjOPQMBBw==\r\n"
341 "-----END EC PARAMETERS-----\r\n"
342 "-----BEGIN EC PRIVATE KEY-----\r\n"
343 "MHcCAQEEIODRxm2YjHqVMx8ilrOH/dT7RsPWzjsJKuFr0+xYBWkCoAoGCCqGSM49\r\n"
344 "AwEHoUQDQgAEc4Neg+rbDR2Wu8NLSxxaa14OZFEIF7/779yiDNtYWPlg2DM9Tkk+\r\n"
345 "LZk3kFkBfJAEbY42xwcbTj7n1sTH8X+dVg==\r\n"
346 "-----END EC PRIVATE KEY-----\r\n";
347 
348 static char g_testEccCertPem[] =
349 "-----BEGIN CERTIFICATE-----\r\n"
350 "MIICOjCCAd+gAwIBAgIGAXKnJjrAMAoGCCqGSM49BAMCMHkxCzAJBgNVBAYTAmNo\r\n"
351 "MQ8wDQYDVQQIDAZodWF3ZWkxDTALBgNVBAcMBHhpYW4xDzANBgNVBAoMBmh1YXdl\r\n"
352 "aTENMAsGA1UECwwEdGVzdDENMAsGA1UEAwwEYW5uZTEbMBkGCSqGSIb3DQEJARYM\r\n"
353 "dGVzdEAxMjMuY29tMB4XDTI0MTEyNzAzMjQ1MFoXDTM0MTEyNTAzMjQ1MFoweTEL\r\n"
354 "MAkGA1UEBhMCY2gxDzANBgNVBAgMBmh1YXdlaTENMAsGA1UEBwwEeGlhbjEPMA0G\r\n"
355 "A1UECgwGaHVhd2VpMQ0wCwYDVQQLDAR0ZXN0MQ0wCwYDVQQDDARhbm5lMRswGQYJ\r\n"
356 "KoZIhvcNAQkBFgx0ZXN0QDEyMy5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNC\r\n"
357 "AARzg16D6tsNHZa7w0tLHFprXg5kUQgXv/vv3KIM21hY+WDYMz1OST4tmTeQWQF8\r\n"
358 "kARtjjbHBxtOPufWxMfxf51Wo1MwUTAdBgNVHQ4EFgQUU/P31GCBwyrj3yXkoNaX\r\n"
359 "xvPp8uIwHwYDVR0jBBgwFoAUU/P31GCBwyrj3yXkoNaXxvPp8uIwDwYDVR0TAQH/\r\n"
360 "BAUwAwEB/zAKBggqhkjOPQQDAgNJADBGAiEA/wCfbTorAWEEZcgd0CgfXI+EzXu2\r\n"
361 "Y88BmDD5LFlj3N0CIQDB34h77Li0CSpYpS4+7Mug237zbkFjHR3Q4/VWOT1G1A==\r\n"
362 "-----END CERTIFICATE-----\r\n";
363 
364 const CfEncodingBlob g_inCertEccPemStream = {
365     .data = reinterpret_cast<uint8_t *>(g_testEccCertPem),
366     .len = strlen(g_testEccCertPem) + 1,
367     .encodingFormat = CF_FORMAT_PEM
368 };
369 
370 const CfEncodingBlob g_inKeyEccPemStream = {
371     .data = reinterpret_cast<uint8_t *>(g_testEccKeyPem),
372     .len = strlen(g_testEccKeyPem) + 1,
373     .encodingFormat = CF_FORMAT_PEM
374 };
375 
376 static const char g_testPwd[] = "123456";
377 static const char g_testPwdError[] = "1234";
378 static const uint8_t g_inContent[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
379 
380 static const char g_digestSHA1[] = "SHA1";
381 static const char g_digestSHA256[] = "SHA256";
382 static const char g_digestSHA384[] = "SHA384";
383 static const char g_digestSHA512[] = "SHA512";
384 static const char g_digestSHA[] = "SHA";
385 static const char g_digestMD5[] = "MD5";
386 
SetUpTestCase()387 void CryptoX509CertCmsGeneratorTest::SetUpTestCase()
388 {
389 }
TearDownTestCase()390 void CryptoX509CertCmsGeneratorTest::TearDownTestCase()
391 {
392 }
393 
SetUp()394 void CryptoX509CertCmsGeneratorTest::SetUp()
395 {
396 }
397 
TearDown()398 void CryptoX509CertCmsGeneratorTest::TearDown()
399 {
400 }
401 
402 HWTEST_F(CryptoX509CertCmsGeneratorTest, CreateCmsGenerator001, TestSize.Level0)
403 {
404     HcfCmsGenerator *cmsGenerator = nullptr;
405     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
406     EXPECT_EQ(res, CF_SUCCESS);
407     EXPECT_NE(cmsGenerator, nullptr);
408     CfObjDestroy(cmsGenerator);
409 }
410 
411 HWTEST_F(CryptoX509CertCmsGeneratorTest, CreateCmsGenerator002, TestSize.Level0)
412 {
413     HcfCmsGenerator *cmsGenerator = nullptr;
414     CfResult res = HcfCreateCmsGenerator(static_cast<HcfCmsContentType>(1), &cmsGenerator);
415     EXPECT_EQ(res, CF_INVALID_PARAMS);
416     EXPECT_EQ(cmsGenerator, nullptr);
417     res = HcfCreateCmsGenerator(static_cast<HcfCmsContentType>(-1), &cmsGenerator);
418     EXPECT_EQ(res, CF_INVALID_PARAMS);
419     EXPECT_EQ(cmsGenerator, nullptr);
420 }
421 
422 HWTEST_F(CryptoX509CertCmsGeneratorTest, AddSigner001, TestSize.Level0)
423 {
424     HcfCmsGenerator *cmsGenerator = nullptr;
425     PrivateKeyInfo *privateKey = nullptr;
426     HcfCmsSignerOptions *options = nullptr;
427     HcfX509Certificate *x509Cert = nullptr;
428 
429     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
430     EXPECT_EQ(res, CF_SUCCESS);
431     EXPECT_NE(cmsGenerator, nullptr);
432 
433     CfResult ret = HcfX509CertificateCreate(&g_inCertPasswordPemStream, &x509Cert);
434     EXPECT_EQ(ret, CF_SUCCESS);
435     ASSERT_NE(x509Cert, nullptr);
436 
437     privateKey = (PrivateKeyInfo *)CfMalloc(sizeof(PrivateKeyInfo), 0);
438     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyPasswordPemStream);
439     privateKey->privateKeyPassword = const_cast<char*>(g_testPwd);
440 
441     options = (HcfCmsSignerOptions *)CfMalloc(sizeof(HcfCmsSignerOptions), 0);
442     options->mdName = const_cast<char*>(g_digestSHA1);
443     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
444     EXPECT_EQ(res, CF_SUCCESS);
445 
446     options->mdName = const_cast<char*>(g_digestSHA256);
447     options->addCert = true;
448     options->addAttr = true;
449     options->addSmimeCapAttr = true;
450     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
451     EXPECT_EQ(res, CF_SUCCESS);
452 
453     options->mdName = const_cast<char*>(g_digestSHA384);
454     options->addCert = false;
455     options->addAttr = false;
456     options->addSmimeCapAttr = false;
457     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
458     EXPECT_EQ(res, CF_SUCCESS);
459 
460     options->mdName = const_cast<char*>(g_digestSHA512);
461     options->addCert = false;
462     options->addAttr = false;
463     options->addSmimeCapAttr = true;
464     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
465     EXPECT_EQ(res, CF_SUCCESS);
466 
467     privateKey->privateKeyPassword = const_cast<char*>(g_testPwdError);
468     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
469     EXPECT_EQ(res, CF_ERR_CERT_INVALID_PRIVATE_KEY);
470 
471     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyPasswordPemStreamError);
472     privateKey->privateKeyPassword = const_cast<char*>(g_testPwd);
473     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
474     EXPECT_EQ(res, CF_ERR_CRYPTO_OPERATION);
475 
476     CfFree(privateKey);
477     CfFree(options);
478     CfObjDestroy(x509Cert);
479     CfObjDestroy(cmsGenerator);
480 }
481 
482 HWTEST_F(CryptoX509CertCmsGeneratorTest, AddSigner002, TestSize.Level0)
483 {
484     HcfCmsGenerator *cmsGenerator = nullptr;
485     PrivateKeyInfo *privateKey = nullptr;
486     HcfCmsSignerOptions *options = nullptr;
487     HcfX509Certificate *x509Cert = nullptr;
488     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
489     EXPECT_EQ(res, CF_SUCCESS);
490     EXPECT_NE(cmsGenerator, nullptr);
491 
492     CfResult ret = HcfX509CertificateCreate(&g_inCertNoPasswordPemStream, &x509Cert);
493     EXPECT_EQ(ret, CF_SUCCESS);
494     ASSERT_NE(x509Cert, nullptr);
495 
496     privateKey = (PrivateKeyInfo *)CfMalloc(sizeof(PrivateKeyInfo), 0);
497     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyNoPasswordPemStream);
498 
499     options = (HcfCmsSignerOptions *)CfMalloc(sizeof(HcfCmsSignerOptions), 0);
500     options->mdName = const_cast<char*>(g_digestSHA1);
501     options->addCert = false;
502     options->addAttr = true;
503     options->addSmimeCapAttr = true;
504     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
505     EXPECT_EQ(res, CF_SUCCESS);
506 
507     options->mdName = const_cast<char*>(g_digestSHA256);
508     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
509     EXPECT_EQ(res, CF_SUCCESS);
510 
511     options->mdName = const_cast<char*>(g_digestSHA384);
512     options->addCert = false;
513     options->addAttr = false;
514     options->addSmimeCapAttr = false;
515     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
516     EXPECT_EQ(res, CF_SUCCESS);
517 
518     options->mdName = const_cast<char*>(g_digestSHA512);
519     options->addCert = false;
520     options->addAttr = false;
521     options->addSmimeCapAttr = true;
522     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
523     EXPECT_EQ(res, CF_SUCCESS);
524 
525     CfFree(privateKey);
526     CfFree(options);
527     CfObjDestroy(x509Cert);
528     CfObjDestroy(cmsGenerator);
529 }
530 
531 HWTEST_F(CryptoX509CertCmsGeneratorTest, AddSigner003, TestSize.Level0)
532 {
533     HcfCmsGenerator *cmsGenerator = nullptr;
534     PrivateKeyInfo *privateKey = nullptr;
535     HcfCmsSignerOptions *options = nullptr;
536     HcfX509Certificate *x509Cert = nullptr;
537     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
538     EXPECT_EQ(res, CF_SUCCESS);
539     EXPECT_NE(cmsGenerator, nullptr);
540 
541     CfResult ret = HcfX509CertificateCreate(&g_inCertPasswordPemStream2, &x509Cert);
542     EXPECT_EQ(ret, CF_SUCCESS);
543     ASSERT_NE(x509Cert, nullptr);
544 
545     privateKey = (PrivateKeyInfo *)CfMalloc(sizeof(PrivateKeyInfo), 0);
546     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyPasswordDerStream);
547     privateKey->privateKeyPassword = const_cast<char*>(g_testPwd);
548 
549     options = (HcfCmsSignerOptions *)CfMalloc(sizeof(HcfCmsSignerOptions), 0);
550     options->mdName = const_cast<char*>(g_digestSHA1);
551     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
552     EXPECT_EQ(res, CF_SUCCESS);
553 
554     options->mdName = const_cast<char*>(g_digestSHA256);
555     options->addCert = true;
556     options->addAttr = true;
557     options->addSmimeCapAttr = true;
558     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
559     EXPECT_EQ(res, CF_SUCCESS);
560 
561     options->mdName = const_cast<char*>(g_digestSHA384);
562     options->addCert = false;
563     options->addAttr = false;
564     options->addSmimeCapAttr = false;
565     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
566     EXPECT_EQ(res, CF_SUCCESS);
567 
568     options->mdName = const_cast<char*>(g_digestSHA512);
569     options->addCert = false;
570     options->addAttr = false;
571     options->addSmimeCapAttr = true;
572     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
573     EXPECT_EQ(res, CF_SUCCESS);
574 
575     privateKey->privateKeyPassword = const_cast<char*>(g_testPwdError);
576     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
577     EXPECT_EQ(res, CF_ERR_CERT_INVALID_PRIVATE_KEY);
578 
579     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyPasswordDerStreamError);
580     privateKey->privateKeyPassword = const_cast<char*>(g_testPwd);
581     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
582     EXPECT_EQ(res, CF_ERR_CRYPTO_OPERATION);
583 
584     CfFree(privateKey);
585     CfFree(options);
586     CfObjDestroy(x509Cert);
587     CfObjDestroy(cmsGenerator);
588 }
589 
590 HWTEST_F(CryptoX509CertCmsGeneratorTest, AddSigner004, TestSize.Level0)
591 {
592     HcfCmsGenerator *cmsGenerator = nullptr;
593     PrivateKeyInfo *privateKey = nullptr;
594     HcfCmsSignerOptions *options = nullptr;
595     HcfX509Certificate *x509Cert = nullptr;
596     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
597     EXPECT_EQ(res, CF_SUCCESS);
598     EXPECT_NE(cmsGenerator, nullptr);
599 
600     CfResult ret = HcfX509CertificateCreate(&g_inCertNoPasswordPemStream, &x509Cert);
601     EXPECT_EQ(ret, CF_SUCCESS);
602     ASSERT_NE(x509Cert, nullptr);
603 
604     privateKey = (PrivateKeyInfo *)CfMalloc(sizeof(PrivateKeyInfo), 0);
605     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyNoPasswordDerStream);
606 
607     options = (HcfCmsSignerOptions *)CfMalloc(sizeof(HcfCmsSignerOptions), 0);
608     options->mdName = const_cast<char*>(g_digestSHA1);
609     options->addCert = false;
610     options->addAttr = true;
611     options->addSmimeCapAttr = true;
612     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
613     EXPECT_EQ(res, CF_SUCCESS);
614 
615     options->mdName = const_cast<char*>(g_digestSHA256);
616     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
617     EXPECT_EQ(res, CF_SUCCESS);
618 
619     options->mdName = const_cast<char*>(g_digestSHA384);
620     options->addCert = false;
621     options->addAttr = false;
622     options->addSmimeCapAttr = false;
623     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
624     EXPECT_EQ(res, CF_SUCCESS);
625 
626     options->mdName = const_cast<char*>(g_digestSHA512);
627     options->addCert = false;
628     options->addAttr = false;
629     options->addSmimeCapAttr = true;
630     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
631     EXPECT_EQ(res, CF_SUCCESS);
632 
633     CfFree(privateKey);
634     CfFree(options);
635     CfObjDestroy(x509Cert);
636     CfObjDestroy(cmsGenerator);
637 }
638 
639 HWTEST_F(CryptoX509CertCmsGeneratorTest, AddSigner005, TestSize.Level0)
640 {
641     HcfCmsGenerator *cmsGenerator = nullptr;
642     PrivateKeyInfo *privateKey = nullptr;
643     HcfCmsSignerOptions *options = nullptr;
644     HcfX509Certificate *x509Cert = nullptr;
645     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
646     EXPECT_EQ(res, CF_SUCCESS);
647     EXPECT_NE(cmsGenerator, nullptr);
648 
649     CfResult ret = HcfX509CertificateCreate(&g_inCertNoPasswordPemStream, &x509Cert);
650     EXPECT_EQ(ret, CF_SUCCESS);
651     ASSERT_NE(x509Cert, nullptr);
652 
653     privateKey = (PrivateKeyInfo *)CfMalloc(sizeof(PrivateKeyInfo), 0);
654     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyNoPasswordPemStream);
655 
656     options = (HcfCmsSignerOptions *)CfMalloc(sizeof(HcfCmsSignerOptions), 0);
657     options->mdName = const_cast<char*>(g_digestSHA1);
658     options->addCert = false;
659     options->addAttr = true;
660     options->addSmimeCapAttr = true;
661     int count = 20;
662     for (int i = 0; i < count; i++) {
663         res = cmsGenerator->addSigner(cmsGenerator,  &(x509Cert->base), privateKey, options);
664         EXPECT_EQ(res, CF_SUCCESS);
665     }
666     res = cmsGenerator->addSigner(cmsGenerator,  &(x509Cert->base), privateKey, options);
667     EXPECT_EQ(res, CF_ERR_CRYPTO_OPERATION);
668 
669     CfFree(privateKey);
670     CfFree(options);
671     CfObjDestroy(x509Cert);
672     CfObjDestroy(cmsGenerator);
673 }
674 
675 HWTEST_F(CryptoX509CertCmsGeneratorTest, AddSigner006, TestSize.Level0)
676 {
677     HcfCmsGenerator *cmsGenerator = nullptr;
678     PrivateKeyInfo *privateKey = nullptr;
679     HcfCmsSignerOptions *options = nullptr;
680     HcfX509Certificate *x509Cert = nullptr;
681     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
682     EXPECT_EQ(res, CF_SUCCESS);
683     EXPECT_NE(cmsGenerator, nullptr);
684 
685     CfResult ret = HcfX509CertificateCreate(&g_inCertNoPasswordPemStream, &x509Cert);
686     EXPECT_EQ(ret, CF_SUCCESS);
687     ASSERT_NE(x509Cert, nullptr);
688 
689     privateKey = (PrivateKeyInfo *)CfMalloc(sizeof(PrivateKeyInfo), 0);
690     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyNoPasswordPemStream);
691 
692     options = (HcfCmsSignerOptions *)CfMalloc(sizeof(HcfCmsSignerOptions), 0);
693     options->mdName = const_cast<char*>(g_digestSHA);
694     options->addCert = true;
695     options->addAttr = true;
696     options->addSmimeCapAttr = true;
697 
698     res = cmsGenerator->addSigner(cmsGenerator,  &(x509Cert->base), privateKey, options);
699     EXPECT_EQ(res, CF_INVALID_PARAMS);
700 
701     options->mdName = const_cast<char*>(g_digestMD5);
702     res = cmsGenerator->addSigner(cmsGenerator,  &(x509Cert->base), privateKey, options);
703     EXPECT_EQ(res, CF_INVALID_PARAMS);
704 
705     res = cmsGenerator->addSigner(cmsGenerator, nullptr, privateKey, options);
706     EXPECT_EQ(res, CF_INVALID_PARAMS);
707 
708     res = cmsGenerator->addSigner(cmsGenerator,  &(x509Cert->base), nullptr, options);
709     EXPECT_EQ(res, CF_INVALID_PARAMS);
710 
711     res = cmsGenerator->addSigner(cmsGenerator,  &(x509Cert->base), privateKey, nullptr);
712     EXPECT_EQ(res, CF_INVALID_PARAMS);
713 
714     res = cmsGenerator->addSigner(nullptr,  &(x509Cert->base), privateKey, options);
715     EXPECT_EQ(res, CF_INVALID_PARAMS);
716 
717     res = cmsGenerator->addSigner(nullptr,  nullptr, nullptr, nullptr);
718     EXPECT_EQ(res, CF_INVALID_PARAMS);
719 
720     CfFree(privateKey);
721     CfFree(options);
722     CfObjDestroy(x509Cert);
723     CfObjDestroy(cmsGenerator);
724 }
725 
726 HWTEST_F(CryptoX509CertCmsGeneratorTest, AddSigner007, TestSize.Level0)
727 {
728     HcfCmsGenerator *cmsGenerator = nullptr;
729     PrivateKeyInfo *privateKey = nullptr;
730     HcfCmsSignerOptions *options = nullptr;
731     HcfX509Certificate *x509Cert = nullptr;
732     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
733     EXPECT_EQ(res, CF_SUCCESS);
734     EXPECT_NE(cmsGenerator, nullptr);
735 
736     CfResult ret = HcfX509CertificateCreate(&g_inCertEccPemStream, &x509Cert);
737     EXPECT_EQ(ret, CF_SUCCESS);
738     ASSERT_NE(x509Cert, nullptr);
739 
740     privateKey = (PrivateKeyInfo *)CfMalloc(sizeof(PrivateKeyInfo), 0);
741     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyEccPemStream);
742 
743     options = (HcfCmsSignerOptions *)CfMalloc(sizeof(HcfCmsSignerOptions), 0);
744     options->mdName = const_cast<char*>(g_digestSHA1);
745     options->addCert = true;
746     options->addAttr = true;
747     options->addSmimeCapAttr = true;
748 
749     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
750     EXPECT_EQ(res, CF_NOT_SUPPORT);
751 
752     CfFree(privateKey);
753     CfFree(options);
754     CfObjDestroy(x509Cert);
755     CfObjDestroy(cmsGenerator);
756 }
757 
758 HWTEST_F(CryptoX509CertCmsGeneratorTest, AddCert001, TestSize.Level0)
759 {
760     HcfCmsGenerator *cmsGenerator = nullptr;
761     HcfX509Certificate *x509Cert = nullptr;
762     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
763     EXPECT_EQ(res, CF_SUCCESS);
764     EXPECT_NE(cmsGenerator, nullptr);
765 
766     CfResult ret = HcfX509CertificateCreate(&g_inCertEccPemStream, &x509Cert);
767     EXPECT_EQ(ret, CF_SUCCESS);
768     ASSERT_NE(x509Cert, nullptr);
769 
770     res = cmsGenerator->addCert(cmsGenerator, &(x509Cert->base));
771     EXPECT_EQ(res, CF_SUCCESS);
772 
773     CfObjDestroy(x509Cert);
774 
775     ret = HcfX509CertificateCreate(&g_inCertPasswordPemStream, &x509Cert);
776     EXPECT_EQ(ret, CF_SUCCESS);
777     ASSERT_NE(x509Cert, nullptr);
778 
779     res = cmsGenerator->addCert(cmsGenerator, &(x509Cert->base));
780     EXPECT_EQ(res, CF_SUCCESS);
781 
782     CfObjDestroy(x509Cert);
783 
784     ret = HcfX509CertificateCreate(&g_inCertNoPasswordPemStream, &x509Cert);
785     EXPECT_EQ(ret, CF_SUCCESS);
786     ASSERT_NE(x509Cert, nullptr);
787 
788     res = cmsGenerator->addCert(cmsGenerator, &(x509Cert->base));
789     EXPECT_EQ(res, CF_SUCCESS);
790 
791     CfObjDestroy(x509Cert);
792     CfObjDestroy(cmsGenerator);
793 }
794 
795 HWTEST_F(CryptoX509CertCmsGeneratorTest, AddCert002, TestSize.Level0)
796 {
797     HcfCmsGenerator *cmsGenerator = nullptr;
798     HcfX509Certificate *x509Cert = nullptr;
799     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
800     EXPECT_EQ(res, CF_SUCCESS);
801     EXPECT_NE(cmsGenerator, nullptr);
802 
803     CfResult ret = HcfX509CertificateCreate(&g_inCertNoPasswordPemStream, &x509Cert);
804     EXPECT_EQ(ret, CF_SUCCESS);
805     ASSERT_NE(x509Cert, nullptr);
806 
807     res = cmsGenerator->addCert(cmsGenerator, &(x509Cert->base));
808     EXPECT_EQ(res, CF_SUCCESS);
809     res = cmsGenerator->addCert(cmsGenerator, &(x509Cert->base));
810     EXPECT_EQ(res, CF_ERR_CRYPTO_OPERATION);
811 
812     res = cmsGenerator->addCert(nullptr, &(x509Cert->base));
813     EXPECT_EQ(res, CF_INVALID_PARAMS);
814 
815     res = cmsGenerator->addCert(cmsGenerator, nullptr);
816     EXPECT_EQ(res, CF_INVALID_PARAMS);
817 
818     res = cmsGenerator->addCert(nullptr, nullptr);
819     EXPECT_EQ(res, CF_INVALID_PARAMS);
820 
821     CfObjDestroy(x509Cert);
822     CfObjDestroy(cmsGenerator);
823 }
824 
825 HWTEST_F(CryptoX509CertCmsGeneratorTest, DoFinal001, TestSize.Level0)
826 {
827     HcfCmsGenerator *cmsGenerator = nullptr;
828     PrivateKeyInfo *privateKey = nullptr;
829     HcfCmsSignerOptions *options = nullptr;
830     HcfX509Certificate *x509Cert = nullptr;
831     CfBlob out = {0, nullptr};
832     CfBlob content;
833     content.data = const_cast<uint8_t*>(g_inContent);
834     content.size = sizeof(g_inContent);
835     HcfCmsGeneratorOptions *cmsOptions = nullptr;
836 
837     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
838     EXPECT_EQ(res, CF_SUCCESS);
839     EXPECT_NE(cmsGenerator, nullptr);
840 
841     CfResult ret = HcfX509CertificateCreate(&g_inCertPasswordPemStream, &x509Cert);
842     EXPECT_EQ(ret, CF_SUCCESS);
843     ASSERT_NE(x509Cert, nullptr);
844 
845     privateKey = (PrivateKeyInfo *)CfMalloc(sizeof(PrivateKeyInfo), 0);
846     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyPasswordPemStream);
847     privateKey->privateKeyPassword = const_cast<char*>(g_testPwd);
848 
849     options = (HcfCmsSignerOptions *)CfMalloc(sizeof(HcfCmsSignerOptions), 0);
850     options->mdName = const_cast<char*>(g_digestSHA1);
851     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
852     EXPECT_EQ(res, CF_SUCCESS);
853 
854     cmsOptions = (HcfCmsGeneratorOptions *)CfMalloc(sizeof(HcfCmsGeneratorOptions), 0);
855     cmsOptions->dataFormat = BINARY;
856     cmsOptions->outFormat = CMS_DER;
857     cmsOptions->isDetachedContent = false;
858     res = cmsGenerator->doFinal(cmsGenerator, &content, cmsOptions, &out);
859     EXPECT_EQ(res, CF_SUCCESS);
860 
861     CfFree(privateKey);
862     CfFree(options);
863     CfFree(cmsOptions);
864     CfObjDestroy(x509Cert);
865     CfBlobDataClearAndFree(&out);
866     CfObjDestroy(cmsGenerator);
867 }
868 
869 HWTEST_F(CryptoX509CertCmsGeneratorTest, DoFinal002, TestSize.Level0)
870 {
871     HcfCmsGenerator *cmsGenerator = nullptr;
872     PrivateKeyInfo *privateKey = nullptr;
873     HcfCmsSignerOptions *options = nullptr;
874     HcfX509Certificate *x509Cert = nullptr;
875     CfBlob out = {0, nullptr};
876     CfBlob content;
877     content.data = const_cast<uint8_t*>(g_inContent);
878     content.size = sizeof(g_inContent);
879     HcfCmsGeneratorOptions *cmsOptions = nullptr;
880 
881     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
882     EXPECT_EQ(res, CF_SUCCESS);
883     EXPECT_NE(cmsGenerator, nullptr);
884 
885     CfResult ret = HcfX509CertificateCreate(&g_inCertPasswordPemStream, &x509Cert);
886     EXPECT_EQ(ret, CF_SUCCESS);
887     ASSERT_NE(x509Cert, nullptr);
888 
889     privateKey = (PrivateKeyInfo *)CfMalloc(sizeof(PrivateKeyInfo), 0);
890     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyPasswordPemStream);
891     privateKey->privateKeyPassword = const_cast<char*>(g_testPwd);
892 
893     options = (HcfCmsSignerOptions *)CfMalloc(sizeof(HcfCmsSignerOptions), 0);
894     options->mdName = const_cast<char*>(g_digestSHA256);
895     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
896     EXPECT_EQ(res, CF_SUCCESS);
897 
898     cmsOptions = (HcfCmsGeneratorOptions *)CfMalloc(sizeof(HcfCmsGeneratorOptions), 0);
899     cmsOptions->dataFormat = BINARY;
900     cmsOptions->outFormat = CMS_PEM;
901     cmsOptions->isDetachedContent = true;
902     res = cmsGenerator->doFinal(cmsGenerator, &content, cmsOptions, &out);
903     EXPECT_EQ(res, CF_SUCCESS);
904 
905     CfFree(privateKey);
906     CfFree(options);
907     CfFree(cmsOptions);
908     CfObjDestroy(x509Cert);
909     CfBlobDataClearAndFree(&out);
910     CfObjDestroy(cmsGenerator);
911 }
912 
913 HWTEST_F(CryptoX509CertCmsGeneratorTest, DoFinal003, TestSize.Level0)
914 {
915     HcfCmsGenerator *cmsGenerator = nullptr;
916     PrivateKeyInfo *privateKey = nullptr;
917     HcfCmsSignerOptions *options = nullptr;
918     HcfX509Certificate *x509Cert = nullptr;
919     CfBlob out = {0, nullptr};
920     CfBlob content;
921     content.data = const_cast<uint8_t*>(g_inContent);
922     content.size = sizeof(g_inContent);
923     HcfCmsGeneratorOptions *cmsOptions = nullptr;
924 
925     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
926     EXPECT_EQ(res, CF_SUCCESS);
927     EXPECT_NE(cmsGenerator, nullptr);
928 
929     CfResult ret = HcfX509CertificateCreate(&g_inCertPasswordPemStream, &x509Cert);
930     EXPECT_EQ(ret, CF_SUCCESS);
931     ASSERT_NE(x509Cert, nullptr);
932 
933     privateKey = (PrivateKeyInfo *)CfMalloc(sizeof(PrivateKeyInfo), 0);
934     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyPasswordPemStream);
935     privateKey->privateKeyPassword = const_cast<char*>(g_testPwd);
936 
937     options = (HcfCmsSignerOptions *)CfMalloc(sizeof(HcfCmsSignerOptions), 0);
938     options->mdName = const_cast<char*>(g_digestSHA384);
939     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
940     EXPECT_EQ(res, CF_SUCCESS);
941 
942     cmsOptions = (HcfCmsGeneratorOptions *)CfMalloc(sizeof(HcfCmsGeneratorOptions), 0);
943     cmsOptions->dataFormat = TEXT;
944     cmsOptions->outFormat = CMS_PEM;
945     cmsOptions->isDetachedContent = false;
946     res = cmsGenerator->doFinal(cmsGenerator, &content, cmsOptions, &out);
947     EXPECT_EQ(res, CF_SUCCESS);
948 
949     CfFree(privateKey);
950     CfFree(options);
951     CfFree(cmsOptions);
952     CfObjDestroy(x509Cert);
953     CfBlobDataClearAndFree(&out);
954     CfObjDestroy(cmsGenerator);
955 }
956 
957 HWTEST_F(CryptoX509CertCmsGeneratorTest, DoFinal004, TestSize.Level0)
958 {
959     HcfCmsGenerator *cmsGenerator = nullptr;
960     PrivateKeyInfo *privateKey = nullptr;
961     HcfCmsSignerOptions *options = nullptr;
962     HcfX509Certificate *x509Cert = nullptr;
963     CfBlob out = {0, nullptr};
964     CfBlob content;
965     content.data = const_cast<uint8_t*>(g_inContent);
966     content.size = sizeof(g_inContent);
967     HcfCmsGeneratorOptions *cmsOptions = nullptr;
968 
969     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
970     EXPECT_EQ(res, CF_SUCCESS);
971     EXPECT_NE(cmsGenerator, nullptr);
972 
973     CfResult ret = HcfX509CertificateCreate(&g_inCertPasswordPemStream, &x509Cert);
974     EXPECT_EQ(ret, CF_SUCCESS);
975     ASSERT_NE(x509Cert, nullptr);
976 
977     privateKey = (PrivateKeyInfo *)CfMalloc(sizeof(PrivateKeyInfo), 0);
978     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyPasswordPemStream);
979     privateKey->privateKeyPassword = const_cast<char*>(g_testPwd);
980 
981     options = (HcfCmsSignerOptions *)CfMalloc(sizeof(HcfCmsSignerOptions), 0);
982     options->mdName = const_cast<char*>(g_digestSHA512);
983     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
984     EXPECT_EQ(res, CF_SUCCESS);
985 
986     cmsOptions = (HcfCmsGeneratorOptions *)CfMalloc(sizeof(HcfCmsGeneratorOptions), 0);
987     cmsOptions->dataFormat = TEXT;
988     cmsOptions->outFormat = CMS_DER;
989     cmsOptions->isDetachedContent = true;
990     res = cmsGenerator->doFinal(cmsGenerator, &content, cmsOptions, &out);
991     EXPECT_EQ(res, CF_SUCCESS);
992 
993     CfFree(privateKey);
994     CfFree(options);
995     CfFree(cmsOptions);
996     CfObjDestroy(x509Cert);
997     CfBlobDataClearAndFree(&out);
998     CfObjDestroy(cmsGenerator);
999 }
1000 
1001 HWTEST_F(CryptoX509CertCmsGeneratorTest, DoFinal005, TestSize.Level0)
1002 {
1003     HcfCmsGenerator *cmsGenerator = nullptr;
1004     PrivateKeyInfo *privateKey = nullptr;
1005     HcfCmsSignerOptions *options = nullptr;
1006     HcfX509Certificate *x509Cert = nullptr;
1007     CfBlob out = {0, nullptr};
1008     CfBlob content;
1009     content.data = const_cast<uint8_t*>(g_inContent);
1010     content.size = sizeof(g_inContent);
1011     HcfCmsGeneratorOptions *cmsOptions = nullptr;
1012 
1013     CfResult res = HcfCreateCmsGenerator(SIGNED_DATA, &cmsGenerator);
1014     EXPECT_EQ(res, CF_SUCCESS);
1015     EXPECT_NE(cmsGenerator, nullptr);
1016 
1017     CfResult ret = HcfX509CertificateCreate(&g_inCertPasswordPemStream, &x509Cert);
1018     EXPECT_EQ(ret, CF_SUCCESS);
1019     ASSERT_NE(x509Cert, nullptr);
1020 
1021     privateKey = (PrivateKeyInfo *)CfMalloc(sizeof(PrivateKeyInfo), 0);
1022     privateKey->privateKey = const_cast<CfEncodingBlob*>(&g_inKeyPasswordPemStream);
1023     privateKey->privateKeyPassword = const_cast<char*>(g_testPwd);
1024 
1025     options = (HcfCmsSignerOptions *)CfMalloc(sizeof(HcfCmsSignerOptions), 0);
1026     options->mdName = const_cast<char*>(g_digestSHA256);
1027     res = cmsGenerator->addSigner(cmsGenerator, &(x509Cert->base), privateKey, options);
1028     EXPECT_EQ(res, CF_SUCCESS);
1029 
1030     cmsOptions = (HcfCmsGeneratorOptions *)CfMalloc(sizeof(HcfCmsGeneratorOptions), 0);
1031     cmsOptions->dataFormat = static_cast<HcfCmsContentDataFormat>(2);
1032     cmsOptions->outFormat = CMS_DER;
1033     cmsOptions->isDetachedContent = false;
1034     res = cmsGenerator->doFinal(cmsGenerator, &content, cmsOptions, &out);
1035     EXPECT_EQ(res, CF_INVALID_PARAMS);
1036 
1037     cmsOptions->dataFormat = BINARY;
1038     cmsOptions->outFormat = static_cast<HcfCmsFormat>(2);
1039     cmsOptions->isDetachedContent = false;
1040     res = cmsGenerator->doFinal(cmsGenerator, &content, cmsOptions, &out);
1041     EXPECT_EQ(res, CF_INVALID_PARAMS);
1042 
1043     res = cmsGenerator->doFinal(nullptr, &content, cmsOptions, &out);
1044     EXPECT_EQ(res, CF_INVALID_PARAMS);
1045 
1046     res = cmsGenerator->doFinal(cmsGenerator, nullptr, cmsOptions, &out);
1047     EXPECT_EQ(res, CF_INVALID_PARAMS);
1048 
1049     res = cmsGenerator->doFinal(cmsGenerator, &content, nullptr, &out);
1050     EXPECT_EQ(res, CF_INVALID_PARAMS);
1051 
1052     res = cmsGenerator->doFinal(cmsGenerator, &content, cmsOptions, nullptr);
1053     EXPECT_EQ(res, CF_INVALID_PARAMS);
1054 
1055     CfFree(privateKey);
1056     CfFree(options);
1057     CfFree(cmsOptions);
1058     CfObjDestroy(x509Cert);
1059     CfObjDestroy(cmsGenerator);
1060 }
1061 }