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 <arpa/inet.h>
17 #include <gtest/gtest.h>
18 
19 #ifdef GTEST_API_
20 #define private public
21 #define protected public
22 #endif
23 
24 #include "mock_netfirewall_service_stub_test.h"
25 #include "net_manager_constants.h"
26 #include "netmanager_ext_test_security.h"
27 #include "netfirewall_common.h"
28 #include "netfirewall_stub.h"
29 
30 namespace OHOS {
31 namespace NetManagerStandard {
32 namespace {
33 constexpr int32_t USER_ID = 100;
34 constexpr int32_t TEST_INT32_NUMBER = 1;
35 
36 using namespace testing::ext;
37 
GetIpList(uint8_t num=1)38 std::vector<NetFirewallIpParam> GetIpList(uint8_t num = 1)
39 {
40     const uint8_t mask = 24;
41     const int32_t gap = 10;
42     const int32_t hexWidth = 4;
43     std::vector<NetFirewallIpParam> localParamList;
44     NetFirewallIpParam localParam;
45     localParam.family = FAMILY_IPV4;
46     localParam.type = SINGLE_IP;
47     std::string ip;
48     std::stringstream ss;
49     const std::string addressStart = "192.168.1.";
50     for (int32_t i = 0; i < num; i++) {
51         ss.str("");
52         ss.clear();
53         ss << addressStart << (i * gap);
54         inet_pton(AF_INET, ss.str().c_str(), &localParam.ipv4.startIp);
55         localParam.mask = mask;
56         localParamList.emplace_back(std::move(localParam));
57     }
58     return localParamList;
59 }
60 
GetPortList(uint8_t num=0)61 std::vector<NetFirewallPortParam> GetPortList(uint8_t num = 0)
62 {
63     const int32_t offset = 20;
64     const uint16_t localStartPort = 10020;
65     std::vector<NetFirewallPortParam> localPortParamList;
66     NetFirewallPortParam localPortParam;
67     localPortParam.startPort = localStartPort;
68     localPortParam.endPort = localStartPort;
69     for (int32_t i = 0; i < num; i++) {
70         localPortParamList.emplace_back(std::move(localPortParam));
71         localPortParam.startPort += offset;
72         localPortParam.endPort += offset;
73     }
74     return localPortParamList;
75 }
76 
77 
GetNetFirewallRuleSptr(NetFirewallRuleType type,uint8_t number,uint8_t portNum=0)78 sptr<NetFirewallRule> GetNetFirewallRuleSptr(NetFirewallRuleType type, uint8_t number, uint8_t portNum = 0)
79 {
80     sptr<NetFirewallRule> rule = (std::make_unique<NetFirewallRule>()).release();
81     if (!rule) {
82         return rule;
83     }
84     rule->ruleId = 1;
85     rule->userId = USER_ID;
86     rule->ruleName = "testRule";
87     rule->ruleDescription = "testRuleDes";
88     rule->ruleDirection = NetFirewallRuleDirection::RULE_OUT;
89     rule->ruleAction = FirewallRuleAction::RULE_ALLOW;
90     rule->ruleType = type;
91     rule->isEnabled = true;
92     rule->appUid = 0;
93     switch (type) {
94         case NetFirewallRuleType::RULE_IP: {
95             rule->localIps = GetIpList(number);
96             rule->localPorts = GetPortList(portNum);
97             break;
98         }
99         case NetFirewallRuleType::RULE_DOMAIN: {
100             std::vector<NetFirewallDomainParam> domainList;
101             NetFirewallDomainParam domain;
102             domain.isWildcard = false;
103             const std::string tmp = "www.openharmony.cn";
104             for (int32_t i = 0; i < number; i++) {
105                 domain.domain = tmp + std::to_string(i);
106                 domainList.emplace_back(domain);
107             }
108             rule->domains = domainList;
109             break;
110         }
111         default:
112             break;
113     }
114 
115     return rule;
116 }
117 }
118 class NetFirewallServiceStubTest : public testing::Test {
119 public:
120     static void SetUpTestCase();
121     static void TearDownTestCase();
122     void SetUp();
123     void TearDown();
124     static inline std::shared_ptr<NetFirewallStub> instance_ = std::make_shared<MockNetFirewallServiceStub>();
125     static int32_t SendRemoteRequest(MessageParcel &data, int32_t code);
126 };
127 
SetUpTestCase()128 void NetFirewallServiceStubTest::SetUpTestCase() {}
129 
TearDownTestCase()130 void NetFirewallServiceStubTest::TearDownTestCase() {}
131 
SetUp()132 void NetFirewallServiceStubTest::SetUp() {}
133 
TearDown()134 void NetFirewallServiceStubTest::TearDown() {}
135 
SendRemoteRequest(MessageParcel & data,int32_t code)136 int32_t NetFirewallServiceStubTest::SendRemoteRequest(MessageParcel &data, int32_t code)
137 {
138     MessageParcel reply;
139     MessageOption option;
140     return instance_->OnRemoteRequest(static_cast<uint32_t>(code), data, reply, option);
141 }
142 
143 HWTEST_F(NetFirewallServiceStubTest, SetNetFirewallPolicy001, TestSize.Level1)
144 {
145     NetManagerExtAccessToken token;
146     MessageParcel data;
147     if (!data.WriteInterfaceToken(NetFirewallStub::GetDescriptor())) {
148         return;
149     }
150 
151     if (!data.WriteInt32(TEST_INT32_NUMBER)) {
152         return;
153     }
154 
155     sptr<NetFirewallPolicy> status = new (std::nothrow) NetFirewallPolicy();
156     EXPECT_TRUE(status != nullptr);
157     if (status == nullptr) {
158         return;
159     }
160 
161     if (!status->Marshalling(data)) {
162         return;
163     }
164 
165     int32_t ret = SendRemoteRequest(data, (INetFirewallService::SET_NET_FIREWALL_STATUS));
166     EXPECT_EQ(ret, FIREWALL_SUCCESS);
167 }
168 
169 HWTEST_F(NetFirewallServiceStubTest, GetNetFirewallPolicy001, TestSize.Level1)
170 {
171     NetManagerExtAccessToken token;
172     MessageParcel data;
173     if (!data.WriteInterfaceToken(NetFirewallStub::GetDescriptor())) {
174         return;
175     }
176 
177     if (!data.WriteInt32(TEST_INT32_NUMBER)) {
178         return;
179     }
180 
181     sptr<NetFirewallPolicy> status = new (std::nothrow) NetFirewallPolicy();
182     EXPECT_TRUE(status != nullptr);
183     if (status == nullptr) {
184         return;
185     }
186 
187     if (!status->Marshalling(data)) {
188         return;
189     }
190 
191     int32_t ret = SendRemoteRequest(data, (INetFirewallService::GET_NET_FIREWALL_STATUS));
192     EXPECT_EQ(ret, FIREWALL_SUCCESS);
193 }
194 
195 HWTEST_F(NetFirewallServiceStubTest, AddNetFirewallRule001, TestSize.Level1)
196 {
197     NetManagerExtAccessToken token;
198     MessageParcel data;
199     if (!data.WriteInterfaceToken(NetFirewallStub::GetDescriptor())) {
200         return;
201     }
202 
203     sptr<NetFirewallRule> status = new (std::nothrow) NetFirewallRule();
204     EXPECT_TRUE(status != nullptr);
205     if (status == nullptr) {
206         return;
207     }
208 
209     if (!status->Marshalling(data)) {
210         return;
211     }
212 
213     int32_t ret = SendRemoteRequest(data, (INetFirewallService::ADD_NET_FIREWALL_RULE));
214     EXPECT_EQ(ret, FIREWALL_SUCCESS);
215 }
216 
217 HWTEST_F(NetFirewallServiceStubTest, UpdateNetFirewallRule001, TestSize.Level1)
218 {
219     NetManagerExtAccessToken token;
220     MessageParcel data;
221     if (!data.WriteInterfaceToken(NetFirewallStub::GetDescriptor())) {
222         return;
223     }
224 
225     sptr<NetFirewallRule> status = new (std::nothrow) NetFirewallRule();
226     EXPECT_TRUE(status != nullptr);
227     if (status == nullptr) {
228         return;
229     }
230 
231     if (!status->Marshalling(data)) {
232         return;
233     }
234 
235     int32_t ret = SendRemoteRequest(data, (INetFirewallService::UPDATE_NET_FIREWALL_RULE));
236     EXPECT_EQ(ret, FIREWALL_SUCCESS);
237 }
238 
239 HWTEST_F(NetFirewallServiceStubTest, DeleteNetFirewallRule001, TestSize.Level1)
240 {
241     NetManagerExtAccessToken token;
242     MessageParcel data;
243     if (!data.WriteInterfaceToken(NetFirewallStub::GetDescriptor())) {
244         return;
245     }
246 
247     if (!data.WriteInt32(USER_ID)) {
248         return;
249     }
250 
251     if (!data.WriteInt32(TEST_INT32_NUMBER)) {
252         return;
253     }
254 
255     int32_t ret = SendRemoteRequest(data, (INetFirewallService::DELETE_NET_FIREWALL_RULE));
256     EXPECT_EQ(ret, FIREWALL_SUCCESS);
257 }
258 
259 HWTEST_F(NetFirewallServiceStubTest, GetAllNetFirewallRule001, TestSize.Level1)
260 {
261     NetManagerExtAccessToken token;
262     MessageParcel data;
263     if (!data.WriteInterfaceToken(NetFirewallStub::GetDescriptor())) {
264         return;
265     }
266 
267     if (!data.WriteInt32(TEST_INT32_NUMBER)) {
268         return;
269     }
270     sptr<RequestParam> param = new (std::nothrow) RequestParam();
271     param->page = 0;
272     param->pageSize = 5;
273     param->orderType = NetFirewallOrderType::ORDER_ASC;
274     if (!param->Marshalling(data)) {
275         return;
276     }
277     int32_t ret = SendRemoteRequest(data, INetFirewallService::GET_ALL_NET_FIREWALL_RULES);
278     EXPECT_EQ(ret, FIREWALL_SUCCESS);
279 }
280 
281 HWTEST_F(NetFirewallServiceStubTest, GetNetFirewallRule001, TestSize.Level1)
282 {
283     NetManagerExtAccessToken token;
284     MessageParcel data;
285     if (!data.WriteInterfaceToken(NetFirewallStub::GetDescriptor())) {
286         return;
287     }
288 
289     if (!data.WriteInt32(TEST_INT32_NUMBER)) {
290         return;
291     }
292 
293     if (!data.WriteInt32(TEST_INT32_NUMBER)) {
294         return;
295     }
296 
297     int32_t ret = SendRemoteRequest(data, (INetFirewallService::GET_NET_FIREWALL_RULE));
298     EXPECT_EQ(ret, FIREWALL_SUCCESS);
299 }
300 
301 HWTEST_F(NetFirewallServiceStubTest, GetInterceptRecord001, TestSize.Level1)
302 {
303     NetManagerExtAccessToken token;
304     MessageParcel data;
305     if (!data.WriteInterfaceToken(NetFirewallStub::GetDescriptor())) {
306         return;
307     }
308 
309     if (!data.WriteInt32(TEST_INT32_NUMBER)) {
310         return;
311     }
312 
313     sptr<RequestParam> param = new (std::nothrow) RequestParam();
314     param->page = 0;
315     param->pageSize = 5;
316     param->orderType = NetFirewallOrderType::ORDER_ASC;
317     if (!param->Marshalling(data)) {
318         NETMGR_EXT_LOG_E("proxy Marshalling failed");
319         return;
320     }
321     int32_t ret = SendRemoteRequest(data, INetFirewallService::GET_ALL_INTERCEPT_RECORDS);
322     EXPECT_EQ(ret, FIREWALL_SUCCESS);
323 }
324 
325 HWTEST_F(NetFirewallServiceStubTest, OnRemoteRequest001, TestSize.Level1)
326 {
327     NetManagerExtAccessToken token;
328     MessageParcel data;
329     if (!data.WriteInterfaceToken(NetFirewallStub::GetDescriptor())) {
330         return;
331     }
332     MessageParcel reply;
333     MessageOption option;
334     int32_t code = static_cast<uint32_t>(INetFirewallService::GET_ALL_INTERCEPT_RECORDS) + 1;
335     int32_t ret = instance_->OnRemoteRequest(code, data, reply, option);
336     EXPECT_EQ(ret, IPC_STUB_UNKNOW_TRANS_ERR);
337 }
338 
339 HWTEST_F(NetFirewallServiceStubTest, OnSetNetFirewallPolicy001, TestSize.Level1)
340 {
341     NetManagerExtAccessToken token;
342     MessageParcel data;
343     MessageParcel reply;
344     int32_t ret = instance_->OnSetNetFirewallPolicy(data, reply);
345     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_READ_DATA_FAIL);
346 
347     int32_t userId = USER_ID;
348     data.WriteInt32(userId);
349     ret = instance_->OnSetNetFirewallPolicy(data, reply);
350     EXPECT_EQ(ret, FIREWALL_ERR_INTERNAL);
351 }
352 
353 HWTEST_F(NetFirewallServiceStubTest, OnGetNetFirewallPolicy001, TestSize.Level1)
354 {
355     NetManagerExtAccessToken token;
356     MessageParcel data;
357     MessageParcel reply;
358     int32_t ret = instance_->OnGetNetFirewallPolicy(data, reply);
359     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_READ_DATA_FAIL);
360 }
361 
362 HWTEST_F(NetFirewallServiceStubTest, OnAddNetFirewallRule001, TestSize.Level1)
363 {
364     NetManagerExtAccessToken token;
365     MessageParcel data;
366     MessageParcel reply;
367     int32_t ret = instance_->OnAddNetFirewallRule(data, reply);
368     EXPECT_EQ(ret, FIREWALL_ERR_INTERNAL);
369 
370     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr(NetFirewallRuleType::RULE_IP, MAX_RULE_IP_COUNT + 1);
371     rule->Marshalling(data);
372     ret = instance_->OnAddNetFirewallRule(data, reply);
373     EXPECT_EQ(ret, FIREWALL_ERR_EXCEED_MAX_IP);
374 }
375 
376 HWTEST_F(NetFirewallServiceStubTest, OnAddNetFirewallRule002, TestSize.Level1)
377 {
378     NetManagerExtAccessToken token;
379     MessageParcel data;
380     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr(NetFirewallRuleType::RULE_IP, 1, MAX_RULE_PORT_COUNT + 1);
381     rule->Marshalling(data);
382     MessageParcel reply;
383     int32_t ret = instance_->OnAddNetFirewallRule(data, reply);
384     EXPECT_EQ(ret, FIREWALL_ERR_EXCEED_MAX_PORT);
385 }
386 
387 HWTEST_F(NetFirewallServiceStubTest, OnAddNetFirewallRule003, TestSize.Level1)
388 {
389     NetManagerExtAccessToken token;
390     MessageParcel data;
391     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr(NetFirewallRuleType::RULE_DOMAIN, MAX_RULE_DOMAIN_COUNT + 1);
392     rule->Marshalling(data);
393     MessageParcel reply;
394     int32_t ret = instance_->OnAddNetFirewallRule(data, reply);
395     EXPECT_EQ(ret, FIREWALL_ERR_EXCEED_MAX_DOMAIN);
396 }
397 
398 HWTEST_F(NetFirewallServiceStubTest, OnUpdateNetFirewallRule001, TestSize.Level1)
399 {
400     NetManagerExtAccessToken token;
401     MessageParcel data;
402     MessageParcel reply;
403     int32_t ret = instance_->OnUpdateNetFirewallRule(data, reply);
404     EXPECT_EQ(ret, FIREWALL_ERR_INTERNAL);
405 
406     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr(NetFirewallRuleType::RULE_IP, MAX_RULE_IP_COUNT + 1);
407     rule->Marshalling(data);
408     ret = instance_->OnUpdateNetFirewallRule(data, reply);
409     EXPECT_EQ(ret, FIREWALL_ERR_EXCEED_MAX_IP);
410 }
411 
412 HWTEST_F(NetFirewallServiceStubTest, OnUpdateNetFirewallRule002, TestSize.Level1)
413 {
414     NetManagerExtAccessToken token;
415     MessageParcel data;
416     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr(NetFirewallRuleType::RULE_IP, 1, MAX_RULE_PORT_COUNT + 1);
417     rule->Marshalling(data);
418     MessageParcel reply;
419     int32_t ret = instance_->OnUpdateNetFirewallRule(data, reply);
420     EXPECT_EQ(ret, FIREWALL_ERR_EXCEED_MAX_PORT);
421 }
422 
423 HWTEST_F(NetFirewallServiceStubTest, OnUpdateNetFirewallRule003, TestSize.Level1)
424 {
425     NetManagerExtAccessToken token;
426     MessageParcel data;
427     sptr<NetFirewallRule> rule = GetNetFirewallRuleSptr(NetFirewallRuleType::RULE_DOMAIN, MAX_RULE_DOMAIN_COUNT + 1);
428     rule->Marshalling(data);
429     MessageParcel reply;
430     int32_t ret = instance_->OnUpdateNetFirewallRule(data, reply);
431     EXPECT_EQ(ret, FIREWALL_ERR_EXCEED_MAX_DOMAIN);
432 }
433 
434 HWTEST_F(NetFirewallServiceStubTest, OnDeleteNetFirewallRule001, TestSize.Level1)
435 {
436     NetManagerExtAccessToken token;
437     MessageParcel data;
438     MessageParcel reply;
439     int32_t ret = instance_->OnDeleteNetFirewallRule(data, reply);
440     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_READ_DATA_FAIL);
441 
442     int32_t userId = -1;
443     data.WriteInt32(userId);
444     ret = instance_->OnDeleteNetFirewallRule(data, reply);
445     EXPECT_EQ(ret, FIREWALL_ERR_INVALID_PARAMETER);
446 }
447 
448 HWTEST_F(NetFirewallServiceStubTest, OnDeleteNetFirewallRule002, TestSize.Level1)
449 {
450     NetManagerExtAccessToken token;
451     MessageParcel data;
452     int32_t userId = USER_ID;
453     data.WriteInt32(userId);
454     MessageParcel reply;
455     int32_t ret = instance_->OnDeleteNetFirewallRule(data, reply);
456     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_READ_DATA_FAIL);
457 }
458 
459 HWTEST_F(NetFirewallServiceStubTest, OnDeleteNetFirewallRule003, TestSize.Level1)
460 {
461     NetManagerExtAccessToken token;
462     MessageParcel data;
463     int32_t userId = USER_ID;
464     data.WriteInt32(userId);
465     int32_t ruleId = -1;
466     data.WriteInt32(ruleId);
467     MessageParcel reply;
468     int32_t ret = instance_->OnDeleteNetFirewallRule(data, reply);
469     EXPECT_EQ(ret, FIREWALL_ERR_INVALID_PARAMETER);
470 }
471 
472 HWTEST_F(NetFirewallServiceStubTest, OnGetNetFirewallRules001, TestSize.Level1)
473 {
474     NetManagerExtAccessToken token;
475     MessageParcel data;
476     MessageParcel reply;
477     int32_t ret = instance_->OnGetNetFirewallRules(data, reply);
478     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_READ_DATA_FAIL);
479 
480     int32_t userId = -1;
481     data.WriteInt32(userId);
482     ret = instance_->OnGetNetFirewallRules(data, reply);
483     EXPECT_EQ(ret, FIREWALL_ERR_INVALID_PARAMETER);
484 }
485 
486 HWTEST_F(NetFirewallServiceStubTest, OnGetNetFirewallRules002, TestSize.Level1)
487 {
488     NetManagerExtAccessToken token;
489     MessageParcel data;
490     int32_t userId = USER_ID;
491     data.WriteInt32(userId);
492     MessageParcel reply;
493     int32_t ret = instance_->OnGetNetFirewallRules(data, reply);
494     EXPECT_EQ(ret, FIREWALL_ERR_INTERNAL);
495 }
496 
497 HWTEST_F(NetFirewallServiceStubTest, OnGetNetFirewallRule001, TestSize.Level1)
498 {
499     NetManagerExtAccessToken token;
500     MessageParcel data;
501     MessageParcel reply;
502     int32_t ret = instance_->OnGetNetFirewallRule(data, reply);
503     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_READ_DATA_FAIL);
504 
505     int32_t userId = USER_ID;
506     data.WriteInt32(userId);
507     ret = instance_->OnGetNetFirewallRule(data, reply);
508     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_READ_DATA_FAIL);
509 }
510 
511 HWTEST_F(NetFirewallServiceStubTest, OnGetInterceptRecords001, TestSize.Level1)
512 {
513     NetManagerExtAccessToken token;
514     MessageParcel data;
515     MessageParcel reply;
516     int32_t ret = instance_->OnGetInterceptRecords(data, reply);
517     EXPECT_EQ(ret, NETMANAGER_EXT_ERR_READ_DATA_FAIL);
518 
519     int32_t userId = USER_ID;
520     data.WriteInt32(userId);
521     ret = instance_->OnGetInterceptRecords(data, reply);
522     EXPECT_EQ(ret, FIREWALL_ERR_INTERNAL);
523 }
524 } // namespace NetManagerStandard
525 } // namespace OHOS
526