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
36 namespace OHOS {
37 namespace AudioStandard {
38 using namespace std;
39
40 static const uint8_t* RAW_DATA = nullptr;
41 static size_t g_dataSize = 0;
42 static size_t g_pos;
43 const size_t THRESHOLD = 10;
44 const uint8_t TESTSIZE = 6;
45 const int32_t NUM_1 = 1;
46 const uint32_t IDNUM = 100;
47 constexpr int32_t AUDIO_MODE_COUNT = static_cast<int32_t>(AudioMode::AUDIO_MODE_RECORD) + NUM_1;
48 constexpr int32_t AUDIO_FLAG_COUNT = static_cast<int32_t>(AudioFlag::AUDIO_FLAG_MAX) + NUM_1;
49
50 typedef void (*TestFuncs)();
51
52 template<class T>
GetData()53 T GetData()
54 {
55 T object {};
56 size_t objectSize = sizeof(object);
57 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
58 return object;
59 }
60 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
61 if (ret != EOK) {
62 return {};
63 }
64 g_pos += objectSize;
65 return object;
66 }
67
68 template<class T>
GetArrLength(T & arr)69 uint32_t GetArrLength(T& arr)
70 {
71 if (arr == nullptr) {
72 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
73 return 0;
74 }
75 return sizeof(arr) / sizeof(arr[0]);
76 }
77
GetPipeTypeFuzzTest()78 void GetPipeTypeFuzzTest()
79 {
80 AudioMode selectedAudioMode = static_cast<AudioMode>(GetData<int32_t>() % AUDIO_MODE_COUNT);
81 uint32_t selectedFlag = static_cast<uint32_t>(GetData<int32_t>() % AUDIO_FLAG_COUNT);
82 AudioPipeSelector::GetPipeSelector()->GetPipeType(selectedFlag, selectedAudioMode);
83 }
84
GetAdapterNameByStreamDescFuzzTest()85 void GetAdapterNameByStreamDescFuzzTest()
86 {
87 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
88 streamDesc->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
89 streamDesc->newDeviceDescs_.front()->deviceType_ = DEVICE_TYPE_SPEAKER;
90 streamDesc->newDeviceDescs_.front()->networkId_ = "0";
91 streamDesc->streamInfo_.format = AudioSampleFormat::SAMPLE_S16LE;
92 streamDesc->streamInfo_.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
93 streamDesc->streamInfo_.channels = AudioChannel::STEREO;
94
95 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
96 std::string result = audioPipeSelector->GetAdapterNameByStreamDesc(streamDesc);
97 }
98
ConvertStreamDescToPipeInfoFuzzTest()99 void ConvertStreamDescToPipeInfoFuzzTest()
100 {
101 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
102 streamDesc->routeFlag_ = 1;
103 streamDesc->sessionId_ = GetData<uint32_t>();
104 streamDesc->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
105 streamDesc->newDeviceDescs_.front()->deviceType_ = DEVICE_TYPE_SPEAKER;
106 streamDesc->newDeviceDescs_.front()->networkId_ = "0";
107 streamDesc->capturerInfo_.sourceType = SourceType::SOURCE_TYPE_MIC;
108
109 std::shared_ptr<PipeStreamPropInfo> streamPropInfo = std::make_shared<PipeStreamPropInfo>();
110 streamPropInfo->format_ = AudioSampleFormat::SAMPLE_S16LE;
111 streamPropInfo->sampleRate_ = GetData<uint32_t>();
112 streamPropInfo->channelLayout_ = AudioChannelLayout::CH_LAYOUT_STEREO;
113 streamPropInfo->bufferSize_ = GetData<uint32_t>();
114
115 std::shared_ptr<AdapterPipeInfo> pipeInfoPtr = std::make_shared<AdapterPipeInfo>();
116 pipeInfoPtr->paProp_.lib_ = "test_lib";
117 pipeInfoPtr->paProp_.role_ = "test_role";
118 pipeInfoPtr->paProp_.moduleName_ = "test_module";
119 pipeInfoPtr->name_ = "test_name";
120 pipeInfoPtr->role_ = PIPE_ROLE_OUTPUT;
121
122 std::shared_ptr<PolicyAdapterInfo> adapterInfoPtr = std::make_shared<PolicyAdapterInfo>();
123 adapterInfoPtr->adapterName = "test_adapter";
124
125 pipeInfoPtr->adapterInfo_ = adapterInfoPtr;
126 streamPropInfo->pipeInfo_ = pipeInfoPtr;
127
128 AudioPipeInfo info;
129 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
130 audioPipeSelector->ConvertStreamDescToPipeInfo(streamDesc, streamPropInfo, info);
131 }
132
JudgeStreamActionFuzzTest()133 void JudgeStreamActionFuzzTest()
134 {
135 std::shared_ptr<AudioPipeInfo> newPipe = std::make_shared<AudioPipeInfo>();
136 uint8_t newRandomNum = GetData<uint8_t>();
137 std::vector<std::string> testStrings = {"test_adapter", "new_adapter", "old_adapter"};
138 std::string newAdapterName(testStrings[newRandomNum % testStrings.size()]);
139 newPipe->adapterName_ = newAdapterName;
140 AudioFlag newAudioFlag = static_cast<AudioFlag>(GetData<uint8_t>() % AUDIO_FLAG_COUNT);
141 newPipe->routeFlag_ = newAudioFlag;
142
143 std::shared_ptr<AudioPipeInfo> oldPipe = std::make_shared<AudioPipeInfo>();
144 uint8_t oldRandomNum = GetData<uint8_t>();
145 std::string oldAdapterName(testStrings[oldRandomNum % testStrings.size()]);
146 oldPipe->adapterName_ = oldAdapterName;
147 AudioFlag oldAudioFlag = static_cast<AudioFlag>(GetData<uint8_t>() % AUDIO_FLAG_COUNT);
148 oldPipe->routeFlag_ = oldAudioFlag;
149
150 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
151 AudioStreamAction result = audioPipeSelector->JudgeStreamAction(newPipe, oldPipe);
152 }
153
FetchPipeAndExecuteFuzzTest()154 void FetchPipeAndExecuteFuzzTest()
155 {
156 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
157 streamDesc->routeFlag_ = AUDIO_FLAG_NONE;
158 streamDesc->audioMode_ = AUDIO_MODE_PLAYBACK;
159 streamDesc->newDeviceDescs_.push_back(std::make_shared<AudioDeviceDescriptor>());
160 streamDesc->newDeviceDescs_.front()->deviceType_ = DEVICE_TYPE_SPEAKER;
161 streamDesc->newDeviceDescs_.front()->networkId_ = "0";
162 streamDesc->streamInfo_.format = AudioSampleFormat::SAMPLE_S16LE;
163 streamDesc->streamInfo_.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
164 streamDesc->streamInfo_.channels = AudioChannel::STEREO;
165
166 std::vector<std::shared_ptr<AudioPipeInfo>> pipeInfoList;
167 std::shared_ptr<AudioPipeInfo> pipeInfo = std::make_shared<AudioPipeInfo>();
168 pipeInfo->pipeRole_ = PIPE_ROLE_OUTPUT;
169 pipeInfo->adapterName_ = "test_adapter";
170 pipeInfo->routeFlag_ = 1;
171 pipeInfoList.push_back(pipeInfo);
172 AudioPipeManager::GetPipeManager()->curPipeList_ = pipeInfoList;
173
174 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
175 std::vector<std::shared_ptr<AudioPipeInfo>> result = audioPipeSelector->FetchPipeAndExecute(streamDesc);
176 }
177
FetchPipesAndExecuteFuzzTest()178 void FetchPipesAndExecuteFuzzTest()
179 {
180 std::vector<std::shared_ptr<AudioStreamDescriptor>> streamDescs;
181 auto audioPipeSelector = AudioPipeSelector::GetPipeSelector();
182 audioPipeSelector->FetchPipesAndExecute(streamDescs);
183 }
184
185 TestFuncs g_testFuncs[TESTSIZE] = {
186 GetPipeTypeFuzzTest,
187 GetAdapterNameByStreamDescFuzzTest,
188 ConvertStreamDescToPipeInfoFuzzTest,
189 JudgeStreamActionFuzzTest,
190 FetchPipeAndExecuteFuzzTest,
191 FetchPipesAndExecuteFuzzTest,
192 };
193
FuzzTest(const uint8_t * rawData,size_t size)194 bool FuzzTest(const uint8_t* rawData, size_t size)
195 {
196 if (rawData == nullptr) {
197 return false;
198 }
199
200 // initialize data
201 RAW_DATA = rawData;
202 g_dataSize = size;
203 g_pos = 0;
204
205 uint32_t code = GetData<uint32_t>();
206 uint32_t len = GetArrLength(g_testFuncs);
207 if (len > 0) {
208 g_testFuncs[code % len]();
209 } else {
210 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
211 }
212
213 return true;
214 }
215 } // namespace AudioStandard
216 } // namesapce OHOS
217
218 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)219 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
220 {
221 if (size < OHOS::AudioStandard::THRESHOLD) {
222 return 0;
223 }
224
225 OHOS::AudioStandard::FuzzTest(data, size);
226 return 0;
227 }
228