diff --git a/services/distributeddataservice/adapter/communicator/test/fuzztest/softbusadapter_fuzzer/softbusadapter_fuzzer.cpp b/services/distributeddataservice/adapter/communicator/test/fuzztest/softbusadapter_fuzzer/softbusadapter_fuzzer.cpp
index 6420589afdd61e62bb47defb6645247b673118b4..6b4d8d49013de8ba63054607240d3c29acc0ffc2 100644
--- a/services/distributeddataservice/adapter/communicator/test/fuzztest/softbusadapter_fuzzer/softbusadapter_fuzzer.cpp
+++ b/services/distributeddataservice/adapter/communicator/test/fuzztest/softbusadapter_fuzzer/softbusadapter_fuzzer.cpp
@@ -13,23 +13,26 @@
  * limitations under the License.
  */
 
+#include <fuzzer/FuzzedDataProvider.h>
+
 #include "softbusadapter_fuzzer.h"
 
 #include <cstddef>
 #include <cstdint>
 
-#include "softbus_adapter_standard.cpp"
 #include "message_parcel.h"
 #include "securec.h"
+#include "softbus_adapter_standard.cpp"
 
 using namespace OHOS::AppDistributedKv;
 
 namespace OHOS {
-bool OnBytesReceivedFuzz(const uint8_t *data, size_t size)
+bool OnBytesReceivedFuzz(FuzzedDataProvider &provider)
 {
-    int connId = static_cast<int>(*data);
-    unsigned int dataLen = static_cast<unsigned int>(size);
-    AppDataListenerWrap::OnClientBytesReceived(connId, data, dataLen);
+    int connId = provider.ConsumeIntegral<int>();
+    std::vector<uint8_t> remaining_data = provider.ConsumeRemainingBytes<uint8_t>();
+    AppDataListenerWrap::OnClientBytesReceived(connId, static_cast<void *>(remaining_data.data()),
+        remaining_data.size());
     return true;
 }
 } // namespace OHOS
@@ -37,11 +40,7 @@ bool OnBytesReceivedFuzz(const uint8_t *data, size_t size)
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
-    if (data == nullptr) {
-        return 0;
-    }
-
-    OHOS::OnBytesReceivedFuzz(data, size);
-
+    FuzzedDataProvider provider(data, size);
+    OHOS::OnBytesReceivedFuzz(provider);
     return 0;
 }
\ No newline at end of file
diff --git a/services/distributeddataservice/app/test/fuzztest/dataservicestub_fuzzer/dataservicestub_fuzzer.cpp b/services/distributeddataservice/app/test/fuzztest/dataservicestub_fuzzer/dataservicestub_fuzzer.cpp
index e5164c9424b81e5de3a566e98209b206d5520b4d..2b2d8bfd1df2e84a27608a065df1af337616a5eb 100644
--- a/services/distributeddataservice/app/test/fuzztest/dataservicestub_fuzzer/dataservicestub_fuzzer.cpp
+++ b/services/distributeddataservice/app/test/fuzztest/dataservicestub_fuzzer/dataservicestub_fuzzer.cpp
@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 
+#include <fuzzer/FuzzedDataProvider.h>
+
 #include "dataservicestub_fuzzer.h"
 
 #include <cstddef>
@@ -29,12 +31,13 @@ const std::u16string INTERFACE_TOKEN = u"OHOS.DistributedKv.IKvStoreDataService"
 const uint32_t CODE_MIN = 0;
 const uint32_t CODE_MAX = 10;
 
-bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
+bool OnRemoteRequestFuzz(FuzzedDataProvider &provider)
 {
-    uint32_t code = static_cast<uint32_t>(*data) % (CODE_MAX - CODE_MIN + 1) + CODE_MIN;
+    uint32_t code = provider.ConsumeIntegralInRange<uint32_t>(CODE_MIN, CODE_MAX);
     MessageParcel request;
     request.WriteInterfaceToken(INTERFACE_TOKEN);
-    request.WriteBuffer(data, size);
+    std::vector<uint8_t> remaining_data = provider.ConsumeRemainingBytes<uint8_t>();
+    request.WriteBuffer(static_cast<void *>(remaining_data.data()), remaining_data.size());
     request.RewindRead(0);
     MessageParcel reply;
     MessageOption option;
@@ -47,11 +50,7 @@ bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
-    if (data == nullptr) {
-        return 0;
-    }
-
-    OHOS::OnRemoteRequestFuzz(data, size);
-
+    FuzzedDataProvider provider(data, size);
+    OHOS::OnRemoteRequestFuzz(provider);
     return 0;
 }
\ No newline at end of file
diff --git a/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/cloudservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/cloudservicestub_fuzzer.cpp
index 1d11a9d364ddc97648aecde35e9d0b0fb7aa58fb..a05bc852f45d6e35284fd14b801fcf31e3bb7266 100644
--- a/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/cloudservicestub_fuzzer.cpp
+++ b/services/distributeddataservice/service/test/fuzztest/cloudservicestub_fuzzer/cloudservicestub_fuzzer.cpp
@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 
+#include <fuzzer/FuzzedDataProvider.h>
+
 #include "cloudservicestub_fuzzer.h"
 
 #include <cstddef>
@@ -65,7 +67,7 @@ void AllocAndSetHapToken()
     SetSelfTokenID(tokenID.tokenIDEx);
 }
 
-bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
+bool OnRemoteRequestFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<CloudServiceImpl> cloudServiceImpl = std::make_shared<CloudServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
@@ -74,10 +76,11 @@ bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
 
     AllocAndSetHapToken();
 
-    uint32_t code = static_cast<uint32_t>(*data) % (CODE_MAX - CODE_MIN + 1) + CODE_MIN;
+    uint32_t code = provider.ConsumeIntegralInRange<uint32_t>(CODE_MIN, CODE_MAX);
+    std::vector<uint8_t> remaining_data = provider.ConsumeRemainingBytes<uint8_t>();
     MessageParcel request;
     request.WriteInterfaceToken(INTERFACE_TOKEN);
-    request.WriteBuffer(data, size);
+    request.WriteBuffer(static_cast<void *>(remaining_data.data()), remaining_data.size());
     request.RewindRead(0);
     MessageParcel reply;
     std::shared_ptr<CloudServiceStub> cloudServiceStub = cloudServiceImpl;
@@ -89,11 +92,7 @@ bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
-    if (data == nullptr) {
-        return 0;
-    }
-
-    OHOS::OnRemoteRequestFuzz(data, size);
-
+    FuzzedDataProvider provider(data, size);
+    OHOS::OnRemoteRequestFuzz(provider);
     return 0;
 }
\ No newline at end of file
diff --git a/services/distributeddataservice/service/test/fuzztest/datashareservicestub_fuzzer/datashareservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/datashareservicestub_fuzzer/datashareservicestub_fuzzer.cpp
index df4f212d0b29f305a3cb0b8fb20f65b8010b630f..6053615ea3b913607e61df8c6ca0251ad87cba4a 100644
--- a/services/distributeddataservice/service/test/fuzztest/datashareservicestub_fuzzer/datashareservicestub_fuzzer.cpp
+++ b/services/distributeddataservice/service/test/fuzztest/datashareservicestub_fuzzer/datashareservicestub_fuzzer.cpp
@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 
+#include <fuzzer/FuzzedDataProvider.h>
+
 #include "datashareservicestub_fuzzer.h"
 
 #include <cstddef>
@@ -32,17 +34,18 @@ constexpr uint32_t CODE_MAX = IDataShareService::DATA_SHARE_SERVICE_CMD_MAX + 1;
 constexpr size_t NUM_MIN = 5;
 constexpr size_t NUM_MAX = 12;
 
-bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
+bool OnRemoteRequestFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<DataShareServiceImpl> dataShareServiceImpl = std::make_shared<DataShareServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     dataShareServiceImpl->OnBind(
         { "DataShareServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
 
-    uint32_t code = static_cast<uint32_t>(*data) % (CODE_MAX - CODE_MIN + 1) + CODE_MIN;
+    uint32_t code = provider.ConsumeIntegralInRange<uint32_t>(CODE_MIN, CODE_MAX);
+    std::vector<uint8_t> remaining_data = provider.ConsumeRemainingBytes<uint8_t>();
     MessageParcel request;
     request.WriteInterfaceToken(INTERFACE_TOKEN);
-    request.WriteBuffer(data, size);
+    request.WriteBuffer(static_cast<void *>(remaining_data.data()), remaining_data.size());
     request.RewindRead(0);
     MessageParcel reply;
     std::shared_ptr<DataShareServiceStub> dataShareServiceStub = dataShareServiceImpl;
@@ -54,11 +57,7 @@ bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
-    if (data == nullptr) {
-        return 0;
-    }
-
-    OHOS::OnRemoteRequestFuzz(data, size);
-
+    FuzzedDataProvider provider(data, size);
+    OHOS::OnRemoteRequestFuzz(provider);
     return 0;
 }
\ No newline at end of file
diff --git a/services/distributeddataservice/service/test/fuzztest/dumphelper_fuzzer/dumphelper_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/dumphelper_fuzzer/dumphelper_fuzzer.cpp
index b8ff95c41935a31104beaac2edcc9be7960636e7..c4033acff3c3358223399f7b732232cd426dce82 100644
--- a/services/distributeddataservice/service/test/fuzztest/dumphelper_fuzzer/dumphelper_fuzzer.cpp
+++ b/services/distributeddataservice/service/test/fuzztest/dumphelper_fuzzer/dumphelper_fuzzer.cpp
@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 
+#include <fuzzer/FuzzedDataProvider.h>
+
 #include "dumphelper_fuzzer.h"
 
 #include <cstddef>
@@ -30,16 +32,15 @@ using namespace OHOS::Security::AccessToken;
 
 namespace OHOS {
 
-bool DumpFuzz(const uint8_t *data, size_t size)
+bool DumpFuzz(FuzzedDataProvider &provider)
 {
-    int connId = static_cast<int>(*data);
+    int connId = provider.ConsumeIntegral<int>();
     std::vector<std::string> args;
     const std::string argstest1 = "OHOS.DistributedData.DumpHelper1";
     const std::string argstest2 = "OHOS.DistributedData.DumpHelper2";
     args.emplace_back(argstest1);
     args.emplace_back(argstest2);
     DumpHelper::GetInstance().Dump(connId, args);
-
     return true;
 }
 } // namespace OHOS
@@ -47,11 +48,7 @@ bool DumpFuzz(const uint8_t *data, size_t size)
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
-    if (data == nullptr) {
-        return 0;
-    }
-
-    OHOS::DumpFuzz(data, size);
-
+    FuzzedDataProvider provider(data, size);
+    OHOS::DumpFuzz(provider);
     return 0;
 }
\ No newline at end of file
diff --git a/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/kvdbservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/kvdbservicestub_fuzzer.cpp
index 09829930b0a0ef38888381aed2eaa5d846d163e7..0603b21be27018b3a6bddecb462974daef34e689 100644
--- a/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/kvdbservicestub_fuzzer.cpp
+++ b/services/distributeddataservice/service/test/fuzztest/kvdbservicestub_fuzzer/kvdbservicestub_fuzzer.cpp
@@ -12,6 +12,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+#include <fuzzer/FuzzedDataProvider.h>
+
 #include "kvdbservicestub_fuzzer.h"
 
 #include <cstddef>
@@ -33,7 +36,7 @@ constexpr uint32_t CODE_MAX = static_cast<uint32_t>(KVDBServiceInterfaceCode::TR
 constexpr size_t NUM_MIN = 5;
 constexpr size_t NUM_MAX = 12;
 
-bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
+bool OnRemoteRequestFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<KVDBServiceImpl> kvdbServiceImpl = std::make_shared<KVDBServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
@@ -45,10 +48,11 @@ bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
     Bootstrap::GetInstance().LoadCheckers();
     Bootstrap::GetInstance().LoadNetworks();
 
-    uint32_t code = static_cast<uint32_t>(*data) % (CODE_MAX - CODE_MIN + 1) + CODE_MIN;
+    uint32_t code = provider.ConsumeIntegralInRange<uint32_t>(CODE_MIN, CODE_MAX);
+    std::vector<uint8_t> remaining_data = provider.ConsumeRemainingBytes<uint8_t>();
     MessageParcel request;
     request.WriteInterfaceToken(INTERFACE_TOKEN);
-    request.WriteBuffer(data, size);
+    request.WriteBuffer(static_cast<void *>(remaining_data.data()), remaining_data.size());
     request.RewindRead(0);
     MessageParcel reply;
     std::shared_ptr<KVDBServiceStub> kvdbServiceStub = kvdbServiceImpl;
@@ -60,11 +64,7 @@ bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
-    if (data == nullptr) {
-        return 0;
-    }
-
-    OHOS::OnRemoteRequestFuzz(data, size);
-
+    FuzzedDataProvider provider(data, size);
+    OHOS::OnRemoteRequestFuzz(provider);
     return 0;
 }
\ No newline at end of file
diff --git a/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/objectservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/objectservicestub_fuzzer.cpp
index 24ce52ba6dd952eee47559763a72e6be1335f036..e78cd4fdb7b94b677bb27aec348546412b5357ae 100644
--- a/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/objectservicestub_fuzzer.cpp
+++ b/services/distributeddataservice/service/test/fuzztest/objectservicestub_fuzzer/objectservicestub_fuzzer.cpp
@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 
+#include <fuzzer/FuzzedDataProvider.h>
+
 #include "objectservicestub_fuzzer.h"
 
 #include <cstddef>
@@ -32,17 +34,18 @@ constexpr uint32_t CODE_MAX = static_cast<uint32_t>(ObjectCode::OBJECTSTORE_SERV
 constexpr size_t NUM_MIN = 5;
 constexpr size_t NUM_MAX = 12;
 
-bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
+bool OnRemoteRequestFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<ObjectServiceImpl> objectServiceImpl = std::make_shared<ObjectServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     objectServiceImpl->OnBind(
         { "ObjectServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
 
-    uint32_t code = static_cast<uint32_t>(*data) % (CODE_MAX - CODE_MIN + 1) + CODE_MIN;
+    uint32_t code = provider.ConsumeIntegralInRange<uint32_t>(CODE_MIN, CODE_MAX);
+    std::vector<uint8_t> remaining_data = provider.ConsumeRemainingBytes<uint8_t>();
     MessageParcel request;
     request.WriteInterfaceToken(INTERFACE_TOKEN);
-    request.WriteBuffer(data, size);
+    request.WriteBuffer(static_cast<void *>(remaining_data.data()), remaining_data.size());
     request.RewindRead(0);
     MessageParcel reply;
     std::shared_ptr<ObjectServiceStub> objectServiceStub = objectServiceImpl;
@@ -54,11 +57,7 @@ bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
-    if (data == nullptr) {
-        return 0;
-    }
-
-    OHOS::OnRemoteRequestFuzz(data, size);
-
+    FuzzedDataProvider provider(data, size);
+    OHOS::OnRemoteRequestFuzz(provider);
     return 0;
 }
\ No newline at end of file
diff --git a/services/distributeddataservice/service/test/fuzztest/rdbresultsetstub_fuzzer/rdbresultsetstub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/rdbresultsetstub_fuzzer/rdbresultsetstub_fuzzer.cpp
index 14d6d1c69b3ab60f12046ce66f5568fc8dfd4760..c390660af5f194e45193f2cefc75667ba8b90d07 100644
--- a/services/distributeddataservice/service/test/fuzztest/rdbresultsetstub_fuzzer/rdbresultsetstub_fuzzer.cpp
+++ b/services/distributeddataservice/service/test/fuzztest/rdbresultsetstub_fuzzer/rdbresultsetstub_fuzzer.cpp
@@ -13,29 +13,30 @@
  * limitations under the License.
  */
 
-#include "rdbresultsetstub_fuzzer.h"
-
 #include <fuzzer/FuzzedDataProvider.h>
 
+#include "rdbresultsetstub_fuzzer.h"
+
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 
-#include "message_parcel.h"
 #include "rdb_result_set_impl.h"
 #include "rdb_result_set_stub.h"
-#include "securec.h"
+#include "message_parcel.h"
 #include "store/cursor.h"
+#include "securec.h"
 
 using namespace OHOS::DistributedRdb;
+
 namespace OHOS {
 using Code = NativeRdb::RemoteResultSet::Code;
 const std::u16string INTERFACE_TOKEN = u"OHOS::NativeRdb.IResultSet";
 
-bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
+bool OnRemoteRequestFuzz(FuzzedDataProvider &provider)
 {
-    FuzzedDataProvider provider(data, size);
-    uint32_t code = provider.ConsumeIntegralInRange<uint32_t>(0, Code::CMD_MAX);
+    const int min = 0;
+    uint32_t code = provider.ConsumeIntegralInRange<uint32_t>(min, Code::CMD_MAX);
     std::vector<uint8_t> remaining_data = provider.ConsumeRemainingBytes<uint8_t>();
     MessageParcel request;
     request.WriteInterfaceToken(INTERFACE_TOKEN);
@@ -54,6 +55,7 @@ bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
-    OHOS::OnRemoteRequestFuzz(data, size);
+    FuzzedDataProvider provider(data, size);
+    OHOS::OnRemoteRequestFuzz(provider);
     return 0;
 }
\ No newline at end of file
diff --git a/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/rdbservicestub_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/rdbservicestub_fuzzer.cpp
index 60767879aa99d8763621d53b71b031de094bacfa..e4df81ba236f7be3eac46443abab54a944ddf160 100644
--- a/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/rdbservicestub_fuzzer.cpp
+++ b/services/distributeddataservice/service/test/fuzztest/rdbservicestub_fuzzer/rdbservicestub_fuzzer.cpp
@@ -13,16 +13,16 @@
  * limitations under the License.
  */
 
-#include "rdbservicestub_fuzzer.h"
-
 #include <fuzzer/FuzzedDataProvider.h>
 
+#include "rdbservicestub_fuzzer.h"
+
 #include <cstddef>
 #include <cstdint>
 
 #include "ipc_skeleton.h"
-#include "message_parcel.h"
 #include "rdb_service_impl.h"
+#include "message_parcel.h"
 #include "securec.h"
 
 using namespace OHOS::DistributedRdb;
@@ -32,16 +32,14 @@ const std::u16string INTERFACE_TOKEN = u"OHOS.DistributedRdb.IRdbService";
 constexpr size_t NUM_MIN = 5;
 constexpr size_t NUM_MAX = 12;
 
-bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
+bool OnRemoteRequestFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<RdbServiceImpl> rdbServiceImpl = std::make_shared<RdbServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     rdbServiceImpl->OnBind(
         { "RdbServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
 
-    FuzzedDataProvider provider(data, size);
-    uint32_t code =
-        provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(RdbServiceCode::RDB_SERVICE_CMD_MAX));
+    uint32_t code = provider.ConsumeIntegral<uint32_t>();
     std::vector<uint8_t> remaining_data = provider.ConsumeRemainingBytes<uint8_t>();
     MessageParcel request;
     request.WriteInterfaceToken(INTERFACE_TOKEN);
@@ -57,6 +55,7 @@ bool OnRemoteRequestFuzz(const uint8_t *data, size_t size)
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
 {
-    OHOS::OnRemoteRequestFuzz(data, size);
+    FuzzedDataProvider provider(data, size);
+    OHOS::OnRemoteRequestFuzz(provider);
     return 0;
 }
\ No newline at end of file
diff --git a/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/udmfservice_fuzzer.cpp b/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/udmfservice_fuzzer.cpp
index 1d5b03a1a8b5c1c90e57bf50c60a286fb3d877a4..fe376bd1a66a6b845c1c67c33c6aff597dbac301 100644
--- a/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/udmfservice_fuzzer.cpp
+++ b/services/distributeddataservice/service/test/fuzztest/udmfservice_fuzzer/udmfservice_fuzzer.cpp
@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 
+#include <fuzzer/FuzzedDataProvider.h>
+
 #include "udmfservice_fuzzer.h"
 
 #include "accesstoken_kit.h"
@@ -36,12 +38,11 @@ constexpr size_t NUM_MAX = 12;
 static constexpr int ID_LEN = 32;
 static constexpr int MINIMUM = 48;
 
-QueryOption GenerateFuzzQueryOption(const uint8_t* data, size_t size)
+QueryOption GenerateFuzzQueryOption(FuzzedDataProvider &provider)
 {
     std::vector<uint8_t> groupId(ID_LEN, '0');
-    size_t length = groupId.size() > size ? size : groupId.size();
-    for (size_t i = 0; i < length; ++i) {
-        groupId[i] = data[i] % MINIMUM + MINIMUM;
+    for (size_t i = 0; i < groupId.size(); ++i) {
+        groupId[i] = provider.ConsumeIntegralInRange<uint8_t>(MINIMUM, MINIMUM);
     }
     std::string groupIdStr(groupId.begin(), groupId.end());
     UnifiedKey udKey = UnifiedKey("drag", "com.test.demo", groupIdStr);
@@ -52,31 +53,33 @@ QueryOption GenerateFuzzQueryOption(const uint8_t* data, size_t size)
     return query;
 }
 
-bool OnRemoteRequestFuzz(const uint8_t* data, size_t size)
+bool OnRemoteRequestFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     udmfServiceImpl->OnBind(
         { "UdmfServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
 
-    uint32_t code = static_cast<uint32_t>(*data) % (CODE_MAX - CODE_MIN + 1) + CODE_MIN;
+    uint32_t code = provider.ConsumeIntegralInRange<uint32_t>(CODE_MIN, CODE_MAX);
+    std::vector<uint8_t> remaining_data = provider.ConsumeRemainingBytes<uint8_t>();
     MessageParcel request;
     request.WriteInterfaceToken(INTERFACE_TOKEN);
-    request.WriteBuffer(data, size);
+    request.WriteBuffer(static_cast<void *>(remaining_data.data()), remaining_data.size());
     request.RewindRead(0);
     MessageParcel reply;
     udmfServiceImpl->OnRemoteRequest(code, request, reply);
     return true;
 }
 
-void SetDataFuzz(const uint8_t *data, size_t size)
+void SetDataFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     udmfServiceImpl->OnBind(
         { "UdmfServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
     CustomOption option1 = {.intention = Intention::UD_INTENTION_DRAG};
-    std::string svalue(data, data + size);
+
+    std::string svalue = provider.ConsumeRandomLengthString();
     UnifiedData data1;
     std::shared_ptr<Object> obj = std::make_shared<Object>();
     obj->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
@@ -91,13 +94,13 @@ void SetDataFuzz(const uint8_t *data, size_t size)
     udmfServiceImpl->OnRemoteRequest(static_cast<uint32_t>(UdmfServiceInterfaceCode::SET_DATA), request, reply);
 }
 
-void GetDataFuzz(const uint8_t *data, size_t size)
+void GetDataFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     udmfServiceImpl->OnBind(
         { "UdmfServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
-    QueryOption query = GenerateFuzzQueryOption(data, size);
+    QueryOption query = GenerateFuzzQueryOption(provider);
     MessageParcel request;
     request.WriteInterfaceToken(INTERFACE_TOKEN);
     ITypesUtil::Marshal(request, query);
@@ -105,13 +108,13 @@ void GetDataFuzz(const uint8_t *data, size_t size)
     udmfServiceImpl->OnRemoteRequest(static_cast<uint32_t>(UdmfServiceInterfaceCode::GET_DATA), request, reply);
 }
 
-void GetBatchDataFuzz(const uint8_t *data, size_t size)
+void GetBatchDataFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     udmfServiceImpl->OnBind(
         { "UdmfServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
-    QueryOption query = GenerateFuzzQueryOption(data, size);
+    QueryOption query = GenerateFuzzQueryOption(provider);
     MessageParcel request;
     request.WriteInterfaceToken(INTERFACE_TOKEN);
     ITypesUtil::Marshal(request, query);
@@ -119,14 +122,14 @@ void GetBatchDataFuzz(const uint8_t *data, size_t size)
     udmfServiceImpl->OnRemoteRequest(static_cast<uint32_t>(UdmfServiceInterfaceCode::GET_BATCH_DATA), request, reply);
 }
 
-void UpdateDataFuzz(const uint8_t *data, size_t size)
+void UpdateDataFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     udmfServiceImpl->OnBind(
         { "UdmfServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
-    QueryOption query = GenerateFuzzQueryOption(data, size);
-    std::string svalue(data, data + size);
+    QueryOption query = GenerateFuzzQueryOption(provider);
+    std::string svalue = provider.ConsumeRandomLengthString();
     UnifiedData data1;
     std::shared_ptr<Object> obj = std::make_shared<Object>();
     obj->value_[UNIFORM_DATA_TYPE] = "general.file-uri";
@@ -141,13 +144,13 @@ void UpdateDataFuzz(const uint8_t *data, size_t size)
     udmfServiceImpl->OnRemoteRequest(static_cast<uint32_t>(UdmfServiceInterfaceCode::UPDATE_DATA), request, reply);
 }
 
-void DeleteDataFuzz(const uint8_t *data, size_t size)
+void DeleteDataFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     udmfServiceImpl->OnBind(
         { "UdmfServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
-    QueryOption query = GenerateFuzzQueryOption(data, size);
+    QueryOption query = GenerateFuzzQueryOption(provider);
     MessageParcel request;
     request.WriteInterfaceToken(INTERFACE_TOKEN);
     ITypesUtil::Marshal(request, query);
@@ -155,13 +158,13 @@ void DeleteDataFuzz(const uint8_t *data, size_t size)
     udmfServiceImpl->OnRemoteRequest(static_cast<uint32_t>(UdmfServiceInterfaceCode::DELETE_DATA), request, reply);
 }
 
-void GetSummaryFuzz(const uint8_t *data, size_t size)
+void GetSummaryFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     udmfServiceImpl->OnBind(
         { "UdmfServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
-    QueryOption query = GenerateFuzzQueryOption(data, size);
+    QueryOption query = GenerateFuzzQueryOption(provider);
     MessageParcel request;
     request.WriteInterfaceToken(INTERFACE_TOKEN);
     ITypesUtil::Marshal(request, query);
@@ -169,13 +172,13 @@ void GetSummaryFuzz(const uint8_t *data, size_t size)
     udmfServiceImpl->OnRemoteRequest(static_cast<uint32_t>(UdmfServiceInterfaceCode::GET_SUMMARY), request, reply);
 }
 
-void AddPrivilegeDataFuzz(const uint8_t *data, size_t size)
+void AddPrivilegeDataFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     udmfServiceImpl->OnBind(
         { "UdmfServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
-    QueryOption query = GenerateFuzzQueryOption(data, size);
+    QueryOption query = GenerateFuzzQueryOption(provider);
 
     Privilege privilege = {
         .tokenId = 1,
@@ -191,13 +194,13 @@ void AddPrivilegeDataFuzz(const uint8_t *data, size_t size)
         request, replyUpdate);
 }
 
-void SyncDataFuzz(const uint8_t *data, size_t size)
+void SyncDataFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     udmfServiceImpl->OnBind(
         { "UdmfServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
-    QueryOption query = GenerateFuzzQueryOption(data, size);
+    QueryOption query = GenerateFuzzQueryOption(provider);
     std::vector<std::string> devices = { "11", "22" };
     MessageParcel requestUpdate;
     requestUpdate.WriteInterfaceToken(INTERFACE_TOKEN);
@@ -207,13 +210,13 @@ void SyncDataFuzz(const uint8_t *data, size_t size)
         requestUpdate, replyUpdate);
 }
 
-void IsRemoteDataFuzz(const uint8_t *data, size_t size)
+void IsRemoteDataFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     udmfServiceImpl->OnBind(
         { "UdmfServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
-    QueryOption query = GenerateFuzzQueryOption(data, size);
+    QueryOption query = GenerateFuzzQueryOption(provider);
     MessageParcel requestUpdate;
     requestUpdate.WriteInterfaceToken(INTERFACE_TOKEN);
     ITypesUtil::Marshal(requestUpdate, query);
@@ -222,16 +225,15 @@ void IsRemoteDataFuzz(const uint8_t *data, size_t size)
         requestUpdate, replyUpdate);
 }
 
-void ObtainAsynProcessFuzz(const uint8_t *data, size_t size)
+void ObtainAsynProcessFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     udmfServiceImpl->OnBind(
         { "UdmfServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
     std::vector<uint8_t> groupId(ID_LEN, '0');
-    size_t length = groupId.size() > size ? size : groupId.size();
-    for (size_t i = 0; i < length; ++i) {
-        groupId[i] = data[i] % MINIMUM + MINIMUM;
+    for (size_t i = 0; i < groupId.size(); ++i) {
+        groupId[i] = provider.ConsumeIntegralInRange<uint8_t>(MINIMUM, MINIMUM);
     }
     std::string businessUdKey(groupId.begin(), groupId.end());
     AsyncProcessInfo processInfo = {
@@ -245,16 +247,15 @@ void ObtainAsynProcessFuzz(const uint8_t *data, size_t size)
         requestUpdate, replyUpdate);
 }
 
-void ClearAsynProcessFuzz(const uint8_t *data, size_t size)
+void ClearAsynProcessFuzz(FuzzedDataProvider &provider)
 {
     std::shared_ptr<UdmfServiceImpl> udmfServiceImpl = std::make_shared<UdmfServiceImpl>();
     std::shared_ptr<ExecutorPool> executor = std::make_shared<ExecutorPool>(NUM_MAX, NUM_MIN);
     udmfServiceImpl->OnBind(
         { "UdmfServiceStubFuzz", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
     std::vector<uint8_t> groupId(ID_LEN, '0');
-    size_t length = groupId.size() > size ? size : groupId.size();
-    for (size_t i = 0; i < length; ++i) {
-        groupId[i] = data[i] % MINIMUM + MINIMUM;
+    for (size_t i = 0; i < groupId.size(); ++i) {
+        groupId[i] = provider.ConsumeIntegralInRange<uint8_t>(MINIMUM, MINIMUM);
     }
     std::string businessUdKey(groupId.begin(), groupId.end());
     MessageParcel requestUpdate;
@@ -278,25 +279,22 @@ extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv)
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    if (data == nullptr) {
-        return 0;
-    }
-
-    OHOS::OnRemoteRequestFuzz(data, size);
-    OHOS::SetDataFuzz(data, size);
-    OHOS::GetDataFuzz(data, size);
+    FuzzedDataProvider provider(data, size);
+    OHOS::OnRemoteRequestFuzz(provider);
+    OHOS::SetDataFuzz(provider);
+    OHOS::GetDataFuzz(provider);
 
-    OHOS::GetBatchDataFuzz(data, size);
-    OHOS::UpdateDataFuzz(data, size);
-    OHOS::DeleteDataFuzz(data, size);
+    OHOS::GetBatchDataFuzz(provider);
+    OHOS::UpdateDataFuzz(provider);
+    OHOS::DeleteDataFuzz(provider);
 
-    OHOS::GetSummaryFuzz(data, size);
-    OHOS::AddPrivilegeDataFuzz(data, size);
-    OHOS::SyncDataFuzz(data, size);
+    OHOS::GetSummaryFuzz(provider);
+    OHOS::AddPrivilegeDataFuzz(provider);
+    OHOS::SyncDataFuzz(provider);
 
-    OHOS::IsRemoteDataFuzz(data, size);
-    OHOS::ObtainAsynProcessFuzz(data, size);
-    OHOS::ClearAsynProcessFuzz(data, size);
+    OHOS::IsRemoteDataFuzz(provider);
+    OHOS::ObtainAsynProcessFuzz(provider);
+    OHOS::ClearAsynProcessFuzz(provider);
 
     return 0;
 }
\ No newline at end of file