1 /*
2 * Copyright (c) 2023 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 #include "sec_comp_enhance_adapter.h"
16
17 #include "sec_comp_err.h"
18 #include "sec_comp_log.h"
19
20 namespace OHOS {
21 namespace Security {
22 namespace SecurityComponent {
23 namespace {
24 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
25 LOG_CORE, SECURITY_DOMAIN_SECURITY_COMPONENT, "MockSecCompEnhanceAdapter"};
26 }
27
SetEnhanceCfg(uint8_t * cfg,uint32_t cfgLen)28 int32_t SecCompEnhanceAdapter::SetEnhanceCfg(uint8_t* cfg, uint32_t cfgLen)
29 {
30 SC_LOG_DEBUG(LABEL, "SetEnhanceCfg success");
31 return SC_OK;
32 }
33
GetPointerEventEnhanceData(void * data,uint32_t dataLen,uint8_t * enhanceData,uint32_t & enHancedataLen)34 int32_t SecCompEnhanceAdapter::GetPointerEventEnhanceData(void* data, uint32_t dataLen,
35 uint8_t* enhanceData, uint32_t& enHancedataLen)
36 {
37 SC_LOG_DEBUG(LABEL, "GetPointerEventEnhanceData success");
38 return SC_OK;
39 }
40
CheckExtraInfo(const SecCompClickEvent & clickInfo)41 int32_t SecCompEnhanceAdapter::CheckExtraInfo(const SecCompClickEvent& clickInfo)
42 {
43 SC_LOG_DEBUG(LABEL, "CheckExtraInfo success");
44 return SC_OK;
45 }
46
EnableInputEnhance()47 int32_t SecCompEnhanceAdapter::EnableInputEnhance()
48 {
49 SC_LOG_DEBUG(LABEL, "EnableInputEnhance success");
50 return SC_OK;
51 }
52
DisableInputEnhance()53 int32_t SecCompEnhanceAdapter::DisableInputEnhance()
54 {
55 SC_LOG_DEBUG(LABEL, "DisableInputEnhance success");
56 return SC_OK;
57 }
58
EnhanceDataPreprocess(std::string & componentInfo)59 bool SecCompEnhanceAdapter::EnhanceDataPreprocess(std::string& componentInfo)
60 {
61 SC_LOG_DEBUG(LABEL, "EnhanceDataPreprocess success");
62 return true;
63 }
64
EnhanceDataPreprocess(int32_t scId,std::string & componentInfo)65 bool SecCompEnhanceAdapter::EnhanceDataPreprocess(int32_t scId, std::string& componentInfo)
66 {
67 SC_LOG_DEBUG(LABEL, "EnhanceDataPreprocess success");
68 return true;
69 }
70
71 #ifndef FUZZ_ENABLE
WriteMessageParcel(MessageParcel & tmpData,SecCompRawdata & data)72 bool WriteMessageParcel(MessageParcel& tmpData, SecCompRawdata& data)
73 {
74 size_t bufferLength = tmpData.GetDataSize();
75 if (bufferLength == 0) {
76 SC_LOG_INFO(LABEL, "TmpData is empty.");
77 return true;
78 }
79
80 char* buffer = reinterpret_cast<char *>(tmpData.GetData());
81 if (buffer == nullptr) {
82 SC_LOG_ERROR(LABEL, "Get tmpData data failed.");
83 return false;
84 }
85
86 data.size = bufferLength;
87 int32_t ret = data.RawDataCpy(reinterpret_cast<void *>(buffer));
88 if (ret != SC_OK) {
89 SC_LOG_ERROR(LABEL, "Copy tmpData to rawdata failed.");
90 return false;
91 }
92 return true;
93 }
94
ReadMessageParcel(SecCompRawdata & tmpData,MessageParcel & data)95 bool ReadMessageParcel(SecCompRawdata& tmpData, MessageParcel& data)
96 {
97 int32_t size = tmpData.size;
98 if (size == 0) {
99 SC_LOG_INFO(LABEL, "Read tmpData length empty.");
100 return true;
101 }
102
103 const void *iter = tmpData.data;
104 if (iter == nullptr) {
105 SC_LOG_ERROR(LABEL, "Read const void failed.");
106 return false;
107 }
108 char* ptr = reinterpret_cast<char *>(const_cast<void *>(iter));
109
110 if (!data.WriteBuffer(reinterpret_cast<void *>(ptr), size)) {
111 SC_LOG_ERROR(LABEL, "Write buffer failed.");
112 return false;
113 }
114 return true;
115 }
116
EnhanceClientSerialize(MessageParcel & input,SecCompRawdata & output)117 bool SecCompEnhanceAdapter::EnhanceClientSerialize(MessageParcel& input, SecCompRawdata& output)
118 {
119 SC_LOG_DEBUG(LABEL, "EnhanceClientSerialize successful.");
120 return WriteMessageParcel(input, output);
121 }
122
EnhanceClientDeserialize(SecCompRawdata & input,MessageParcel & output)123 bool SecCompEnhanceAdapter::EnhanceClientDeserialize(SecCompRawdata& input, MessageParcel& output)
124 {
125 SC_LOG_DEBUG(LABEL, "EnhanceClientDeserialize successful.");
126 return ReadMessageParcel(input, output);
127 }
128
EnhanceSrvSerialize(MessageParcel & input,SecCompRawdata & output)129 bool SecCompEnhanceAdapter::EnhanceSrvSerialize(MessageParcel& input, SecCompRawdata& output)
130 {
131 SC_LOG_DEBUG(LABEL, "EnhanceSrvSerialize successful.");
132 return WriteMessageParcel(input, output);
133 }
134
EnhanceSrvDeserialize(SecCompRawdata & input,MessageParcel & output)135 bool SecCompEnhanceAdapter::EnhanceSrvDeserialize(SecCompRawdata& input, MessageParcel& output)
136 {
137 SC_LOG_DEBUG(LABEL, "EnhanceSrvDeserialize successful.");
138 return ReadMessageParcel(input, output);
139 }
140 #else
WriteMessageParcel(MessageParcel & tmpData,SecCompRawdata & data)141 bool WriteMessageParcel(MessageParcel& tmpData, SecCompRawdata& data)
142 {
143 size_t bufferLength = tmpData.GetDataSize();
144 if (bufferLength == 0) {
145 SC_LOG_INFO(LABEL, "TmpData is empty.");
146 return true;
147 }
148
149 char* buffer = reinterpret_cast<char *>(tmpData.GetData());
150 if (buffer == nullptr) {
151 SC_LOG_ERROR(LABEL, "Get tmpData data failed.");
152 return false;
153 }
154
155 data.size = bufferLength;
156 int32_t ret = data.RawDataCpy(reinterpret_cast<void *>(buffer));
157 if (ret != SC_OK) {
158 SC_LOG_ERROR(LABEL, "Copy tmpData to rawdata failed.");
159 return false;
160 }
161 return true;
162 }
163
ReadMessageParcel(SecCompRawdata & tmpData,MessageParcel & data)164 bool ReadMessageParcel(SecCompRawdata& tmpData, MessageParcel& data)
165 {
166 int32_t size = tmpData.size;
167 if (size == 0) {
168 SC_LOG_INFO(LABEL, "Read tmpData length empty.");
169 return true;
170 }
171
172 const void *iter = tmpData.data;
173 if (iter == nullptr) {
174 SC_LOG_ERROR(LABEL, "Read const void failed.");
175 return false;
176 }
177 char* ptr = reinterpret_cast<char *>(const_cast<void *>(iter));
178
179 if (!data.WriteBuffer(reinterpret_cast<void *>(ptr), size)) {
180 SC_LOG_ERROR(LABEL, "Write buffer failed.");
181 return false;
182 }
183 return true;
184 }
185
EnhanceClientSerialize(MessageParcel & input,SecCompRawdata & output)186 bool SecCompEnhanceAdapter::EnhanceClientSerialize(MessageParcel& input, SecCompRawdata& output)
187 {
188 SC_LOG_DEBUG(LABEL, "EnhanceClientSerialize successful.");
189 return WriteMessageParcel(input, output);
190 }
191
EnhanceClientDeserialize(SecCompRawdata & input,MessageParcel & output)192 bool SecCompEnhanceAdapter::EnhanceClientDeserialize(SecCompRawdata& input, MessageParcel& output)
193 {
194 SC_LOG_DEBUG(LABEL, "EnhanceClientDeserialize successful.");
195 return ReadMessageParcel(input, output);
196 }
197
EnhanceSrvSerialize(MessageParcel & input,SecCompRawdata & output)198 bool SecCompEnhanceAdapter::EnhanceSrvSerialize(MessageParcel& input, SecCompRawdata& output)
199 {
200 SC_LOG_DEBUG(LABEL, "EnhanceSrvSerialize successful.");
201 return WriteMessageParcel(input, output);
202 }
203
EnhanceSrvDeserialize(SecCompRawdata & input,MessageParcel & output)204 bool SecCompEnhanceAdapter::EnhanceSrvDeserialize(SecCompRawdata& input, MessageParcel& output)
205 {
206 SC_LOG_DEBUG(LABEL, "EnhanceSrvDeserialize successful.");
207 return ReadMessageParcel(input, output);
208 }
209 #endif // FUZZ_ENABLE
210
RegisterScIdEnhance(int32_t scId)211 void SecCompEnhanceAdapter::RegisterScIdEnhance(int32_t scId)
212 {
213 SC_LOG_DEBUG(LABEL, "RegisterScIdEnhance success");
214 }
215
UnregisterScIdEnhance(int32_t scId)216 void SecCompEnhanceAdapter::UnregisterScIdEnhance(int32_t scId)
217 {
218 SC_LOG_DEBUG(LABEL, "UnregisterScIdEnhance success");
219 }
220
StartEnhanceService()221 void SecCompEnhanceAdapter::StartEnhanceService()
222 {
223 SC_LOG_DEBUG(LABEL, "StartEnhanceService success");
224 }
225
ExitEnhanceService()226 void SecCompEnhanceAdapter::ExitEnhanceService()
227 {
228 SC_LOG_DEBUG(LABEL, "ExitEnhanceService success");
229 }
230
NotifyProcessDied(int32_t pid)231 void SecCompEnhanceAdapter::NotifyProcessDied(int32_t pid)
232 {
233 SC_LOG_DEBUG(LABEL, "NotifyProcessDied success");
234 }
235
CheckComponentInfoEnhance(int32_t pid,std::shared_ptr<SecCompBase> & compInfo,const nlohmann::json & jsonComponent)236 int32_t SecCompEnhanceAdapter::CheckComponentInfoEnhance(int32_t pid,
237 std::shared_ptr<SecCompBase>& compInfo, const nlohmann::json& jsonComponent)
238 {
239 SC_LOG_DEBUG(LABEL, "CheckComponentInfoEnhance success");
240 return SC_OK;
241 }
242
AddSecurityComponentProcess(int32_t pid)243 void SecCompEnhanceAdapter::AddSecurityComponentProcess(int32_t pid)
244 {
245 SC_LOG_DEBUG(LABEL, "AddSecurityComponentProcess success");
246 }
247 } // namespace SecurityComponent
248 } // namespace Security
249 } // namespace OHOS
250