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 "risk_classify_kit_test.h"
17
18 #include "file_ex.h"
19 #include "securec.h"
20
21 #include "sg_classify_client.h"
22
23 using namespace testing::ext;
24 using namespace OHOS::Security::SecurityGuardTest;
25
26 #ifdef __cplusplus
27 extern "C" {
28 #endif
29 int32_t RequestSecurityEventInfoAsync(const DeviceIdentify *devId, const char *eventJson,
30 RequestSecurityEventInfoCallBack callback);
31 int32_t RequestSecurityModelResultSync(const DeviceIdentify *devId, uint32_t modelId, SecurityModelResult *result);
32 #ifdef __cplusplus
33 }
34 #endif
35
36 namespace OHOS::Security::SecurityGuardTest {
37
SetUpTestCase()38 void RiskClassifyKitTest::SetUpTestCase()
39 {
40 string isEnforcing;
41 LoadStringFromFile("/sys/fs/selinux/enforce", isEnforcing);
42 if (isEnforcing.compare("1") == 0) {
43 RiskClassifyKitTest::isEnforcing_ = true;
44 SaveStringToFile("/sys/fs/selinux/enforce", "0");
45 }
46 }
47
TearDownTestCase()48 void RiskClassifyKitTest::TearDownTestCase()
49 {
50 if (RiskClassifyKitTest::isEnforcing_) {
51 SaveStringToFile("/sys/fs/selinux/enforce", "1");
52 }
53 }
54
SetUp()55 void RiskClassifyKitTest::SetUp()
56 {
57 }
58
TearDown()59 void RiskClassifyKitTest::TearDown()
60 {
61 }
62
63 bool RiskClassifyKitTest::isEnforcing_ = false;
64
SecurityGuardRiskCallbackFunc(SecurityModelResult * result)65 void RiskClassifyKitTest::SecurityGuardRiskCallbackFunc(SecurityModelResult *result)
66 {
67 EXPECT_TRUE(result != nullptr);
68 }
69
70 /**
71 * @tc.name: RequestSecurityModelResultSync001
72 * @tc.desc: RequestSecurityModelResultSync with wrong modelId
73 * @tc.type: FUNC
74 * @tc.require: SR000H9A70
75 */
76 HWTEST_F(RiskClassifyKitTest, RequestSecurityModelResultSync001, TestSize.Level1)
77 {
78 DeviceIdentify deviceIdentify = {};
79 static uint32_t modelId = 0;
80 SecurityModelResult result;
81 (void) memset_s(&result, sizeof(SecurityModelResult), 0, sizeof(SecurityModelResult));
82 int ret = RequestSecurityModelResultSync(&deviceIdentify, modelId, &result);
83 EXPECT_EQ(ret, SecurityGuard::NO_PERMISSION);
84 EXPECT_STREQ(reinterpret_cast<const char *>(result.devId.identity),
85 reinterpret_cast<const char *>(deviceIdentify.identity));
86 EXPECT_EQ(result.modelId, modelId);
87 EXPECT_STREQ(reinterpret_cast<const char *>(result.result), "");
88 }
89
90 /**
91 * @tc.name: RequestSecurityModelResultSync002
92 * @tc.desc: RequestSecurityModelResultSync with right modelId
93 * @tc.type: FUNC
94 * @tc.require: SR000H9A70
95 */
96 HWTEST_F(RiskClassifyKitTest, RequestSecurityModelResultSync002, TestSize.Level1)
97 {
98 DeviceIdentify deviceIdentify = {};
99 static uint32_t modelId = 3001000000;
100 SecurityModelResult result;
101 (void) memset_s(&result, sizeof(SecurityModelResult), 0, sizeof(SecurityModelResult));
102 int ret = RequestSecurityModelResultSync(&deviceIdentify, modelId, &result);
103 EXPECT_EQ(ret, SecurityGuard::NO_PERMISSION);
104 EXPECT_STREQ(reinterpret_cast<const char *>(result.devId.identity),
105 reinterpret_cast<const char *>(deviceIdentify.identity));
106 EXPECT_TRUE(result.modelId == 0);
107 EXPECT_STRNE(reinterpret_cast<const char *>(result.result), "unknown");
108 }
109
110 /**
111 * @tc.name: RequestSecurityModelResultSync003
112 * @tc.desc: RequestSecurityModelResultSync with null devId
113 * @tc.type: FUNC
114 * @tc.require: SR000H9A70
115 */
116 HWTEST_F(RiskClassifyKitTest, RequestSecurityModelResultSync003, TestSize.Level1)
117 {
118 static uint32_t modelId = 3001000000;
119 SecurityModelResult result;
120 (void) memset_s(&result, sizeof(SecurityModelResult), 0, sizeof(SecurityModelResult));
121 int ret = RequestSecurityModelResultSync(nullptr, modelId, &result);
122 EXPECT_EQ(ret, SecurityGuard::BAD_PARAM);
123 }
124
125 /**
126 * @tc.name: RequestSecurityModelResultSync004
127 * @tc.desc: RequestSecurityModelResultSync with null result
128 * @tc.type: FUNC
129 * @tc.require: SR000H9A70
130 */
131 HWTEST_F(RiskClassifyKitTest, RequestSecurityModelResultSync004, TestSize.Level1)
132 {
133 DeviceIdentify deviceIdentify = {};
134 static uint32_t modelId = 3001000000;
135 int ret = RequestSecurityModelResultSync(&deviceIdentify, modelId, nullptr);
136 EXPECT_EQ(ret, SecurityGuard::BAD_PARAM);
137 }
138
139 /**
140 * @tc.name: RequestSecurityModelResultAsync001
141 * @tc.desc: RequestSecurityModelResultAsync with wrong modelId
142 * @tc.type: FUNC
143 * @tc.require: SR000H9A70
144 */
145 HWTEST_F(RiskClassifyKitTest, RequestSecurityModelResultAsync001, TestSize.Level1)
146 {
147 DeviceIdentify deviceIdentify = {};
148 static uint32_t modelId = 0;
149 int ret = RequestSecurityModelResultAsync(&deviceIdentify, modelId, SecurityGuardRiskCallbackFunc);
150 EXPECT_EQ(ret, SecurityGuard::NO_PERMISSION);
151 }
152
153 /**
154 * @tc.name: RequestSecurityModelResultAsync002
155 * @tc.desc: RequestSecurityModelResultAsync with right modelId
156 * @tc.type: FUNC
157 * @tc.require: SR000H9A70
158 */
159 HWTEST_F(RiskClassifyKitTest, RequestSecurityModelResultAsync002, TestSize.Level1)
160 {
161 DeviceIdentify deviceIdentify = {};
162 static uint32_t modelId = 3001000000;
163 int ret = RequestSecurityModelResultAsync(&deviceIdentify, modelId, SecurityGuardRiskCallbackFunc);
164 EXPECT_EQ(ret, SecurityGuard::NO_PERMISSION);
165 }
166
167 /**
168 * @tc.name: RequestSecurityModelResultAsync003
169 * @tc.desc: RequestSecurityModelResultAsync with null devId
170 * @tc.type: FUNC
171 * @tc.require: SR000H9A70
172 */
173 HWTEST_F(RiskClassifyKitTest, RequestSecurityModelResultAsync003, TestSize.Level1)
174 {
175 static uint32_t modelId = 3001000000;
176 int ret = RequestSecurityModelResultAsync(nullptr, modelId, SecurityGuardRiskCallbackFunc);
177 EXPECT_EQ(ret, SecurityGuard::BAD_PARAM);
178 }
179 }