diff --git a/services/src/sensor_service.cpp b/services/src/sensor_service.cpp index ccc4a74b47892dded3b7f974de7d786ee12c2dcc..e751179af97dd76582314f316b0ac11237b1fc5a 100644 --- a/services/src/sensor_service.cpp +++ b/services/src/sensor_service.cpp @@ -52,6 +52,9 @@ std::atomic_bool g_isRegister = false; constexpr int32_t SINGLE_DISPLAY_SMALL_FOLD = 4; constexpr int32_t SINGLE_DISPLAY_THREE_FOLD = 6; const std::string DEFAULTS_FOLD_TYPE = "0,0,0,0"; +const std::set g_systemApiSensorCall = { + SENSOR_TYPE_ID_COLOR, SENSOR_TYPE_ID_SAR, SENSOR_TYPE_ID_HEADPOSTURE +}; } // namespace std::atomic_bool SensorService::isAccessTokenServiceActive_ = false; @@ -396,7 +399,7 @@ bool SensorService::IsSystemCalling() ErrCode SensorService::CheckAuthAndParameter(const SensorDescription &sensorDesc, int64_t samplingPeriodNs, int64_t maxReportDelayNs) { - if (((sensorDesc.sensorType == SENSOR_TYPE_ID_COLOR) || (sensorDesc.sensorType == SENSOR_TYPE_ID_SAR) || + if (((g_systemApiSensorCall.find(sensorDesc.sensorType) != g_systemApiSensorCall.end()) || (sensorDesc.sensorType > GL_SENSOR_TYPE_PRIVATE_MIN_VALUE)) && !IsSystemCalling()) { SEN_HILOGE("Permission check failed. A non-system application uses the system API"); return NON_SYSTEM_API; diff --git a/test/fuzztest/interfaces/BUILD.gn b/test/fuzztest/interfaces/BUILD.gn index 054343a75a436f4b02ce298d122987d433d99522..6b9fb77135ad65605abe874fb6f62962ce696a36 100644 --- a/test/fuzztest/interfaces/BUILD.gn +++ b/test/fuzztest/interfaces/BUILD.gn @@ -26,5 +26,7 @@ group("fuzztest") { "setdevicestatus_fuzzer:fuzztest", "suspendsensors_fuzzer:fuzztest", "unregister_fuzzer:fuzztest", + "getsensorlistbydeviceproxy_fuzzer:fuzztest", + "resetsensors_fuzzer:fuzztest", ] } diff --git a/test/fuzztest/interfaces/getactivesensorinfos_fuzzer/BUILD.gn b/test/fuzztest/interfaces/getactivesensorinfos_fuzzer/BUILD.gn index aaae2dd008855adf613fe7548b5b9adecf012a62..ab1fa92fc3ee2a2802b092ffd1f3a7864f759cd5 100644 --- a/test/fuzztest/interfaces/getactivesensorinfos_fuzzer/BUILD.gn +++ b/test/fuzztest/interfaces/getactivesensorinfos_fuzzer/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2023 Huawei Device Co., Ltd. +# Copyright (c) 2023-2025 Huawei Device Co., Ltd. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -27,6 +27,7 @@ ohos_fuzztest("GetActiveSensorInfosFuzzTest") { "$SUBSYSTEM_DIR/frameworks/native/include", "$SUBSYSTEM_DIR/test/fuzztest/interfaces/getactivesensorinfos_fuzzer", "$SUBSYSTEM_DIR/utils/common/include", + "$SUBSYSTEM_DIR/utils/ipc/include", ] cflags = [ @@ -38,7 +39,14 @@ ohos_fuzztest("GetActiveSensorInfosFuzzTest") { sources = [ "getactivesensorinfos_fuzzer.cpp" ] - deps = [ "$SUBSYSTEM_DIR/frameworks/native:sensor_interface_native" ] + deps = [ + "$SUBSYSTEM_DIR/frameworks/native:sensor_interface_native", + "$SUBSYSTEM_DIR/frameworks/native:libsensor_client", + "$SUBSYSTEM_DIR/frameworks/native:sensor_service_stub", + "$SUBSYSTEM_DIR/services:libsensor_service_static", + "$SUBSYSTEM_DIR/utils/common:libsensor_utils", + "$SUBSYSTEM_DIR/utils/ipc:libsensor_ipc", + ] external_deps = [ "access_token:libaccesstoken_sdk", @@ -46,7 +54,11 @@ ohos_fuzztest("GetActiveSensorInfosFuzzTest") { "access_token:libtokensetproc_shared", "c_utils:utils", "drivers_interface_sensor:libsensor_proxy_3.0", + "eventhandler:libeventhandler", "hilog:libhilog", + "ipc:ipc_single", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", ] } diff --git a/test/fuzztest/interfaces/getactivesensorinfos_fuzzer/getactivesensorinfos_fuzzer.cpp b/test/fuzztest/interfaces/getactivesensorinfos_fuzzer/getactivesensorinfos_fuzzer.cpp index 57d545e6eb12fd609aa0290c912a44aad585c1c2..f4bbceb69b5aa62b3cf9bcd18b4460ac2d549581 100644 --- a/test/fuzztest/interfaces/getactivesensorinfos_fuzzer/getactivesensorinfos_fuzzer.cpp +++ b/test/fuzztest/interfaces/getactivesensorinfos_fuzzer/getactivesensorinfos_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -23,9 +23,12 @@ #include "sensor_agent.h" #include "sensor_agent_type.h" #include "sensor_errors.h" +#include "sensor.h" +#include "sensor_service_client.h" #undef LOG_TAG #define LOG_TAG "GetActiveSensorInfosFuzzTest" +#define SEN_CLIENT SensorServiceClient::GetInstance() namespace OHOS { namespace Sensors { @@ -74,11 +77,13 @@ void GetActiveSensorInfosFuzzTest(const uint8_t *data, size_t size) return; } SetUpTestCase(); - int32_t pid { -1 }; + int32_t pid { 0 }; GetObject(data, size, pid); SensorActiveInfo *sensorActiveInfos { nullptr }; int32_t count { 0 }; GetActiveSensorInfos(pid, &sensorActiveInfos, &count); + std::vector sensorActiveInfoList; + SEN_CLIENT.GetActiveInfoList(pid, sensorActiveInfoList); } } // namespace Sensors } // namespace OHOS diff --git a/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/BUILD.gn b/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..45887649511397b2e589e1790becaecedb53f395 --- /dev/null +++ b/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/BUILD.gn @@ -0,0 +1,72 @@ +# Copyright (c) 2025 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/ohos.gni") +import("//build/test.gni") +import("./../../../../sensor.gni") + +ohos_fuzztest("GetSensorListByDeviceProxyFuzzTest") { + module_out_path = FUZZ_MODULE_OUT_PATH + + fuzz_config_file = + "$SUBSYSTEM_DIR/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer" + + include_dirs = [ + "$SUBSYSTEM_DIR/interfaces/inner_api", + "$SUBSYSTEM_DIR/frameworks/native/include", + "$SUBSYSTEM_DIR/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer", + "$SUBSYSTEM_DIR/utils/common/include", + "$SUBSYSTEM_DIR/utils/ipc/include", + ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ "getsensorlistbydeviceproxy_fuzzer.cpp" ] + + deps = [ + "$SUBSYSTEM_DIR/frameworks/native:sensor_interface_native", + "$SUBSYSTEM_DIR/frameworks/native:libsensor_client", + "$SUBSYSTEM_DIR/frameworks/native:sensor_service_stub", + "$SUBSYSTEM_DIR/services:libsensor_service_static", + "$SUBSYSTEM_DIR/utils/common:libsensor_utils", + "$SUBSYSTEM_DIR/utils/ipc:libsensor_ipc", + ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken_shared", + "access_token:libtokensetproc_shared", + "c_utils:utils", + "drivers_interface_sensor:libsensor_proxy_3.0", + "eventhandler:libeventhandler", + "hilog:libhilog", + "ipc:ipc_single", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] +} + +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":GetSensorListByDeviceProxyFuzzTest", + ] +} diff --git a/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/corpus/init b/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..e010f5889b59a772ce45fc45b17e8a578984479c --- /dev/null +++ b/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2025 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/getsensorlistbydeviceproxy_fuzzer.cpp b/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/getsensorlistbydeviceproxy_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5397d199f0e8f78c02ccf842b1989a07a8535700 --- /dev/null +++ b/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/getsensorlistbydeviceproxy_fuzzer.cpp @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "getsensorlistbydeviceproxy_fuzzer.h" + +#include "accesstoken_kit.h" +#include "nativetoken_kit.h" +#include "securec.h" +#include "token_setproc.h" + +#include "sensor_agent.h" +#include "sensor_agent_type.h" +#include "sensor_errors.h" + +#include "sensor.h" +#include "sensor_service_client.h" + +#undef LOG_TAG +#define LOG_TAG "GetSensorListByDeviceProxyFuzzTest" +#define SEN_CLIENT SensorServiceClient::GetInstance() + +namespace OHOS { +namespace Sensors { +using namespace OHOS::HiviewDFX; +using namespace Security::AccessToken; +using Security::AccessToken::AccessTokenID; +namespace { +constexpr size_t DATA_MIN_SIZE = 4; +} // namespace + +template +void GetObject(const uint8_t *data, size_t size, T &object) +{ + size_t objectSize = sizeof(object); + if (objectSize > size) { + return; + } + errno_t ret = memcpy_s(&object, objectSize, data, objectSize); + if (ret != EOK) { + return; + } +} + +void SetUpTestCase() +{ + const char **perms = new (std::nothrow) const char *[2]; + CHKPV(perms); + perms[0] = "ohos.permission.ACCELEROMETER"; + perms[1] = "ohos.permission.MANAGE_SENSOR"; + TokenInfoParams infoInstance = { + .dcapsNum = 0, + .permsNum = 2, + .aclsNum = 0, + .dcaps = nullptr, + .perms = perms, + .acls = nullptr, + .processName = "GetSensorListByDeviceProxyFuzzTest", + .aplStr = "system_core", + }; + uint64_t tokenId = GetAccessTokenId(&infoInstance); + SetSelfTokenID(tokenId); + AccessTokenKit::ReloadNativeTokenInfo(); + delete[] perms; +} + +void GetSensorListByDeviceProxyFuzzTest(const uint8_t *data, size_t size) +{ + if (data == nullptr || size < DATA_MIN_SIZE) { + return; + } + SetUpTestCase(); + int32_t deviceId { 0 }; + GetObject(data, size, deviceId); + std::vector singleDevSensors; + SEN_CLIENT.GetSensorListByDevice(deviceId, singleDevSensors); + return; +} +} // namespace Sensors +} // namespace OHOS + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::Sensors::GetSensorListByDeviceProxyFuzzTest(data, size); + return 0; +} diff --git a/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/getsensorlistbydeviceproxy_fuzzer.h b/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/getsensorlistbydeviceproxy_fuzzer.h new file mode 100644 index 0000000000000000000000000000000000000000..5db99f8c50b99df05df9068f9bd67b8e29664549 --- /dev/null +++ b/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/getsensorlistbydeviceproxy_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef GET_SENSOR_LIST_BY_DEVICE_PROXY_FUZZER_H +#define GET_SENSOR_LIST_BY_DEVICE_PROXY_FUZZER_H + +#define FUZZ_PROJECT_NAME "getsensorlistbydeviceproxy_fuzzer" + +#endif // GET_SENSOR_LIST_BY_DEVICE_PROXY_FUZZER_H \ No newline at end of file diff --git a/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/project.xml b/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..2eb360c27f1b159e1b043e38846f10fcf37fa37c --- /dev/null +++ b/test/fuzztest/interfaces/getsensorlistbydeviceproxy_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 120 + + 2048 + + diff --git a/test/fuzztest/interfaces/resetsensors_fuzzer/BUILD.gn b/test/fuzztest/interfaces/resetsensors_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..ece8b1bd81cc4495644a314015ff5479a9d52829 --- /dev/null +++ b/test/fuzztest/interfaces/resetsensors_fuzzer/BUILD.gn @@ -0,0 +1,60 @@ +# Copyright (c) 2025 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/ohos.gni") +import("//build/test.gni") +import("./../../../../sensor.gni") + +ohos_fuzztest("ResetSensorsFuzzTest") { + module_out_path = FUZZ_MODULE_OUT_PATH + + fuzz_config_file = + "$SUBSYSTEM_DIR/test/fuzztest/interfaces/resetsensors_fuzzer" + + include_dirs = [ + "$SUBSYSTEM_DIR/interfaces/inner_api", + "$SUBSYSTEM_DIR/frameworks/native/include", + "$SUBSYSTEM_DIR/test/fuzztest/interfaces/resetsensors_fuzzer", + "$SUBSYSTEM_DIR/utils/common/include", + ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + + sources = [ "resetsensors_fuzzer.cpp" ] + + deps = [ "$SUBSYSTEM_DIR/frameworks/native:sensor_interface_native" ] + + external_deps = [ + "access_token:libaccesstoken_sdk", + "access_token:libnativetoken_shared", + "access_token:libtokensetproc_shared", + "c_utils:utils", + "drivers_interface_sensor:libsensor_proxy_3.0", + "hilog:libhilog", + ] +} + +group("fuzztest") { + testonly = true + deps = [] + deps += [ + # deps file + ":ResetSensorsFuzzTest", + ] +} diff --git a/test/fuzztest/interfaces/resetsensors_fuzzer/corpus/init b/test/fuzztest/interfaces/resetsensors_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..e010f5889b59a772ce45fc45b17e8a578984479c --- /dev/null +++ b/test/fuzztest/interfaces/resetsensors_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2025 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/interfaces/resetsensors_fuzzer/project.xml b/test/fuzztest/interfaces/resetsensors_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..2eb360c27f1b159e1b043e38846f10fcf37fa37c --- /dev/null +++ b/test/fuzztest/interfaces/resetsensors_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 120 + + 2048 + + diff --git a/test/fuzztest/interfaces/resetsensors_fuzzer/resetsensors_fuzzer.cpp b/test/fuzztest/interfaces/resetsensors_fuzzer/resetsensors_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..184f70ce08c490a9a2cbf12e30ef1461e779381e --- /dev/null +++ b/test/fuzztest/interfaces/resetsensors_fuzzer/resetsensors_fuzzer.cpp @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "resetsensors_fuzzer.h" + +#include "accesstoken_kit.h" +#include "nativetoken_kit.h" +#include "securec.h" +#include "token_setproc.h" + +#include "sensor_agent.h" +#include "sensor_agent_type.h" +#include "sensor_errors.h" + +#undef LOG_TAG +#define LOG_TAG "ResetSensorsFuzzTest" + +namespace OHOS { +namespace Sensors { +using namespace OHOS::HiviewDFX; +using namespace Security::AccessToken; +using Security::AccessToken::AccessTokenID; +namespace { +constexpr size_t DATA_MIN_SIZE = 4; +} // namespace + +template +void GetObject(const uint8_t *data, size_t size, T &object) +{ + size_t objectSize = sizeof(object); + if (objectSize > size) { + return; + } + errno_t ret = memcpy_s(&object, objectSize, data, objectSize); + if (ret != EOK) { + return; + } +} + +void SetUpTestCase() +{ + const char **perms = new (std::nothrow) const char *[2]; + CHKPV(perms); + perms[0] = "ohos.permission.ACCELEROMETER"; + perms[1] = "ohos.permission.MANAGE_SENSOR"; + TokenInfoParams infoInstance = { + .dcapsNum = 0, + .permsNum = 2, + .aclsNum = 0, + .dcaps = nullptr, + .perms = perms, + .acls = nullptr, + .processName = "ResetSensorsFuzzTest", + .aplStr = "system_core", + }; + uint64_t tokenId = GetAccessTokenId(&infoInstance); + SetSelfTokenID(tokenId); + AccessTokenKit::ReloadNativeTokenInfo(); + delete[] perms; +} + +void ResetSensorsFuzzTest(const uint8_t *data, size_t size) +{ + if (data == nullptr || size < DATA_MIN_SIZE) { + return; + } + SetUpTestCase(); + int32_t status { 0 }; + GetObject(data, size, status); + ResetSensors(); + SetDeviceStatus(status); + return; +} +} // namespace Sensors +} // namespace OHOS + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::Sensors::ResetSensorsFuzzTest(data, size); + return 0; +} diff --git a/test/fuzztest/interfaces/resetsensors_fuzzer/resetsensors_fuzzer.h b/test/fuzztest/interfaces/resetsensors_fuzzer/resetsensors_fuzzer.h new file mode 100644 index 0000000000000000000000000000000000000000..544ee0126ec8f995d726048bdc7864bc2fb56408 --- /dev/null +++ b/test/fuzztest/interfaces/resetsensors_fuzzer/resetsensors_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef RESET_SENSORS_FUZZER_H +#define RESET_SENSORS_FUZZER_H + +#define FUZZ_PROJECT_NAME "resetsensors_fuzzer" + +#endif // RESET_SENSORS_FUZZER_H \ No newline at end of file