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             "1d3472b9.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             "4f316efb.0",
47             "SwissSign AG",
48             true,
49             "CN=SwissSign Gold CA - G2,OU=,O=SwissSign AG",
50             "CN=SwissSign Gold CA - G2,OU=,O=SwissSign AG",
51             "BB401C43F55E4FB0",
52             "2006-10-25",
53             "2036-10-25",
54             "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"
55         },
56         true
57     },
58     {
59         {
60             "5ad8a5d6.0",
61             "GlobalSign nv-sa",
62             true,
63             "CN=GlobalSign Root CA,OU=Root CA,O=GlobalSign nv-sa",
64             "CN=GlobalSign Root CA,OU=Root CA,O=GlobalSign nv-sa",
65             "040000000001154B5AC394",
66             "1998-9-1",
67             "2028-1-28",
68             "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"
69         },
70         true
71     }
72 };
73 
74 class CmGetCertInfoTest : public testing::Test {
75 public:
76     static void SetUpTestCase(void);
77 
78     static void TearDownTestCase(void);
79 
80     void SetUp();
81 
82     void TearDown();
83 
84     struct CertList *lstCert;
85 };
86 
SetUpTestCase(void)87 void CmGetCertInfoTest::SetUpTestCase(void)
88 {
89     SetATPermission();
90 }
91 
TearDownTestCase(void)92 void CmGetCertInfoTest::TearDownTestCase(void)
93 {
94 }
95 
SetUp()96 void CmGetCertInfoTest::SetUp()
97 {
98     InitCertList(&lstCert);
99 }
100 
TearDown()101 void CmGetCertInfoTest::TearDown()
102 {
103     FreeCertList(lstCert);
104 }
105 
106 /**
107  * @tc.name: SimpleCmGetCertInfo001
108  * @tc.desc: Test CertManager get cert info interface base function
109  * @tc.type: FUNC
110  * @tc.require: AR000H0MJA /SR000H096P
111  */
112 HWTEST_F(CmGetCertInfoTest, SimpleCmGetCertInfo001, TestSize.Level0)
113 {
114     char *uri = g_listCertInfoexpectResult[0].CertInfo.uri;
115     struct CmBlob uriBlob = {strlen(uri) + 1, (uint8_t *)(uri)};
116     struct CertInfo certInfo;
117     unsigned int len = sizeof(struct CertInfo);
118     (void)memset_s(&certInfo, len, 0, len);
119     int32_t ret = InitCertInfo(&certInfo);
120     EXPECT_EQ(ret, CM_SUCCESS) << "CertInfo malloc faild, retcode:" << ret;
121 
122     ret = CmGetCertInfo(&uriBlob, CM_SYSTEM_TRUSTED_STORE, &certInfo);
123     EXPECT_EQ(ret, CM_SUCCESS) << "CmGetCertInfo failed, retcode:" << ret;
124 
125     EXPECT_EQ(CompareCertInfo(&certInfo, &(g_listCertInfoexpectResult[0].CertInfo)), true) <<DumpCertInfo(&certInfo);
126 
127     FreeCMBlobData(&(certInfo.certInfo));
128 }
129 
130 /**
131  * @tc.name: AppGetCertInfoCompare002
132  * @tc.desc: Test CertManager get cert info compare interface function
133  * @tc.type: FUNC
134  * @tc.require: AR000H0MJA /SR000H096P
135  */
136 HWTEST_F(CmGetCertInfoTest, AppGetCertInfoCompare002, TestSize.Level0)
137 {
138     int length = sizeof(g_listCertInfoexpectResult) / sizeof(g_listCertInfoexpectResult[0]);
139 
140     char *uri = g_listCertInfoexpectResult[length - 1].CertInfo.uri;
141     struct CmBlob uriBlob = {strlen(uri) + 1, (uint8_t *)(uri)};
142 
143     struct CertInfo firstCertInfo, secondCertInfo;
144     unsigned int len = sizeof(struct CertInfo);
145 
146     (void)memset_s(&firstCertInfo, len, 0, len);
147     int32_t ret = InitCertInfo(&firstCertInfo);
148     EXPECT_EQ(ret, CM_SUCCESS) << "firstCertInfo malloc faild, retcode:" << ret;
149 
150     (void)memset_s(&secondCertInfo, len, 0, len);
151     ret = InitCertInfo(&secondCertInfo);
152     EXPECT_EQ(ret, CM_SUCCESS) << "secondCertInfo malloc faild, retcode:" << ret;
153 
154     ret = CmGetCertInfo(&uriBlob, CM_SYSTEM_TRUSTED_STORE, &firstCertInfo);
155     EXPECT_EQ(ret, CM_SUCCESS) << "first CmGetCertInfo failed,retcode:" << ret;
156 
157     ret = CmGetCertInfo(&uriBlob, CM_SYSTEM_TRUSTED_STORE, &secondCertInfo);
158     EXPECT_EQ(ret, CM_SUCCESS) << "second CmGetCertInfo failed,retcode:" << ret;
159 
160     EXPECT_EQ(CompareCertInfo(&firstCertInfo, &secondCertInfo), true) << "Diffrent app do not get the same cert.";
161     FreeCMBlobData(&(firstCertInfo.certInfo));
162     FreeCMBlobData(&(secondCertInfo.certInfo));
163 }
164 
165 /**
166  * @tc.name: AppGetAllCertInfo003
167  * @tc.desc: Test CertManager get all cert info interface function
168  * @tc.type: FUNC
169  * @tc.require: AR000H0MJA /SR000H096P
170  */
171 HWTEST_F(CmGetCertInfoTest, AppGetAllCertInfo003, TestSize.Level0)
172 {
173     unsigned int len = sizeof(struct CertInfo);;
174     struct CertInfo certInfo;
175     int32_t ret = CmGetCertList(CM_SYSTEM_TRUSTED_STORE, lstCert);
176 
177     EXPECT_EQ(ret, CM_SUCCESS) << "CmGetCertList failed,retcode:" << ret;
178 
179     for (uint32_t i = 0; i < lstCert->certsCount; ++i) {
180         (void)memset_s(&certInfo, len, 0, len);
181         ret = InitCertInfo(&certInfo);
182         EXPECT_EQ(ret, CM_SUCCESS) << "CertInfo malloc faild, retcode:" << ret;
183 
184         struct CertAbstract *ptr = &(lstCert->certAbstract[i]);
185         ASSERT_TRUE(ptr != NULL);
186 
187         struct CmBlob uriBlob = {strlen(ptr->uri) + 1, (uint8_t *)(ptr->uri)};
188 
189         ret = CmGetCertInfo(&uriBlob, CM_SYSTEM_TRUSTED_STORE, &certInfo);
190         EXPECT_EQ(ret, CM_SUCCESS) << " CmGetCertInfo failed,retcode:" << ptr->uri;
191         FreeCMBlobData(&(certInfo.certInfo));
192     }
193 }
194 
195 /**
196  * @tc.name: ExceptionGetCertInfoTest004
197  * @tc.desc: Test CertManager get cert info interface abnormal function
198  * @tc.type: FUNC
199  * @tc.require: AR000H0MJA /SR000H096P
200  */
201 HWTEST_F(CmGetCertInfoTest, ExceptionGetCertInfoTest004, TestSize.Level0)
202 {
203     char *uri = g_listCertInfoexpectResult[1].CertInfo.uri;
204     struct CmBlob uriBlob = {strlen(uri) + 1, (uint8_t *)(uri)};
205     struct CertInfo certInfo;
206     unsigned int len = sizeof(struct CertInfo);
207     (void)memset_s(&certInfo, len, 0, len);
208     int32_t ret = InitCertInfo(&certInfo);
209     EXPECT_EQ(ret, CM_SUCCESS) << "CertInfo malloc faild, retcode:" << ret;
210 
211     EXPECT_EQ(CmGetCertInfo(NULL, CM_SYSTEM_TRUSTED_STORE, &certInfo), CMR_ERROR_NULL_POINTER);
212 
213     EXPECT_EQ(CmGetCertInfo(&uriBlob, 10,  &certInfo), CMR_ERROR_INVALID_ARGUMENT);
214 
215     EXPECT_EQ(CmGetCertInfo(&uriBlob, CM_SYSTEM_TRUSTED_STORE, NULL), CMR_ERROR_NULL_POINTER);
216 
217     const char *invalidUri = "INVALID";
218     struct CmBlob invalidUriBlob = {strlen(invalidUri), (uint8_t *)invalidUri};
219     EXPECT_EQ(CmGetCertInfo(&invalidUriBlob, CM_SYSTEM_TRUSTED_STORE, &certInfo),
220         CMR_ERROR_INVALID_ARGUMENT);
221 
222     FreeCMBlobData(&(certInfo.certInfo));
223 }
224 }