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 "addressutils_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #include <unistd.h>
21 #include "securec.h"
22 #include "address_utils.h"
23 #include "dhcp_s_define.h"
24
25 namespace OHOS {
26 namespace Wifi {
27 constexpr size_t DHCP_SLEEP_1 = 2;
28
NetworkAddressTest(const uint8_t * data,size_t size)29 void NetworkAddressTest(const uint8_t* data, size_t size)
30 {
31 uint32_t index = 0;
32 uint32_t ip = static_cast<uint32_t>(data[index++]);
33 uint32_t netmask = static_cast<uint32_t>(data[index++]);
34 NetworkAddress(ip, netmask);
35 }
36
FirstIpAddressTest(const uint8_t * data,size_t size)37 void FirstIpAddressTest(const uint8_t* data, size_t size)
38 {
39 uint32_t index = 0;
40 uint32_t ip = static_cast<uint32_t>(data[index++]);
41 uint32_t netmask = static_cast<uint32_t>(data[index++]);
42 FirstIpAddress(ip, netmask);
43 }
44
NextIpAddressTest(const uint8_t * data,size_t size)45 void NextIpAddressTest(const uint8_t* data, size_t size)
46 {
47 uint32_t index = 0;
48 uint32_t currIp = static_cast<uint32_t>(data[index++]);
49 uint32_t netmask = static_cast<uint32_t>(data[index++]);
50 uint32_t offset = static_cast<uint32_t>(data[index++]);
51 NextIpAddress(currIp, netmask, offset);
52 }
53
FirstNetIpAddressTest(const uint8_t * data,size_t size)54 void FirstNetIpAddressTest(const uint8_t* data, size_t size)
55 {
56 uint32_t index = 0;
57 uint32_t networkAddr = static_cast<uint32_t>(data[index++]);
58 FirstNetIpAddress(networkAddr);
59 }
60
LastIpAddressTest(const uint8_t * data,size_t size)61 void LastIpAddressTest(const uint8_t* data, size_t size)
62 {
63 uint32_t index = 0;
64 uint32_t ip = static_cast<uint32_t>(data[index++]);
65 uint32_t netmask = static_cast<uint32_t>(data[index++]);
66 LastIpAddress(ip, netmask);
67 }
68
IpInNetworkTest(const uint8_t * data,size_t size)69 void IpInNetworkTest(const uint8_t* data, size_t size)
70 {
71 uint32_t index = 0;
72 uint32_t ip = static_cast<uint32_t>(data[index++]);
73 uint32_t network = static_cast<uint32_t>(data[index++]);
74 uint32_t netmask = static_cast<uint32_t>(data[index++]);
75 IpInNetwork(ip, network, netmask);
76 }
77
IpInRangeTest(const uint8_t * data,size_t size)78 void IpInRangeTest(const uint8_t* data, size_t size)
79 {
80 uint32_t index = 0;
81 uint32_t ip = static_cast<uint32_t>(data[index++]);
82 uint32_t beginIp = static_cast<uint32_t>(data[index++]);
83 uint32_t endIp = static_cast<uint32_t>(data[index++]);
84 uint32_t netmask = static_cast<uint32_t>(data[index++]);
85 IpInRange(ip, beginIp, endIp, netmask);
86 }
87
BroadCastAddressTest(const uint8_t * data,size_t size)88 void BroadCastAddressTest(const uint8_t* data, size_t size)
89 {
90 uint32_t index = 0;
91 uint32_t ip = static_cast<uint32_t>(data[index++]);
92 uint32_t netmask = static_cast<uint32_t>(data[index++]);
93 BroadCastAddress(ip, netmask);
94 }
95
ParseIpAddrTest(const uint8_t * data,size_t size)96 void ParseIpAddrTest(const uint8_t* data, size_t size)
97 {
98 char strIp;
99 if (size > 0) {
100 strIp = static_cast<char>(data[0]);
101 }
102 (void)ParseIpAddr(&strIp);
103 }
104
ParseIpHtonlTest(const uint8_t * data,size_t size)105 void ParseIpHtonlTest(const uint8_t* data, size_t size)
106 {
107 char strIp;
108 if (size > 0) {
109 strIp = static_cast<char>(data[0]);
110 }
111 (void)ParseIpHtonl(&strIp);
112 }
113
NetworkBitsTest(const uint8_t * data,size_t size)114 void NetworkBitsTest(const uint8_t* data, size_t size)
115 {
116 uint32_t index = 0;
117 uint32_t netmask = static_cast<uint32_t>(data[index++]);
118 NetworkBits(netmask);
119 }
120
HostBitsTest(const uint8_t * data,size_t size)121 void HostBitsTest(const uint8_t* data, size_t size)
122 {
123 uint32_t index = 0;
124 uint32_t netmask = static_cast<uint32_t>(data[index++]);
125 HostBits(netmask);
126 }
127
HostTotalTest(const uint8_t * data,size_t size)128 void HostTotalTest(const uint8_t* data, size_t size)
129 {
130 uint32_t index = 0;
131 uint32_t netmask = static_cast<uint32_t>(data[index++]);
132 HostTotal(netmask);
133 }
134
ParseIpTest(const uint8_t * data,size_t size)135 void ParseIpTest(const uint8_t* data, size_t size)
136 {
137 uint8_t index = 0;
138 uint8_t ipAddr = static_cast<uint8_t>(data[index++]);
139 ParseIp(&ipAddr);
140 }
141
ParseStrIpTest(const uint8_t * data,size_t size)142 void ParseStrIpTest(const uint8_t* data, size_t size)
143 {
144 uint32_t index = 0;
145 uint32_t ipAddr = static_cast<uint32_t>(data[index++]);
146 ParseStrIp(ipAddr);
147 }
148
IsEmptyHWAddrTest(const uint8_t * data,size_t size)149 void IsEmptyHWAddrTest(const uint8_t* data, size_t size)
150 {
151 uint8_t ipAddr[DHCP_HWADDR_LENGTH];
152 IsEmptyHWAddr(&ipAddr[0]);
153 }
154
ParseStrMacTest(const uint8_t * data,size_t size)155 void ParseStrMacTest(const uint8_t* data, size_t size)
156 {
157 uint8_t* macAddr = nullptr;
158 size_t addrSize = MAC_ADDR_LENGTH;
159 ParseStrMac(macAddr, addrSize);
160 }
161
ParseMacAddressTest(const uint8_t * data,size_t size)162 void ParseMacAddressTest(const uint8_t* data, size_t size)
163 {
164 char strMac;
165 uint8_t macAddr[DHCP_HWADDR_LENGTH];
166 if (size > 0) {
167 strMac = static_cast<char>(data[0]);
168 }
169 (void)ParseMacAddress(&strMac, &macAddr[0]);
170 }
171
ParseHostNameTest(const uint8_t * data,size_t size)172 void ParseHostNameTest(const uint8_t* data, size_t size)
173 {
174 char strHostName;
175 char hostName[DHCP_BOOT_FILE_LENGTH];
176 if (size > 0) {
177 strHostName = static_cast<char>(data[0]);
178 }
179 (void)ParseHostName(&strHostName, &hostName[0]);
180 }
181
HostToNetworkTest(const uint8_t * data,size_t size)182 void HostToNetworkTest(const uint8_t* data, size_t size)
183 {
184 uint32_t index = 0;
185 uint32_t host = static_cast<uint32_t>(data[index++]);
186 HostToNetwork(host);
187 }
188
NetworkToHostTest(const uint8_t * data,size_t size)189 void NetworkToHostTest(const uint8_t* data, size_t size)
190 {
191 uint32_t index = 0;
192 uint32_t network = static_cast<uint32_t>(data[index++]);
193 NetworkToHost(network);
194 }
195
ParseLogMacTest(const uint8_t * data,size_t size)196 void ParseLogMacTest(const uint8_t* data, size_t size)
197 {
198 uint8_t macAddr[DHCP_HWADDR_LENGTH];
199 ParseLogMac(&macAddr[0]);
200 }
201
AddrEquelsTest(const uint8_t * data,size_t size)202 void AddrEquelsTest(const uint8_t* data, size_t size)
203 {
204 int index = 0;
205 int addrLength = static_cast<int>(data[index++]);
206 uint8_t firstAddr[DHCP_HWADDR_LENGTH];
207 uint8_t secondAddr[DHCP_HWADDR_LENGTH];
208 AddrEquels(&firstAddr[0], &secondAddr[0], addrLength);
209 }
210
211 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)212 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
213 {
214 if (data == nullptr) {
215 return 0;
216 }
217 sleep(DHCP_SLEEP_1);
218 OHOS::Wifi::NetworkAddressTest(data, size);
219 OHOS::Wifi::FirstIpAddressTest(data, size);
220 OHOS::Wifi::NextIpAddressTest(data, size);
221 OHOS::Wifi::FirstNetIpAddressTest(data, size);
222 OHOS::Wifi::LastIpAddressTest(data, size);
223 OHOS::Wifi::IpInNetworkTest(data, size);
224 OHOS::Wifi::IpInRangeTest(data, size);
225 OHOS::Wifi::BroadCastAddressTest(data, size);
226 OHOS::Wifi::ParseIpAddrTest(data, size);
227 OHOS::Wifi::ParseIpHtonlTest(data, size);
228 OHOS::Wifi::NetworkBitsTest(data, size);
229 OHOS::Wifi::HostBitsTest(data, size);
230 OHOS::Wifi::HostTotalTest(data, size);
231 OHOS::Wifi::ParseIpTest(data, size);
232 OHOS::Wifi::ParseStrIpTest(data, size);
233 OHOS::Wifi::IsEmptyHWAddrTest(data, size);
234 OHOS::Wifi::ParseStrMacTest(data, size);
235 OHOS::Wifi::ParseMacAddressTest(data, size);
236 OHOS::Wifi::ParseHostNameTest(data, size);
237 OHOS::Wifi::HostToNetworkTest(data, size);
238 OHOS::Wifi::NetworkToHostTest(data, size);
239 OHOS::Wifi::ParseLogMacTest(data, size);
240 OHOS::Wifi::AddrEquelsTest(data, size);
241 return 0;
242 }
243 } // namespace Wifi
244 } // namespace OHOS
245