1 /*
2 * Copyright (c) 2025 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 <iostream>
17 #include <cstddef>
18 #include <cstdint>
19 #include <vector>
20 #include <memory>
21 #include <queue>
22 #include <string>
23 #undef private
24 #include "hpae_source_input_cluster.h"
25 #include "hpae_source_input_node.h"
26 #include "hpae_source_output_node.h"
27 #include "hpae_format_convert.h"
28 #include "audio_engine_log.h"
29 using namespace std;
30 using namespace OHOS::AudioStandard::HPAE;
31
32
33 namespace OHOS {
34 namespace AudioStandard {
35 using namespace std;
36 static const uint8_t *RAW_DATA = nullptr;
37 static size_t g_dataSize = 0;
38 static size_t g_pos;
39 const size_t THRESHOLD = 10;
40 const uint32_t DEFAULT_FRAME_LENGTH = 960;
41 const uint32_t DEFAULT_NODE_ID = 1243;
42 typedef void (*TestPtr)(const uint8_t *, size_t);
43
44 template<class T>
GetData()45 T GetData()
46 {
47 T object {};
48 size_t objectSize = sizeof(object);
49 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
50 return object;
51 }
52 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
53 if (ret != EOK) {
54 return {};
55 }
56 g_pos += objectSize;
57 return object;
58 }
59
60 template<class T>
GetArrLength(T & arr)61 uint32_t GetArrLength(T& arr)
62 {
63 if (arr == nullptr) {
64 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
65 return 0;
66 }
67 return sizeof(arr) / sizeof(arr[0]);
68 }
69
GetTestNodeInfo(HpaeNodeInfo & nodeInfo)70 static void GetTestNodeInfo(HpaeNodeInfo &nodeInfo)
71 {
72 nodeInfo.nodeId = DEFAULT_NODE_ID;
73 nodeInfo.frameLen = DEFAULT_FRAME_LENGTH;
74 nodeInfo.samplingRate = SAMPLE_RATE_48000;
75 nodeInfo.channels = STEREO;
76 nodeInfo.format = SAMPLE_S16LE;
77 nodeInfo.sceneType = HPAE_SCENE_RECORD;
78 nodeInfo.sourceBufferType = HPAE_SOURCE_BUFFER_TYPE_MIC;
79 }
80
DoProcessFuzzTest()81 void DoProcessFuzzTest()
82 {
83 HpaeNodeInfo nodeInfo;
84 GetTestNodeInfo(nodeInfo);
85 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
86 hpaeSourceInputCluster->DoProcess();
87 }
88
ResetFuzzTest()89 void ResetFuzzTest()
90 {
91 HpaeNodeInfo nodeInfo;
92 GetTestNodeInfo(nodeInfo);
93 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
94 hpaeSourceInputCluster->Reset();
95 }
96
ResetAllFuzzTest()97 void ResetAllFuzzTest()
98 {
99 HpaeNodeInfo nodeInfo;
100 GetTestNodeInfo(nodeInfo);
101 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
102 hpaeSourceInputCluster->ResetAll();
103 }
104
GetSharedInstanceFuzzTest1()105 void GetSharedInstanceFuzzTest1()
106 {
107 HpaeNodeInfo nodeInfo;
108 GetTestNodeInfo(nodeInfo);
109 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
110 hpaeSourceInputCluster->GetSharedInstance();
111 }
112
GetSharedInstanceFuzzTest2()113 void GetSharedInstanceFuzzTest2()
114 {
115 HpaeNodeInfo nodeInfo;
116 GetTestNodeInfo(nodeInfo);
117 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
118 hpaeSourceInputCluster->GetSharedInstance(nodeInfo);
119 }
120
GetOutputPortFuzzTest1()121 void GetOutputPortFuzzTest1()
122 {
123 HpaeNodeInfo nodeInfo;
124 GetTestNodeInfo(nodeInfo);
125 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
126 hpaeSourceInputCluster->GetOutputPort();
127 }
128
GetOutputPortFuzzTest2()129 void GetOutputPortFuzzTest2()
130 {
131 HpaeNodeInfo nodeInfo;
132 GetTestNodeInfo(nodeInfo);
133 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
134 hpaeSourceInputCluster->GetOutputPort(nodeInfo);
135 }
136
GetCapturerSourceInstanceFuzzTest()137 void GetCapturerSourceInstanceFuzzTest()
138 {
139 HpaeNodeInfo nodeInfo;
140 GetTestNodeInfo(nodeInfo);
141 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
142 std::string deviceClass = "file_io";
143 std::string deviceNetId = "LocalDevice";
144 SourceType sourceType = SOURCE_TYPE_MIC;
145 std::string sourceName = "mic";
146 hpaeSourceInputCluster->GetCapturerSourceInstance(deviceClass, deviceNetId, sourceType, sourceName);
147 }
148
GetOutputPortFuzzTest()149 void GetOutputPortFuzzTest()
150 {
151 HpaeNodeInfo nodeInfo;
152 GetTestNodeInfo(nodeInfo);
153 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
154 hpaeSourceInputCluster->GetOutputPort();
155 }
156
CapturerSourceDeInitFuzzTest()157 void CapturerSourceDeInitFuzzTest()
158 {
159 HpaeNodeInfo nodeInfo;
160 GetTestNodeInfo(nodeInfo);
161 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
162 hpaeSourceInputCluster->CapturerSourceDeInit();
163 }
164
CapturerSourceFlushFuzzTest()165 void CapturerSourceFlushFuzzTest()
166 {
167 HpaeNodeInfo nodeInfo;
168 GetTestNodeInfo(nodeInfo);
169 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
170 hpaeSourceInputCluster->CapturerSourceFlush();
171 }
172
CapturerSourcePauseFuzzTest()173 void CapturerSourcePauseFuzzTest()
174 {
175 HpaeNodeInfo nodeInfo;
176 GetTestNodeInfo(nodeInfo);
177 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
178 hpaeSourceInputCluster->CapturerSourcePause();
179 }
180
CapturerSourceResetFuzzTest()181 void CapturerSourceResetFuzzTest()
182 {
183 HpaeNodeInfo nodeInfo;
184 GetTestNodeInfo(nodeInfo);
185 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
186 hpaeSourceInputCluster->CapturerSourceReset();
187 }
188
CapturerSourceResumeFuzzTest()189 void CapturerSourceResumeFuzzTest()
190 {
191 HpaeNodeInfo nodeInfo;
192 GetTestNodeInfo(nodeInfo);
193 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
194 hpaeSourceInputCluster->CapturerSourceResume();
195 }
196
CapturerSourceStartFuzzTest()197 void CapturerSourceStartFuzzTest()
198 {
199 HpaeNodeInfo nodeInfo;
200 GetTestNodeInfo(nodeInfo);
201 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
202 hpaeSourceInputCluster->CapturerSourceStart();
203 }
204
CapturerSourceStopFuzzTest()205 void CapturerSourceStopFuzzTest()
206 {
207 HpaeNodeInfo nodeInfo;
208 GetTestNodeInfo(nodeInfo);
209 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
210 hpaeSourceInputCluster->CapturerSourceStop();
211 }
212
GetSourceStateFuzzTest()213 void GetSourceStateFuzzTest()
214 {
215 HpaeNodeInfo nodeInfo;
216 GetTestNodeInfo(nodeInfo);
217 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
218 hpaeSourceInputCluster->GetSourceState();
219 }
220
GetOutputPortNumFuzzTest1()221 void GetOutputPortNumFuzzTest1()
222 {
223 HpaeNodeInfo nodeInfo;
224 GetTestNodeInfo(nodeInfo);
225 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
226 hpaeSourceInputCluster->GetOutputPortNum();
227 }
228
GetOutputPortNumFuzzTest2()229 void GetOutputPortNumFuzzTest2()
230 {
231 HpaeNodeInfo nodeInfo;
232 GetTestNodeInfo(nodeInfo);
233 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
234 hpaeSourceInputCluster->GetOutputPortNum(nodeInfo);
235 }
236
GetSourceInputNodeTypeFuzzTest()237 void GetSourceInputNodeTypeFuzzTest()
238 {
239 HpaeNodeInfo nodeInfo;
240 GetTestNodeInfo(nodeInfo);
241 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
242 hpaeSourceInputCluster->GetSourceInputNodeType();
243 }
244
GSetSourceInputNodeTypeFuzzTest()245 void GSetSourceInputNodeTypeFuzzTest()
246 {
247 HpaeNodeInfo nodeInfo;
248 GetTestNodeInfo(nodeInfo);
249 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
250 HpaeSourceInputNodeType type = HpaeSourceInputNodeType::HPAE_SOURCE_DEFAULT;
251 hpaeSourceInputCluster->SetSourceInputNodeType(type);
252 }
253
UpdateAppsUidAndSessionIdFuzzTest()254 void UpdateAppsUidAndSessionIdFuzzTest()
255 {
256 HpaeNodeInfo nodeInfo;
257 GetTestNodeInfo(nodeInfo);
258 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
259 std::vector<int32_t> appsUid = {GetData<int32_t>()};
260 std::vector<int32_t> sessionsId = {GetData<int32_t>()};
261 hpaeSourceInputCluster->UpdateAppsUidAndSessionId(appsUid, sessionsId);
262 }
263
GetCaptureIdFuzzTest()264 void GetCaptureIdFuzzTest()
265 {
266 HpaeNodeInfo nodeInfo;
267 GetTestNodeInfo(nodeInfo);
268 auto hpaeSourceInputCluster = std::make_shared<HpaeSourceInputCluster>(nodeInfo);
269 hpaeSourceInputCluster->GetCaptureId();
270 }
271
272 typedef void (*TestFuncs[23])();
273
274 TestFuncs g_testFuncs = {
275 DoProcessFuzzTest,
276 ResetFuzzTest,
277 ResetAllFuzzTest,
278 GetSharedInstanceFuzzTest1,
279 GetSharedInstanceFuzzTest2,
280 GetOutputPortFuzzTest1,
281 GetOutputPortFuzzTest2,
282 GetCapturerSourceInstanceFuzzTest,
283 GetOutputPortFuzzTest,
284 CapturerSourceDeInitFuzzTest,
285 CapturerSourceFlushFuzzTest,
286 CapturerSourcePauseFuzzTest,
287 CapturerSourceResetFuzzTest,
288 CapturerSourceResumeFuzzTest,
289 CapturerSourceStartFuzzTest,
290 CapturerSourceStopFuzzTest,
291 GetSourceStateFuzzTest,
292 GetOutputPortNumFuzzTest1,
293 GetOutputPortNumFuzzTest2,
294 GetSourceInputNodeTypeFuzzTest,
295 GSetSourceInputNodeTypeFuzzTest,
296 UpdateAppsUidAndSessionIdFuzzTest,
297 GetCaptureIdFuzzTest,
298 };
299
FuzzTest(const uint8_t * rawData,size_t size)300 bool FuzzTest(const uint8_t* rawData, size_t size)
301 {
302 if (rawData == nullptr) {
303 return false;
304 }
305
306 // initialize data
307 RAW_DATA = rawData;
308 g_dataSize = size;
309 g_pos = 0;
310
311 uint32_t code = GetData<uint32_t>();
312 uint32_t len = GetArrLength(g_testFuncs);
313 if (len > 0) {
314 g_testFuncs[code % len]();
315 } else {
316 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
317 }
318
319 return true;
320 }
321
322 } // namespace AudioStandard
323 } // namesapce OHOS
324
325 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)326 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
327 {
328 if (size < OHOS::AudioStandard::THRESHOLD) {
329 return 0;
330 }
331
332 OHOS::AudioStandard::FuzzTest(data, size);
333 return 0;
334 }
335