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