1 /*
2 * Copyright (c) 2021-2022 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 "clienttranssessionmanager_fuzzer.h"
17
18 #include "client_trans_session_manager.h"
19 #include "client_trans_socket_manager.h"
20 #include "fuzz_data_generator.h"
21 #include "session.h"
22 #include "softbus_trans_def.h"
23
24 namespace OHOS {
OnSessionOpened(int32_t sessionId,int32_t result)25 static int32_t OnSessionOpened(int32_t sessionId, int32_t result)
26 {
27 return 0;
28 }
OnSessionClosed(int32_t sessionId)29 static void OnSessionClosed(int32_t sessionId) {}
30
OnBytesReceived(int32_t sessionId,const void * data,unsigned int len)31 static void OnBytesReceived(int32_t sessionId, const void* data, unsigned int len) {}
32
OnMessageReceived(int32_t sessionId,const void * data,unsigned int len)33 static void OnMessageReceived(int32_t sessionId, const void* data, unsigned int len) {}
34
35 static ISessionListener g_sessionlistener = {
36 .OnSessionOpened = OnSessionOpened,
37 .OnSessionClosed = OnSessionClosed,
38 .OnBytesReceived = OnBytesReceived,
39 .OnMessageReceived = OnMessageReceived,
40 };
41
ClientAddNewSessionTest(const uint8_t * data,size_t size)42 void ClientAddNewSessionTest(const uint8_t* data, size_t size)
43 {
44 if ((data == nullptr) || (size == 0)) {
45 return;
46 }
47 const char* testSessionName = reinterpret_cast<const char *>(data);
48 SessionInfo session;
49 ClientAddNewSession(testSessionName, &session);
50 }
51
ClientAddAuthSessionTest(const uint8_t * data,size_t size)52 void ClientAddAuthSessionTest(const uint8_t* data, size_t size)
53 {
54 #define SESSION_NAME_SIZE_MAX 256
55 if ((data == nullptr) || (size < SESSION_NAME_SIZE_MAX)) {
56 return;
57 }
58 DataGenerator::Write(data, size);
59 int32_t sessionId = 0;
60 GenerateInt32(sessionId);
61 ClientAddAuthSession(nullptr, &sessionId);
62 DataGenerator::Clear();
63 }
64
ClientDeleteSessionTest(const uint8_t * data,size_t size)65 void ClientDeleteSessionTest(const uint8_t* data, size_t size)
66 {
67 if ((data == nullptr) || (size < sizeof(int32_t))) {
68 return;
69 }
70 DataGenerator::Write(data, size);
71 int32_t sessionId = 0;
72 GenerateInt32(sessionId);
73 ClientDeleteSession(sessionId);
74 DataGenerator::Clear();
75 }
76
ClientGetSessionDataTest(const uint8_t * data,size_t size)77 void ClientGetSessionDataTest(const uint8_t* data, size_t size)
78 {
79 if ((data == nullptr) || (size < sizeof(int32_t) + sizeof(int))) {
80 return;
81 }
82 uint32_t offset = 0;
83 int32_t sessionId = *(reinterpret_cast<const int32_t *>(data));
84 offset += sizeof(int32_t);
85 char* testData = const_cast<char*>(reinterpret_cast<const char *>(data));
86 int* testInt = const_cast<int*>(reinterpret_cast<const int *>(data + offset));
87 ClientGetSessionDataById(sessionId, testData, size, KEY_SESSION_NAME);
88 ClientGetSessionIntegerDataById(sessionId, testInt, KEY_SESSION_NAME);
89 ClientGetSessionSide(sessionId);
90 }
91
ClientSetChannelBySessionIdTest(const uint8_t * data,size_t size)92 void ClientSetChannelBySessionIdTest(const uint8_t* data, size_t size)
93 {
94 if ((data == nullptr) || (size < sizeof(int32_t))) {
95 return;
96 }
97 DataGenerator::Write(data, size);
98 int32_t sessionId = 0;
99 GenerateInt32(sessionId);
100 TransInfo transInfo = {
101 .channelId = 0,
102 .channelType = 0,
103 };
104
105 ClientSetChannelBySessionId(sessionId, &transInfo);
106 DataGenerator::Clear();
107 }
108
ClientGetSessionCallbackTest(const uint8_t * data,size_t size)109 void ClientGetSessionCallbackTest(const uint8_t* data, size_t size)
110 {
111 if ((data == nullptr) || (size < sizeof(int32_t))) {
112 return;
113 }
114 DataGenerator::Write(data, size);
115 int32_t sessionId = 0;
116 GenerateInt32(sessionId);
117 const char* testSessionName = reinterpret_cast<const char *>(data);
118
119 ClientGetSessionCallbackById(sessionId, &g_sessionlistener);
120 ClientGetSessionCallbackByName(testSessionName, &g_sessionlistener);
121 DataGenerator::Clear();
122 }
123
ClientTransOnLinkDownTest(const uint8_t * data,size_t size)124 void ClientTransOnLinkDownTest(const uint8_t* data, size_t size)
125 {
126 if ((data == nullptr) || (size < sizeof(int32_t))) {
127 return;
128 }
129 DataGenerator::Write(data, size);
130 int32_t routeType = 0;
131 GenerateInt32(routeType);
132 const char* netWorkId = reinterpret_cast<const char *>(data);
133
134 ClientTransOnLinkDown(netWorkId, routeType);
135 DataGenerator::Clear();
136 }
137
ClientRemovePermissionTest(const uint8_t * data,size_t size)138 void ClientRemovePermissionTest(const uint8_t* data, size_t size)
139 {
140 (void)data;
141 (void)size;
142 ClientRemovePermission(nullptr);
143 }
144
ClientGetFileConfigInfoByIdTest(const uint8_t * data,size_t size)145 void ClientGetFileConfigInfoByIdTest(const uint8_t* data, size_t size)
146 {
147 if ((data == nullptr) || (size < sizeof(int32_t))) {
148 return;
149 }
150 DataGenerator::Write(data, size);
151 int32_t sessionId = 0;
152 int32_t fileEncrypt = 0;
153 GenerateInt32(sessionId);
154 GenerateInt32(fileEncrypt);
155 ClientGetFileConfigInfoById(sessionId, &fileEncrypt, &fileEncrypt, &fileEncrypt);
156 DataGenerator::Clear();
157 }
158
GetEncryptByChannelIdTest(const uint8_t * data,size_t size)159 void GetEncryptByChannelIdTest(const uint8_t* data, size_t size)
160 {
161 if ((data == nullptr) || (size < sizeof(int32_t))) {
162 return;
163 }
164 DataGenerator::Write(data, size);
165 int32_t channelId = 0;
166 int32_t channelType = 0;
167 GenerateInt32(channelId);
168 GenerateInt32(channelType);
169 int32_t encryp = 0;
170 GetEncryptByChannelId(channelId, channelType, &encryp);
171 DataGenerator::Clear();
172 }
173
ClientGetSessionIdByChannelIdTest(const uint8_t * data,size_t size)174 void ClientGetSessionIdByChannelIdTest(const uint8_t* data, size_t size)
175 {
176 if ((data == nullptr) || (size < sizeof(int32_t))) {
177 return;
178 }
179 DataGenerator::Write(data, size);
180 int32_t channelId = 0;
181 int32_t channelType = 0;
182 GenerateInt32(channelId);
183 GenerateInt32(channelType);
184 int32_t sessionId;
185 bool isClosing = false;
186 ClientGetSessionIdByChannelId(channelId, channelType, &sessionId, isClosing);
187 DataGenerator::Clear();
188 }
189
ClientEnableSessionByChannelIdTest(const uint8_t * data,size_t size)190 void ClientEnableSessionByChannelIdTest(const uint8_t* data, size_t size)
191 {
192 if ((data == nullptr) || (size < sizeof(int32_t))) {
193 return;
194 }
195 ChannelInfo channel;
196 DataGenerator::Write(data, size);
197 int32_t sessionId = 0;
198 GenerateInt32(sessionId);
199 ClientEnableSessionByChannelId(&channel, &sessionId);
200 DataGenerator::Clear();
201 }
202
203 } // namespace OHOS
204
205 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)206 extern "C" int32_t LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
207 {
208 OHOS::ClientAddNewSessionTest(data, size);
209 OHOS::ClientAddAuthSessionTest(data, size);
210 OHOS::ClientDeleteSessionTest(data, size);
211 OHOS::ClientGetSessionDataTest(data, size);
212 OHOS::ClientSetChannelBySessionIdTest(data, size);
213 OHOS::ClientGetSessionCallbackTest(data, size);
214 OHOS::ClientTransOnLinkDownTest(data, size);
215 OHOS::ClientRemovePermissionTest(data, size);
216 OHOS::ClientGetFileConfigInfoByIdTest(data, size);
217 OHOS::GetEncryptByChannelIdTest(data, size);
218 OHOS::ClientGetSessionIdByChannelIdTest(data, size);
219 OHOS::ClientEnableSessionByChannelIdTest(data, size);
220 return 0;
221 }
222