1 /*
2 * Copyright (c) 2021 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 "distributedkvdatamanager_fuzzer.h"
16
17 #include <vector>
18 #include <sys/stat.h>
19
20 #include "distributed_kv_data_manager.h"
21 #include "fuzzer/FuzzedDataProvider.h"
22 #include "kvstore_death_recipient.h"
23 #include "kvstore_observer.h"
24 #include "types.h"
25
26 using namespace OHOS;
27 using namespace OHOS::DistributedKv;
28
29 class DistributedKvDataManagerFuzzer {
30 /* Keep C++ file names the same as the class name */
31 };
32
33 namespace OHOS {
34 static std::shared_ptr<SingleKvStore> singleKvStore_ = nullptr;
35
36 static DistributedKvDataManager manager;
37 static Options create;
38 static Options noCreate;
39 static UserId userId;
40 static AppId appId;
41 static StoreId storeIdTest;
42
43 class MyDeathRecipient : public KvStoreDeathRecipient {
44 public:
MyDeathRecipient()45 MyDeathRecipient()
46 {
47 }
~MyDeathRecipient()48 virtual ~MyDeathRecipient()
49 {
50 }
OnRemoteDied()51 void OnRemoteDied() override
52 {
53 }
54 };
55
56 class SwitchDataObserver : public KvStoreObserver {
57 public:
SwitchDataObserver()58 SwitchDataObserver() {}
~SwitchDataObserver()59 ~SwitchDataObserver() {}
60 SwitchDataObserver(const SwitchDataObserver &) = delete;
61 SwitchDataObserver &operator=(const SwitchDataObserver &) = delete;
62 SwitchDataObserver(SwitchDataObserver &&) = delete;
63 SwitchDataObserver &operator=(SwitchDataObserver &&) = delete;
64
OnSwitchChange(const SwitchNotification & notification)65 void OnSwitchChange(const SwitchNotification ¬ification) override
66 {
67 }
68 };
69
SetUpTestCase(void)70 void SetUpTestCase(void)
71 {
72 userId.userId = "account";
73 appId.appId = "distributedkvdatamanagerfuzzertest";
74 create.createIfMissing = true;
75 create.encrypt = false;
76 create.autoSync = true;
77 create.kvStoreType = SINGLE_VERSION;
78 create.area = EL1;
79 create.baseDir = std::string("/data/service/el1/public/database/") + appId.appId;
80 mkdir(create.baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
81
82 manager.CloseAllKvStore(appId);
83 manager.DeleteAllKvStore(appId, create.baseDir);
84 }
85
TearDown(void)86 void TearDown(void)
87 {
88 manager.CloseAllKvStore(appId);
89 manager.DeleteAllKvStore(appId, create.baseDir);
90 (void)remove("/data/service/el1/public/database/distributedkvdatamanagerfuzzertest/key");
91 (void)remove("/data/service/el1/public/database/distributedkvdatamanagerfuzzertest/kvdb");
92 (void)remove("/data/service/el1/public/database/distributedkvdatamanagerfuzzertest");
93 }
94
GetKvStoreFuzz(FuzzedDataProvider & provider)95 void GetKvStoreFuzz(FuzzedDataProvider &provider)
96 {
97 StoreId storeId;
98 storeId.storeId = provider.ConsumeRandomLengthString();
99 std::shared_ptr<SingleKvStore> notExistKvStore;
100 manager.GetSingleKvStore(create, appId, storeId, notExistKvStore);
101 std::shared_ptr<SingleKvStore> existKvStore;
102 manager.GetSingleKvStore(noCreate, appId, storeId, existKvStore);
103 manager.CloseKvStore(appId, storeId);
104 manager.DeleteKvStore(appId, storeId);
105 }
106
GetAllKvStoreFuzz(FuzzedDataProvider & provider)107 void GetAllKvStoreFuzz(FuzzedDataProvider &provider)
108 {
109 std::vector<StoreId> storeIds;
110 manager.GetAllKvStoreId(appId, storeIds);
111
112 std::shared_ptr<SingleKvStore> KvStore;
113 std::string storeId_base = provider.ConsumeRandomLengthString();
114 int sum = 10;
115 for (int i = 0; i < sum; i++) {
116 StoreId storeId;
117 storeId.storeId = storeId_base + "_" + std::to_string(i);
118 manager.GetSingleKvStore(create, appId, storeId, KvStore);
119 }
120 manager.GetAllKvStoreId(appId, storeIds);
121 manager.CloseAllKvStore(appId);
122
123 manager.GetAllKvStoreId(appId, storeIds);
124 }
125
CloseKvStoreFuzz(FuzzedDataProvider & provider)126 void CloseKvStoreFuzz(FuzzedDataProvider &provider)
127 {
128 StoreId storeId;
129 storeId.storeId = provider.ConsumeRandomLengthString();
130 manager.CloseKvStore(appId, storeId);
131 std::shared_ptr<SingleKvStore> kvStore;
132 manager.GetSingleKvStore(create, appId, storeId, kvStore);
133 manager.CloseKvStore(appId, storeId);
134 manager.CloseKvStore(appId, storeId);
135 }
136
DeleteKvStoreFuzz(FuzzedDataProvider & provider)137 void DeleteKvStoreFuzz(FuzzedDataProvider &provider)
138 {
139 StoreId storeId;
140 storeId.storeId = provider.ConsumeRandomLengthString();
141 manager.DeleteKvStore(appId, storeId, create.baseDir);
142
143 std::shared_ptr<SingleKvStore> kvStore;
144 manager.GetSingleKvStore(create, appId, storeId, kvStore);
145 manager.CloseKvStore(appId, storeId);
146 manager.DeleteKvStore(appId, storeId, create.baseDir);
147
148 manager.CloseKvStore(appId, storeId);
149 }
150
DeleteAllKvStoreFuzz1(FuzzedDataProvider & provider)151 void DeleteAllKvStoreFuzz1(FuzzedDataProvider &provider)
152 {
153 std::vector<StoreId> storeIds;
154 manager.GetAllKvStoreId(appId, storeIds);
155
156 manager.DeleteAllKvStore(appId, create.baseDir);
157 std::shared_ptr<SingleKvStore> KvStore;
158 std::string storeId_base = provider.ConsumeRandomLengthString();
159 int sum = 10;
160 for (int i = 0; i < sum; i++) {
161 StoreId storeId;
162 storeId.storeId = storeId_base + "_" + std::to_string(i);
163 manager.GetSingleKvStore(create, appId, storeId, KvStore);
164
165 manager.CloseKvStore(appId, storeId);
166 }
167 manager.DeleteAllKvStore(appId, create.baseDir);
168 }
169
DeleteAllKvStoreFuzz2(FuzzedDataProvider & provider)170 void DeleteAllKvStoreFuzz2(FuzzedDataProvider &provider)
171 {
172 std::vector<StoreId> storeIds;
173 manager.GetAllKvStoreId(appId, storeIds);
174
175 std::shared_ptr<SingleKvStore> KvStore;
176 std::string storeId_base = provider.ConsumeRandomLengthString();
177 manager.GetSingleKvStore(create, appId, storeIdTest, KvStore);
178 manager.CloseKvStore(appId, storeIdTest);
179 int sum = 10;
180 for (int i = 0; i < sum; i++) {
181 StoreId storeId;
182 storeId.storeId = storeId_base + "_" + std::to_string(i);
183 manager.GetSingleKvStore(create, appId, storeId, KvStore);
184 }
185 manager.DeleteAllKvStore(appId, create.baseDir);
186 }
187
DeleteAllKvStoreFuzz3(FuzzedDataProvider & provider)188 void DeleteAllKvStoreFuzz3(FuzzedDataProvider &provider)
189 {
190 std::vector<StoreId> storeIds;
191 manager.GetAllKvStoreId(appId, storeIds);
192
193 std::shared_ptr<SingleKvStore> KvStore;
194 std::string storeId_base = provider.ConsumeRandomLengthString();
195 int sum = 10;
196 for (int i = 0; i < sum; i++) {
197 StoreId storeId;
198 storeId.storeId = storeId_base + "_" + std::to_string(i);
199 manager.GetSingleKvStore(create, appId, storeId, KvStore);
200 }
201 manager.DeleteAllKvStore(appId, create.baseDir);
202 }
203
RegisterKvStoreServiceDeathRecipientFuzz()204 void RegisterKvStoreServiceDeathRecipientFuzz()
205 {
206 std::shared_ptr<KvStoreDeathRecipient> kvStoreDeathRecipient = std::make_shared<MyDeathRecipient>();
207 manager.RegisterKvStoreServiceDeathRecipient(kvStoreDeathRecipient);
208 kvStoreDeathRecipient->OnRemoteDied();
209 }
210
UnRegisterKvStoreServiceDeathRecipientFuzz()211 void UnRegisterKvStoreServiceDeathRecipientFuzz()
212 {
213 std::shared_ptr<KvStoreDeathRecipient> kvStoreDeathRecipient = std::make_shared<MyDeathRecipient>();
214 manager.UnRegisterKvStoreServiceDeathRecipient(kvStoreDeathRecipient);
215 kvStoreDeathRecipient->OnRemoteDied();
216 }
217
PutSwitchFuzz(FuzzedDataProvider & provider)218 void PutSwitchFuzz(FuzzedDataProvider &provider)
219 {
220 std::string appIds = provider.ConsumeRandomLengthString();
221 uint32_t input = provider.ConsumeIntegral<uint32_t>();
222 SwitchData switchData;
223 switchData.value = input;
224 switchData.length = input & 0xFFFF;
225 manager.PutSwitch({ appIds }, switchData);
226 manager.PutSwitch({ "distributed_device_profile_service" }, switchData);
227 }
228
GetSwitchFuzz(FuzzedDataProvider & provider)229 void GetSwitchFuzz(FuzzedDataProvider &provider)
230 {
231 std::string appIds = provider.ConsumeRandomLengthString();
232 std::string networkId = provider.ConsumeRandomLengthString();
233 manager.GetSwitch({ appIds }, networkId);
234 manager.GetSwitch({ "distributed_device_profile_service" }, networkId);
235 }
236
SubscribeSwitchDataFuzz(FuzzedDataProvider & provider)237 void SubscribeSwitchDataFuzz(FuzzedDataProvider &provider)
238 {
239 std::string appIds = provider.ConsumeRandomLengthString();
240 std::shared_ptr<SwitchDataObserver> observer = std::make_shared<SwitchDataObserver>();
241 manager.SubscribeSwitchData({ appIds }, observer);
242 }
243
UnsubscribeSwitchDataFuzz(FuzzedDataProvider & provider)244 void UnsubscribeSwitchDataFuzz(FuzzedDataProvider &provider)
245 {
246 std::string appIds = provider.ConsumeRandomLengthString();
247 std::shared_ptr<SwitchDataObserver> observer = std::make_shared<SwitchDataObserver>();
248 manager.SubscribeSwitchData({ appIds }, observer);
249 manager.UnsubscribeSwitchData({ appIds }, observer);
250 }
251
SetExecutorsFuzz(FuzzedDataProvider & provider)252 void SetExecutorsFuzz(FuzzedDataProvider &provider)
253 {
254 size_t max = provider.ConsumeIntegral<size_t>();
255 size_t min = provider.ConsumeIntegral<size_t>();
256 auto executors = std::make_shared<ExecutorPool>(max, min);
257 manager.SetExecutors(executors);
258 }
259 } // namespace OHOS
260
261 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)262 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
263 {
264 /* Run your code on data */
265 FuzzedDataProvider provider(data, size);
266 OHOS::SetUpTestCase();
267 OHOS::GetKvStoreFuzz(provider);
268 OHOS::GetAllKvStoreFuzz(provider);
269 OHOS::CloseKvStoreFuzz(provider);
270 OHOS::DeleteKvStoreFuzz(provider);
271 OHOS::DeleteAllKvStoreFuzz1(provider);
272 OHOS::DeleteAllKvStoreFuzz2(provider);
273 OHOS::DeleteAllKvStoreFuzz3(provider);
274 OHOS::RegisterKvStoreServiceDeathRecipientFuzz();
275 OHOS::UnRegisterKvStoreServiceDeathRecipientFuzz();
276 OHOS::PutSwitchFuzz(provider);
277 OHOS::GetSwitchFuzz(provider);
278 OHOS::SubscribeSwitchDataFuzz(provider);
279 OHOS::UnsubscribeSwitchDataFuzz(provider);
280 OHOS::TearDown();
281 return 0;
282 }