1 /*
2 * Copyright (c) 2023 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 "medialibrary_util_fuzzer.h"
16
17 #include <cstdint>
18 #include <string>
19 #include <thread>
20 #include <fuzzer/FuzzedDataProvider.h>
21
22 #include "ability_context_impl.h"
23 #include "app_mgr_interface.h"
24 #include "cloud_sync_utils.h"
25 #include "cpu_utils.h"
26 #include "medialibrary_album_operations.h"
27 #include "medialibrary_analysis_album_operations.h"
28 #include "medialibrary_app_uri_permission_operations.h"
29 #include "medialibrary_appstate_observer.h"
30 #include "media_log.h"
31 #include "medialibrary_command.h"
32 #include "medialibrary_dir_operations.h"
33 #include "medialibrary_uripermission_operations.h"
34 #include "medialibrary_data_manager.h"
35 #include "medialibrary_data_manager_utils.h"
36 #include "multistages_capture_dfx_first_visit.h"
37 #include "rdb_predicates.h"
38 #include "datashare_values_bucket.h"
39 #include "media_analysis_proxy.h"
40 #include "media_analysis_helper.h"
41 #include "background_cloud_file_processor.h"
42 #include "medialibrary_db_const.h"
43 #include "scanner_utils.h"
44 #include "medialibrary_rdbstore.h"
45 #include "medialibrary_unistore_manager.h"
46 #include "database_adapter.h"
47 #include "userfile_manager_types.h"
48 #include "medialibrary_operation.h"
49 #include "datashare_helper.h"
50 #include "medialibrary_kvstore_manager.h"
51
52 #define private public
53 #include "medialibrary_common_utils.h"
54 #include "permission_utils.h"
55 #include "photo_file_utils.h"
56 #undef private
57
58 namespace OHOS {
59 using namespace std;
60 const std::string ROOT_MEDIA_DIR = "/storage/cloud/files/";
61 const std::string DISPLAY_NAME = "IMG_20250306_202859.jpg";
62 const std::string FILE_HIDDEN = ".FileHidden/";
63 static const int32_t E_ERR = -1;
64 const int32_t NUM_BYTES = 1;
65 static const int32_t MIN_CPU_AFFINITY_TYPE = -1;
66 static const int32_t MAX_CPU_AFFINITY_TYPE = 11;
67 static const string PHOTOS_TABLE = "Photos";
68 std::shared_ptr<Media::MediaLibraryRdbStore> g_rdbStore;
69 FuzzedDataProvider *FDP = nullptr;
70
FuzzUri()71 static inline Uri FuzzUri()
72 {
73 return Uri(FDP->ConsumeBytesAsString(NUM_BYTES));
74 }
75
FuzzCpuAffinityType()76 static inline Media::CpuAffinityType FuzzCpuAffinityType()
77 {
78 int32_t value = FDP->ConsumeIntegralInRange<int32_t>(MIN_CPU_AFFINITY_TYPE, MAX_CPU_AFFINITY_TYPE);
79 return static_cast<Media::CpuAffinityType>(value);
80 }
81
FuzzMediaLibraryCmd()82 static inline Media::MediaLibraryCommand FuzzMediaLibraryCmd()
83 {
84 return Media::MediaLibraryCommand(FuzzUri());
85 }
86
InsertAsset(string photoId)87 static int32_t InsertAsset(string photoId)
88 {
89 if (g_rdbStore == nullptr) {
90 return E_ERR;
91 }
92 NativeRdb::ValuesBucket values;
93 values.PutString(Media::PhotoColumn::PHOTO_ID, photoId);
94 values.PutString(Media::MediaColumn::MEDIA_FILE_PATH, FDP->ConsumeBytesAsString(NUM_BYTES));
95 values.PutString(Media::PhotoColumn::PHOTO_LAST_VISIT_TIME, FDP->ConsumeBytesAsString(NUM_BYTES));
96 int64_t fileId = 0;
97 g_rdbStore->Insert(fileId, PHOTOS_TABLE, values);
98 return static_cast<int32_t>(fileId);
99 }
100
SetTables()101 void SetTables()
102 {
103 vector<string> createTableSqlList = { Media::PhotoColumn::CREATE_PHOTO_TABLE };
104 for (auto &createTableSql : createTableSqlList) {
105 CHECK_AND_RETURN_LOG(g_rdbStore != nullptr, "g_rdbStore is null.");
106 int32_t ret = g_rdbStore->ExecuteSql(createTableSql);
107 if (ret != NativeRdb::E_OK) {
108 MEDIA_ERR_LOG("Execute sql %{private}s failed.", createTableSql.c_str());
109 return;
110 }
111 MEDIA_DEBUG_LOG("Execute sql %{private}s success.", createTableSql.c_str());
112 }
113 }
Init()114 static void Init()
115 {
116 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
117 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
118 abilityContextImpl->SetStageContext(stageContext);
119 int32_t sceneCode = 0;
120 auto ret = Media::MediaLibraryDataManager::GetInstance()->InitMediaLibraryMgr(abilityContextImpl,
121 abilityContextImpl, sceneCode);
122 CHECK_AND_RETURN_LOG(ret == NativeRdb::E_OK, "InitMediaLibrary Mgr failed, ret: %{public}d.", ret);
123 auto rdbStore = Media::MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
124 if (rdbStore == nullptr) {
125 MEDIA_ERR_LOG("rdbStore is nullptr.");
126 return;
127 }
128 g_rdbStore = rdbStore;
129 SetTables();
130 }
131
CommandTest()132 static void CommandTest()
133 {
134 NativeRdb::ValuesBucket value;
135 int32_t operationObject1 = FDP->ConsumeIntegral<int32_t>();
136 int32_t operationType1 = FDP->ConsumeIntegral<int32_t>();
137 int32_t mediaLibraryApi1 = FDP->ConsumeIntegral<int32_t>();
138 Media::MediaLibraryCommand cmd(static_cast<Media::OperationObject>(operationObject1),
139 static_cast<Media::OperationType>(operationType1), static_cast<Media::MediaLibraryApi>(mediaLibraryApi1));
140 cmd.SetTableName(FDP->ConsumeBytesAsString(NUM_BYTES));
141 cmd.SetBundleName(FDP->ConsumeBytesAsString(NUM_BYTES));
142 cmd.SetDeviceName(FDP->ConsumeBytesAsString(NUM_BYTES));
143 cmd.SetResult(FDP->ConsumeBytesAsString(NUM_BYTES));
144 int32_t operationObject2 = FDP->ConsumeIntegral<int32_t>();
145 cmd.SetOprnObject(static_cast<Media::OperationObject>(operationObject2));
146 cmd.GetOprnFileId();
147 cmd.SetOprnAssetId(FDP->ConsumeBytesAsString(NUM_BYTES));
148 DataShare::DataSharePredicates pred;
149 cmd.SetDataSharePred(pred);
150 cmd.SetValueBucket(value);
151 Media::MediaLibraryCommand cmdValueBucket(FuzzUri(), value);
152 int32_t operationObject3 = FDP->ConsumeIntegral<int32_t>();
153 int32_t operationType2 = FDP->ConsumeIntegral<int32_t>();
154 int32_t mediaLibraryApi2 = FDP->ConsumeIntegral<int32_t>();
155 Media::MediaLibraryCommand cmdValueBucket2(static_cast<Media::OperationObject>(operationObject3),
156 static_cast<Media::OperationType>(operationType2), value,
157 static_cast<Media::MediaLibraryApi>(mediaLibraryApi2));
158 int32_t operationObject4 = FDP->ConsumeIntegral<int32_t>();
159 int32_t operationType3 = FDP->ConsumeIntegral<int32_t>();
160 int32_t mediaLibraryApi3 = FDP->ConsumeIntegral<int32_t>();
161 Media::MediaLibraryCommand cmdDevice(static_cast<Media::OperationObject>(operationObject4),
162 static_cast<Media::OperationType>(operationType3), FDP->ConsumeBytesAsString(NUM_BYTES),
163 static_cast<Media::MediaLibraryApi>(mediaLibraryApi3));
164 }
165
DirOperationTest()166 static void DirOperationTest()
167 {
168 int32_t operationObject = FDP->ConsumeIntegral<int32_t>();
169 int32_t operationType = FDP->ConsumeIntegral<int32_t>();
170 int32_t mediaLibraryApi = FDP->ConsumeIntegral<int32_t>();
171 Media::MediaLibraryCommand cmd(static_cast<Media::OperationObject>(operationObject),
172 static_cast<Media::OperationType>(operationType), static_cast<Media::MediaLibraryApi>(mediaLibraryApi));
173 Media::MediaLibraryDirOperations::HandleDirOperation(cmd);
174 Media::MediaLibraryDirOperations::CreateDirOperation(cmd);
175 Media::MediaLibraryDirOperations::TrashDirOperation(cmd);
176 }
177
UriPermissionTest()178 static void UriPermissionTest()
179 {
180 int32_t operationObject = FDP->ConsumeIntegral<int32_t>();
181 int32_t operationType = FDP->ConsumeIntegral<int32_t>();
182 int32_t mediaLibraryApi = FDP->ConsumeIntegral<int32_t>();
183 Media::MediaLibraryCommand cmd(static_cast<Media::OperationObject>(operationObject),
184 static_cast<Media::OperationType>(operationType), static_cast<Media::MediaLibraryApi>(mediaLibraryApi));
185 NativeRdb::ValuesBucket rdbValueBucket;
186 rdbValueBucket.Put(Media::PERMISSION_FILE_ID, FDP->ConsumeIntegral<int32_t>());
187 rdbValueBucket.Put(Media::PERMISSION_BUNDLE_NAME, FDP->ConsumeBytesAsString(NUM_BYTES));
188 rdbValueBucket.Put(Media::PERMISSION_MODE, "r");
189 rdbValueBucket.Put(Media::PERMISSION_TABLE_TYPE, FDP->ConsumeBytesAsString(NUM_BYTES));
190 cmd.SetValueBucket(rdbValueBucket);
191 Media::UriPermissionOperations::HandleUriPermOperations(cmd);
192 Media::UriPermissionOperations::HandleUriPermInsert(cmd);
193 Media::UriPermissionOperations::InsertBundlePermission(FDP->ConsumeIntegral<int32_t>(),
194 FDP->ConsumeBytesAsString(NUM_BYTES), FDP->ConsumeBytesAsString(NUM_BYTES),
195 FDP->ConsumeBytesAsString(NUM_BYTES));
196 Media::UriPermissionOperations::DeleteBundlePermission(FDP->ConsumeBytesAsString(NUM_BYTES),
197 FDP->ConsumeBytesAsString(NUM_BYTES), FDP->ConsumeBytesAsString(NUM_BYTES));
198 string mode = "r";
199 Media::UriPermissionOperations::CheckUriPermission(FDP->ConsumeBytesAsString(NUM_BYTES), mode);
200
201 Media::UriPermissionOperations::GetUriPermissionMode(FDP->ConsumeBytesAsString(NUM_BYTES),
202 FDP->ConsumeBytesAsString(NUM_BYTES), FDP->ConsumeIntegral<int32_t>(), mode);
203 Media::UriPermissionOperations::UpdateOperation(cmd);
204 Media::UriPermissionOperations::InsertOperation(cmd);
205 std::vector<NativeRdb::ValuesBucket> rdbValues;
206 Media::UriPermissionOperations::BatchInsertOperation(cmd, rdbValues);
207 Media::UriPermissionOperations::DeleteOperation(cmd);
208 std::vector<DataShare::DataShareValuesBucket> sharedValues;
209 DataShare::DataShareValuesBucket valueTest1;
210 valueTest1.Put(Media::AppUriPermissionColumn::FILE_ID, "file_id");
211 valueTest1.Put(Media::AppUriPermissionColumn::APP_ID, "appid");
212 DataShare::DataShareValuesBucket valueTest2;
213 valueTest2.Put(Media::AppUriPermissionColumn::FILE_ID, "file_id");
214 valueTest2.Put(Media::AppUriPermissionColumn::APP_ID, "appid");
215 sharedValues.push_back(valueTest1);
216 sharedValues.push_back(valueTest2);
217 Media::UriPermissionOperations::GrantUriPermission(cmd, sharedValues);
218 Media::UriPermissionOperations::DeleteAllTemporaryAsync();
219 }
220
AnalysisTest()221 static void AnalysisTest()
222 {
223 std::vector<std::string> columns;
224 NativeRdb::ValuesBucket values;
225 DataShare::DataSharePredicates pred;
226 int32_t operationObject = FDP->ConsumeIntegral<int32_t>();
227 int32_t operationType = FDP->ConsumeIntegral<int32_t>();
228 int32_t mediaLibraryApi = FDP->ConsumeIntegral<int32_t>();
229 Media::MediaLibraryCommand cmd(static_cast<Media::OperationObject>(operationObject),
230 static_cast<Media::OperationType>(operationType), static_cast<Media::MediaLibraryApi>(mediaLibraryApi));
231 cmd.SetTableName("Photos");
232 Media::MergeAlbumInfo info1;
233 info1.albumId = FDP->ConsumeIntegral<int32_t>();
234 Media::MergeAlbumInfo info2;
235 info2.albumId = FDP->ConsumeIntegral<int32_t>();
236 std::vector<Media::MergeAlbumInfo> infos;
237 infos.push_back(info1);
238 infos.push_back(info2);
239 Media::MediaLibraryAnalysisAlbumOperations::UpdateMergeGroupAlbumsInfo(infos);
240 Media::MediaLibraryAnalysisAlbumOperations::HandleGroupPhotoAlbum(
241 static_cast<Media::OperationType>(FDP->ConsumeIntegral<int32_t>()), values, pred);
242 Media::MediaLibraryAnalysisAlbumOperations::QueryGroupPhotoAlbum(cmd, columns);
243 Media::MediaLibraryAnalysisAlbumOperations::UpdateGroupPhotoAlbumById(FDP->ConsumeIntegral<int32_t>());
244 }
245
AppPermissionTest()246 static void AppPermissionTest()
247 {
248 std::vector<std::string> columns;
249 NativeRdb::RdbPredicates rdbPred("Photos");
250 DataShare::DataSharePredicates sharedPred;
251 int32_t operationObject = FDP->ConsumeIntegral<int32_t>();
252 int32_t operationType = FDP->ConsumeIntegral<int32_t>();
253 int32_t mediaLibraryApi = FDP->ConsumeIntegral<int32_t>();
254 Media::MediaLibraryCommand cmd(static_cast<Media::OperationObject>(operationObject),
255 static_cast<Media::OperationType>(operationType), static_cast<Media::MediaLibraryApi>(mediaLibraryApi));
256 Media::MediaLibraryAppUriPermissionOperations::HandleInsertOperation(cmd);
257 std::vector<DataShare::DataShareValuesBucket> sharedValues;
258 DataShare::DataShareValuesBucket values;
259 values.Put(Media::AppUriPermissionColumn::FILE_ID, "file_id");
260 values.Put(Media::AppUriPermissionColumn::APP_ID, "appid");
261 sharedValues.push_back(values);
262 Media::MediaLibraryAppUriPermissionOperations::BatchInsert(cmd, sharedValues);
263 Media::MediaLibraryAppUriPermissionOperations::DeleteOperation(rdbPred);
264 Media::MediaLibraryAppUriPermissionOperations::QueryOperation(sharedPred, columns);
265 }
266
AppStateTest()267 static void AppStateTest()
268 {
269 Media::MedialibraryAppStateObserverManager::GetInstance().SubscribeAppState();
270 Media::MedialibraryAppStateObserverManager::GetInstance().UnSubscribeAppState();
271 }
272
MediaLibraryManagerTest()273 static void MediaLibraryManagerTest()
274 {
275 Media::MediaLibraryDataManagerUtils::IsNumber(FDP->ConsumeBytesAsString(NUM_BYTES));
276 Media::MediaLibraryDataManagerUtils::GetOperationType(FDP->ConsumeBytesAsString(NUM_BYTES));
277 Media::MediaLibraryDataManagerUtils::GetDisPlayNameFromPath(FDP->ConsumeBytesAsString(NUM_BYTES));
278 std::vector<std::string> whereArgs;
279 std::string str = FDP->ConsumeBytesAsString(NUM_BYTES);
280 Media::MediaLibraryDataManagerUtils::ObtionCondition(str, whereArgs);
281 Media::MediaLibraryDataManagerUtils::GetTypeUriByUri(str);
282 }
283
MultistageAdapterTest()284 static void MultistageAdapterTest()
285 {
286 Media::MediaLibraryCommand cmd = FuzzMediaLibraryCmd();
287 Media::DatabaseAdapter::Update(cmd);
288 MEDIA_INFO_LOG("MultistageAdapterTest");
289 }
290
MultistageTest()291 static void MultistageTest()
292 {
293 std::string photoId = FDP->ConsumeBytesAsString(NUM_BYTES);
294 int32_t fileId = InsertAsset(photoId);
295 MEDIA_INFO_LOG("fileId: %{public}d.", fileId);
296 Media::MultiStagesCaptureDfxFirstVisit::GetInstance().Report(photoId);
297 MEDIA_INFO_LOG("MultistageTest");
298 }
299
ActiveAnalysisTest()300 static void ActiveAnalysisTest()
301 {
302 std::vector<std::string> fileIds;
303 fileIds.push_back("1");
304 Media::MediaAnalysisHelper::StartMediaAnalysisServiceSync(
305 static_cast<int32_t>(Media::MediaAnalysisProxy::ActivateServiceType::START_SERVICE_OCR), fileIds);
306 Media::MediaAnalysisHelper::StartMediaAnalysisServiceAsync(
307 static_cast<int32_t>(Media::MediaAnalysisProxy::ActivateServiceType::START_SERVICE_OCR), fileIds);
308 Media::MediaAnalysisHelper::AsyncStartMediaAnalysisService(
309 static_cast<int32_t>(Media::MediaAnalysisProxy::ActivateServiceType::START_SERVICE_OCR), fileIds);
310 Media::MediaAnalysisHelper::StartPortraitCoverSelectionAsync(fileIds.at(0));
311 (void)Media::MediaAnalysisHelper::ParseGeoInfo(fileIds, true);
312 }
313
CloudDownloadTest()314 static void CloudDownloadTest()
315 {
316 Media::BackgroundCloudFileProcessor::StartTimer();
317 int sleepTime = 200;
318 std::this_thread::sleep_for(std::chrono::microseconds(sleepTime));
319 Media::BackgroundCloudFileProcessor::StopTimer();
320 }
321
CpuUtilsTest()322 static void CpuUtilsTest()
323 {
324 Media::CpuUtils::SlowDown();
325 Media::CpuAffinityType cpuAffinityType = FuzzCpuAffinityType();
326 Media::CpuUtils::SetSelfThreadAffinity(cpuAffinityType);
327 Media::CpuUtils::ResetSelfThreadAffinity();
328 Media::CpuUtils::ResetCpu();
329 }
330
CommonUtilsTest()331 static void CommonUtilsTest()
332 {
333 std::string str = FDP->ConsumeBytesAsString(NUM_BYTES);
334 Media::MediaLibraryCommonUtils::CanConvertStrToInt32(str);
335 }
336
CloudSyncUtilsTest()337 static void CloudSyncUtilsTest()
338 {
339 Media::CloudSyncUtils::IsUnlimitedTrafficStatusOn();
340 Media::CloudSyncUtils::IsCloudSyncSwitchOn();
341 Media::CloudSyncUtils::IsCloudDataAgingPolicyOn();
342 }
343
ScannerUtilsTest()344 static void ScannerUtilsTest()
345 {
346 std::string pathOrDisplayName = FDP->ConsumeBool() ? DISPLAY_NAME : FDP->ConsumeBytesAsString(NUM_BYTES);
347 Media::ScannerUtils::GetFileExtension(pathOrDisplayName);
348
349 std::string path = FDP->ConsumeBool() ? "" : FDP->ConsumeBytesAsString(NUM_BYTES);
350 Media::ScannerUtils::IsDirectory(path);
351 Media::ScannerUtils::IsRegularFile(path);
352
353 path = FDP->ConsumeBool() ? FILE_HIDDEN : FDP->ConsumeBytesAsString(NUM_BYTES);
354 Media::ScannerUtils::IsFileHidden(path);
355
356 std::string dir = FDP->ConsumeBytesAsString(NUM_BYTES);
357 Media::ScannerUtils::GetRootMediaDir(dir);
358
359 std::string displayName = FDP->ConsumeBytesAsString(NUM_BYTES);
360 Media::ScannerUtils::GetFileTitle(displayName);
361
362 path = FDP->ConsumeBool() ? FILE_HIDDEN : FDP->ConsumeBytesAsString(NUM_BYTES);
363 Media::ScannerUtils::IsDirHidden(path, true);
364
365 path = FDP->ConsumeBool() ? ROOT_MEDIA_DIR + "Pictures": FDP->ConsumeBytesAsString(NUM_BYTES);
366 Media::ScannerUtils::CheckSkipScanList(path);
367 }
368
ClearKvStore()369 static inline void ClearKvStore()
370 {
371 Media::MediaLibraryKvStoreManager::GetInstance().CloseAllKvStore();
372 }
373 } // namespace OHOS
374
LLVMFuzzerInitialize(int * argc,char *** argv)375 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv)
376 {
377 OHOS::Init();
378 return 0;
379 }
380
381 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)382 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
383 {
384 /* Run your code on data */
385 int sleepTime = 100;
386 std::this_thread::sleep_for(std::chrono::microseconds(sleepTime));
387 FuzzedDataProvider fdp(data, size);
388 OHOS::FDP = &fdp;
389 if (data == nullptr) {
390 return 0;
391 }
392 OHOS::CommandTest();
393 OHOS::DirOperationTest();
394 OHOS::UriPermissionTest();
395 OHOS::AnalysisTest();
396 OHOS::AppPermissionTest();
397 OHOS::AppStateTest();
398 OHOS::MediaLibraryManagerTest();
399 OHOS::MultistageAdapterTest();
400 OHOS::MultistageTest();
401 OHOS::ActiveAnalysisTest();
402 OHOS::CloudDownloadTest();
403 OHOS::CpuUtilsTest();
404 OHOS::CommonUtilsTest();
405 OHOS::CloudSyncUtilsTest();
406 OHOS::ScannerUtilsTest();
407 OHOS::ClearKvStore();
408 return 0;
409 }
410