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