1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "medialibrarycloudmediadataclient_fuzzer.h"
17
18 #include <cstdint>
19 #include <string>
20 #include <fstream>
21 #define private public
22 #include "cloud_media_data_client.h"
23 #undef private
24 #include "media_log.h"
25 #include <fuzzer/FuzzedDataProvider.h>
26 #include "userfile_manager_types.h"
27 #include "medialibrary_type_const.h"
28
29 #include "ability_context_impl.h"
30 #include "medialibrary_command.h"
31 #include "medialibrary_data_manager.h"
32 #include "medialibrary_rdbstore.h"
33 #include "medialibrary_type_const.h"
34 #include "medialibrary_unistore_manager.h"
35 #include "medialibrary_kvstore_manager.h"
36
37 namespace OHOS {
38 using namespace std;
39 using namespace OHOS::Media;
40 using namespace OHOS::Media::CloudSync;
41 const int32_t NUM_BYTES = 1;
42 const int32_t MAX_BYTE_VALUE = 256;
43 const int32_t SEED_SIZE = 1024;
44 const string PHOTOS_TABLE = "Photos";
45 FuzzedDataProvider* provider;
46 std::shared_ptr<Media::MediaLibraryRdbStore> g_rdbStore;
47
FuzzThmsType()48 static inline ThmsType FuzzThmsType()
49 {
50 int32_t value = provider->ConsumeIntegral<int32_t>();
51 if (value >= static_cast<int32_t>(ThmsType::TYPE_THM) &&
52 value <= static_cast<int32_t>(ThmsType::TYPE_ASTC)) {
53 return static_cast<ThmsType>(value);
54 }
55 return ThmsType::TYPE_THM_AND_LCD;
56 }
57
FuzzSyncStatusType()58 static inline SyncStatusType FuzzSyncStatusType()
59 {
60 int32_t value = provider->ConsumeIntegral<int32_t>();
61 if (value >= static_cast<int32_t>(SyncStatusType::TYPE_BACKUP) &&
62 value <= static_cast<int32_t>(SyncStatusType::TYPE_UPLOAD)) {
63 return static_cast<SyncStatusType>(value);
64 }
65 return SyncStatusType::TYPE_UPLOAD;
66 }
67
FuzzDirtyTypes()68 static inline Media::DirtyTypes FuzzDirtyTypes()
69 {
70 int32_t value = provider->ConsumeIntegral<int32_t>();
71 if (value >= static_cast<int32_t>(Media::DirtyTypes::TYPE_SYNCED) &&
72 value <= static_cast<int32_t>(Media::DirtyTypes::TYPE_COPY)) {
73 return static_cast<Media::DirtyTypes>(value);
74 }
75 return Media::DirtyTypes::TYPE_COPY;
76 }
77
FuzzPhotoPositionType()78 static inline Media::PhotoPositionType FuzzPhotoPositionType()
79 {
80 int32_t value = provider->ConsumeIntegral<int32_t>();
81 if (value >= static_cast<int32_t>(Media::PhotoPositionType::LOCAL) &&
82 value <= static_cast<int32_t>(Media::PhotoPositionType::LOCAL_AND_CLOUD)) {
83 return static_cast<Media::PhotoPositionType>(value);
84 }
85 return Media::PhotoPositionType::LOCAL_AND_CLOUD;
86 }
87
InsertPhotoAsset(string & cloudId)88 static int32_t InsertPhotoAsset(string &cloudId)
89 {
90 if (g_rdbStore == nullptr) {
91 return E_ERR;
92 }
93 NativeRdb::ValuesBucket values;
94 values.PutString(Media::PhotoColumn::PHOTO_CLOUD_ID, cloudId);
95 int32_t dirtyTypes = static_cast<int32_t>(FuzzDirtyTypes());
96 values.PutInt(Media::PhotoColumn::PHOTO_DIRTY, dirtyTypes);
97 values.PutInt(Media::PhotoColumn::PHOTO_POSITION, static_cast<int32_t>(FuzzPhotoPositionType()));
98 int64_t fileId = 0;
99 g_rdbStore->Insert(fileId, PHOTOS_TABLE, values);
100 return static_cast<int32_t>(fileId);
101 }
102
UpdateDirtyFuzzer()103 static void UpdateDirtyFuzzer()
104 {
105 CloudMediaDataClient cloudMediaDataClient(1);
106 std::string cloudId = provider->ConsumeBytesAsString(NUM_BYTES);
107 InsertPhotoAsset(cloudId);
108 cloudMediaDataClient.UpdateDirty(cloudId, FuzzDirtyTypes());
109
110 cloudMediaDataClient.dataHandler_ = nullptr;
111 cloudMediaDataClient.UpdateDirty(cloudId, FuzzDirtyTypes());
112 }
113
UpdatePositionFuzzer()114 static void UpdatePositionFuzzer()
115 {
116 CloudMediaDataClient cloudMediaDataClient(1);
117 std::string cloudId = provider->ConsumeBytesAsString(NUM_BYTES);
118 InsertPhotoAsset(cloudId);
119 PhotoPositionType position = FuzzPhotoPositionType();
120 std::vector<std::string> cloudIds;
121 cloudIds.push_back(cloudId);
122 cloudMediaDataClient.UpdatePosition(cloudIds, static_cast<int32_t>(position));
123
124 cloudMediaDataClient.dataHandler_ = nullptr;
125 cloudMediaDataClient.UpdatePosition(cloudIds, static_cast<int32_t>(position));
126 }
127
UpdateSyncStatusFuzzer()128 static void UpdateSyncStatusFuzzer()
129 {
130 CloudMediaDataClient cloudMediaDataClient(1);
131 std::string cloudId = provider->ConsumeBytesAsString(NUM_BYTES);
132 InsertPhotoAsset(cloudId);
133 int32_t syncStatus = static_cast<int32_t>(FuzzSyncStatusType());
134 cloudMediaDataClient.UpdateSyncStatus(cloudId, syncStatus);
135
136 cloudMediaDataClient.dataHandler_ = nullptr;
137 cloudMediaDataClient.UpdateSyncStatus(cloudId, syncStatus);
138 }
139
UpdateThmStatusFuzzer()140 static void UpdateThmStatusFuzzer()
141 {
142 CloudMediaDataClient cloudMediaDataClient(1);
143 std::string cloudId = provider->ConsumeBytesAsString(NUM_BYTES);
144 InsertPhotoAsset(cloudId);
145 ThumbStatus thumbStatus = provider->ConsumeBool() ? ThumbStatus::DOWNLOADED : ThumbStatus::TO_DOWNLOAD;
146 cloudMediaDataClient.UpdateThmStatus(cloudId, static_cast<int32_t>(thumbStatus));
147
148 cloudMediaDataClient.dataHandler_ = nullptr;
149 cloudMediaDataClient.UpdateThmStatus(cloudId, static_cast<int32_t>(thumbStatus));
150 }
151
GetAgingFileFuzzer()152 static void GetAgingFileFuzzer()
153 {
154 int64_t time = provider->ConsumeIntegral<int64_t>();
155 int32_t mediaType = provider->ConsumeIntegral<int32_t>();
156 int32_t sizeLimit = provider->ConsumeIntegral<int32_t>();
157 int32_t offset = 0;
158 vector<CloudMetaData> metaDataList;
159 CloudMediaDataClient cloudMediaDataClient(1);
160 cloudMediaDataClient.GetAgingFile(time, mediaType, sizeLimit, offset, metaDataList);
161
162 cloudMediaDataClient.dataHandler_ = nullptr;
163 cloudMediaDataClient.GetAgingFile(time, mediaType, sizeLimit, offset, metaDataList);
164 }
165
GetActiveAgingFileFuzzer()166 static void GetActiveAgingFileFuzzer()
167 {
168 int64_t time = provider->ConsumeIntegral<int64_t>();
169 int32_t mediaType = provider->ConsumeIntegral<int32_t>();
170 int32_t sizeLimit = provider->ConsumeIntegral<int32_t>();
171 int32_t offset = 0;
172 vector<CloudMetaData> metaDataList;
173 CloudMediaDataClient cloudMediaDataClient(1);
174 cloudMediaDataClient.GetActiveAgingFile(time, mediaType, sizeLimit, offset, metaDataList);
175
176 cloudMediaDataClient.dataHandler_ = nullptr;
177 cloudMediaDataClient.GetActiveAgingFile(time, mediaType, sizeLimit, offset, metaDataList);
178 }
179
GetDownloadAssetFuzzer()180 static void GetDownloadAssetFuzzer()
181 {
182 CloudMediaDataClient cloudMediaDataClient(1);
183 vector<string> uris;
184 string uri = provider->ConsumeBytesAsString(NUM_BYTES);
185 uris.push_back(uri);
186 vector<CloudMetaData> cloudMetaDataVec;
187 cloudMediaDataClient.GetDownloadAsset(uris, cloudMetaDataVec);
188
189 cloudMediaDataClient.dataHandler_ = nullptr;
190 cloudMediaDataClient.GetDownloadAsset(uris, cloudMetaDataVec);
191 }
192
GetDownloadThmsByUriFuzzer()193 static void GetDownloadThmsByUriFuzzer()
194 {
195 CloudMediaDataClient cloudMediaDataClient(1);
196 vector<string> uris;
197 int32_t thmType = FuzzThmsType();
198 vector<CloudMetaData> cloudMetaDataVec;
199 string uri = provider->ConsumeBytesAsString(NUM_BYTES);
200 uris.push_back(uri);
201
202 cloudMediaDataClient.GetDownloadThmsByUri(uris, thmType, cloudMetaDataVec);
203
204 cloudMediaDataClient.dataHandler_ = nullptr;
205 cloudMediaDataClient.GetDownloadThmsByUri(uris, thmType, cloudMetaDataVec);
206 }
207
OnDownloadAssetFuzzer()208 static void OnDownloadAssetFuzzer()
209 {
210 string cloudId = provider->ConsumeBytesAsString(NUM_BYTES);
211 vector<string> cloudIds;
212 cloudIds.push_back(cloudId);
213 CloudMediaDataClient cloudMediaDataClient(1);
214 vector<MediaOperateResult> result;
215 cloudMediaDataClient.OnDownloadAsset(cloudIds, result);
216
217 cloudMediaDataClient.dataHandler_ = nullptr;
218 cloudMediaDataClient.OnDownloadAsset(cloudIds, result);
219 }
220
GetDownloadThmsFuzzer()221 static void GetDownloadThmsFuzzer()
222 {
223 std::vector<CloudMetaData> cloudMetaDataVec;
224 int32_t paramSize = provider->ConsumeIntegral<int32_t>();
225 int32_t offset = 0;
226 int32_t type = provider->ConsumeIntegral<int32_t>();
227 CloudMediaDataClient cloudMediaDataClient(1);
228 DownloadThumPara param;
229 param.size = paramSize;
230 param.offset = offset;
231 param.type = type;
232 param.isDownloadDisplayFirst = provider->ConsumeBool();
233 cloudMediaDataClient.GetDownloadThms(cloudMetaDataVec, param);
234
235 cloudMediaDataClient.dataHandler_ = nullptr;
236 cloudMediaDataClient.GetDownloadThms(cloudMetaDataVec, param);
237 }
238
OnDownloadThmsFuzzer()239 static void OnDownloadThmsFuzzer()
240 {
241 std::unordered_map<std::string, int32_t> cloudIdThmStatusMap = {
242 { provider->ConsumeBytesAsString(NUM_BYTES), FuzzThmsType() },
243 };
244 CloudMediaDataClient cloudMediaDataClient(1);
245 int32_t failSize = provider->ConsumeIntegral<int32_t>();
246 cloudMediaDataClient.OnDownloadThms(cloudIdThmStatusMap, failSize);
247
248 cloudMediaDataClient.dataHandler_ = nullptr;
249 cloudMediaDataClient.OnDownloadThms(cloudIdThmStatusMap, failSize);
250 }
251
GetVideoToCacheFuzzer()252 static void GetVideoToCacheFuzzer()
253 {
254 CloudMediaDataClient cloudMediaDataClient(1);
255 std::vector<CloudMetaData> cloudMetaDataList;
256 int32_t sizeTest = provider->ConsumeIntegral<int32_t>();
257 cloudMediaDataClient.GetVideoToCache(cloudMetaDataList, sizeTest);
258
259 cloudMediaDataClient.dataHandler_ = nullptr;
260 cloudMediaDataClient.GetVideoToCache(cloudMetaDataList, sizeTest);
261 }
262
GetDownloadThmNumFuzzer()263 static void GetDownloadThmNumFuzzer()
264 {
265 CloudMediaDataClient cloudMediaDataClient(1);
266 std::vector<CloudMetaData> cloudMetaDataList;
267 int32_t totalNum = 0;
268 int32_t type = FuzzThmsType();
269 cloudMediaDataClient.GetDownloadThmNum(totalNum, type);
270
271 cloudMediaDataClient.dataHandler_ = nullptr;
272 cloudMediaDataClient.GetDownloadThmNum(totalNum, type);
273 }
274
GetFilePosStatFuzzer()275 static void GetFilePosStatFuzzer()
276 {
277 CloudMediaDataClient cloudMediaDataClient(1);
278 vector<uint64_t> filePosStat = { 0, 0 };
279 cloudMediaDataClient.GetFilePosStat(filePosStat);
280 uint64_t filePos = provider->ConsumeIntegral<uint64_t>();
281 filePosStat.push_back(filePos);
282 cloudMediaDataClient.GetFilePosStat(filePosStat);
283
284 cloudMediaDataClient.dataHandler_ = nullptr;
285 cloudMediaDataClient.GetFilePosStat(filePosStat);
286 }
287
GetCloudThmStatFuzzer()288 static void GetCloudThmStatFuzzer()
289 {
290 std::vector<uint64_t> cloudThmStat{ 0, 0, 0 };
291 CloudMediaDataClient cloudMediaDataClient(1);
292 cloudMediaDataClient.GetCloudThmStat(cloudThmStat);
293 uint64_t cloudThm = provider->ConsumeIntegral<uint64_t>();
294 cloudThmStat.push_back(cloudThm);
295 cloudMediaDataClient.GetCloudThmStat(cloudThmStat);
296
297 cloudMediaDataClient.dataHandler_ = nullptr;
298 cloudMediaDataClient.GetCloudThmStat(cloudThmStat);
299 }
300
GetDirtyTypeStatFuzzer()301 static void GetDirtyTypeStatFuzzer()
302 {
303 vector<uint64_t> dirtyTypeStat{ 0, 0, 0, 0 };
304 CloudMediaDataClient cloudMediaDataClient(1);
305 cloudMediaDataClient.GetDirtyTypeStat(dirtyTypeStat);
306 uint64_t dirtyType = provider->ConsumeIntegral<uint64_t>();
307 dirtyTypeStat.push_back(dirtyType);
308 cloudMediaDataClient.GetDirtyTypeStat(dirtyTypeStat);
309
310 cloudMediaDataClient.dataHandler_ = nullptr;
311 cloudMediaDataClient.GetDirtyTypeStat(dirtyTypeStat);
312 }
313
UpdateLocalFileDirtyFuzzer()314 static void UpdateLocalFileDirtyFuzzer()
315 {
316 MDKRecord mDKRecord;
317 vector<MDKRecord> records;
318 string id = provider->ConsumeBytesAsString(NUM_BYTES);
319 mDKRecord.SetRecordId(id);
320 CloudMediaDataClient cloudMediaDataClient(1);
321 cloudMediaDataClient.UpdateLocalFileDirty(records);
322
323 cloudMediaDataClient.dataHandler_ = nullptr;
324 cloudMediaDataClient.UpdateLocalFileDirty(records);
325 }
326
TraceIdFuzzer()327 static void TraceIdFuzzer()
328 {
329 string traceId = provider->ConsumeBytesAsString(NUM_BYTES);
330 CloudMediaDataClient cloudMediaDataClient(1);
331 cloudMediaDataClient.SetTraceId(traceId);
332 cloudMediaDataClient.GetTraceId();
333
334 cloudMediaDataClient.dataHandler_ = nullptr;
335 cloudMediaDataClient.SetTraceId(traceId);
336 cloudMediaDataClient.GetTraceId();
337 }
338
MediaLibraryCloudMediaDataClientFuzzer()339 static void MediaLibraryCloudMediaDataClientFuzzer()
340 {
341 UpdateDirtyFuzzer();
342 UpdatePositionFuzzer();
343 UpdateSyncStatusFuzzer();
344 UpdateThmStatusFuzzer();
345 GetAgingFileFuzzer();
346 GetActiveAgingFileFuzzer();
347 GetDownloadAssetFuzzer();
348 GetDownloadThmsByUriFuzzer();
349 OnDownloadAssetFuzzer();
350 GetDownloadThmsFuzzer();
351 OnDownloadThmsFuzzer();
352 GetVideoToCacheFuzzer();
353 GetDownloadThmNumFuzzer();
354 GetFilePosStatFuzzer();
355 GetCloudThmStatFuzzer();
356 GetDirtyTypeStatFuzzer();
357 UpdateLocalFileDirtyFuzzer();
358 TraceIdFuzzer();
359 }
360
SetTables()361 void SetTables()
362 {
363 vector<string> createTableSqlList = {
364 Media::PhotoColumn::CREATE_PHOTO_TABLE,
365 };
366 for (auto &createTableSql : createTableSqlList) {
367 int32_t ret = g_rdbStore->ExecuteSql(createTableSql);
368 if (ret != NativeRdb::E_OK) {
369 MEDIA_ERR_LOG("Execute sql %{private}s failed", createTableSql.c_str());
370 return;
371 }
372 MEDIA_DEBUG_LOG("Execute sql %{private}s success", createTableSql.c_str());
373 }
374 }
375
Init()376 static void Init()
377 {
378 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
379 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
380 abilityContextImpl->SetStageContext(stageContext);
381 int32_t sceneCode = 0;
382 auto ret = Media::MediaLibraryDataManager::GetInstance()->InitMediaLibraryMgr(abilityContextImpl,
383 abilityContextImpl, sceneCode);
384 CHECK_AND_RETURN_LOG(ret == NativeRdb::E_OK, "InitMediaLibraryMgr failed, ret: %{public}d", ret);
385
386 auto rdbStore = Media::MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
387 if (rdbStore == nullptr) {
388 MEDIA_ERR_LOG("rdbStore is nullptr");
389 return;
390 }
391 g_rdbStore = rdbStore;
392 SetTables();
393 }
394
AddSeed()395 static int32_t AddSeed()
396 {
397 char *seedData = new char[OHOS::SEED_SIZE];
398 for (int i = 0; i < OHOS::SEED_SIZE; i++) {
399 seedData[i] = static_cast<char>(i % MAX_BYTE_VALUE);
400 }
401
402 const char* filename = "corpus/seed.txt";
403 std::ofstream file(filename, std::ios::binary | std::ios::trunc);
404 if (!file) {
405 MEDIA_ERR_LOG("Cannot open file filename:%{public}s", filename);
406 delete[] seedData;
407 return Media::E_ERR;
408 }
409 file.write(seedData, OHOS::SEED_SIZE);
410 file.close();
411 delete[] seedData;
412 MEDIA_INFO_LOG("seedData has been successfully written to file filename:%{public}s", filename);
413 return Media::E_OK;
414 }
415
ClearKvStore()416 static inline void ClearKvStore()
417 {
418 Media::MediaLibraryKvStoreManager::GetInstance().CloseAllKvStore();
419 }
420 } // namespace OHOS
421
LLVMFuzzerInitialize(int * argc,char *** argv)422 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv)
423 {
424 OHOS::AddSeed();
425 OHOS::Init();
426 return 0;
427 }
428
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)429 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
430 {
431 FuzzedDataProvider fdp(data, size);
432 if (data == nullptr) {
433 return 0;
434 }
435 OHOS::provider = &fdp;
436 OHOS::MediaLibraryCloudMediaDataClientFuzzer();
437 OHOS::ClearKvStore();
438 return 0;
439 }