1 /*
2 * Copyright (c) 2021-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 * miscservices under the License is miscservices 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 "screenlockmanager_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20
21 #include "message_parcel.h"
22 #include "screenlock_callback.h"
23 #include "screenlock_manager.h"
24 #include "screenlock_manager_interface.h"
25 #include "screenlock_system_ability.h"
26 #include "screenlock_system_ability_callback.h"
27 #include "innerListener_fuzz_utils.h"
28
29 using namespace OHOS::ScreenLock;
30
31 namespace OHOS {
32 constexpr size_t THRESHOLD = 10;
33 constexpr int32_t OFFSET = 4;
34 constexpr size_t LENGTH = 1;
35 constexpr size_t RANDNUM_ZERO = 0;
36 constexpr size_t RANDNUM_ONE = 1;
37 constexpr size_t RANDNUM_TWO = 2;
38 constexpr size_t DEFAULT_USER = 100;
39 sptr<StrongAuthListener> StrongAuthListenerTest1 = new (std::nothrow) StrongAuthListenerTest(100);
40 sptr<DeviceLockedListener> DeviceLockedListenerTest1 = new (std::nothrow) DeviceLockedListenerTest(100);
41
ConvertToUint32(const uint8_t * ptr)42 uint32_t ConvertToUint32(const uint8_t *ptr)
43 {
44 if (ptr == nullptr) {
45 return 0;
46 }
47 uint32_t bigvar = (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | (ptr[3]);
48 return bigvar;
49 }
50
FuzzScreenlockManager(const uint8_t * rawData,size_t size)51 bool FuzzScreenlockManager(const uint8_t *rawData, size_t size)
52 {
53 uint32_t code = ConvertToUint32(rawData);
54 EventListener eventListener;
55 if (code == RANDNUM_ZERO) {
56 return ScreenLockManager::GetInstance()->IsScreenLocked();
57 }
58 if (code == RANDNUM_ONE) {
59 return ScreenLockManager::GetInstance()->GetSecure();
60 }
61 if (code == RANDNUM_TWO) {
62 sptr<ScreenlockCallback> listener_ = new ScreenlockCallback(eventListener);
63 int32_t ret = ScreenLockManager::GetInstance()->Lock(listener_);
64 return ret == E_SCREENLOCK_OK;
65 }
66 return true;
67 }
68
UnlockFuzzTest(const uint8_t * rawData,size_t size)69 bool UnlockFuzzTest(const uint8_t *rawData, size_t size)
70 {
71 EventListener eventListener;
72 sptr<ScreenlockCallback> listener_ = new ScreenlockCallback(eventListener);
73 if (size < LENGTH) {
74 return true;
75 }
76 int32_t ret = ScreenLockManager::GetInstance()->Unlock(static_cast<Action>(rawData[0] % 3), listener_);
77 return ret == E_SCREENLOCK_OK;
78 }
79
IsLockedFuzzTest(const uint8_t * rawData,size_t size)80 bool IsLockedFuzzTest(const uint8_t *rawData, size_t size)
81 {
82 if (size < LENGTH) {
83 return true;
84 }
85 bool isLocked = static_cast<bool>(rawData[0] % 2);
86 int32_t ret = ScreenLockManager::GetInstance()->IsLocked(isLocked);
87 return ret == E_SCREENLOCK_OK;
88 }
89
FuzzScreenlockAppManager(const uint8_t * rawData,size_t size)90 bool FuzzScreenlockAppManager(const uint8_t *rawData, size_t size)
91 {
92 uint32_t code = ConvertToUint32(rawData);
93 rawData = rawData + OFFSET;
94 size = size - OFFSET;
95 EventListener eventListener;
96 if (code == RANDNUM_ZERO) {
97 sptr<ScreenlockSystemAbilityCallback> listener_ = new ScreenlockSystemAbilityCallback(eventListener);
98 int32_t ret = ScreenLockManager::GetInstance()->OnSystemEvent(listener_);
99 return ret == E_SCREENLOCK_OK;
100 }
101 if (code == RANDNUM_ONE) {
102 int param = 0;
103 std::string event(reinterpret_cast<const char *>(rawData), size);
104 int32_t ret = ScreenLockManager::GetInstance()->SendScreenLockEvent(event, param);
105 return ret == E_SCREENLOCK_OK;
106 }
107 return true;
108 }
109
FuzzScreenlockIsDisabled(const uint8_t * rawData,size_t size)110 bool FuzzScreenlockIsDisabled(const uint8_t *rawData, size_t size)
111 {
112 if (size < LENGTH) {
113 return true;
114 }
115 int32_t userId = 100;
116 bool isDisabled = static_cast<bool>(rawData[0] % 2);
117 int32_t ret = ScreenLockManager::GetInstance()->IsScreenLockDisabled(userId, isDisabled);
118 return ret == E_SCREENLOCK_OK;
119 }
120
FuzzScreenlockSetDisabled(const uint8_t * rawData,size_t size)121 bool FuzzScreenlockSetDisabled(const uint8_t *rawData, size_t size)
122 {
123 if (size < LENGTH) {
124 return true;
125 }
126 int32_t userId = 100;
127 bool isDisabled = static_cast<bool>(rawData[0] % 2);
128 int32_t ret = ScreenLockManager::GetInstance()->SetScreenLockDisabled(isDisabled, userId);
129 return ret == E_SCREENLOCK_OK;
130 }
131
FuzzScreenlockSetAuthState(const uint8_t * rawData,size_t size)132 bool FuzzScreenlockSetAuthState(const uint8_t *rawData, size_t size)
133 {
134 if (size < LENGTH) {
135 return true;
136 }
137 int32_t userId = 100;
138 int32_t authState = 2;
139 std::string authToken = "test";
140 int32_t ret = ScreenLockManager::GetInstance()->SetScreenLockAuthState(authState, userId, authToken);
141 return ret == E_SCREENLOCK_OK;
142 }
143
FuzzScreenlockGetAuthState(const uint8_t * rawData,size_t size)144 bool FuzzScreenlockGetAuthState(const uint8_t *rawData, size_t size)
145 {
146 if (size < LENGTH) {
147 return true;
148 }
149 int32_t userId = 100;
150 int32_t authState = 2;
151 int32_t ret = ScreenLockManager::GetInstance()->GetScreenLockAuthState(userId, authState);
152 return ret == E_SCREENLOCK_OK;
153 }
154
FuzzScreenlockRequestStrongAuth(const uint8_t * rawData,size_t size)155 bool FuzzScreenlockRequestStrongAuth(const uint8_t *rawData, size_t size)
156 {
157 if (size < LENGTH) {
158 return true;
159 }
160 int32_t userId = 100;
161 int reasonFlag = 1;
162 int32_t ret = ScreenLockManager::GetInstance()->RequestStrongAuth(reasonFlag, userId);
163 return ret == E_SCREENLOCK_OK;
164 }
165
FuzzScreenlockGetStrongAuth(const uint8_t * rawData,size_t size)166 bool FuzzScreenlockGetStrongAuth(const uint8_t *rawData, size_t size)
167 {
168 if (size < LENGTH) {
169 return true;
170 }
171 int32_t userId = 100;
172 int reasonFlag = 1;
173 int32_t ret = ScreenLockManager::GetInstance()->GetStrongAuth(userId, reasonFlag);
174 return ret == E_SCREENLOCK_OK;
175 }
176
FuzzRegisterStrongAuthListener(const uint8_t * rawData,size_t size)177 bool FuzzRegisterStrongAuthListener(const uint8_t *rawData, size_t size)
178 {
179 if (size < LENGTH) {
180 return true;
181 }
182 if (StrongAuthListenerTest1 == nullptr) {
183 StrongAuthListenerTest1 = new (std::nothrow) StrongAuthListenerTest(DEFAULT_USER);
184 }
185 int32_t ret = ScreenLockManager::GetInstance()->RegisterStrongAuthListener(StrongAuthListenerTest1);
186 ScreenLockManager::GetInstance()->UnRegisterStrongAuthListener(StrongAuthListenerTest1);
187 return ret == E_SCREENLOCK_OK;
188 }
189
FuzzRegisterDeviceLockedListener(const uint8_t * rawData,size_t size)190 bool FuzzRegisterDeviceLockedListener(const uint8_t *rawData, size_t size)
191 {
192 if (size < LENGTH) {
193 return true;
194 }
195 if (DeviceLockedListenerTest1 == nullptr) {
196 DeviceLockedListenerTest1 = new (std::nothrow) DeviceLockedListenerTest(DEFAULT_USER);
197 }
198 int32_t ret = ScreenLockManager::GetInstance()->RegisterDeviceLockedListener(DeviceLockedListenerTest1);
199 ScreenLockManager::GetInstance()->UnRegisterDeviceLockedListener(DeviceLockedListenerTest1);
200 return ret == E_SCREENLOCK_OK;
201 }
202
FuzzIsDeviceLocked(const uint8_t * rawData,size_t size)203 bool FuzzIsDeviceLocked(const uint8_t *rawData, size_t size)
204 {
205 if (size < LENGTH) {
206 return true;
207 }
208 int32_t userId = rawData[0];
209 bool isDeviceLocked = static_cast<bool>(rawData[0] % 2);
210 int32_t ret = ScreenLockManager::GetInstance()->IsDeviceLocked(userId, isDeviceLocked);
211 if (userId != DEFAULT_USER) {
212 return ret == E_SCREENLOCK_USER_ID_INVALID;
213 } else {
214 return ret == E_SCREENLOCK_OK;
215 }
216 }
217
FuzzIsLockedWithUserId(const uint8_t * rawData,size_t size)218 bool FuzzIsLockedWithUserId(const uint8_t *rawData, size_t size)
219 {
220 if (size < LENGTH) {
221 return true;
222 }
223 int32_t userId = rawData[0];
224 bool isLocked = static_cast<bool>(rawData[0] % 2);
225 int32_t ret = ScreenLockManager::GetInstance()->IsLockedWithUserId(userId, isLocked);
226 if (userId != DEFAULT_USER) {
227 return ret == E_SCREENLOCK_USER_ID_INVALID;
228 } else {
229 return ret == E_SCREENLOCK_OK;
230 }
231 }
232
233 } // namespace OHOS
234
235 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)236 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
237 {
238 if (size < OHOS::THRESHOLD) {
239 return 0;
240 }
241
242 /* Run your code on data */
243 OHOS::FuzzScreenlockManager(data, size);
244 OHOS::UnlockFuzzTest(data, size);
245 OHOS::IsLockedFuzzTest(data, size);
246 OHOS::FuzzScreenlockAppManager(data, size);
247 OHOS::FuzzScreenlockIsDisabled(data, size);
248 OHOS::FuzzScreenlockSetDisabled(data, size);
249 OHOS::FuzzScreenlockSetAuthState(data, size);
250 OHOS::FuzzScreenlockGetAuthState(data, size);
251 OHOS::FuzzScreenlockRequestStrongAuth(data, size);
252 OHOS::FuzzScreenlockGetStrongAuth(data, size);
253 OHOS::FuzzRegisterStrongAuthListener(data, size);
254 OHOS::FuzzRegisterDeviceLockedListener(data, size);
255 OHOS::FuzzIsDeviceLocked(data, size);
256 OHOS::FuzzIsLockedWithUserId(data, size);
257 return 0;
258 }