1 /*
2 * Copyright (c) 2024 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 "audio_info.h"
20 #include "audio_policy_server.h"
21 #include "audio_policy_service.h"
22 #include "audio_hdiadapter_info.h"
23 #include "audio_device_info.h"
24 #include "i_audio_device_manager.h"
25 #include "audio_device_manager_impl.h"
26 #include "audio_device_adapter_impl.h"
27
28 namespace OHOS {
29 namespace AudioStandard {
30 using namespace std;
31 const uint32_t ENUMSIZE = 4;
32 const string DEFAULTNAME = "DEFAULT";
33 static const uint8_t *RAW_DATA = nullptr;
34 static size_t g_dataSize = 0;
35 static size_t g_pos;
36 const size_t THRESHOLD = 10;
37
38 /*
39 * describe: get data from outside untrusted data(RAW_DATA) which size is according to sizeof(T)
40 * tips: only support basic type
41 */
42 template<class T>
GetData()43 T GetData()
44 {
45 T object {};
46 size_t objectSize = sizeof(object);
47 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
48 return object;
49 }
50 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
51 if (ret != EOK) {
52 return {};
53 }
54 g_pos += objectSize;
55 return object;
56 }
57
58 template<class T>
GetArrLength(T & arr)59 uint32_t GetArrLength(T& arr)
60 {
61 if (arr == nullptr) {
62 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
63 return 0;
64 }
65 return sizeof(arr) / sizeof(arr[0]);
66 }
67
AudioDeviceManagerFactoryFuzzTest()68 void AudioDeviceManagerFactoryFuzzTest()
69 {
70 AudioDeviceManagerFactory &audioDeviceManagerFactory = AudioDeviceManagerFactory::GetInstance();
71 uint32_t audioDeviceManagerTypeInt = GetData<uint32_t>();
72 audioDeviceManagerTypeInt = audioDeviceManagerTypeInt % ENUMSIZE;
73 AudioDeviceManagerType audioDeviceManagerType = static_cast<AudioDeviceManagerType>(audioDeviceManagerTypeInt);
74 audioDeviceManagerFactory.CreatDeviceManager(audioDeviceManagerType);
75 audioDeviceManagerFactory.DestoryDeviceManager(audioDeviceManagerType);
76 }
77
AudioDeviceManagerImlFuzzTest()78 void AudioDeviceManagerImlFuzzTest()
79 {
80 shared_ptr<AudioDeviceManagerImpl> audioDeviceManagerIml = nullptr;
81 uint32_t audioDeviceManagerTypeInt = GetData<uint32_t>();
82 audioDeviceManagerTypeInt = audioDeviceManagerTypeInt % ENUMSIZE;
83 AudioDeviceManagerType audioDeviceManagerType = static_cast<AudioDeviceManagerType>(audioDeviceManagerTypeInt);
84 #ifdef FEATURE_DISTRIBUTE_AUDIO
85 sptr<IAudioManager> audioMgr = IAudioManager::Get("daudio_primary_service", false);
86 #else
87 sptr<IAudioManager> audioMgr = nullptr;
88 #endif // FEATURE_DISTRIBUTE_AUDIO
89 audioDeviceManagerIml = make_shared<AudioDeviceManagerImpl>(audioDeviceManagerType, audioMgr);
90 if (audioDeviceManagerIml == nullptr) {
91 return;
92 }
93 audioDeviceManagerIml->GetAllAdapters();
94 bool isMmap = GetData<bool>();
95 const string adapterName = "";
96 audioDeviceManagerIml->LoadAdapters(adapterName, isMmap);
97 audioDeviceManagerIml->UnloadAdapter(adapterName);
98 audioDeviceManagerIml->LoadAdapters(DEFAULTNAME, isMmap);
99 audioDeviceManagerIml->UnloadAdapter(DEFAULTNAME);
100 audioDeviceManagerIml->Release();
101 struct AudioAdapterDescriptor *desc = audioDeviceManagerIml->GetTargetAdapterDesc(DEFAULTNAME, isMmap);
102 if (desc == nullptr || audioMgr == nullptr) {
103 return;
104 }
105 AudioAdapterDescriptor descriptor = {
106 .adapterName = desc->adapterName,
107 };
108 sptr<IAudioAdapter> audioAdapter = nullptr;
109 audioMgr->LoadAdapter(descriptor, audioAdapter);
110
111 auto audioDevAdp = std::make_shared<AudioDeviceAdapterImpl>(std::string(desc->adapterName), audioAdapter);
112 audioDevAdp->SetParamCallback(audioDevAdp);
113 audioDevAdp = AudioDeviceAdapterImpl::GetParamCallback();
114 audioDevAdp->Init();
115 audioDevAdp->RegExtraParamObserver();
116 AudioParamKey audioParamKey = GetData<AudioParamKey>();
117 const string condition = "";
118 const string value = "";
119 audioDevAdp->SetAudioParameter(audioParamKey, condition, value);
120 audioDevAdp->GetAudioParameter(audioParamKey, condition);
121 audioDevAdp->Release();
122 }
123
124 typedef void (*TestFuncs[2])();
125
126 TestFuncs g_testFuncs = {
127 AudioDeviceManagerFactoryFuzzTest,
128 AudioDeviceManagerImlFuzzTest,
129 };
130
FuzzTest(const uint8_t * rawData,size_t size)131 bool FuzzTest(const uint8_t* rawData, size_t size)
132 {
133 if (rawData == nullptr) {
134 return false;
135 }
136
137 // initialize data
138 RAW_DATA = rawData;
139 g_dataSize = size;
140 g_pos = 0;
141
142 uint32_t code = GetData<uint32_t>();
143 uint32_t len = GetArrLength(g_testFuncs);
144 if (len > 0) {
145 g_testFuncs[code % len]();
146 } else {
147 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
148 }
149
150 return true;
151 }
152 } // namespace AudioStandard
153 } // namesapce OHOS
154
155 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)156 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
157 {
158 if (size < OHOS::AudioStandard::THRESHOLD) {
159 return 0;
160 }
161
162 OHOS::AudioStandard::FuzzTest(data, size);
163 return 0;
164 }
165