1 /*
2  * Copyright (c) 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 #include "cloudsyncservicestub_fuzzer.h"
16 
17 #include <cstddef>
18 #include <cstdint>
19 #include <fcntl.h>
20 #include <map>
21 
22 #include "accesstoken_kit.h"
23 #include "cloud_file_sync_service_interface_code.h"
24 #include "cloud_fuzzer_helper.h"
25 #include "cloud_sync_service.h"
26 #include "cloud_sync_service_stub.h"
27 #include "i_cloud_download_callback.h"
28 #include "i_cloud_sync_callback.h"
29 #include "i_download_asset_callback.h"
30 #include "task_state_manager.h"
31 
32 #include "message_parcel.h"
33 #include "nativetoken_kit.h"
34 #include "token_setproc.h"
35 #include "utils_log.h"
36 
37 namespace OHOS {
38 constexpr size_t U32_AT_SIZE = 4;
39 constexpr size_t U64_AT_SIZE = 8;
40 constexpr size_t BOOL_AT_SIZE = 1;
41 constexpr int SPLITE_SIZE = 5;
42 const std::u16string CLOUD_SYNC_SERVICE_TOKEN = u"OHOS.Filemanagement.Dfs.ICloudSyncService";
43 constexpr int32_t SERVICE_SA_ID = 5204;
44 
45 using namespace OHOS::FileManagement::CloudSync;
46 using namespace std;
47 class ICloudSyncCallbackTest : public IRemoteStub<ICloudSyncCallback> {
48 public:
OnSyncStateChanged(SyncType type,SyncPromptState state)49     void OnSyncStateChanged(SyncType type, SyncPromptState state) override {}
OnSyncStateChanged(CloudSyncState state,ErrorType error)50     void OnSyncStateChanged(CloudSyncState state, ErrorType error) override {}
51 };
52 
53 class ICloudDownloadCallbackTest : public IRemoteStub<ICloudDownloadCallback> {
54 public:
OnDownloadProcess(const DownloadProgressObj & progress)55     void OnDownloadProcess(const DownloadProgressObj &progress) override {}
56 };
57 
58 class IDownloadAssetCallbackTest : public IRemoteStub<IDownloadAssetCallback> {
59 public:
OnFinished(const TaskId taskId,const std::string & uri,const int32_t result)60     void OnFinished(const TaskId taskId, const std::string &uri, const int32_t result) override {}
61 };
62 
NativeTokenGet(bool isSystem)63 void NativeTokenGet(bool isSystem)
64 {
65     uint64_t tokenId;
66     static const char *perms[] = {"ohos.permission.CLOUDFILE_SYNC", "ohos.permission.CLOUDFILE_SYNC_MANAGER",
67                                   "ohos.permission.PROXY_AUTHORIZATION_URI"};
68     NativeTokenInfoParams infoInstance = {
69         .dcapsNum = 0,
70         .permsNum = 3,
71         .aclsNum = 0,
72         .dcaps = nullptr,
73         .perms = perms,
74         .acls = nullptr,
75         .aplStr = "system_core",
76     };
77 
78     infoInstance.processName = "CloudOnRemoteRequestFuzzerTest";
79     tokenId = GetAccessTokenId(&infoInstance);
80     if (isSystem) {
81         const uint64_t systemAppMask = (static_cast<uint64_t>(1) << 32);
82         tokenId |= systemAppMask;
83     }
84     SetSelfTokenID(tokenId);
85     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
86 }
87 
WriteInterfaceToken(MessageParcel & data)88 bool WriteInterfaceToken(MessageParcel &data)
89 {
90     if (!data.WriteInterfaceToken(CLOUD_SYNC_SERVICE_TOKEN)) {
91         LOGE("Write token failed.");
92         return false;
93     }
94     return true;
95 }
96 
HandleChangeAppSwitchFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)97 void HandleChangeAppSwitchFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
98                                    FuzzData &fuzzData,
99                                    size_t size)
100 {
101     fuzzData.ResetData(size);
102     MessageParcel datas;
103     if (!WriteInterfaceToken(datas)) {
104         return;
105     }
106     bool status = fuzzData.GetData<bool>();
107     int pos = static_cast<int>((size - BOOL_AT_SIZE) >> 1);
108     std::string accountId = fuzzData.GetStringFromData(pos);
109     std::string bundleName = fuzzData.GetStringFromData(pos);
110     datas.WriteString(accountId);
111     datas.WriteString(bundleName);
112     datas.WriteBool(status);
113     datas.RewindRead(0);
114     // SERVICE_CMD_CHANGE_APP_SWITCH
115     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CHANGE_APP_SWITCH);
116     MessageParcel reply;
117     MessageOption option;
118 
119     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
120 }
121 
HandleCleanFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)122 void HandleCleanFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr, FuzzData &fuzzData, size_t size)
123 {
124     fuzzData.ResetData(size);
125     MessageParcel datas;
126     if (!WriteInterfaceToken(datas)) {
127         return;
128     }
129     std::string uri = fuzzData.GetStringFromData(static_cast<int>(size));
130     datas.WriteString(uri);
131     datas.RewindRead(0);
132     // SERVICE_CMD_CLEAN
133     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CLEAN);
134     MessageParcel reply;
135     MessageOption option;
136 
137     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
138 }
139 
HandleDeleteAssetFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)140 void HandleDeleteAssetFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
141                                FuzzData &fuzzData,
142                                size_t size)
143 {
144     fuzzData.ResetData(size);
145     MessageParcel datas;
146     if (!WriteInterfaceToken(datas)) {
147         return;
148     }
149     int32_t userId = fuzzData.GetData<int32_t>();
150     datas.WriteInt32(userId);
151     int len = static_cast<int>(size - U32_AT_SIZE);
152     std::string uri = fuzzData.GetStringFromData(len);
153     datas.WriteString(uri);
154     datas.RewindRead(0);
155     // SERVICE_CMD_DELETE_ASSET
156     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DELETE_ASSET);
157     MessageParcel reply;
158     MessageOption option;
159 
160     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
161 }
162 
HandleDisableCloudFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)163 void HandleDisableCloudFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
164                                 FuzzData &fuzzData,
165                                 size_t size)
166 {
167     fuzzData.ResetData(size);
168     MessageParcel datas;
169     if (!WriteInterfaceToken(datas)) {
170         return;
171     }
172     string accountId = fuzzData.GetStringFromData(static_cast<int>(size));
173     datas.WriteString(accountId);
174     datas.RewindRead(0);
175     // SERVICE_CMD_DISABLE_CLOUD
176     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DISABLE_CLOUD);
177     MessageParcel reply;
178     MessageOption option;
179 
180     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
181 }
182 
HandleDownloadFileFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)183 void HandleDownloadFileFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
184                                 FuzzData &fuzzData,
185                                 size_t size)
186 {
187     fuzzData.ResetData(size);
188     MessageParcel datas;
189     if (!WriteInterfaceToken(datas)) {
190         return;
191     }
192     int32_t userId = fuzzData.GetData<int32_t>();
193     datas.WriteInt32(userId);
194     int pos = static_cast<int>(size - U32_AT_SIZE) / (SPLITE_SIZE + 1);
195     string bundleName = fuzzData.GetStringFromData(pos);
196     datas.WriteString(bundleName);
197     AssetInfo assetInfo = {.uri = fuzzData.GetStringFromData(pos),
198                            .recordType = fuzzData.GetStringFromData(pos),
199                            .recordId = fuzzData.GetStringFromData(pos),
200                            .fieldKey = fuzzData.GetStringFromData(pos),
201                            .assetName = fuzzData.GetStringFromData(pos)};
202     AssetInfoObj assetInfoObj(assetInfo);
203     datas.WriteParcelable(&assetInfoObj);
204     datas.RewindRead(0);
205     // SERVICE_CMD_DOWNLOAD_FILE
206     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_FILE);
207     MessageParcel reply;
208     MessageOption option;
209 
210     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
211 }
212 
HandleEnableCloudFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)213 void HandleEnableCloudFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
214                                FuzzData &fuzzData,
215                                size_t size)
216 {
217     fuzzData.ResetData(size);
218     MessageParcel datas;
219     if (!WriteInterfaceToken(datas)) {
220         return;
221     }
222     int pos = static_cast<int>(size >> 1);
223     string accountId = fuzzData.GetStringFromData(pos);
224     datas.WriteString(accountId);
225     int itemStrLen = pos / SPLITE_SIZE;
226     if (itemStrLen <= static_cast<int>(BOOL_AT_SIZE)) {
227         return;
228     }
229     std::map<string, bool> switchData;
230     for (int i = 0; i < SPLITE_SIZE; i++) {
231         string itemStr = fuzzData.GetStringFromData(itemStrLen - static_cast<int>(BOOL_AT_SIZE));
232         bool itemBool = fuzzData.GetData<bool>();
233         switchData.insert(pair<string, bool>(itemStr, itemBool));
234     }
235     SwitchDataObj switchDataObj;
236     switchDataObj.switchData = switchData;
237     datas.WriteParcelable(&switchDataObj);
238     datas.RewindRead(0);
239     // SERVICE_CMD_ENABLE_CLOUD
240     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_ENABLE_CLOUD);
241     MessageParcel reply;
242     MessageOption option;
243 
244     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
245 }
246 
HandleNotifyDataChangeFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)247 void HandleNotifyDataChangeFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
248                                     FuzzData &fuzzData,
249                                     size_t size)
250 {
251     fuzzData.ResetData(size);
252     MessageParcel datas;
253     if (!WriteInterfaceToken(datas)) {
254         return;
255     }
256     int pos = static_cast<int>(size >> 1);
257     string accountId = fuzzData.GetStringFromData(pos);
258     datas.WriteString(accountId);
259     string bundleName = fuzzData.GetStringFromData(pos);
260     datas.WriteString(bundleName);
261     datas.RewindRead(0);
262     // SERVICE_CMD_NOTIFY_DATA_CHANGE
263     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_NOTIFY_DATA_CHANGE);
264     MessageParcel reply;
265     MessageOption option;
266 
267     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
268 }
269 
HandleRegisterCallbackInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)270 void HandleRegisterCallbackInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
271                                          FuzzData &fuzzData,
272                                          size_t size)
273 {
274     fuzzData.ResetData(size);
275     MessageParcel datas;
276     if (!WriteInterfaceToken(datas)) {
277         return;
278     }
279     sptr<ICloudSyncCallbackTest> callback = new (std::nothrow) ICloudSyncCallbackTest();
280     if (callback == nullptr) {
281         return;
282     }
283     datas.WriteRemoteObject(callback->AsObject().GetRefPtr());
284     string bundleName = fuzzData.GetStringFromData(static_cast<int>(size));
285     datas.WriteString(bundleName);
286     datas.RewindRead(0);
287     // SERVICE_CMD_REGISTER_CALLBACK
288     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_CALLBACK);
289     MessageParcel reply;
290     MessageOption option;
291 
292     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
293 }
294 
HandleRegisterDownloadFileCallbackFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)295 void HandleRegisterDownloadFileCallbackFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
296                                                 FuzzData &fuzzData,
297                                                 size_t size)
298 {
299     fuzzData.ResetData(size);
300     MessageParcel datas;
301     if (!WriteInterfaceToken(datas)) {
302         return;
303     }
304     sptr<ICloudDownloadCallbackTest> callback = new (std::nothrow) ICloudDownloadCallbackTest();
305     if (callback == nullptr) {
306         return;
307     }
308     datas.WriteRemoteObject(callback->AsObject().GetRefPtr());
309     datas.RewindRead(0);
310     // SERVICE_CMD_REGISTER_DOWNLOAD_FILE_CALLBACK
311     uint32_t code =
312         static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_FILE_CALLBACK);
313     MessageParcel reply;
314     MessageOption option;
315 
316     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
317 }
318 
HandleStartDownloadFileFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)319 void HandleStartDownloadFileFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
320                                      FuzzData &fuzzData,
321                                      size_t size)
322 {
323     fuzzData.ResetData(size);
324     MessageParcel datas;
325     if (!WriteInterfaceToken(datas)) {
326         return;
327     }
328     string path = fuzzData.GetStringFromData(static_cast<int>(size));
329     datas.WriteString(path);
330     datas.RewindRead(0);
331     // SERVICE_CMD_START_DOWNLOAD_FILE
332     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_DOWNLOAD_FILE);
333     MessageParcel reply;
334     MessageOption option;
335 
336     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
337 }
338 
HandleStartSyncInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)339 void HandleStartSyncInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
340                                   FuzzData &fuzzData,
341                                   size_t size)
342 {
343     fuzzData.ResetData(size);
344     MessageParcel datas;
345     if (!WriteInterfaceToken(datas)) {
346         return;
347     }
348     auto forceFlag = fuzzData.GetData<bool>();
349     datas.WriteBool(forceFlag);
350     string bundleName = fuzzData.GetStringFromData(static_cast<int>(size - BOOL_AT_SIZE));
351     datas.WriteString(bundleName);
352     datas.RewindRead(0);
353     // SERVICE_CMD_START_SYNC
354     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_SYNC);
355     MessageParcel reply;
356     MessageOption option;
357 
358     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
359 }
360 
HandleStopDownloadFileFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)361 void HandleStopDownloadFileFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
362                                     FuzzData &fuzzData,
363                                     size_t size)
364 {
365     fuzzData.ResetData(size);
366     MessageParcel datas;
367     if (!WriteInterfaceToken(datas)) {
368         return;
369     }
370     string path = fuzzData.GetStringFromData(static_cast<int>(size));
371     datas.WriteString(path);
372     datas.RewindRead(0);
373     // SERVICE_CMD_STOP_DOWNLOAD_FILE
374     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_DOWNLOAD_FILE);
375     MessageParcel reply;
376     MessageOption option;
377 
378     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
379 }
380 
HandleStopSyncInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,const uint8_t * data,size_t size)381 void HandleStopSyncInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
382                                  const uint8_t *data,
383                                  size_t size)
384 {
385     MessageParcel datas;
386     if (!WriteInterfaceToken(datas)) {
387         return;
388     }
389     datas.WriteBuffer(data, size);
390     datas.RewindRead(0);
391     // SERVICE_CMD_STOP_SYNC
392     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_SYNC);
393     MessageParcel reply;
394     MessageOption option;
395 
396     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
397 }
398 
HandleUnRegisterCallbackInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)399 void HandleUnRegisterCallbackInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
400                                            FuzzData &fuzzData,
401                                            size_t size)
402 {
403     fuzzData.ResetData(size);
404     MessageParcel datas;
405     if (!WriteInterfaceToken(datas)) {
406         return;
407     }
408     string bundleName = fuzzData.GetStringFromData(static_cast<int>(size));
409     datas.WriteString(bundleName);
410     datas.RewindRead(0);
411     // SERVICE_CMD_UNREGISTER_CALLBACK
412     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_CALLBACK);
413     MessageParcel reply;
414     MessageOption option;
415 
416     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
417 }
418 
HandleUnRegisterDownloadFileCallbackFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,const uint8_t * data,size_t size)419 void HandleUnRegisterDownloadFileCallbackFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
420                                                   const uint8_t *data,
421                                                   size_t size)
422 {
423     MessageParcel datas;
424     if (!WriteInterfaceToken(datas)) {
425         return;
426     }
427     datas.WriteBuffer(data, size);
428     datas.RewindRead(0);
429     // SERVICE_CMD_UNREGISTER_DOWNLOAD_FILE_CALLBACK
430     uint32_t code =
431         static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_DOWNLOAD_FILE_CALLBACK);
432     MessageParcel reply;
433     MessageOption option;
434 
435     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
436 }
437 
HandleUploadAssetFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)438 void HandleUploadAssetFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
439                                FuzzData &fuzzData,
440                                size_t size)
441 {
442     fuzzData.ResetData(size);
443     MessageParcel datas;
444     if (!WriteInterfaceToken(datas)) {
445         return;
446     }
447     int32_t userId = fuzzData.GetData<int32_t>();
448     datas.WriteInt32(userId);
449     int len = static_cast<int32_t>(size - U32_AT_SIZE);
450     string request = fuzzData.GetStringFromData(len);
451     datas.WriteString(request);
452     datas.RewindRead(0);
453     // SERVICE_CMD_UPLOAD_ASSET
454     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UPLOAD_ASSET);
455     MessageParcel reply;
456     MessageOption option;
457 
458     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
459 }
460 
HandleTriggerSyncInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)461 void HandleTriggerSyncInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
462                                     FuzzData &fuzzData,
463                                     size_t size)
464 {
465     fuzzData.ResetData(size);
466     MessageParcel datas;
467     if (!WriteInterfaceToken(datas)) {
468         return;
469     }
470     int len = static_cast<int32_t>(size - U32_AT_SIZE);
471     string bundleName = fuzzData.GetStringFromData(len);
472     datas.WriteString(bundleName);
473     int32_t userId = fuzzData.GetData<int32_t>();
474     datas.WriteInt32(userId);
475     datas.RewindRead(0);
476     // SERVICE_CMD_TRIGGER_SYNC
477     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_TRIGGER_SYNC);
478     MessageParcel reply;
479     MessageOption option;
480 
481     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
482 }
483 
HandleNotifyEventChangeFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)484 void HandleNotifyEventChangeFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
485                                      FuzzData &fuzzData,
486                                      size_t size)
487 {
488     fuzzData.ResetData(size);
489     MessageParcel datas;
490     if (!WriteInterfaceToken(datas)) {
491         return;
492     }
493     int32_t userId = fuzzData.GetData<int32_t>();
494     datas.WriteInt32(userId);
495 
496     int pos = static_cast<int>((size - U32_AT_SIZE) >> 1);
497     string eventIdStr = fuzzData.GetStringFromData(pos);
498     string extraDataStr = fuzzData.GetStringFromData(pos);
499     datas.WriteString(eventIdStr);
500     datas.WriteString(extraDataStr);
501     datas.RewindRead(0);
502     // SERVICE_CMD_NOTIFY_EVENT_CHANGE
503     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_NOTIFY_EVENT_CHANGE);
504     MessageParcel reply;
505     MessageOption option;
506 
507     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
508 }
509 
HandleStartFileCacheFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)510 void HandleStartFileCacheFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
511                                   FuzzData &fuzzData,
512                                   size_t size)
513 {
514     fuzzData.ResetData(size);
515     MessageParcel datas;
516     if (!WriteInterfaceToken(datas)) {
517         return;
518     }
519     int32_t userId = fuzzData.GetData<int32_t>();
520     datas.WriteInt32(userId);
521     int pos = static_cast<int>((size - U32_AT_SIZE) >> 1);
522     string eventIdStr = fuzzData.GetStringFromData(pos);
523     string extraDataStr = fuzzData.GetStringFromData(pos);
524     datas.WriteString(eventIdStr);
525     datas.WriteString(extraDataStr);
526     datas.RewindRead(0);
527     // SERVICE_CMD_START_FILE_CACHE
528     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_FILE_CACHE);
529     MessageParcel reply;
530     MessageOption option;
531 
532     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
533 }
534 
HandleDownloadFilesFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)535 void HandleDownloadFilesFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
536                                  FuzzData &fuzzData,
537                                  size_t size)
538 {
539     fuzzData.ResetData(size);
540     MessageParcel datas;
541     if (!WriteInterfaceToken(datas)) {
542         return;
543     }
544     int32_t userId = fuzzData.GetData<int32_t>();
545     datas.WriteInt32(userId);
546     int32_t vecSize = fuzzData.GetData<int32_t>() % SPLITE_SIZE + 1;
547     auto remainSize = fuzzData.GetRemainSize();
548     if (static_cast<int>(remainSize) <= vecSize * SPLITE_SIZE + 1) {
549         return;
550     }
551     int len = static_cast<int>(remainSize / (vecSize * SPLITE_SIZE + 1));
552     string bundleName = fuzzData.GetStringFromData(len);
553     datas.WriteString(bundleName);
554     datas.WriteInt32(vecSize);
555     for (auto i = 0; i < vecSize; i++) {
556         AssetInfo assetInfo = {.uri = fuzzData.GetStringFromData(len),
557                                .recordType = fuzzData.GetStringFromData(len),
558                                .recordId = fuzzData.GetStringFromData(len),
559                                .fieldKey = fuzzData.GetStringFromData(len),
560                                .assetName = fuzzData.GetStringFromData(len)};
561         AssetInfoObj assetInfoObj(assetInfo);
562         datas.WriteParcelable(&assetInfoObj);
563     }
564     datas.RewindRead(0);
565     // SERVICE_CMD_DOWNLOAD_FILES
566     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_FILES);
567     MessageParcel reply;
568     MessageOption option;
569 
570     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
571 }
572 
HandleDownloadAssetFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)573 void HandleDownloadAssetFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
574                                  FuzzData &fuzzData,
575                                  size_t size)
576 {
577     fuzzData.ResetData(size);
578     MessageParcel datas;
579     if (!WriteInterfaceToken(datas)) {
580         return;
581     }
582     uint64_t taskId = fuzzData.GetData<uint64_t>();
583     datas.WriteUint64(taskId);
584     int32_t userId = fuzzData.GetData<int32_t>();
585     datas.WriteUint32(userId);
586     int len = static_cast<int>(fuzzData.GetRemainSize() >> 1);
587     string bundleName = fuzzData.GetStringFromData(len);
588     datas.WriteString(bundleName);
589     string networkId = fuzzData.GetStringFromData(len);
590     datas.WriteString(networkId);
591 
592     fuzzData.ResetData(size);
593     len = static_cast<int>(size) / SPLITE_SIZE;
594     AssetInfo assetInfo = {.uri = fuzzData.GetStringFromData(len),
595                            .recordType = fuzzData.GetStringFromData(len),
596                            .recordId = fuzzData.GetStringFromData(len),
597                            .fieldKey = fuzzData.GetStringFromData(len),
598                            .assetName = fuzzData.GetStringFromData(len)};
599     AssetInfoObj assetInfoObj(assetInfo);
600     datas.WriteParcelable(&assetInfoObj);
601     datas.RewindRead(0);
602     // SERVICE_CMD_DOWNLOAD_ASSET
603     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_ASSET);
604     MessageParcel reply;
605     MessageOption option;
606 
607     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
608 }
609 
HandleRegisterDownloadAssetCallbackFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)610 void HandleRegisterDownloadAssetCallbackFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
611                                                  FuzzData &fuzzData,
612                                                  size_t size)
613 {
614     fuzzData.ResetData(size);
615     MessageParcel datas;
616     if (!WriteInterfaceToken(datas)) {
617         return;
618     }
619     sptr<IDownloadAssetCallbackTest> callback = new (std::nothrow) IDownloadAssetCallbackTest();
620     if (callback == nullptr) {
621         return;
622     }
623     datas.WriteRemoteObject(callback->AsObject().GetRefPtr());
624     datas.RewindRead(0);
625     // SERVICE_CMD_REGISTER_DOWNLOAD_ASSET_CALLBACK
626     uint32_t code =
627         static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_ASSET_CALLBACK);
628     MessageParcel reply;
629     MessageOption option;
630 
631     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
632 }
633 
HandleGetSyncTimeFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)634 void HandleGetSyncTimeFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
635                                FuzzData &fuzzData,
636                                size_t size)
637 {
638     fuzzData.ResetData(size);
639     MessageParcel datas;
640     if (!WriteInterfaceToken(datas)) {
641         return;
642     }
643     string bundleName = fuzzData.GetStringFromData(static_cast<int>(size));
644     datas.WriteString(bundleName);
645     datas.RewindRead(0);
646     // SERVICE_CMD_GET_SYNC_TIME
647     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_GET_SYNC_TIME);
648     MessageParcel reply;
649     MessageOption option;
650 
651     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
652 }
653 
HandleCleanCacheFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)654 void HandleCleanCacheFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
655                               FuzzData &fuzzData,
656                               size_t size)
657 {
658     fuzzData.ResetData(size);
659     MessageParcel datas;
660     if (!WriteInterfaceToken(datas)) {
661         return;
662     }
663     string uri = fuzzData.GetStringFromData(static_cast<int>(size));
664     datas.WriteString(uri);
665     datas.RewindRead(0);
666     // SERVICE_CMD_CLEAN_CACHE
667     uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CLEAN_CACHE);
668     MessageParcel reply;
669     MessageOption option;
670 
671     cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
672 }
673 } // namespace OHOS
674 
675 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)676 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
677 {
678     /* Run your code on data */
679     if (data == nullptr || size < OHOS::U32_AT_SIZE * static_cast<size_t>(OHOS::SPLITE_SIZE)) {
680         return 0;
681     }
682 
683     OHOS::NativeTokenGet(true);
684     auto cloudSyncServiceStubStr =
685         std::make_shared<OHOS::FileManagement::CloudSync::CloudSyncService>(OHOS::SERVICE_SA_ID);
686     if (cloudSyncServiceStubStr == nullptr) {
687         return false;
688     }
689     if (cloudSyncServiceStubStr->dataSyncManager_ == nullptr) {
690         cloudSyncServiceStubStr->dataSyncManager_ =
691             std::make_shared<OHOS::FileManagement::CloudFile::DataSyncManager>();
692     }
693 
694     OHOS::FuzzData fuzzData(data, size);
695     OHOS::HandleChangeAppSwitchFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
696     OHOS::HandleCleanFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
697     OHOS::HandleDeleteAssetFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
698     OHOS::HandleDisableCloudFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
699     OHOS::HandleDownloadFileFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
700     OHOS::HandleEnableCloudFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
701     OHOS::HandleNotifyDataChangeFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
702     OHOS::HandleRegisterCallbackInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
703     OHOS::HandleRegisterDownloadFileCallbackFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
704     OHOS::HandleStartDownloadFileFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
705     OHOS::HandleStartSyncInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
706     OHOS::HandleStopDownloadFileFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
707     OHOS::HandleStopSyncInnerFuzzTest(cloudSyncServiceStubStr, data, size);
708     OHOS::HandleUnRegisterCallbackInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
709     OHOS::HandleUnRegisterDownloadFileCallbackFuzzTest(cloudSyncServiceStubStr, data, size);
710     OHOS::HandleUploadAssetFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
711     OHOS::HandleTriggerSyncInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
712     OHOS::HandleNotifyEventChangeFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
713     OHOS::HandleStartFileCacheFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
714     OHOS::HandleDownloadFilesFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
715     OHOS::HandleDownloadAssetFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
716     OHOS::HandleRegisterDownloadAssetCallbackFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
717     OHOS::HandleGetSyncTimeFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
718     OHOS::HandleCleanCacheFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
719     if (OHOS::FileManagement::CloudSync::TaskStateManager::GetInstance().unloadTaskHandle_ != nullptr) {
720         OHOS::FileManagement::CloudSync::TaskStateManager::GetInstance().queue_.wait(
721             OHOS::FileManagement::CloudSync::TaskStateManager::GetInstance().unloadTaskHandle_);
722     }
723     return 0;
724 }
725