1 /*
2 * Copyright (c) 2023 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 "soft_bus_fuzzer.h"
17
18 #include "parcel.h"
19
20 #include "socket_factory.h"
21 #include "soft_bus_base_socket.h"
22 #include "soft_bus_client_socket.h"
23 #include "soft_bus_manager.h"
24 #include "soft_bus_message.h"
25 #include "soft_bus_server_socket.h"
26 #include "soft_bus_socket_listener.h"
27 #include "iam_fuzz_test.h"
28 #include "iam_logger.h"
29 #include "iam_ptr.h"
30
31 #define LOG_TAG "USER_AUTH_SA"
32
33 using namespace std;
34
35 namespace OHOS {
36 namespace UserIam {
37 namespace UserAuth {
38 namespace {
39
FuzzSoftBusManagerSecond(Parcel & parcel)40 void FuzzSoftBusManagerSecond(Parcel &parcel)
41 {
42 IAM_LOGI("start");
43 SoftBusManager::GetInstance().GetServerSocket();
44 SoftBusManager::GetInstance().Stop();
45 SoftBusManager::GetInstance().RegistDeviceManagerListener();
46 SoftBusManager::GetInstance().UnRegistDeviceManagerListener();
47 SoftBusManager::GetInstance().RegistSoftBusListener();
48 SoftBusManager::GetInstance().UnRegistSoftBusListener();
49 SoftBusManager::GetInstance().DeviceInit();
50 SoftBusManager::GetInstance().DeviceUnInit();
51 SoftBusManager::GetInstance().ServiceSocketInit();
52 SoftBusManager::GetInstance().ServiceSocketUnInit();
53 SoftBusManager::GetInstance().ClearServerSocket();
54 IAM_LOGI("end");
55 }
56
FuzzSoftBusBaseSocketSecond(Parcel & parcel)57 void FuzzSoftBusBaseSocketSecond(Parcel &parcel)
58 {
59 int32_t socketId = parcel.ReadInt32();
60 auto clientSocket = Common::MakeShared<ClientSocket>(socketId);
61 PeerSocketInfo info;
62 clientSocket->OnBind(socketId, info);
63 clientSocket->GetNetworkId();
64 std::string networkId = parcel.ReadString();
65 char message[] = "testMesage";
66 uint32_t messageLen = sizeof(message) / sizeof(char);
67 clientSocket->ParseMessage(networkId, message, messageLen);
68 ShutdownReason reason = SHUTDOWN_REASON_LOCAL;
69 clientSocket->OnShutdown(socketId, reason);
70 clientSocket->OnBytes(socketId, message, messageLen);
71 clientSocket->SetNetworkId(networkId);
72 clientSocket->SendKeepAliveMessage();
73 std::vector<uint8_t> attr;
74 Common::FillFuzzUint8Vector(parcel, attr);
75 auto attributes = Common::MakeShared<Attributes>(attr);
76 std::shared_ptr<SoftBusMessage> softBusMessage1 =
77 Common::MakeShared<SoftBusMessage>(0, networkId, networkId, networkId, attributes);
78 clientSocket->ProcDataReceive(socketId, softBusMessage1);
79 softBusMessage1->isAck_ = true;
80 clientSocket->ProcDataReceive(socketId, softBusMessage1);
81 softBusMessage1 =
82 Common::MakeShared<SoftBusMessage>(0, networkId, networkId, networkId, nullptr);
83 clientSocket->ProcDataReceive(socketId, softBusMessage1);
84 }
85
FuzzSoftBusBaseSocketFirst(Parcel & parcel)86 void FuzzSoftBusBaseSocketFirst(Parcel &parcel)
87 {
88 IAM_LOGI("start");
89 std::string connectionName = parcel.ReadString();
90 int32_t socketId = parcel.ReadInt32();
91 auto clientSocket = Common::MakeShared<ClientSocket>(socketId);
92 clientSocket->GetSocketId();
93 std::string srcEndPoint = parcel.ReadString();
94 std::string destEndPoint = parcel.ReadString();
95 std::vector<uint8_t> attr;
96 Common::FillFuzzUint8Vector(parcel, attr);
97 auto attributes = Common::MakeShared<Attributes>(attr);
98 std::shared_ptr<Attributes> request = Common::MakeShared<Attributes>(attributes->Serialize());
99 MsgCallback callback = [](const std::shared_ptr<Attributes> &) { IAM_LOGI("message sent"); };
100 clientSocket->SendMessage(connectionName, srcEndPoint, destEndPoint, attributes, callback);
101 uint32_t messageSeq = parcel.ReadUint32();
102 clientSocket->SendResponse(socketId, connectionName, srcEndPoint, destEndPoint, attributes, messageSeq);
103 std::string networkId = parcel.ReadString();
104 clientSocket->GetConnectionName();
105 clientSocket->GetMsgCallback(messageSeq);
106 uint32_t timerId = parcel.ReadUint32();
107 clientSocket->InsertMsgCallback(messageSeq, connectionName, callback, timerId);
108 clientSocket->RemoveMsgCallback(messageSeq);
109 clientSocket->GetReplyTimer(messageSeq);
110 clientSocket->StartReplyTimer(messageSeq);
111 clientSocket->StopReplyTimer(messageSeq);
112 clientSocket->ReplyTimerTimeOut(messageSeq);
113 clientSocket->GetMessageSeq();
114 clientSocket->SetDeviceNetworkId(networkId, attributes);
115 clientSocket->PrintTransferDuration(messageSeq);
116 clientSocket->SetConnectionName(connectionName);
117 IAM_LOGI("end");
118 }
119
FuzzSoftBusServerSocketFisrst(Parcel & parcel)120 void FuzzSoftBusServerSocketFisrst(Parcel &parcel)
121 {
122 IAM_LOGI("start");
123 int32_t socketId = parcel.ReadInt32();
124 auto serverSocket = Common::MakeShared<ServerSocket>(socketId);
125 std::string connectionName = parcel.ReadString();
126 ShutdownReason reason = SHUTDOWN_REASON_LOCAL;
127 serverSocket->OnShutdown(socketId, reason);
128 serverSocket->GetConnectionName();
129 std::string networkId = parcel.ReadString();
130 serverSocket->GetNetworkId();
131 serverSocket->AddServerSocket(socketId, networkId);
132 serverSocket->DeleteServerSocket(socketId);
133 serverSocket->AddClientConnection(socketId, connectionName);
134 serverSocket->DeleteClientConnection(socketId);
135 serverSocket->GetNetworkIdBySocketId(socketId);
136 serverSocket->GetClientConnectionName(socketId);
137 serverSocket->GetSocketIdByClientConnectionName(connectionName);
138 std::vector<uint8_t> attr;
139 Common::FillFuzzUint8Vector(parcel, attr);
140 auto attributes = Common::MakeShared<Attributes>(attr);
141 MsgCallback callback = nullptr;
142 serverSocket->SendMessage(connectionName, connectionName, connectionName, attributes, callback);
143 std::string data = parcel.ReadString();
144 serverSocket->OnBytes(socketId, &data, data.size());
145 IAM_LOGI("end");
146 }
147
FuzzSoftBusManagerServer(Parcel & parcel)148 void FuzzSoftBusManagerServer(Parcel &parcel)
149 {
150 SoftBusManager::GetInstance().ServiceSocketInit();
151 auto serverSocket = SoftBusManager::GetInstance().GetServerSocket();
152 if (serverSocket != nullptr) {
153 ShutdownReason reason = SHUTDOWN_REASON_UNKNOWN;
154 SoftBusManager::GetInstance().OnShutdown(serverSocket->GetSocketId(), reason);
155
156 PeerSocketInfo info;
157 SoftBusManager::GetInstance().OnBind(serverSocket->GetSocketId(), info);
158
159 std::string data = parcel.ReadString();
160 SoftBusManager::GetInstance().OnServerBytes(serverSocket->GetSocketId(), &data, data.size());
161 }
162 SoftBusManager::GetInstance().ServiceSocketUnInit();
163 }
164
FuzzSoftBusManagerClient(Parcel & parcel)165 void FuzzSoftBusManagerClient(Parcel &parcel)
166 {
167 std::string connectionName = parcel.ReadString();
168 uint32_t tokenId = parcel.ReadUint32();
169 std::string networkId = parcel.ReadString();
170 SoftBusManager::GetInstance().DoOpenConnection(connectionName, tokenId, networkId);
171 auto clientSocket = SoftBusManager::GetInstance().FindClientSocket(connectionName);
172 if (clientSocket != nullptr) {
173 PeerSocketInfo info;
174 SoftBusManager::GetInstance().OnBind(clientSocket->GetSocketId(), info);
175 ShutdownReason reason = SHUTDOWN_REASON_LOCAL;
176 SoftBusManager::GetInstance().OnShutdown(clientSocket->GetSocketId(), reason);
177 std::string data = parcel.ReadString();
178 SoftBusManager::GetInstance().OnClientBytes(clientSocket->GetSocketId(), &data, data.size());
179 }
180 SoftBusManager::GetInstance().DoCloseConnection(connectionName);
181 }
182
FuzzSoftBusManagerInit(Parcel & parcel)183 void FuzzSoftBusManagerInit(Parcel &parcel)
184 {
185 IAM_LOGI("start");
186 SoftBusManager::GetInstance().Stop();
187 SoftBusManager::GetInstance().Start();
188 SoftBusManager::GetInstance().Stop();
189 IAM_LOGI("end");
190 }
191
192 using FuzzFunc = decltype(FuzzSoftBusManagerInit);
193 FuzzFunc *g_fuzzFuncs[] = {
194 FuzzSoftBusManagerInit,
195 FuzzSoftBusManagerSecond,
196 FuzzSoftBusBaseSocketFirst,
197 FuzzSoftBusBaseSocketSecond,
198 FuzzSoftBusServerSocketFisrst,
199 FuzzSoftBusManagerServer,
200 FuzzSoftBusManagerClient,
201 };
202
SoftBusFuzzTest(const uint8_t * data,size_t size)203 void SoftBusFuzzTest(const uint8_t *data, size_t size)
204 {
205 Parcel parcel;
206 parcel.WriteBuffer(data, size);
207 parcel.RewindRead(0);
208 uint32_t index = parcel.ReadUint32() % (sizeof(g_fuzzFuncs) / sizeof(FuzzFunc *));
209 auto fuzzFunc = g_fuzzFuncs[index];
210 fuzzFunc(parcel);
211 return;
212 }
213
214 } // namespace
215 } // namespace UserAuth
216 } // namespace UserIam
217 } // namespace OHOS
218
219 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)220 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
221 {
222 /* Run your code on data */
223 OHOS::UserIam::UserAuth::SoftBusFuzzTest(data, size);
224 return 0;
225 }
226