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 SecurityGuard::SecurityModelResult tmp {};
124 std::string devStr;
125 devStr.resize(DEVICE_ID_MAX_LEN + 1, '0');
126 ret = SecurityGuard::RequestSecurityModelResultSync(devStr, 0, "", tmp);
127 EXPECT_EQ(ret, SecurityGuard::BAD_PARAM);
__anon5e0dce4a0102(const SecurityGuard::SecurityModelResult &tmp) 128 auto cppCallBack = [](const SecurityGuard::SecurityModelResult &tmp) {};
129 ret = SecurityGuard::RequestSecurityModelResultAsync(devStr, 0, "", cppCallBack);
130 EXPECT_EQ(ret, SecurityGuard::BAD_PARAM);
131 }
132
133 /**
134 * @tc.name: RequestSecurityModelResultSync004
135 * @tc.desc: RequestSecurityModelResultSync with null result
136 * @tc.type: FUNC
137 * @tc.require: SR000H9A70
138 */
139 HWTEST_F(RiskClassifyKitTest, RequestSecurityModelResultSync004, TestSize.Level1)
140 {
141 DeviceIdentify deviceIdentify = {};
142 static uint32_t modelId = 3001000000;
143 int ret = RequestSecurityModelResultSync(&deviceIdentify, modelId, nullptr);
144 EXPECT_EQ(ret, SecurityGuard::BAD_PARAM);
145 }
146
147 /**
148 * @tc.name: RequestSecurityModelResultAsync001
149 * @tc.desc: RequestSecurityModelResultAsync with wrong modelId
150 * @tc.type: FUNC
151 * @tc.require: SR000H9A70
152 */
153 HWTEST_F(RiskClassifyKitTest, RequestSecurityModelResultAsync001, TestSize.Level1)
154 {
155 DeviceIdentify deviceIdentify = {};
156 static uint32_t modelId = 0;
157 int ret = RequestSecurityModelResultAsync(&deviceIdentify, modelId, SecurityGuardRiskCallbackFunc);
158 EXPECT_EQ(ret, SecurityGuard::NO_PERMISSION);
159 }
160
161 /**
162 * @tc.name: RequestSecurityModelResultAsync002
163 * @tc.desc: RequestSecurityModelResultAsync with right modelId
164 * @tc.type: FUNC
165 * @tc.require: SR000H9A70
166 */
167 HWTEST_F(RiskClassifyKitTest, RequestSecurityModelResultAsync002, TestSize.Level1)
168 {
169 DeviceIdentify deviceIdentify = {};
170 static uint32_t modelId = 3001000000;
171 int ret = RequestSecurityModelResultAsync(&deviceIdentify, modelId, SecurityGuardRiskCallbackFunc);
172 EXPECT_EQ(ret, SecurityGuard::NO_PERMISSION);
173 }
174
175 /**
176 * @tc.name: RequestSecurityModelResultAsync003
177 * @tc.desc: RequestSecurityModelResultAsync with null devId
178 * @tc.type: FUNC
179 * @tc.require: SR000H9A70
180 */
181 HWTEST_F(RiskClassifyKitTest, RequestSecurityModelResultAsync003, TestSize.Level1)
182 {
183 static uint32_t modelId = 3001000000;
184 int ret = RequestSecurityModelResultAsync(nullptr, modelId, SecurityGuardRiskCallbackFunc);
185 EXPECT_EQ(ret, SecurityGuard::BAD_PARAM);
186 }
187 }