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