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 
18 #include "gtest/gtest-message.h"
19 #include "gtest/gtest-test-part.h"
20 #include "gtest/hwext/gtest-ext.h"
21 #include "gtest/hwext/gtest-tag.h"
22 #include "http_proxy.h"
23 #include "inet_addr.h"
24 #include "net_manager_constants.h"
25 #include "netmanager_ext_test_security.h"
26 #include "netmgr_ext_log_wrapper.h"
27 #include "refbase.h"
28 #include "singleton.h"
29 
30 
31 #define private public
32 #define protected public
33 
34 #include <string>
35 
36 #include "i_netfirewall_service.h"
37 #include "netfirewall_service.h"
38 #include "netfirewall_client.h"
39 #include "netfirewall_common.h"
40 #include "netfirewall_proxy.h"
41 #include "netsys_controller.h"
42 #include "system_ability_definition.h"
43 #include "bundle_constants.h"
44 #include "netfirewall_database.h"
45 #include "netfirewall_default_rule_parser.h"
46 #include "netfirewall_db_helper.h"
47 #include "netfirewall_hisysevent.h"
48 #include "netfirewall_intercept_recorder.h"
49 
50 namespace OHOS {
51 namespace NetManagerStandard {
52 namespace {
53 using namespace testing::ext;
54 int32_t g_rowId = 0;
55 
56 constexpr uint32_t APPID_TEST01 = 2034;
57 constexpr int32_t USER_ID1 = 100;
58 constexpr int32_t USER_ID2 = 101;
59 constexpr int32_t OLD_VERSION = 1;
60 constexpr int32_t NEW_VERSION = 2;
61 constexpr int32_t MAX_USER_RULE = 1;
62 constexpr int32_t MAX_IPS = 1;
63 constexpr int32_t MAX_PORTS = 1;
64 constexpr int32_t MAX_DOMAINS = 1;
65 constexpr uint16_t LOCAL_START_PORT = 10020;
66 constexpr uint16_t LOCAL_END_PORT = 1003;
67 constexpr uint16_t REMOTE_START_PORT = 1002;
68 constexpr uint16_t REMOTE_END_PORT = 10030;
69 
GetIpList(const std::string & addressStart)70 std::vector<NetFirewallIpParam> GetIpList(const std::string &addressStart)
71 {
72     const uint8_t mask = 24;
73     std::vector<NetFirewallIpParam> localParamList;
74     NetFirewallIpParam localParam;
75     localParam.family = 1;
76     localParam.type = 1;
77     localParam.mask = mask;
78     for (int i = 0; i < MAX_IPS; i++) {
79         inet_pton(AF_INET, (addressStart + std::to_string(i)).c_str(), &localParam.ipv4.startIp);
80         localParamList.push_back(localParam);
81     }
82     return localParamList;
83 }
84 
GetNetFirewallRuleSptr()85 sptr<NetFirewallRule> GetNetFirewallRuleSptr()
86 {
87     sptr<NetFirewallRule> rule = (std::make_unique<NetFirewallRule>()).release();
88     if (!rule) {
89         return rule;
90     }
91     rule->ruleId = 1;
92     rule->userId = USER_ID1;
93     rule->ruleName = "rule test";
94     rule->ruleDescription = "AddNetFirewallRule 001";
95     rule->ruleDirection = NetFirewallRuleDirection::RULE_OUT;
96     rule->ruleAction = FirewallRuleAction::RULE_ALLOW;
97     rule->isEnabled = true;
98     rule->appUid = APPID_TEST01;
99 
100     rule->localIps = GetIpList("192.168.10.");
101     rule->remoteIps = GetIpList("192.168.2.");
102     std::vector<NetFirewallPortParam> localPortParamList;
103     NetFirewallPortParam localPortParam;
104     localPortParam.startPort = LOCAL_START_PORT;
105     localPortParam.endPort = LOCAL_END_PORT;
106     for (int i = 0; i < MAX_PORTS; i++) {
107         localPortParamList.push_back(localPortParam);
108     }
109     rule->localPorts = localPortParamList;
110     std::vector<NetFirewallPortParam> remotePortParamList;
111     NetFirewallPortParam remotePortParam;
112     remotePortParam.startPort = REMOTE_START_PORT;
113     remotePortParam.endPort = REMOTE_END_PORT;
114     for (int i = 0; i < MAX_PORTS; i++) {
115         remotePortParamList.push_back(remotePortParam);
116     }
117     rule->remotePorts = remotePortParamList;
118     std::vector<NetFirewallDomainParam> domainList;
119     NetFirewallDomainParam domain;
120     domain.isWildcard = 1;
121     domain.domain = "www.openharmony.cn";
122     for (int i = 0; i < MAX_DOMAINS; i++) {
123         domainList.push_back(domain);
124     }
125     rule->domains = domainList;
126     rule->dns.primaryDns = "192.168.1.245";
127     rule->dns.standbyDns = "192.168.1.1";
128 
129     return rule;
130 }
131 
GetNetFirewallRuleSptrTypeDns()132 sptr<NetFirewallRule> GetNetFirewallRuleSptrTypeDns()
133 {
134     sptr<NetFirewallRule> rule = (std::make_unique<NetFirewallRule>()).release();
135     if (!rule) {
136         return rule;
137     }
138     int ruleId = 2;
139     rule->ruleId = ruleId;
140     rule->userId = USER_ID1;
141     rule->ruleName = "rule test";
142     rule->ruleDescription = "AddNetFirewallRule 001";
143     rule->ruleDirection = NetFirewallRuleDirection::RULE_OUT;
144     rule->ruleAction = FirewallRuleAction::RULE_ALLOW;
145     rule->isEnabled = true;
146     rule->appUid = APPID_TEST01;
147 
148     rule->localIps = GetIpList("192.168.10.");
149     rule->remoteIps = GetIpList("192.168.2.");
150     rule->ruleType = NetFirewallRuleType::RULE_IP;
151     std::vector<NetFirewallPortParam> localPortParamList;
152     NetFirewallPortParam localPortParam;
153     localPortParam.startPort = LOCAL_START_PORT;
154     localPortParam.endPort = LOCAL_END_PORT;
155     for (int i = 0; i < MAX_PORTS; i++) {
156         localPortParamList.push_back(localPortParam);
157     }
158     rule->localPorts = localPortParamList;
159     std::vector<NetFirewallPortParam> remotePortParamList;
160     NetFirewallPortParam remotePortParam;
161     remotePortParam.startPort = REMOTE_START_PORT;
162     remotePortParam.endPort = REMOTE_END_PORT;
163     for (int i = 0; i < MAX_PORTS; i++) {
164         remotePortParamList.push_back(remotePortParam);
165     }
166     rule->remotePorts = remotePortParamList;
167     std::vector<NetFirewallDomainParam> domainList;
168     NetFirewallDomainParam domain;
169     domain.isWildcard = 1;
170     domain.domain = "www.openharmony.cn";
171     for (int i = 0; i < MAX_DOMAINS; i++) {
172         domainList.push_back(domain);
173     }
174     rule->domains = domainList;
175     rule->dns.primaryDns = "192.168.1.245";
176     rule->dns.standbyDns = "192.168.1.1";
177 
178     return rule;
179 }
180 }
181 
182 class NetFirewallServiceTest : public testing::Test {
183 public:
184     static void SetUpTestCase();
185     static void TearDownTestCase();
186 
187     void SetUp();
188     void TearDown();
189     bool PublishChangedEvent(const std::string &action, int32_t code) const;
190     static inline auto instance_ = DelayedSingleton<NetFirewallService>::GetInstance();
191 };
192 
SetUpTestCase()193 void NetFirewallServiceTest::SetUpTestCase() {}
194 
TearDownTestCase()195 void NetFirewallServiceTest::TearDownTestCase() {}
196 
SetUp()197 void NetFirewallServiceTest::SetUp() {}
198 
TearDown()199 void NetFirewallServiceTest::TearDown() {}
200 
201 /**
202  * @tc.name: OnStart
203  * @tc.desc: Test NetFirewallServiceTest OnStart.
204  * @tc.type: FUNC
205  */
206 HWTEST_F(NetFirewallServiceTest, OnStart, TestSize.Level1)
207 {
208     instance_->state_ = NetFirewallService::ServiceRunningState::STATE_RUNNING;
209     instance_->OnStart();
210     instance_->state_ = NetFirewallService::ServiceRunningState::STATE_NOT_START;
211     EXPECT_EQ(instance_->state_, NetFirewallService::ServiceRunningState::STATE_NOT_START);
212 }
213 
214 /**
215  * @tc.name: OnInit001
216  * @tc.desc: Test NetFirewallServiceTest OnInit.
217  * @tc.type: FUNC
218  */
219 HWTEST_F(NetFirewallServiceTest, OnInit001, TestSize.Level1)
220 {
221     int32_t ret = instance_->OnInit();
222     EXPECT_EQ(ret, FIREWALL_SUCCESS);
223 }
224 
225 /**
226  * @tc.name: OnStop
227  * @tc.desc: Test NetFirewallServiceTest OnStop.
228  * @tc.type: FUNC
229  */
230 HWTEST_F(NetFirewallServiceTest, OnStop, TestSize.Level1)
231 {
232     instance_->OnStop();
233     EXPECT_EQ(instance_->state_, NetFirewallService::ServiceRunningState::STATE_NOT_START);
234 }
235 
236 /**
237  * @tc.name: Dump
238  * @tc.desc: Test NetFirewallServiceTest Dump.
239  * @tc.type: FUNC
240  */
241 HWTEST_F(NetFirewallServiceTest, Dump, TestSize.Level1)
242 {
243     int32_t fd = 1;
244     std::vector<std::u16string> args = {};
245     EXPECT_EQ(instance_->Dump(fd, args), FIREWALL_SUCCESS);
246 }
247 
248 /**
249  * @tc.name: GetDumpMessage
250  * @tc.desc: Test NetFirewallServiceTest GetDumpMessage.
251  * @tc.type: FUNC
252  */
253 HWTEST_F(NetFirewallServiceTest, GetDumpMessage, TestSize.Level1)
254 {
255     std::string message;
256     instance_->GetDumpMessage(message);
257     EXPECT_EQ(message.empty(), false);
258 }
259 
260 /**
261  * @tc.name: OnAddSystemAbility001
262  * @tc.desc: Test NetFirewallServiceTest OnAddSystemAbility.
263  * @tc.type: FUNC
264  */
265 HWTEST_F(NetFirewallServiceTest, OnAddSystemAbility001, TestSize.Level1)
266 {
267     std::string deviceId = "dev1";
268     instance_->OnRemoveSystemAbility(COMM_NETSYS_NATIVE_SYS_ABILITY_ID, deviceId);
269     EXPECT_TRUE(instance_->hasSaRemoved_);
270 
271     instance_->OnAddSystemAbility(COMM_NETSYS_NATIVE_SYS_ABILITY_ID, deviceId);
272     EXPECT_FALSE(instance_->hasSaRemoved_);
273 
274     instance_->OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
275     EXPECT_EQ(instance_->subscriber_, nullptr);
276 
277     instance_->SubscribeCommonEvent();
278     instance_->OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
279     EXPECT_NE(instance_->subscriber_, nullptr);
280 }
281 
282 /**
283  * @tc.name: AddDefaultNetFirewallRule001
284  * @tc.desc: Test NetFirewallServiceTest AddDefaultNetFirewallRule.
285  * @tc.type: FUNC
286  */
287 HWTEST_F(NetFirewallServiceTest, AddDefaultNetFirewallRule001, TestSize.Level1)
288 {
289     int ret = instance_->AddDefaultNetFirewallRule(instance_->GetCurrentAccountId());
290     EXPECT_EQ(ret, FIREWALL_SUCCESS);
291 }
292 
293 /**
294  * @tc.name: AddDefaultNetFirewallRule002
295  * @tc.desc: Test NetFirewallServiceTest AddDefaultNetFirewallRule.
296  * @tc.type: FUNC
297  */
298 HWTEST_F(NetFirewallServiceTest, AddDefaultNetFirewallRule002, TestSize.Level1)
299 {
300     int ret = instance_->AddDefaultNetFirewallRule(instance_->GetCurrentAccountId());
301     EXPECT_EQ(ret, FIREWALL_SUCCESS);
302 }
303 
304 /**
305  * @tc.name: DeleteNetFirewallRuleByUserId001
306  * @tc.desc: Test NetFirewallServiceTest DeleteNetFirewallRuleByUserId.
307  * @tc.type: FUNC
308  */
309 HWTEST_F(NetFirewallServiceTest, DeleteNetFirewallRuleByUserId001, TestSize.Level1)
310 {
311     NETMGR_EXT_LOG_I("delete userid id = %{public}d ", instance_->GetCurrentAccountId());
312     int ret = NetFirewallRuleManager::GetInstance().DeleteNetFirewallRuleByUserId(instance_->GetCurrentAccountId());
313     EXPECT_EQ(ret, FIREWALL_SUCCESS);
314 }
315 
316 
317 /**
318  * @tc.name: SetNetFirewallPolicy001
319  * @tc.desc: Test NetFirewallServiceTest SetNetFirewallPolicy.
320  * @tc.type: FUNC
321  */
322 HWTEST_F(NetFirewallServiceTest, SetNetFirewallPolicy001, TestSize.Level1)
323 {
324     int32_t userId = USER_ID1;
325     DelayedSingleton<NetFirewallService>::GetInstance()->GetCurrentAccountId();
326     sptr<NetFirewallPolicy> status = new (std::nothrow) NetFirewallPolicy;
327     status->isOpen = true;
328     status->inAction = FirewallRuleAction::RULE_DENY;
329     status->outAction = FirewallRuleAction::RULE_ALLOW;
330     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->SetNetFirewallPolicy(userId, status);
331     EXPECT_EQ(ret, FIREWALL_SUCCESS);
332     status->isOpen = false;
333     ret = DelayedSingleton<NetFirewallService>::GetInstance()->SetNetFirewallPolicy(userId, status);
334     EXPECT_EQ(ret, FIREWALL_SUCCESS);
335     status->isOpen = true;
336     status->inAction = FirewallRuleAction::RULE_ALLOW;
337     ret = DelayedSingleton<NetFirewallService>::GetInstance()->SetNetFirewallPolicy(userId, status);
338     EXPECT_EQ(ret, FIREWALL_SUCCESS);
339 }
340 
341 /**
342  * @tc.name: SetNetFirewallPolicy002
343  * @tc.desc: Test NetFirewallServiceTest SetNetFirewallPolicy.
344  * @tc.type: FUNC
345  */
346 HWTEST_F(NetFirewallServiceTest, SetNetFirewallPolicy002, TestSize.Level1)
347 {
348     int32_t userId = 101;
349     sptr<NetFirewallPolicy> status = new (std::nothrow) NetFirewallPolicy;
350     status->isOpen = false;
351     status->inAction = FirewallRuleAction::RULE_DENY;
352     status->outAction = FirewallRuleAction::RULE_ALLOW;
353     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->SetNetFirewallPolicy(userId, status);
354     int usrRet = DelayedSingleton<NetFirewallService>::GetInstance()->CheckUserExist(userId);
355     EXPECT_EQ(ret, usrRet);
356 }
357 
358 /**
359  * @tc.name: ClearCurrentNetFirewallPreferences001
360  * @tc.desc: Test NetFirewallServiceTest ClearCurrentFirewallPolicy.
361  * @tc.type: FUNC
362  */
363 HWTEST_F(NetFirewallServiceTest, ClearCurrentNetFirewallPreferences001, TestSize.Level1)
364 {
365     int32_t userId = 101;
366     int ret = NetFirewallPolicyManager::GetInstance().ClearCurrentFirewallPolicy();
367     EXPECT_EQ(ret, FIREWALL_SUCCESS);
368 }
369 
370 
371 /**
372  * @tc.name: GetNetFirewallPolicy001
373  * @tc.desc: Test NetFirewallServiceTest GetNetFirewallPolicy.
374  * @tc.type: FUNC
375  */
376 HWTEST_F(NetFirewallServiceTest, GetNetFirewallPolicy001, TestSize.Level1)
377 {
378     int32_t userId = USER_ID1;
379     sptr<NetFirewallPolicy> status = new (std::nothrow) NetFirewallPolicy;
380     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->GetNetFirewallPolicy(userId, status);
381     EXPECT_EQ(ret, FIREWALL_SUCCESS);
382     EXPECT_FALSE(status->isOpen);
383     userId = USER_ID2;
384     ret = DelayedSingleton<NetFirewallService>::GetInstance()->GetNetFirewallPolicy(userId, status);
385     EXPECT_EQ(ret, FIREWALL_ERR_NO_USER);
386 }
387 
388 /**
389  * @tc.name: AddNetFirewallRule001
390  * @tc.desc: Test NetFirewallServiceTest AddNetFirewallRule.
391  * @tc.type: FUNC
392  */
393 HWTEST_F(NetFirewallServiceTest, AddNetFirewallRule001, TestSize.Level1)
394 {
395     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr();
396     int32_t ruleId = 0;
397     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->AddNetFirewallRule(rule, ruleId);
398     g_rowId = ruleId;
399     EXPECT_EQ(ret, FIREWALL_SUCCESS);
400 }
401 
402 /**
403  * @tc.name: DeleteNetFirewallRuleByAppId001
404  * @tc.desc: Test NetFirewallServiceTest DeleteNetFirewallRuleByAppId.
405  * @tc.type: FUNC
406  */
407 HWTEST_F(NetFirewallServiceTest, DeleteNetFirewallRuleByAppId001, TestSize.Level1)
408 {
409     NETMGR_EXT_LOG_I("delete appid id = %{public}d ", APPID_TEST01);
410     int ret = NetFirewallRuleManager::GetInstance().DeleteNetFirewallRuleByAppId(APPID_TEST01);
411     EXPECT_EQ(ret, FIREWALL_SUCCESS);
412 }
413 
414 
415 /**
416  * @tc.name: AddNetFirewallRule002
417  * @tc.desc: Test NetFirewallServiceTest AddNetFirewallRule.
418  * @tc.type: FUNC
419  */
420 HWTEST_F(NetFirewallServiceTest, AddNetFirewallRule002, TestSize.Level1)
421 {
422     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr();
423     int32_t ruleId = 0;
424     rule->userId = 102;
425     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->AddNetFirewallRule(rule, ruleId);
426     NETMGR_EXT_LOG_I("db row id = %{public}d ", ruleId);
427     g_rowId = ruleId;
428     EXPECT_EQ(ret, FIREWALL_ERR_NO_USER);
429 }
430 
431 /**
432  * @tc.name: AddNetFirewallRule003
433  * @tc.desc: Test NetFirewallServiceTest AddNetFirewallRule.
434  * @tc.type: FUNC
435  */
436 HWTEST_F(NetFirewallServiceTest, AddNetFirewallRule003, TestSize.Level1)
437 {
438     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr();
439     int32_t ruleId = 0;
440     int ret = 0;
441     int userId = instance_->GetCurrentAccountId();
442 
443     ret = instance_->OnInit();
444 
445     ret = instance_->AddDefaultNetFirewallRule(instance_->GetCurrentAccountId());
446 
447     rule->userId = userId;
448     uint64_t startTime = 0;
449     uint64_t endTime = 0;
450     for (int i = 0; i < MAX_USER_RULE; i++) {
451         startTime = GetCurrentMilliseconds();
452         rule->ruleName = "ruleTest_" + std::to_string(i + 1);
453         ret = DelayedSingleton<NetFirewallService>::GetInstance()->AddNetFirewallRule(rule, ruleId);
454         endTime = GetCurrentMilliseconds();
455         if (ret != FIREWALL_SUCCESS) {
456             std::cout << "add user " << userId << " to db row failed! error code = " << ret << std::endl;
457             break;
458         }
459         std::cout << "add user " << userId << " to db row id " << ruleId << ", use time : " << endTime - startTime <<
460             std::endl;
461         g_rowId = ruleId;
462     }
463 
464     EXPECT_EQ(ret, FIREWALL_SUCCESS);
465 }
466 
467 /**
468  * @tc.name: AddNetFirewallRule004
469  * @tc.desc: Test NetFirewallServiceTest AddNetFirewallRule.
470  * @tc.type: FUNC
471  */
472 HWTEST_F(NetFirewallServiceTest, AddNetFirewallRule004, TestSize.Level1)
473 {
474     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr();
475     int32_t ruleId = 0;
476     int userId = instance_->GetCurrentAccountId();
477     rule->userId = ++userId;
478     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->AddNetFirewallRule(rule, ruleId);
479     NETMGR_EXT_LOG_I("db row id = %{public}d ", ruleId);
480     if (ruleId > 0) {
481         g_rowId = ruleId;
482     }
483     EXPECT_EQ(ret, FIREWALL_ERR_NO_USER);
484 }
485 
486 /**
487  * @tc.name: AddNetFirewallRule005
488  * @tc.desc: Test NetFirewallServiceTest AddNetFirewallRule.
489  * @tc.type: FUNC
490  */
491 HWTEST_F(NetFirewallServiceTest, AddNetFirewallRule005, TestSize.Level1)
492 {
493     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptrTypeDns();
494     int32_t ruleId = 0;
495     int userId = instance_->GetCurrentAccountId();
496     rule->userId = ++userId;
497     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->AddNetFirewallRule(rule, ruleId);
498     NETMGR_EXT_LOG_I("db row id = %{public}d ", ruleId);
499     if (ruleId > 0) {
500         g_rowId = ruleId;
501     }
502     EXPECT_EQ(ret, FIREWALL_ERR_NO_USER);
503 }
504 
505 /**
506  * @tc.name: UpdateNetFirewallRule001
507  * @tc.desc: Test NetFirewallServiceTest UpdateNetFirewallRule.
508  * @tc.type: FUNC
509  */
510 HWTEST_F(NetFirewallServiceTest, UpdateNetFirewallRule001, TestSize.Level1)
511 {
512     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr();
513     rule->userId = USER_ID1;
514     rule->ruleId = g_rowId;
515     NETMGR_EXT_LOG_I("update row id = %{public}d ", g_rowId);
516     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->UpdateNetFirewallRule(rule);
517     EXPECT_EQ(ret, FIREWALL_SUCCESS);
518 }
519 
520 /**
521  * @tc.name: UpdateNetFirewallRule002
522  * @tc.desc: Test NetFirewallServiceTest UpdateNetFirewallRule.
523  * @tc.type: FUNC
524  */
525 HWTEST_F(NetFirewallServiceTest, UpdateNetFirewallRule002, TestSize.Level1)
526 {
527     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptrTypeDns();
528     rule->userId = USER_ID1;
529     rule->ruleId = g_rowId;
530     NETMGR_EXT_LOG_I("update row id = %{public}d ", g_rowId);
531     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->UpdateNetFirewallRule(rule);
532     EXPECT_EQ(ret, FIREWALL_SUCCESS);
533 }
534 
535 /**
536  * @tc.name: DeleteNetFirewallRule001
537  * @tc.desc: Test NetFirewallServiceTest DeleteNetFirewallRule.
538  * @tc.type: FUNC
539  */
540 HWTEST_F(NetFirewallServiceTest, DeleteNetFirewallRule001, TestSize.Level1)
541 {
542     int32_t ruleId = g_rowId;
543     NETMGR_EXT_LOG_I("delete row id = %{public}d ", g_rowId);
544     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->DeleteNetFirewallRule(USER_ID1, ruleId);
545     EXPECT_EQ(ret, FIREWALL_SUCCESS);
546 }
547 
548 /**
549  * @tc.name: GetAllNetFirewallRule001
550  * @tc.desc: Test NetFirewallServiceTest GetNetFirewallRules.
551  * @tc.type: FUNC
552  */
553 HWTEST_F(NetFirewallServiceTest, GetAllNetFirewallRule001, TestSize.Level1)
554 {
555     int32_t userId = USER_ID1;
556     sptr<RequestParam> param = new (std::nothrow) RequestParam();
557     param->page = 0;
558     param->pageSize = 5;
559     param->orderType = NetFirewallOrderType::ORDER_ASC;
560     param->orderField = NetFirewallOrderField::ORDER_BY_RULE_NAME;
561     sptr<FirewallRulePage> info = new (std::nothrow) FirewallRulePage();
562     uint64_t startTime = GetCurrentMilliseconds();
563     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->GetNetFirewallRules(userId, param, info);
564     uint64_t endTime = GetCurrentMilliseconds();
565     std::cout << "GetNetFirewallRules " << userId << "running time : " << endTime - startTime << std::endl;
566     EXPECT_EQ(ret, FIREWALL_SUCCESS);
567 }
568 
569 /**
570  * @tc.name: GetAllNetFirewallRule002
571  * @tc.desc: Test NetFirewallServiceTest GetNetFirewallRules.
572  * @tc.type: FUNC
573  */
574 HWTEST_F(NetFirewallServiceTest, GetAllNetFirewallRule002, TestSize.Level1)
575 {
576     int32_t userId = 102;
577     sptr<RequestParam> param = new (std::nothrow) RequestParam();
578     param->page = 0;
579     param->pageSize = 5;
580     param->orderType = NetFirewallOrderType::ORDER_ASC;
581     param->orderField = NetFirewallOrderField::ORDER_BY_RULE_NAME;
582     sptr<FirewallRulePage> info = new (std::nothrow) FirewallRulePage();
583     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->GetNetFirewallRules(userId, param, info);
584 
585     EXPECT_EQ(ret, FIREWALL_ERR_NO_USER);
586 }
587 
588 /**
589  * @tc.name: GetNetFirewallRule001
590  * @tc.desc: Test NetFirewallServiceTest GetNetFirewallRule.
591  * @tc.type: FUNC
592  */
593 HWTEST_F(NetFirewallServiceTest, GetNetFirewallRule001, TestSize.Level1)
594 {
595     int32_t ruleId = 1;
596     int32_t userId = USER_ID1;
597     NetFirewallRuleManager::GetInstance().GetAllRuleConstraint(userId);
598     ruleId = NetFirewallRuleManager::GetInstance().allUserRule_;
599     uint64_t startTime = GetCurrentMilliseconds();
600     sptr<NetFirewallRule> rule = new (std::nothrow) NetFirewallRule();
601     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->GetNetFirewallRule(userId, ruleId, rule);
602     uint64_t endTime = GetCurrentMilliseconds();
603     std::cout << "GetNetFirewallRule " << userId << "running time : " << endTime - startTime << std::endl;
604 
605     if (rule->ruleId == 0) {
606         EXPECT_EQ(ret, FIREWALL_ERR_NO_RULE);
607     } else {
608         EXPECT_EQ(ret, FIREWALL_SUCCESS);
609     }
610 }
611 
612 /**
613  * @tc.name: OnInit002
614  * @tc.desc: Test NetFirewallServiceTest OnInit.
615  * @tc.type: FUNC
616  */
617 HWTEST_F(NetFirewallServiceTest, OnInit002, TestSize.Level1)
618 {
619     int32_t ret = instance_->OnInit();
620     EXPECT_EQ(ret, FIREWALL_SUCCESS);
621 }
622 
623 /**
624  * @tc.name: OnReceiveEvent
625  * @tc.desc: Test NetFirewallServiceTest OnReceiveEvent.
626  * @tc.type: FUNC
627  */
628 HWTEST_F(NetFirewallServiceTest, OnReceiveEvent, TestSize.Level1)
629 {
630     int32_t ret = PublishChangedEvent(EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED, USER_ID1);
631     EXPECT_EQ(ret, true);
632     Want want;
633     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
634     want.SetParam(AppExecFwk::Constants::UID, -1);
635     CommonEventData data;
636     data.SetWant(want);
637     data.SetCode(USER_ID1);
638     if (instance_->subscriber_ != nullptr) {
639         instance_->subscriber_->OnReceiveEvent(data);
640     }
641     ret = PublishChangedEvent(EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED, USER_ID2);
642     EXPECT_EQ(ret, true);
643     ret = PublishChangedEvent(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED, USER_ID1);
644 
645     EXPECT_EQ(ret, true);
646 }
647 
PublishChangedEvent(const std::string & action,int32_t code) const648 bool NetFirewallServiceTest::PublishChangedEvent(const std::string &action, int32_t code) const
649 {
650     Want want;
651     want.SetAction(action);
652     want.SetParam(AppExecFwk::Constants::UID, USER_ID1);
653     CommonEventData data;
654     data.SetWant(want);
655     data.SetCode(code);
656     if (instance_->subscriber_ != nullptr) {
657         instance_->subscriber_->OnReceiveEvent(data);
658     }
659     return true;
660 }
661 
662 /**
663  * @tc.name: OnIntercept
664  * @tc.desc: Test NetFirewallServiceTest OnIntercept.
665  * @tc.type: FUNC
666  */
667 HWTEST_F(NetFirewallServiceTest, OnIntercept, TestSize.Level1)
668 {
669     sptr<InterceptRecord> record = (std::make_unique<InterceptRecord>()).release();
670     const uint32_t time = 10025152;
671     const uint16_t sourcePort = 10000;
672     const uint16_t destPort = 20000;
673     const uint32_t uid = 10085;
674     record->time = time;
675     record->localIp = "192.168.1.2";
676     record->remoteIp = "192.168.1.3";
677     record->localPort = sourcePort;
678     record->remotePort = destPort;
679     record->protocol = 1;
680     record->appUid = uid;
681     NetFirewallInterceptRecorder::GetInstance()->RegisterInterceptCallback();
682     int32_t ret = NetFirewallInterceptRecorder::GetInstance()->callback_->OnIntercept(record);
683     NetFirewallInterceptRecorder::GetInstance()->UnRegisterInterceptCallback();
684     EXPECT_EQ(ret, FIREWALL_SUCCESS);
685 }
686 
687 /**
688  * @tc.name: GetInterceptRecord001
689  * @tc.desc: Test NetFirewallServiceTest GetInterceptRecords.
690  * @tc.type: FUNC
691  */
692 HWTEST_F(NetFirewallServiceTest, GetInterceptRecord001, TestSize.Level1)
693 {
694     sptr<RequestParam> param = new (std::nothrow) RequestParam();
695     param->page = 0;
696     param->pageSize = 5;
697     param->orderType = NetFirewallOrderType::ORDER_ASC;
698     param->orderField = NetFirewallOrderField::ORDER_BY_RECORD_TIME;
699     sptr<InterceptRecordPage> info = new (std::nothrow) InterceptRecordPage();
700     int32_t userId = instance_->GetCurrentAccountId();
701     int ret = instance_->GetInterceptRecords(userId, param, info);
702     EXPECT_EQ(ret, FIREWALL_SUCCESS);
703     userId += 1;
704     ret = instance_->GetInterceptRecords(userId, param, info);
705     EXPECT_EQ(ret, FIREWALL_ERR_NO_USER);
706 }
707 
708 /**
709  * @tc.name: OnCreate
710  * @tc.desc: Test NetFirewallServiceTest OnCreate001.
711  * @tc.type: FUNC
712  */
713 HWTEST_F(NetFirewallServiceTest, OnCreate001, TestSize.Level1)
714 {
715     auto dbCallBack = new (std::nothrow) NetFirewallDataBaseCallBack();
716     std::string firewallDatabaseName = FIREWALL_DB_PATH + FIREWALL_DB_NAME;
717     int32_t errCode = OHOS::NativeRdb::E_OK;
718     OHOS::NativeRdb::RdbStoreConfig config(firewallDatabaseName);
719     config.SetSecurityLevel(NativeRdb::SecurityLevel::S1);
720     NetFirewallDataBaseCallBack sqliteOpenHelperCallback;
721     std::shared_ptr<OHOS::NativeRdb::RdbStore> store_ =
722         OHOS::NativeRdb::RdbHelper::GetRdbStore(config, OLD_VERSION, sqliteOpenHelperCallback, errCode);
723     int32_t ret = dbCallBack->OnCreate(*(store_));
724     EXPECT_EQ(ret, FIREWALL_SUCCESS);
725 }
726 
727 /**
728  * @tc.name: OnUpgrade
729  * @tc.desc: Test NetFirewallServiceTest OnUpgrade001.
730  * @tc.type: FUNC
731  */
732 HWTEST_F(NetFirewallServiceTest, OnUpgrade001, TestSize.Level1)
733 {
734     auto dbCallBack = new (std::nothrow) NetFirewallDataBaseCallBack();
735     std::string firewallDatabaseName = FIREWALL_DB_PATH + FIREWALL_DB_NAME;
736     int32_t errCode = OHOS::NativeRdb::E_OK;
737     OHOS::NativeRdb::RdbStoreConfig config(firewallDatabaseName);
738     config.SetSecurityLevel(NativeRdb::SecurityLevel::S1);
739     NetFirewallDataBaseCallBack sqliteOpenHelperCallback;
740     std::shared_ptr<OHOS::NativeRdb::RdbStore> store_ =
741         OHOS::NativeRdb::RdbHelper::GetRdbStore(config, NEW_VERSION, sqliteOpenHelperCallback, errCode);
742     int32_t ret = dbCallBack->OnUpgrade(*(store_), OLD_VERSION, NEW_VERSION);
743     EXPECT_EQ(ret, FIREWALL_SUCCESS);
744 }
745 
746 /**
747  * @tc.name: OnDowngrade
748  * @tc.desc: Test NetFirewallServiceTest OnDowngrade001.
749  * @tc.type: FUNC
750  */
751 HWTEST_F(NetFirewallServiceTest, OnDowngrade001, TestSize.Level1)
752 {
753     auto dbCallBack = new (std::nothrow) NetFirewallDataBaseCallBack();
754     std::string firewallDatabaseName = FIREWALL_DB_PATH + FIREWALL_DB_NAME;
755     int32_t errCode = OHOS::NativeRdb::E_OK;
756     OHOS::NativeRdb::RdbStoreConfig config(firewallDatabaseName);
757     config.SetSecurityLevel(NativeRdb::SecurityLevel::S1);
758     NetFirewallDataBaseCallBack sqliteOpenHelperCallback;
759     std::shared_ptr<OHOS::NativeRdb::RdbStore> store_ =
760         OHOS::NativeRdb::RdbHelper::GetRdbStore(config, NEW_VERSION, sqliteOpenHelperCallback, errCode);
761     int32_t ret = dbCallBack->OnDowngrade(*(store_), OLD_VERSION, NEW_VERSION);
762     EXPECT_EQ(ret, FIREWALL_SUCCESS);
763 }
764 
765 /**
766  * @tc.name: RollBack
767  * @tc.desc: Test NetFirewallServiceTest RollBack001.
768  * @tc.type: FUNC
769  */
770 HWTEST_F(NetFirewallServiceTest, RollBack001, TestSize.Level1)
771 {
772     auto dbInstance_ = NetFirewallDataBase::GetInstance();
773     int32_t ret = dbInstance_->RollBack();
774     EXPECT_EQ(ret != FIREWALL_SUCCESS, true);
775 }
776 
777 /**
778  * @tc.name: QueryEnabledFirewallRules
779  * @tc.desc: Test NetFirewallDbHelper QueryEnabledFirewallRules001.
780  * @tc.type: FUNC
781  */
782 HWTEST_F(NetFirewallServiceTest, QueryEnabledFirewallRules001, TestSize.Level1)
783 {
784     std::vector<NetFirewallRule> rules;
785     int32_t userId = USER_ID1;
786     int32_t appUip = APPID_TEST01;
787     int32_t ret = NetFirewallDbHelper::GetInstance().QueryEnabledFirewallRules(userId, appUip, rules);
788     EXPECT_EQ(ret, FIREWALL_SUCCESS);
789 }
790 
791 /**
792  * @tc.name: ConvertIpParamToConfig
793  * @tc.desc: Test NetFirewallDefaultRuleParser ConvertIpParamToConfig001.
794  * @tc.type: FUNC
795  */
796 HWTEST_F(NetFirewallServiceTest, ConvertIpParamToConfig001, TestSize.Level1)
797 {
798     NetFirewallIpParam rule;
799     std::string jsonString = "\"family\": 1,\"type\": 1,\"address\": \"192.168.1.2\",\"mask\": 32,\"startIp\": "
800         "\"192.168.1.1\",\"endIp\": \"192.168.1.255\"";
801     cJSON *mem = cJSON_Parse(jsonString.c_str());
802     NetFirewallDefaultRuleParser::ConvertIpParamToConfig(rule, mem);
803 }
804 
805 /**
806  * @tc.name: ConvertDomainParamToConfig
807  * @tc.desc: Test NetFirewallDefaultRuleParser ConvertDomainParamToConfig001.
808  * @tc.type: FUNC
809  */
810 HWTEST_F(NetFirewallServiceTest, ConvertDomainParamToConfig001, TestSize.Level1)
811 {
812     NetFirewallDomainParam rule;
813     std::string jsonString = "\"isWildcard\": false,\"domain\": \"www.openharmony.cn\"";
814     cJSON *mem = cJSON_Parse(jsonString.c_str());
815     NetFirewallDefaultRuleParser::ConvertDomainParamToConfig(rule, mem);
816 }
817 
818 /**
819  * @tc.name: ConvertDnsParamToConfig
820  * @tc.desc: Test NetFirewallDefaultRuleParser ConvertDnsParamToConfig001.
821  * @tc.type: FUNC
822  */
823 HWTEST_F(NetFirewallServiceTest, ConvertDnsParamToConfig001, TestSize.Level1)
824 {
825     NetFirewallDnsParam rule;
826     std::string jsonString = "\"primaryDns\": \"192.168.1.1\",\"standbyDns\": \"192.168.1.1\"";
827     cJSON *mem = cJSON_Parse(jsonString.c_str());
828     NetFirewallDefaultRuleParser::ConvertDnsParamToConfig(rule, mem);
829 }
830 
831 /**
832  * @tc.name: QueryAllFirewallRuleRecord
833  * @tc.desc: Test NetFirewallDbHelper QueryAllFirewallRuleRecord001.
834  * @tc.type: FUNC
835  */
836 HWTEST_F(NetFirewallServiceTest, QueryAllFirewallRuleRecord001, TestSize.Level1)
837 {
838     std::vector<NetFirewallRule> rules;
839     int32_t ret = NetFirewallDbHelper::GetInstance().QueryAllFirewallRuleRecord(rules);
840     EXPECT_EQ(ret, FIREWALL_SUCCESS);
841     EXPECT_GT(rules.size(), 0);
842 }
843 
844 /**
845  * @tc.name: SendInitDefaultRequestReport
846  * @tc.desc: Test NetFirewallDbHelper SendInitDefaultRequestReport001.
847  * @tc.type: FUNC
848  */
849 HWTEST_F(NetFirewallServiceTest, SendInitDefaultRequestReport001, TestSize.Level1)
850 {
851     int32_t errorCode = 0;
852     NetFirewallHisysEvent::SendInitDefaultRequestReport(USER_ID1, errorCode);
853     EXPECT_TRUE(true);
854 }
855 
856 /**
857  * @tc.name: SendNetFirewallRuleFault
858  * @tc.desc: Test NetFirewallDbHelper SendNetFirewallRuleFault001.
859  * @tc.type: FUNC
860  */
861 HWTEST_F(NetFirewallServiceTest, SendNetFirewallRuleFault001, TestSize.Level1)
862 {
863     int32_t errorCode = 0;
864     NetFirewallEvent event;
865     event.userId = USER_ID1;
866     event.errorType = errorCode;
867     std::string eventName = "eventName";
868     auto _netFileHisysEvent = NetFirewallHisysEvent::GetInstance();
869     _netFileHisysEvent.SendNetFirewallRuleFault(event, eventName);
870     EXPECT_TRUE(true);
871 }
872 
873 /**
874  * @tc.name: SendNetFirewallFault
875  * @tc.desc: Test NetFirewallDbHelper SendNetFirewallFault001.
876  * @tc.type: FUNC
877  */
878 HWTEST_F(NetFirewallServiceTest, SendNetFirewallFault001, TestSize.Level1)
879 {
880     int32_t errorCode = 0;
881     std::string eventName = "eventName";
882     NetFirewallEvent event;
883     event.userId = USER_ID1;
884     event.errorType = errorCode;
885     auto _netFileHisysEvent = NetFirewallHisysEvent::GetInstance();
886     _netFileHisysEvent.SendNetFirewallFault(event, eventName);
887     EXPECT_TRUE(true);
888 }
889 
890 /**
891  * @tc.name: GetCurrentNetFirewallPolicy
892  * @tc.desc: Test NetFirewallDbHelper GetCurrentNetFirewallPolicy001.
893  * @tc.type: FUNC
894  */
895 HWTEST_F(NetFirewallServiceTest, GetCurrentNetFirewallPolicy001, TestSize.Level1)
896 {
897     NetFirewallPolicyManager::GetInstance().currentUserId_ = USER_ID1;
898 
899     sptr<NetFirewallPolicy> policy = new (std::nothrow) NetFirewallPolicy();
900     policy->isOpen = true;
901     policy->inAction = (FirewallRuleAction)(1);
902     policy->outAction = FirewallRuleAction::RULE_ALLOW;
903     NetFirewallPolicyManager::GetInstance().SetCurrentUserFirewallPolicy(policy);
904 
905     int ret = NetFirewallPolicyManager::GetInstance().GetCurrentNetFirewallPolicy(policy);
906     EXPECT_EQ(ret, 0);
907 }
908 
909 /**
910  * @tc.name: SetFirewallDnsRules
911  * @tc.desc: Test NetFirewallDbHelper SetFirewallDnsRules001.
912  * @tc.type: FUNC
913  */
914 HWTEST_F(NetFirewallServiceTest, SetFirewallDnsRules001, TestSize.Level1)
915 {
916     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr();
917     int32_t ruleId = 1;
918     int ret = DelayedSingleton<NetFirewallService>::GetInstance()->AddNetFirewallRule(rule, ruleId);
919     g_rowId = ruleId;
920     EXPECT_EQ(ret, FIREWALL_SUCCESS);
921     ret = NetFirewallRuleManager::GetInstance().SetRulesToNativeByType(USER_ID1, NetFirewallRuleType::RULE_DNS);
922     EXPECT_EQ(ret, FIREWALL_SUCCESS);
923 }
924 
925 HWTEST_F(NetFirewallServiceTest, GetLastRulePushTime001, TestSize.Level1)
926 {
927     NetFirewallRuleManager::GetInstance().currentSetRuleSecond_ = 0;
928     std::string ret = DelayedSingleton<NetFirewallService>::GetInstance()->GetLastRulePushTime();
929     EXPECT_EQ(ret, "Unkonw");
930     NetFirewallRuleManager::GetInstance().SetNetFirewallDumpMessage(FIREWALL_SUCCESS);
931     ret = DelayedSingleton<NetFirewallService>::GetInstance()->GetLastRulePushTime();
932     EXPECT_NE(ret, "Unkonw");
933 }
934 
935 HWTEST_F(NetFirewallServiceTest, GetLastRulePushResult001, TestSize.Level1)
936 {
937     NetFirewallRuleManager::GetInstance().SetNetFirewallDumpMessage(1);
938     std::string ret = DelayedSingleton<NetFirewallService>::GetInstance()->GetLastRulePushResult();
939     EXPECT_EQ(ret, "Faild");
940     NetFirewallRuleManager::GetInstance().SetNetFirewallDumpMessage(-1);
941     ret = DelayedSingleton<NetFirewallService>::GetInstance()->GetLastRulePushResult();
942     EXPECT_EQ(ret, "Unkonw");
943 }
944 } // namespace NetManagerStandard
945 } // namespace OHOS
946