1 /*
2 * Copyright (c) 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 "securec.h"
17 #include <cstddef>
18 #include <cstdint>
19 #include <iostream>
20 #include <memory>
21 #include <fuzzer/FuzzedDataProvider.h>
22 #include "audio_adapter.h"
23 #include "audio_system_manager.h"
24 #include "avsession_log.h"
25 #include "avsession_errors.h"
26 #include "audioadapterinterface_fuzzer.h"
27
28 using namespace std;
29 using namespace OHOS;
30 using namespace OHOS::AVSession;
31
32 static const int32_t MIN_SIZE_NUM = 10;
33 static const uint8_t *RAW_DATA = nullptr;
34 static size_t g_totalSize = 0;
35 using TestFunc = function<void()>;
36
AudioAdapterTest001()37 void AudioAdapterTest001()
38 {
39 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
40
41 auto &audioAdapter = AudioAdapter::GetInstance();
42
43 int32_t volume = provider.ConsumeIntegral<int32_t>();
44 audioAdapter.SetVolume(volume);
45
46 int32_t uid = provider.ConsumeIntegral<int32_t>();
47 int32_t pid = provider.ConsumeIntegral<int32_t>();
48 audioAdapter.MuteAudioStream(uid, pid);
49 audioAdapter.UnsetAvailableDeviceChangeCallback();
50 auto callback = [](int32_t) {};
51 audioAdapter.RegisterVolumeKeyEventCallback(callback);
52 audioAdapter.GetVolume();
53 audioAdapter.UnsetDeviceChangeCallback();
54 }
55
AudioAdapterTest002()56 void AudioAdapterTest002()
57 {
58 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
59
60 OHOS::AudioStandard::VolumeEvent volumeEvent;
61 volumeEvent.volumeType = static_cast<OHOS::AudioStandard::AudioVolumeType>(
62 provider.ConsumeIntegralInRange<int>(0, AudioStandard::AudioVolumeType::STREAM_APP));
63 volumeEvent.volume = provider.ConsumeIntegral<int32_t>();
64 volumeEvent.updateUi = provider.ConsumeBool();
65 volumeEvent.networkId = provider.ConsumeRandomLengthString();
66 volumeEvent.volumeMode = static_cast<OHOS::AudioStandard::AudioVolumeMode>(
67 provider.ConsumeIntegralInRange<int>(0,
68 AudioStandard::AudioVolumeMode::AUDIOSTREAM_VOLUMEMODE_APP_INDIVIDUAL));
69
70 auto &audioAdapter = OHOS::AVSession::AudioAdapter::GetInstance();
71 auto callbackFunction = [](int32_t volume) {};
72 OHOS::AVSession::AudioVolumeKeyEventCallback callback(callbackFunction);
73 callback.OnVolumeKeyEvent(volumeEvent);
74 audioAdapter.SetDeviceChangeCallback();
75
76 int32_t uid = provider.ConsumeIntegral<int32_t>();
77 int32_t pid = provider.ConsumeIntegral<int32_t>();
78 audioAdapter.MuteAudioStream(uid, pid);
79 audioAdapter.UnsetAvailableDeviceChangeCallback();
80 audioAdapter.UnregisterVolumeKeyEventCallback();
81 audioAdapter.UnsetPreferredOutputDeviceChangeCallback();
82 }
83
AudioAdapterTest003()84 void AudioAdapterTest003()
85 {
86 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
87
88 auto &audioAdapter = AudioAdapter::GetInstance();
89 audioAdapter.SetDeviceChangeCallback();
90 audioAdapter.UnregisterVolumeKeyEventCallback();
91
92 int32_t uid = provider.ConsumeIntegral<int32_t>();
93 audioAdapter.UnMuteAudioStream(uid);
94 auto callback = [](int32_t volume) {};
95 audioAdapter.RegisterVolumeKeyEventCallback(callback);
96
97 OHOS::AVSession::AudioAdapter::StateListener StateListener;
98 audioAdapter.AddStreamRendererStateListener(StateListener);
99 audioAdapter.UnsetPreferredOutputDeviceChangeCallback();
100 }
101
AudioAdapterTest004()102 void AudioAdapterTest004()
103 {
104 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
105
106 int32_t uid = provider.ConsumeIntegral<int32_t>();
107 int32_t pid = provider.ConsumeIntegral<int32_t>();
108 int32_t muteUid = provider.ConsumeIntegral<int32_t>();
109 OHOS::AudioStandard::StreamUsage muteUsage = static_cast<OHOS::AudioStandard::StreamUsage>(
110 provider.ConsumeIntegralInRange<int32_t>(0, OHOS::AudioStandard::STREAM_USAGE_MAX));
111 int32_t pauseUid = provider.ConsumeIntegral<int32_t>();
112 OHOS::AudioStandard::StreamUsage pauseUsage = static_cast<OHOS::AudioStandard::StreamUsage>(
113 provider.ConsumeIntegralInRange<int32_t>(0, OHOS::AudioStandard::STREAM_USAGE_MAX));
114
115 auto desc = std::make_shared<OHOS::AudioStandard::AudioDeviceDescriptor>();
116 desc->deviceRole_ = static_cast<OHOS::AudioStandard::DeviceRole>(
117 provider.ConsumeIntegralInRange<int32_t>(0, OHOS::AudioStandard::DEVICE_ROLE_MAX));
118 desc->deviceType_ = static_cast<OHOS::AudioStandard::DeviceType>(
119 provider.ConsumeIntegralInRange<int32_t>(0, OHOS::AudioStandard::DEVICE_TYPE_MAX));
120 desc->connectState_ = static_cast<OHOS::AudioStandard::ConnectState>(
121 provider.ConsumeIntegralInRange<int32_t>(0, OHOS::AudioStandard::CONNECTED));
122 OHOS::AudioStandard::AudioRendererChangeInfo rendererChangeInfo;
123 rendererChangeInfo.rendererState = static_cast<OHOS::AudioStandard::RendererState>(
124 provider.ConsumeIntegralInRange<int32_t>(0, OHOS::AudioStandard::RENDERER_PAUSED));
125
126 int32_t unmuteUid = provider.ConsumeIntegral<int32_t>();
127 OHOS::AudioStandard::StreamUsage unmuteUsage = static_cast<OHOS::AudioStandard::StreamUsage>(
128 provider.ConsumeIntegralInRange<int32_t>(0, OHOS::AudioStandard::STREAM_USAGE_MAX));
129
130 auto &audioAdapter = AudioAdapter::GetInstance();
131 audioAdapter.GetRendererRunning(uid, pid);
132 audioAdapter.MuteAudioStream(muteUid, muteUsage);
133 audioAdapter.PauseAudioStream(pauseUid, pauseUsage);
134 audioAdapter.SelectOutputDevice(desc);
135 OHOS::AVSession::AudioRendererChangeInfos rendererChangeInfos;
136 rendererChangeInfos.push_back(std::make_shared<OHOS::AudioStandard::AudioRendererChangeInfo>(rendererChangeInfo));
137 audioAdapter.OnRendererStateChange(rendererChangeInfos);
138 audioAdapter.UnMuteAudioStream(unmuteUid, unmuteUsage);
139 }
140
AudioAdapterTest005()141 void AudioAdapterTest005()
142 {
143 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
144
145 int32_t uid = provider.ConsumeIntegral<int32_t>();
146 OHOS::AudioStandard::StreamUsage usage = static_cast<OHOS::AudioStandard::StreamUsage>(
147 provider.ConsumeIntegralInRange<int32_t>(0, OHOS::AudioStandard::STREAM_USAGE_MAX));
148
149 auto callback = [](const OHOS::AVSession::AudioDeviceDescriptors&) {};
150 OHOS::AVSession::AudioAdapter::PreferOutputDeviceChangeListener listener;
151
152 auto &audioAdapter = OHOS::AVSession::AudioAdapter::GetInstance();
153 audioAdapter.MuteAudioStream(uid, usage);
154 audioAdapter.PauseAudioStream(uid, usage);
155 audioAdapter.SetAvailableDeviceChangeCallback(callback);
156 audioAdapter.SetPreferredOutputDeviceChangeCallback(callback);
157 audioAdapter.UnMuteAudioStream(uid, usage);
158 audioAdapter.AddDeviceChangeListener(listener);
159 }
160
AudioAdapterTest006()161 void AudioAdapterTest006()
162 {
163 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
164 auto &audioAdapter = AudioAdapter::GetInstance();
165 int32_t volume = provider.ConsumeIntegral<int32_t>();
166 audioAdapter.SetVolume(volume);
167 auto allowedPlaybackCallback = [](int32_t, int32_t) ->bool {
168 return true;
169 };
170 audioAdapter.RegisterAllowedPlaybackCallback(allowedPlaybackCallback);
171
172 auto volumeKeyEventCallback = [](int32_t) -> void {};
173 audioAdapter.RegisterVolumeKeyEventCallback(volumeKeyEventCallback);
174 audioAdapter.GetVolume();
175 int32_t uid = provider.ConsumeIntegral<int32_t>();
176 audioAdapter.UnMuteAudioStream(uid);
177 audioAdapter.UnsetAvailableDeviceChangeCallback();
178 }
179
AudioAdapterTest007()180 void AudioAdapterTest007()
181 {
182 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
183
184 constexpr int maxRange = 10;
185 auto deviceCount = provider.ConsumeIntegralInRange(0, maxRange);
186 AudioDeviceDescriptors deviceDescriptors;
187 for (int i = 0; i < deviceCount; ++i) {
188 auto desc = std::make_shared<AudioDeviceDescriptor>();
189 desc->deviceType_ = static_cast<AudioStandard::DeviceType>(provider.ConsumeIntegralInRange<int>(0,
190 AudioStandard::DEVICE_TYPE_MAX));
191 desc->deviceRole_ = static_cast<AudioStandard::DeviceRole>(provider.ConsumeIntegralInRange<int32_t>(0,
192 AudioStandard::DEVICE_ROLE_MAX));
193 desc->connectState_ = static_cast<AudioStandard::ConnectState>(provider.ConsumeIntegralInRange<int32_t>(0,
194 AudioStandard::ConnectState::DEACTIVE_CONNECTED));
195 deviceDescriptors.push_back(desc);
196 }
197
198 auto &audioAdapter = AudioAdapter::GetInstance();
199 audioAdapter.GetPreferredOutputDeviceForRendererInfo();
200 audioAdapter.OnPreferredOutputDeviceUpdated(deviceDescriptors);
201 audioAdapter.GetAvailableDevices();
202 audioAdapter.GetDevices();
203 AudioPreferredDeviceChangeCallback callback([] (const AudioDeviceDescriptors& devices) {});
204 callback.OnPreferredOutputDeviceUpdated(deviceDescriptors);
205
206 auto desc = std::make_shared<AudioDeviceDescriptor>();
207 audioAdapter.FindRenderDeviceForUsage(deviceDescriptors, desc);
208 }
209
AudioAdapterTest008()210 void AudioAdapterTest008()
211 {
212 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
213
214 auto& audioAdapter = AudioAdapter::GetInstance();
215 auto preferredDevices = audioAdapter.GetPreferredOutputDeviceForRendererInfo();
216
217 bool shouldSetNull = provider.ConsumeBool();
218 AudioDeviceDescriptors deviceDescriptors;
219 constexpr int maxRange = 10;
220 if (!shouldSetNull) {
221 size_t numDescriptors = provider.ConsumeIntegralInRange<size_t>(1, maxRange);
222 for (size_t i = 0; i < numDescriptors; ++i) {
223 auto descriptor = std::make_shared<AudioDeviceDescriptor>();
224 descriptor->deviceType_ = static_cast<AudioStandard::DeviceType>(provider.ConsumeIntegral<int>());
225 descriptor->deviceRole_ = static_cast<AudioStandard::DeviceRole>(provider.ConsumeIntegral<int>());
226 deviceDescriptors.push_back(descriptor);
227 }
228 }
229
230 audioAdapter.OnPreferredOutputDeviceUpdated(deviceDescriptors);
231 auto availableDevices = audioAdapter.GetAvailableDevices();
232 audioAdapter.Init();
233 auto devices = audioAdapter.GetDevices();
234 AudioDeviceDescriptorWithSptr targetDescriptor = std::make_shared<AudioDeviceDescriptor>();
235 targetDescriptor->deviceType_ = static_cast<AudioStandard::DeviceType>(provider.ConsumeIntegral<int>());
236 targetDescriptor->deviceRole_ = static_cast<AudioStandard::DeviceRole>(provider.ConsumeIntegral<int>());
237 auto foundDevice = audioAdapter.FindRenderDeviceForUsage(availableDevices, targetDescriptor);
238 }
239
AudioAdapterTest009()240 void AudioAdapterTest009()
241 {
242 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
243
244 AudioDeviceDescriptor deviceDescriptor;
245 deviceDescriptor.deviceRole_ = static_cast<AudioStandard::DeviceRole>(
246 provider.ConsumeIntegralInRange<int>(0, AudioStandard::DEVICE_ROLE_MAX));
247 deviceDescriptor.deviceType_ = static_cast<AudioStandard::DeviceType>(
248 provider.ConsumeIntegralInRange<int>(0, AudioStandard::DEVICE_TYPE_MAX));
249 AudioStandard::AudioRendererInfo rendererInfo;
250 rendererInfo.contentType = static_cast<AudioStandard::ContentType>(
251 provider.ConsumeIntegralInRange<int>(0, AudioStandard::CONTENT_TYPE_ULTRASONIC));
252 rendererInfo.streamUsage = static_cast<AudioStandard::StreamUsage>(
253 provider.ConsumeIntegralInRange<int>(0, AudioStandard::STREAM_USAGE_VOICE_CALL_ASSISTANT));
254 rendererInfo.rendererFlags = provider.ConsumeIntegral<int32_t>();
255 rendererInfo.volumeMode = static_cast<AudioStandard::AudioVolumeMode>(provider.ConsumeIntegralInRange<int>(0,
256 AudioStandard::AudioVolumeMode::AUDIOSTREAM_VOLUMEMODE_APP_INDIVIDUAL));
257 rendererInfo.sceneType = provider.ConsumeRandomLengthString();
258 rendererInfo.spatializationEnabled = provider.ConsumeBool();
259 rendererInfo.pipeType = static_cast<AudioStandard::AudioPipeType>(
260 provider.ConsumeIntegralInRange<int>(0, AudioStandard::PIPE_TYPE_DIRECT_VOIP));
261 rendererInfo.samplingRate = static_cast<AudioStandard::AudioSamplingRate>(
262 provider.ConsumeIntegralInRange<int>(0, AudioStandard::SAMPLE_RATE_192000));
263 rendererInfo.format = static_cast<AudioStandard::AudioSampleFormat>(
264 provider.ConsumeIntegralInRange<int>(0, AudioStandard::INVALID_WIDTH));
265 rendererInfo.encodingType = provider.ConsumeIntegral<uint8_t>();
266 rendererInfo.channelLayout = static_cast<AudioStandard::AudioChannelLayout>(provider.ConsumeIntegral<uint64_t>());
267 rendererInfo.playerType = static_cast<AudioStandard::PlayerType>(
268 provider.ConsumeIntegralInRange<int>(0, AudioStandard::PLAYER_TYPE_TONE_PLAYER));
269
270 AudioStandard::AudioRendererChangeInfo rendererChangeInfo;
271 rendererChangeInfo.rendererState = static_cast<AudioStandard::RendererState>(
272 provider.ConsumeIntegralInRange<int>(0, AudioStandard::RENDERER_PAUSED));
273 rendererChangeInfo.rendererInfo = rendererInfo;
274
275 std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> deviceDescriptors;
276 constexpr size_t maxDescriptors = 10;
277 size_t numDescriptors = provider.ConsumeIntegralInRange<size_t>(0, maxDescriptors);
278 for (size_t i = 0; i < numDescriptors; ++i) {
279 deviceDescriptors.push_back(std::make_shared<AudioStandard::AudioDeviceDescriptor>(deviceDescriptor));
280 }
281
282 auto deviceDescriptorWithSptr = std::make_shared<AudioStandard::AudioDeviceDescriptor>(deviceDescriptor);
283
284 AudioRendererChangeInfos rendererChangeInfos;
285 rendererChangeInfos.push_back(std::make_shared<AudioStandard::AudioRendererChangeInfo>(rendererChangeInfo));
286
287 auto &audioAdapter = AudioAdapter::GetInstance();
288 audioAdapter.GetPreferredOutputDeviceForRendererInfo();
289 audioAdapter.OnPreferredOutputDeviceUpdated(deviceDescriptors);
290 audioAdapter.GetAvailableDevices();
291 audioAdapter.GetDevices();
292 audioAdapter.FindRenderDeviceForUsage(deviceDescriptors, deviceDescriptorWithSptr);
293 audioAdapter.OnRendererStateChange(rendererChangeInfos);
294 }
295
AudioAdapterTest010()296 void AudioAdapterTest010()
297 {
298 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
299
300 int32_t volume = provider.ConsumeIntegral<int32_t>();
301 int32_t uid = provider.ConsumeIntegral<int32_t>();
302 int32_t pid = provider.ConsumeIntegral<int32_t>();
303 std::function<void(int32_t)> volumeKeyEventCallback = [](int32_t) {};
304 std::function<bool(int32_t, int32_t)> allowedPlaybackCallback = [](int32_t, int32_t) { return true; };
305
306 auto &audioAdapter = AudioAdapter::GetInstance();
307 audioAdapter.SetVolume(volume);
308 audioAdapter.SetDeviceChangeCallback();
309 audioAdapter.MuteAudioStream(uid, pid);
310 audioAdapter.RegisterVolumeKeyEventCallback(volumeKeyEventCallback);
311 audioAdapter.RegisterAllowedPlaybackCallback(allowedPlaybackCallback);
312 audioAdapter.UnsetDeviceChangeCallback();
313 }
314
AudioAdapterTest011()315 void AudioAdapterTest011()
316 {
317 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
318
319 auto descriptor = std::make_shared<AudioStandard::AudioDeviceDescriptor>();
320 descriptor->deviceType_ = static_cast<AudioStandard::DeviceType>(
321 provider.ConsumeIntegralInRange<int>(0, AudioStandard::DEVICE_TYPE_MAX));
322 descriptor->deviceRole_ = static_cast<AudioStandard::DeviceRole>(
323 provider.ConsumeIntegralInRange<int>(0, AudioStandard::DEVICE_ROLE_MAX));
324 descriptor->networkId_ = provider.ConsumeRandomLengthString();
325 descriptor->macAddress_ = provider.ConsumeRandomLengthString();
326 descriptor->deviceName_ = provider.ConsumeRandomLengthString();
327
328 AudioDeviceDescriptors devices;
329 constexpr int maxDevices = 10;
330 size_t count = provider.ConsumeIntegralInRange<size_t>(0, maxDevices);
331 for (size_t i = 0; i < count; ++i) {
332 devices.push_back(descriptor);
333 }
334
335 auto &audioAdapter = AudioAdapter::GetInstance();
336 audioAdapter.UnregisterVolumeKeyEventCallback();
337 audioAdapter.UnsetAvailableDeviceChangeCallback();
338 audioAdapter.FindRenderDeviceForUsage(devices, descriptor);
339
340 audioAdapter.SelectOutputDevice(descriptor);
341 audioAdapter.GetVolume();
342 int32_t uid = provider.ConsumeIntegral<int32_t>();
343 audioAdapter.UnMuteAudioStream(uid);
344 }
345
FuzzTest(const uint8_t * rawData,size_t size)346 bool FuzzTest(const uint8_t* rawData, size_t size)
347 {
348 if (rawData == nullptr) {
349 return false;
350 }
351
352 // initialize data
353 RAW_DATA = rawData;
354 g_totalSize = size;
355 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
356 std::vector<TestFunc> allFuncs = {
357 AudioAdapterTest001,
358 AudioAdapterTest002,
359 AudioAdapterTest003,
360 AudioAdapterTest004,
361 AudioAdapterTest005,
362 AudioAdapterTest006,
363 AudioAdapterTest007,
364 AudioAdapterTest008,
365 AudioAdapterTest009,
366 AudioAdapterTest010,
367 AudioAdapterTest011
368 };
369
370 uint32_t code = provider.ConsumeIntegral<uint32_t>();
371 uint32_t len = allFuncs.size();
372 if (len > 0) {
373 allFuncs[code % len]();
374 } else {
375 SLOGE("%{public}s: The len length is equal to 0", __func__);
376 }
377
378 return true;
379 }
380
381 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)382 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
383 {
384 if (size < MIN_SIZE_NUM) {
385 return 0;
386 }
387 /* Run your code on data */
388 FuzzTest(data, size);
389 return 0;
390 }
391