From 0f94bac2bbd742694fd1c1efa0d1956a8af7bf92 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=9F=A6=E5=9B=BD=E5=BA=86?= Date: Sat, 21 Jun 2025 22:29:42 +0800 Subject: [PATCH 1/5] add FUZZ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 韦国庆 --- .../dcameradeviceupdatesettings_fuzzer.cpp | 517 ++++++++++++++++++ .../dcamerahost_fuzzer/dcamerahost_fuzzer.cpp | 56 ++ .../dcamerasetflashlight_fuzzer.cpp | 12 + 3 files changed, 585 insertions(+) diff --git a/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp b/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp index bcf55fa104..e3097fbdb5 100644 --- a/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp +++ b/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp @@ -13,6 +13,8 @@ * limitations under the License. */ +#include + #include "dcameradeviceupdatesettings_fuzzer.h" #include "dcamera_device.h" @@ -43,6 +45,501 @@ void DcameraDeviceUpdateSettingsFuzzTest(const uint8_t* data, size_t size) } dcameraDevice->UpdateSettings(results); } + +void DcameraDeviceGetStreamOperatorFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint8_t))) { + return; + } + + std::string deviceId(reinterpret_cast(data), size); + std::string dhId(reinterpret_cast(data), size); + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo(reinterpret_cast(data), size); + std::string srcAbilityInfo(reinterpret_cast(data), size); + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + if (dcameraDevice == nullptr) { + return; + } + OHOS::sptr callbackObj = nullptr; + OHOS::sptr streamOperator = nullptr; + + dcameraDevice->GetStreamOperator(callbackObj, streamOperator); +} + +void DcameraDeviceGetStreamOperatorV1_1FuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint8_t))) { + return; + } + + std::string deviceId(reinterpret_cast(data), size); + std::string dhId(reinterpret_cast(data), size); + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo(reinterpret_cast(data), size); + std::string srcAbilityInfo(reinterpret_cast(data), size); + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + if (dcameraDevice == nullptr) { + return; + } + + OHOS::sptr callbackObj = nullptr; + OHOS::sptr streamOperator = nullptr; + + dcameraDevice->GetStreamOperator_V1_1(callbackObj, streamOperator); +} + +void DcameraDeviceGetStreamOperatorV1_2FuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint8_t))) { + return; + } + + std::string deviceId(reinterpret_cast(data), size); + std::string dhId(reinterpret_cast(data), size); + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo(reinterpret_cast(data), size); + std::string srcAbilityInfo(reinterpret_cast(data), size); + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + if (dcameraDevice == nullptr) { + return; + } + + OHOS::sptr callbackObj = nullptr; + OHOS::sptr streamOperator = nullptr; + + dcameraDevice->GetStreamOperator_V1_2(callbackObj, streamOperator); +} + +void DcameraDeviceGetStreamOperatorV1_3FuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint8_t))) { + return; + } + + std::string deviceId(reinterpret_cast(data), size); + std::string dhId(reinterpret_cast(data), size); + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo(reinterpret_cast(data), size); + std::string srcAbilityInfo(reinterpret_cast(data), size); + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + if (dcameraDevice == nullptr) { + return; + } + + OHOS::sptr callbackObj = nullptr; + OHOS::sptr streamOperator = nullptr; + + dcameraDevice->GetStreamOperator_V1_3(callbackObj, streamOperator); +} + +void DCameraGetSecureCameraSeqFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint64_t))) { + return; + } + + std::string deviceId(reinterpret_cast(data), size); + std::string dhId(reinterpret_cast(data), size); + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo(reinterpret_cast(data), size); + std::string srcAbilityInfo(reinterpret_cast(data), size); + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + if (dcameraDevice == nullptr) { + return; + } + + uint64_t seqId = *(reinterpret_cast(data)); + dcameraDevice->GetSecureCameraSeq(seqId); +} + +void DCameraDeviceGetStatusFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + std::string deviceId(reinterpret_cast(data), size); + std::string dhId(reinterpret_cast(data), size); + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo(reinterpret_cast(data), size); + std::string srcAbilityInfo(reinterpret_cast(data), size); + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + if (dcameraDevice == nullptr) { + return; + } + + std::vector metaIn(data, data + size); + std::vector metaOut; + + dcameraDevice->GetStatus(metaIn, metaOut); +} + +void DCameraDeviceResetFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + std::string deviceId(reinterpret_cast(data), size); + std::string dhId(reinterpret_cast(data), size); + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo(reinterpret_cast(data), size); + std::string srcAbilityInfo(reinterpret_cast(data), size); + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + if (dcameraDevice == nullptr) { + return; + } + dcameraDevice->Reset(); +} + +void DCameraDeviceGetDefaultSettingsFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + std::string deviceId(reinterpret_cast(data), size); + std::string dhId(reinterpret_cast(data), size); + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo(reinterpret_cast(data), size); + std::string srcAbilityInfo(reinterpret_cast(data), size); + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + if (dcameraDevice == nullptr) { + return; + } + + std::vector settings; + dcameraDevice->GetDefaultSettings(settings); +} + +void DCameraDeviceSetResultModeFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(ResultCallbackMode))) { + return; + } + + std::string deviceId(reinterpret_cast(data), size); + std::string dhId(reinterpret_cast(data), size); + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo(reinterpret_cast(data), size); + std::string srcAbilityInfo(reinterpret_cast(data), size); + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + if (dcameraDevice == nullptr) { + return; + } + + ResultCallbackMode mode = *(reinterpret_cast(data)); + dcameraDevice->SetResultMode(mode); +} + +void DCameraDeviceGetEnabledResultsFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + std::string deviceId(reinterpret_cast(data), size); + std::string dhId(reinterpret_cast(data), size); + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo(reinterpret_cast(data), size); + std::string srcAbilityInfo(reinterpret_cast(data), size); + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + if (dcameraDevice == nullptr) { + return; + } + + std::vector results; + dcameraDevice->GetEnabledResults(results); +} + +void DCameraEnableResultFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + + std::string deviceId(reinterpret_cast(data), size); + std::string dhId(reinterpret_cast(data), size); + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo(reinterpret_cast(data), size); + std::string srcAbilityInfo(reinterpret_cast(data), size); + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + if (dcameraDevice == nullptr) { + return; + } + + std::vector results; + results.push_back(*(reinterpret_cast(data))); + + dcameraDevice->EnableResult(results); +} + +void DCameraDisableResultFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + + std::string deviceId(reinterpret_cast(data), size); + std::string dhId(reinterpret_cast(data), size); + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo(reinterpret_cast(data), size); + std::string srcAbilityInfo(reinterpret_cast(data), size); + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + if (dcameraDevice == nullptr) { + return; + } + + std::vector results; + results.push_back(*(reinterpret_cast(data))); + + dcameraDevice->DisableResult(results); +} + +void DCameraAcquireBufferFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + + std::string deviceId = "deviceId"; + std::string dhId = "dhId"; + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo = "sinkAbilityInfo"; + std::string sourceCodecInfo = "sourceCodecInfo"; + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); + if (dcameraDevice == nullptr) { + return; + } + + FuzzedDataProvider fdp(data, size); + int32_t streamId = fdp.ConsumeIntegral(); + DCameraBuffer buffer; + buffer.index_ = fdp.ConsumeIntegral(); + buffer.size_ = fdp.ConsumeIntegral(); + + dcameraDevice->AcquireBuffer(streamId, buffer); +} + +void DCameraShutterBufferFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + + std::string deviceId = "deviceId"; + std::string dhId = "dhId"; + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo = "sinkAbilityInfo"; + std::string sourceCodecInfo = "sourceCodecInfo"; + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); + if (dcameraDevice == nullptr) { + return; + } + + FuzzedDataProvider fdp(data, size); + int32_t streamId = fdp.ConsumeIntegral(); + DCameraBuffer buffer; + buffer.index_ = fdp.ConsumeIntegral(); + buffer.size_ = fdp.ConsumeIntegral(); + + dcameraDevice->ShutterBuffer(streamId, buffer); +} + +void DCameraOnSettingsResultFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + std::string deviceId = "deviceId"; + std::string dhId = "dhId"; + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo = "sinkAbilityInfo"; + std::string sourceCodecInfo = "sourceCodecInfo"; + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); + if (dcameraDevice == nullptr) { + return; + } + + FuzzedDataProvider fdp(data, size); + DCameraSettings result; + result.type_ = static_cast(fdp.ConsumeIntegral()); + result.value_ = fdp.ConsumeRemainingBytesAsString(); + + dcameraDevice->OnSettingsResult(std::make_shared(result)); +} + +void DCameraNotifyFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + std::string deviceId = "deviceId"; + std::string dhId = "dhId"; + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo = "sinkAbilityInfo"; + std::string sourceCodecInfo = "sourceCodecInfo"; + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); + if (dcameraDevice == nullptr) { + return; + } + + FuzzedDataProvider fdp(data, size); + std::shared_ptr event = std::make_shared(); + event->type_ = static_cast(fdp.ConsumeIntegral()); + event->result_ = static_cast(fdp.ConsumeIntegral()); + event->content_ = fdp.ConsumeRemainingBytesAsString(); + + dcameraDevice->Notify(event); +} + +void DCameraIsOpenSessFailedStateFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + std::string deviceId = "deviceId"; + std::string dhId = "dhId"; + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo = "sinkAbilityInfo"; + std::string sourceCodecInfo = "sourceCodecInfo"; + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); + if (dcameraDevice == nullptr) { + return; + } + + FuzzedDataProvider fdp(data, size); + bool state = fdp.ConsumeBool(); + + dcameraDevice->IsOpenSessFailedState(state); +} + +void DCameraNotifyStartCaptureErrorFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + std::string deviceId = "deviceId"; + std::string dhId = "dhId"; + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo = "sinkAbilityInfo"; + std::string sourceCodecInfo = "sourceCodecInfo"; + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); + if (dcameraDevice == nullptr) { + return; + } + + dcameraDevice->NotifyStartCaptureError(); +} + +void DCameraNotifyCameraErrorFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + std::string deviceId = "deviceId"; + std::string dhId = "dhId"; + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo = "sinkAbilityInfo"; + std::string sourceCodecInfo = "sourceCodecInfo"; + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); + if (dcameraDevice == nullptr) { + return; + } + + FuzzedDataProvider fdp(data, size); + ErrorType errorType = static_cast(fdp.ConsumeIntegral()); + + dcameraDevice->NotifyCameraError(errorType); +} + +void DCameraSetDcameraAbilityFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + std::string deviceId = "deviceId"; + std::string dhId = "dhId"; + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + + std::string sinkAbilityInfo = "sinkAbilityInfo"; + std::string sourceCodecInfo = "sourceCodecInfo"; + OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); + if (dcameraDevice == nullptr) { + return; + } + + FuzzedDataProvider fdp(data, size); + std::string randomSinkAbilityInfo = fdp.ConsumeRemainingBytesAsString(); + + dcameraDevice->SetDcameraAbility(randomSinkAbilityInfo); +} } } @@ -51,6 +548,26 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { /* Run your code on data */ OHOS::DistributedHardware::DcameraDeviceUpdateSettingsFuzzTest(data, size); + OHOS::DistributedHardware::DcameraDeviceGetStreamOperatorFuzzTest(data, size); + OHOS::DistributedHardware::DcameraDeviceGetStreamOperatorV1_1FuzzTest(data, size); + OHOS::DistributedHardware::DcameraDeviceGetStreamOperatorV1_2FuzzTest(data, size); + OHOS::DistributedHardware::DcameraDeviceGetStreamOperatorV1_3FuzzTest(data, size); + OHOS::DistributedHardware::DCameraGetSecureCameraSeqFuzzTest(data, size); + OHOS::DistributedHardware::DCameraDeviceGetStatusFuzzTest(data, size); + OHOS::DistributedHardware::DCameraDeviceResetFuzzTest(data, size); + OHOS::DistributedHardware::DCameraDeviceGetDefaultSettingsFuzzTest(data, size); + OHOS::DistributedHardware::DCameraDeviceSetResultModeFuzzTest(data, size); + OHOS::DistributedHardware::DCameraDeviceGetEnabledResultsFuzzTest(data, size); + OHOS::DistributedHardware::DCameraEnableResultFuzzTest(data, size); + OHOS::DistributedHardware::DCameraDisableResultFuzzTest(data, size); + OHOS::DistributedHardware::DCameraAcquireBufferFuzzTest(data, size); + OHOS::DistributedHardware::DCameraShutterBufferFuzzTest(data, size); + OHOS::DistributedHardware::DCameraOnSettingsResultFuzzTest(data, size); + OHOS::DistributedHardware::DCameraNotifyFuzzTest(data, size); + OHOS::DistributedHardware::DCameraIsOpenSessFailedStateFuzzTest(data, size); + OHOS::DistributedHardware::DCameraNotifyStartCaptureErrorFuzzTest(data, size); + OHOS::DistributedHardware::DCameraNotifyCameraErrorFuzzTest(data, size); + OHOS::DistributedHardware::DCameraSetDcameraAbilityFuzzTest(data, size); return 0; } diff --git a/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp b/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp index 1752440649..6650037305 100644 --- a/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp +++ b/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp @@ -17,6 +17,7 @@ #include #include +#include #include "dcamera_host.h" @@ -101,6 +102,56 @@ void DCameraGetCameraIdByDHBaseFuzzTest(const uint8_t* data, size_t size) dhBase.dhId_ = dhId; DCameraHost::GetInstance()->GetCameraIdByDHBase(dhBase); } + +void DCameraGetResourceCostFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + std::string cameraId(reinterpret_cast(data), size); + OHOS::HDI::Camera::V1_3::CameraDeviceResourceCost resourceCost; + + DCameraHost::GetInstance()->GetResourceCost(cameraId, resourceCost); +} + +void DCameraNotifyDeviceStateChangeInfoFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t) * 2)) { + return; + } + FuzzedDataProvider fdp(data, size); + int32_t notifyType = *(reinterpret_cast(data)); + int32_t deviceState = *(reinterpret_cast(data + sizeof(int32_t))); + DCameraHost::GetInstance()->NotifyDeviceStateChangeInfo(notifyType, deviceState); +} + +void DCameraPreCameraSwitchFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + std::string cameraId(reinterpret_cast(data), size); + DCameraHost::GetInstance()->PreCameraSwitch(cameraId); +} + +void DCameraPrelaunchWithOpModeFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int32_t))) { + return; + } + int32_t operationMode = *(reinterpret_cast(data)); + PrelaunchConfig config; + DCameraHost::GetInstance()->PrelaunchWithOpMode(config, operationMode); +} + +void DCameraPrelaunchFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + PrelaunchConfig config; + DCameraHost::GetInstance()->Prelaunch(config); +} } } @@ -113,5 +164,10 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) OHOS::DistributedHardware::DCameraGetCamDevNumFuzzTest(data, size); OHOS::DistributedHardware::DCameraIsCameraIdInvalidFuzzTest(data, size); OHOS::DistributedHardware::DCameraGetCameraIdByDHBaseFuzzTest(data, size); + OHOS::DistributedHardware::DCameraGetResourceCostFuzzTest(data, size); + OHOS::DistributedHardware::DCameraNotifyDeviceStateChangeInfoFuzzTest(data, size); + OHOS::DistributedHardware::DCameraPreCameraSwitchFuzzTest(data, size); + OHOS::DistributedHardware::DCameraPrelaunchWithOpModeFuzzTest(data, size); + OHOS::DistributedHardware::DCameraPrelaunchFuzzTest(data, size); return 0; } diff --git a/distributed_camera/hdi_service/test/fuzztest/dcamerasetflashlight_fuzzer/dcamerasetflashlight_fuzzer.cpp b/distributed_camera/hdi_service/test/fuzztest/dcamerasetflashlight_fuzzer/dcamerasetflashlight_fuzzer.cpp index 1bd9c982e1..21c4bee978 100644 --- a/distributed_camera/hdi_service/test/fuzztest/dcamerasetflashlight_fuzzer/dcamerasetflashlight_fuzzer.cpp +++ b/distributed_camera/hdi_service/test/fuzztest/dcamerasetflashlight_fuzzer/dcamerasetflashlight_fuzzer.cpp @@ -17,6 +17,7 @@ #include #include +#include #include "dcamera_host.h" @@ -39,6 +40,16 @@ void DcameraSetFlashlightFuzzTest(const uint8_t* data, size_t size) DCameraHost::GetInstance()->PrelaunchWithOpMode(config, operationMode); DCameraHost::GetInstance()->Prelaunch(config); } + +void DCameraSetFlashlightV1_2FuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(float))) { + return; + } + FuzzedDataProvider fuzzProvider(data, size); + float level = fuzzProvider.ConsumeFloatingPoint(); + DCameraHost::GetInstance()->SetFlashlight_V1_2(level); +} } } @@ -47,5 +58,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { /* Run your code on data */ OHOS::DistributedHardware::DcameraSetFlashlightFuzzTest(data, size); + OHOS::DistributedHardware::DCameraSetFlashlightV1_2FuzzTest(data, size); return 0; } \ No newline at end of file -- Gitee From 1f5d578f8a6ce18b76ace48bad71175d6f9bd597 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E9=9B=B7?= Date: Sat, 21 Jun 2025 22:44:02 +0800 Subject: [PATCH 2/5] add FUZZ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 张雷 --- .../test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp b/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp index 6650037305..e831eb4c06 100644 --- a/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp +++ b/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp @@ -17,7 +17,7 @@ #include #include -#include +#include #include "dcamera_host.h" @@ -116,7 +116,8 @@ void DCameraGetResourceCostFuzzTest(const uint8_t* data, size_t size) void DCameraNotifyDeviceStateChangeInfoFuzzTest(const uint8_t* data, size_t size) { - if ((data == nullptr) || (size < sizeof(int32_t) * 2)) { + int doubleNum = 2; + if ((data == nullptr) || (size < sizeof(int32_t) * doubleNum)) { return; } FuzzedDataProvider fdp(data, size); -- Gitee From fd1cd8201eccb46ef040e3885889dddb162c59ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=9F=A6=E5=9B=BD=E5=BA=86?= Date: Mon, 23 Jun 2025 11:28:17 +0800 Subject: [PATCH 3/5] add FUZZ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 韦国庆 --- .../dcameradeviceupdatesettings_fuzzer.cpp | 270 +++++++++++++++++- .../dcamerahost_fuzzer/dcamerahost_fuzzer.cpp | 33 ++- 2 files changed, 296 insertions(+), 7 deletions(-) diff --git a/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp b/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp index e3097fbdb5..ea0aa9988e 100644 --- a/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp +++ b/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024 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 @@ -28,8 +28,10 @@ void DcameraDeviceUpdateSettingsFuzzTest(const uint8_t* data, size_t size) if ((data == nullptr) || (size < sizeof(uint8_t))) { return; } - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; @@ -37,9 +39,10 @@ void DcameraDeviceUpdateSettingsFuzzTest(const uint8_t* data, size_t size) std::vector results; results.push_back(*(reinterpret_cast(data))); - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); if (dcameraDevice == nullptr) { return; } @@ -52,15 +55,29 @@ void DcameraDeviceGetStreamOperatorFuzzTest(const uint8_t* data, size_t size) return; } +<<<<<<< HEAD std::string deviceId(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); +======= + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + +>>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo(reinterpret_cast(data), size); std::string srcAbilityInfo(reinterpret_cast(data), size); OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +======= + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -76,15 +93,29 @@ void DcameraDeviceGetStreamOperatorV1_1FuzzTest(const uint8_t* data, size_t size return; } +<<<<<<< HEAD std::string deviceId(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); +======= + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + +>>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo(reinterpret_cast(data), size); std::string srcAbilityInfo(reinterpret_cast(data), size); OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +======= + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -101,15 +132,29 @@ void DcameraDeviceGetStreamOperatorV1_2FuzzTest(const uint8_t* data, size_t size return; } +<<<<<<< HEAD std::string deviceId(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); +======= + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + +>>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo(reinterpret_cast(data), size); std::string srcAbilityInfo(reinterpret_cast(data), size); OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +======= + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -126,15 +171,29 @@ void DcameraDeviceGetStreamOperatorV1_3FuzzTest(const uint8_t* data, size_t size return; } +<<<<<<< HEAD std::string deviceId(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); +======= + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + +>>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo(reinterpret_cast(data), size); std::string srcAbilityInfo(reinterpret_cast(data), size); OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +======= + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -151,15 +210,29 @@ void DCameraGetSecureCameraSeqFuzzTest(const uint8_t* data, size_t size) return; } +<<<<<<< HEAD std::string deviceId(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); +======= + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + +>>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo(reinterpret_cast(data), size); std::string srcAbilityInfo(reinterpret_cast(data), size); OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +======= + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -174,15 +247,29 @@ void DCameraDeviceGetStatusFuzzTest(const uint8_t* data, size_t size) return; } +<<<<<<< HEAD std::string deviceId(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); +======= + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + +>>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo(reinterpret_cast(data), size); std::string srcAbilityInfo(reinterpret_cast(data), size); OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +======= + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -199,15 +286,29 @@ void DCameraDeviceResetFuzzTest(const uint8_t* data, size_t size) return; } +<<<<<<< HEAD std::string deviceId(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); +======= + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + +>>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo(reinterpret_cast(data), size); std::string srcAbilityInfo(reinterpret_cast(data), size); OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +======= + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -220,15 +321,29 @@ void DCameraDeviceGetDefaultSettingsFuzzTest(const uint8_t* data, size_t size) return; } +<<<<<<< HEAD std::string deviceId(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); +======= + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + +>>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo(reinterpret_cast(data), size); std::string srcAbilityInfo(reinterpret_cast(data), size); OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +======= + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -243,6 +358,7 @@ void DCameraDeviceSetResultModeFuzzTest(const uint8_t* data, size_t size) return; } +<<<<<<< HEAD std::string deviceId(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); DHBase dhBase; @@ -252,6 +368,19 @@ void DCameraDeviceSetResultModeFuzzTest(const uint8_t* data, size_t size) std::string sinkAbilityInfo(reinterpret_cast(data), size); std::string srcAbilityInfo(reinterpret_cast(data), size); OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +======= + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -265,6 +394,7 @@ void DCameraDeviceGetEnabledResultsFuzzTest(const uint8_t* data, size_t size) if ((data == nullptr) || (size == 0)) { return; } +<<<<<<< HEAD std::string deviceId(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); @@ -275,6 +405,19 @@ void DCameraDeviceGetEnabledResultsFuzzTest(const uint8_t* data, size_t size) std::string sinkAbilityInfo(reinterpret_cast(data), size); std::string srcAbilityInfo(reinterpret_cast(data), size); OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +======= + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + + DHBase dhBase; + dhBase.deviceId_ = deviceId; + dhBase.dhId_ = dhId; + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -289,15 +432,29 @@ void DCameraEnableResultFuzzTest(const uint8_t* data, size_t size) return; } +<<<<<<< HEAD std::string deviceId(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); +======= + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + +>>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo(reinterpret_cast(data), size); std::string srcAbilityInfo(reinterpret_cast(data), size); OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +======= + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -314,15 +471,30 @@ void DCameraDisableResultFuzzTest(const uint8_t* data, size_t size) return; } +<<<<<<< HEAD std::string deviceId(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); +======= + FuzzedDataProvider fdp(data, size); + std::string deviceId = fdp.ConsumeRandomLengthString(size); + std::string dhId = fdp.ConsumeRandomLengthString(size); + +>>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo(reinterpret_cast(data), size); std::string srcAbilityInfo(reinterpret_cast(data), size); OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +======= + FuzzedDataProvider fdp(data, size); + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -345,14 +517,25 @@ void DCameraAcquireBufferFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo = "sinkAbilityInfo"; std::string sourceCodecInfo = "sourceCodecInfo"; OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +======= + FuzzedDataProvider fdp(data, size); + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } +<<<<<<< HEAD FuzzedDataProvider fdp(data, size); +======= +>>>>>>> origin/dev_addFUZZ int32_t streamId = fdp.ConsumeIntegral(); DCameraBuffer buffer; buffer.index_ = fdp.ConsumeIntegral(); @@ -373,14 +556,25 @@ void DCameraShutterBufferFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo = "sinkAbilityInfo"; std::string sourceCodecInfo = "sourceCodecInfo"; OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +======= + FuzzedDataProvider fdp(data, size); + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } +<<<<<<< HEAD FuzzedDataProvider fdp(data, size); +======= +>>>>>>> origin/dev_addFUZZ int32_t streamId = fdp.ConsumeIntegral(); DCameraBuffer buffer; buffer.index_ = fdp.ConsumeIntegral(); @@ -401,14 +595,25 @@ void DCameraOnSettingsResultFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo = "sinkAbilityInfo"; std::string sourceCodecInfo = "sourceCodecInfo"; OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +======= + FuzzedDataProvider fdp(data, size); + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } +<<<<<<< HEAD FuzzedDataProvider fdp(data, size); +======= +>>>>>>> origin/dev_addFUZZ DCameraSettings result; result.type_ = static_cast(fdp.ConsumeIntegral()); result.value_ = fdp.ConsumeRemainingBytesAsString(); @@ -428,14 +633,25 @@ void DCameraNotifyFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo = "sinkAbilityInfo"; std::string sourceCodecInfo = "sourceCodecInfo"; OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +======= + FuzzedDataProvider fdp(data, size); + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } +<<<<<<< HEAD FuzzedDataProvider fdp(data, size); +======= +>>>>>>> origin/dev_addFUZZ std::shared_ptr event = std::make_shared(); event->type_ = static_cast(fdp.ConsumeIntegral()); event->result_ = static_cast(fdp.ConsumeIntegral()); @@ -456,16 +672,27 @@ void DCameraIsOpenSessFailedStateFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo = "sinkAbilityInfo"; std::string sourceCodecInfo = "sourceCodecInfo"; OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +======= + FuzzedDataProvider fdp(data, size); + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } FuzzedDataProvider fdp(data, size); bool state = fdp.ConsumeBool(); +<<<<<<< HEAD +======= +>>>>>>> origin/dev_addFUZZ dcameraDevice->IsOpenSessFailedState(state); } @@ -481,9 +708,17 @@ void DCameraNotifyStartCaptureErrorFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo = "sinkAbilityInfo"; std::string sourceCodecInfo = "sourceCodecInfo"; OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +======= + FuzzedDataProvider fdp(data, size); + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -503,14 +738,25 @@ void DCameraNotifyCameraErrorFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo = "sinkAbilityInfo"; std::string sourceCodecInfo = "sourceCodecInfo"; OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +======= + FuzzedDataProvider fdp(data, size); + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } +<<<<<<< HEAD FuzzedDataProvider fdp(data, size); +======= +>>>>>>> origin/dev_addFUZZ ErrorType errorType = static_cast(fdp.ConsumeIntegral()); dcameraDevice->NotifyCameraError(errorType); @@ -528,16 +774,28 @@ void DCameraSetDcameraAbilityFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; +<<<<<<< HEAD std::string sinkAbilityInfo = "sinkAbilityInfo"; std::string sourceCodecInfo = "sourceCodecInfo"; OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +======= + FuzzedDataProvider fdp(data, size); + std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); + std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); + + OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); +>>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } +<<<<<<< HEAD FuzzedDataProvider fdp(data, size); std::string randomSinkAbilityInfo = fdp.ConsumeRemainingBytesAsString(); +======= + std::string randomSinkAbilityInfo = fdp.ConsumeRemainingBytesAsString(); +>>>>>>> origin/dev_addFUZZ dcameraDevice->SetDcameraAbility(randomSinkAbilityInfo); } } diff --git a/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp b/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp index e831eb4c06..836b6fa3ca 100644 --- a/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp +++ b/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-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 @@ -17,7 +17,11 @@ #include #include +<<<<<<< HEAD #include +======= +#include +>>>>>>> origin/dev_addFUZZ #include "dcamera_host.h" @@ -108,7 +112,13 @@ void DCameraGetResourceCostFuzzTest(const uint8_t* data, size_t size) if ((data == nullptr) || (size == 0)) { return; } +<<<<<<< HEAD std::string cameraId(reinterpret_cast(data), size); +======= + + FuzzedDataProvider fdp(data, size); + std::string cameraId = fdp.ConsumeRandomLengthString(size); +>>>>>>> origin/dev_addFUZZ OHOS::HDI::Camera::V1_3::CameraDeviceResourceCost resourceCost; DCameraHost::GetInstance()->GetResourceCost(cameraId, resourceCost); @@ -116,6 +126,7 @@ void DCameraGetResourceCostFuzzTest(const uint8_t* data, size_t size) void DCameraNotifyDeviceStateChangeInfoFuzzTest(const uint8_t* data, size_t size) { +<<<<<<< HEAD int doubleNum = 2; if ((data == nullptr) || (size < sizeof(int32_t) * doubleNum)) { return; @@ -123,6 +134,14 @@ void DCameraNotifyDeviceStateChangeInfoFuzzTest(const uint8_t* data, size_t size FuzzedDataProvider fdp(data, size); int32_t notifyType = *(reinterpret_cast(data)); int32_t deviceState = *(reinterpret_cast(data + sizeof(int32_t))); +======= + if ((data == nullptr) || (size < sizeof(int32_t) * 2)) { + return; + } + FuzzedDataProvider fdp(data, size); + int32_t notifyType = fdp.ConsumeIntegral(); + int32_t deviceState = fdp.ConsumeIntegral(); +>>>>>>> origin/dev_addFUZZ DCameraHost::GetInstance()->NotifyDeviceStateChangeInfo(notifyType, deviceState); } @@ -131,7 +150,13 @@ void DCameraPreCameraSwitchFuzzTest(const uint8_t* data, size_t size) if ((data == nullptr) || (size == 0)) { return; } +<<<<<<< HEAD std::string cameraId(reinterpret_cast(data), size); +======= + + FuzzedDataProvider fdp(data, size); + std::string cameraId = fdp.ConsumeRandomLengthString(size); +>>>>>>> origin/dev_addFUZZ DCameraHost::GetInstance()->PreCameraSwitch(cameraId); } @@ -140,7 +165,13 @@ void DCameraPrelaunchWithOpModeFuzzTest(const uint8_t* data, size_t size) if ((data == nullptr) || (size < sizeof(int32_t))) { return; } +<<<<<<< HEAD int32_t operationMode = *(reinterpret_cast(data)); +======= + + FuzzedDataProvider fdp(data, size); + int32_t operationMode = fdp.ConsumeIntegral(); +>>>>>>> origin/dev_addFUZZ PrelaunchConfig config; DCameraHost::GetInstance()->PrelaunchWithOpMode(config, operationMode); } -- Gitee From 5f24aa68c26b730b5843446bc26feafcdc749fa2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=9F=A6=E5=9B=BD=E5=BA=86?= Date: Mon, 23 Jun 2025 11:33:07 +0800 Subject: [PATCH 4/5] add FUZZ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 韦国庆 --- .../dcameradeviceupdatesettings_fuzzer.cpp | 213 ------------------ .../dcamerahost_fuzzer/dcamerahost_fuzzer.cpp | 26 --- 2 files changed, 239 deletions(-) diff --git a/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp b/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp index ea0aa9988e..563afeefe6 100644 --- a/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp +++ b/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp @@ -55,29 +55,18 @@ void DcameraDeviceGetStreamOperatorFuzzTest(const uint8_t* data, size_t size) return; } -<<<<<<< HEAD - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); -======= FuzzedDataProvider fdp(data, size); std::string deviceId = fdp.ConsumeRandomLengthString(size); std::string dhId = fdp.ConsumeRandomLengthString(size); ->>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); -======= std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -93,29 +82,18 @@ void DcameraDeviceGetStreamOperatorV1_1FuzzTest(const uint8_t* data, size_t size return; } -<<<<<<< HEAD - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); -======= FuzzedDataProvider fdp(data, size); std::string deviceId = fdp.ConsumeRandomLengthString(size); std::string dhId = fdp.ConsumeRandomLengthString(size); ->>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); -======= std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -132,29 +110,18 @@ void DcameraDeviceGetStreamOperatorV1_2FuzzTest(const uint8_t* data, size_t size return; } -<<<<<<< HEAD - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); -======= FuzzedDataProvider fdp(data, size); std::string deviceId = fdp.ConsumeRandomLengthString(size); std::string dhId = fdp.ConsumeRandomLengthString(size); ->>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); -======= std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -171,29 +138,18 @@ void DcameraDeviceGetStreamOperatorV1_3FuzzTest(const uint8_t* data, size_t size return; } -<<<<<<< HEAD - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); -======= FuzzedDataProvider fdp(data, size); std::string deviceId = fdp.ConsumeRandomLengthString(size); std::string dhId = fdp.ConsumeRandomLengthString(size); ->>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); -======= std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -210,29 +166,18 @@ void DCameraGetSecureCameraSeqFuzzTest(const uint8_t* data, size_t size) return; } -<<<<<<< HEAD - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); -======= FuzzedDataProvider fdp(data, size); std::string deviceId = fdp.ConsumeRandomLengthString(size); std::string dhId = fdp.ConsumeRandomLengthString(size); ->>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); -======= std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -247,29 +192,18 @@ void DCameraDeviceGetStatusFuzzTest(const uint8_t* data, size_t size) return; } -<<<<<<< HEAD - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); -======= FuzzedDataProvider fdp(data, size); std::string deviceId = fdp.ConsumeRandomLengthString(size); std::string dhId = fdp.ConsumeRandomLengthString(size); ->>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); -======= std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -286,29 +220,18 @@ void DCameraDeviceResetFuzzTest(const uint8_t* data, size_t size) return; } -<<<<<<< HEAD - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); -======= FuzzedDataProvider fdp(data, size); std::string deviceId = fdp.ConsumeRandomLengthString(size); std::string dhId = fdp.ConsumeRandomLengthString(size); ->>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); -======= std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -321,29 +244,18 @@ void DCameraDeviceGetDefaultSettingsFuzzTest(const uint8_t* data, size_t size) return; } -<<<<<<< HEAD - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); -======= FuzzedDataProvider fdp(data, size); std::string deviceId = fdp.ConsumeRandomLengthString(size); std::string dhId = fdp.ConsumeRandomLengthString(size); ->>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); -======= std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -358,17 +270,6 @@ void DCameraDeviceSetResultModeFuzzTest(const uint8_t* data, size_t size) return; } -<<<<<<< HEAD - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); - DHBase dhBase; - dhBase.deviceId_ = deviceId; - dhBase.dhId_ = dhId; - - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); -======= FuzzedDataProvider fdp(data, size); std::string deviceId = fdp.ConsumeRandomLengthString(size); std::string dhId = fdp.ConsumeRandomLengthString(size); @@ -380,7 +281,6 @@ void DCameraDeviceSetResultModeFuzzTest(const uint8_t* data, size_t size) std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -394,18 +294,6 @@ void DCameraDeviceGetEnabledResultsFuzzTest(const uint8_t* data, size_t size) if ((data == nullptr) || (size == 0)) { return; } -<<<<<<< HEAD - - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); - DHBase dhBase; - dhBase.deviceId_ = deviceId; - dhBase.dhId_ = dhId; - - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); -======= FuzzedDataProvider fdp(data, size); std::string deviceId = fdp.ConsumeRandomLengthString(size); std::string dhId = fdp.ConsumeRandomLengthString(size); @@ -417,7 +305,6 @@ void DCameraDeviceGetEnabledResultsFuzzTest(const uint8_t* data, size_t size) std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -432,29 +319,18 @@ void DCameraEnableResultFuzzTest(const uint8_t* data, size_t size) return; } -<<<<<<< HEAD - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); -======= FuzzedDataProvider fdp(data, size); std::string deviceId = fdp.ConsumeRandomLengthString(size); std::string dhId = fdp.ConsumeRandomLengthString(size); ->>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); -======= std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -471,30 +347,19 @@ void DCameraDisableResultFuzzTest(const uint8_t* data, size_t size) return; } -<<<<<<< HEAD - std::string deviceId(reinterpret_cast(data), size); - std::string dhId(reinterpret_cast(data), size); -======= FuzzedDataProvider fdp(data, size); std::string deviceId = fdp.ConsumeRandomLengthString(size); std::string dhId = fdp.ConsumeRandomLengthString(size); ->>>>>>> origin/dev_addFUZZ DHBase dhBase; dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo(reinterpret_cast(data), size); - std::string srcAbilityInfo(reinterpret_cast(data), size); - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); -======= FuzzedDataProvider fdp(data, size); std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -517,25 +382,15 @@ void DCameraAcquireBufferFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo = "sinkAbilityInfo"; - std::string sourceCodecInfo = "sourceCodecInfo"; - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); -======= FuzzedDataProvider fdp(data, size); std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } -<<<<<<< HEAD - FuzzedDataProvider fdp(data, size); -======= ->>>>>>> origin/dev_addFUZZ int32_t streamId = fdp.ConsumeIntegral(); DCameraBuffer buffer; buffer.index_ = fdp.ConsumeIntegral(); @@ -556,25 +411,15 @@ void DCameraShutterBufferFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo = "sinkAbilityInfo"; - std::string sourceCodecInfo = "sourceCodecInfo"; - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); -======= FuzzedDataProvider fdp(data, size); std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } -<<<<<<< HEAD - FuzzedDataProvider fdp(data, size); -======= ->>>>>>> origin/dev_addFUZZ int32_t streamId = fdp.ConsumeIntegral(); DCameraBuffer buffer; buffer.index_ = fdp.ConsumeIntegral(); @@ -595,25 +440,15 @@ void DCameraOnSettingsResultFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo = "sinkAbilityInfo"; - std::string sourceCodecInfo = "sourceCodecInfo"; - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); -======= FuzzedDataProvider fdp(data, size); std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } -<<<<<<< HEAD - FuzzedDataProvider fdp(data, size); -======= ->>>>>>> origin/dev_addFUZZ DCameraSettings result; result.type_ = static_cast(fdp.ConsumeIntegral()); result.value_ = fdp.ConsumeRemainingBytesAsString(); @@ -633,25 +468,15 @@ void DCameraNotifyFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo = "sinkAbilityInfo"; - std::string sourceCodecInfo = "sourceCodecInfo"; - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); -======= FuzzedDataProvider fdp(data, size); std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } -<<<<<<< HEAD - FuzzedDataProvider fdp(data, size); -======= ->>>>>>> origin/dev_addFUZZ std::shared_ptr event = std::make_shared(); event->type_ = static_cast(fdp.ConsumeIntegral()); event->result_ = static_cast(fdp.ConsumeIntegral()); @@ -672,27 +497,17 @@ void DCameraIsOpenSessFailedStateFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo = "sinkAbilityInfo"; - std::string sourceCodecInfo = "sourceCodecInfo"; - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); -======= FuzzedDataProvider fdp(data, size); std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } FuzzedDataProvider fdp(data, size); bool state = fdp.ConsumeBool(); -<<<<<<< HEAD - -======= ->>>>>>> origin/dev_addFUZZ dcameraDevice->IsOpenSessFailedState(state); } @@ -708,17 +523,11 @@ void DCameraNotifyStartCaptureErrorFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo = "sinkAbilityInfo"; - std::string sourceCodecInfo = "sourceCodecInfo"; - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); -======= FuzzedDataProvider fdp(data, size); std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } @@ -738,25 +547,15 @@ void DCameraNotifyCameraErrorFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo = "sinkAbilityInfo"; - std::string sourceCodecInfo = "sourceCodecInfo"; - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); -======= FuzzedDataProvider fdp(data, size); std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } -<<<<<<< HEAD - FuzzedDataProvider fdp(data, size); -======= ->>>>>>> origin/dev_addFUZZ ErrorType errorType = static_cast(fdp.ConsumeIntegral()); dcameraDevice->NotifyCameraError(errorType); @@ -774,28 +573,16 @@ void DCameraSetDcameraAbilityFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; -<<<<<<< HEAD - std::string sinkAbilityInfo = "sinkAbilityInfo"; - std::string sourceCodecInfo = "sourceCodecInfo"; - OHOS::sptr dcameraDevice(new DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); -======= FuzzedDataProvider fdp(data, size); std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size); OHOS::sptr dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo)); ->>>>>>> origin/dev_addFUZZ if (dcameraDevice == nullptr) { return; } -<<<<<<< HEAD - FuzzedDataProvider fdp(data, size); - std::string randomSinkAbilityInfo = fdp.ConsumeRemainingBytesAsString(); - -======= std::string randomSinkAbilityInfo = fdp.ConsumeRemainingBytesAsString(); ->>>>>>> origin/dev_addFUZZ dcameraDevice->SetDcameraAbility(randomSinkAbilityInfo); } } diff --git a/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp b/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp index 836b6fa3ca..dc1b093a60 100644 --- a/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp +++ b/distributed_camera/hdi_service/test/fuzztest/dcamerahost_fuzzer/dcamerahost_fuzzer.cpp @@ -17,11 +17,7 @@ #include #include -<<<<<<< HEAD -#include -======= #include ->>>>>>> origin/dev_addFUZZ #include "dcamera_host.h" @@ -112,13 +108,9 @@ void DCameraGetResourceCostFuzzTest(const uint8_t* data, size_t size) if ((data == nullptr) || (size == 0)) { return; } -<<<<<<< HEAD - std::string cameraId(reinterpret_cast(data), size); -======= FuzzedDataProvider fdp(data, size); std::string cameraId = fdp.ConsumeRandomLengthString(size); ->>>>>>> origin/dev_addFUZZ OHOS::HDI::Camera::V1_3::CameraDeviceResourceCost resourceCost; DCameraHost::GetInstance()->GetResourceCost(cameraId, resourceCost); @@ -126,22 +118,12 @@ void DCameraGetResourceCostFuzzTest(const uint8_t* data, size_t size) void DCameraNotifyDeviceStateChangeInfoFuzzTest(const uint8_t* data, size_t size) { -<<<<<<< HEAD - int doubleNum = 2; - if ((data == nullptr) || (size < sizeof(int32_t) * doubleNum)) { - return; - } - FuzzedDataProvider fdp(data, size); - int32_t notifyType = *(reinterpret_cast(data)); - int32_t deviceState = *(reinterpret_cast(data + sizeof(int32_t))); -======= if ((data == nullptr) || (size < sizeof(int32_t) * 2)) { return; } FuzzedDataProvider fdp(data, size); int32_t notifyType = fdp.ConsumeIntegral(); int32_t deviceState = fdp.ConsumeIntegral(); ->>>>>>> origin/dev_addFUZZ DCameraHost::GetInstance()->NotifyDeviceStateChangeInfo(notifyType, deviceState); } @@ -150,13 +132,9 @@ void DCameraPreCameraSwitchFuzzTest(const uint8_t* data, size_t size) if ((data == nullptr) || (size == 0)) { return; } -<<<<<<< HEAD - std::string cameraId(reinterpret_cast(data), size); -======= FuzzedDataProvider fdp(data, size); std::string cameraId = fdp.ConsumeRandomLengthString(size); ->>>>>>> origin/dev_addFUZZ DCameraHost::GetInstance()->PreCameraSwitch(cameraId); } @@ -165,13 +143,9 @@ void DCameraPrelaunchWithOpModeFuzzTest(const uint8_t* data, size_t size) if ((data == nullptr) || (size < sizeof(int32_t))) { return; } -<<<<<<< HEAD - int32_t operationMode = *(reinterpret_cast(data)); -======= FuzzedDataProvider fdp(data, size); int32_t operationMode = fdp.ConsumeIntegral(); ->>>>>>> origin/dev_addFUZZ PrelaunchConfig config; DCameraHost::GetInstance()->PrelaunchWithOpMode(config, operationMode); } -- Gitee From 6939baded1ea1aac7f56ca100f0e3b870f26681c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=9F=A6=E5=9B=BD=E5=BA=86?= Date: Mon, 23 Jun 2025 13:34:43 +0800 Subject: [PATCH 5/5] add FUZZ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 韦国庆 --- .../dcameradeviceupdatesettings_fuzzer.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp b/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp index 563afeefe6..63faabbad5 100644 --- a/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp +++ b/distributed_camera/hdi_service/test/fuzztest/dcameradeviceupdatesettings_fuzzer/dcameradeviceupdatesettings_fuzzer.cpp @@ -355,7 +355,6 @@ void DCameraDisableResultFuzzTest(const uint8_t* data, size_t size) dhBase.deviceId_ = deviceId; dhBase.dhId_ = dhId; - FuzzedDataProvider fdp(data, size); std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size); std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size); @@ -506,7 +505,6 @@ void DCameraIsOpenSessFailedStateFuzzTest(const uint8_t* data, size_t size) return; } - FuzzedDataProvider fdp(data, size); bool state = fdp.ConsumeBool(); dcameraDevice->IsOpenSessFailedState(state); } -- Gitee