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 "dhcpfunction_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #include <unistd.h>
21 #include "securec.h"
22 #include "dhcp_function.h"
23
24 namespace OHOS {
25 namespace DHCP {
26 constexpr size_t DHCP_SLEEP_1 = 2;
27 constexpr int TWO = 2;
28
29 std::shared_ptr<DhcpFunction> pDhcpFunction = std::make_shared<DhcpFunction>();
30
Ip4StrConToIntTest(const uint8_t * data,size_t size)31 void Ip4StrConToIntTest(const uint8_t* data, size_t size)
32 {
33 uint32_t index = 0;
34 uint32_t uIp = static_cast<uint32_t>(data[index++]);
35 std::string strIp = std::string(reinterpret_cast<const char*>(data), size);
36 bool bHost = (static_cast<int>(data[0]) % TWO) ? true : false;
37 pDhcpFunction->Ip4StrConToInt(strIp, uIp, bHost);
38 }
39
Ip4IntConvertToStrTest(const uint8_t * data,size_t size)40 void Ip4IntConvertToStrTest(const uint8_t* data, size_t size)
41 {
42 uint32_t index = 0;
43 uint32_t uIp = static_cast<uint32_t>(data[index++]);
44 bool bHost = (static_cast<int>(data[0]) % TWO) ? true : false;
45 pDhcpFunction->Ip4IntConvertToStr(uIp, bHost);
46 }
47
Ip6StrConToCharTest(const uint8_t * data,size_t size)48 void Ip6StrConToCharTest(const uint8_t* data, size_t size)
49 {
50 std::string strIp = std::string(reinterpret_cast<const char*>(data), size);
51 uint8_t chIp[sizeof(struct in6_addr)] = {0};
52 pDhcpFunction->Ip6StrConToChar(strIp, chIp, sizeof(struct in6_addr));
53 }
54
CheckIpStrTest(const uint8_t * data,size_t size)55 void CheckIpStrTest(const uint8_t* data, size_t size)
56 {
57 std::string strIp = std::string(reinterpret_cast<const char*>(data), size);
58 pDhcpFunction->CheckIpStr(strIp);
59 }
60
IsExistFileTest(const uint8_t * data,size_t size)61 void IsExistFileTest(const uint8_t* data, size_t size)
62 {
63 std::string filename = std::string(reinterpret_cast<const char*>(data), size);
64 pDhcpFunction->IsExistFile(filename);
65 }
66
CreateFileTest(const uint8_t * data,size_t size)67 void CreateFileTest(const uint8_t* data, size_t size)
68 {
69 std::string filename = std::string(reinterpret_cast<const char*>(data), size);
70 std::string filedata = std::string(reinterpret_cast<const char*>(data), size);
71 pDhcpFunction->CreateFile(filename, filedata);
72 }
73
RemoveFileTest(const uint8_t * data,size_t size)74 void RemoveFileTest(const uint8_t* data, size_t size)
75 {
76 std::string filename = std::string(reinterpret_cast<const char*>(data), size);
77 pDhcpFunction->RemoveFile(filename);
78 }
79
AddFileLineDataTest(const uint8_t * data,size_t size)80 void AddFileLineDataTest(const uint8_t* data, size_t size)
81 {
82 std::string filename = std::string(reinterpret_cast<const char*>(data), size);
83 std::string prevdata = std::string(reinterpret_cast<const char*>(data), size);
84 std::string linedata = std::string(reinterpret_cast<const char*>(data), size);
85 pDhcpFunction->AddFileLineData(filename, prevdata, linedata);
86 }
87
DelFileLineDataTest(const uint8_t * data,size_t size)88 void DelFileLineDataTest(const uint8_t* data, size_t size)
89 {
90 std::string filename = std::string(reinterpret_cast<const char*>(data), size);
91 std::string linedata = std::string(reinterpret_cast<const char*>(data), size);
92 pDhcpFunction->DelFileLineData(filename, linedata);
93 }
94
ModifyFileLineDataTest(const uint8_t * data,size_t size)95 void ModifyFileLineDataTest(const uint8_t* data, size_t size)
96 {
97 std::string filename = std::string(reinterpret_cast<const char*>(data), size);
98 std::string srcdata = std::string(reinterpret_cast<const char*>(data), size);
99 std::string dstdata = std::string(reinterpret_cast<const char*>(data), size);
100 pDhcpFunction->ModifyFileLineData(filename, srcdata, dstdata);
101 }
102
FormatStringTest(const uint8_t * data,size_t size)103 void FormatStringTest(const uint8_t* data, size_t size)
104 {
105 struct DhcpPacketResult result;
106 memset_s(&result, sizeof(result), 0, sizeof(result));
107 strncpy_s(result.strYiaddr, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
108 strncpy_s(result.strOptServerId, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
109 strncpy_s(result.strOptSubnet, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
110 strncpy_s(result.strOptDns1, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
111 strncpy_s(result.strOptDns2, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
112 strncpy_s(result.strOptRouter1, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
113 strncpy_s(result.strOptRouter2, INET_ADDRSTRLEN, "*", INET_ADDRSTRLEN - 1);
114 strncpy_s(result.strOptVendor, DHCP_FILE_MAX_BYTES, "*", DHCP_FILE_MAX_BYTES - 1);
115 pDhcpFunction->FormatString(result);
116 }
117
InitPidfileTest(const uint8_t * data,size_t size)118 void InitPidfileTest(const uint8_t* data, size_t size)
119 {
120 std::string piddir = std::string(reinterpret_cast<const char*>(data), size);
121 std::string pidfile = std::string(reinterpret_cast<const char*>(data), size);
122 pDhcpFunction->InitPidfile(piddir, pidfile);
123 }
124
GetPIDTest(const uint8_t * data,size_t size)125 void GetPIDTest(const uint8_t* data, size_t size)
126 {
127 std::string pidfile = std::string(reinterpret_cast<const char*>(data), size);
128 pDhcpFunction->GetPID(pidfile);
129 }
130
CheckProRunningTest(const uint8_t * data,size_t size)131 void CheckProRunningTest(const uint8_t* data, size_t size)
132 {
133 pid_t index = 0;
134 pid_t proPid = static_cast<pid_t>(data[index++]);
135 std::string proName = std::string(reinterpret_cast<const char*>(data), size);
136 pDhcpFunction->CheckProRunning(proPid, proName);
137 }
138
CreateDirsTest(const uint8_t * data,size_t size)139 void CreateDirsTest(const uint8_t* data, size_t size)
140 {
141 int mode = DIR_DEFAULT_MODE;
142 std::string dirs = std::string(reinterpret_cast<const char*>(data), size);
143 pDhcpFunction->CreateDirs(dirs, mode);
144 }
145
SplitStringTest(const uint8_t * data,size_t size)146 void SplitStringTest(const uint8_t* data, size_t size)
147 {
148 int index = 0;
149 int count = static_cast<int>(data[index++]);
150 std::vector<std::string> splits {};
151 std::string src = std::string(reinterpret_cast<const char*>(data), size);
152 std::string delim = std::string(reinterpret_cast<const char*>(data), size);
153 pDhcpFunction->SplitString(src, delim, count, splits);
154 }
155
WaitProcessExitTest(const uint8_t * data,size_t size)156 void WaitProcessExitTest(const uint8_t* data, size_t size)
157 {
158 pid_t index = 0;
159 pid_t serverPid = static_cast<pid_t>(data[index++]);
160 pDhcpFunction->WaitProcessExit(serverPid);
161 }
162
163 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)164 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
165 {
166 if (data == nullptr) {
167 return 0;
168 }
169 sleep(DHCP_SLEEP_1);
170 OHOS::DHCP::Ip4StrConToIntTest(data, size);
171 OHOS::DHCP::Ip4IntConvertToStrTest(data, size);
172 OHOS::DHCP::Ip6StrConToCharTest(data, size);
173 OHOS::DHCP::CheckIpStrTest(data, size);
174 OHOS::DHCP::IsExistFileTest(data, size);
175 OHOS::DHCP::CreateFileTest(data, size);
176 OHOS::DHCP::RemoveFileTest(data, size);
177 OHOS::DHCP::AddFileLineDataTest(data, size);
178 OHOS::DHCP::DelFileLineDataTest(data, size);
179 OHOS::DHCP::ModifyFileLineDataTest(data, size);
180 OHOS::DHCP::FormatStringTest(data, size);
181 OHOS::DHCP::InitPidfileTest(data, size);
182 OHOS::DHCP::GetPIDTest(data, size);
183 OHOS::DHCP::CheckProRunningTest(data, size);
184 OHOS::DHCP::CreateDirsTest(data, size);
185 OHOS::DHCP::SplitStringTest(data, size);
186 OHOS::DHCP::WaitProcessExitTest(data, size);
187 return 0;
188 }
189 } // namespace DHCP
190 } // namespace OHOS
191