1 /*
2 * Copyright (c) 2023-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 "capabilityinfomanager_fuzzer.h"
17
18 #include "constants.h"
19 #include "capability_info.h"
20 #include "capability_utils.h"
21 #include "capability_info_manager.h"
22 #include "distributed_hardware_log.h"
23 #include "dh_context.h"
24 #include "dh_utils_tool.h"
25
26 namespace OHOS {
27 namespace DistributedHardware {
28 namespace {
29 constexpr uint16_t TEST_DEV_TYPE_PAD = 0x11;
30 }
31
CapabilityInfoManagerFuzzTest(const uint8_t * data,size_t size)32 void CapabilityInfoManagerFuzzTest(const uint8_t* data, size_t size)
33 {
34 if ((data == nullptr) || (size <= sizeof(DistributedKv::ChangeNotification))) {
35 return;
36 }
37
38 DistributedKv::Entry insert;
39 DistributedKv::Entry update;
40 DistributedKv::Entry del;
41 insert.key = std::string(reinterpret_cast<const char*>(data), size);
42 update.key = std::string(reinterpret_cast<const char*>(data), size);
43 del.key = std::string(reinterpret_cast<const char*>(data), size);
44 insert.value = std::string(reinterpret_cast<const char*>(data), size);
45 update.value = std::string(reinterpret_cast<const char*>(data), size);
46 del.value = std::string(reinterpret_cast<const char*>(data), size);
47 std::vector<DistributedKv::Entry> inserts;
48 std::vector<DistributedKv::Entry> updates;
49 std::vector<DistributedKv::Entry> deleteds;
50 inserts.push_back(insert);
51 updates.push_back(update);
52 deleteds.push_back(del);
53 std::string deviceId(reinterpret_cast<const char*>(data), size);
54
55 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds),
56 deviceId, true);
57 CapabilityInfoManager::GetInstance()->OnChange(changeIn);
58 }
59
RemoveCapabilityInfoInMemFuzzTest(const uint8_t * data,size_t size)60 void RemoveCapabilityInfoInMemFuzzTest(const uint8_t* data, size_t size)
61 {
62 if ((data == nullptr) || (size == 0)) {
63 return;
64 }
65 std::string deviceId(reinterpret_cast<const char*>(data), size);
66 CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoInMem(deviceId);
67 }
68
RemoveCapabilityInfoByKeyFuzzTest(const uint8_t * data,size_t size)69 void RemoveCapabilityInfoByKeyFuzzTest(const uint8_t* data, size_t size)
70 {
71 if ((data == nullptr) || (size == 0)) {
72 return;
73 }
74 std::string key(reinterpret_cast<const char*>(data), size);
75 CapabilityInfoManager::GetInstance()->Init();
76 CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(key);
77 CapabilityInfoManager::GetInstance()->UnInit();
78 }
79
RemoveCapabilityInfoInDBFuzzTest(const uint8_t * data,size_t size)80 void RemoveCapabilityInfoInDBFuzzTest(const uint8_t* data, size_t size)
81 {
82 if ((data == nullptr) || (size == 0)) {
83 return;
84 }
85 std::string deviceId(reinterpret_cast<const char*>(data), size);
86 CapabilityInfoManager::GetInstance()->Init();
87 CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoInDB(deviceId);
88 CapabilityInfoManager::GetInstance()->UnInit();
89 }
90
SyncDeviceInfoFromDBFuzzTest(const uint8_t * data,size_t size)91 void SyncDeviceInfoFromDBFuzzTest(const uint8_t* data, size_t size)
92 {
93 if ((data == nullptr) || (size == 0)) {
94 return;
95 }
96 std::string deviceId(reinterpret_cast<const char*>(data), size);
97 CapabilityInfoManager::GetInstance()->Init();
98 CapabilityInfoManager::GetInstance()->SyncDeviceInfoFromDB(deviceId);
99 CapabilityInfoManager::GetInstance()->SyncRemoteCapabilityInfos();
100 CapabilityInfoManager::GetInstance()->UnInit();
101 }
102
AddCapabilityInMemFuzzTest(const uint8_t * data,size_t size)103 void AddCapabilityInMemFuzzTest(const uint8_t* data, size_t size)
104 {
105 if ((data == nullptr) || (size == 0)) {
106 return;
107 }
108 std::vector<std::shared_ptr<CapabilityInfo>> resInfos;
109 CapabilityInfoManager::GetInstance()->AddCapabilityInMem(resInfos);
110
111 std::string dhId1(reinterpret_cast<const char*>(data), size);
112 std::string deviceId1(reinterpret_cast<const char*>(data), size);
113 std::string deviceName1(reinterpret_cast<const char*>(data), size);
114 std::string dhAttrs1(reinterpret_cast<const char*>(data), size);
115 std::string dhSubtype1(reinterpret_cast<const char*>(data), size);
116 std::shared_ptr<CapabilityInfo> capInfo1 = std::make_shared<CapabilityInfo>(
117 dhId1, deviceId1, deviceName1, TEST_DEV_TYPE_PAD, DHType::AUDIO, dhAttrs1, dhSubtype1);
118
119 std::string dhId2(reinterpret_cast<const char*>(data), size);
120 std::string deviceId2(reinterpret_cast<const char*>(data), size);
121 std::string deviceName2(reinterpret_cast<const char*>(data), size);
122 std::string dhAttrs2(reinterpret_cast<const char*>(data), size);
123 std::string dhSubtype2(reinterpret_cast<const char*>(data), size);
124 std::shared_ptr<CapabilityInfo> capInfo2 = std::make_shared<CapabilityInfo>(
125 dhId2, deviceId2, deviceName2, TEST_DEV_TYPE_PAD, DHType::CAMERA, dhAttrs2, dhSubtype2);
126 std::vector<std::shared_ptr<CapabilityInfo>> resInfos1 { capInfo1, capInfo2 };
127 CapabilityInfoManager::GetInstance()->AddCapabilityInMem(resInfos1);
128 }
129
GetDataByKeyFuzzTest(const uint8_t * data,size_t size)130 void GetDataByKeyFuzzTest(const uint8_t* data, size_t size)
131 {
132 if ((data == nullptr) || (size == 0)) {
133 return;
134 }
135 std::string key(reinterpret_cast<const char*>(data), size);
136 std::shared_ptr<CapabilityInfo> capInfoPtr;
137 CapabilityInfoManager::GetInstance()->GetDataByKey(key, capInfoPtr);
138
139 CapabilityInfoManager::GetInstance()->Init();
140 CapabilityInfoManager::GetInstance()->GetDataByKey(key, capInfoPtr);
141 CapabilityInfoManager::GetInstance()->UnInit();
142 }
143
CapabilityInfoManagerOnChangeInsertFuzzTest(const uint8_t * data,size_t size)144 void CapabilityInfoManagerOnChangeInsertFuzzTest(const uint8_t* data, size_t size)
145 {
146 if ((data == nullptr) || (size == 0)) {
147 return;
148 }
149 cJSON *insertJson = cJSON_CreateObject();
150 if (insertJson == nullptr) {
151 return;
152 }
153 std::string networkId(reinterpret_cast<const char*>(data), size);
154 std::string udId(reinterpret_cast<const char*>(data), size);
155 std::string uuId(reinterpret_cast<const char*>(data), size);
156 DHContext::GetInstance().AddOnlineDevice(udId, uuId, networkId);
157 std::string deviceId = Sha256(uuId);
158 cJSON_AddStringToObject(insertJson, DH_ID.c_str(), "111111");
159 cJSON_AddStringToObject(insertJson, DEV_ID.c_str(), deviceId.c_str());
160 cJSON_AddStringToObject(insertJson, DEV_NAME.c_str(), "dev_name");
161 char* cjson = cJSON_PrintUnformatted(insertJson);
162 if (cjson == nullptr) {
163 cJSON_Delete(insertJson);
164 return;
165 }
166 std::string jsonStr(cjson);
167 DistributedKv::Entry insert;
168 insert.key = std::string(reinterpret_cast<const char*>(data), size);
169 insert.value = jsonStr;
170
171 DistributedKv::Entry update;
172 DistributedKv::Entry del;
173 std::vector<DistributedKv::Entry> inserts;
174 std::vector<DistributedKv::Entry> updates;
175 std::vector<DistributedKv::Entry> deleteds;
176 inserts.push_back(insert);
177 updates.push_back(update);
178 deleteds.push_back(del);
179
180 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds),
181 deviceId, true);
182 CapabilityInfoManager::GetInstance()->OnChange(changeIn);
183 DHContext::GetInstance().RemoveOnlineDeviceIdEntryByNetworkId(networkId);
184 cJSON_free(cjson);
185 cJSON_Delete(insertJson);
186 }
187
CapabilityInfoManagerOnChangeUpdateFuzzTest(const uint8_t * data,size_t size)188 void CapabilityInfoManagerOnChangeUpdateFuzzTest(const uint8_t* data, size_t size)
189 {
190 if ((data == nullptr) || (size == 0)) {
191 return;
192 }
193 cJSON *updateJson = cJSON_CreateObject();
194 if (updateJson == nullptr) {
195 return;
196 }
197 std::string networkId(reinterpret_cast<const char*>(data), size);
198 std::string udId(reinterpret_cast<const char*>(data), size);
199 std::string uuId(reinterpret_cast<const char*>(data), size);
200 DHContext::GetInstance().AddOnlineDevice(udId, uuId, networkId);
201 std::string deviceId = Sha256(uuId);
202 cJSON_AddStringToObject(updateJson, DH_ID.c_str(), "222222");
203 cJSON_AddStringToObject(updateJson, DEV_ID.c_str(), deviceId.c_str());
204 cJSON_AddStringToObject(updateJson, DEV_NAME.c_str(), "dev_name");
205 char* cjson = cJSON_PrintUnformatted(updateJson);
206 if (cjson == nullptr) {
207 cJSON_Delete(updateJson);
208 return;
209 }
210 std::string jsonStr(cjson);
211 DistributedKv::Entry update;
212 update.key = std::string(reinterpret_cast<const char*>(data), size);
213 update.value = jsonStr;
214
215 DistributedKv::Entry insert;
216 DistributedKv::Entry del;
217 std::vector<DistributedKv::Entry> inserts;
218 std::vector<DistributedKv::Entry> updates;
219 std::vector<DistributedKv::Entry> deleteds;
220 inserts.push_back(insert);
221 updates.push_back(update);
222 deleteds.push_back(del);
223
224 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds),
225 deviceId, true);
226 CapabilityInfoManager::GetInstance()->OnChange(changeIn);
227 DHContext::GetInstance().RemoveOnlineDeviceIdEntryByNetworkId(networkId);
228 cJSON_free(cjson);
229 cJSON_Delete(updateJson);
230 }
231
CapabilityInfoManagerOnChangeDeleteFuzzTest(const uint8_t * data,size_t size)232 void CapabilityInfoManagerOnChangeDeleteFuzzTest(const uint8_t* data, size_t size)
233 {
234 if ((data == nullptr) || (size == 0)) {
235 return;
236 }
237 cJSON *deleteJson = cJSON_CreateObject();
238 if (deleteJson == nullptr) {
239 return;
240 }
241 std::string networkId(reinterpret_cast<const char*>(data), size);
242 std::string udId(reinterpret_cast<const char*>(data), size);
243 std::string uuId(reinterpret_cast<const char*>(data), size);
244 DHContext::GetInstance().AddOnlineDevice(udId, uuId, networkId);
245 std::string deviceId = Sha256(uuId);
246 cJSON_AddStringToObject(deleteJson, DH_ID.c_str(), "333333");
247 cJSON_AddStringToObject(deleteJson, DEV_ID.c_str(), deviceId.c_str());
248 cJSON_AddStringToObject(deleteJson, DEV_NAME.c_str(), "dev_name");
249 char* cjson = cJSON_PrintUnformatted(deleteJson);
250 if (cjson == nullptr) {
251 cJSON_Delete(deleteJson);
252 return;
253 }
254 std::string jsonStr(cjson);
255 DistributedKv::Entry del;
256 del.key = std::string(reinterpret_cast<const char*>(data), size);
257 del.value = jsonStr;
258
259 DistributedKv::Entry insert;
260 DistributedKv::Entry update;
261 std::vector<DistributedKv::Entry> inserts;
262 std::vector<DistributedKv::Entry> updates;
263 std::vector<DistributedKv::Entry> deleteds;
264 inserts.push_back(insert);
265 updates.push_back(update);
266 deleteds.push_back(del);
267
268 DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds),
269 deviceId, true);
270 CapabilityInfoManager::GetInstance()->OnChange(changeIn);
271 DHContext::GetInstance().RemoveOnlineDeviceIdEntryByNetworkId(networkId);
272 cJSON_free(cjson);
273 cJSON_Delete(deleteJson);
274 }
275 }
276 }
277
278 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)279 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
280 {
281 /* Run your code on data */
282 OHOS::DistributedHardware::CapabilityInfoManagerFuzzTest(data, size);
283 OHOS::DistributedHardware::RemoveCapabilityInfoInMemFuzzTest(data, size);
284 OHOS::DistributedHardware::RemoveCapabilityInfoByKeyFuzzTest(data, size);
285 OHOS::DistributedHardware::RemoveCapabilityInfoInDBFuzzTest(data, size);
286 OHOS::DistributedHardware::SyncDeviceInfoFromDBFuzzTest(data, size);
287 OHOS::DistributedHardware::AddCapabilityInMemFuzzTest(data, size);
288 OHOS::DistributedHardware::GetDataByKeyFuzzTest(data, size);
289 OHOS::DistributedHardware::CapabilityInfoManagerOnChangeInsertFuzzTest(data, size);
290 OHOS::DistributedHardware::CapabilityInfoManagerOnChangeUpdateFuzzTest(data, size);
291 OHOS::DistributedHardware::CapabilityInfoManagerOnChangeDeleteFuzzTest(data, size);
292 return 0;
293 }
294
295