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