1 /*
2  * Copyright (c) 2021-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 
16 #include "camera_host_fuzzer.h"
17 #include "camera.h"
18 
19 namespace OHOS {
20 const size_t THRESHOLD = 10;
21 
22 enum HostCmdId {
23     CAMERA_HOST_PRELAUNCH,
24     CAMERA_HOST_GET_CAMERA_ABILITY,
25     CAMERA_HOST_OPEN_CAMERA,
26     CAMERA_HOST_OPEN_CAMERA_V1_1,
27     CAMERA_HOST_SET_FLASH_LIGHTS,
28     CAMERA_HOST_SET_FLASH_LIGHTS_V1_2,
29     CAMERA_HOST_NOTIFY_DEVICE_STATE_CHANGE_INFO,
30     CAMERA_HOST_PRE_CAMERA_SWITCH,
31     CAMERA_HOST_PRELAUNCH_WITH_OPMODE,
32     CAMERA_HOST_OPEN_SECURECAMERA,
33     CAMERA_HOST_END, // Enumerated statistical value. The new enumerated value is added before
34 };
35 
FuncPrelaunch(const uint8_t * rawData,size_t size)36 void FuncPrelaunch(const uint8_t *rawData, size_t size)
37 {
38     if (size < sizeof(struct HDI::Camera::V1_1::PrelaunchConfig)) {
39         return;
40     }
41     cameraTest->prelaunchConfig = std::make_shared<OHOS::HDI::Camera::V1_1::PrelaunchConfig>();
42     cameraTest->prelaunchConfig->cameraId = const_cast<char*>(reinterpret_cast<const char*>(rawData));
43     cameraTest->prelaunchConfig->streamInfos_V1_1 = {};
44     cameraTest->prelaunchConfig->setting.push_back(*rawData);
45     cameraTest->serviceV1_2->Prelaunch(*cameraTest->prelaunchConfig);
46 }
47 
FuncGetCameraAbility(const uint8_t * rawData,size_t size)48 void FuncGetCameraAbility(const uint8_t *rawData, size_t size)
49 {
50     cameraTest->serviceV1_2->GetCameraAbility(const_cast<char*>(reinterpret_cast<const char*>(rawData)),
51         cameraTest->abilityVec);
52 }
53 
FuncOpenCamera(const uint8_t * rawData,size_t size)54 void FuncOpenCamera(const uint8_t *rawData, size_t size)
55 {
56     sptr<HDI::Camera::V1_0::ICameraDevice> g_CameraDevice = nullptr;
57     const sptr<HDI::Camera::V1_0::ICameraDeviceCallback> callback =
58         new Camera::CameraManager::DemoCameraDeviceCallback();
59     cameraTest->serviceV1_2->OpenCamera(
60         const_cast<char*>(reinterpret_cast<const char*>(rawData)), callback, g_CameraDevice);
61 }
62 
FuncOpenCamera_V1_1(const uint8_t * rawData,size_t size)63 void FuncOpenCamera_V1_1(const uint8_t *rawData, size_t size)
64 {
65     sptr<HDI::Camera::V1_1::ICameraDevice> g_CameraDevice = nullptr;
66     const sptr<HDI::Camera::V1_0::ICameraDeviceCallback> callback =
67         new Camera::CameraManager::DemoCameraDeviceCallback();
68     cameraTest->serviceV1_2->OpenCamera_V1_1(
69         const_cast<char*>(reinterpret_cast<const char*>(rawData)), callback, g_CameraDevice);
70 }
71 
FuncSetFlashlight(const uint8_t * rawData,size_t size)72 void FuncSetFlashlight(const uint8_t *rawData, size_t size)
73 {
74     cameraTest->serviceV1_2->SetFlashlight(
75         const_cast<char*>(reinterpret_cast<const char*>(rawData)), true);
76 }
77 
FuncSetFlashlightV1_2(const uint8_t * rawData,size_t size)78 void FuncSetFlashlightV1_2(const uint8_t *rawData, size_t size)
79 {
80     uint8_t *data = const_cast<uint8_t *>(rawData);
81     cameraTest->serviceV1_2->SetFlashlight_V1_2(*(reinterpret_cast<float *>(data)));
82 }
83 
FuncNotifyDeviceStateChangeInfo(const uint8_t * rawData,size_t size)84 void FuncNotifyDeviceStateChangeInfo(const uint8_t *rawData, size_t size)
85 {
86     int *data = const_cast<int *>(reinterpret_cast<const int *>(rawData));
87     cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(data[0], data[1]);
88 }
89 
FuncPreCameraSwitch(const uint8_t * rawData,size_t size)90 void FuncPreCameraSwitch(const uint8_t *rawData, size_t size)
91 {
92     std::string cameraId = reinterpret_cast<const char*>(rawData);
93     cameraTest->serviceV1_2->PreCameraSwitch(cameraId);
94 }
95 
FuncPrelaunchWithOpMode(const uint8_t * rawData,size_t size)96 void FuncPrelaunchWithOpMode(const uint8_t *rawData, size_t size)
97 {
98     cameraTest->prelaunchConfig = std::make_shared<OHOS::HDI::Camera::V1_1::PrelaunchConfig>();
99     std::string cameraId = reinterpret_cast<const char*>(rawData);
100     cameraTest->prelaunchConfig->cameraId = cameraId;
101     cameraTest->prelaunchConfig->streamInfos_V1_1 = {};
102     cameraTest->prelaunchConfig->setting.push_back(*rawData);
103 
104     int *data = const_cast<int *>(reinterpret_cast<const int *>(rawData));
105 
106     cameraTest->serviceV1_2->PrelaunchWithOpMode(*cameraTest->prelaunchConfig, data[0]);
107 }
108 
FuncOpenSecureCamera(const uint8_t * rawData,size_t size)109 void FuncOpenSecureCamera(const uint8_t *rawData, size_t size)
110 {
111     sptr<HDI::Camera::V1_3::ICameraDevice> g_CameraDevice = nullptr;
112     const sptr<HDI::Camera::V1_0::ICameraDeviceCallback> callback =
113         new Camera::CameraManager::DemoCameraDeviceCallback();
114     cameraTest->serviceV1_3->OpenSecureCamera(
115         const_cast<char*>(reinterpret_cast<const char*>(rawData)), callback, g_CameraDevice);
116 }
117 
HostFuncSwitch(uint32_t cmd,const uint8_t * rawData,size_t size)118 static void HostFuncSwitch(uint32_t cmd, const uint8_t *rawData, size_t size)
119 {
120     switch (cmd) {
121         case CAMERA_HOST_PRELAUNCH: {
122             FuncPrelaunch(rawData, size);
123             break;
124         }
125         case CAMERA_HOST_GET_CAMERA_ABILITY: {
126             FuncGetCameraAbility(rawData, size);
127             break;
128         }
129         case CAMERA_HOST_OPEN_CAMERA: {
130             FuncOpenCamera(rawData, size);
131             break;
132         }
133         case CAMERA_HOST_OPEN_CAMERA_V1_1: {
134             FuncOpenCamera_V1_1(rawData, size);
135             break;
136         }
137         case CAMERA_HOST_SET_FLASH_LIGHTS: {
138             FuncSetFlashlight(rawData, size);
139             break;
140         }
141         case CAMERA_HOST_SET_FLASH_LIGHTS_V1_2: {
142             FuncSetFlashlightV1_2(rawData, size);
143             break;
144         }
145         case CAMERA_HOST_NOTIFY_DEVICE_STATE_CHANGE_INFO: {
146             FuncNotifyDeviceStateChangeInfo(rawData, size);
147             break;
148         }
149         case CAMERA_HOST_PRE_CAMERA_SWITCH: {
150             FuncPreCameraSwitch(rawData, size);
151             break;
152         }
153         case CAMERA_HOST_PRELAUNCH_WITH_OPMODE: {
154             FuncPrelaunchWithOpMode(rawData, size);
155             break;
156         }
157         case CAMERA_HOST_OPEN_SECURECAMERA: {
158             FuncOpenSecureCamera(rawData, size);
159             break;
160         }
161         default:
162             return;
163     }
164 }
165 
DoSomethingInterestingWithMyApi(const uint8_t * rawData,size_t size)166 bool DoSomethingInterestingWithMyApi(const uint8_t *rawData, size_t size)
167 {
168     if (rawData == nullptr) {
169         return false;
170     }
171 
172     uint32_t cmd = 0;
173     rawData += sizeof(cmd);
174 
175     cameraTest = std::make_shared<OHOS::Camera::CameraManager>();
176     cameraTest->InitV1_3();
177     if (cameraTest->serviceV1_3 == nullptr) {
178         return false;
179     }
180     cameraTest->OpenV1_3();
181     if (cameraTest->cameraDeviceV1_3 == nullptr) {
182         return false;
183     }
184 
185     for (cmd = 0; cmd < CAMERA_HOST_END; cmd++) {
186         HostFuncSwitch(cmd, rawData, size);
187     }
188     cameraTest->Close();
189     return true;
190 }
191 
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)192 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
193 {
194     if (size < OHOS::THRESHOLD) {
195         return 0;
196     }
197 
198     OHOS::DoSomethingInterestingWithMyApi(data, size);
199     return 0;
200 }
201 } // namespace OHOS
202