diff --git a/distributed_camera/hdi_service/include/dcamera_host/dcamera_host.h b/distributed_camera/hdi_service/include/dcamera_host/dcamera_host.h
index fec52a3dab3bea35e458ff6c9455bd823d7f77d1..81b5f7c0b88c69cfe52d33bc32d824e8301de07b 100644
--- a/distributed_camera/hdi_service/include/dcamera_host/dcamera_host.h
+++ b/distributed_camera/hdi_service/include/dcamera_host/dcamera_host.h
@@ -23,12 +23,15 @@
 #include "v1_0/icamera_host_callback.h"
 #include "v1_0/dcamera_types.h"
 #include "v1_0/types.h"
+#include "constants.h"
 
 namespace OHOS {
 namespace DistributedHardware {
 using namespace OHOS::HDI::DistributedCamera::V1_0;
 using namespace OHOS::HDI::Camera::V1_0;
 class DCameraHost : public ICameraHost {
+const uint32_t ABILITYINFO_MAX_LENGTH = 50 * 1024 * 1024;
+const uint32_t ID_MAX_SIZE = 2 * DEVID_MAX_LENGTH;
 public:
     DCameraHost() = default;
     virtual ~DCameraHost() = default;
diff --git a/distributed_camera/hdi_service/include/dcamera_provider/dcamera_provider.h b/distributed_camera/hdi_service/include/dcamera_provider/dcamera_provider.h
index 2bb093a8d519dbdd64984e1c52b2daedf991ba36..76ddab0da22c4cdd79504128896a8192b3bfc4d9 100644
--- a/distributed_camera/hdi_service/include/dcamera_provider/dcamera_provider.h
+++ b/distributed_camera/hdi_service/include/dcamera_provider/dcamera_provider.h
@@ -24,6 +24,9 @@ using namespace OHOS::HDI::DistributedCamera::V1_0;
 class DCameraHost;
 class DCameraDevice;
 class DCameraProvider : public IDCameraProvider {
+const uint32_t ABILITYINFO_MAX_LENGTH = 50 * 1024 * 1024;
+const uint32_t HDF_EVENT_CONTENT_MAX_LENGTH = 50 * 1024 * 1024;
+const uint32_t SETTING_VALUE_MAX_LENGTH = 50 * 1024 * 1024;
 public:
     DCameraProvider() = default;
     virtual ~DCameraProvider() = default;
@@ -51,7 +54,8 @@ public:
     int32_t UpdateSettings(const DHBase &dhBase, const std::vector<DCameraSettings> &settings);
 
 private:
-    bool IsDhBaseInfoInvalid(const DHBase &dhBase);
+    bool IsDCameraSettingsInvalid(const DCameraSettings& result);
+    bool IsDCameraHDFEventInvalid(const DCameraHDFEvent& event);
     sptr<IDCameraProviderCallback> GetCallbackBydhBase(const DHBase &dhBase);
     OHOS::sptr<DCameraDevice> GetDCameraDevice(const DHBase &dhBase);
 
diff --git a/distributed_camera/hdi_service/include/dstream_operator/dstream_operator.h b/distributed_camera/hdi_service/include/dstream_operator/dstream_operator.h
index 5dd817c2c1278c97564fa64278522a06c766be6e..ea4382ce8b7233bc1870a3af26ba26b7c7d58801 100644
--- a/distributed_camera/hdi_service/include/dstream_operator/dstream_operator.h
+++ b/distributed_camera/hdi_service/include/dstream_operator/dstream_operator.h
@@ -116,6 +116,11 @@ private:
     void AddStreamCaptureBufferNum(const pair<int, int>& streamPair);
     void EraseStreamCaptureBufferNum(const pair<int, int>& streamPair);
 
+    bool IsStreamInfosInvalid(const std::vector<StreamInfo> &infos);
+    bool IsCaptureInfoInvalid(const CaptureInfo &info);
+
+    int32_t DoCapture(int32_t captureId, const CaptureInfo &info, bool isStreaming);
+
 private:
     std::shared_ptr<DMetadataProcessor> dMetadataProcessor_;
     OHOS::sptr<IStreamOperatorCallback> dcStreamOperatorCallback_;
diff --git a/distributed_camera/hdi_service/include/utils/constants.h b/distributed_camera/hdi_service/include/utils/constants.h
index 3288141679e9574179035089eaa8c9e4bc27aedd..548a5808e3c553f2d4d86bdbe7d77dc74629eac5 100644
--- a/distributed_camera/hdi_service/include/utils/constants.h
+++ b/distributed_camera/hdi_service/include/utils/constants.h
@@ -24,8 +24,12 @@ namespace DistributedHardware {
 const uint32_t YUV_WIDTH_RATIO = 3;
 const uint32_t YUV_HEIGHT_RATIO = 2;
 
-const uint32_t DEVID_MAX_LENGTH = 64;
-const uint32_t DHID_MAX_LENGTH = 64;
+const uint32_t DEVID_MAX_LENGTH = 256;
+const uint32_t DHID_MAX_LENGTH =  256;
+const uint32_t CONTAINER_CAPACITY_MAX_SIZE = 10 * 1024;
+const uint32_t METADATA_CAPACITY_MAX_SIZE = 10 * 1024 * 1024;
+const int32_t STREAM_HEIGHT_MAX_SIZE = 10000;
+const int32_t STREAM_WIDTH_MAX_SIZE = 10000;
 
 constexpr size_t DEFAULT_ENTRY_CAPACITY = 100;
 constexpr size_t DEFAULT_DATA_CAPACITY = 2000;
diff --git a/distributed_camera/hdi_service/include/utils/dcamera.h b/distributed_camera/hdi_service/include/utils/dcamera.h
index 9798789c22f35c37ab8b522fb02ba0deec3ec4f3..f390f81ffd8b1b62c37a5145c32ab723550df41e 100644
--- a/distributed_camera/hdi_service/include/utils/dcamera.h
+++ b/distributed_camera/hdi_service/include/utils/dcamera.h
@@ -44,6 +44,8 @@ std::string Base64Encode(const unsigned char *toEncode, unsigned int len);
 std::string Base64Decode(const std::string& basicString);
 
 bool IsBase64(unsigned char c);
+
+bool IsDhBaseInfoInvalid(const DHBase& dhBase);
 } // namespace DistributedHardware
 } // namespace OHOS
 #endif // DISTRIBUTED_CAMERA_H
diff --git a/distributed_camera/hdi_service/src/dcamera_device/dcamera_device.cpp b/distributed_camera/hdi_service/src/dcamera_device/dcamera_device.cpp
index f727496e274157858916ee91d9249bf1158d924a..a47022babd6ebb4af6c88682c1c989d13761ab6e 100644
--- a/distributed_camera/hdi_service/src/dcamera_device/dcamera_device.cpp
+++ b/distributed_camera/hdi_service/src/dcamera_device/dcamera_device.cpp
@@ -88,16 +88,16 @@ DCamRetCode DCameraDevice::CreateDStreamOperator()
 int32_t DCameraDevice::GetStreamOperator(const sptr<IStreamOperatorCallback> &callbackObj,
     sptr<IStreamOperator> &streamOperator)
 {
-    if (dCameraStreamOperator_ == nullptr) {
-        DHLOGE("Distributed camera stream operator not init.");
-        return CamRetCode::DEVICE_ERROR;
-    }
-
     if (callbackObj == nullptr) {
-        DHLOGE("Input callbackObj is null.");
+        DHLOGE("DCameraDevice::GetStreamOperator, input stream operator callback is null.");
         return CamRetCode::INVALID_ARGUMENT;
     }
 
+    if (dCameraStreamOperator_ == nullptr) {
+        DHLOGE("DCameraDevice::GetStreamOperator, input distributed camera stream operator is null.");
+        return CamRetCode::DEVICE_ERROR;
+    }
+
     DCamRetCode ret = dCameraStreamOperator_->SetCallBack(callbackObj);
     if (ret != SUCCESS) {
         DHLOGE("Set stream operator callbackObj failed, ret=%d.", ret);
@@ -110,8 +110,8 @@ int32_t DCameraDevice::GetStreamOperator(const sptr<IStreamOperatorCallback> &ca
 
 int32_t DCameraDevice::UpdateSettings(const std::vector<uint8_t>& settings)
 {
-    if (settings.empty()) {
-        DHLOGE("DCameraDevice::UpdateSettings, input settings is null.");
+    if (settings.empty() || settings.size() > METADATA_CAPACITY_MAX_SIZE) {
+        DHLOGE("DCameraDevice::UpdateSettings, input settings is invalid.");
         return CamRetCode::INVALID_ARGUMENT;
     }
 
@@ -173,6 +173,11 @@ int32_t DCameraDevice::GetEnabledResults(std::vector<int32_t> &results)
 
 int32_t DCameraDevice::EnableResult(const std::vector<int32_t> &results)
 {
+    if (results.empty() || results.size() > METADATA_CAPACITY_MAX_SIZE) {
+        DHLOGE("DCameraDevice::EnableResult, input results is invalid.");
+        return CamRetCode::DEVICE_ERROR;
+    }
+
     if (dMetadataProcessor_ == nullptr) {
         DHLOGE("Metadata processor not init.");
         return CamRetCode::DEVICE_ERROR;
@@ -203,6 +208,11 @@ int32_t DCameraDevice::EnableResult(const std::vector<int32_t> &results)
 
 int32_t DCameraDevice::DisableResult(const std::vector<int32_t> &results)
 {
+    if (results.empty() || results.size() > METADATA_CAPACITY_MAX_SIZE) {
+        DHLOGE("DCameraDevice::DisableResult, input results is invalid.");
+        return CamRetCode::DEVICE_ERROR;
+    }
+
     if (dMetadataProcessor_ == nullptr) {
         DHLOGE("Metadata processor not init.");
         return CamRetCode::DEVICE_ERROR;
diff --git a/distributed_camera/hdi_service/src/dcamera_host/dcamera_host.cpp b/distributed_camera/hdi_service/src/dcamera_host/dcamera_host.cpp
index f0552f23224a0320a093672189c4ee53d3c6ec09..c1394ac71547834f67e5df800652048a7d6dfdd7 100644
--- a/distributed_camera/hdi_service/src/dcamera_host/dcamera_host.cpp
+++ b/distributed_camera/hdi_service/src/dcamera_host/dcamera_host.cpp
@@ -18,6 +18,7 @@
 #include "anonymous_string.h"
 #include "distributed_hardware_log.h"
 #include "metadata_utils.h"
+#include "dcamera.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -44,7 +45,7 @@ OHOS::sptr<DCameraHost> DCameraHost::GetInstance()
 int32_t DCameraHost::SetCallback(const sptr<ICameraHostCallback> &callbackObj)
 {
     if (callbackObj == nullptr) {
-        DHLOGE("DCameraHost::SetCallback, camera host callback is null.");
+        DHLOGE("DCameraHost::SetCallback, input camera host callback is null.");
         return CamRetCode::INVALID_ARGUMENT;
     }
     dCameraHostCallback_ = callbackObj;
@@ -65,13 +66,13 @@ int32_t DCameraHost::GetCameraIds(std::vector<std::string> &cameraIds)
 
 int32_t DCameraHost::GetCameraAbility(const std::string &cameraId, std::vector<uint8_t> &cameraAbility)
 {
-    DHLOGE("DCameraHost::GetCameraAbility for cameraId: %s", GetAnonyString(cameraId).c_str());
-
     if (IsCameraIdInvalid(cameraId)) {
-        DHLOGE("DCameraHost::GetCameraAbility, invalid camera id.");
+        DHLOGE("DCameraHost::GetCameraAbility, input cameraId is invalid.");
         return CamRetCode::INVALID_ARGUMENT;
     }
 
+    DHLOGE("DCameraHost::GetCameraAbility for cameraId: %s", GetAnonyString(cameraId).c_str());
+
     auto iter = dCameraDeviceMap_.find(cameraId);
     std::shared_ptr<CameraAbility> ability = nullptr;
     int32_t ret = (iter->second)->GetDCameraAbility(ability);
@@ -114,13 +115,13 @@ int32_t DCameraHost::GetCameraAbility(const std::string &cameraId, std::vector<u
 int32_t DCameraHost::OpenCamera(const std::string &cameraId, const sptr<ICameraDeviceCallback> &callbackObj,
     sptr<ICameraDevice> &device)
 {
-    DHLOGI("DCameraHost::OpenCamera for cameraId: %s", GetAnonyString(cameraId).c_str());
-
     if (IsCameraIdInvalid(cameraId) || callbackObj == nullptr) {
-        DHLOGE("DCameraHost::OpenCamera, open camera id is empty or callback is null.");
+        DHLOGE("DCameraHost::OpenCamera, open camera id is invalid or camera device callback is null.");
         return CamRetCode::INVALID_ARGUMENT;
     }
 
+    DHLOGI("DCameraHost::OpenCamera for cameraId: %s", GetAnonyString(cameraId).c_str());
+
     auto iter = dCameraDeviceMap_.find(cameraId);
     if (iter == dCameraDeviceMap_.end()) {
         DHLOGE("DCameraHost::OpenCamera, dcamera device not found.");
@@ -161,9 +162,18 @@ int32_t DCameraHost::SetFlashlight(const std::string &cameraId, bool isEnable)
 DCamRetCode DCameraHost::AddDCameraDevice(const DHBase &dhBase, const std::string &abilityInfo,
     const sptr<IDCameraProviderCallback> &callback)
 {
+    if (IsDhBaseInfoInvalid(dhBase)) {
+        DHLOGE("DCameraHost::AddDCameraDevice, devId or dhId is invalid.");
+        return DCamRetCode::INVALID_ARGUMENT;
+    }
     DHLOGI("DCameraHost::AddDCameraDevice for {devId: %s, dhId: %s}",
         GetAnonyString(dhBase.deviceId_).c_str(), GetAnonyString(dhBase.dhId_).c_str());
 
+    if (abilityInfo.empty() || abilityInfo.length() > ABILITYINFO_MAX_LENGTH) {
+        DHLOGE("DCameraHost::AddDCameraDevice, input abilityInfo is invalid.");
+        return DCamRetCode::INVALID_ARGUMENT;
+    }
+
     OHOS::sptr<DCameraDevice> dcameraDevice = new (std::nothrow) DCameraDevice(dhBase, abilityInfo);
     if (dcameraDevice == nullptr) {
         DHLOGE("DCameraHost::AddDCameraDevice, create dcamera device failed.");
@@ -219,7 +229,7 @@ DCamRetCode DCameraHost::RemoveDCameraDevice(const DHBase &dhBase)
 
 bool DCameraHost::IsCameraIdInvalid(const std::string &cameraId)
 {
-    if (cameraId.empty()) {
+    if (cameraId.empty() || cameraId.length() > ID_MAX_SIZE) {
         return true;
     }
 
diff --git a/distributed_camera/hdi_service/src/dcamera_provider/dcamera_provider.cpp b/distributed_camera/hdi_service/src/dcamera_provider/dcamera_provider.cpp
index d2987c39e0586ebbb231995bead23ea3fc98a43d..dde17638d48545f6b08231b22e37144af79b0862 100644
--- a/distributed_camera/hdi_service/src/dcamera_provider/dcamera_provider.cpp
+++ b/distributed_camera/hdi_service/src/dcamera_provider/dcamera_provider.cpp
@@ -19,6 +19,7 @@
 #include "dcamera_device.h"
 #include "dcamera_host.h"
 #include "distributed_hardware_log.h"
+#include "dcamera.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -45,19 +46,19 @@ OHOS::sptr<DCameraProvider> DCameraProvider::GetInstance()
 int32_t DCameraProvider::EnableDCameraDevice(const DHBase& dhBase, const std::string& abilityInfo,
     const sptr<IDCameraProviderCallback>& callbackObj)
 {
-    DHLOGI("DCameraProvider::EnableDCameraDevice for {devId: %s, dhId: %s, abilityInfo length: %d}.",
-        GetAnonyString(dhBase.deviceId_).c_str(), GetAnonyString(dhBase.dhId_).c_str(), abilityInfo.length());
-
     if (IsDhBaseInfoInvalid(dhBase)) {
         DHLOGE("DCameraProvider::EnableDCameraDevice, devId or dhId is invalid.");
         return DCamRetCode::INVALID_ARGUMENT;
     }
-    if (abilityInfo.empty()) {
-        DHLOGE("DCameraProvider::EnableDCameraDevice, dcamera ability is empty.");
+    DHLOGI("DCameraProvider::EnableDCameraDevice for {devId: %s, dhId: %s, abilityInfo length: %d}.",
+        GetAnonyString(dhBase.deviceId_).c_str(), GetAnonyString(dhBase.dhId_).c_str(), abilityInfo.length());
+
+    if (abilityInfo.empty() || abilityInfo.length() > ABILITYINFO_MAX_LENGTH) {
+        DHLOGE("DCameraProvider::EnableDCameraDevice, dcamera ability is empty or over limit.");
         return DCamRetCode::INVALID_ARGUMENT;
     }
     if (callbackObj == nullptr) {
-        DHLOGE("DCameraProvider::EnableDCameraDevice, dcamera provider callbackObj is null.");
+        DHLOGE("DCameraProvider::EnableDCameraDevice, dcamera provider callback is null.");
         return DCamRetCode::INVALID_ARGUMENT;
     }
 
@@ -76,13 +77,12 @@ int32_t DCameraProvider::EnableDCameraDevice(const DHBase& dhBase, const std::st
 
 int32_t DCameraProvider::DisableDCameraDevice(const DHBase& dhBase)
 {
-    DHLOGI("DCameraProvider::DisableDCameraDevice for {devId: %s, dhId: %s}.",
-        GetAnonyString(dhBase.deviceId_).c_str(), GetAnonyString(dhBase.dhId_).c_str());
-
     if (IsDhBaseInfoInvalid(dhBase)) {
         DHLOGE("DCameraProvider::DisableDCameraDevice, devId or dhId is invalid.");
         return DCamRetCode::INVALID_ARGUMENT;
     }
+    DHLOGI("DCameraProvider::DisableDCameraDevice for {devId: %s, dhId: %s}.",
+        GetAnonyString(dhBase.deviceId_).c_str(), GetAnonyString(dhBase.dhId_).c_str());
 
     OHOS::sptr<DCameraHost> dCameraHost = DCameraHost::GetInstance();
     if (dCameraHost == nullptr) {
@@ -100,6 +100,15 @@ int32_t DCameraProvider::DisableDCameraDevice(const DHBase& dhBase)
 
 int32_t DCameraProvider::AcquireBuffer(const DHBase& dhBase, int32_t streamId, DCameraBuffer& buffer)
 {
+    if (IsDhBaseInfoInvalid(dhBase)) {
+        DHLOGE("DCameraProvider::AcquireBuffer, devId or dhId is invalid.");
+        return DCamRetCode::INVALID_ARGUMENT;
+    }
+    if (streamId < 0) {
+        DHLOGE("DCameraProvider::AcquireBuffer, input streamId is invalid.");
+        return DCamRetCode::INVALID_ARGUMENT;
+    }
+
     DHLOGD("DCameraProvider::AcquireBuffer for {devId: %s, dhId: %s}, streamId: %d.",
         GetAnonyString(dhBase.deviceId_).c_str(), GetAnonyString(dhBase.dhId_).c_str(), streamId);
 
@@ -119,6 +128,19 @@ int32_t DCameraProvider::AcquireBuffer(const DHBase& dhBase, int32_t streamId, D
 
 int32_t DCameraProvider::ShutterBuffer(const DHBase& dhBase, int32_t streamId, const DCameraBuffer& buffer)
 {
+    if (IsDhBaseInfoInvalid(dhBase)) {
+        DHLOGE("DCameraProvider::ShutterBuffer, devId or dhId is invalid.");
+        return DCamRetCode::INVALID_ARGUMENT;
+    }
+    if (buffer.index_ < 0 || buffer.size_ < 0) {
+        DHLOGE("DCameraProvider::ShutterBuffer, input dcamera buffer is invalid.");
+        return DCamRetCode::INVALID_ARGUMENT;
+    }
+    if (streamId < 0) {
+        DHLOGE("DCameraProvider::ShutterBuffer, input streamId is invalid.");
+        return DCamRetCode::INVALID_ARGUMENT;
+    }
+
     DHLOGD("DCameraProvider::ShutterBuffer for {devId: %s, dhId: %s}, streamId = %d, buffer index = %d.",
         GetAnonyString(dhBase.deviceId_).c_str(), GetAnonyString(dhBase.dhId_).c_str(), streamId, buffer.index_);
 
@@ -136,6 +158,14 @@ int32_t DCameraProvider::ShutterBuffer(const DHBase& dhBase, int32_t streamId, c
 
 int32_t DCameraProvider::OnSettingsResult(const DHBase& dhBase, const DCameraSettings& result)
 {
+    if (IsDhBaseInfoInvalid(dhBase)) {
+        DHLOGE("DCameraProvider::OnSettingsResult, devId or dhId is invalid.");
+        return DCamRetCode::INVALID_ARGUMENT;
+    }
+    if (IsDCameraSettingsInvalid(result)) {
+        DHLOGE("DCameraProvider::OnSettingsResult, input dcamera settings is valid.");
+        return DCamRetCode::INVALID_ARGUMENT;
+    }
     DHLOGI("DCameraProvider::OnSettingsResult for {devId: %s, dhId: %s}.",
         GetAnonyString(dhBase.deviceId_).c_str(), GetAnonyString(dhBase.dhId_).c_str());
 
@@ -153,6 +183,14 @@ int32_t DCameraProvider::OnSettingsResult(const DHBase& dhBase, const DCameraSet
 
 int32_t DCameraProvider::Notify(const DHBase& dhBase, const DCameraHDFEvent& event)
 {
+    if (IsDhBaseInfoInvalid(dhBase)) {
+        DHLOGE("DCameraProvider::Notify, devId or dhId is invalid.");
+        return DCamRetCode::INVALID_ARGUMENT;
+    }
+    if (IsDCameraHDFEventInvalid(event)) {
+        DHLOGE("DCameraProvider::Notify, input dcamera hdf event is null.");
+        return DCamRetCode::INVALID_ARGUMENT;
+    }
     DHLOGI("DCameraProvider::Notify for {devId: %s, dhId: %s}.",
         GetAnonyString(dhBase.deviceId_).c_str(), GetAnonyString(dhBase.dhId_).c_str());
 
@@ -291,10 +329,14 @@ int32_t DCameraProvider::UpdateSettings(const DHBase &dhBase, const std::vector<
     return callback->UpdateSettings(dhBase, settings);
 }
 
-bool DCameraProvider::IsDhBaseInfoInvalid(const DHBase &dhBase)
+bool DCameraProvider::IsDCameraSettingsInvalid(const DCameraSettings& result)
+{
+    return result.value_.empty() || result.value_.length() > SETTING_VALUE_MAX_LENGTH;
+}
+
+bool DCameraProvider::IsDCameraHDFEventInvalid(const DCameraHDFEvent& event)
 {
-    return dhBase.deviceId_.empty() || (dhBase.deviceId_.size() > DEVID_MAX_LENGTH) ||
-        dhBase.dhId_.empty() || (dhBase.dhId_.size() > DHID_MAX_LENGTH);
+    return event.content_.length() > HDF_EVENT_CONTENT_MAX_LENGTH;
 }
 
 sptr<IDCameraProviderCallback> DCameraProvider::GetCallbackBydhBase(const DHBase &dhBase)
diff --git a/distributed_camera/hdi_service/src/dstream_operator/dstream_operator.cpp b/distributed_camera/hdi_service/src/dstream_operator/dstream_operator.cpp
index 68dd15cf48423a4567539f8c8e36028297a244b9..5b6687183d824a0500e6929b8113aad02c791a6a 100644
--- a/distributed_camera/hdi_service/src/dstream_operator/dstream_operator.cpp
+++ b/distributed_camera/hdi_service/src/dstream_operator/dstream_operator.cpp
@@ -19,6 +19,7 @@
 #include "dcamera.h"
 #include "distributed_hardware_log.h"
 #include "metadata_utils.h"
+#include "constants.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -31,6 +32,11 @@ DStreamOperator::DStreamOperator(std::shared_ptr<DMetadataProcessor> &dMetadataP
 int32_t DStreamOperator::IsStreamsSupported(OperationMode mode, const std::vector<uint8_t> &modeSetting,
     const std::vector<StreamInfo> &infos, StreamSupportType &type)
 {
+    if (IsStreamInfosInvalid(infos)) {
+        DHLOGE("DStreamOperator::IsStreamsSupported, input stream infos is invalid.");
+        return CamRetCode::INVALID_ARGUMENT;
+    }
+
     (void)mode;
     (void)modeSetting;
     type = DYNAMIC_SUPPORTED;
@@ -47,12 +53,13 @@ int32_t DStreamOperator::IsStreamsSupported(OperationMode mode, const std::vecto
 
 int32_t DStreamOperator::CreateStreams(const std::vector<StreamInfo> &streamInfos)
 {
-    DHLOGI("DStreamOperator::CreateStreams, input stream info size=%d.", streamInfos.size());
-    if (streamInfos.empty()) {
-        DHLOGE("DStreamOperator::CreateStreams, input stream info is empty.");
+    if (IsStreamInfosInvalid(streamInfos)) {
+        DHLOGE("DStreamOperator::CreateStreams, input stream Infos is invalid.");
         return CamRetCode::INVALID_ARGUMENT;
     }
 
+    DHLOGI("DStreamOperator::CreateStreams, input stream info size=%d.", streamInfos.size());
+
     for (const auto &info : streamInfos) {
         DHLOGI("DStreamOperator::CreateStreams, streamInfo: id=%d, intent=%d, width=%d, height=%d, format=%d, " +
             "dataspace=%d, encodeType=%d", info.streamId_, info.intent_, info.width_, info.height_, info.format_,
@@ -85,7 +92,13 @@ int32_t DStreamOperator::CreateStreams(const std::vector<StreamInfo> &streamInfo
 
 int32_t DStreamOperator::ReleaseStreams(const std::vector<int32_t> &streamIds)
 {
+    if (streamIds.empty() || streamIds.size() > CONTAINER_CAPACITY_MAX_SIZE) {
+        DHLOGE("DStreamOperator::ReleaseStreams, input streamIds is invalid.");
+        return CamRetCode::INVALID_ARGUMENT;
+    }
+
     DHLOGI("DStreamOperator::ReleaseStreams, input stream id list size=%d.", streamIds.size());
+
     if (IsCapturing()) {
         DHLOGE("Can not release streams when capture.");
         return CamRetCode::CAMERA_BUSY;
@@ -150,6 +163,12 @@ int32_t DStreamOperator::ExtractStreamInfo(std::vector<DCStreamInfo>& dCameraStr
 int32_t DStreamOperator::CommitStreams(OperationMode mode, const std::vector<uint8_t> &modeSetting)
 {
     DHLOGI("DStreamOperator::CommitStreams, input operation mode=%d.", mode);
+
+    if (modeSetting.empty() || modeSetting.size() > METADATA_CAPACITY_MAX_SIZE) {
+        DHLOGE("DStreamOperator::CommitStreams, input modeSetting is invalid.");
+        return CamRetCode::INVALID_ARGUMENT;
+    }
+
     if (IsCapturing()) {
         DHLOGE("Can not commit streams when capture.");
         return CamRetCode::CAMERA_BUSY;
@@ -225,6 +244,16 @@ int32_t DStreamOperator::GetStreamAttributes(std::vector<StreamAttribute> &attri
 
 int32_t DStreamOperator::AttachBufferQueue(int32_t streamId, const sptr<BufferProducerSequenceable> &bufferProducer)
 {
+    if (streamId < 0) {
+        DHLOGE("DStreamOperator::AttachBufferQueue, input streamId is invalid.");
+        return CamRetCode::INVALID_ARGUMENT;
+    }
+
+    if (bufferProducer == nullptr) {
+        DHLOGE("DStreamOperator::AttachBufferQueue, input bufferProducer is null.");
+        return CamRetCode::INVALID_ARGUMENT;
+    }
+    
     if (IsCapturing()) {
         DHLOGE("Can not attach buffer queue when capture.");
         return CamRetCode::CAMERA_BUSY;
@@ -243,8 +272,38 @@ int32_t DStreamOperator::AttachBufferQueue(int32_t streamId, const sptr<BufferPr
     }
 }
 
+bool DStreamOperator::IsStreamInfosInvalid(const std::vector<StreamInfo> &infos)
+{
+    if (infos.empty() || infos.size() > CONTAINER_CAPACITY_MAX_SIZE) {
+        return true;
+    }
+    for (auto streamInfo : infos) {
+        if (streamInfo.streamId_ < 0 ||
+            streamInfo.width_ < 0 ||
+            streamInfo.width_ > (STREAM_WIDTH_MAX_SIZE * STREAM_HEIGHT_MAX_SIZE) ||
+            streamInfo.height_ < 0 ||
+            streamInfo.height_ > (STREAM_WIDTH_MAX_SIZE * STREAM_HEIGHT_MAX_SIZE) ||
+            streamInfo.format_ < 0 ||
+            streamInfo.dataspace_ < 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool DStreamOperator::IsCaptureInfoInvalid(const CaptureInfo &info)
+{
+    return info.streamIds_.size() == 0 || info.streamIds_.size() > CONTAINER_CAPACITY_MAX_SIZE ||
+        info.captureSetting_.size() == 0 || info.captureSetting_.size() > CONTAINER_CAPACITY_MAX_SIZE;
+}
+
 int32_t DStreamOperator::DetachBufferQueue(int32_t streamId)
 {
+    if (streamId < 0) {
+        DHLOGE("DStreamOperator::DetachBufferQueue, input streamId is invalid.");
+        return CamRetCode::INVALID_ARGUMENT;
+    }
+
     if (IsCapturing()) {
         DHLOGE("Can not detach buffer queue when capture.");
         return CamRetCode::CAMERA_BUSY;
@@ -283,11 +342,19 @@ void DStreamOperator::ExtractCaptureInfo(std::vector<DCCaptureInfo> &captureInfo
 
 int32_t DStreamOperator::Capture(int32_t captureId, const CaptureInfo &info, bool isStreaming)
 {
+    if (IsCaptureInfoInvalid(info)) {
+        DHLOGE("DStreamOperator::Capture, input capture info is valid.");
+        return CamRetCode::INVALID_ARGUMENT;
+    }
     if (captureId < 0 || FindCaptureInfoById(captureId) != nullptr) {
         DHLOGE("Input captureId %d is exist.", captureId);
         return CamRetCode::INVALID_ARGUMENT;
     }
+    return DoCapture(captureId, info, isStreaming);
+}
 
+int32_t DStreamOperator::DoCapture(int32_t captureId, const CaptureInfo &info, bool isStreaming)
+{
     for (const auto &id : info.streamIds_) {
         auto stream = FindHalStreamById(id);
         if (stream == nullptr) {
@@ -299,7 +366,8 @@ int32_t DStreamOperator::Capture(int32_t captureId, const CaptureInfo &info, boo
             return CamRetCode::INVALID_ARGUMENT;
         }
         InsertEnableShutter(id, info.enableShutterCallback_);
-        DHLOGI("DStreamOperator::Capture info: captureId=%d, streamId=%d, isStreaming=%d", captureId, id, isStreaming);
+        DHLOGI("DStreamOperator::DoCapture info: "+
+            "captureId=%d, streamId=%d, isStreaming=%d", captureId, id, isStreaming);
     }
 
     DCamRetCode ret = NegotiateSuitableCaptureInfo(info, isStreaming);
@@ -330,13 +398,18 @@ int32_t DStreamOperator::Capture(int32_t captureId, const CaptureInfo &info, boo
         dcStreamOperatorCallback_->OnCaptureStarted(captureId, info.streamIds_);
     }
     SetCapturing(true);
-    DHLOGI("DStreamOperator::Capture, start distributed camera capture success.");
+    DHLOGI("DStreamOperator::DoCapture, start distributed camera capture success.");
 
     return CamRetCode::NO_ERROR;
 }
 
 int32_t DStreamOperator::CancelCapture(int32_t captureId)
 {
+    if (captureId < 0) {
+        DHLOGE("DStreamOperator::CancelCapture, input captureId is valid.");
+        return CamRetCode::INVALID_ARGUMENT;
+    }
+
     DHLOGI("DStreamOperator::CancelCapture, cancel distributed camera capture, captureId=%d.", captureId);
     auto halCaptureInfo = FindCaptureInfoById(captureId);
     if (captureId < 0 || halCaptureInfo == nullptr) {
diff --git a/distributed_camera/hdi_service/src/utils/dcamera.cpp b/distributed_camera/hdi_service/src/utils/dcamera.cpp
index b8e31f6dee1ca313382bdcf11a422b23c12dea30..e341b4f5b6cfefe35f0afcdc8ce4826cb9d81bb9 100644
--- a/distributed_camera/hdi_service/src/utils/dcamera.cpp
+++ b/distributed_camera/hdi_service/src/utils/dcamera.cpp
@@ -15,6 +15,7 @@
 
 #include "dcamera.h"
 #include <chrono>
+#include "constants.h"
 
 namespace OHOS {
 namespace DistributedHardware {
@@ -195,5 +196,11 @@ bool IsBase64(unsigned char c)
 {
     return (isalnum(c) || (c == '+') || (c == '/'));
 }
+
+bool IsDhBaseInfoInvalid(const DHBase& dhBase)
+{
+    return dhBase.deviceId_.empty() || (dhBase.deviceId_.length() > DEVID_MAX_LENGTH) ||
+        dhBase.dhId_.empty() || (dhBase.dhId_.length() > DHID_MAX_LENGTH);
+}
 } // namespace DistributedHardware
 } // namespace OHOS