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 <arpa/inet.h>
18 
19 #include "gtest/gtest-message.h"
20 #include "gtest/gtest-test-part.h"
21 #include "gtest/hwext/gtest-ext.h"
22 #include "gtest/hwext/gtest-tag.h"
23 #include "http_proxy.h"
24 #include "interface_type.h"
25 #include "net_manager_constants.h"
26 #include "netmanager_ext_test_security.h"
27 #include "netmgr_ext_log_wrapper.h"
28 #include "refbase.h"
29 
30 #define private public
31 #define protected public
32 
33 #include "netfirewall_client.h"
34 #include "netfirewall_common.h"
35 #include "netfirewall_proxy.h"
36 #include "netfirewall_service.h"
37 
38 namespace OHOS {
39 namespace NetManagerStandard {
40 namespace {
41 using namespace testing::ext;
42 
43 const int32_t USER_ID = 100;
44 const int32_t PAGE = 0;
45 const int32_t PAGE_SIZE = 5;
46 const int32_t TOTAL_PAGE = 10;
47 const int32_t APP_ID = 2034;
48 const uint8_t MASK = 24;
49 const uint16_t LOCAL_START_PORT = 10020;
50 const uint16_t LOCAL_END_PORT = 1003;
51 const uint16_t REMOTE_START_PORT = 1002;
52 const uint16_t REMOTE_END_PORT = 10030;
53 
GetNetFirewallRuleSptr()54 sptr<NetFirewallRule> GetNetFirewallRuleSptr()
55 {
56     sptr<NetFirewallRule> rule = (std::make_unique<NetFirewallRule>()).release();
57     if (!rule) {
58         return rule;
59     }
60     rule->ruleId = 1;
61     rule->userId = USER_ID;
62     rule->ruleName = "rule test";
63     rule->ruleDescription = "AddNetFirewallRule 001";
64     rule->ruleDirection = NetFirewallRuleDirection::RULE_OUT;
65     rule->ruleAction = FirewallRuleAction::RULE_ALLOW;
66     rule->isEnabled = false;
67     rule->appUid = APP_ID;
68 
69     NetFirewallIpParam localParam;
70     localParam.family = 1;
71     localParam.type = 1;
72     inet_pton(AF_INET, "192.168.10.1", &localParam.ipv4.startIp);
73     localParam.mask = MASK;
74     rule->localIps.push_back(localParam);
75 
76     NetFirewallIpParam remoteParam;
77     remoteParam.family = FAMILY_IPV6;
78     remoteParam.type = 1;
79     inet_pton(AF_INET6, "fe80::6bec:e9b9:a1df:f69d", &localParam.ipv6.startIp);
80     remoteParam.mask = MASK;
81     rule->remoteIps.push_back(remoteParam);
82 
83     NetFirewallPortParam localPortParam;
84     localPortParam.startPort = LOCAL_START_PORT;
85     localPortParam.endPort = LOCAL_END_PORT;
86     rule->localPorts.push_back(localPortParam);
87 
88     NetFirewallPortParam remotePortParam;
89     remotePortParam.startPort = REMOTE_START_PORT;
90     remotePortParam.endPort = REMOTE_END_PORT;
91     rule->remotePorts.push_back(remotePortParam);
92 
93     NetFirewallDomainParam domain;
94     domain.isWildcard = 1;
95     domain.domain = "www.openharmony.cn";
96     rule->domains.push_back(domain);
97     rule->dns.primaryDns = "192.168.1.245";
98     rule->dns.standbyDns = "192.168.1.1";
99 
100     return rule;
101 }
102 
GetNetFirewallPolicySptr()103 sptr<NetFirewallPolicy> GetNetFirewallPolicySptr()
104 {
105     sptr<NetFirewallPolicy> status = (std::make_unique<NetFirewallPolicy>()).release();
106     status->isOpen = true;
107     status->inAction = FirewallRuleAction::RULE_DENY;
108     status->outAction = FirewallRuleAction::RULE_ALLOW;
109     return status;
110 }
111 
GetInterceptRecordSptr()112 sptr<InterceptRecord> GetInterceptRecordSptr()
113 {
114     sptr<InterceptRecord> record = (std::make_unique<InterceptRecord>()).release();
115     const uint32_t time = 10025152;
116     const uint16_t localPort = 10000;
117     const uint16_t remotePort = 20000;
118     const uint32_t uid = 10085;
119     record->time = time;
120     record->localIp = "192.168.1.2";
121     record->remoteIp = "192.168.1.3";
122     record->localPort = localPort;
123     record->remotePort = remotePort;
124     record->protocol = 1;
125     record->appUid = uid;
126     return record;
127 }
128 } // namespace
129 
130 class MockNetIRemoteObject : public IRemoteObject {
131 public:
MockNetIRemoteObject()132     MockNetIRemoteObject() : IRemoteObject(u"mock_i_remote_object") {}
~MockNetIRemoteObject()133     ~MockNetIRemoteObject() {}
134 
GetObjectRefCount()135     int32_t GetObjectRefCount() override
136     {
137         return 0;
138     }
139 
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)140     int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override
141     {
142         switch (code) {
143             case static_cast<uint32_t>(INetFirewallService::ADD_NET_FIREWALL_RULE):
144                 reply.WriteInt32(1);
145                 break;
146             case static_cast<uint32_t>(INetFirewallService::GET_NET_FIREWALL_STATUS):
147                 GetNetFirewallPolicySptr()->Marshalling(reply);
148                 break;
149             case static_cast<uint32_t>(INetFirewallService::GET_NET_FIREWALL_RULE):
150                 GetNetFirewallRuleSptr()->Marshalling(reply);
151                 break;
152             case static_cast<uint32_t>(INetFirewallService::GET_ALL_NET_FIREWALL_RULES): {
153                 std::vector<NetFirewallRule> ruleList;
154                 reply.WriteInt32(PAGE);
155                 reply.WriteInt32(PAGE_SIZE);
156                 reply.WriteInt32(TOTAL_PAGE);
157                 sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr();
158                 if (rule != nullptr) {
159                     ruleList.push_back(*rule);
160                 }
161                 reply.WriteUint32(ruleList.size());
162                 for (auto &rule : ruleList) {
163                     rule.Marshalling(reply);
164                 }
165                 break;
166             }
167             case static_cast<uint32_t>(INetFirewallService::SET_NET_FIREWALL_STATUS):
168             case static_cast<uint32_t>(INetFirewallService::DELETE_NET_FIREWALL_RULE):
169             case static_cast<uint32_t>(INetFirewallService::UPDATE_NET_FIREWALL_RULE):
170                 reply.WriteInt32(1);
171                 break;
172             case static_cast<uint32_t>(INetFirewallService::GET_ALL_INTERCEPT_RECORDS): {
173                 std::vector<InterceptRecord> recordList;
174                 reply.WriteInt32(PAGE);
175                 reply.WriteInt32(PAGE_SIZE);
176                 reply.WriteInt32(TOTAL_PAGE);
177                 sptr<InterceptRecord> record = GetInterceptRecordSptr();
178                 recordList.push_back(*record);
179                 reply.WriteUint32(recordList.size());
180                 for (auto rule : recordList) {
181                     rule.Marshalling(reply);
182                 }
183                 break;
184             }
185             default:
186                 reply.WriteInt32(1);
187                 break;
188         }
189         return eCode;
190     }
191 
IsProxyObject() const192     bool IsProxyObject() const override
193     {
194         return true;
195     }
196 
CheckObjectLegality() const197     bool CheckObjectLegality() const override
198     {
199         return true;
200     }
201 
AddDeathRecipient(const sptr<DeathRecipient> & recipient)202     bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) override
203     {
204         return true;
205     }
206 
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)207     bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) override
208     {
209         return true;
210     }
211 
Marshalling(Parcel & parcel) const212     bool Marshalling(Parcel &parcel) const override
213     {
214         return true;
215     }
216 
AsInterface()217     sptr<IRemoteBroker> AsInterface() override
218     {
219         return nullptr;
220     }
221 
Dump(int fd,const std::vector<std::u16string> & args)222     int Dump(int fd, const std::vector<std::u16string> &args) override
223     {
224         return 0;
225     }
226 
GetObjectDescriptor() const227     std::u16string GetObjectDescriptor() const
228     {
229         std::u16string descriptor = std::u16string();
230         return descriptor;
231     }
232 
SetErrorCode(int errorCode)233     void SetErrorCode(int errorCode)
234     {
235         eCode = errorCode;
236     }
237 
238 private:
239     int eCode = FIREWALL_SUCCESS;
240 };
241 
242 class NetFirewallServiceProxyTest : public testing::Test {
243 public:
244     static void SetUpTestCase();
245     static void TearDownTestCase();
246     void SetUp();
247     void TearDown();
248     static inline sptr<MockNetIRemoteObject> remoteObj_ = std::make_unique<MockNetIRemoteObject>().release();
249     static inline std::shared_ptr<NetFirewallProxy> instance_ = std::make_shared<NetFirewallProxy>(remoteObj_);
250 };
251 
SetUpTestCase()252 void NetFirewallServiceProxyTest::SetUpTestCase() {}
253 
TearDownTestCase()254 void NetFirewallServiceProxyTest::TearDownTestCase() {}
255 
SetUp()256 void NetFirewallServiceProxyTest::SetUp() {}
257 
TearDown()258 void NetFirewallServiceProxyTest::TearDown() {}
259 
260 HWTEST_F(NetFirewallServiceProxyTest, SetNetFirewallPolicy001, TestSize.Level1)
261 {
262     NetManagerExtAccessToken token;
263     int32_t userId = USER_ID;
264     sptr<NetFirewallPolicy> status = GetNetFirewallPolicySptr();
265     auto ret = instance_->SetNetFirewallPolicy(userId, status);
266     EXPECT_EQ(ret, FIREWALL_SUCCESS);
267 }
268 
269 HWTEST_F(NetFirewallServiceProxyTest, AddNetFirewallRule001, TestSize.Level1)
270 {
271     NetManagerExtAccessToken token;
272     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr();
273     int32_t ruleId = 0;
274     auto ret = instance_->AddNetFirewallRule(rule, ruleId);
275     EXPECT_EQ(ret, FIREWALL_SUCCESS);
276 }
277 
278 HWTEST_F(NetFirewallServiceProxyTest, GetNetFirewallPolicy001, TestSize.Level1)
279 {
280     NetManagerExtAccessToken token;
281     int32_t userId = USER_ID;
282     sptr<NetFirewallPolicy> status = new (std::nothrow) NetFirewallPolicy;
283     auto ret = instance_->GetNetFirewallPolicy(userId, status);
284     EXPECT_EQ(ret, FIREWALL_SUCCESS);
285 }
286 
287 HWTEST_F(NetFirewallServiceProxyTest, UpdateNetFirewallRule001, TestSize.Level1)
288 {
289     NetManagerExtAccessToken token;
290     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr();
291     auto ret = instance_->UpdateNetFirewallRule(rule);
292     EXPECT_EQ(ret, FIREWALL_SUCCESS);
293 }
294 
295 HWTEST_F(NetFirewallServiceProxyTest, GetAllNetFirewallRule001, TestSize.Level1)
296 {
297     NetManagerExtAccessToken token;
298     int32_t userId = USER_ID;
299     sptr<RequestParam> param = new (std::nothrow) RequestParam();
300     param->page = 0;
301     param->pageSize = 5;
302     param->orderField = NetFirewallOrderField::ORDER_BY_RULE_NAME;
303     param->orderType = NetFirewallOrderType::ORDER_ASC;
304     sptr<FirewallRulePage> info = new (std::nothrow) FirewallRulePage();
305     auto ret = instance_->GetNetFirewallRules(userId, param, info);
306     EXPECT_EQ(ret, FIREWALL_SUCCESS);
307 }
308 
309 HWTEST_F(NetFirewallServiceProxyTest, GetNetFirewallRule001, TestSize.Level1)
310 {
311     NetManagerExtAccessToken token;
312     int32_t ruleId = 1;
313     int32_t userId = USER_ID;
314     sptr<NetFirewallRule> rule = new (std::nothrow) NetFirewallRule;
315     auto ret = instance_->GetNetFirewallRule(userId, ruleId, rule);
316     EXPECT_EQ(ret, FIREWALL_SUCCESS);
317 }
318 
319 HWTEST_F(NetFirewallServiceProxyTest, DeleteNetFirewallRule001, TestSize.Level1)
320 {
321     NetManagerExtAccessToken token;
322     int32_t userId = USER_ID;
323     int32_t ruleId = 1;
324     auto ret = instance_->DeleteNetFirewallRule(userId, ruleId);
325     EXPECT_EQ(ret, FIREWALL_SUCCESS);
326 }
327 
328 HWTEST_F(NetFirewallServiceProxyTest, GetInterceptRecord001, TestSize.Level1)
329 {
330     NetManagerExtAccessToken token;
331     int32_t userId = USER_ID;
332     sptr<RequestParam> param = new (std::nothrow) RequestParam();
333     param->page = 0;
334     param->pageSize = 5;
335     param->orderField = NetFirewallOrderField::ORDER_BY_RECORD_TIME;
336     param->orderType = NetFirewallOrderType::ORDER_ASC;
337     sptr<InterceptRecordPage> info = new (std::nothrow) InterceptRecordPage();
338     auto ret = instance_->GetInterceptRecords(userId, param, info);
339     EXPECT_EQ(ret, FIREWALL_SUCCESS);
340 }
341 } // namespace NetManagerStandard
342 } // namespace OHOS