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 
16 #include "activateosaccountstub_fuzzer.h"
17 #include <string>
18 #include <thread>
19 #include <vector>
20 
21 #include "fuzz_data.h"
22 #include "ios_account.h"
23 #include "os_account_manager_service.h"
24 
25 using namespace std;
26 using namespace OHOS::AccountSA;
27 
28 namespace OHOS {
29 const int ENUM_TYPE_MAX = 5;
30 const int PRIVATE_NUMBER = 3;
31 const int END_NUMBER = 4;
32 const std::u16string IOS_ACCOUNT_DESCRIPTOR = u"ohos.accountfwk.IOsAccount";
ActivateOsAccountStubFuzzTest(const uint8_t * data,size_t size)33 bool ActivateOsAccountStubFuzzTest(const uint8_t *data, size_t size)
34 {
35     if ((data == nullptr) || (size == 0)) {
36         return false;
37     }
38 
39     MessageParcel datas;
40     FuzzData fuzzData(data, size);
41     datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR);
42 
43     if (!datas.WriteInt32(fuzzData.GetData<int32_t>())) {
44         return false;
45     }
46 
47     MessageParcel reply;
48     MessageOption option;
49     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
50     osAccountManagerService_ ->OnRemoteRequest(
51         static_cast<int32_t>(OsAccountInterfaceCode::ACTIVATE_OS_ACCOUNT), datas, reply, option);
52 
53     return true;
54 }
55 
ProcCreateOsAccountWithFullInfoStubFuzzTest(const uint8_t * data,size_t size)56 bool ProcCreateOsAccountWithFullInfoStubFuzzTest(const uint8_t *data, size_t size)
57 {
58     if ((data == nullptr) || (size == 0)) {
59         return false;
60     }
61 
62     MessageParcel datas;
63     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
64         return false;
65     }
66 
67     FuzzData fuzzData(data, size);
68 
69     OsAccountInfo osAccountInfo;
70     osAccountInfo.SetLocalId(fuzzData.GetData<int>());
71     osAccountInfo.SetLocalName(fuzzData.GenerateRandomString());
72     osAccountInfo.SetShortName(fuzzData.GenerateRandomString());
73     int typeNumber = fuzzData.GetData<int>() % ENUM_TYPE_MAX;
74     if (typeNumber == PRIVATE_NUMBER) {
75         osAccountInfo.SetType(PRIVATE);
76     } else if (typeNumber == END_NUMBER) {
77         osAccountInfo.SetType(END);
78     } else {
79         OsAccountType testType = static_cast<OsAccountType>(typeNumber);
80         osAccountInfo.SetType(testType);
81     }
82     osAccountInfo.SetSerialNumber(fuzzData.GetData<int64_t>());
83 
84     if (!datas.WriteParcelable(&osAccountInfo)) {
85         return false;
86     }
87 
88     MessageParcel reply;
89     MessageOption option;
90     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
91     osAccountManagerService_->OnRemoteRequest(
92         static_cast<int32_t>(OsAccountInterfaceCode::CREATE_OS_ACCOUNT_WITH_FULL_INFO), datas, reply, option);
93 
94     return true;
95 }
96 
ProcDeactivateAllOsAccountsStubFuzzTest(const uint8_t * data,size_t size)97 bool ProcDeactivateAllOsAccountsStubFuzzTest(const uint8_t *data, size_t size)
98 {
99     if ((data == nullptr) || (size == 0)) {
100         return false;
101     }
102 
103     MessageParcel datas;
104     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
105         return false;
106     }
107 
108     MessageParcel reply;
109     MessageOption option;
110     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
111     osAccountManagerService_->OnRemoteRequest(
112         static_cast<int32_t>(OsAccountInterfaceCode::DEACTIVATE_ALL_OS_ACCOUNTS), datas, reply, option);
113 
114     return true;
115 }
116 
ProcGetBackgroundOsAccountLocalIdsStubFuzzTest(const uint8_t * data,size_t size)117 bool ProcGetBackgroundOsAccountLocalIdsStubFuzzTest(const uint8_t *data, size_t size)
118 {
119     if ((data == nullptr) || (size == 0)) {
120         return false;
121     }
122 
123     MessageParcel datas;
124     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
125         return false;
126     }
127 
128     MessageParcel reply;
129     MessageOption option;
130     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
131     osAccountManagerService_->OnRemoteRequest(
132         static_cast<int32_t>(OsAccountInterfaceCode::GET_BACKGROUND_OS_ACCOUNT_LOCAL_IDS), datas, reply, option);
133 
134     return true;
135 }
136 
ProcGetCreatedOsAccountNumFromDatabaseStubFuzzTest(const uint8_t * data,size_t size)137 bool ProcGetCreatedOsAccountNumFromDatabaseStubFuzzTest(const uint8_t *data, size_t size)
138 {
139     if ((data == nullptr) || (size == 0)) {
140         return false;
141     }
142 
143     MessageParcel datas;
144     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
145         return false;
146     }
147 
148     FuzzData fuzzData(data, size);
149     if (!datas.WriteString(fuzzData.GenerateRandomString())) {
150         return false;
151     }
152 
153     MessageParcel reply;
154     MessageOption option;
155     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
156     osAccountManagerService_->OnRemoteRequest(
157         static_cast<int32_t>(OsAccountInterfaceCode::GET_CREATED_OS_ACCOUNT_NUM_FROM_DATABASE), datas, reply, option);
158 
159     return true;
160 }
161 
ProcGetDefaultActivatedOsAccountStubFuzzTest(const uint8_t * data,size_t size)162 bool ProcGetDefaultActivatedOsAccountStubFuzzTest(const uint8_t *data, size_t size)
163 {
164     if ((data == nullptr) || (size == 0)) {
165         return false;
166     }
167 
168     MessageParcel datas;
169     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
170         return false;
171     }
172 
173     MessageParcel reply;
174     MessageOption option;
175     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
176     osAccountManagerService_->OnRemoteRequest(
177         static_cast<int32_t>(OsAccountInterfaceCode::GET_DEFAULT_ACTIVATED_OS_ACCOUNT), datas, reply, option);
178 
179     return true;
180 }
181 
ProcGetForegroundOsAccountsStubFuzzTest(const uint8_t * data,size_t size)182 bool ProcGetForegroundOsAccountsStubFuzzTest(const uint8_t *data, size_t size)
183 {
184     if ((data == nullptr) || (size == 0)) {
185         return false;
186     }
187 
188     MessageParcel datas;
189     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
190         return false;
191     }
192 
193     MessageParcel reply;
194     MessageOption option;
195     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
196     osAccountManagerService_->OnRemoteRequest(
197         static_cast<int32_t>(OsAccountInterfaceCode::GET_FOREGROUND_OS_ACCOUNTS), datas, reply, option);
198 
199     return true;
200 }
201 
ProcGetMaxAllowCreateIdFromDatabaseStubFuzzTest(const uint8_t * data,size_t size)202 bool ProcGetMaxAllowCreateIdFromDatabaseStubFuzzTest(const uint8_t *data, size_t size)
203 {
204     if ((data == nullptr) || (size == 0)) {
205         return false;
206     }
207 
208     MessageParcel datas;
209     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
210         return false;
211     }
212 
213     FuzzData fuzzData(data, size);
214     if (!datas.WriteString(fuzzData.GenerateRandomString())) {
215         return false;
216     }
217 
218     MessageParcel reply;
219     MessageOption option;
220     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
221     osAccountManagerService_->OnRemoteRequest(
222         static_cast<int32_t>(OsAccountInterfaceCode::GET_MAX_ALLOW_CREATE_ID_FROM_DATABASE), datas, reply, option);
223 
224     return true;
225 }
226 
ProcGetOsAccountFromDatabaseStubFuzzTest(const uint8_t * data,size_t size)227 bool ProcGetOsAccountFromDatabaseStubFuzzTest(const uint8_t *data, size_t size)
228 {
229     if ((data == nullptr) || (size == 0)) {
230         return false;
231     }
232 
233     MessageParcel datas;
234     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
235         return false;
236     }
237 
238     FuzzData fuzzData(data, size);
239     if (!datas.WriteString(fuzzData.GenerateRandomString())) {
240         return false;
241     }
242 
243     if (!datas.WriteInt32(fuzzData.GetData<int32_t>())) {
244         return false;
245     }
246 
247     MessageParcel reply;
248     MessageOption option;
249     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
250     osAccountManagerService_->OnRemoteRequest(
251         static_cast<int32_t>(OsAccountInterfaceCode::GET_OS_ACCOUNT_FROM_DATABASE), datas, reply, option);
252 
253     return true;
254 }
255 
ProcGetOsAccountListFromDatabaseStubFuzzTest(const uint8_t * data,size_t size)256 bool ProcGetOsAccountListFromDatabaseStubFuzzTest(const uint8_t *data, size_t size)
257 {
258     if ((data == nullptr) || (size == 0)) {
259         return false;
260     }
261 
262     MessageParcel datas;
263     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
264         return false;
265     }
266 
267     FuzzData fuzzData(data, size);
268     if (!datas.WriteString(fuzzData.GenerateRandomString())) {
269         return false;
270     }
271 
272     MessageParcel reply;
273     MessageOption option;
274     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
275     osAccountManagerService_->OnRemoteRequest(
276         static_cast<int32_t>(OsAccountInterfaceCode::GET_OS_ACCOUNT_LIST_FROM_DATABASE), datas, reply, option);
277 
278     return true;
279 }
280 
ProcGetOsAccountShortNameStubFuzzTest(const uint8_t * data,size_t size)281 bool ProcGetOsAccountShortNameStubFuzzTest(const uint8_t *data, size_t size)
282 {
283     if ((data == nullptr) || (size == 0)) {
284         return false;
285     }
286 
287     MessageParcel datas;
288     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
289         return false;
290     }
291 
292     MessageParcel reply;
293     MessageOption option;
294     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
295     osAccountManagerService_->OnRemoteRequest(
296         static_cast<int32_t>(OsAccountInterfaceCode::GET_OS_ACCOUNT_SHORT_NAME), datas, reply, option);
297 
298     return true;
299 }
300 
ProcGetOsAccountTypeFromProcessStubFuzzTest(const uint8_t * data,size_t size)301 bool ProcGetOsAccountTypeFromProcessStubFuzzTest(const uint8_t *data, size_t size)
302 {
303     if ((data == nullptr) || (size == 0)) {
304         return false;
305     }
306 
307     MessageParcel datas;
308     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
309         return false;
310     }
311 
312     MessageParcel reply;
313     MessageOption option;
314     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
315     osAccountManagerService_->OnRemoteRequest(
316         static_cast<int32_t>(OsAccountInterfaceCode::GET_OS_ACCOUNT_TYPE_FROM_PROCESS), datas, reply, option);
317 
318     return true;
319 }
320 
ProcGetSerialNumberFromDatabaseStubFuzzTest(const uint8_t * data,size_t size)321 bool ProcGetSerialNumberFromDatabaseStubFuzzTest(const uint8_t *data, size_t size)
322 {
323     if ((data == nullptr) || (size == 0)) {
324         return false;
325     }
326 
327     MessageParcel datas;
328     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
329         return false;
330     }
331 
332     FuzzData fuzzData(data, size);
333     if (!datas.WriteString(fuzzData.GenerateRandomString())) {
334         return false;
335     }
336 
337     MessageParcel reply;
338     MessageOption option;
339     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
340     osAccountManagerService_->OnRemoteRequest(
341         static_cast<int32_t>(OsAccountInterfaceCode::GET_SERIAL_NUM_FROM_DATABASE), datas, reply, option);
342 
343     return true;
344 }
345 
ProcIsCurrentOsAccountVerifiedStubFuzzTest(const uint8_t * data,size_t size)346 bool ProcIsCurrentOsAccountVerifiedStubFuzzTest(const uint8_t *data, size_t size)
347 {
348     if ((data == nullptr) || (size == 0)) {
349         return false;
350     }
351 
352     MessageParcel datas;
353     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
354         return false;
355     }
356 
357     MessageParcel reply;
358     MessageOption option;
359     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
360     osAccountManagerService_->OnRemoteRequest(
361         static_cast<int32_t>(OsAccountInterfaceCode::IS_CURRENT_OS_ACCOUNT_VERIFIED), datas, reply, option);
362 
363     return true;
364 }
365 
ProcIsMultiOsAccountEnableStubFuzzTest(const uint8_t * data,size_t size)366 bool ProcIsMultiOsAccountEnableStubFuzzTest(const uint8_t *data, size_t size)
367 {
368     if ((data == nullptr) || (size == 0)) {
369         return false;
370     }
371 
372     MessageParcel datas;
373     if (!datas.WriteInterfaceToken(IOS_ACCOUNT_DESCRIPTOR)) {
374         return false;
375     }
376 
377     MessageParcel reply;
378     MessageOption option;
379     auto osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
380     osAccountManagerService_->OnRemoteRequest(
381         static_cast<int32_t>(OsAccountInterfaceCode::IS_MULTI_OS_ACCOUNT_ENABLE), datas, reply, option);
382 
383     return true;
384 }
385 } // namespace OHOS
386 
387 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)388 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
389 {
390     /* Run your code on data */
391     OHOS::ActivateOsAccountStubFuzzTest(data, size);
392     OHOS::ProcGetCreatedOsAccountNumFromDatabaseStubFuzzTest(data, size);
393     OHOS::ProcDeactivateAllOsAccountsStubFuzzTest(data, size);
394     OHOS::ProcCreateOsAccountWithFullInfoStubFuzzTest(data, size);
395     OHOS::ProcGetBackgroundOsAccountLocalIdsStubFuzzTest(data, size);
396     OHOS::ProcGetDefaultActivatedOsAccountStubFuzzTest(data, size);
397     OHOS::ProcGetForegroundOsAccountsStubFuzzTest(data, size);
398     OHOS::ProcGetMaxAllowCreateIdFromDatabaseStubFuzzTest(data, size);
399     OHOS::ProcGetOsAccountFromDatabaseStubFuzzTest(data, size);
400     OHOS::ProcGetOsAccountListFromDatabaseStubFuzzTest(data, size);
401     OHOS::ProcGetOsAccountShortNameStubFuzzTest(data, size);
402     OHOS::ProcGetOsAccountTypeFromProcessStubFuzzTest(data, size);
403     OHOS::ProcGetSerialNumberFromDatabaseStubFuzzTest(data, size);
404     OHOS::ProcIsCurrentOsAccountVerifiedStubFuzzTest(data, size);
405     OHOS::ProcIsMultiOsAccountEnableStubFuzzTest(data, size);
406     return 0;
407 }
408