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 <parcel.h>
17 
18 #include <securec.h>
19 
20 #include "marshalling_helper.h"
21 #include "window_manager.h"
22 
23 using namespace OHOS::Rosen;
24 
25 namespace OHOS {
26 namespace {
27 constexpr size_t DATA_MIN_SIZE = 2;
28 }
29 
30 template<class T>
GetObject(T & object,const uint8_t * data,size_t size)31 size_t GetObject(T& object, const uint8_t* data, size_t size)
32 {
33     size_t objectSize = sizeof(object);
34     if (objectSize > size) {
35         return 0;
36     }
37     return memcpy_s(&object, objectSize, data, objectSize) == EOK ? objectSize : 0;
38 }
39 
40 class FocusChangedListener : public IFocusChangedListener {
41 public:
OnFocused(const sptr<FocusChangeInfo> & focusChangeInfo)42     virtual void OnFocused(const sptr<FocusChangeInfo>& focusChangeInfo) override
43     {
44     }
45 
OnUnfocused(const sptr<FocusChangeInfo> & focusChangeInfo)46     virtual void OnUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo) override
47     {
48     }
49 };
50 
51 class SystemBarChangedListener : public ISystemBarChangedListener {
52 public:
OnSystemBarPropertyChange(DisplayId displayId,const SystemBarRegionTints & tints)53     virtual void OnSystemBarPropertyChange(DisplayId displayId, const SystemBarRegionTints& tints) override
54     {
55     }
56 };
57 
58 class VisibilityChangedListener : public IVisibilityChangedListener {
59 public:
OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>> & windowVisibilityInfo)60     virtual void OnWindowVisibilityChanged(const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfo) override
61     {
62     }
63 };
64 
65 class WindowUpdateListener : public IWindowUpdateListener {
66 public:
OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>> & infos,WindowUpdateType type)67     virtual void OnWindowUpdate(const std::vector<sptr<AccessibilityWindowInfo>>& infos, WindowUpdateType type) override
68     {
69     }
70 };
71 
72 class CameraFloatWindowChangedListener : public ICameraFloatWindowChangedListener {
73 public:
OnCameraFloatWindowChange(uint32_t accessTokenId,bool isShowing)74     void OnCameraFloatWindowChange(uint32_t accessTokenId, bool isShowing) override
75     {
76     }
77 };
78 
79 class WaterMarkFlagChangedListener : public IWaterMarkFlagChangedListener {
80 public:
OnWaterMarkFlagUpdate(bool showWaterMark)81     void OnWaterMarkFlagUpdate(bool showWaterMark) override
82     {
83     }
84 };
85 
86 class GestureNavigationEnabledChangedListener : public IGestureNavigationEnabledChangedListener {
87 public:
OnGestureNavigationEnabledUpdate(bool enable)88     void OnGestureNavigationEnabledUpdate(bool enable) override
89     {
90     }
91 };
92 
DoSomethingForWindowManagerImpl(WindowManager & windowManager,const uint8_t * data,size_t size)93 bool DoSomethingForWindowManagerImpl(WindowManager& windowManager, const uint8_t* data, size_t size)
94 {
95     if (data == nullptr || size < DATA_MIN_SIZE) {
96         return false;
97     }
98     size_t startPos = 0;
99     uint32_t accessTokenId;
100     bool isShowing;
101     startPos += GetObject<uint32_t>(accessTokenId, data + startPos, size - startPos);
102     startPos += GetObject<bool>(isShowing, data + startPos, size - startPos);
103     windowManager.UpdateCameraFloatWindowStatus(accessTokenId, isShowing);
104     bool enable;
105     startPos += GetObject<bool>(enable, data + startPos, size - startPos);
106     windowManager.SetGestureNavigaionEnabled(enable);
107 
108     DisplayId displayId;
109     SystemBarRegionTints tints;
110     startPos += GetObject<DisplayId>(displayId, data + startPos, size - startPos);
111     GetObject<SystemBarRegionTints>(tints, data + startPos, size - startPos);
112     windowManager.UpdateSystemBarRegionTints(displayId, tints);
113 
114     return true;
115 }
116 
CheckAccessibilityWindowInfo(WindowManager & windowManager,const uint8_t * data,size_t size)117 void CheckAccessibilityWindowInfo(WindowManager& windowManager, const uint8_t* data, size_t size)
118 {
119     Parcel accessibilityWindowInfosParcel;
120     if (!accessibilityWindowInfosParcel.WriteBuffer(data, size)) {
121         return;
122     }
123     std::vector<sptr<AccessibilityWindowInfo>> windowInfos;
124     if (!MarshallingHelper::UnmarshallingVectorParcelableObj<AccessibilityWindowInfo>(
125         accessibilityWindowInfosParcel, windowInfos)) {
126         return;
127     }
128     windowManager.GetAccessibilityWindowInfo(windowInfos);
129     WindowUpdateType type;
130     GetObject<WindowUpdateType>(type, data, size);
131     windowManager.NotifyAccessibilityWindowInfo(windowInfos, type);
132 }
133 
CheckVisibilityInfo(WindowManager & windowManager,const uint8_t * data,size_t size)134 void CheckVisibilityInfo(WindowManager& windowManager, const uint8_t* data, size_t size)
135 {
136     Parcel windowVisibilityInfosParcel;
137     if (!windowVisibilityInfosParcel.WriteBuffer(data, size)) {
138         return;
139     }
140     std::vector<sptr<WindowVisibilityInfo>> visibilitynfos;
141     if (!MarshallingHelper::UnmarshallingVectorParcelableObj<WindowVisibilityInfo>(windowVisibilityInfosParcel,
142             visibilitynfos)) {
143         return;
144     }
145     windowManager.GetVisibilityWindowInfo(visibilitynfos);
146     windowManager.UpdateWindowVisibilityInfo(visibilitynfos);
147     bool enable = false;
148     windowManager.SetGestureNavigaionEnabled(enable);
149 }
150 
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)151 bool DoSomethingInterestingWithMyAPI(const uint8_t* data, size_t size)
152 {
153     WindowManager& windowManager = WindowManager::GetInstance();
154     CheckAccessibilityWindowInfo(windowManager, data, size);
155     CheckVisibilityInfo(windowManager, data, size);
156     Parcel focusChangeInfoParcel;
157     if (focusChangeInfoParcel.WriteBuffer(data, size)) {
158         FocusChangeInfo::Unmarshalling(focusChangeInfoParcel);
159     }
160     Parcel parcel;
161     sptr<FocusChangeInfo> focusChangeInfo = new FocusChangeInfo();
162     focusChangeInfo->Marshalling(parcel);
163     Parcel windowVisibilityInfoParcel;
164     if (windowVisibilityInfoParcel.WriteBuffer(data, size)) {
165         WindowVisibilityInfo::Unmarshalling(windowVisibilityInfoParcel);
166     }
167     sptr<WindowVisibilityInfo> windowVisibilityInfo = new WindowVisibilityInfo();
168     windowVisibilityInfo->Marshalling(parcel);
169     Parcel accessibilityWindowInfoParcel;
170     if (accessibilityWindowInfoParcel.WriteBuffer(data, size)) {
171         AccessibilityWindowInfo::Unmarshalling(accessibilityWindowInfoParcel);
172     }
173     sptr<AccessibilityWindowInfo> accessibilityWindowInfo = new AccessibilityWindowInfo();
174     accessibilityWindowInfo->Marshalling(parcel);
175     windowManager.MinimizeAllAppWindows(static_cast<DisplayId>(data[0]));
176     sptr<IFocusChangedListener> focusChangedListener = new FocusChangedListener();
177     windowManager.RegisterFocusChangedListener(focusChangedListener);
178     sptr<ISystemBarChangedListener> systemBarChangedListener = new SystemBarChangedListener();
179     windowManager.RegisterSystemBarChangedListener(systemBarChangedListener);
180     sptr<IVisibilityChangedListener> visibilityChangedListener = new VisibilityChangedListener();
181     windowManager.RegisterVisibilityChangedListener(visibilityChangedListener);
182     sptr<IWindowUpdateListener> windowUpdateListener = new WindowUpdateListener();
183     windowManager.RegisterWindowUpdateListener(windowUpdateListener);
184     sptr<ICameraFloatWindowChangedListener> cameraFloatWindowChanagedListener = new CameraFloatWindowChangedListener();
185     windowManager.RegisterCameraFloatWindowChangedListener(cameraFloatWindowChanagedListener);
186     windowManager.SetWindowLayoutMode(static_cast<WindowLayoutMode>(data[0]));
187     windowManager.UnregisterFocusChangedListener(focusChangedListener);
188     windowManager.UnregisterSystemBarChangedListener(systemBarChangedListener);
189     windowManager.UnregisterVisibilityChangedListener(visibilityChangedListener);
190     windowManager.UnregisterWindowUpdateListener(windowUpdateListener);
191     windowManager.UnregisterCameraFloatWindowChangedListener(cameraFloatWindowChanagedListener);
192     sptr<IWaterMarkFlagChangedListener> waterMarkFlagChangedListener = new WaterMarkFlagChangedListener();
193     windowManager.RegisterWaterMarkFlagChangedListener(waterMarkFlagChangedListener);
194     windowManager.UnregisterWaterMarkFlagChangedListener(waterMarkFlagChangedListener);
195     sptr<IGestureNavigationEnabledChangedListener> gestureListener = new GestureNavigationEnabledChangedListener();
196     windowManager.RegisterGestureNavigationEnabledChangedListener(gestureListener);
197     windowManager.UnregisterGestureNavigationEnabledChangedListener(gestureListener);
198     return true;
199 }
200 } // namespace.OHOS
201 
202 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)203 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
204 {
205     /* Run your code on data */
206     if (data == nullptr || size < OHOS::DATA_MIN_SIZE) {
207         return 0;
208     }
209     OHOS::DoSomethingInterestingWithMyAPI(data, size);
210     return 0;
211 }
212 
213