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 "avsessionadapter_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #include <iostream>
21 #include <memory>
22 #include <fuzzer/FuzzedDataProvider.h>
23
24 #include "audio_adapter.h"
25 #include "avsession_users_manager.h"
26 #include "collaboration_manager.h"
27 #include "securec.h"
28
29 namespace OHOS {
30 namespace AVSession {
31 using namespace std;
32 static const int32_t MAX_CODE_LEN = 20;
33 static const int32_t MIN_SIZE_NUM = 10;
34 static const uint8_t *RAW_DATA = nullptr;
35 static size_t g_totalSize = 0;
36 static size_t g_sizePos;
37
38 /*
39 * describe: get data from FUZZ 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_totalSize - g_sizePos) {
48 return object;
49 }
50 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_sizePos, objectSize);
51 if (ret != EOK) {
52 return {};
53 }
54 g_sizePos += objectSize;
55 return object;
56 }
57
GetString()58 std::string GetString()
59 {
60 size_t objectSize = (GetData<int8_t>() % MAX_CODE_LEN) + 1;
61 if (RAW_DATA == nullptr || objectSize > g_totalSize - g_sizePos) {
62 return "OVER_SIZE";
63 }
64 char object[objectSize + 1];
65 errno_t ret = memcpy_s(object, sizeof(object), RAW_DATA + g_sizePos, objectSize);
66 if (ret != EOK) {
67 return "";
68 }
69 g_sizePos += objectSize;
70 std::string output(object);
71 return output;
72 }
73
74 template<class T>
GetArrLength(T & arr)75 uint32_t GetArrLength(T& arr)
76 {
77 if (arr == nullptr) {
78 SLOGE("%{public}s: The array length is equal to 0", __func__);
79 return 0;
80 }
81 return sizeof(arr) / sizeof(arr[0]);
82 }
83
84 typedef void (*TestFuncs[4])();
85
86 TestFuncs g_allFuncs = {
87 AVSessionUsersManagerTest,
88 AVSessionAudioAdapterTest,
89 CollaborationManagerTest,
90 PluginLibTest,
91 };
92
FuzzTest(const uint8_t * rawData,size_t size)93 bool FuzzTest(const uint8_t* rawData, size_t size)
94 {
95 if (rawData == nullptr) {
96 return false;
97 }
98
99 // initialize data
100 RAW_DATA = rawData;
101 g_totalSize = size;
102 g_sizePos = 0;
103
104 uint32_t code = GetData<uint32_t>();
105 uint32_t len = GetArrLength(g_allFuncs);
106 if (len > 0) {
107 g_allFuncs[code % len]();
108 } else {
109 SLOGE("%{public}s: The len length is equal to 0", __func__);
110 }
111
112 return true;
113 }
114
AVSessionUsersManagerTest()115 void AVSessionUsersManagerTest()
116 {
117 FuzzedDataProvider provider(RAW_DATA, g_totalSize);
118
119 int32_t userId = provider.ConsumeIntegral<int32_t>();
120
121 auto &usersManager = AVSessionUsersManager::GetInstance();
122 usersManager.Init();
123 usersManager.GetContainerFromUser(userId);
124 usersManager.HandleUserRemoved(userId);
125 usersManager.GetContainer();
126 usersManager.GetContainerFromAll();
127 usersManager.GetCurSessionListForFront(userId);
128 usersManager.GetCurSessionListForKeyEvent(userId);
129 usersManager.GetCurrentUserId();
130 usersManager.GetDirForCurrentUser(userId);
131
132 pid_t pid = provider.ConsumeIntegral<pid_t>();
133 std::string abilityName = provider.ConsumeRandomLengthString();
134 sptr<AVSessionItem> item;
135 usersManager.AddSessionForCurrentUser(pid, abilityName, item);
136 usersManager.RemoveSessionForAllUser(pid, abilityName);
137
138 std::string sessionId = provider.ConsumeRandomLengthString();
139 usersManager.RemoveSessionForAllUser(sessionId);
140 usersManager.RemoveSessionForAllUser(pid);
141
142 sptr<ISessionListener> listener;
143 usersManager.AddSessionListener(pid, listener);
144 usersManager.AddSessionListenerForAllUsers(pid, listener);
145 usersManager.RemoveSessionListener(pid);
146 usersManager.GetSessionListener(userId);
147 usersManager.GetSessionListenerForAllUsers();
148
149 std::string type = provider.ConsumeRandomLengthString();
150 usersManager.NotifyAccountsEvent(type, userId);
151 sptr<AVSessionItem> session;
152 usersManager.SetTopSession(session);
153 usersManager.SetTopSession(session, userId);
154 usersManager.GetTopSession();
155 usersManager.GetTopSession(userId);
156 usersManager.ClearCache();
157 }
158
AVSessionAudioAdapterTest()159 void AVSessionAudioAdapterTest()
160 {
161 AudioAdapter audioAdapter;
162 audioAdapter.is2in1_ = GetData<bool>();
163
164 audioAdapter.MuteAudioStream(GetData<int32_t>(), GetData<int32_t>());
165 audioAdapter.UnMuteAudioStream(GetData<int32_t>());
166 audioAdapter.UnMuteAudioStream(GetData<int32_t>(), static_cast<AudioStandard::StreamUsage>(GetData<int32_t>()));
167 audioAdapter.MuteAudioStream(GetData<int32_t>(), static_cast<AudioStandard::StreamUsage>(GetData<int32_t>()));
168
169 DeviceChangeAction deviceChangeAction;
170 audioAdapter.OnDeviceChange(deviceChangeAction);
171 audioAdapter.deviceChangeListeners_ =
172 std::vector<OHOS::AVSession::AudioAdapter::PreferOutputDeviceChangeListener>();
173 AudioDeviceDescriptors deviceDescriptors;
174 audioAdapter.OnPreferredOutputDeviceUpdated(deviceDescriptors);
175
176 audioAdapter.SetVolume(GetData<int32_t>());
177 audioAdapter.GetVolume();
178 audioAdapter.RegisterVolumeKeyEventCallback([](int32_t)->void {});
179 audioAdapter.UnregisterVolumeKeyEventCallback();
180 audioAdapter.GetAvailableDevices();
181 audioAdapter.UnsetAvailableDeviceChangeCallback();
182 audioAdapter.GetDevices();
183 audioAdapter.GetPreferredOutputDeviceForRendererInfo();
184 audioAdapter.UnsetPreferredOutputDeviceChangeCallback();
185 AudioDeviceDescriptorWithSptr desc;
186 audioAdapter.FindRenderDeviceForUsage(deviceDescriptors, desc);
187 }
188
CollaborationManagerTest()189 void CollaborationManagerTest()
190 {
191 CollaborationManager::GetInstance().SendCollaborationOnStop([]()->void {});
192 CollaborationManager::GetInstance().SendCollaborationApplyResult([](int32_t)->void {});
193 }
194
PluginLibTest()195 void PluginLibTest()
196 {
197 auto pluginLib = std::make_shared<PluginLib>(GetString());
198 pluginLib->LogDlfcnErr(GetString());
199 }
200
201 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)202 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
203 {
204 if (size < MIN_SIZE_NUM) {
205 return 0;
206 }
207 /* Run your code on data */
208 FuzzTest(data, size);
209 return 0;
210 }
211 } // namespace AVSession
212 } // namespace OHOS
213