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 "medialibrarycloudmediaassetmanager_fuzzer.h"
17
18 #include <cstdint>
19 #include <string>
20 #include <pixel_map.h>
21
22 #define private public
23 #include "cloud_media_asset_manager.h"
24 #include "cloud_media_asset_download_operation.h"
25 #include "cloud_media_asset_types.h"
26 #undef private
27 #include "ability_context_impl.h"
28 #include "media_log.h"
29 #include "medialibrary_command.h"
30 #include "medialibrary_data_manager.h"
31 #include "medialibrary_rdbstore.h"
32 #include "medialibrary_unistore_manager.h"
33
34 namespace OHOS {
35 using namespace std;
36 using namespace AbilityRuntime;
37 static const string DELETE_DISPLAY_NAME = "cloud_media_asset_deleted";
38 const int32_t EVEN = 2;
39 static const int32_t E_ERR = -1;
40 static const string PHOTOS_TABLE = "Photos";
41 std::shared_ptr<Media::MediaLibraryRdbStore> g_rdbStore;
42
FuzzInt32(const uint8_t * data,size_t size)43 static inline int32_t FuzzInt32(const uint8_t *data, size_t size)
44 {
45 return static_cast<int32_t>(*data);
46 }
47
FuzzInt64(const uint8_t * data,size_t size)48 static inline int64_t FuzzInt64(const uint8_t *data, size_t size)
49 {
50 return static_cast<int64_t>(*data);
51 }
52
FuzzString(const uint8_t * data,size_t size)53 static inline string FuzzString(const uint8_t *data, size_t size)
54 {
55 return {reinterpret_cast<const char*>(data), size};
56 }
57
FuzzBool(const uint8_t * data,size_t size)58 static inline bool FuzzBool(const uint8_t* data, size_t size)
59 {
60 if (size == 0) {
61 return false;
62 }
63 return (data[0] % EVEN) == 0;
64 }
65
FuzzCloudMediaDownloadType(const uint8_t * data,size_t size)66 static inline Media::CloudMediaDownloadType FuzzCloudMediaDownloadType(const uint8_t* data, size_t size)
67 {
68 int32_t value = FuzzInt32(data, size);
69 if (value >= static_cast<int32_t>(Media::CloudMediaDownloadType::DOWNLOAD_FORCE) &&
70 value <= static_cast<int32_t>(Media::CloudMediaDownloadType::DOWNLOAD_GENTLE)) {
71 return static_cast<Media::CloudMediaDownloadType>(value);
72 }
73 return Media::CloudMediaDownloadType::DOWNLOAD_FORCE;
74 }
75
FuzzCloudMediaTaskRecoverCause(const uint8_t * data,size_t size)76 static inline Media::CloudMediaTaskRecoverCause FuzzCloudMediaTaskRecoverCause(const uint8_t* data, size_t size)
77 {
78 int32_t value = FuzzInt32(data, size);
79 if (value >= static_cast<int32_t>(Media::CloudMediaTaskRecoverCause::FOREGROUND_TEMPERATURE_PROPER) &&
80 value <= static_cast<int32_t>(Media::CloudMediaTaskRecoverCause::RETRY_FOR_CLOUD_ERROR)) {
81 return static_cast<Media::CloudMediaTaskRecoverCause>(value);
82 }
83 return Media::CloudMediaTaskRecoverCause::RETRY_FOR_CLOUD_ERROR;
84 }
85
FuzzCloudMediaTaskPauseCause(const uint8_t * data,size_t size)86 static inline Media::CloudMediaTaskPauseCause FuzzCloudMediaTaskPauseCause(const uint8_t* data, size_t size)
87 {
88 int32_t value = FuzzInt32(data, size);
89 if (value >= static_cast<int32_t>(Media::CloudMediaTaskPauseCause::NO_PAUSE) &&
90 value <= static_cast<int32_t>(Media::CloudMediaTaskPauseCause::USER_PAUSED)) {
91 return static_cast<Media::CloudMediaTaskPauseCause>(value);
92 }
93 return Media::CloudMediaTaskPauseCause::NO_PAUSE;
94 }
95
InsertAsset(const uint8_t * data,size_t size)96 static int32_t InsertAsset(const uint8_t *data, size_t size)
97 {
98 if (g_rdbStore == nullptr) {
99 return E_ERR;
100 }
101 NativeRdb::ValuesBucket values;
102 values.PutString(Media::MediaColumn::MEDIA_FILE_PATH, FuzzString(data, size));
103 values.PutLong(Media::MediaColumn::MEDIA_DATE_TAKEN, FuzzInt64(data, size));
104 values.PutString(Media::MediaColumn::MEDIA_NAME, DELETE_DISPLAY_NAME);
105 int64_t fileId = 0;
106 g_rdbStore->Insert(fileId, PHOTOS_TABLE, values);
107 return static_cast<int32_t>(fileId);
108 }
109
FuzzUri(const uint8_t * data,size_t size)110 static inline Uri FuzzUri(const uint8_t *data, size_t size)
111 {
112 uint8_t length = static_cast<uint8_t>(Media::CLOUD_MEDIA_ASSET_MANAGER_FUZZER_URI_LISTS.size());
113 if (*data < length) {
114 string uriStr = Media::CLOUD_MEDIA_ASSET_MANAGER_FUZZER_URI_LISTS[*data];
115 Uri uri(uriStr);
116 return uri;
117 }
118 return Uri("Undefined");
119 }
120
FuzzMediaLibraryCmd(const uint8_t * data,size_t size)121 static inline Media::MediaLibraryCommand FuzzMediaLibraryCmd(const uint8_t *data, size_t size)
122 {
123 return Media::MediaLibraryCommand(FuzzUri(data, size));
124 }
125
SetTables()126 void SetTables()
127 {
128 vector<string> createTableSqlList = { Media::PhotoColumn::CREATE_PHOTO_TABLE };
129 for (auto &createTableSql : createTableSqlList) {
130 int32_t ret = g_rdbStore->ExecuteSql(createTableSql);
131 if (ret != NativeRdb::E_OK) {
132 MEDIA_ERR_LOG("Execute sql %{private}s failed", createTableSql.c_str());
133 return;
134 }
135 MEDIA_DEBUG_LOG("Execute sql %{private}s success", createTableSql.c_str());
136 }
137 }
138
Init()139 static void Init()
140 {
141 auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
142 auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
143 abilityContextImpl->SetStageContext(stageContext);
144 int32_t sceneCode = 0;
145 auto ret = Media::MediaLibraryDataManager::GetInstance()->InitMediaLibraryMgr(abilityContextImpl,
146 abilityContextImpl, sceneCode);
147 CHECK_AND_RETURN_LOG(ret == NativeRdb::E_OK, "InitMediaLibraryMgr failed, ret: %{public}d", ret);
148
149 auto rdbStore = Media::MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
150 if (rdbStore == nullptr) {
151 MEDIA_ERR_LOG("rdbStore is nullptr");
152 return;
153 }
154 g_rdbStore = rdbStore;
155 SetTables();
156 }
157
CloudMediaAssetManagerFuzzer(const uint8_t * data,size_t size)158 static void CloudMediaAssetManagerFuzzer(const uint8_t *data, size_t size)
159 {
160 Media::MediaLibraryCommand cmd = FuzzMediaLibraryCmd(data, size);
161 Media::CloudMediaAssetManager::GetInstance().HandleCloudMediaAssetUpdateOperations(cmd);
162 Media::CloudMediaAssetManager::GetInstance().HandleCloudMediaAssetGetTypeOperations(cmd);
163 }
164
CloudMediaAssetDownloadFuzzer(const uint8_t * data,size_t size)165 static void CloudMediaAssetDownloadFuzzer(const uint8_t *data, size_t size)
166 {
167 Media::CloudMediaAssetManager &instance = Media::CloudMediaAssetManager::GetInstance();
168 instance.CheckDownloadTypeOfTask(FuzzCloudMediaDownloadType(data, size));
169
170 instance.StartDownloadCloudAsset(FuzzCloudMediaDownloadType(data, size));
171 instance.StartDownloadCloudAsset(FuzzCloudMediaDownloadType(data, size));
172 instance.RecoverDownloadCloudAsset(FuzzCloudMediaTaskRecoverCause(data, size));
173 instance.PauseDownloadCloudAsset(FuzzCloudMediaTaskPauseCause(data, size));
174 instance.CancelDownloadCloudAsset();
175 instance.GetCloudMediaAssetTaskStatus();
176 instance.SetIsThumbnailUpdate();
177 instance.GetTaskStatus();
178 instance.GetDownloadType();
179 instance.SetBgDownloadPermission(FuzzBool(data, size));
180 }
181
CloudMediaAssetDeleteFuzzer(const uint8_t * data,size_t size)182 static void CloudMediaAssetDeleteFuzzer(const uint8_t *data, size_t size)
183 {
184 Media::CloudMediaAssetManager &instance = Media::CloudMediaAssetManager::GetInstance();
185 int32_t fileId = InsertAsset(data, size);
186 vector<string> fileIds = { to_string(fileId) };
187 instance.DeleteBatchCloudFile(fileIds);
188 fileIds.clear();
189 vector<string> paths;
190 vector<string> dateTakens;
191 fileId = InsertAsset(data, size);
192 instance.ReadyDataForDelete(fileIds, paths, dateTakens);
193 instance.ForceRetainDownloadCloudMedia();
194 }
195 } // namespace OHOS
196
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)197 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
198 {
199 OHOS::Init();
200 OHOS::CloudMediaAssetManagerFuzzer(data, size);
201 OHOS::CloudMediaAssetDownloadFuzzer(data, size);
202 OHOS::CloudMediaAssetDeleteFuzzer(data, size);
203 return 0;
204 }
205