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
HandleStartDownloadFileFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)295 void HandleStartDownloadFileFuzzTest(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 int64_t downloadId = fuzzData.GetData<int64_t>();
305 int len = static_cast<int>(size - U64_AT_SIZE);
306 string path = fuzzData.GetStringFromData(len);
307 datas.WriteString(path);
308 sptr<ICloudDownloadCallbackTest> callback = new (std::nothrow) ICloudDownloadCallbackTest();
309 datas.WriteRemoteObject(callback->AsObject().GetRefPtr());
310 datas.WriteInt64(downloadId);
311 datas.RewindRead(0);
312 // SERVICE_CMD_START_DOWNLOAD_FILE
313 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_DOWNLOAD_FILE);
314 MessageParcel reply;
315 MessageOption option;
316
317 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
318 }
319
HandleStartSyncInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)320 void HandleStartSyncInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
321 FuzzData &fuzzData,
322 size_t size)
323 {
324 fuzzData.ResetData(size);
325 MessageParcel datas;
326 if (!WriteInterfaceToken(datas)) {
327 return;
328 }
329 auto forceFlag = fuzzData.GetData<bool>();
330 datas.WriteBool(forceFlag);
331 string bundleName = fuzzData.GetStringFromData(static_cast<int>(size - BOOL_AT_SIZE));
332 datas.WriteString(bundleName);
333 datas.RewindRead(0);
334 // SERVICE_CMD_START_SYNC
335 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_SYNC);
336 MessageParcel reply;
337 MessageOption option;
338
339 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
340 }
341
HandleStopDownloadFileFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)342 void HandleStopDownloadFileFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
343 FuzzData &fuzzData,
344 size_t size)
345 {
346 fuzzData.ResetData(size);
347 MessageParcel datas;
348 if (!WriteInterfaceToken(datas)) {
349 return;
350 }
351 int64_t downloadId = fuzzData.GetData<int64_t>();
352 int len = static_cast<int>(size - U64_AT_SIZE);
353 bool needClean = fuzzData.GetData<bool>();
354 datas.WriteInt64(downloadId);
355 datas.WriteBool(needClean);
356 datas.RewindRead(0);
357 // SERVICE_CMD_STOP_DOWNLOAD_FILE
358 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_DOWNLOAD_FILE);
359 MessageParcel reply;
360 MessageOption option;
361
362 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
363 }
364
HandleStopSyncInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,const uint8_t * data,size_t size)365 void HandleStopSyncInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
366 const uint8_t *data,
367 size_t size)
368 {
369 MessageParcel datas;
370 if (!WriteInterfaceToken(datas)) {
371 return;
372 }
373 datas.WriteBuffer(data, size);
374 datas.RewindRead(0);
375 // SERVICE_CMD_STOP_SYNC
376 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_SYNC);
377 MessageParcel reply;
378 MessageOption option;
379
380 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
381 }
382
HandleUnRegisterCallbackInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)383 void HandleUnRegisterCallbackInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
384 FuzzData &fuzzData,
385 size_t size)
386 {
387 fuzzData.ResetData(size);
388 MessageParcel datas;
389 if (!WriteInterfaceToken(datas)) {
390 return;
391 }
392 string bundleName = fuzzData.GetStringFromData(static_cast<int>(size));
393 datas.WriteString(bundleName);
394 datas.RewindRead(0);
395 // SERVICE_CMD_UNREGISTER_CALLBACK
396 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_CALLBACK);
397 MessageParcel reply;
398 MessageOption option;
399
400 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
401 }
402
HandleUploadAssetFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)403 void HandleUploadAssetFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
404 FuzzData &fuzzData,
405 size_t size)
406 {
407 fuzzData.ResetData(size);
408 MessageParcel datas;
409 if (!WriteInterfaceToken(datas)) {
410 return;
411 }
412 int32_t userId = fuzzData.GetData<int32_t>();
413 datas.WriteInt32(userId);
414 int len = static_cast<int32_t>(size - U32_AT_SIZE);
415 string request = fuzzData.GetStringFromData(len);
416 datas.WriteString(request);
417 datas.RewindRead(0);
418 // SERVICE_CMD_UPLOAD_ASSET
419 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UPLOAD_ASSET);
420 MessageParcel reply;
421 MessageOption option;
422
423 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
424 }
425
HandleTriggerSyncInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)426 void HandleTriggerSyncInnerFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
427 FuzzData &fuzzData,
428 size_t size)
429 {
430 fuzzData.ResetData(size);
431 MessageParcel datas;
432 if (!WriteInterfaceToken(datas)) {
433 return;
434 }
435 int len = static_cast<int32_t>(size - U32_AT_SIZE);
436 string bundleName = fuzzData.GetStringFromData(len);
437 datas.WriteString(bundleName);
438 int32_t userId = fuzzData.GetData<int32_t>();
439 datas.WriteInt32(userId);
440 datas.RewindRead(0);
441 // SERVICE_CMD_TRIGGER_SYNC
442 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_TRIGGER_SYNC);
443 MessageParcel reply;
444 MessageOption option;
445
446 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
447 }
448
HandleNotifyEventChangeFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)449 void HandleNotifyEventChangeFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
450 FuzzData &fuzzData,
451 size_t size)
452 {
453 fuzzData.ResetData(size);
454 MessageParcel datas;
455 if (!WriteInterfaceToken(datas)) {
456 return;
457 }
458 int32_t userId = fuzzData.GetData<int32_t>();
459 datas.WriteInt32(userId);
460
461 int pos = static_cast<int>((size - U32_AT_SIZE) >> 1);
462 string eventIdStr = fuzzData.GetStringFromData(pos);
463 string extraDataStr = fuzzData.GetStringFromData(pos);
464 datas.WriteString(eventIdStr);
465 datas.WriteString(extraDataStr);
466 datas.RewindRead(0);
467 // SERVICE_CMD_NOTIFY_EVENT_CHANGE
468 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_NOTIFY_EVENT_CHANGE);
469 MessageParcel reply;
470 MessageOption option;
471
472 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
473 }
474
HandleStartFileCacheFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)475 void HandleStartFileCacheFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
476 FuzzData &fuzzData,
477 size_t size)
478 {
479 fuzzData.ResetData(size);
480 MessageParcel datas;
481 if (!WriteInterfaceToken(datas)) {
482 return;
483 }
484 int32_t userId = fuzzData.GetData<int32_t>();
485 datas.WriteInt32(userId);
486 int pos = static_cast<int>((size - U32_AT_SIZE) >> 1);
487 string eventIdStr = fuzzData.GetStringFromData(pos);
488 string extraDataStr = fuzzData.GetStringFromData(pos);
489 datas.WriteString(eventIdStr);
490 datas.WriteString(extraDataStr);
491 datas.RewindRead(0);
492 // SERVICE_CMD_START_FILE_CACHE
493 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_FILE_CACHE);
494 MessageParcel reply;
495 MessageOption option;
496
497 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
498 }
499
HandleDownloadFilesFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)500 void HandleDownloadFilesFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
501 FuzzData &fuzzData,
502 size_t size)
503 {
504 fuzzData.ResetData(size);
505 MessageParcel datas;
506 if (!WriteInterfaceToken(datas)) {
507 return;
508 }
509 int32_t userId = fuzzData.GetData<int32_t>();
510 datas.WriteInt32(userId);
511 int32_t vecSize = fuzzData.GetData<int32_t>() % SPLITE_SIZE + 1;
512 auto remainSize = fuzzData.GetRemainSize();
513 if (static_cast<int>(remainSize) <= vecSize * SPLITE_SIZE + 1) {
514 return;
515 }
516 int len = static_cast<int>(remainSize / (vecSize * SPLITE_SIZE + 1));
517 string bundleName = fuzzData.GetStringFromData(len);
518 datas.WriteString(bundleName);
519 datas.WriteInt32(vecSize);
520 for (auto i = 0; i < vecSize; i++) {
521 AssetInfo assetInfo = {.uri = fuzzData.GetStringFromData(len),
522 .recordType = fuzzData.GetStringFromData(len),
523 .recordId = fuzzData.GetStringFromData(len),
524 .fieldKey = fuzzData.GetStringFromData(len),
525 .assetName = fuzzData.GetStringFromData(len)};
526 AssetInfoObj assetInfoObj(assetInfo);
527 datas.WriteParcelable(&assetInfoObj);
528 }
529 datas.RewindRead(0);
530 // SERVICE_CMD_DOWNLOAD_FILES
531 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_FILES);
532 MessageParcel reply;
533 MessageOption option;
534
535 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
536 }
537
HandleDownloadAssetFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)538 void HandleDownloadAssetFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
539 FuzzData &fuzzData,
540 size_t size)
541 {
542 fuzzData.ResetData(size);
543 MessageParcel datas;
544 if (!WriteInterfaceToken(datas)) {
545 return;
546 }
547 uint64_t taskId = fuzzData.GetData<uint64_t>();
548 datas.WriteUint64(taskId);
549 int32_t userId = fuzzData.GetData<int32_t>();
550 datas.WriteUint32(userId);
551 int len = static_cast<int>(fuzzData.GetRemainSize() >> 1);
552 string bundleName = fuzzData.GetStringFromData(len);
553 datas.WriteString(bundleName);
554 string networkId = fuzzData.GetStringFromData(len);
555 datas.WriteString(networkId);
556
557 fuzzData.ResetData(size);
558 len = static_cast<int>(size) / SPLITE_SIZE;
559 AssetInfo assetInfo = {.uri = fuzzData.GetStringFromData(len),
560 .recordType = fuzzData.GetStringFromData(len),
561 .recordId = fuzzData.GetStringFromData(len),
562 .fieldKey = fuzzData.GetStringFromData(len),
563 .assetName = fuzzData.GetStringFromData(len)};
564 AssetInfoObj assetInfoObj(assetInfo);
565 datas.WriteParcelable(&assetInfoObj);
566 datas.RewindRead(0);
567 // SERVICE_CMD_DOWNLOAD_ASSET
568 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_ASSET);
569 MessageParcel reply;
570 MessageOption option;
571
572 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
573 }
574
HandleRegisterDownloadAssetCallbackFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)575 void HandleRegisterDownloadAssetCallbackFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
576 FuzzData &fuzzData,
577 size_t size)
578 {
579 fuzzData.ResetData(size);
580 MessageParcel datas;
581 if (!WriteInterfaceToken(datas)) {
582 return;
583 }
584 sptr<IDownloadAssetCallbackTest> callback = new (std::nothrow) IDownloadAssetCallbackTest();
585 if (callback == nullptr) {
586 return;
587 }
588 datas.WriteRemoteObject(callback->AsObject().GetRefPtr());
589 datas.RewindRead(0);
590 // SERVICE_CMD_REGISTER_DOWNLOAD_ASSET_CALLBACK
591 uint32_t code =
592 static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_ASSET_CALLBACK);
593 MessageParcel reply;
594 MessageOption option;
595
596 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
597 }
598
HandleGetSyncTimeFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)599 void HandleGetSyncTimeFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
600 FuzzData &fuzzData,
601 size_t size)
602 {
603 fuzzData.ResetData(size);
604 MessageParcel datas;
605 if (!WriteInterfaceToken(datas)) {
606 return;
607 }
608 string bundleName = fuzzData.GetStringFromData(static_cast<int>(size));
609 datas.WriteString(bundleName);
610 datas.RewindRead(0);
611 // SERVICE_CMD_GET_SYNC_TIME
612 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_GET_SYNC_TIME);
613 MessageParcel reply;
614 MessageOption option;
615
616 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
617 }
618
HandleCleanCacheFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,FuzzData & fuzzData,size_t size)619 void HandleCleanCacheFuzzTest(std::shared_ptr<CloudSyncServiceStub> cloudSyncServiceStubStr,
620 FuzzData &fuzzData,
621 size_t size)
622 {
623 fuzzData.ResetData(size);
624 MessageParcel datas;
625 if (!WriteInterfaceToken(datas)) {
626 return;
627 }
628 string uri = fuzzData.GetStringFromData(static_cast<int>(size));
629 datas.WriteString(uri);
630 datas.RewindRead(0);
631 // SERVICE_CMD_CLEAN_CACHE
632 uint32_t code = static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CLEAN_CACHE);
633 MessageParcel reply;
634 MessageOption option;
635
636 cloudSyncServiceStubStr->OnRemoteRequest(code, datas, reply, option);
637 }
638 } // namespace OHOS
639
640 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)641 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
642 {
643 /* Run your code on data */
644 if (data == nullptr || size < OHOS::U32_AT_SIZE * static_cast<size_t>(OHOS::SPLITE_SIZE)) {
645 return 0;
646 }
647
648 OHOS::NativeTokenGet(true);
649 auto cloudSyncServiceStubStr =
650 std::make_shared<OHOS::FileManagement::CloudSync::CloudSyncService>(OHOS::SERVICE_SA_ID);
651 if (cloudSyncServiceStubStr->dataSyncManager_ == nullptr) {
652 cloudSyncServiceStubStr->dataSyncManager_ =
653 std::make_shared<OHOS::FileManagement::CloudFile::DataSyncManager>();
654 }
655
656 OHOS::FuzzData fuzzData(data, size);
657 OHOS::HandleChangeAppSwitchFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
658 OHOS::HandleCleanFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
659 OHOS::HandleDeleteAssetFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
660 OHOS::HandleDisableCloudFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
661 OHOS::HandleDownloadFileFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
662 OHOS::HandleEnableCloudFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
663 OHOS::HandleNotifyDataChangeFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
664 OHOS::HandleRegisterCallbackInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
665 OHOS::HandleStartDownloadFileFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
666 OHOS::HandleStartSyncInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
667 OHOS::HandleStopDownloadFileFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
668 OHOS::HandleStopSyncInnerFuzzTest(cloudSyncServiceStubStr, data, size);
669 OHOS::HandleUnRegisterCallbackInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
670 OHOS::HandleUploadAssetFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
671 OHOS::HandleTriggerSyncInnerFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
672 OHOS::HandleNotifyEventChangeFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
673 OHOS::HandleStartFileCacheFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
674 OHOS::HandleDownloadFilesFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
675 OHOS::HandleDownloadAssetFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
676 OHOS::HandleRegisterDownloadAssetCallbackFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
677 OHOS::HandleGetSyncTimeFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
678 OHOS::HandleCleanCacheFuzzTest(cloudSyncServiceStubStr, fuzzData, size);
679 if (OHOS::FileManagement::CloudSync::TaskStateManager::GetInstance().unloadTaskHandle_ != nullptr) {
680 OHOS::FileManagement::CloudSync::TaskStateManager::GetInstance().queue_.wait(
681 OHOS::FileManagement::CloudSync::TaskStateManager::GetInstance().unloadTaskHandle_);
682 }
683 return 0;
684 }
685