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 <cstring>
20 #include "audio_info.h"
21 #include "audio_policy_server.h"
22 #include "audio_policy_service.h"
23 #include "audio_device_info.h"
24 #include "audio_utils.h"
25 #include "accesstoken_kit.h"
26 #include "nativetoken_kit.h"
27 #include "token_setproc.h"
28 #include "access_token.h"
29 #include "audio_channel_blend.h"
30 #include "volume_ramp.h"
31 #include "audio_speed.h"
32
33 #include "audio_policy_utils.h"
34 #include "audio_stream_descriptor.h"
35 #include "audio_limiter_manager.h"
36 #include "dfx_msg_manager.h"
37
38 #include "audio_source_clock.h"
39 #include "capturer_clock_manager.h"
40 #include "hpae_policy_manager.h"
41
42 namespace OHOS {
43 namespace AudioStandard {
44 using namespace std;
45
46 static const uint8_t* RAW_DATA = nullptr;
47 static size_t g_dataSize = 0;
48 static size_t g_pos;
49 const size_t THRESHOLD = 10;
50 const uint8_t TESTSIZE = 22;
51 static int32_t NUM_2 = 2;
52
53 typedef void (*TestFuncs)();
54
55 vector<AudioSpatializationSceneType> AudioSpatializationSceneTypeVec {
56 SPATIALIZATION_SCENE_TYPE_DEFAULT,
57 SPATIALIZATION_SCENE_TYPE_MUSIC,
58 SPATIALIZATION_SCENE_TYPE_MOVIE,
59 SPATIALIZATION_SCENE_TYPE_AUDIOBOOK,
60 SPATIALIZATION_SCENE_TYPE_MAX,
61 };
62
63 vector<DeviceType> DeviceTypeVec = {
64 DEVICE_TYPE_NONE,
65 DEVICE_TYPE_INVALID,
66 DEVICE_TYPE_EARPIECE,
67 DEVICE_TYPE_SPEAKER,
68 DEVICE_TYPE_WIRED_HEADSET,
69 DEVICE_TYPE_WIRED_HEADPHONES,
70 DEVICE_TYPE_BLUETOOTH_SCO,
71 DEVICE_TYPE_BLUETOOTH_A2DP,
72 DEVICE_TYPE_BLUETOOTH_A2DP_IN,
73 DEVICE_TYPE_MIC,
74 DEVICE_TYPE_WAKEUP,
75 DEVICE_TYPE_USB_HEADSET,
76 DEVICE_TYPE_DP,
77 DEVICE_TYPE_REMOTE_CAST,
78 DEVICE_TYPE_USB_DEVICE,
79 DEVICE_TYPE_ACCESSORY,
80 DEVICE_TYPE_REMOTE_DAUDIO,
81 DEVICE_TYPE_HDMI,
82 DEVICE_TYPE_LINE_DIGITAL,
83 DEVICE_TYPE_NEARLINK,
84 DEVICE_TYPE_NEARLINK_IN,
85 DEVICE_TYPE_FILE_SINK,
86 DEVICE_TYPE_FILE_SOURCE,
87 DEVICE_TYPE_EXTERN_CABLE,
88 DEVICE_TYPE_DEFAULT,
89 DEVICE_TYPE_USB_ARM_HEADSET,
90 DEVICE_TYPE_MAX,
91 };
92
93 template<class T>
GetData()94 T GetData()
95 {
96 T object {};
97 size_t objectSize = sizeof(object);
98 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
99 return object;
100 }
101 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
102 if (ret != EOK) {
103 return {};
104 }
105 g_pos += objectSize;
106 return object;
107 }
108
109 template<class T>
GetArrLength(T & arr)110 uint32_t GetArrLength(T& arr)
111 {
112 if (arr == nullptr) {
113 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
114 return 0;
115 }
116 return sizeof(arr) / sizeof(arr[0]);
117 }
118
UpdateSpatializationStateFuzzTest()119 void UpdateSpatializationStateFuzzTest()
120 {
121 AudioSpatializationState spatializationState = {};
122 HPAE::HpaePolicyManager hpaePolicyManager;
123 hpaePolicyManager.GetInstance().UpdateSpatializationState(spatializationState);
124 }
125
UpdateSpatialDeviceTypeFuzzTest()126 void UpdateSpatialDeviceTypeFuzzTest()
127 {
128 HPAE::HpaePolicyManager hpaePolicyManager;
129 constexpr int32_t spatialDeviceTypeCount = static_cast<int32_t>(AudioSpatialDeviceType::EARPHONE_TYPE_OTHERS) + 1;
130 AudioSpatialDeviceType spatialDeviceType =
131 static_cast<AudioSpatialDeviceType>(GetData<uint8_t>() % spatialDeviceTypeCount);
132 hpaePolicyManager.GetInstance().UpdateSpatialDeviceType(spatialDeviceType);
133 }
134
SetSpatializationSceneTypeFuzzTest()135 void SetSpatializationSceneTypeFuzzTest()
136 {
137 HPAE::HpaePolicyManager hpaePolicyManager;
138 uint32_t audioSpatializationSceneTypeCount = GetData<uint32_t>() % AudioSpatializationSceneTypeVec.size();
139 AudioSpatializationSceneType spatializationSceneType =
140 AudioSpatializationSceneTypeVec[audioSpatializationSceneTypeCount];
141 hpaePolicyManager.GetInstance().SetSpatializationSceneType(spatializationSceneType);
142 }
143
EffectRotationUpdateFuzzTest()144 void EffectRotationUpdateFuzzTest()
145 {
146 HPAE::HpaePolicyManager hpaePolicyManager;
147 uint32_t rotationState = GetData<uint32_t>();
148 hpaePolicyManager.GetInstance().EffectRotationUpdate(rotationState);
149 }
150
SetEffectSystemVolumeFuzzTest()151 void SetEffectSystemVolumeFuzzTest()
152 {
153 HPAE::HpaePolicyManager hpaePolicyManager;
154 int32_t systemVolumeType = GetData<int32_t>();
155 float systemVolume = GetData<float>();
156 hpaePolicyManager.GetInstance().SetEffectSystemVolume(systemVolumeType, systemVolume);
157 }
158
SetAudioEffectPropertyFuzzTest()159 void SetAudioEffectPropertyFuzzTest()
160 {
161 HPAE::HpaePolicyManager hpaePolicyManager;
162 AudioEffectPropertyArrayV3 propertyArray;
163 hpaePolicyManager.GetInstance().SetAudioEffectProperty(propertyArray);
164 }
165
GetAudioEffectPropertyFuzzTest()166 void GetAudioEffectPropertyFuzzTest()
167 {
168 HPAE::HpaePolicyManager hpaePolicyManager;
169 AudioEffectPropertyArray propertyArray1;
170 hpaePolicyManager.GetInstance().GetAudioEffectProperty(propertyArray1);
171 }
172
SetInputDeviceFuzzTest()173 void SetInputDeviceFuzzTest()
174 {
175 HPAE::HpaePolicyManager hpaePolicyManager;
176 uint32_t captureId = GetData<uint32_t>();
177 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
178 DeviceType inputDevice = DeviceTypeVec[deviceTypeCount];
179 hpaePolicyManager.GetInstance().SetInputDevice(captureId, inputDevice, "Built_in_mic");
180 }
181
SetOutputDeviceFuzzTest()182 void SetOutputDeviceFuzzTest()
183 {
184 HPAE::HpaePolicyManager hpaePolicyManager;
185 uint32_t renderId = GetData<uint32_t>();
186 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
187 DeviceType outputDevice = DeviceTypeVec[deviceTypeCount];
188 hpaePolicyManager.GetInstance().SetOutputDevice(renderId, outputDevice);
189 }
190
SetVolumeInfoFuzzTest()191 void SetVolumeInfoFuzzTest()
192 {
193 HPAE::HpaePolicyManager hpaePolicyManager;
194 AudioVolumeType volumeType = static_cast<AudioVolumeType>(0);
195 float systemVolume = GetData<float>();
196 hpaePolicyManager.GetInstance().SetVolumeInfo(volumeType, systemVolume);
197 }
198
SetMicrophoneMuteInfoFuzzTest()199 void SetMicrophoneMuteInfoFuzzTest()
200 {
201 HPAE::HpaePolicyManager hpaePolicyManager;
202 bool isMute = GetData<uint32_t>() % NUM_2;
203 hpaePolicyManager.GetInstance().SetMicrophoneMuteInfo(isMute);
204 }
205
SetStreamVolumeInfoFuzzTest()206 void SetStreamVolumeInfoFuzzTest()
207 {
208 HPAE::HpaePolicyManager hpaePolicyManager;
209 uint32_t sessionId = GetData<uint32_t>();
210 float streamVol = GetData<float>();
211 hpaePolicyManager.GetInstance().SetStreamVolumeInfo(sessionId, streamVol);
212 }
213
SetAudioEnhancePropertyFuzzTest()214 void SetAudioEnhancePropertyFuzzTest()
215 {
216 HPAE::HpaePolicyManager hpaePolicyManager;
217 AudioEffectPropertyArrayV3 propertyArray2;
218 propertyArray2.property.push_back({"invalidEffect", "property1"});
219 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
220 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
221 hpaePolicyManager.GetInstance().SetAudioEnhanceProperty(propertyArray2, deviceType);
222 }
223
GetAudioEnhancePropertyFuzzTest()224 void GetAudioEnhancePropertyFuzzTest()
225 {
226 HPAE::HpaePolicyManager hpaePolicyManager;
227 AudioEffectPropertyArrayV3 propertyArray3;
228 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
229 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
230 hpaePolicyManager.GetInstance().GetAudioEnhanceProperty(propertyArray3, deviceType);
231 }
232
UpdateExtraSceneTypeFuzzTest()233 void UpdateExtraSceneTypeFuzzTest()
234 {
235 HPAE::HpaePolicyManager hpaePolicyManager;
236 std::string mainkey = "other_mainkey";
237 std::string subkey = "other_subkey";
238 std::string extraSceneType = "extra_scene";
239 hpaePolicyManager.GetInstance().UpdateExtraSceneType(mainkey, subkey, extraSceneType);
240 }
241
InitAudioEffectChainManagerFuzzTest()242 void InitAudioEffectChainManagerFuzzTest()
243 {
244 HPAE::HpaePolicyManager hpaePolicyManager;
245 std::vector<EffectChain> effectChains = {{"EFFECTCHAIN_SPK_MUSIC", {}, ""}, {"EFFECTCHAIN_BT_MUSIC", {}, ""}};
246 EffectChainManagerParam effectChainManagerParam;
247 std::vector<std::shared_ptr<AudioEffectLibEntry>> effectLibraryList;
248 hpaePolicyManager.GetInstance().InitAudioEffectChainManager(effectChains,
249 effectChainManagerParam, effectLibraryList);
250 }
251
SetOutputDeviceSinkFuzzTest()252 void SetOutputDeviceSinkFuzzTest()
253 {
254 HPAE::HpaePolicyManager hpaePolicyManager;
255 int32_t device = GetData<int32_t>();
256 std::string sinkName = "abc";
257 hpaePolicyManager.GetInstance().SetOutputDeviceSink(device, sinkName);
258 }
259
SetAbsVolumeStateToEffectFuzzTest()260 void SetAbsVolumeStateToEffectFuzzTest()
261 {
262 HPAE::HpaePolicyManager hpaePolicyManager;
263 bool absVolumeState = GetData<bool>();
264 hpaePolicyManager.GetInstance().SetAbsVolumeStateToEffect(absVolumeState);
265 }
266
InitHdiStateFuzzTest()267 void InitHdiStateFuzzTest()
268 {
269 HPAE::HpaePolicyManager hpaePolicyManager;
270 hpaePolicyManager.GetInstance().InitHdiState();
271 }
272
UpdateParamExtraFuzzTest()273 void UpdateParamExtraFuzzTest()
274 {
275 HPAE::HpaePolicyManager hpaePolicyManager;
276 std::string mainkey = "device_status";
277 std::string subkey = "update_audio_effect_type";
278 std::string value = "test";
279 hpaePolicyManager.GetInstance().UpdateParamExtra(mainkey, subkey, value);
280 }
281
InitAudioEnhanceChainManagerFuzzTest()282 void InitAudioEnhanceChainManagerFuzzTest()
283 {
284 HPAE::HpaePolicyManager hpaePolicyManager;
285 std::vector<EffectChain> enhanceChains = {{"EFFECTCHAIN_SPK_MUSIC", {}, ""}, {"EFFECTCHAIN_BT_MUSIC", {}, ""}};
286 EffectChainManagerParam managerParam;
287 std::vector<std::shared_ptr<AudioEffectLibEntry>> enhanceLibraryList;
288 hpaePolicyManager.GetInstance().InitAudioEnhanceChainManager(enhanceChains, managerParam, enhanceLibraryList);
289 }
290
SetAudioParameterFuzzTest()291 void SetAudioParameterFuzzTest()
292 {
293 HPAE::HpaePolicyManager hpaePolicyManager;
294 std::string adapterName = "abc";
295 AudioParamKey key = GetData<AudioParamKey>();
296 std::string condition = "123456";
297 std::string value = "123456";
298 hpaePolicyManager.GetInstance().SetAudioParameter(adapterName, key, condition, value);
299 }
300
301 TestFuncs g_testFuncs[TESTSIZE] = {
302 UpdateSpatializationStateFuzzTest,
303 UpdateSpatialDeviceTypeFuzzTest,
304 SetSpatializationSceneTypeFuzzTest,
305 EffectRotationUpdateFuzzTest,
306 SetEffectSystemVolumeFuzzTest,
307 SetAudioEffectPropertyFuzzTest,
308 GetAudioEffectPropertyFuzzTest,
309 SetInputDeviceFuzzTest,
310 SetOutputDeviceFuzzTest,
311 SetVolumeInfoFuzzTest,
312 SetMicrophoneMuteInfoFuzzTest,
313 SetStreamVolumeInfoFuzzTest,
314 SetAudioEnhancePropertyFuzzTest,
315 GetAudioEnhancePropertyFuzzTest,
316 UpdateExtraSceneTypeFuzzTest,
317 InitAudioEffectChainManagerFuzzTest,
318 SetOutputDeviceSinkFuzzTest,
319 SetAbsVolumeStateToEffectFuzzTest,
320 InitHdiStateFuzzTest,
321 UpdateParamExtraFuzzTest,
322 InitAudioEnhanceChainManagerFuzzTest,
323 SetAudioParameterFuzzTest,
324 };
325
FuzzTest(const uint8_t * rawData,size_t size)326 bool FuzzTest(const uint8_t* rawData, size_t size)
327 {
328 if (rawData == nullptr) {
329 return false;
330 }
331
332 // initialize data
333 RAW_DATA = rawData;
334 g_dataSize = size;
335 g_pos = 0;
336
337 uint32_t code = GetData<uint32_t>();
338 uint32_t len = GetArrLength(g_testFuncs);
339 if (len > 0) {
340 g_testFuncs[code % len]();
341 } else {
342 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
343 }
344
345 return true;
346 }
347 } // namespace AudioStandard
348 } // namesapce OHOS
349
350 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)351 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
352 {
353 if (size < OHOS::AudioStandard::THRESHOLD) {
354 return 0;
355 }
356
357 OHOS::AudioStandard::FuzzTest(data, size);
358 return 0;
359 }
360