1 /*
2 * Copyright (c) 2022 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 "schemaquery_fuzzer.h"
17 #include "distributed_kv_data_manager.h"
18 #include "data_query.h"
19 #include "sys/stat.h"
20
21 using namespace std;
22 using namespace OHOS;
23 using namespace DistributedKv;
24
25 namespace OHOS {
26 constexpr const char *VALID_SCHEMA_STRICT_DEFINE = "{\"SCHEMA_VERSION\":\"1.0\","
27 "\"SCHEMA_MODE\":\"STRICT\",\"SCHEMA_DEFINE\":{"
28 "\"name\":\"INTEGER, NOT NULL\"},\"SCHEMA_INDEXES\":[\"$.name\"}}";
29 static DistributedKvDataManager g_kvManager;
30
31 // Test 1: Open KvStore with fuzzed schema string.
TestOpenSchemaStore001(const std::string & fuzzedString)32 void TestOpenSchemaStore001(const std::string &fuzzedString)
33 {
34 std::shared_ptr<SingleKvStore> singleKvStorePtr;
35 Options options = {.createIfMissing = true, .encrypt = true, .autoSync = true};
36 options.schema = fuzzedString;
37 options.area = EL1;
38 options.baseDir = "/data/service/el1/public/database/schemaqueryfuzztest";
39 AppId appId = {"schemaqueryfuzztest"};
40 StoreId storeId = {"TestOpenSchemaStore001_storeId_fuzz"};
41 g_kvManager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr);
42 g_kvManager.CloseAllKvStore(appId);
43 g_kvManager.DeleteAllKvStore(appId);
44 }
45
ExecuteQuery(SingleKvStore * singleKvStorePtr,const DataQuery & query)46 void ExecuteQuery(SingleKvStore* singleKvStorePtr, const DataQuery &query)
47 {
48 if (singleKvStorePtr == nullptr) {
49 return;
50 }
51 std::vector<Entry> results1;
52 singleKvStorePtr->GetEntries(query, results1);
53 Key prefix1;
54 std::vector<Entry> results2;
55 singleKvStorePtr->GetEntries(prefix1, results2);
56 std::shared_ptr<KvStoreResultSet> callback1;
57 singleKvStorePtr->GetResultSet(query, callback1);
58 singleKvStorePtr->CloseResultSet(callback1);
59 Key prefix2;
60 std::shared_ptr<KvStoreResultSet> callback2;
61 singleKvStorePtr->GetResultSet(prefix2, callback2);
62 singleKvStorePtr->CloseResultSet(callback2);
63 int resultSize = 0;
64 singleKvStorePtr->GetCount(query, resultSize);
65 }
66
67 // Test 2: Query EqualTo.
TestQuerySchemaStore001(int fuzzedInt,int64_t fuzzedLong,double fuzzedDouble,bool fuzzedBoolean,std::string & fuzzedString)68 void TestQuerySchemaStore001(int fuzzedInt, int64_t fuzzedLong, double fuzzedDouble,
69 bool fuzzedBoolean, std::string &fuzzedString)
70 {
71 std::shared_ptr<SingleKvStore> singleKvStorePtr;
72 Options options = {.createIfMissing = true, .encrypt = true, .autoSync = true};
73 options.schema = VALID_SCHEMA_STRICT_DEFINE;
74 options.area = EL1;
75 options.baseDir = "/data/service/el1/public/database/schemaqueryfuzztest";
76 AppId appId = {"schemaqueryfuzztest"};
77 StoreId storeId = {"TestQuerySchemaStore001_storeId_fuzz"};
78 g_kvManager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr);
79 DataQuery query;
80 query.Reset();
81 query.EqualTo(fuzzedString, fuzzedInt);
82 query.And();
83 query.EqualTo(fuzzedString, fuzzedLong);
84 query.Or();
85 query.EqualTo(fuzzedString, fuzzedDouble);
86 query.And();
87 query.EqualTo(fuzzedString, fuzzedBoolean);
88 query.Or();
89 query.EqualTo(fuzzedString, fuzzedString);
90 ExecuteQuery(singleKvStorePtr.get(), query);
91 g_kvManager.CloseAllKvStore(appId);
92 g_kvManager.DeleteAllKvStore(appId);
93 }
94
95 // Test 3: Query NotEqualTo.
TestQuerySchemaStore002(int fuzzedInt,int64_t fuzzedLong,double fuzzedDouble,bool fuzzedBoolean,std::string & fuzzedString)96 void TestQuerySchemaStore002(int fuzzedInt, int64_t fuzzedLong, double fuzzedDouble,
97 bool fuzzedBoolean, std::string &fuzzedString)
98 {
99 std::shared_ptr<SingleKvStore> singleKvStorePtr;
100 Options options = {.createIfMissing = true, .encrypt = true, .autoSync = true};
101 options.schema = VALID_SCHEMA_STRICT_DEFINE;
102 options.area = EL1;
103 options.baseDir = "/data/service/el1/public/database/schemaqueryfuzztest";
104 AppId appId = {"schemaqueryfuzztest"};
105 StoreId storeId = {"TestQuerySchemaStore002_storeId_fuzz"};
106 g_kvManager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr);
107 DataQuery query;
108 query.Reset();
109 query.NotEqualTo(fuzzedString, fuzzedInt);
110 query.And();
111 query.NotEqualTo(fuzzedString, fuzzedLong);
112 query.Or();
113 query.NotEqualTo(fuzzedString, fuzzedDouble);
114 query.And();
115 query.NotEqualTo(fuzzedString, fuzzedBoolean);
116 query.Or();
117 query.NotEqualTo(fuzzedString, fuzzedString);
118 ExecuteQuery(singleKvStorePtr.get(), query);
119 g_kvManager.CloseAllKvStore(appId);
120 g_kvManager.DeleteAllKvStore(appId);
121 }
122
123 // Test 4: Query GreaterThan.
TestQuerySchemaStore003(int fuzzedInt,int64_t fuzzedLong,double fuzzedDouble,std::string & fuzzedString)124 void TestQuerySchemaStore003(int fuzzedInt, int64_t fuzzedLong, double fuzzedDouble, std::string &fuzzedString)
125 {
126 std::shared_ptr<SingleKvStore> singleKvStorePtr;
127 Options options = {.createIfMissing = true, .encrypt = true, .autoSync = true};
128 options.schema = VALID_SCHEMA_STRICT_DEFINE;
129 options.area = EL1;
130 options.baseDir = "/data/service/el1/public/database/schemaqueryfuzztest";
131 AppId appId = {"schemaqueryfuzztest"};
132 StoreId storeId = {"TestQuerySchemaStore003_storeId_fuzz"};
133 g_kvManager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr);
134 DataQuery query;
135 query.Reset();
136 query.GreaterThan(fuzzedString, fuzzedInt);
137 query.And();
138 query.GreaterThan(fuzzedString, fuzzedLong);
139 query.Or();
140 query.GreaterThan(fuzzedString, fuzzedDouble);
141 query.And();
142 query.GreaterThan(fuzzedString, fuzzedString);
143 ExecuteQuery(singleKvStorePtr.get(), query);
144 g_kvManager.CloseAllKvStore(appId);
145 g_kvManager.DeleteAllKvStore(appId);
146 }
147
148 // Test 5: Query LessThan.
TestQuerySchemaStore004(int fuzzedInt,int64_t fuzzedLong,double fuzzedDouble,std::string & fuzzedString)149 void TestQuerySchemaStore004(int fuzzedInt, int64_t fuzzedLong, double fuzzedDouble, std::string &fuzzedString)
150 {
151 std::shared_ptr<SingleKvStore> singleKvStorePtr;
152 Options options = {.createIfMissing = true, .encrypt = true, .autoSync = true};
153 options.schema = VALID_SCHEMA_STRICT_DEFINE;
154 options.area = EL1;
155 options.baseDir = "/data/service/el1/public/database/schemaqueryfuzztest";
156 AppId appId = {"schemaqueryfuzztest"};
157 StoreId storeId = {"TestQuerySchemaStore004_storeId_fuzz"};
158 g_kvManager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr);
159 DataQuery query;
160 query.Reset();
161 query.LessThan(fuzzedString, fuzzedInt);
162 query.And();
163 query.LessThan(fuzzedString, fuzzedLong);
164 query.Or();
165 query.LessThan(fuzzedString, fuzzedDouble);
166 query.And();
167 query.LessThan(fuzzedString, fuzzedString);
168 ExecuteQuery(singleKvStorePtr.get(), query);
169 g_kvManager.CloseAllKvStore(appId);
170 g_kvManager.DeleteAllKvStore(appId);
171 }
172
173 // Test 6: Query GreaterThanOrEqualTo
TestQuerySchemaStore005(int fuzzedInt,int64_t fuzzedLong,double fuzzedDouble,std::string & fuzzedString)174 void TestQuerySchemaStore005(int fuzzedInt, int64_t fuzzedLong, double fuzzedDouble, std::string &fuzzedString)
175 {
176 std::shared_ptr<SingleKvStore> singleKvStorePtr;
177 Options options = {.createIfMissing = true, .encrypt = true, .autoSync = true};
178 options.schema = VALID_SCHEMA_STRICT_DEFINE;
179 options.area = EL1;
180 options.baseDir = "/data/service/el1/public/database/schemaqueryfuzztest";
181 AppId appId = {"schemaqueryfuzztest"};
182 StoreId storeId = {"TestQuerySchemaStore005_storeId_fuzz"};
183 g_kvManager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr);
184 DataQuery query;
185 query.Reset();
186 query.GreaterThanOrEqualTo(fuzzedString, fuzzedInt);
187 query.And();
188 query.GreaterThanOrEqualTo(fuzzedString, fuzzedLong);
189 query.Or();
190 query.GreaterThanOrEqualTo(fuzzedString, fuzzedDouble);
191 query.And();
192 query.GreaterThanOrEqualTo(fuzzedString, fuzzedString);
193 ExecuteQuery(singleKvStorePtr.get(), query);
194 g_kvManager.CloseAllKvStore(appId);
195 g_kvManager.DeleteAllKvStore(appId);
196 }
197
198 // Test 7: Query LessThanOrEqualTo.
TestQuerySchemaStore006(int fuzzedInt,int64_t fuzzedLong,double fuzzedDouble,std::string & fuzzedString)199 void TestQuerySchemaStore006(int fuzzedInt, int64_t fuzzedLong, double fuzzedDouble, std::string &fuzzedString)
200 {
201 std::shared_ptr<SingleKvStore> singleKvStorePtr;
202 Options options = {.createIfMissing = true, .encrypt = true, .autoSync = true};
203 options.schema = VALID_SCHEMA_STRICT_DEFINE;
204 options.area = EL1;
205 options.baseDir = "/data/service/el1/public/database/schemaqueryfuzztest";
206 AppId appId = {"schemaqueryfuzztest"};
207 StoreId storeId = {"TestQuerySchemaStore006_storeId_fuzz"};
208 g_kvManager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr);
209 DataQuery query;
210 query.Reset();
211 query.LessThanOrEqualTo(fuzzedString, fuzzedInt);
212 query.And();
213 query.LessThanOrEqualTo(fuzzedString, fuzzedLong);
214 query.Or();
215 query.LessThanOrEqualTo(fuzzedString, fuzzedDouble);
216 query.And();
217 query.LessThanOrEqualTo(fuzzedString, fuzzedString);
218 ExecuteQuery(singleKvStorePtr.get(), query);
219 g_kvManager.CloseAllKvStore(appId);
220 g_kvManager.DeleteAllKvStore(appId);
221 }
222
223 // Test 8: Query IsNull.
TestQuerySchemaStore007(std::string & fuzzedString)224 void TestQuerySchemaStore007(std::string &fuzzedString)
225 {
226 std::shared_ptr<SingleKvStore> singleKvStorePtr;
227 Options options = {.createIfMissing = true, .encrypt = true, .autoSync = true};
228 options.schema = VALID_SCHEMA_STRICT_DEFINE;
229 options.area = EL1;
230 options.baseDir = "/data/service/el1/public/database/schemaqueryfuzztest";
231 AppId appId = {"schemaqueryfuzztest"};
232 StoreId storeId = {"TestQuerySchemaStore007_storeId_fuzz"};
233 g_kvManager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr);
234 DataQuery query;
235 query.Reset();
236 query.IsNull(fuzzedString);
237 ExecuteQuery(singleKvStorePtr.get(), query);
238 g_kvManager.CloseAllKvStore(appId);
239 g_kvManager.DeleteAllKvStore(appId);
240 }
241
242 // Test 9: Query Like Unlike OrderByAsc OrderByDesc Limit.
TestQuerySchemaStore008(int fuzzedInt,std::string & fuzzedString)243 void TestQuerySchemaStore008(int fuzzedInt, std::string &fuzzedString)
244 {
245 std::shared_ptr<SingleKvStore> singleKvStorePtr;
246 Options options = {.createIfMissing = true, .encrypt = true, .autoSync = true};
247 options.schema = VALID_SCHEMA_STRICT_DEFINE;
248 options.area = EL1;
249 options.baseDir = "/data/service/el1/public/database/schemaqueryfuzztest";
250 AppId appId = {"schemaqueryfuzztest"};
251 StoreId storeId = {"TestQuerySchemaStore008_storeId_fuzz"};
252 g_kvManager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr);
253 DataQuery query;
254 query.Reset();
255 query.Like(fuzzedString, fuzzedString);
256 query.And();
257 query.Unlike(fuzzedString, fuzzedString);
258 query.OrderByAsc(fuzzedString);
259 query.OrderByDesc(fuzzedString);
260 query.Limit(fuzzedInt, fuzzedInt);
261 ExecuteQuery(singleKvStorePtr.get(), query);
262 g_kvManager.CloseAllKvStore(appId);
263 g_kvManager.DeleteAllKvStore(appId);
264 }
265
266 // Test 10: Batch.
TestBatch001(std::string & fuzzedString)267 void TestBatch001(std::string &fuzzedString)
268 {
269 std::shared_ptr<SingleKvStore> singleKvStorePtr;
270 Options options = {.createIfMissing = true, .encrypt = true, .autoSync = true};
271 options.schema = VALID_SCHEMA_STRICT_DEFINE;
272 options.area = EL1;
273 options.baseDir = "/data/service/el1/public/database/schemaqueryfuzztest";
274 AppId appId = {"schemaqueryfuzztest"};
275 StoreId storeId = {"TestBatch001_storeId_fuzz"};
276 g_kvManager.GetSingleKvStore(options, appId, storeId, singleKvStorePtr);
277 if (singleKvStorePtr == nullptr) {
278 return;
279 }
280 std::vector<Entry> entries;
281 Entry entry1, entry2, entry3;
282 entry1.key = fuzzedString;
283 entry1.value = fuzzedString;
284 entry2.key = fuzzedString;
285 entry2.value = fuzzedString;
286 entry3.key = fuzzedString;
287 entry3.value = fuzzedString;
288 entries.push_back(entry1);
289 entries.push_back(entry2);
290 entries.push_back(entry3);
291 std::vector<Key> keys;
292 keys.push_back(fuzzedString);
293 singleKvStorePtr->PutBatch(entries);
294 singleKvStorePtr->DeleteBatch(keys);
295 g_kvManager.CloseAllKvStore(appId);
296 g_kvManager.DeleteAllKvStore(appId);
297 }
298 }
299
300 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)301 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
302 {
303 // odd or even 2
304 bool fuzzedBoolean = ((size % 2) == 0);
305 auto fuzzedInt = static_cast<int>(size);
306 auto fuzzedLong = static_cast<int64_t>(size);
307 auto fuzzedDouble = static_cast<double>(size);
308 std::string fuzzedString(reinterpret_cast<const char *>(data), size);
309
310 std::string storeDir = "/data/service/el1/public/database/schemaqueryfuzztest";
311 mkdir(storeDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
312
313 OHOS::TestOpenSchemaStore001(fuzzedString);
314 OHOS::TestQuerySchemaStore001(fuzzedInt, fuzzedLong, fuzzedDouble, fuzzedBoolean, fuzzedString);
315 OHOS::TestQuerySchemaStore002(fuzzedInt, fuzzedLong, fuzzedDouble, fuzzedBoolean, fuzzedString);
316 OHOS::TestQuerySchemaStore003(fuzzedInt, fuzzedLong, fuzzedDouble, fuzzedString);
317 OHOS::TestQuerySchemaStore004(fuzzedInt, fuzzedLong, fuzzedDouble, fuzzedString);
318 OHOS::TestQuerySchemaStore005(fuzzedInt, fuzzedLong, fuzzedDouble, fuzzedString);
319 OHOS::TestQuerySchemaStore006(fuzzedInt, fuzzedLong, fuzzedDouble, fuzzedString);
320 OHOS::TestQuerySchemaStore007(fuzzedString);
321 OHOS::TestQuerySchemaStore008(fuzzedInt, fuzzedString);
322 OHOS::TestBatch001(fuzzedString);
323
324 (void)remove("/data/service/el1/public/database/schemaqueryfuzztest/key");
325 (void)remove("/data/service/el1/public/database/schemaqueryfuzztest/kvdb");
326 (void)remove("/data/service/el1/public/database/schemaqueryfuzztest");
327 return 0;
328 }