1 /*
2  * Copyright (c) 2021-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 "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 #undef MMI_LOG_TAG
25 #define MMI_LOG_TAG "KeyEventDataTransformation"
26 
27 namespace OHOS {
28 namespace MMI {
KeyEventToNetPacket(const std::shared_ptr<KeyEvent> key,NetPacket & pkt)29 int32_t InputEventDataTransformation::KeyEventToNetPacket(
30     const std::shared_ptr<KeyEvent> key, NetPacket &pkt)
31 {
32     CHKPR(key, RET_ERR);
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->GetSwitchType() << 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->SetSwitchType(data);
143     pkt >> data;
144     swEvent->SetSwitchValue(data);
145     pkt >> data;
146     swEvent->SetSwitchMask(data);
147     return RET_OK;
148 }
149 
SerializeInputEvent(std::shared_ptr<InputEvent> event,NetPacket & pkt)150 int32_t InputEventDataTransformation::SerializeInputEvent(std::shared_ptr<InputEvent> event, NetPacket &pkt)
151 {
152     CHKPR(event, ERROR_NULL_POINTER);
153     pkt << event->GetEventType() << event->GetId() << event->GetActionTime()
154         << event->GetAction() << event->GetActionStartTime() << event->GetSensorInputTime() << event->GetDeviceId()
155         << event->GetTargetDisplayId() << event->GetTargetWindowId()
156         << event->GetAgentWindowId() << event->GetFlag() << event->IsMarkEnabled();
157     if (pkt.ChkRWError()) {
158         MMI_HILOGE("Serialize packet is failed");
159         return RET_ERR;
160     }
161     return RET_OK;
162 }
163 
DeserializeInputEvent(NetPacket & pkt,std::shared_ptr<InputEvent> event)164 int32_t InputEventDataTransformation::DeserializeInputEvent(NetPacket &pkt, std::shared_ptr<InputEvent> event)
165 {
166     CHKPR(event, ERROR_NULL_POINTER);
167     int32_t tField = 0;
168     pkt >> tField;
169     pkt >> tField;
170     event->SetId(tField);
171     int64_t rField = 0;
172     pkt >> rField;
173     event->SetActionTime(rField);
174     pkt >> tField;
175     event->SetAction(tField);
176     pkt >> rField;
177     event->SetActionStartTime(rField);
178     uint64_t sensorTime;
179     pkt >> sensorTime;
180     event->SetSensorInputTime(sensorTime);
181     pkt >> tField;
182     event->SetDeviceId(tField);
183     pkt >> tField;
184     event->SetTargetDisplayId(tField);
185     pkt >> tField;
186     event->SetTargetWindowId(tField);
187     pkt >> tField;
188     event->SetAgentWindowId(tField);
189     uint32_t tFlag = InputEvent::EVENT_FLAG_NONE;
190     pkt >> tFlag;
191     event->AddFlag(tFlag);
192     bool markEnabled = true;
193     pkt >> markEnabled;
194     event->SetMarkEnabled(markEnabled);
195     if (pkt.ChkRWError()) {
196         MMI_HILOGE("Deserialize packet is failed");
197         return RET_ERR;
198     }
199     return RET_OK;
200 }
201 
Marshalling(std::shared_ptr<PointerEvent> event,NetPacket & pkt)202 int32_t InputEventDataTransformation::Marshalling(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
203 {
204     CHKPR(event, ERROR_NULL_POINTER);
205     if (SerializeInputEvent(event, pkt) != RET_OK) {
206         MMI_HILOGE("Serialize input event failed");
207         return RET_ERR;
208     }
209     SerializeFingerprint(event, pkt);
210     SerializePointerEvent(event, pkt);
211     std::set<int32_t> pressedBtns { event->GetPressedButtons() };
212     pkt << pressedBtns.size();
213     for (int32_t btnId : pressedBtns) {
214         pkt << btnId;
215     }
216     std::vector<int32_t> pointerIds { event->GetPointerIds() };
217     pkt << pointerIds.size();
218     for (const auto &pointerId : pointerIds) {
219         PointerEvent::PointerItem item;
220         if (!event->GetPointerItem(pointerId, item)) {
221             MMI_HILOGE("Get pointer item failed");
222             return RET_ERR;
223         }
224         if (SerializePointerItem(pkt, item) != RET_OK) {
225             MMI_HILOGE("Serialize pointer item failed");
226             return RET_ERR;
227         }
228     }
229     std::vector<int32_t> pressedKeys = event->GetPressedKeys();
230     pkt << pressedKeys.size();
231     for (const auto &keyCode : pressedKeys) {
232         pkt << keyCode;
233     }
234     std::vector<uint8_t> buffer = event->GetBuffer();
235     if (buffer.size() > ExtraData::MAX_BUFFER_SIZE) {
236         MMI_HILOGE("buffer is oversize:%{public}zu", buffer.size());
237         return RET_ERR;
238     }
239     pkt << buffer.size();
240     for (const auto &buf : buffer) {
241         pkt << buf;
242     }
243     pkt << event->GetPullId();
244     if (pkt.ChkRWError()) {
245         MMI_HILOGE("Marshalling pointer event failed");
246         return RET_ERR;
247     }
248     return RET_OK;
249 }
250 
SerializePointerEvent(const std::shared_ptr<PointerEvent> event,NetPacket & pkt)251 void InputEventDataTransformation::SerializePointerEvent(const std::shared_ptr<PointerEvent> event, NetPacket &pkt)
252 {
253     pkt << event->GetPointerAction() << event->GetOriginPointerAction() << event->GetPointerId()
254         << event->GetSourceType() << event->GetButtonId() << event->GetFingerCount()
255         << event->GetZOrder() << event->GetDispatchTimes() << event->GetAxes();
256     for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
257         if (event->HasAxis(static_cast<PointerEvent::AxisType>(i))) {
258             pkt << event->GetAxisValue(static_cast<PointerEvent::AxisType>(i));
259         }
260     }
261     pkt << event->GetVelocity();
262     pkt << event->GetAxisEventType();
263 }
264 
SerializeFingerprint(const std::shared_ptr<PointerEvent> event,NetPacket & pkt)265 void InputEventDataTransformation::SerializeFingerprint(const std::shared_ptr<PointerEvent> event, NetPacket &pkt)
266 {
267 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
268     pkt << event->GetFingerprintDistanceX() << event->GetFingerprintDistanceY();
269 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
270 }
271 
DeserializePressedButtons(std::shared_ptr<PointerEvent> event,NetPacket & pkt)272 int32_t InputEventDataTransformation::DeserializePressedButtons(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
273 {
274     CHKPR(event, ERROR_NULL_POINTER);
275     int32_t tField;
276     pkt >> tField;
277     event->SetPointerAction(tField);
278     pkt >> tField;
279     event->SetOriginPointerAction(tField);
280     pkt >> tField;
281     event->SetPointerId(tField);
282     pkt >> tField;
283     event->SetSourceType(tField);
284     pkt >> tField;
285     event->SetButtonId(tField);
286     pkt >> tField;
287     event->SetFingerCount(tField);
288     pkt >> tField;
289     event->SetZOrder(tField);
290     pkt >> tField;
291     event->SetDispatchTimes(tField);
292     SetAxisInfo(pkt, event);
293 
294     std::set<int32_t>::size_type nPressed;
295     pkt >> nPressed;
296     while (nPressed-- > 0) {
297         pkt >> tField;
298         event->SetButtonPressed(tField);
299     }
300     return RET_OK;
301 }
302 
DeserializePointerIds(std::shared_ptr<PointerEvent> event,NetPacket & pkt)303 int32_t InputEventDataTransformation::DeserializePointerIds(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
304 {
305     CHKPR(event, ERROR_NULL_POINTER);
306     std::vector<int32_t>::size_type pointerCnt;
307     pkt >> pointerCnt;
308     while (pointerCnt-- > 0) {
309         PointerEvent::PointerItem item;
310         if (DeserializePointerItem(pkt, item) != RET_OK) {
311             MMI_HILOGE("Deserialize pointer item failed");
312             return RET_ERR;
313         }
314         event->AddPointerItem(item);
315     }
316     return RET_OK;
317 }
318 
Unmarshalling(NetPacket & pkt,std::shared_ptr<PointerEvent> event)319 int32_t InputEventDataTransformation::Unmarshalling(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
320 {
321     if (DeserializeInputEvent(pkt, event) != RET_OK) {
322         MMI_HILOGE("Deserialize input event failed");
323         return RET_ERR;
324     }
325 
326 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT
327     double distanceX {0.0};
328     double distanceY {0.0};
329     pkt >> distanceX;
330     pkt >> distanceY;
331     event->SetFingerprintDistanceX(distanceX);
332     event->SetFingerprintDistanceY(distanceY);
333 #endif // OHOS_BUILD_ENABLE_FINGERPRINT
334 
335     if (DeserializePressedButtons(event, pkt) != RET_OK) {
336         MMI_HILOGE("Deserialize pressed buttons failed");
337         return RET_ERR;
338     }
339 
340     if (DeserializePointerIds(event, pkt) != RET_OK) {
341         MMI_HILOGE("Deserialize pressed ids failed");
342         return RET_ERR;
343     }
344 
345     std::vector<int32_t> pressedKeys;
346     std::vector<int32_t>::size_type pressedKeySize;
347     int32_t tField;
348     pkt >> pressedKeySize;
349     while (pressedKeySize-- > 0) {
350         pkt >> tField;
351         pressedKeys.push_back(tField);
352     }
353     if (pkt.ChkRWError()) {
354         MMI_HILOGE("Unmarshalling pointer event failed");
355         return RET_ERR;
356     }
357     event->SetPressedKeys(pressedKeys);
358 
359     std::vector<uint8_t> buffer;
360     std::vector<uint8_t>::size_type bufferSize;
361     pkt >> bufferSize;
362     uint8_t buff = 0;
363     while (bufferSize-- > 0) {
364         pkt >> buff;
365         buffer.push_back(buff);
366     }
367     pkt >> tField;
368     if (pkt.ChkRWError()) {
369         MMI_HILOGE("Unmarshalling pointer event failed");
370         return RET_ERR;
371     }
372     event->SetBuffer(buffer);
373     event->SetPullId(tField);
374     return RET_OK;
375 }
376 
SetAxisInfo(NetPacket & pkt,std::shared_ptr<PointerEvent> event)377 void InputEventDataTransformation::SetAxisInfo(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
378 {
379     uint32_t tAxes;
380     pkt >> tAxes;
381     double axisValue;
382     for (int32_t i = PointerEvent::AXIS_TYPE_UNKNOWN; i < PointerEvent::AXIS_TYPE_MAX; ++i) {
383         if (PointerEvent::HasAxis(tAxes, static_cast<PointerEvent::AxisType>(i))) {
384             pkt >> axisValue;
385             event->SetAxisValue(static_cast<PointerEvent::AxisType>(i), axisValue);
386         }
387     }
388     double velocity;
389     pkt >> velocity;
390     event->SetVelocity(velocity);
391     int32_t axisEventType;
392     pkt >> axisEventType;
393     event->SetAxisEventType(axisEventType);
394 }
395 
SerializePointerItem(NetPacket & pkt,PointerEvent::PointerItem & item)396 int32_t InputEventDataTransformation::SerializePointerItem(NetPacket &pkt, PointerEvent::PointerItem &item)
397 {
398     pkt << item;
399     if (pkt.ChkRWError()) {
400         MMI_HILOGE("Packet write pointer item failed");
401         return RET_ERR;
402     }
403     return RET_OK;
404 }
405 
DeserializePointerItem(NetPacket & pkt,PointerEvent::PointerItem & item)406 int32_t InputEventDataTransformation::DeserializePointerItem(NetPacket &pkt, PointerEvent::PointerItem &item)
407 {
408     pkt >> item;
409     if (pkt.ChkRWError()) {
410         MMI_HILOGE("Packet read pointer item failed");
411         return RET_ERR;
412     }
413     return RET_OK;
414 }
415 
416 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
MarshallingEnhanceData(std::shared_ptr<PointerEvent> event,NetPacket & pkt)417 int32_t InputEventDataTransformation::MarshallingEnhanceData(std::shared_ptr<PointerEvent> event, NetPacket &pkt)
418 {
419     CHKPR(event, ERROR_NULL_POINTER);
420     int32_t pointerId = event->GetPointerId();
421     PointerEvent::PointerItem pointerItem;
422     if (!event->GetPointerItem(pointerId, pointerItem)) {
423         MMI_HILOGE("Can't find pointer item, pointer:%{public}d", pointerId);
424         return RET_ERR;
425     }
426     SecCompPointEvent *secCompPointEvent = static_cast<SecCompPointEvent*>(malloc(sizeof(SecCompPointEvent)));
427     if (secCompPointEvent == NULL) {
428         MMI_HILOGE("Malloc failed");
429         return RET_ERR;
430     }
431     secCompPointEvent->touchX = pointerItem.GetDisplayX();
432     secCompPointEvent->touchY = pointerItem.GetDisplayY();
433     secCompPointEvent->timeStamp = event->GetActionTime();
434     uint32_t dataLen = sizeof(*secCompPointEvent);
435     uint8_t outBuf[MAX_HMAC_SIZE] = { 0 };
436     uint8_t* enHanceData = reinterpret_cast<uint8_t *>(&outBuf[0]);
437     uint32_t enHanceDataLen = MAX_HMAC_SIZE;
438     int32_t result = Security::SecurityComponent::SecCompEnhanceKit::GetPointerEventEnhanceData(secCompPointEvent,
439         dataLen, enHanceData, enHanceDataLen);
440     if (result != 0 || enHanceDataLen > MAX_HMAC_SIZE) {
441         pkt << 0;
442         free(secCompPointEvent);
443         secCompPointEvent = nullptr;
444         return RET_ERR;
445     }
446     pkt << enHanceDataLen;
447     std::vector<uint8_t> realBuf;
448     for (size_t i = 0; i < enHanceDataLen; i++) {
449         realBuf.push_back(enHanceData[i]);
450         pkt << realBuf[i];
451     }
452     free(secCompPointEvent);
453     secCompPointEvent = nullptr;
454     if (pkt.ChkRWError()) {
455         MMI_HILOGE("Marshalling enhanceData failed");
456         return RET_ERR;
457     }
458     return RET_OK;
459 }
460 
UnmarshallingEnhanceData(NetPacket & pkt,std::shared_ptr<PointerEvent> event)461 int32_t InputEventDataTransformation::UnmarshallingEnhanceData(NetPacket &pkt, std::shared_ptr<PointerEvent> event)
462 {
463     uint32_t enHanceDataLen;
464     pkt >> enHanceDataLen;
465     if (enHanceDataLen == 0) {
466         return RET_OK;
467     }
468     uint8_t enhanceDataBuf[enHanceDataLen];
469     std::vector<uint8_t> enhanceData;
470     for (size_t i = 0; i < enHanceDataLen; i++) {
471         pkt >> enhanceDataBuf[i];
472         enhanceData.push_back(enhanceDataBuf[i]);
473     }
474     if (pkt.ChkRWError()) {
475         MMI_HILOGE("UnmarshallingEnhanceData pointer event failed");
476         return RET_ERR;
477     }
478     event->SetEnhanceData(enhanceData);
479     return RET_OK;
480 }
481 
482 struct keyEventEnhanceData {
483     int64_t timestamp;
484     int32_t keyCode;
485 };
486 
MarshallingEnhanceData(std::shared_ptr<KeyEvent> event,NetPacket & pkt)487 int32_t InputEventDataTransformation::MarshallingEnhanceData(std::shared_ptr<KeyEvent> event, NetPacket &pkt)
488 {
489     CHKPR(event, ERROR_NULL_POINTER);
490     struct keyEventEnhanceData secCompKeyEvent;
491     secCompKeyEvent.timestamp = event->GetActionTime();
492     secCompKeyEvent.keyCode = event->GetKeyCode();
493     uint32_t dataLen = sizeof(secCompKeyEvent);
494     uint8_t outBuf[MAX_HMAC_SIZE] = { 0 };
495     uint8_t* enHanceData = reinterpret_cast<uint8_t *>(&outBuf[0]);
496     uint32_t enHanceDataLen = MAX_HMAC_SIZE;
497     int32_t result = Security::SecurityComponent::SecCompEnhanceKit::GetPointerEventEnhanceData(&secCompKeyEvent,
498         dataLen, enHanceData, enHanceDataLen);
499     if (result != 0 || enHanceDataLen > MAX_HMAC_SIZE) {
500         pkt << 0;
501         return RET_ERR;
502     }
503     pkt << enHanceDataLen;
504     std::vector<uint8_t> realBuf;
505     for (size_t i = 0; i < enHanceDataLen; i++) {
506         realBuf.push_back(enHanceData[i]);
507         pkt << realBuf[i];
508     }
509     if (pkt.ChkRWError()) {
510         MMI_HILOGE("Marshalling enhanceData failed");
511         return RET_ERR;
512     }
513     return RET_OK;
514 }
515 
UnmarshallingEnhanceData(NetPacket & pkt,std::shared_ptr<KeyEvent> event)516 int32_t InputEventDataTransformation::UnmarshallingEnhanceData(NetPacket &pkt, std::shared_ptr<KeyEvent> event)
517 {
518     uint32_t enHanceDataLen;
519     pkt >> enHanceDataLen;
520     if (enHanceDataLen == 0 || enHanceDataLen > MAX_HMAC_SIZE) {
521         return RET_OK;
522     }
523     uint8_t enhanceDataBuf[enHanceDataLen];
524     std::vector<uint8_t> enhanceData;
525     for (size_t i = 0; i < enHanceDataLen; i++) {
526         pkt >> enhanceDataBuf[i];
527         enhanceData.push_back(enhanceDataBuf[i]);
528     }
529     if (pkt.ChkRWError()) {
530         MMI_HILOGE("UnmarshallingEnhanceData key event failed");
531         return RET_ERR;
532     }
533     event->SetEnhanceData(enhanceData);
534     return RET_OK;
535 }
536 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
537 } // namespace MMI
538 } // namespace OHOS
539