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
21 #include "ability_context_impl.h"
22 #include "app_mgr_interface.h"
23 #include "medialibrary_album_operations.h"
24 #include "medialibrary_analysis_album_operations.h"
25 #include "medialibrary_app_uri_permission_operations.h"
26 #include "medialibrary_appstate_observer.h"
27 #include "media_log.h"
28 #include "medialibrary_command.h"
29 #include "medialibrary_dir_operations.h"
30 #include "medialibrary_uripermission_operations.h"
31 #include "medialibrary_data_manager.h"
32 #include "medialibrary_data_manager_utils.h"
33 #include "multistages_capture_dfx_first_visit.h"
34 #include "rdb_predicates.h"
35 #include "datashare_values_bucket.h"
36 #include "media_analysis_proxy.h"
37 #include "media_analysis_helper.h"
38 #include "background_cloud_file_processor.h"
39 #include "medialibrary_db_const.h"
40 #include "medialibrary_album_refresh.h"
41
42 namespace OHOS {
43 using namespace std;
44
FuzzString(const uint8_t * data,size_t size)45 static inline string FuzzString(const uint8_t *data, size_t size)
46 {
47 return {reinterpret_cast<const char*>(data), size};
48 }
49
FuzzInt32(const uint8_t * data)50 static inline int32_t FuzzInt32(const uint8_t *data)
51 {
52 return static_cast<int32_t>(*data);
53 }
54
FuzzUri(const uint8_t * data,size_t size)55 static inline Uri FuzzUri(const uint8_t *data, size_t size)
56 {
57 return Uri(FuzzString(data, size));
58 }
59
Init()60 static int Init()
61 {
62 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
63 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
64 abilityContextImpl->SetStageContext(stageContext);
65 int32_t sceneCode = 0;
66 return Media::MediaLibraryDataManager::GetInstance()->InitMediaLibraryMgr(abilityContextImpl, abilityContextImpl,
67 sceneCode);
68 }
69
CommandTest(const uint8_t * data,size_t size)70 static void CommandTest(const uint8_t *data, size_t size)
71 {
72 NativeRdb::ValuesBucket value;
73 Media::MediaLibraryCommand cmd(static_cast<Media::OperationObject>(FuzzInt32(data)),
74 static_cast<Media::OperationType>(FuzzInt32(data)), static_cast<Media::MediaLibraryApi>(FuzzInt32(data)));
75 cmd.SetTableName(FuzzString(data, size));
76 cmd.SetBundleName(FuzzString(data, size));
77 cmd.SetDeviceName(FuzzString(data, size));
78 cmd.SetResult(FuzzString(data, size));
79 cmd.SetOprnObject(static_cast<Media::OperationObject>(FuzzInt32(data)));
80 cmd.GetOprnFileId();
81 cmd.SetOprnAssetId(FuzzString(data, size));
82 DataShare::DataSharePredicates pred;
83 cmd.SetDataSharePred(pred);
84 cmd.SetValueBucket(value);
85 Media::MediaLibraryCommand cmdValueBucket(FuzzUri(data, size), value);
86 Media::MediaLibraryCommand cmdValueBucket2(static_cast<Media::OperationObject>(FuzzInt32(data)),
87 static_cast<Media::OperationType>(FuzzInt32(data)), value,
88 static_cast<Media::MediaLibraryApi>(FuzzInt32(data)));
89 Media::MediaLibraryCommand cmdDevice(static_cast<Media::OperationObject>(FuzzInt32(data)),
90 static_cast<Media::OperationType>(FuzzInt32(data)), FuzzString(data, size),
91 static_cast<Media::MediaLibraryApi>(FuzzInt32(data)));
92 }
93
DirOperationTest(const uint8_t * data,size_t size)94 static void DirOperationTest(const uint8_t *data, size_t size)
95 {
96 Media::MediaLibraryCommand cmd(static_cast<Media::OperationObject>(FuzzInt32(data)),
97 static_cast<Media::OperationType>(FuzzInt32(data)), static_cast<Media::MediaLibraryApi>(FuzzInt32(data)));
98 Media::MediaLibraryDirOperations::HandleDirOperation(cmd);
99 Media::MediaLibraryDirOperations::CreateDirOperation(cmd);
100 Media::MediaLibraryDirOperations::TrashDirOperation(cmd);
101 }
102
UriPermissionTest(const uint8_t * data,size_t size)103 static void UriPermissionTest(const uint8_t *data, size_t size)
104 {
105 Media::MediaLibraryCommand cmd(static_cast<Media::OperationObject>(FuzzInt32(data)),
106 static_cast<Media::OperationType>(FuzzInt32(data)), static_cast<Media::MediaLibraryApi>(FuzzInt32(data)));
107 NativeRdb::ValuesBucket rdbValueBucket;
108 rdbValueBucket.Put(Media::PERMISSION_FILE_ID, FuzzInt32(data));
109 rdbValueBucket.Put(Media::PERMISSION_BUNDLE_NAME, FuzzString(data, size));
110 rdbValueBucket.Put(Media::PERMISSION_MODE, "r");
111 rdbValueBucket.Put(Media::PERMISSION_TABLE_TYPE, FuzzString(data, size));
112 cmd.SetValueBucket(rdbValueBucket);
113 Media::UriPermissionOperations::HandleUriPermOperations(cmd);
114 Media::UriPermissionOperations::HandleUriPermInsert(cmd);
115 Media::UriPermissionOperations::InsertBundlePermission(FuzzInt32(data), FuzzString(data, size),
116 FuzzString(data, size), FuzzString(data, size));
117 Media::UriPermissionOperations::DeleteBundlePermission(FuzzString(data, size),
118 FuzzString(data, size), FuzzString(data, size));
119 string mode = "r";
120 Media::UriPermissionOperations::CheckUriPermission(FuzzString(data, size), mode);
121
122 Media::UriPermissionOperations::GetUriPermissionMode(FuzzString(data, size), FuzzString(data, size),
123 FuzzInt32(data), mode);
124 Media::UriPermissionOperations::UpdateOperation(cmd);
125 Media::UriPermissionOperations::InsertOperation(cmd);
126 std::vector<NativeRdb::ValuesBucket> rdbValues;
127 Media::UriPermissionOperations::BatchInsertOperation(cmd, rdbValues);
128 Media::UriPermissionOperations::DeleteOperation(cmd);
129 std::vector<DataShare::DataShareValuesBucket> sharedValues;
130 DataShare::DataShareValuesBucket valueTest1;
131 DataShare::DataShareValuesBucket valueTest2;
132 sharedValues.push_back(valueTest1);
133 sharedValues.push_back(valueTest2);
134 Media::UriPermissionOperations::GrantUriPermission(cmd, sharedValues);
135 Media::UriPermissionOperations::DeleteAllTemporaryAsync();
136 }
137
AnalysisTest(const uint8_t * data,size_t size)138 static void AnalysisTest(const uint8_t *data, size_t size)
139 {
140 std::vector<std::string> columns;
141 NativeRdb::ValuesBucket values;
142 DataShare::DataSharePredicates pred;
143 Media::MediaLibraryCommand cmd(static_cast<Media::OperationObject>(FuzzInt32(data)),
144 static_cast<Media::OperationType>(FuzzInt32(data)), static_cast<Media::MediaLibraryApi>(FuzzInt32(data)));
145 cmd.SetTableName("Photos");
146 Media::MergeAlbumInfo info1;
147 info1.albumId = FuzzInt32(data);
148 Media::MergeAlbumInfo info2;
149 info2.albumId = FuzzInt32(data);
150 std::vector<Media::MergeAlbumInfo> infos;
151 infos.push_back(info1);
152 infos.push_back(info2);
153 Media::MediaLibraryAnalysisAlbumOperations::UpdateMergeGroupAlbumsInfo(infos);
154 Media::MediaLibraryAnalysisAlbumOperations::HandleGroupPhotoAlbum(
155 static_cast<Media::OperationType>(FuzzInt32(data)), values, pred);
156 Media::MediaLibraryAnalysisAlbumOperations::QueryGroupPhotoAlbum(cmd, columns);
157 Media::MediaLibraryAnalysisAlbumOperations::UpdateGroupPhotoAlbumById(FuzzInt32(data));
158 }
159
AppPermissionTest(const uint8_t * data,size_t size)160 static void AppPermissionTest(const uint8_t *data, size_t size)
161 {
162 std::vector<std::string> columns;
163 NativeRdb::RdbPredicates rdbPred("Photos");
164 DataShare::DataSharePredicates sharedPred;
165
166 Media::MediaLibraryCommand cmd(static_cast<Media::OperationObject>(FuzzInt32(data)),
167 static_cast<Media::OperationType>(FuzzInt32(data)), static_cast<Media::MediaLibraryApi>(FuzzInt32(data)));
168 Media::MediaLibraryAppUriPermissionOperations::HandleInsertOperation(cmd);
169 std::vector<DataShare::DataShareValuesBucket> sharedValues;
170 Media::MediaLibraryAppUriPermissionOperations::BatchInsert(cmd, sharedValues);
171 Media::MediaLibraryAppUriPermissionOperations::DeleteOperation(rdbPred);
172 Media::MediaLibraryAppUriPermissionOperations::QueryOperation(sharedPred, columns);
173 }
174
AppStateTest(const uint8_t * data,size_t size)175 static void AppStateTest(const uint8_t *data, size_t size)
176 {
177 Media::MedialibraryAppStateObserverManager::GetInstance().SubscribeAppState();
178 Media::MedialibraryAppStateObserverManager::GetInstance().UnSubscribeAppState();
179 }
180
MediaLibraryManagerTest(const uint8_t * data,size_t size)181 static void MediaLibraryManagerTest(const uint8_t *data, size_t size)
182 {
183 Media::MediaLibraryDataManagerUtils::IsNumber(FuzzString(data, size));
184 Media::MediaLibraryDataManagerUtils::GetOperationType(FuzzString(data, size));
185 Media::MediaLibraryDataManagerUtils::GetDisPlayNameFromPath(FuzzString(data, size));
186 std::vector<std::string> whereArgs;
187 std::string str = FuzzString(data, size);
188 Media::MediaLibraryDataManagerUtils::ObtionCondition(str, whereArgs);
189 Media::MediaLibraryDataManagerUtils::GetTypeUriByUri(str);
190 }
191
MultistageTest(const uint8_t * data,size_t size)192 static void MultistageTest(const uint8_t *data, size_t size)
193 {
194 Media::MultiStagesCaptureDfxFirstVisit::GetInstance().Report(FuzzString(data, size));
195 }
196
RefreshAlbumTest(const uint8_t * data,size_t size)197 static void RefreshAlbumTest(const uint8_t *data, size_t size)
198 {
199 Media::RefreshAlbums(true);
200 }
201
ActiveAnalysisTest()202 static void ActiveAnalysisTest()
203 {
204 std::vector<std::string> fileIds;
205 fileIds.push_back("1");
206 Media::MediaAnalysisHelper::StartMediaAnalysisServiceSync(
207 static_cast<int32_t>(Media::MediaAnalysisProxy::ActivateServiceType::START_SERVICE_OCR), fileIds);
208 Media::MediaAnalysisHelper::StartMediaAnalysisServiceAsync(
209 static_cast<int32_t>(Media::MediaAnalysisProxy::ActivateServiceType::START_SERVICE_OCR), fileIds);
210 }
211
CloudDownloadTest()212 static void CloudDownloadTest()
213 {
214 Media::BackgroundCloudFileProcessor::StartTimer();
215 int sleepTime = 200;
216 std::this_thread::sleep_for(std::chrono::microseconds(sleepTime));
217 Media::BackgroundCloudFileProcessor::StopTimer();
218 }
219 } // namespace OHOS
220
221 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)222 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
223 {
224 /* Run your code on data */
225 OHOS::Init();
226 int sleepTime = 100;
227 std::this_thread::sleep_for(std::chrono::microseconds(sleepTime));
228 OHOS::CommandTest(data, size);
229 OHOS::DirOperationTest(data, size);
230 OHOS::UriPermissionTest(data, size);
231 OHOS::AnalysisTest(data, size);
232 OHOS::AppPermissionTest(data, size);
233 OHOS::AppStateTest(data, size);
234 OHOS::MediaLibraryManagerTest(data, size);
235 OHOS::MultistageTest(data, size);
236 OHOS::RefreshAlbumTest(data, size);
237 OHOS::ActiveAnalysisTest();
238 OHOS::CloudDownloadTest();
239 return 0;
240 }
241