1 /*
2 * Copyright (c) 2022 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 "cm_test_common.h"
18 #include "cm_test_log.h"
19 #include "cert_manager_api.h"
20
21 using namespace testing::ext;
22 using namespace CertmanagerTest;
23 namespace {
24 struct CertInfoResult {
25 struct CertInfo CertInfo;
26 bool bExpectResult;
27 };
28
29 struct CertInfoResult g_listCertInfoexpectResult[] = {
30 {
31 {
32 "2add47b6.0",
33 "GlobalSign",
34 true,
35 "CN=GlobalSign,OU=GlobalSign ECC Root CA - R5,O=GlobalSign",
36 "CN=GlobalSign,OU=GlobalSign ECC Root CA - R5,O=GlobalSign",
37 "605949E0262EBB55F90A778A71F94AD86C",
38 "2012-11-13",
39 "2038-1-19",
40 "17:9F:BC:14:8A:3D:D0:0F:D2:4E:A1:34:58:CC:43:BF:A7:F5:9C:81:82:D7:83:A5:13:F6:EB:EC:10:0C:89:24"
41 },
42 true
43 },
44 {
45 {
46 "85cde254.0",
47 "Starfield Technologies, Inc.",
48 true,
49 "CN=Starfield Root Certificate Authority - G2,OU=,O=Starfield Technologies, Inc.",
50 "CN=Starfield Root Certificate Authority - G2,OU=,O=Starfield Technologies, Inc.",
51 "0",
52 "2009-9-1",
53 "2037-12-31",
54 "2C:E1:CB:0B:F9:D2:F9:E1:02:99:3F:BE:21:51:52:C3:B2:DD:0C:AB:DE:1C:68:E5:31:9B:83:91:54:DB:B7:F5"
55 },
56 true
57 },
58 {
59 {
60 "3c860d51.0",
61 "SwissSign AG",
62 true,
63 "CN=SwissSign Gold CA - G2,OU=,O=SwissSign AG",
64 "CN=SwissSign Gold CA - G2,OU=,O=SwissSign AG",
65 "BB401C43F55E4FB0",
66 "2006-10-25",
67 "2036-10-25",
68 "62:DD:0B:E9:B9:F5:0A:16:3E:A0:F8:E7:5C:05:3B:1E:CA:57:EA:55:C8:68:8F:64:7C:68:81:F2:C8:35:7B:95"
69 },
70 true
71 },
72 {
73 {
74 "b0f3e76e.0",
75 "GlobalSign nv-sa",
76 true,
77 "CN=GlobalSign Root CA,OU=Root CA,O=GlobalSign nv-sa",
78 "CN=GlobalSign Root CA,OU=Root CA,O=GlobalSign nv-sa",
79 "040000000001154B5AC394",
80 "1998-9-1",
81 "2028-1-28",
82 "EB:D4:10:40:E4:BB:3E:C7:42:C9:E3:81:D3:1E:F2:A4:1A:48:B6:68:5C:96:E7:CE:F3:C1:DF:6C:D4:33:1C:99"
83 },
84 true
85 },
86 {
87 {
88 "869fbf79.0",
89 "eMudhra Inc",
90 true,
91 "CN=emSign ECC Root CA - C3,OU=emSign PKI,O=eMudhra Inc",
92 "CN=emSign ECC Root CA - C3,OU=emSign PKI,O=eMudhra Inc",
93 "7B71B68256B8127C9CA8",
94 "2018-2-18",
95 "2043-2-18",
96 "BC:4D:80:9B:15:18:9D:78:DB:3E:1D:8C:F4:F9:72:6A:79:5D:A1:64:3C:A5:F1:35:8E:1D:DB:0E:DC:0D:7E:B3"
97 },
98 true
99 }
100 };
101
102 class CmGetCertInfoTest : public testing::Test {
103 public:
104 static void SetUpTestCase(void);
105
106 static void TearDownTestCase(void);
107
108 void SetUp();
109
110 void TearDown();
111
112 struct CertList *lstCert;
113 };
114
SetUpTestCase(void)115 void CmGetCertInfoTest::SetUpTestCase(void)
116 {
117 SetATPermission();
118 }
119
TearDownTestCase(void)120 void CmGetCertInfoTest::TearDownTestCase(void)
121 {
122 }
123
SetUp()124 void CmGetCertInfoTest::SetUp()
125 {
126 InitCertList(&lstCert);
127 }
128
TearDown()129 void CmGetCertInfoTest::TearDown()
130 {
131 FreeCertList(lstCert);
132 }
133
134 /**
135 * @tc.name: SimpleCmGetCertInfo001
136 * @tc.desc: Test CertManager get cert info interface base function
137 * @tc.type: FUNC
138 * @tc.require: AR000H0MJA /SR000H096P
139 */
140 HWTEST_F(CmGetCertInfoTest, SimpleCmGetCertInfo001, TestSize.Level0)
141 {
142 char *uri = g_listCertInfoexpectResult[0].CertInfo.uri;
143 struct CmBlob uriBlob = {strlen(uri) + 1, (uint8_t *)(uri)};
144 struct CertInfo certInfo;
145 unsigned int len = sizeof(struct CertInfo);
146 (void)memset_s(&certInfo, len, 0, len);
147 int32_t ret = InitCertInfo(&certInfo);
148 EXPECT_EQ(ret, CM_SUCCESS) << "CertInfo malloc faild, retcode:" << ret;
149
150 ret = CmGetCertInfo(&uriBlob, CM_SYSTEM_TRUSTED_STORE, &certInfo);
151 EXPECT_EQ(ret, CM_SUCCESS) << "CmGetCertInfo failed, retcode:" << ret;
152
153 EXPECT_EQ(CompareCertInfo(&certInfo, &(g_listCertInfoexpectResult[0].CertInfo)), true) <<DumpCertInfo(&certInfo);
154
155 FreeCMBlobData(&(certInfo.certInfo));
156 }
157
158 /**
159 * @tc.name: AppGetCertInfoCompare002
160 * @tc.desc: Test CertManager get cert info compare interface function
161 * @tc.type: FUNC
162 * @tc.require: AR000H0MJA /SR000H096P
163 */
164 HWTEST_F(CmGetCertInfoTest, AppGetCertInfoCompare002, TestSize.Level0)
165 {
166 int length = sizeof(g_listCertInfoexpectResult) / sizeof(g_listCertInfoexpectResult[0]);
167
168 char *uri = g_listCertInfoexpectResult[length - 1].CertInfo.uri;
169 struct CmBlob uriBlob = {strlen(uri) + 1, (uint8_t *)(uri)};
170
171 struct CertInfo firstCertInfo, secondCertInfo;
172 unsigned int len = sizeof(struct CertInfo);
173
174 (void)memset_s(&firstCertInfo, len, 0, len);
175 int32_t ret = InitCertInfo(&firstCertInfo);
176 EXPECT_EQ(ret, CM_SUCCESS) << "firstCertInfo malloc faild, retcode:" << ret;
177
178 (void)memset_s(&secondCertInfo, len, 0, len);
179 ret = InitCertInfo(&secondCertInfo);
180 EXPECT_EQ(ret, CM_SUCCESS) << "secondCertInfo malloc faild, retcode:" << ret;
181
182 ret = CmGetCertInfo(&uriBlob, CM_SYSTEM_TRUSTED_STORE, &firstCertInfo);
183 EXPECT_EQ(ret, CM_SUCCESS) << "first CmGetCertInfo failed,retcode:" << ret;
184
185 ret = CmGetCertInfo(&uriBlob, CM_SYSTEM_TRUSTED_STORE, &secondCertInfo);
186 EXPECT_EQ(ret, CM_SUCCESS) << "second CmGetCertInfo failed,retcode:" << ret;
187
188 EXPECT_EQ(CompareCertInfo(&firstCertInfo, &secondCertInfo), true) << "Diffrent app do not get the same cert.";
189 FreeCMBlobData(&(firstCertInfo.certInfo));
190 FreeCMBlobData(&(secondCertInfo.certInfo));
191 }
192
193 /**
194 * @tc.name: AppGetAllCertInfo003
195 * @tc.desc: Test CertManager get all cert info interface function
196 * @tc.type: FUNC
197 * @tc.require: AR000H0MJA /SR000H096P
198 */
199 HWTEST_F(CmGetCertInfoTest, AppGetAllCertInfo003, TestSize.Level0)
200 {
201 unsigned int len = sizeof(struct CertInfo);;
202 struct CertInfo certInfo;
203 int32_t ret = CmGetCertList(CM_SYSTEM_TRUSTED_STORE, lstCert);
204
205 EXPECT_EQ(ret, CM_SUCCESS) << "CmGetCertList failed,retcode:" << ret;
206
207 for (uint32_t i = 0; i < lstCert->certsCount; ++i) {
208 (void)memset_s(&certInfo, len, 0, len);
209 ret = InitCertInfo(&certInfo);
210 EXPECT_EQ(ret, CM_SUCCESS) << "CertInfo malloc faild, retcode:" << ret;
211
212 struct CertAbstract *ptr = &(lstCert->certAbstract[i]);
213 ASSERT_TRUE(ptr != NULL);
214
215 struct CmBlob uriBlob = {strlen(ptr->uri) + 1, (uint8_t *)(ptr->uri)};
216
217 ret = CmGetCertInfo(&uriBlob, CM_SYSTEM_TRUSTED_STORE, &certInfo);
218 EXPECT_EQ(ret, CM_SUCCESS) << " CmGetCertInfo failed,retcode:" << ptr->uri;
219 FreeCMBlobData(&(certInfo.certInfo));
220 }
221 }
222
223 /**
224 * @tc.name: ExceptionGetCertInfoTest004
225 * @tc.desc: Test CertManager get cert info interface abnormal function
226 * @tc.type: FUNC
227 * @tc.require: AR000H0MJA /SR000H096P
228 */
229 HWTEST_F(CmGetCertInfoTest, ExceptionGetCertInfoTest004, TestSize.Level0)
230 {
231 char *uri = g_listCertInfoexpectResult[1].CertInfo.uri;
232 struct CmBlob uriBlob = {strlen(uri) + 1, (uint8_t *)(uri)};
233 struct CertInfo certInfo;
234 unsigned int len = sizeof(struct CertInfo);
235 (void)memset_s(&certInfo, len, 0, len);
236 int32_t ret = InitCertInfo(&certInfo);
237 EXPECT_EQ(ret, CM_SUCCESS) << "CertInfo malloc faild, retcode:" << ret;
238
239 EXPECT_EQ(CmGetCertInfo(NULL, CM_SYSTEM_TRUSTED_STORE, &certInfo), CMR_ERROR_NULL_POINTER);
240
241 EXPECT_EQ(CmGetCertInfo(&uriBlob, 10, &certInfo), CMR_ERROR_INVALID_ARGUMENT);
242
243 EXPECT_EQ(CmGetCertInfo(&uriBlob, CM_SYSTEM_TRUSTED_STORE, NULL), CMR_ERROR_NULL_POINTER);
244
245 const char *invalidUri = "INVALID";
246 struct CmBlob invalidUriBlob = {strlen(invalidUri), (uint8_t *)invalidUri};
247 EXPECT_EQ(CmGetCertInfo(&invalidUriBlob, CM_SYSTEM_TRUSTED_STORE, &certInfo),
248 CMR_ERROR_INVALID_ARGUMENT);
249
250 FreeCMBlobData(&(certInfo.certInfo));
251 }
252 }