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
37namespace OHOS {
38constexpr size_t U32_AT_SIZE = 4;
39constexpr size_t U64_AT_SIZE = 8;
40constexpr size_t BOOL_AT_SIZE = 1;
41constexpr int SPLITE_SIZE = 5;
42const std::u16string CLOUD_SYNC_SERVICE_TOKEN = u"OHOS.Filemanagement.Dfs.ICloudSyncService";
43constexpr int32_t SERVICE_SA_ID = 5204;
44
45using namespace OHOS::FileManagement::CloudSync;
46using namespace std;
47class ICloudSyncCallbackTest : public IRemoteStub<ICloudSyncCallback> {
48public:
49    void OnSyncStateChanged(SyncType type, SyncPromptState state) override {}
50    void OnSyncStateChanged(CloudSyncState state, ErrorType error) override {}
51};
52
53class ICloudDownloadCallbackTest : public IRemoteStub<ICloudDownloadCallback> {
54public:
55    void OnDownloadProcess(const DownloadProgressObj &progress) override {}
56};
57
58class IDownloadAssetCallbackTest : public IRemoteStub<IDownloadAssetCallback> {
59public:
60    void OnFinished(const TaskId taskId, const std::string &uri, const int32_t result) override {}
61};
62
63void 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
88bool 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
97void 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
122void 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
140void 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
163void 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
183void 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
213void 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
247void 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
270void 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
295void 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
319void 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
339void 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
361void 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
381void 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
399void 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
419void 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
438void 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
461void 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
484void 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
510void 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
535void 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
573void 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
610void 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
634void 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
654void 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 */
676extern "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->dataSyncManager_ == nullptr) {
687        cloudSyncServiceStubStr->dataSyncManager_ =
688            std::make_shared<OHOS::FileManagement::CloudFile::DataSyncManager>();
689    }
690
691    OHOS::FuzzData fuzzData(data, size);
692    OHOS::HandleChangeAppSwitchFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
693    OHOS::HandleCleanFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
694    OHOS::HandleDeleteAssetFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
695    OHOS::HandleDisableCloudFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
696    OHOS::HandleDownloadFileFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
697    OHOS::HandleEnableCloudFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
698    OHOS::HandleNotifyDataChangeFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
699    OHOS::HandleRegisterCallbackInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
700    OHOS::HandleRegisterDownloadFileCallbackFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
701    OHOS::HandleStartDownloadFileFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
702    OHOS::HandleStartSyncInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
703    OHOS::HandleStopDownloadFileFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
704    OHOS::HandleStopSyncInnerFuzzTest(cloudSyncServiceStubStr, data, size);
705    OHOS::HandleUnRegisterCallbackInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
706    OHOS::HandleUnRegisterDownloadFileCallbackFuzzTest(cloudSyncServiceStubStr, data, size);
707    OHOS::HandleUploadAssetFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
708    OHOS::HandleTriggerSyncInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
709    OHOS::HandleNotifyEventChangeFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
710    OHOS::HandleStartFileCacheFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
711    OHOS::HandleDownloadFilesFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
712    OHOS::HandleDownloadAssetFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
713    OHOS::HandleRegisterDownloadAssetCallbackFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
714    OHOS::HandleGetSyncTimeFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
715    OHOS::HandleCleanCacheFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
716    if (OHOS::FileManagement::CloudSync::TaskStateManager::GetInstance().unloadTaskHandle_ != nullptr) {
717        OHOS::FileManagement::CloudSync::TaskStateManager::GetInstance().queue_.wait(
718            OHOS::FileManagement::CloudSync::TaskStateManager::GetInstance().unloadTaskHandle_);
719    }
720    return 0;
721}
722