1 /*
2 * Copyright (c) 2021-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
16 #include "input_event_data_transformation.h"
17
18 #include "define_multimodal.h"
19 #include "extra_data.h"
20 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
21 #include "sec_comp_enhance_kit.h"
22 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
23
24 namespace OHOS {
25 namespace MMI {
26 namespace {
27 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = { LOG_CORE, MMI_LOG_DOMAIN, "KeyEventDataTransformation" };
28 } // namespace
29
KeyEventToNetPacket(const std::shared_ptr<KeyEvent> key,NetPacket & pkt)30 int32_t InputEventDataTransformation::KeyEventToNetPacket(
31 const std::shared_ptr<KeyEvent> key, NetPacket &pkt)
32 {
33 if (SerializeInputEvent(key, pkt) != RET_OK) {
34 MMI_HILOGE("Serialize input event failed");
35 return RET_ERR;
36 }
37 pkt << key->GetKeyCode() << key->GetKeyAction() << key->GetKeyIntention();
38 auto keys = key->GetKeyItems();
39 int32_t size = static_cast<int32_t>(keys.size());
40 if (size > MAX_KEY_SIZE) {
41 MMI_HILOGE("Key exceeds the max range");
42 return RET_ERR;
43 }
44 pkt << size;
45 for (const auto &item : keys) {
46 pkt << item.GetKeyCode() << item.GetDownTime()
47 << item.GetDeviceId() << item.IsPressed() << item.GetUnicode();
48 }
49 pkt << key->GetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY)
50 << key->GetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY)
51 << key->GetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY);
52 if (pkt.ChkRWError()) {
53 MMI_HILOGE("Packet write key event failed");
54 return RET_ERR;
55 }
56 return RET_OK;
57 }
58
NetPacketToKeyEvent(NetPacket & pkt,std::shared_ptr<KeyEvent> key)59 int32_t InputEventDataTransformation::NetPacketToKeyEvent(NetPacket &pkt, std::shared_ptr<KeyEvent> key)
60 {
61 if (DeserializeInputEvent(pkt, key) != RET_OK) {
62 MMI_HILOGE("Deserialize input event failed");
63 return RET_ERR;
64 }
65 int32_t data = 0;
66 pkt >> data;
67 key->SetKeyCode(data);
68 pkt >> data;
69 key->SetKeyAction(data);
70 pkt >> data;
71 key->SetKeyIntention(data);
72 int32_t size = 0;
73 pkt >> size;
74 if (size > MAX_KEY_SIZE) {
75 MMI_HILOGE("Key exceeds the max range");
76 return RET_ERR;
77 }
78 if (pkt.ChkRWError()) {
79 MMI_HILOGE("Packet read size failed");
80 return RET_ERR;
81 }
82 bool isPressed = false;
83 for (int32_t i = 0; i < size; i++) {
84 KeyEvent::KeyItem keyItem;
85 pkt >> data;
86 keyItem.SetKeyCode(data);
87 int64_t datatime = 0;
88 pkt >> datatime;
89 keyItem.SetDownTime(datatime);
90 pkt >> data;
91 keyItem.SetDeviceId(data);
92 pkt >> isPressed;
93 if (pkt.ChkRWError()) {
94 MMI_HILOGE("Packet read item isPressed failed");
95 return RET_ERR;
96 }
97 keyItem.SetPressed(isPressed);
98 uint32_t unicode;
99 pkt >> unicode;
100 keyItem.SetUnicode(unicode);
101 key->AddKeyItem(keyItem);
102 }
103 ReadFunctionKeys(pkt, key);
104 return RET_OK;
105 }
106
ReadFunctionKeys(NetPacket & pkt,std::shared_ptr<KeyEvent> key)107 void InputEventDataTransformation::ReadFunctionKeys(NetPacket &pkt, std::shared_ptr<KeyEvent> key)
108 {
109 CHKPV(key);
110 bool state = false;
111 pkt >> state;
112 key->SetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY, state);
113 pkt >> state;
114 key->SetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY, state);
115 pkt >> state;
116 key->SetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY, state);
117 }
118
SwitchEventToNetPacket(const std::shared_ptr<SwitchEvent> swEvent,NetPacket & pkt)119 int32_t InputEventDataTransformation::SwitchEventToNetPacket(
120 const std::shared_ptr<SwitchEvent> swEvent, NetPacket &pkt)
121 {
122 if (SerializeInputEvent(swEvent, pkt) != RET_OK) {
123 MMI_HILOGE("Serialize input event failed");
124 return RET_ERR;
125 }
126 pkt << swEvent->GetSwitchValue() << swEvent->GetSwitchMask();
127 if (pkt.ChkRWError()) {
128 MMI_HILOGE("Packet write key event failed");
129 return RET_ERR;
130 }
131 return RET_OK;
132 }
133
NetPacketToSwitchEvent(NetPacket & pkt,std::shared_ptr<SwitchEvent> swEvent)134 int32_t InputEventDataTransformation::NetPacketToSwitchEvent(NetPacket &pkt, std::shared_ptr<SwitchEvent> swEvent)
135 {
136 if (DeserializeInputEvent(pkt, swEvent) != RET_OK) {
137 MMI_HILOGE("Deserialize input event failed");
138 return RET_ERR;
139 }
140 int32_t data = 0;
141 pkt >> data;
142 swEvent->SetSwitchValue(data);
143 pkt >> data;
144 swEvent->SetSwitchMask(data);
145 return RET_OK;
146 }
147
SerializeInputEvent(std::shared_ptr<InputEvent> event,NetPacket & pkt)148 int32_t InputEventDataTransformation::SerializeInputEvent(std::shared_ptr<InputEvent> event, NetPacket &pkt)
149 {
150 CHKPR(event, ERROR_NULL_POINTER);
151 pkt << event->GetEventType() << event->GetId() << event->GetActionTime()
152 << event->GetAction() << event->GetActionStartTime() << event->GetSensorInputTime() << event->GetDeviceId()
153 << event->GetTargetDisplayId() << event->GetTargetWindowId()
154 << event->GetAgentWindowId() << event->GetFlag();
155 if (pkt.ChkRWError()) {
156 MMI_HILOGE("Serialize packet is failed");
157 return RET_ERR;
158 }
159 return RET_OK;
160 }
161
DeserializeInputEvent(NetPacket & pkt,std::shared_ptr<InputEvent> event)162 int32_t InputEventDataTransformation::DeserializeInputEvent(NetPacket &pkt, std::shared_ptr<InputEvent> event)
163 {
164 CHKPR(event, ERROR_NULL_POINTER);
165 int32_t tField = 0;
166 pkt >> tField;
167 pkt >> tField;
168 event->SetId(tField);
169 int64_t rField = 0;
170 pkt >> rField;
171 event->SetActionTime(rField);
172 pkt >> tField;
173 event->SetAction(tField);
174 pkt >> rField;
175 event->SetActionStartTime(rField);
176 uint64_t sensorTime;
177 pkt >> sensorTime;
178 event->SetSensorInputTime(sensorTime);
179 pkt >> tField;
180 event->SetDeviceId(tField);
181 pkt >> tField;
182 event->SetTargetDisplayId(tField);
183 pkt >> tField;
184 event->SetTargetWindowId(tField);
185 pkt >> tField;
186 event->SetAgentWindowId(tField);
187 uint32_t tFlag = InputEvent::EVENT_FLAG_NONE;
188 pkt >> tFlag;
189 if (pkt.ChkRWError()) {
190 MMI_HILOGE("Deserialize packet is failed");
191 return RET_ERR;
192 }
193 event->AddFlag(tFlag);
194 return RET_OK;
195 }
196
Marshalling(std::shared_ptr<PointerEvent> event,NetPacket & pkt)197 int32_t InputEventDataTransformation::Marshalling(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
198 {
199 CHKPR(event, ERROR_NULL_POINTER);
200 if (SerializeInputEvent(event, pkt) != RET_OK) {
201 MMI_HILOGE("Serialize input event failed");
202 return RET_ERR;
203 }
204 pkt << event->GetPointerAction() << event->GetPointerId() << event->GetSourceType() << event->GetButtonId()
205 << event->GetFingerCount() << event->GetZOrder() << event->GetAxes();
206
207 for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
208 if (event->HasAxis(static_cast<PointerEvent::AxisType>(i))) {
209 pkt << event->GetAxisValue(static_cast<PointerEvent::AxisType>(i));
210 }
211 }
212 std::set<int32_t> pressedBtns { event->GetPressedButtons() };
213 pkt << pressedBtns.size();
214 for (int32_t btnId : pressedBtns) {
215 pkt << btnId;
216 }
217 std::vector<int32_t> pointerIds { event->GetPointerIds() };
218 pkt << pointerIds.size();
219 for (const auto &pointerId : pointerIds) {
220 PointerEvent::PointerItem item;
221 if (!event->GetPointerItem(pointerId, item)) {
222 MMI_HILOGE("Get pointer item failed");
223 return RET_ERR;
224 }
225 if (SerializePointerItem(pkt, item) != RET_OK) {
226 MMI_HILOGE("Serialize pointer item failed");
227 return RET_ERR;
228 }
229 }
230 std::vector<int32_t> pressedKeys = event->GetPressedKeys();
231 pkt << pressedKeys.size();
232 for (const auto &keyCode : pressedKeys) {
233 pkt << keyCode;
234 }
235 std::vector<uint8_t> buffer = event->GetBuffer();
236 if (buffer.size() > ExtraData::MAX_BUFFER_SIZE) {
237 MMI_HILOGE("buffer is oversize:%{public}zu", buffer.size());
238 return RET_ERR;
239 }
240 pkt << buffer.size();
241 for (const auto &buf : buffer) {
242 pkt << buf;
243 }
244 if (pkt.ChkRWError()) {
245 MMI_HILOGE("Marshalling pointer event failed");
246 return RET_ERR;
247 }
248 return RET_OK;
249 }
250
DeserializePressedButtons(std::shared_ptr<PointerEvent> event,NetPacket & pkt)251 int32_t InputEventDataTransformation::DeserializePressedButtons(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
252 {
253 CHKPR(event, ERROR_NULL_POINTER);
254 int32_t tField;
255 pkt >> tField;
256 event->SetPointerAction(tField);
257 pkt >> tField;
258 event->SetPointerId(tField);
259 pkt >> tField;
260 event->SetSourceType(tField);
261 pkt >> tField;
262 event->SetButtonId(tField);
263 pkt >> tField;
264 event->SetFingerCount(tField);
265 pkt >> tField;
266 event->SetZOrder(tField);
267 SetAxisInfo(pkt, event);
268 std::set<int32_t>::size_type nPressed;
269 pkt >> nPressed;
270 while (nPressed-- > 0) {
271 pkt >> tField;
272 event->SetButtonPressed(tField);
273 }
274 return RET_OK;
275 }
276
DeserializePointerIds(std::shared_ptr<PointerEvent> event,NetPacket & pkt)277 int32_t InputEventDataTransformation::DeserializePointerIds(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
278 {
279 CHKPR(event, ERROR_NULL_POINTER);
280 std::vector<int32_t>::size_type pointerCnt;
281 pkt >> pointerCnt;
282 while (pointerCnt-- > 0) {
283 PointerEvent::PointerItem item;
284 if (DeserializePointerItem(pkt, item) != RET_OK) {
285 MMI_HILOGE("Deserialize pointer item failed");
286 return RET_ERR;
287 }
288 event->AddPointerItem(item);
289 }
290 return RET_OK;
291 }
292
Unmarshalling(NetPacket & pkt,std::shared_ptr<PointerEvent> event)293 int32_t InputEventDataTransformation::Unmarshalling(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
294 {
295 if (DeserializeInputEvent(pkt, event) != RET_OK) {
296 MMI_HILOGE("Deserialize input event failed");
297 return RET_ERR;
298 }
299
300 if (DeserializePressedButtons(event, pkt) != RET_OK) {
301 MMI_HILOGE("Deserialize pressed buttons failed");
302 return RET_ERR;
303 }
304
305 if (DeserializePointerIds(event, pkt) != RET_OK) {
306 MMI_HILOGE("Deserialize pressed ids failed");
307 return RET_ERR;
308 }
309
310 std::vector<int32_t> pressedKeys;
311 std::vector<int32_t>::size_type pressedKeySize;
312 int32_t tField;
313 pkt >> pressedKeySize;
314 while (pressedKeySize-- > 0) {
315 pkt >> tField;
316 pressedKeys.push_back(tField);
317 }
318 if (pkt.ChkRWError()) {
319 MMI_HILOGE("Unmarshalling pointer event failed");
320 return RET_ERR;
321 }
322 event->SetPressedKeys(pressedKeys);
323
324 std::vector<uint8_t> buffer;
325 std::vector<uint8_t>::size_type bufferSize;
326 pkt >> bufferSize;
327 uint8_t buff = 0;
328 while (bufferSize-- > 0) {
329 pkt >> buff;
330 buffer.push_back(buff);
331 }
332 if (pkt.ChkRWError()) {
333 MMI_HILOGE("Unmarshalling pointer event failed");
334 return RET_ERR;
335 }
336 event->SetBuffer(buffer);
337 return RET_OK;
338 }
339
SetAxisInfo(NetPacket & pkt,std::shared_ptr<PointerEvent> event)340 void InputEventDataTransformation::SetAxisInfo(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
341 {
342 uint32_t tAxes;
343 pkt >> tAxes;
344 double axisValue;
345 for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
346 if (PointerEvent::HasAxis(tAxes, static_cast<PointerEvent::AxisType>(i))) {
347 pkt >> axisValue;
348 event->SetAxisValue(static_cast<PointerEvent::AxisType>(i), axisValue);
349 }
350 }
351 }
352
SerializePointerItem(NetPacket & pkt,PointerEvent::PointerItem & item)353 int32_t InputEventDataTransformation::SerializePointerItem(NetPacket &pkt, PointerEvent::PointerItem &item)
354 {
355 pkt << item;
356 if (pkt.ChkRWError()) {
357 MMI_HILOGE("Packet write pointer item failed");
358 return RET_ERR;
359 }
360 return RET_OK;
361 }
362
DeserializePointerItem(NetPacket & pkt,PointerEvent::PointerItem & item)363 int32_t InputEventDataTransformation::DeserializePointerItem(NetPacket &pkt, PointerEvent::PointerItem &item)
364 {
365 pkt >> item;
366 if (pkt.ChkRWError()) {
367 MMI_HILOGE("Packet read pointer item failed");
368 return RET_ERR;
369 }
370 return RET_OK;
371 }
372
373 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
MarshallingEnhanceData(std::shared_ptr<PointerEvent> event,NetPacket & pkt)374 int32_t InputEventDataTransformation::MarshallingEnhanceData(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
375 {
376 CHKPR(event, ERROR_NULL_POINTER);
377 int32_t pointerId = event->GetPointerId();
378 PointerEvent::PointerItem pointerItem;
379 if (!event->GetPointerItem(pointerId, pointerItem)) {
380 MMI_HILOGE("Can't find pointer item, pointer:%{public}d", pointerId);
381 return RET_ERR;
382 }
383 SecCompPointEvent *secCompPointEvent = static_cast<SecCompPointEvent*>(malloc(sizeof(SecCompPointEvent)));
384 if (secCompPointEvent == NULL) {
385 MMI_HILOGE("Malloc failed");
386 return RET_ERR;
387 }
388 secCompPointEvent->touchX = pointerItem.GetDisplayX();
389 secCompPointEvent->touchY = pointerItem.GetDisplayY();
390 secCompPointEvent->timeStamp = event->GetActionTime();
391 uint32_t dataLen = sizeof(*secCompPointEvent);
392 uint8_t outBuf[MAX_HMAC_SIZE] = { 0 };
393 uint8_t* enHanceData = reinterpret_cast<uint8_t *>(&outBuf[0]);
394 uint32_t enHanceDataLen = MAX_HMAC_SIZE;
395 int32_t result = Security::SecurityComponent::SecCompEnhanceKit::GetPointerEventEnhanceData(secCompPointEvent,
396 dataLen, enHanceData, enHanceDataLen);
397 if (result != 0 || enHanceDataLen > MAX_HMAC_SIZE) {
398 pkt << 0;
399 free(secCompPointEvent);
400 secCompPointEvent = nullptr;
401 MMI_HILOGD("GetPointerEventEnhanceData failed!");
402 return RET_ERR;
403 }
404 pkt << enHanceDataLen;
405 std::vector<uint8_t> realBuf;
406 for (size_t i = 0; i < enHanceDataLen; i++) {
407 realBuf.push_back(enHanceData[i]);
408 pkt << realBuf[i];
409 }
410 free(secCompPointEvent);
411 secCompPointEvent = nullptr;
412 if (pkt.ChkRWError()) {
413 MMI_HILOGE("Marshalling enhanceData failed");
414 return RET_ERR;
415 }
416 return RET_OK;
417 }
418
UnmarshallingEnhanceData(NetPacket & pkt,std::shared_ptr<PointerEvent> event)419 int32_t InputEventDataTransformation::UnmarshallingEnhanceData(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
420 {
421 uint32_t enHanceDataLen;
422 pkt >> enHanceDataLen;
423 if (enHanceDataLen == 0) {
424 return RET_OK;
425 }
426 uint8_t enhanceDataBuf[enHanceDataLen];
427 std::vector<uint8_t> enhanceData;
428 for (size_t i = 0; i < enHanceDataLen; i++) {
429 pkt >> enhanceDataBuf[i];
430 enhanceData.push_back(enhanceDataBuf[i]);
431 }
432 if (pkt.ChkRWError()) {
433 MMI_HILOGE("UnmarshallingEnhanceData pointer event failed");
434 return RET_ERR;
435 }
436 event->SetEnhanceData(enhanceData);
437 return RET_OK;
438 }
439
440 struct keyEventEnhanceData {
441 int64_t timestamp;
442 int32_t keyCode;
443 };
444
MarshallingEnhanceData(std::shared_ptr<KeyEvent> event,NetPacket & pkt)445 int32_t InputEventDataTransformation::MarshallingEnhanceData(std::shared_ptr<KeyEvent> event, NetPacket &pkt)
446 {
447 CHKPR(event, ERROR_NULL_POINTER);
448 struct keyEventEnhanceData secCompKeyEvent;
449 secCompKeyEvent.timestamp = event->GetActionTime();
450 secCompKeyEvent.keyCode = event->GetKeyCode();
451 uint32_t dataLen = sizeof(secCompKeyEvent);
452 uint8_t outBuf[MAX_HMAC_SIZE] = { 0 };
453 uint8_t* enHanceData = reinterpret_cast<uint8_t *>(&outBuf[0]);
454 uint32_t enHanceDataLen = MAX_HMAC_SIZE;
455 int32_t result = Security::SecurityComponent::SecCompEnhanceKit::GetPointerEventEnhanceData(&secCompKeyEvent,
456 dataLen, enHanceData, enHanceDataLen);
457 if (result != 0 || enHanceDataLen > MAX_HMAC_SIZE) {
458 pkt << 0;
459 MMI_HILOGD("GetKeyEventEnhanceData failed!");
460 return RET_ERR;
461 }
462 pkt << enHanceDataLen;
463 std::vector<uint8_t> realBuf;
464 for (size_t i = 0; i < enHanceDataLen; i++) {
465 realBuf.push_back(enHanceData[i]);
466 pkt << realBuf[i];
467 }
468 if (pkt.ChkRWError()) {
469 MMI_HILOGE("Marshalling enhanceData failed");
470 return RET_ERR;
471 }
472 return RET_OK;
473 }
474
UnmarshallingEnhanceData(NetPacket & pkt,std::shared_ptr<KeyEvent> event)475 int32_t InputEventDataTransformation::UnmarshallingEnhanceData(NetPacket &pkt, std::shared_ptr<KeyEvent> event)
476 {
477 uint32_t enHanceDataLen;
478 pkt >> enHanceDataLen;
479 if (enHanceDataLen == 0 || enHanceDataLen > MAX_HMAC_SIZE) {
480 return RET_OK;
481 }
482 uint8_t enhanceDataBuf[enHanceDataLen];
483 std::vector<uint8_t> enhanceData;
484 for (size_t i = 0; i < enHanceDataLen; i++) {
485 pkt >> enhanceDataBuf[i];
486 enhanceData.push_back(enhanceDataBuf[i]);
487 }
488 if (pkt.ChkRWError()) {
489 MMI_HILOGE("UnmarshallingEnhanceData key event failed");
490 return RET_ERR;
491 }
492 event->SetEnhanceData(enhanceData);
493 return RET_OK;
494 }
495 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
496 } // namespace MMI
497 } // namespace OHOS
498