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 #include "audio_policy_state_monitor.h"
42 #include "audio_device_info.h"
43
44 namespace OHOS {
45 namespace AudioStandard {
46 using namespace std;
47
48 static const uint8_t* RAW_DATA = nullptr;
49 static size_t g_dataSize = 0;
50 static size_t g_pos;
51 const size_t THRESHOLD = 10;
52 const uint8_t TESTSIZE = 8;
53 static int32_t NUM_2 = 2;
54
55 typedef void (*TestFuncs)();
56
57 vector<AudioSamplingRate> AudioSamplingRateVec = {
58 SAMPLE_RATE_8000,
59 SAMPLE_RATE_11025,
60 SAMPLE_RATE_12000,
61 SAMPLE_RATE_16000,
62 SAMPLE_RATE_22050,
63 SAMPLE_RATE_24000,
64 SAMPLE_RATE_32000,
65 SAMPLE_RATE_44100,
66 SAMPLE_RATE_48000,
67 SAMPLE_RATE_64000,
68 SAMPLE_RATE_88200,
69 SAMPLE_RATE_96000,
70 SAMPLE_RATE_176400,
71 SAMPLE_RATE_192000,
72 };
73
74 vector<AudioSampleFormat> AudioSampleFormatVec = {
75 SAMPLE_U8,
76 SAMPLE_S16LE,
77 SAMPLE_S24LE,
78 SAMPLE_S32LE,
79 SAMPLE_F32LE,
80 INVALID_WIDTH,
81 };
82
83 template<class T>
GetData()84 T GetData()
85 {
86 T object {};
87 size_t objectSize = sizeof(object);
88 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
89 return object;
90 }
91 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
92 if (ret != EOK) {
93 return {};
94 }
95 g_pos += objectSize;
96 return object;
97 }
98
99 template<class T>
GetArrLength(T & arr)100 uint32_t GetArrLength(T& arr)
101 {
102 if (arr == nullptr) {
103 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
104 return 0;
105 }
106 return sizeof(arr) / sizeof(arr[0]);
107 }
108
GetA2dpDeviceInfoFuzzTest()109 void GetA2dpDeviceInfoFuzzTest()
110 {
111 uint32_t samplingRateCount = GetData<uint32_t>() % AudioSamplingRateVec.size();
112 AudioSamplingRate samplingRate = AudioSamplingRateVec[samplingRateCount];
113 int32_t encodingCount =
114 static_cast<int32_t>(AudioEncodingType::ENCODING_EAC3 - AudioEncodingType::ENCODING_INVALID) + 1;
115 AudioEncodingType encoding = static_cast<AudioEncodingType>(GetData<int32_t>() % encodingCount - 1);
116 uint32_t formatCount = GetData<uint32_t>() % AudioSampleFormatVec.size();
117 AudioSampleFormat format = AudioSampleFormatVec[formatCount];
118 int32_t channelsCount = static_cast<int32_t>(AudioChannel::CHANNEL_16) + 1;
119 AudioChannel channels = static_cast<AudioChannel>(GetData<int32_t>() % channelsCount);
120 DeviceStreamInfo streamInfo(samplingRate, encoding, format, channels);
121 A2dpDeviceConfigInfo configInfo;
122 configInfo.streamInfo = streamInfo;
123 configInfo.absVolumeSupport = GetData<uint32_t>() % NUM_2;
124 configInfo.volumeLevel = GetData<int32_t>();
125 configInfo.mute = GetData<uint32_t>() % NUM_2;
126 string device = "test_device";
127 AudioA2dpDevice::GetInstance().AddA2dpDevice(device, configInfo);
128 A2dpDeviceConfigInfo info;
129 AudioA2dpDevice::GetInstance().GetA2dpDeviceInfo(device, info);
130 AudioA2dpDevice::GetInstance().DelA2dpDevice(device);
131 }
132
GetA2dpInDeviceInfoFuzzTest()133 void GetA2dpInDeviceInfoFuzzTest()
134 {
135 uint32_t samplingRateCount = GetData<uint32_t>() % AudioSamplingRateVec.size();
136 AudioSamplingRate samplingRate = AudioSamplingRateVec[samplingRateCount];
137 int32_t encodingCount =
138 static_cast<int32_t>(AudioEncodingType::ENCODING_EAC3 - AudioEncodingType::ENCODING_INVALID) + 1;
139 AudioEncodingType encoding = static_cast<AudioEncodingType>(GetData<int32_t>() % encodingCount - 1);
140 uint32_t formatCount = GetData<uint32_t>() % AudioSampleFormatVec.size();
141 AudioSampleFormat format = AudioSampleFormatVec[formatCount];
142 int32_t channelsCount = static_cast<int32_t>(AudioChannel::CHANNEL_16) + 1;
143 AudioChannel channels = static_cast<AudioChannel>(GetData<int32_t>() % channelsCount);
144 DeviceStreamInfo streamInfo(samplingRate, encoding, format, channels);
145 A2dpDeviceConfigInfo configInfo;
146 configInfo.streamInfo = streamInfo;
147 configInfo.absVolumeSupport = GetData<uint32_t>() % NUM_2;
148 configInfo.volumeLevel = GetData<int32_t>();
149 configInfo.mute = GetData<uint32_t>() % NUM_2;
150 std::string device = "test_device";
151 AudioA2dpDevice::GetInstance().AddA2dpInDevice(device, configInfo);
152 A2dpDeviceConfigInfo info;
153 AudioA2dpDevice::GetInstance().GetA2dpInDeviceInfo(device, info);
154 AudioA2dpDevice::GetInstance().DelA2dpInDevice(device);
155 }
156
GetA2dpDeviceVolumeLevelFuzzTest()157 void GetA2dpDeviceVolumeLevelFuzzTest()
158 {
159 A2dpDeviceConfigInfo configInfo;
160 configInfo.volumeLevel = GetData<int32_t>();
161 std::string device = "test_device";
162 AudioA2dpDevice::GetInstance().AddA2dpDevice(device, configInfo);
163 int32_t volumeLevel;
164 AudioA2dpDevice::GetInstance().GetA2dpDeviceVolumeLevel(device, volumeLevel);
165 string nonDevice = "non_existent_device";
166 int32_t volumeLeve2;
167 AudioA2dpDevice::GetInstance().GetA2dpDeviceVolumeLevel(nonDevice, volumeLeve2);
168 }
169
CheckA2dpDeviceExistFuzzTest()170 void CheckA2dpDeviceExistFuzzTest()
171 {
172 A2dpDeviceConfigInfo configInfo;
173 std::string device = "test_device";
174 AudioA2dpDevice::GetInstance().AddA2dpDevice(device, configInfo);
175 AudioA2dpDevice::GetInstance().CheckA2dpDeviceExist(device);
176 AudioA2dpDevice::GetInstance().DelA2dpDevice(device);
177 }
178
SetA2dpDeviceMuteFuzzTest()179 void SetA2dpDeviceMuteFuzzTest()
180 {
181 A2dpDeviceConfigInfo configInfo;
182 configInfo.absVolumeSupport = GetData<uint32_t>() % NUM_2;
183 std::string device = "test_device";
184 AudioA2dpDevice::GetInstance().AddA2dpDevice(device, configInfo);
185 AudioA2dpDevice::GetInstance().SetA2dpDeviceMute(device, GetData<uint32_t>() % NUM_2);
186 A2dpDeviceConfigInfo info;
187 AudioA2dpDevice::GetInstance().GetA2dpDeviceInfo(device, info);
188 AudioA2dpDevice::GetInstance().DelA2dpDevice(device);
189 }
190
GetA2dpDeviceMuteFuzzTest()191 void GetA2dpDeviceMuteFuzzTest()
192 {
193 A2dpDeviceConfigInfo configInfo;
194 configInfo.absVolumeSupport = GetData<uint32_t>() % NUM_2;
195 configInfo.mute = GetData<uint32_t>() % NUM_2;
196 std::string device = "test_device";
197 AudioA2dpDevice::GetInstance().AddA2dpDevice(device, configInfo);
198 bool isMute = GetData<uint32_t>() % NUM_2;
199 AudioA2dpDevice::GetInstance().GetA2dpDeviceMute(device, isMute);
200 AudioA2dpDevice::GetInstance().DelA2dpDevice(device);
201 }
202
SetA2dpDeviceAbsVolumeSupportFuzzTest()203 void SetA2dpDeviceAbsVolumeSupportFuzzTest()
204 {
205 A2dpDeviceConfigInfo configInfo;
206 configInfo.absVolumeSupport = GetData<uint32_t>() % NUM_2;
207 std::string device = "test_device";
208 AudioA2dpDevice::GetInstance().AddA2dpDevice(device, configInfo);
209 bool support = GetData<uint32_t>() % NUM_2;
210 int32_t volume = GetData<int32_t>();
211 bool mute = GetData<uint32_t>() % NUM_2;
212 AudioA2dpDevice::GetInstance().SetA2dpDeviceAbsVolumeSupport(device, support, volume, mute);
213 A2dpDeviceConfigInfo info;
214 AudioA2dpDevice::GetInstance().GetA2dpDeviceInfo(device, info);
215 AudioA2dpDevice::GetInstance().DelA2dpDevice(device);
216 }
217
SetA2dpDeviceVolumeLevelFuzzTest()218 void SetA2dpDeviceVolumeLevelFuzzTest()
219 {
220 A2dpDeviceConfigInfo configInfo;
221 configInfo.absVolumeSupport = GetData<uint32_t>() % NUM_2;
222 std::string device = "test_device";
223 AudioA2dpDevice::GetInstance().AddA2dpDevice(device, configInfo);
224 int32_t volumeLevel = GetData<int32_t>();
225 bool result = AudioA2dpDevice::GetInstance().SetA2dpDeviceVolumeLevel(device, volumeLevel);
226 A2dpDeviceConfigInfo info;
227 bool getInfoResult = AudioA2dpDevice::GetInstance().GetA2dpDeviceInfo(device, info);
228 AudioA2dpDevice::GetInstance().DelA2dpDevice(device);
229 }
230
231 TestFuncs g_testFuncs[TESTSIZE] = {
232 GetA2dpDeviceInfoFuzzTest,
233 GetA2dpInDeviceInfoFuzzTest,
234 GetA2dpDeviceVolumeLevelFuzzTest,
235 CheckA2dpDeviceExistFuzzTest,
236 SetA2dpDeviceMuteFuzzTest,
237 GetA2dpDeviceMuteFuzzTest,
238 SetA2dpDeviceAbsVolumeSupportFuzzTest,
239 SetA2dpDeviceVolumeLevelFuzzTest,
240 };
241
FuzzTest(const uint8_t * rawData,size_t size)242 bool FuzzTest(const uint8_t* rawData, size_t size)
243 {
244 if (rawData == nullptr) {
245 return false;
246 }
247
248 // initialize data
249 RAW_DATA = rawData;
250 g_dataSize = size;
251 g_pos = 0;
252
253 uint32_t code = GetData<uint32_t>();
254 uint32_t len = GetArrLength(g_testFuncs);
255 if (len > 0) {
256 g_testFuncs[code % len]();
257 } else {
258 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
259 }
260
261 return true;
262 }
263 } // namespace AudioStandard
264 } // namesapce OHOS
265
266 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)267 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
268 {
269 if (size < OHOS::AudioStandard::THRESHOLD) {
270 return 0;
271 }
272
273 OHOS::AudioStandard::FuzzTest(data, size);
274 return 0;
275 }
276