1 /*
2 * Copyright (c) 2024 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 <string>
17 #include <cstdlib>
18 #include <random>
19 #include <utility>
20 #include <vector>
21 #include <fuzzer/FuzzedDataProvider.h>
22
23 #include "device_manager_service_listener.h"
24 #include "dm_anonymous.h"
25 #include "dm_auth_manager.h"
26 #include "dm_constants.h"
27 #include "hichain_connector.h"
28
29 #include "hichain_connector_fuzzer.h"
30
31 namespace OHOS {
32 namespace DistributedHardware {
33 constexpr const char* FIELD_OPERATION_CODE = "operationCode";
34 constexpr const char* FIELD_META_NODE_TYPE = "metaNodeType";
35 constexpr const char* FIELD_TYPE = "TType";
36
37 class HiChainConnectorCallbackTest : public IHiChainConnectorCallback {
38 public:
HiChainConnectorCallbackTest()39 HiChainConnectorCallbackTest() {}
~HiChainConnectorCallbackTest()40 virtual ~HiChainConnectorCallbackTest() {}
OnGroupCreated(int64_t requestId,const std::string & groupId)41 void OnGroupCreated(int64_t requestId, const std::string &groupId) override
42 {
43 (void)requestId;
44 (void)groupId;
45 }
OnMemberJoin(int64_t requestId,int32_t status)46 void OnMemberJoin(int64_t requestId, int32_t status) override
47 {
48 (void)requestId;
49 (void)status;
50 }
GetConnectAddr(std::string deviceId)51 std::string GetConnectAddr(std::string deviceId) override
52 {
53 (void)deviceId;
54 return "";
55 }
GetPinCode(int32_t & code)56 int32_t GetPinCode(int32_t &code) override
57 {
58 (void)code;
59 return DM_OK;
60 }
61 };
62
AddGroupInfo(std::vector<GroupInfo> & groupList)63 void AddGroupInfo(std::vector<GroupInfo> &groupList)
64 {
65 GroupInfo groupInfo1;
66 groupInfo1.groupId = "234";
67 groupInfo1.groupType = GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP;
68 groupList.push_back(groupInfo1);
69 GroupInfo groupInfo2;
70 groupInfo2.groupId = "1485";
71 groupInfo2.groupOwner = DM_PKG_NAME;
72 groupList.push_back(groupInfo2);
73 }
74
AddAclInfo(std::vector<std::pair<int32_t,std::string>> & delACLInfoVec,std::vector<int32_t> & userIdVec)75 void AddAclInfo(std::vector<std::pair<int32_t, std::string>> &delACLInfoVec, std::vector<int32_t> &userIdVec)
76 {
77 int32_t key = 12;
78 std::string value = "acl_info1";
79 delACLInfoVec.push_back(std::make_pair(key, value));
80 userIdVec.push_back(key);
81 int32_t key1 = 23;
82 value = "acl_info2";
83 delACLInfoVec.push_back(std::make_pair(key1, value));
84 userIdVec.push_back(key);
85 int32_t key2 = 25;
86 value = "acl_info3";
87 delACLInfoVec.push_back(std::make_pair(key2, value));
88 userIdVec.push_back(key);
89 }
90
HiChainConnectorFuzzTest(const uint8_t * data,size_t size)91 void HiChainConnectorFuzzTest(const uint8_t* data, size_t size)
92 {
93 if ((data == nullptr) || (size < (sizeof(int32_t) + sizeof(int32_t) + sizeof(int32_t)))) {
94 return;
95 }
96
97 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
98 hichainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
99
100 FuzzedDataProvider fdp(data, size);
101 std::string userId(reinterpret_cast<const char*>(data), size);
102 int32_t authType = fdp.ConsumeIntegral<int32_t>();
103 std::vector<GroupInfo> groupList;
104 std::string queryParams(reinterpret_cast<const char*>(data), size);
105 std::string deviceId(reinterpret_cast<const char*>(data), size);
106 std::string reqDeviceId(reinterpret_cast<const char*>(data), size);
107 std::string hostDevice(reinterpret_cast<const char*>(data), size);
108 std::vector<std::string> remoteGroupIdList;
109 int32_t groupType = fdp.ConsumeIntegral<int32_t>();
110 JsonObject jsonDeviceList;
111 std::string groupOwner(reinterpret_cast<const char*>(data), size);
112 std::string credentialInfo(reinterpret_cast<const char*>(data), size);
113 std::string jsonStr(reinterpret_cast<const char*>(data), size);
114 std::vector<std::string> udidList;
115 std::string pkgNameStr(reinterpret_cast<const char*>(data), size);
116 int32_t delUserid = fdp.ConsumeIntegral<int32_t>();
117
118 hichainConnector->IsRedundanceGroup(userId, authType, groupList);
119 hichainConnector->GetGroupInfo(queryParams, groupList);
120 hichainConnector->GetGroupInfo(delUserid, queryParams, groupList);
121 hichainConnector->GetGroupType(deviceId);
122 hichainConnector->AddMember(deviceId, queryParams);
123 hichainConnector->GetConnectPara(deviceId, reqDeviceId);
124 hichainConnector->IsDevicesInP2PGroup(hostDevice, reqDeviceId);
125 hichainConnector->SyncGroups(deviceId, remoteGroupIdList);
126 hichainConnector->DeleteTimeOutGroup(deviceId.data());
127 hichainConnector->getRegisterInfo(queryParams, jsonStr);
128 hichainConnector->GetGroupId(userId, groupType, queryParams);
129 hichainConnector->addMultiMembers(groupType, userId, jsonDeviceList);
130 hichainConnector->GetGroupIdExt(userId, groupType, queryParams, groupOwner);
131 hichainConnector->ParseRemoteCredentialExt(credentialInfo, queryParams, groupOwner);
132 hichainConnector->addMultiMembersExt(credentialInfo);
133 hichainConnector->GetTrustedDevices(deviceId);
134 hichainConnector->GetTrustedDevicesUdid(jsonStr.data(), udidList);
135 hichainConnector->DeleteAllGroup(delUserid);
136 hichainConnector->GetRelatedGroupsCommon(deviceId, pkgNameStr.data(), groupList);
137 hichainConnector->UnRegisterHiChainCallback();
138 }
139
HiChainConnectorSecondFuzzTest(const uint8_t * data,size_t size)140 void HiChainConnectorSecondFuzzTest(const uint8_t* data, size_t size)
141 {
142 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
143 hichainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
144
145 std::vector<GroupInfo> groupList;
146 JsonObject jsonDeviceList;
147 GroupInfo groupInfo;
148 std::vector<std::string> syncGroupList;
149 hichainConnector->GetSyncGroupList(groupList, syncGroupList);
150 hichainConnector->IsGroupInfoInvalid(groupInfo);
151 hichainConnector->UnRegisterHiChainGroupCallback();
152 hichainConnector->GetJsonStr(jsonDeviceList, "key");
153 }
154
HiChainConnectorThirdFuzzTest(const uint8_t * data,size_t size)155 void HiChainConnectorThirdFuzzTest(const uint8_t* data, size_t size)
156 {
157 if ((data == nullptr) || (size < (sizeof(int64_t) + sizeof(int32_t) + sizeof(int32_t) + sizeof(int32_t)))) {
158 return;
159 }
160 FuzzedDataProvider fdp(data, size);
161 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
162 hichainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
163 int64_t requestId = fdp.ConsumeIntegral<int64_t>();
164 std::string groupName = "groupName";
165 GroupInfo groupInfo;
166 std::string userId(reinterpret_cast<const char*>(data), size);
167 int32_t authType = fdp.ConsumeIntegral<int32_t>();
168 std::vector<GroupInfo> groupList;
169 std::string queryParams(reinterpret_cast<const char*>(data), size);
170 std::string pkgName(reinterpret_cast<const char*>(data), size);
171 std::string groupId(reinterpret_cast<const char*>(data), size);
172 std::string deviceId(reinterpret_cast<const char*>(data), size);
173 std::string reqDeviceId(reinterpret_cast<const char*>(data), size);
174 JsonObject jsonOutObj;
175 std::shared_ptr<IDmGroupResCallback> callback;
176 std::string jsonStr(reinterpret_cast<const char*>(data), size);
177 int32_t groupType = fdp.ConsumeIntegral<int32_t>();
178 int32_t switchUserId = fdp.ConsumeIntegral<int32_t>();
179 std::string reqParams(reinterpret_cast<const char*>(data), size);
180 std::string credentialInfo(reinterpret_cast<const char*>(data), size);
181 int operationCode = GroupOperationCode::MEMBER_JOIN;
182 hichainConnector->deviceGroupManager_ = nullptr;
183 hichainConnector->AddMember(deviceId, queryParams);
184 hichainConnector->getRegisterInfo(queryParams, jsonStr);
185 hichainConnector->addMultiMembers(groupType, userId, jsonOutObj);
186 hichainConnector->addMultiMembersExt(credentialInfo);
187 hichainConnector->deleteMultiMembers(groupType, userId, jsonOutObj);
188 hichainConnector->GetGroupInfoCommon(authType, queryParams, pkgName.c_str(), groupList);
189 hichainConnector->hiChainConnectorCallback_ = nullptr;
190 hichainConnector->GetConnectPara(deviceId, reqDeviceId);
191 hichainConnector->onRequest(requestId, operationCode, reqParams.c_str());
192 hichainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
193 if (hichainConnector->deviceGroupManager_ == nullptr) {
194 hichainConnector->deviceGroupManager_ = GetGmInstance();
195 }
196 hichainConnector->IsGroupCreated(groupName, groupInfo);
197 hichainConnector->GetGroupInfoExt(authType, queryParams, groupList);
198 hichainConnector->GetGroupInfoCommon(authType, queryParams, pkgName.c_str(), groupList);
199 hichainConnector->RegisterHiChainGroupCallback(callback);
200 hichainConnector->GetJsonInt(jsonOutObj, "key");
201 hichainConnector->deleteMultiMembers(groupType, userId, jsonOutObj);
202 hichainConnector->DeleteAllGroupByUdid(reqParams);
203 }
204
HiChainConnectorForthFuzzTest(const uint8_t * data,size_t size)205 void HiChainConnectorForthFuzzTest(const uint8_t* data, size_t size)
206 {
207 if ((data == nullptr) || (size < sizeof(int64_t) + sizeof(int32_t))) {
208 return;
209 }
210
211 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
212 hichainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
213 FuzzedDataProvider fdp(data, size);
214 int64_t requestId = fdp.ConsumeIntegral<int64_t>();
215 std::string groupName(reinterpret_cast<const char*>(data), size);
216 std::string groupId = "groupId_forth";
217 std::string deviceId = "deviceId_forth";
218 std::string returnData(reinterpret_cast<const char*>(data), size);
219 std::string userId = "userId_forth";
220 int32_t authType = fdp.ConsumeIntegral<int32_t>();
221 int operationCode = GroupOperationCode::MEMBER_JOIN;
222 int errCode = 102;
223 std::vector<std::string> syncGroupList;
224 std::vector<std::pair<int32_t, std::string>> delACLInfoVec;
225 std::vector<int32_t> userIdVec;
226 hichainConnector->DeleteGroupByACL(delACLInfoVec, userIdVec);
227 std::vector<GroupInfo> groupList;
228 AddGroupInfo(groupList);
229 AddAclInfo(delACLInfoVec, userIdVec);
230 hichainConnector->DeleteGroup(groupId);
231 hichainConnector->DeleteGroupExt(groupId);
232 hichainConnector->DeleteGroup(authType, groupId);
233 hichainConnector->DeleteGroup(requestId, userId, authType);
234 hichainConnector->DelMemberFromGroup(groupId, deviceId);
235 hichainConnector->DeleteRedundanceGroup(userId);
236 hichainConnector->DealRedundanceGroup(userId, authType);
237 hichainConnector->DeleteGroupByACL(delACLInfoVec, userIdVec);
238 hichainConnector->IsNeedDelete(groupName, authType, delACLInfoVec);
239 hichainConnector->onFinish(requestId, operationCode, returnData.c_str());
240 hichainConnector->onError(requestId, operationCode, errCode, returnData.c_str());
241 hichainConnector->onRequest(requestId, operationCode, returnData.c_str());
242 operationCode = GroupOperationCode::GROUP_CREATE;
243 hichainConnector->onFinish(requestId, operationCode, returnData.c_str());
244 hichainConnector->onError(requestId, operationCode, errCode, returnData.c_str());
245 operationCode == GroupOperationCode::MEMBER_DELETE;
246 hichainConnector->onFinish(requestId, operationCode, returnData.c_str());
247 hichainConnector->onError(requestId, operationCode, errCode, returnData.c_str());
248 operationCode == GroupOperationCode::GROUP_DISBAND;
249 hichainConnector->onFinish(requestId, operationCode, returnData.c_str());
250 hichainConnector->onError(requestId, operationCode, errCode, returnData.c_str());
251 hichainConnector->GenRequestId();
252 hichainConnector->GetRelatedGroups(deviceId, groupList);
253 hichainConnector->GetRelatedGroupsExt(deviceId, groupList);
254 hichainConnector->GetSyncGroupList(groupList, syncGroupList);
255 hichainConnector->GetGroupId(userId, authType, userId);
256 }
257
HiChainConnectorFifthFuzzTest(const uint8_t * data,size_t size)258 void HiChainConnectorFifthFuzzTest(const uint8_t* data, size_t size)
259 {
260 if ((data == nullptr) || (size < sizeof(int64_t) + sizeof(int32_t) + sizeof(int32_t))) {
261 return;
262 }
263
264 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
265 hichainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
266 FuzzedDataProvider fdp(data, size);
267 int64_t requestId = fdp.ConsumeIntegral<int64_t>();
268 std::string groupName = "groupName_fifth";
269 int32_t authType = fdp.ConsumeIntegral<int32_t>();
270 std::string params = "params";
271 int32_t osAccountUserId = fdp.ConsumeIntegral<int32_t>();
272 JsonObject jsonDeviceList;
273 std::vector<std::pair<int32_t, std::string>> delACLInfoVec;
274 std::vector<int32_t> userIdVec;
275 std::vector<std::pair<int32_t, std::string>> delAclInfoVec1;
276 std::string jsonStr = R"({"content": {"deviceid": "123"}}, authId: "123456"))";
277 std::vector<std::string> udidList;
278 int32_t key = 12;
279 std::string value = "acl_info1";
280 std::string credentialInfo = R"({"content": {"deviceid": "123"}}, authId: "123456"))";
281 std::string groupOwner(reinterpret_cast<const char*>(data), size);
282 delAclInfoVec1.push_back(std::make_pair(key, value));
283 JsonObject jsonObj;
284 jsonObj[AUTH_TYPE] = 1;
285 jsonObj[FIELD_USER_ID] = "123456";
286 jsonObj[FIELD_CREDENTIAL_TYPE] = 1;
287 jsonObj[FIELD_OPERATION_CODE] = 1;
288 jsonObj[FIELD_TYPE] = "filed_type";
289 jsonObj[FIELD_DEVICE_LIST] = "device_list";
290 hichainConnector->deviceGroupManager_ = nullptr;
291 hichainConnector->CreateGroup(requestId, groupName);
292 hichainConnector->CreateGroup(requestId, authType, groupName, jsonDeviceList);
293 if (hichainConnector->deviceGroupManager_ == nullptr) {
294 hichainConnector->deviceGroupManager_ = GetGmInstance();
295 }
296 hichainConnector->CreateGroup(requestId, groupName);
297 hichainConnector->CreateGroup(requestId, authType, groupName, jsonDeviceList);
298 hichainConnector->ParseRemoteCredential(authType, groupName, jsonDeviceList, params, osAccountUserId);
299 hichainConnector->ParseRemoteCredential(authType, "", jsonDeviceList, params, osAccountUserId);
300 hichainConnector->IsNeedDelete(groupName, authType, delACLInfoVec);
301 hichainConnector->DeleteGroupByACL(delAclInfoVec1, userIdVec);
302 hichainConnector->GetTrustedDevicesUdid(jsonStr.data(), udidList);
303 jsonStr = R"({"content": {"deviceid": "123"}}, authId: "123456")";
304 hichainConnector->GetTrustedDevicesUdid(jsonStr.data(), udidList);
305 jsonStr = R"({"content": {"deviceid": "123"}}, localId: "123456")";
306 hichainConnector->GetTrustedDevicesUdid(jsonStr.data(), udidList);
307 }
308
HiChainConnectorSixthFuzzTest(const uint8_t * data,size_t size)309 void HiChainConnectorSixthFuzzTest(const uint8_t* data, size_t size)
310 {
311 if ((data == nullptr) || (size < sizeof(int32_t))) {
312 return;
313 }
314
315 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
316 hichainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
317 std::string groupOwner(reinterpret_cast<const char*>(data), size);
318 JsonObject jsonObj;
319 std::string deviceId = "deviceId";
320 std::string key = "localDeviceId";
321 jsonObj["deviceId"] = 1;
322 hichainConnector->GetJsonInt(jsonObj, key);
323 hichainConnector->GetJsonInt(jsonObj, key);
324 jsonObj[key] = 1;
325 jsonObj["deviceName"] = "devieName1";
326 hichainConnector->GetJsonInt(jsonObj, "devieName");
327 hichainConnector->AddMember(deviceId, SafetyDump(jsonObj));
328 jsonObj[TAG_DEVICE_ID] = "deviceId_001";
329 jsonObj[PIN_CODE_KEY] = 1;
330 jsonObj[TAG_GROUP_ID] = "groupId";
331 jsonObj[TAG_REQUEST_ID] = 1;
332 jsonObj[TAG_GROUP_NAME] = "groupName";
333 hichainConnector->AddMember(deviceId, SafetyDump(jsonObj));
334
335 JsonObject jsonObjCre;
336 std::string params;
337 jsonObjCre[AUTH_TYPE] = 1;
338 jsonObjCre["userId"] = "user_001";
339 jsonObjCre[FIELD_CREDENTIAL_TYPE] = 1;
340 jsonObjCre[FIELD_OPERATION_CODE] = 1;
341 jsonObjCre[FIELD_META_NODE_TYPE] = "metaNode_002";
342 jsonObjCre[FIELD_DEVICE_LIST] = "deviceList";
343 std::string credentialInfo = SafetyDump(jsonObjCre);
344 hichainConnector->ParseRemoteCredentialExt(credentialInfo, params, groupOwner);
345 int32_t groupType = *(reinterpret_cast<const int32_t*>(data));
346 JsonObject jsonDeviceList(JsonCreateType::JSON_CREATE_TYPE_ARRAY);
347 int32_t osAccountUserId = 0;
348 std::string userId = "user_002";
349 jsonDeviceList[FIELD_DEVICE_LIST] = "deviceList";
350 hichainConnector->ParseRemoteCredential(groupType, userId, jsonDeviceList, params, osAccountUserId);
351 }
352
HiChainConnectorSevenhFuzzTest(const uint8_t * data,size_t size)353 void HiChainConnectorSevenhFuzzTest(const uint8_t* data, size_t size)
354 {
355 if ((data == nullptr) || (size < sizeof(int32_t) + sizeof(int32_t))) {
356 return;
357 }
358
359 std::shared_ptr<HiChainConnector> hichainConnector = std::make_shared<HiChainConnector>();
360 hichainConnector->RegisterHiChainCallback(std::make_shared<HiChainConnectorCallbackTest>());
361 std::vector<std::pair<int32_t, std::string>> delACLInfoVec;
362 delACLInfoVec.push_back(std::make_pair(1, "aclinfo_001"));
363 std::vector<int32_t> userIdVec;
364 hichainConnector->DeleteGroupByACL(delACLInfoVec, userIdVec);
365 std::string groupName = "";
366 FuzzedDataProvider fdp(data, size);
367 int32_t userId = fdp.ConsumeIntegral<int32_t>();
368 hichainConnector->IsNeedDelete(groupName, userId, delACLInfoVec);
369 userId = 1;
370 groupName = "aclinfo_001";
371 hichainConnector->IsNeedDelete(groupName, userId, delACLInfoVec);
372 std::vector<std::string> udidList;
373 JsonObject jsonObject;
374 std::string jsonStr = "dkocosdpa";
375 hichainConnector->GetTrustedDevicesUdid(jsonStr.data(), udidList);
376 jsonObject["authId"] = 1;
377 jsonStr = jsonObject.Dump();
378 hichainConnector->GetTrustedDevicesUdid(jsonStr.data(), udidList);
379
380 jsonObject["authId"] = "authInfoId";
381 jsonStr = jsonObject.Dump();
382 hichainConnector->GetTrustedDevicesUdid(jsonStr.data(), udidList);
383 hichainConnector->deviceGroupManager_ = nullptr;
384 int32_t groupType = fdp.ConsumeIntegral<int32_t>();
385 std::string usersId(reinterpret_cast<const char*>(data), size);
386 JsonObject jsonDeviceList;
387 hichainConnector->deleteMultiMembers(groupType, usersId, jsonDeviceList);
388 }
389 }
390 }
391
392 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)393 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
394 {
395 /* Run your code on data */
396 OHOS::DistributedHardware::HiChainConnectorFuzzTest(data, size);
397 OHOS::DistributedHardware::HiChainConnectorSecondFuzzTest(data, size);
398 OHOS::DistributedHardware::HiChainConnectorThirdFuzzTest(data, size);
399 OHOS::DistributedHardware::HiChainConnectorForthFuzzTest(data, size);
400 OHOS::DistributedHardware::HiChainConnectorFifthFuzzTest(data, size);
401 OHOS::DistributedHardware::HiChainConnectorSixthFuzzTest(data, size);
402 OHOS::DistributedHardware::HiChainConnectorSevenhFuzzTest(data, size);
403 return 0;
404 }