1 /*
2 * Copyright (c) 2023 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 #include <cstddef>
16 #include <cstdint>
17 #define private public
18 #include "intell_voice_service_manager.h"
19 #include "intell_voice_manager.h"
20 #include "intell_voice_log.h"
21 #include "engine_base.h"
22 #include "i_intell_voice_engine.h"
23 #include "i_intell_voice_engine_callback.h"
24 #include "enroll_intell_voice_engine.h"
25 #include "wakeup_intell_voice_engine.h"
26 #include "base_macros.h"
27 #include "engine_host_manager.h"
28 #include "intell_voice_util.h"
29 #include "wakeup_engine_impl.h"
30 #include "history_info_mgr.h"
31 #include "headset_wakeup_engine_impl.h"
32 #include "intell_voice_definitions.h"
33
34 #define LOG_TAG "ServiceManagerFuzzer"
35 const int32_t LIMITSIZE = 4;
36
37 using namespace std;
38 using namespace OHOS::IntellVoiceEngine;
39 using namespace OHOS::IntellVoice;
40 using namespace OHOS::IntellVoiceUtils;
41
42 namespace OHOS {
43 namespace IntellVoiceTests {
IntellVoiceServiceManagerFuzzTest(const uint8_t * data,size_t size)44 void IntellVoiceServiceManagerFuzzTest(const uint8_t* data, size_t size)
45 {
46 if ((data == nullptr) || (size < LIMITSIZE)) {
47 return;
48 }
49 IntellVoiceManager::GetInstance();
50 INTELL_VOICE_LOG_ERROR("enter");
51 auto &manager = ServiceManagerType::GetInstance();
52 IntellVoiceEngineType type = *reinterpret_cast<const IntellVoiceEngineType *>(data);
53 manager.HandleCreateEngine(type);
54 manager.HandleReleaseEngine(type);
55 const sptr<IRemoteObject> object;
56 manager.HandleSilenceUpdate();
57 manager.HandleCloneUpdate(std::to_string(size), object);
58 manager.HandleSwitchOn(data, size, size);
59 manager.HandleSwitchOff(data, size);
60 manager.HandleCloseWakeupSource();
61 manager.HandleUnloadIntellVoiceService(data);
62 manager.HandleOnIdle();
63 manager.HandleServiceStop();
64 manager.HandleHeadsetHostDie();
65 manager.ProcBreathModel();
66 manager.CreateSwitchProvider();
67 manager.ReleaseSwitchProvider();
68 manager.StartDetection(size);
69 manager.StopDetection(size);
70 manager.QuerySwitchStatus(std::to_string(size));
71 manager.DeregisterProxyDeathRecipient(type);
72 std::vector<std::string> cloneFiles;
73 manager.GetWakeupSourceFilesList(cloneFiles);
74 std::vector<uint8_t> buffer;
75 manager.GetWakeupSourceFile(std::to_string(size), buffer);
76 manager.SendWakeupFile(std::to_string(size), buffer);
77 }
78
EnrollEngineFuzzTest(const uint8_t * data,size_t size)79 void EnrollEngineFuzzTest(const uint8_t* data, size_t size)
80 {
81 if ((data == nullptr) || (size < LIMITSIZE)) {
82 return;
83 }
84 INTELL_VOICE_LOG_ERROR("enter");
85 EngineHostManager::GetInstance().Init();
86 auto enrollEngine = ServiceManagerType::GetInstance().HandleCreateEngine(INTELL_VOICE_ENROLL);
87 if (enrollEngine == nullptr) {
88 INTELL_VOICE_LOG_ERROR("enrollEngine is nullptr");
89 return;
90 }
91 IntellVoiceEngineInfo info = {
92 .wakeupPhrase = std::to_string(size),
93 .isPcmFromExternal = data,
94 .minBufSize = size,
95 .sampleChannels = size,
96 .bitsPerSample = size,
97 .sampleRate = size,
98 };
99 enrollEngine->Attach(info);
100 enrollEngine->Start(data);
101 enrollEngine->SetParameter(std::to_string(size));
102 sptr<IRemoteObject> object;
103 enrollEngine->SetCallback(object);
104 enrollEngine->GetParameter(std::to_string(size));
105 enrollEngine->WriteAudio(data, size);
106 EvaluationResult infos;
107 enrollEngine->Evaluate(std::to_string(size), infos);
108 enrollEngine->Stop();
109 enrollEngine->Detach();
110 ServiceManagerType::GetInstance().HandleReleaseEngine(INTELL_VOICE_ENROLL);
111 }
112
WakeupEngineFuzzTest(const uint8_t * data,size_t size)113 void WakeupEngineFuzzTest(const uint8_t* data, size_t size)
114 {
115 if ((data == nullptr) || (size < LIMITSIZE)) {
116 return;
117 }
118 INTELL_VOICE_LOG_ERROR("enter");
119 EngineHostManager::GetInstance().Init();
120 auto wakeEngine = ServiceManagerType::GetInstance().HandleCreateEngine(INTELL_VOICE_WAKEUP);
121 if (wakeEngine == nullptr) {
122 INTELL_VOICE_LOG_ERROR("wakeEngine is nullptr");
123 return;
124 }
125 wakeEngine->SetParameter("CommitEnrollment=true");
126 sptr<IRemoteObject> object;
127 wakeEngine->SetCallback(object);
128 IntellVoiceEngineInfo info = {};
129 wakeEngine->Attach(info);
130 wakeEngine->Start(data);
131 wakeEngine->SetParameter(std::to_string(size));
132 wakeEngine->GetParameter(std::to_string(size));
133 std::vector<uint8_t> pcmData;
134 wakeEngine->GetWakeupPcm(pcmData);
135 wakeEngine->StartCapturer(size);
136 wakeEngine->Read(pcmData);
137 wakeEngine->StopCapturer();
138 wakeEngine->NotifyHeadsetWakeEvent();
139 wakeEngine->NotifyHeadsetHostEvent(*reinterpret_cast<const HeadsetHostEventType *>(data));
140 wakeEngine->Stop();
141 wakeEngine->Detach();
142
143 auto wakeupSourceProcess = std::make_shared<WakeupSourceProcess>();
144 wakeupSourceProcess->Init(size);
145 std::vector<std::vector<uint8_t>> audioData;
146 wakeupSourceProcess->Write(audioData);
147 std::vector<uint8_t> capturerData;
148 wakeupSourceProcess->Read(capturerData, size);
149 wakeupSourceProcess->Release();
150 ServiceManagerType::GetInstance().HandleReleaseEngine(INTELL_VOICE_WAKEUP);
151 }
152
UpdataEngineFuzzTest(const uint8_t * data,size_t size)153 void UpdataEngineFuzzTest(const uint8_t* data, size_t size)
154 {
155 if ((data == nullptr) || (size < LIMITSIZE)) {
156 return;
157 }
158 EngineHostManager::GetInstance().Init();
159 INTELL_VOICE_LOG_ERROR("enter");
160 auto updateEngine = ServiceManagerType::GetInstance().HandleCreateEngine(INTELL_VOICE_UPDATE);
161 if (updateEngine == nullptr) {
162 INTELL_VOICE_LOG_ERROR("updateEngine is nullptr");
163 return;
164 }
165 }
166
ServiceUtilsFuzzTest(const uint8_t * data,size_t size)167 void ServiceUtilsFuzzTest(const uint8_t* data, size_t size)
168 {
169 if ((data == nullptr) || (size < LIMITSIZE)) {
170 return;
171 }
172 INTELL_VOICE_LOG_ERROR("enter");
173 IntellVoiceUtil::VerifySystemPermission(std::to_string(size));
174 std::shared_ptr<uint8_t> buffer = nullptr;
175 uint32_t size1 = static_cast<uint32_t>(size);
176 IntellVoiceUtil::ReadFile(std::to_string(size), buffer, size1);
177 IntellVoiceUtil::GetHdiVersionId(size, size);
178 std::vector<std::vector<uint8_t>> audioData;
179 HistoryInfoMgr &historyInfoMgr = HistoryInfoMgr::GetInstance();
180 historyInfoMgr.SetIntKVPair(KEY_ENROLL_ENGINE_UID, size);
181 historyInfoMgr.GetIntKVPair(KEY_ENROLL_ENGINE_UID);
182 historyInfoMgr.SetStringKVPair(KEY_WAKEUP_ENGINE_BUNDLE_NAME, std::to_string(size));
183 historyInfoMgr.GetStringKVPair(KEY_WAKEUP_ENGINE_BUNDLE_NAME);
184 historyInfoMgr.SetStringKVPair(KEY_WAKEUP_ENGINE_ABILITY_NAME, std::to_string(size));
185 historyInfoMgr.GetStringKVPair(KEY_WAKEUP_ENGINE_ABILITY_NAME);
186 historyInfoMgr.SetStringKVPair(KEY_WAKEUP_VESRION, std::to_string(size));
187 historyInfoMgr.GetStringKVPair(KEY_WAKEUP_VESRION);
188 historyInfoMgr.SetStringKVPair(KEY_LANGUAGE, std::to_string(size));
189 historyInfoMgr.GetStringKVPair(KEY_LANGUAGE);
190 historyInfoMgr.SetStringKVPair(KEY_AREA, std::to_string(size));
191 historyInfoMgr.GetStringKVPair(KEY_AREA);
192 historyInfoMgr.SetStringKVPair(KEY_WAKEUP_PHRASE, std::to_string(size));
193 historyInfoMgr.GetStringKVPair(KEY_WAKEUP_PHRASE);
194 historyInfoMgr.SetStringKVPair(KEY_WAKEUP_DSP_FEATURE, std::to_string(size));
195 historyInfoMgr.GetStringKVPair(KEY_WAKEUP_DSP_FEATURE);
196 }
197
HdiAdapterFuzzTest(const uint8_t * data,size_t size)198 void HdiAdapterFuzzTest(const uint8_t* data, size_t size)
199 {
200 if ((data == nullptr) || (size < LIMITSIZE)) {
201 return;
202 }
203 INTELL_VOICE_LOG_ERROR("enter");
204 EngineHostManager::GetInstance().Init();
205 EngineHostManager::GetInstance().RegisterEngineHDIDeathRecipient();
206 EngineHostManager::GetInstance().DeregisterEngineHDIDeathRecipient();
207 EngineHostManager::GetInstance().SetDataOprCallback();
208 IntellVoiceEngineAdapterDescriptor desc;
209 EngineHostManager::GetInstance().CreateEngineAdapter(desc);
210 EngineHostManager::GetInstance().ReleaseEngineAdapter(desc);
211 std::vector<UploadHdiFile> files;
212 EngineHostManager::GetInstance().GetUploadFiles(size, files);
213 std::vector<std::string> cloneFiles;
214 EngineHostManager::GetInstance().GetWakeupSourceFilesList(cloneFiles);
215 std::vector<uint8_t> buffer;
216 EngineHostManager::GetInstance().GetWakeupSourceFile(std::to_string(size), buffer);
217 EngineHostManager::GetInstance().SendWakeupFile(std::to_string(size), buffer);
218 EngineHostManager::GetInstance().GetEngineHostProxy1_0();
219 EngineHostManager::GetInstance().GetEngineHostProxy1_1();
220 EngineHostManager::GetInstance().GetEngineHostProxy1_2();
221 }
222 } // namespace.OHOS
223 } // namespace.IntellVoiceTests
224
225 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)226 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
227 {
228 /* Run your code on data */
229 OHOS::IntellVoiceTests::IntellVoiceServiceManagerFuzzTest(data, size);
230 OHOS::IntellVoiceTests::EnrollEngineFuzzTest(data, size);
231 OHOS::IntellVoiceTests::WakeupEngineFuzzTest(data, size);
232 OHOS::IntellVoiceTests::UpdataEngineFuzzTest(data, size);
233 OHOS::IntellVoiceTests::ServiceUtilsFuzzTest(data, size);
234 OHOS::IntellVoiceTests::HdiAdapterFuzzTest(data, size);
235 INTELL_VOICE_LOG_ERROR("LLVMFuzzerTestOneInput end");
236 return 0;
237 }
238