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
25namespace OHOS {
26namespace Wifi {
27constexpr size_t DHCP_SLEEP_1 = 2;
28constexpr size_t U32_AT_SIZE_ZERO = 4;
29constexpr int CFG_DATA_MAX_BYTES = 20;
30
31void 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
39void 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
47void 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
56void 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
63void 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
71void 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
80void 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
90void 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
98void ParseIpAddrTest(const uint8_t* data, size_t size)
99{
100    const char *strIp = "TEXT";
101    (void)ParseIpAddr(strIp);
102}
103
104void ParseIpHtonlTest(const uint8_t* data, size_t size)
105{
106    const char *strIp = "TEXT";
107    (void)ParseIpHtonl(strIp);
108}
109
110void NetworkBitsTest(const uint8_t* data, size_t size)
111{
112    uint32_t netmask = static_cast<uint32_t>(data[0]);
113    NetworkBits(netmask);
114}
115
116void HostBitsTest(const uint8_t* data, size_t size)
117{
118    uint32_t netmask = static_cast<uint32_t>(data[0]);
119    HostBits(netmask);
120}
121
122void HostTotalTest(const uint8_t* data, size_t size)
123{
124    uint32_t netmask = static_cast<uint32_t>(data[0]);
125    HostTotal(netmask);
126}
127
128void 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
137void IsEmptyHWAddrTest(const uint8_t* data, size_t size)
138{
139    uint8_t ipAddr[DHCP_HWADDR_LENGTH];
140    IsEmptyHWAddr(&ipAddr[0]);
141}
142
143void 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
150void 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
157void 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
164void 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
171void 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
178void ParseLogMacTest(const uint8_t* data, size_t size)
179{
180    uint8_t macAddr[DHCP_HWADDR_LENGTH];
181    ParseLogMac(&macAddr[0]);
182}
183
184void 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 */
194extern "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