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 <cstddef>
17 #include <cstdint>
18 #include <unistd.h>
19 #include "dhcpserverimpl_fuzzer.h"
20 #include "securec.h"
21 #include "dhcp_server_service_impl.h"
22 #include "dhcp_server_death_recipient.h"
23 #include "iremote_object.h"
24
25 namespace OHOS {
26 namespace DHCP {
27 constexpr size_t U32_AT_SIZE_ZERO = 4;
28 constexpr size_t DHCP_SLEEP_1 = 2;
29 constexpr size_t MAX_STRING_SIZE = 1024;
30 sptr<DhcpServerServiceImpl> pDhcpServerServiceImpl = DhcpServerServiceImpl::GetInstance();
31
OnStartTest(const uint8_t * data,size_t size)32 void OnStartTest(const uint8_t* data, size_t size)
33 {
34 pDhcpServerServiceImpl->OnStart();
35 }
36
OnStopTest(const uint8_t * data,size_t size)37 void OnStopTest(const uint8_t* data, size_t size)
38 {
39 pDhcpServerServiceImpl->OnStop();
40 }
41
StartDhcpServerTest(const uint8_t * data,size_t size)42 void StartDhcpServerTest(const uint8_t* data, size_t size)
43 {
44 std::string ifname = "";
45 pDhcpServerServiceImpl->StartDhcpServer(ifname);
46 }
47
StopDhcpServerTest(const uint8_t * data,size_t size)48 void StopDhcpServerTest(const uint8_t* data, size_t size)
49 {
50 std::string ifname1 = "wlan0";
51 std::string ifname2 = "";
52 pDhcpServerServiceImpl->StopDhcpServer(ifname1);
53 pDhcpServerServiceImpl->StopDhcpServer(ifname2);
54 }
55
PutDhcpRangeTest(const uint8_t * data,size_t size)56 void PutDhcpRangeTest(const uint8_t* data, size_t size)
57 {
58 std::string tagName = "sta";
59 DhcpRange range;
60 range.iptype = 0;
61 pDhcpServerServiceImpl->PutDhcpRange(tagName, range);
62 pDhcpServerServiceImpl->PutDhcpRange("", range);
63 }
64
RemoveDhcpRangeTest(const uint8_t * data,size_t size)65 void RemoveDhcpRangeTest(const uint8_t* data, size_t size)
66 {
67 std::string tagName = "sta";
68 DhcpRange range;
69 range.iptype = 0;
70 pDhcpServerServiceImpl->RemoveDhcpRange(tagName, range);
71 pDhcpServerServiceImpl->RemoveDhcpRange("", range);
72 }
73
RemoveAllDhcpRangeTest(const uint8_t * data,size_t size)74 void RemoveAllDhcpRangeTest(const uint8_t* data, size_t size)
75 {
76 std::string tagName1 = "sta";
77 std::string tagName2 = "";
78 pDhcpServerServiceImpl->RemoveAllDhcpRange(tagName1);
79 pDhcpServerServiceImpl->RemoveAllDhcpRange(tagName2);
80 }
81
SetDhcpRangeTest(const uint8_t * data,size_t size)82 void SetDhcpRangeTest(const uint8_t* data, size_t size)
83 {
84 std::string ifname = "wlan0";
85 DhcpRange range;
86 range.iptype = 0;
87 pDhcpServerServiceImpl->SetDhcpRange(ifname, range);
88 }
89
SetDhcpNameTest(const uint8_t * data,size_t size)90 void SetDhcpNameTest(const uint8_t* data, size_t size)
91 {
92 std::string ifname = "wlan0";
93 std::string tagName = "sta";
94 pDhcpServerServiceImpl->SetDhcpName(ifname, tagName);
95 pDhcpServerServiceImpl->SetDhcpName("", tagName);
96 pDhcpServerServiceImpl->SetDhcpName(ifname, "");
97 pDhcpServerServiceImpl->SetDhcpName("", "");
98 }
99
GetDhcpClientInfosTest(const uint8_t * data,size_t size)100 void GetDhcpClientInfosTest(const uint8_t* data, size_t size)
101 {
102 if (data == nullptr || size == 0) {
103 return;
104 }
105 std::string ifname1 = "";
106 std::string ifname2 = "wlan0";
107 std::vector<std::string> leases;
108 size_t safeSize = (size > MAX_STRING_SIZE) ? MAX_STRING_SIZE : size;
109 leases.push_back(std::string(reinterpret_cast<const char*>(data), safeSize));
110 pDhcpServerServiceImpl->GetDhcpClientInfos(ifname1, leases);
111 pDhcpServerServiceImpl->GetDhcpClientInfos(ifname2, leases);
112 }
113
UpdateLeasesTimeTest(const uint8_t * data,size_t size)114 void UpdateLeasesTimeTest(const uint8_t* data, size_t size)
115 {
116 if (data == nullptr || size == 0) {
117 return;
118 }
119 size_t safeSize = (size > MAX_STRING_SIZE) ? MAX_STRING_SIZE : size;
120 std::string leaseTime = std::string(reinterpret_cast<const char*>(data), safeSize);
121 pDhcpServerServiceImpl->UpdateLeasesTime(leaseTime);
122 }
123
IsRemoteDiedTest(const uint8_t * data,size_t size)124 void IsRemoteDiedTest(const uint8_t* data, size_t size)
125 {
126 pDhcpServerServiceImpl->IsRemoteDied();
127 }
128
DeleteLeaseFileTest(const uint8_t * data,size_t size)129 void DeleteLeaseFileTest(const uint8_t* data, size_t size)
130 {
131 std::string ifname = "wlan0";
132 pDhcpServerServiceImpl->DeleteLeaseFile(ifname);
133 }
134
CheckAndUpdateConfTest(const uint8_t * data,size_t size)135 void CheckAndUpdateConfTest(const uint8_t* data, size_t size)
136 {
137 std::string ifname1 = "";
138 std::string ifname2 = "wlan0";
139 pDhcpServerServiceImpl->CheckAndUpdateConf(ifname1);
140 pDhcpServerServiceImpl->CheckAndUpdateConf(ifname2);
141 }
142
CheckIpAddrRangeTest(const uint8_t * data,size_t size)143 void CheckIpAddrRangeTest(const uint8_t* data, size_t size)
144 {
145 if (data == nullptr || size == 0) {
146 return;
147 }
148 DhcpRange range;
149 int call = 2;
150 size_t safeSize = (size > MAX_STRING_SIZE) ? MAX_STRING_SIZE : size;
151 range.strTagName = std::string(reinterpret_cast<const char*>(data), safeSize);
152 range.strStartip = std::string(reinterpret_cast<const char*>(data), safeSize);
153 range.strEndip = std::string(reinterpret_cast<const char*>(data), safeSize);
154 range.strSubnet = std::string(reinterpret_cast<const char*>(data), safeSize);
155 range.iptype = static_cast<int>(data[0]) % call;
156 range.leaseHours = static_cast<int>(data[0]);
157 pDhcpServerServiceImpl->CheckIpAddrRange(range);
158 }
159
AddSpecifiedInterfaceTest(const uint8_t * data,size_t size)160 void AddSpecifiedInterfaceTest(const uint8_t* data, size_t size)
161 {
162 std::string ifname = "wlan0";
163 pDhcpServerServiceImpl->AddSpecifiedInterface(ifname);
164 }
165
GetUsingIpRangeTest(const uint8_t * data,size_t size)166 void GetUsingIpRangeTest(const uint8_t* data, size_t size)
167 {
168 if (data == nullptr || size == 0) {
169 return;
170 }
171 std::string ifname1 = "";
172 std::string ifname2 = "ww";
173 std::string ifname3 = "wlan0";
174 size_t safeSize = (size > MAX_STRING_SIZE) ? MAX_STRING_SIZE : size;
175 std::string ipRange = std::string(reinterpret_cast<const char*>(data), safeSize);
176 pDhcpServerServiceImpl->GetUsingIpRange(ifname1, ipRange);
177 pDhcpServerServiceImpl->GetUsingIpRange(ifname2, ipRange);
178 pDhcpServerServiceImpl->GetUsingIpRange(ifname3, ipRange);
179 }
180
CreateDefaultConfigFileTest(const uint8_t * data,size_t size)181 void CreateDefaultConfigFileTest(const uint8_t* data, size_t size)
182 {
183 if (data == nullptr || size == 0) {
184 return;
185 }
186 size_t safeSize = (size > MAX_STRING_SIZE) ? MAX_STRING_SIZE : size;
187 std::string strFile = std::string(reinterpret_cast<const char*>(data), safeSize);
188 pDhcpServerServiceImpl->CreateDefaultConfigFile(strFile);
189 }
190
DelSpecifiedInterfaceTest(const uint8_t * data,size_t size)191 void DelSpecifiedInterfaceTest(const uint8_t* data, size_t size)
192 {
193 if (data == nullptr || size == 0) {
194 return;
195 }
196 size_t safeSize = (size > MAX_STRING_SIZE) ? MAX_STRING_SIZE : size;
197 std::string ifname = std::string(reinterpret_cast<const char*>(data), safeSize);
198 pDhcpServerServiceImpl->DelSpecifiedInterface(ifname);
199 }
200
RegisterDhcpServerCallBackTest(const uint8_t * data,size_t size)201 void RegisterDhcpServerCallBackTest(const uint8_t* data, size_t size)
202 {
203 if (data == nullptr || size == 0) {
204 return;
205 }
206 size_t safeSize = (size > MAX_STRING_SIZE) ? MAX_STRING_SIZE : size;
207 std::string ifname = std::string(reinterpret_cast<const char*>(data), safeSize);
208 sptr<IDhcpServerCallBack> serverCallback;
209 pDhcpServerServiceImpl->RegisterDhcpServerCallBack(ifname, serverCallback);
210 }
211
DeviceInfoCallBackTest(const uint8_t * data,size_t size)212 void DeviceInfoCallBackTest(const uint8_t* data, size_t size)
213 {
214 if (data == nullptr || size == 0) {
215 return;
216 }
217 size_t safeSize = (size > MAX_STRING_SIZE) ? MAX_STRING_SIZE : size;
218 std::string ifname = std::string(reinterpret_cast<const char*>(data), safeSize);
219 pDhcpServerServiceImpl->DeviceInfoCallBack(ifname);
220 }
221
ConvertLeasesToStationInfosTest(const uint8_t * data,size_t size)222 void ConvertLeasesToStationInfosTest(const uint8_t* data, size_t size)
223 {
224 if (data == nullptr || size == 0) {
225 return;
226 }
227 std::vector<std::string> leases;
228 std::vector<DhcpStationInfo> stationInfos = {};
229 size_t safeSize = (size > MAX_STRING_SIZE) ? MAX_STRING_SIZE : size;
230 leases.push_back(std::string(reinterpret_cast<const char*>(data), safeSize));
231 pDhcpServerServiceImpl->ConvertLeasesToStationInfos(leases, stationInfos);
232 }
233
DeviceConnectCallBackTest(const uint8_t * data,size_t size)234 void DeviceConnectCallBackTest(const uint8_t* data, size_t size)
235 {
236 if (data == nullptr || size == 0) {
237 return;
238 }
239 std::string safeIfname(reinterpret_cast<const char*>(data), size);
240 DeviceConnectCallBack(safeIfname.c_str());
241 }
242
SetDhcpNameExtTest(const uint8_t * data,size_t size)243 void SetDhcpNameExtTest(const uint8_t* data, size_t size)
244 {
245 std::string ifname = std::string(reinterpret_cast<const char*>(data), size);
246 std::string tagName = std::string(reinterpret_cast<const char*>(data), size);
247 std::map<std::string, std::list<DhcpRange>> m_mapTagDhcpRange = {};
248 std::list<DhcpRange> dhcpRangelist;
249 DhcpRange dhcpRange;
250 dhcpRange.strTagName = "";
251 dhcpRange.iptype = 0;
252 dhcpRangelist.push_back(dhcpRange);
253 m_mapTagDhcpRange[""] = dhcpRangelist;
254 pDhcpServerServiceImpl->m_mapTagDhcpRange = m_mapTagDhcpRange;
255 pDhcpServerServiceImpl->SetDhcpNameExt(ifname, tagName);
256 }
257
258 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)259 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
260 {
261 if ((data == nullptr) || (size <= OHOS::DHCP::U32_AT_SIZE_ZERO)) {
262 return 0;
263 }
264 sleep(DHCP_SLEEP_1);
265 OHOS::DHCP::OnStartTest(data, size);
266 OHOS::DHCP::OnStopTest(data, size);
267 OHOS::DHCP::StartDhcpServerTest(data, size);
268 OHOS::DHCP::StopDhcpServerTest(data, size);
269 OHOS::DHCP::PutDhcpRangeTest(data, size);
270 OHOS::DHCP::RemoveDhcpRangeTest(data, size);
271 OHOS::DHCP::RemoveAllDhcpRangeTest(data, size);
272 OHOS::DHCP::SetDhcpRangeTest(data, size);
273 OHOS::DHCP::SetDhcpNameTest(data, size);
274 OHOS::DHCP::GetDhcpClientInfosTest(data, size);
275 OHOS::DHCP::UpdateLeasesTimeTest(data, size);
276 OHOS::DHCP::IsRemoteDiedTest(data, size);
277 OHOS::DHCP::DeleteLeaseFileTest(data, size);
278 OHOS::DHCP::CheckAndUpdateConfTest(data, size);
279 OHOS::DHCP::CheckIpAddrRangeTest(data, size);
280 OHOS::DHCP::AddSpecifiedInterfaceTest(data, size);
281 OHOS::DHCP::GetUsingIpRangeTest(data, size);
282 OHOS::DHCP::CreateDefaultConfigFileTest(data, size);
283 OHOS::DHCP::DelSpecifiedInterfaceTest(data, size);
284 OHOS::DHCP::RegisterDhcpServerCallBackTest(data, size);
285 OHOS::DHCP::DeviceInfoCallBackTest(data, size);
286 OHOS::DHCP::ConvertLeasesToStationInfosTest(data, size);
287 OHOS::DHCP::DeviceConnectCallBackTest(data, size);
288 OHOS::DHCP::SetDhcpNameExtTest(data, size);
289 return 0;
290 }
291 } // namespace DHCP
292 } // namespace OHOS
293