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 <vector>
18 #include "device_manager_service.h"
19 #include "device_manager_service_impl.h"
20 #include "authenticate_device_service_impl_fuzzer.h"
21 #include "accesstoken_kit.h"
22 #include "nativetoken_kit.h"
23 #include "token_setproc.h"
24 
25 namespace OHOS {
26 namespace DistributedHardware {
27 DmPublishInfo publishInfo = {
28     .publishId = 1234,
29     .mode = DmDiscoverMode::DM_DISCOVER_MODE_ACTIVE,
30     .freq = DmExchangeFreq::DM_MID,
31     .ranging = true,
32 };
33 
34 PeerTargetId peerTargetId = {
35     .deviceId = "deviceId",
36     .brMac = "brMac",
37     .bleMac = "bleMac",
38     .wifiIp = "wifiIp",
39     .wifiPort = 1,
40 };
41 
42 std::vector<DmDeviceInfo> deviceList;
43 std::map<std::string, std::string> bindParam;
44 std::string g_returnJsonStr;
45 int32_t g_eventId = 1;
46 int32_t g_action = 1;
47 int32_t g_authType = -1;
48 uint16_t g_subscribeId = 123;
49 
50 std::string g_reqJsonStr = R"(
51 {
52     "userId":"4269DC28B639681698809A67EDAD08E39F207900038F91EFF95DD042FE2874E4"
53 }
54 )";
55 
56 std::string g_credentialInfo = R"(
57 {
58     "processType" : 1,
59     "authType" : 1,
60     "userId" : "123",
61     "credentialData" :
62     [
63         {
64             "credentialType" : 1,
65             "credentialId" : "104",
66             "authCode" : "1234567812345678123456781234567812345678123456781234567812345678",
67             "serverPk" : "",
68             "pkInfoSignature" : "",
69             "pkInfo" : "",
70             "peerDeviceId" : ""
71         }
72     ]
73 }
74 )";
75 
76 std::string g_deleteInfo = R"(
77 {
78     "processType" : 1,
79     "authType" : 1,
80     "userId" : "123"
81 }
82 )";
83 
AddPermission()84 void AddPermission()
85 {
86     const int32_t permsNum = 3;
87     const int32_t indexZero = 0;
88     const int32_t indexOne = 1;
89     const int32_t indexTwo = 2;
90     uint64_t tokenId;
91     const char *perms[permsNum];
92     perms[indexZero] = "ohos.permission.ACCESS_SERVICE_DM";
93     perms[indexOne] = "ohos.permission.DISTRIBUTED_DATASYNC";
94     perms[indexTwo] = "ohos.permission.DISTRIBUTED_SOFTBUS_CENTER";
95     NativeTokenInfoParams infoInstance = {
96         .dcapsNum = 0,
97         .permsNum = permsNum,
98         .aclsNum = 0,
99         .dcaps = NULL,
100         .perms = perms,
101         .acls = NULL,
102         .processName = "device_manager",
103         .aplStr = "system_core",
104     };
105     tokenId = GetAccessTokenId(&infoInstance);
106     SetSelfTokenID(tokenId);
107     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
108 }
109 
AuthenticateDeviceServiceImplFuzzTest(const uint8_t * data,size_t size)110 void AuthenticateDeviceServiceImplFuzzTest(const uint8_t* data, size_t size)
111 {
112     if ((data == nullptr) || (size == 0)) {
113         return;
114     }
115 
116     std::string str(reinterpret_cast<const char*>(data), size);
117     AddPermission();
118     DmSubscribeInfo subscribeInfo = {
119         .subscribeId = 0,
120         .mode = DmDiscoverMode::DM_DISCOVER_MODE_ACTIVE,
121         .medium = DmExchangeMedium::DM_AUTO,
122         .freq = DmExchangeFreq::DM_MID,
123         .isSameAccount = true,
124         .isWakeRemote = true,
125     };
126     if (strcpy_s(subscribeInfo.capability, DM_MAX_DEVICE_CAPABILITY_LEN, "capability")) {
127         return;
128     }
129     std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
130     auto deviceManagerServiceImpl = std::make_shared<DeviceManagerServiceImpl>();
131 
132     deviceManagerServiceImpl->Initialize(listener);
133     deviceManagerServiceImpl->RegisterUiStateCallback(str);
134     deviceManagerServiceImpl->RegisterCredentialCallback(str);
135     deviceManagerServiceImpl->StartDeviceDiscovery(str, subscribeInfo, str);
136     deviceManagerServiceImpl->StopDeviceDiscovery(str, subscribeInfo.subscribeId);
137     deviceManagerServiceImpl->StartDeviceDiscovery(str, g_subscribeId, str);
138     deviceManagerServiceImpl->StopDeviceDiscovery(str, g_subscribeId);
139     deviceManagerServiceImpl->PublishDeviceDiscovery(str, publishInfo);
140     deviceManagerServiceImpl->UnPublishDeviceDiscovery(str, publishInfo.publishId);
141     deviceManagerServiceImpl->AuthenticateDevice(str, g_authType, str, str);
142     deviceManagerServiceImpl->UnAuthenticateDevice(str, str);
143     deviceManagerServiceImpl->BindDevice(str, g_authType, str, str);
144     deviceManagerServiceImpl->UnBindDevice(str, str);
145     deviceManagerServiceImpl->SetUserOperation(str, g_action, str);
146     deviceManagerServiceImpl->RequestCredential(g_reqJsonStr, g_returnJsonStr);
147     deviceManagerServiceImpl->ImportCredential(str, g_credentialInfo);
148     deviceManagerServiceImpl->DeleteCredential(str, g_deleteInfo);
149     deviceManagerServiceImpl->MineRequestCredential(str, g_returnJsonStr);
150     deviceManagerServiceImpl->CheckCredential(str, g_reqJsonStr, g_returnJsonStr);
151     deviceManagerServiceImpl->ImportCredential(str, g_reqJsonStr, g_returnJsonStr);
152     deviceManagerServiceImpl->DeleteCredential(str, g_reqJsonStr, g_returnJsonStr);
153     deviceManagerServiceImpl->NotifyEvent(str, g_eventId, str);
154     deviceManagerServiceImpl->GetGroupType(deviceList);
155     deviceManagerServiceImpl->GetUdidHashByNetWorkId(str.c_str(), str);
156     deviceManagerServiceImpl->ImportAuthCode(str, str);
157     deviceManagerServiceImpl->ExportAuthCode(str);
158     deviceManagerServiceImpl->BindTarget(str, peerTargetId, bindParam);
159     deviceManagerServiceImpl->UnRegisterCredentialCallback(str);
160     deviceManagerServiceImpl->UnRegisterUiStateCallback(str);
161     deviceManagerServiceImpl->Release();
162 }
163 }
164 }
165 
166 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)167 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
168 {
169     /* Run your code on data */
170     OHOS::DistributedHardware::AuthenticateDeviceServiceImplFuzzTest(data, size);
171 
172     return 0;
173 }