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 "types.h"
23
24 using namespace OHOS;
25 using namespace OHOS::DistributedKv;
26
27 class DistributedKvDataManagerFuzzer {
28 /* Keep C++ file names the same as the class name */
29 };
30
31 namespace OHOS {
32 static std::shared_ptr<SingleKvStore> singleKvStore_ = nullptr;
33
34 static DistributedKvDataManager manager;
35 static Options create;
36 static Options noCreate;
37 static UserId userId;
38 static AppId appId;
39 static StoreId storeIdTest;
40
41 class MyDeathRecipient : public KvStoreDeathRecipient {
42 public:
MyDeathRecipient()43 MyDeathRecipient()
44 {
45 }
~MyDeathRecipient()46 virtual ~MyDeathRecipient()
47 {
48 }
OnRemoteDied()49 void OnRemoteDied() override
50 {
51 }
52 };
53
SetUpTestCase(void)54 void SetUpTestCase(void)
55 {
56 userId.userId = "account";
57 appId.appId = "distributedkvdatamanagerfuzzertest";
58 create.createIfMissing = true;
59 create.encrypt = false;
60 create.autoSync = true;
61 create.kvStoreType = SINGLE_VERSION;
62 create.area = EL1;
63 create.baseDir = std::string("/data/service/el1/public/database/") + appId.appId;
64 mkdir(create.baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
65
66 manager.CloseAllKvStore(appId);
67 manager.DeleteAllKvStore(appId, create.baseDir);
68 }
69
TearDown(void)70 void TearDown(void)
71 {
72 manager.CloseAllKvStore(appId);
73 manager.DeleteAllKvStore(appId, create.baseDir);
74 (void)remove("/data/service/el1/public/database/distributedkvdatamanagerfuzzertest/key");
75 (void)remove("/data/service/el1/public/database/distributedkvdatamanagerfuzzertest/kvdb");
76 (void)remove("/data/service/el1/public/database/distributedkvdatamanagerfuzzertest");
77 }
78
GetKvStoreFuzz(const uint8_t * data,size_t size)79 void GetKvStoreFuzz(const uint8_t *data, size_t size)
80 {
81 StoreId storeId;
82 storeId.storeId = std::string(data, data + size);
83 std::shared_ptr<SingleKvStore> notExistKvStore;
84 manager.GetSingleKvStore(create, appId, storeId, notExistKvStore);
85 std::shared_ptr<SingleKvStore> existKvStore;
86 manager.GetSingleKvStore(noCreate, appId, storeId, existKvStore);
87 manager.CloseKvStore(appId, storeId);
88 manager.DeleteKvStore(appId, storeId);
89 }
90
GetAllKvStoreFuzz(const uint8_t * data,size_t size)91 void GetAllKvStoreFuzz(const uint8_t *data, size_t size)
92 {
93 std::vector<StoreId> storeIds;
94 manager.GetAllKvStoreId(appId, storeIds);
95
96 std::shared_ptr<SingleKvStore> KvStore;
97 std::string storeId_base(data, data + size);
98 int sum = 10;
99 for (int i = 0; i < sum; i++) {
100 StoreId storeId;
101 storeId.storeId = storeId_base + "_" + std::to_string(i);
102 manager.GetSingleKvStore(create, appId, storeId, KvStore);
103 }
104 manager.GetAllKvStoreId(appId, storeIds);
105 manager.CloseAllKvStore(appId);
106
107 manager.GetAllKvStoreId(appId, storeIds);
108 }
109
CloseKvStoreFuzz(const uint8_t * data,size_t size)110 void CloseKvStoreFuzz(const uint8_t *data, size_t size)
111 {
112 StoreId storeId;
113 storeId.storeId = std::string(data, data + size);
114 manager.CloseKvStore(appId, storeId);
115 std::shared_ptr<SingleKvStore> kvStore;
116 manager.GetSingleKvStore(create, appId, storeId, kvStore);
117 manager.CloseKvStore(appId, storeId);
118 manager.CloseKvStore(appId, storeId);
119 }
120
DeleteKvStoreFuzz(const uint8_t * data,size_t size)121 void DeleteKvStoreFuzz(const uint8_t *data, size_t size)
122 {
123 StoreId storeId;
124 storeId.storeId = std::string(data, data + size);
125 manager.DeleteKvStore(appId, storeId, create.baseDir);
126
127 std::shared_ptr<SingleKvStore> kvStore;
128 manager.GetSingleKvStore(create, appId, storeId, kvStore);
129 manager.CloseKvStore(appId, storeId);
130 manager.DeleteKvStore(appId, storeId, create.baseDir);
131
132 manager.CloseKvStore(appId, storeId);
133 }
134
DeleteAllKvStoreFuzz1(const uint8_t * data,size_t size)135 void DeleteAllKvStoreFuzz1(const uint8_t *data, size_t size)
136 {
137 std::vector<StoreId> storeIds;
138 manager.GetAllKvStoreId(appId, storeIds);
139
140 manager.DeleteAllKvStore(appId, create.baseDir);
141 std::shared_ptr<SingleKvStore> KvStore;
142 std::string storeId_base(data, data + size);
143 int sum = 10;
144 for (int i = 0; i < sum; i++) {
145 StoreId storeId;
146 storeId.storeId = storeId_base + "_" + std::to_string(i);
147 manager.GetSingleKvStore(create, appId, storeId, KvStore);
148
149 manager.CloseKvStore(appId, storeId);
150 }
151 manager.DeleteAllKvStore(appId, create.baseDir);
152 }
153
DeleteAllKvStoreFuzz2(const uint8_t * data,size_t size)154 void DeleteAllKvStoreFuzz2(const uint8_t *data, size_t size)
155 {
156 std::vector<StoreId> storeIds;
157 manager.GetAllKvStoreId(appId, storeIds);
158
159 std::shared_ptr<SingleKvStore> KvStore;
160 std::string storeId_base(data, data + size);
161 manager.GetSingleKvStore(create, appId, storeIdTest, KvStore);
162 manager.CloseKvStore(appId, storeIdTest);
163 int sum = 10;
164 for (int i = 0; i < sum; i++) {
165 StoreId storeId;
166 storeId.storeId = storeId_base + "_" + std::to_string(i);
167 manager.GetSingleKvStore(create, appId, storeId, KvStore);
168 }
169 manager.DeleteAllKvStore(appId, create.baseDir);
170 }
171
DeleteAllKvStoreFuzz3(const uint8_t * data,size_t size)172 void DeleteAllKvStoreFuzz3(const uint8_t *data, size_t size)
173 {
174 std::vector<StoreId> storeIds;
175 manager.GetAllKvStoreId(appId, storeIds);
176
177 std::shared_ptr<SingleKvStore> KvStore;
178 std::string storeId_base(data, data + size);
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
RegisterKvStoreServiceDeathRecipientFuzz()188 void RegisterKvStoreServiceDeathRecipientFuzz()
189 {
190 std::shared_ptr<KvStoreDeathRecipient> kvStoreDeathRecipient = std::make_shared<MyDeathRecipient>();
191 manager.RegisterKvStoreServiceDeathRecipient(kvStoreDeathRecipient);
192 kvStoreDeathRecipient->OnRemoteDied();
193 }
194
UnRegisterKvStoreServiceDeathRecipientFuzz()195 void UnRegisterKvStoreServiceDeathRecipientFuzz()
196 {
197 std::shared_ptr<KvStoreDeathRecipient> kvStoreDeathRecipient = std::make_shared<MyDeathRecipient>();
198 manager.UnRegisterKvStoreServiceDeathRecipient(kvStoreDeathRecipient);
199 kvStoreDeathRecipient->OnRemoteDied();
200 }
201 } // namespace OHOS
202
203 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)204 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
205 {
206 /* Run your code on data */
207 OHOS::SetUpTestCase();
208 OHOS::GetKvStoreFuzz(data, size);
209 OHOS::GetAllKvStoreFuzz(data, size);
210 OHOS::CloseKvStoreFuzz(data, size);
211 OHOS::DeleteKvStoreFuzz(data, size);
212 OHOS::DeleteAllKvStoreFuzz1(data, size);
213 OHOS::DeleteAllKvStoreFuzz2(data, size);
214 OHOS::DeleteAllKvStoreFuzz3(data, size);
215 OHOS::RegisterKvStoreServiceDeathRecipientFuzz();
216 OHOS::UnRegisterKvStoreServiceDeathRecipientFuzz();
217 OHOS::TearDown();
218 return 0;
219 }