diff --git a/test/fuzztest/innerkits/accesstoken/allochaptoken_fuzzer/allochaptoken_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/allochaptoken_fuzzer/allochaptoken_fuzzer.cpp
index 5bcdf5a3453cc35bea1ccdf62f19ffa02f0130ef..ee91ab3fbb682f8b50e880a06b763a6cb8caa440 100644
--- a/test/fuzztest/innerkits/accesstoken/allochaptoken_fuzzer/allochaptoken_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/allochaptoken_fuzzer/allochaptoken_fuzzer.cpp
@@ -16,60 +16,104 @@
 #include "allochaptoken_fuzzer.h"
 
 #include <iostream>
-#include <thread>
 #include <string>
+#include <thread>
 #include <vector>
+
 #undef private
-#include "accesstoken_fuzzdata.h"
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
 
 namespace OHOS {
+    void InitHapInfoParams(const std::string& bundleName, FuzzedDataProvider& provider, HapInfoParams &param)
+    {
+        param.userID = provider.ConsumeIntegral<int32_t>();
+        param.bundleName = bundleName;
+        param.instIndex = provider.ConsumeIntegral<int32_t>();
+        param.dlpType = static_cast<int32_t>(
+            provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(HapDlpType::BUTT_DLP_TYPE)));
+        param.appIDDesc = provider.ConsumeRandomLengthString();
+        param.apiVersion = provider.ConsumeIntegral<int32_t>();
+        param.isSystemApp = provider.ConsumeBool();
+        param.appDistributionType = provider.ConsumeRandomLengthString();
+        param.isRestore = provider.ConsumeBool();
+        param.tokenID = provider.ConsumeIntegral<AccessTokenID>();
+        param.isAtomicService = provider.ConsumeBool();
+    }
+
+    void InitHapPolicy(const std::string& bundleName, const std::string& permissionName, FuzzedDataProvider& provider,
+        HapPolicyParams& policy)
+    {
+        PermissionDef def = {
+            .permissionName = permissionName,
+            .bundleName = bundleName,
+            .grantMode = static_cast<int32_t>(
+                provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(GrantMode::SYSTEM_GRANT))),
+            .availableLevel = static_cast<ATokenAplEnum>(
+                provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(ATokenAplEnum::APL_ENUM_BUTT))),
+            .provisionEnable = provider.ConsumeBool(),
+            .distributedSceneEnable = provider.ConsumeBool(),
+            .label = provider.ConsumeRandomLengthString(),
+            .labelId = provider.ConsumeIntegral<int32_t>(),
+            .description = provider.ConsumeRandomLengthString(),
+            .descriptionId = provider.ConsumeIntegral<int32_t>(),
+            .availableType = static_cast<ATokenAvailableTypeEnum>(provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(ATokenAvailableTypeEnum::AVAILABLE_TYPE_BUTT))),
+            .isKernelEffect = provider.ConsumeBool(),
+            .hasValue = provider.ConsumeBool(),
+        };
+
+        PermissionStateFull state = {
+            .permissionName = permissionName,
+            .isGeneral = provider.ConsumeBool(),
+            .resDeviceID = {provider.ConsumeRandomLengthString()},
+            .grantStatus = {static_cast<int32_t>(provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(PermissionState::PERMISSION_GRANTED)))},
+            .grantFlags = {provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(PermissionFlag::PERMISSION_ALLOW_THIS_TIME))},
+        };
+
+        PreAuthorizationInfo info = {
+            .permissionName = permissionName,
+            .userCancelable = provider.ConsumeBool(),
+        };
+
+        policy.apl = static_cast<ATokenAplEnum>(
+            provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(ATokenAplEnum::APL_ENUM_BUTT)));
+        policy.domain = provider.ConsumeRandomLengthString();
+        policy.permList = {def};
+        policy.permStateList = {state};
+        policy.aclRequestedList = {provider.ConsumeRandomLengthString()};
+        policy.preAuthorizationInfo = {info};
+        policy.checkIgnore = static_cast<HapPolicyCheckIgnore>(provider.ConsumeIntegralInRange<uint32_t>(
+            0, static_cast<uint32_t>(HapPolicyCheckIgnore::ACL_IGNORE_CHECK)));
+        policy.aclExtendedMap = {std::make_pair<std::string, std::string>(provider.ConsumeRandomLengthString(),
+            provider.ConsumeRandomLengthString())};
+    }
+
     bool AllocHapTokenFuzzTest(const uint8_t* data, size_t size)
     {
-        AccessTokenIDEx tokenIdEx = {0};
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
-        std::string permissionName(fuzzData.GenerateStochasticString());
-        std::string bundleName(fuzzData.GenerateStochasticString());
-        PermissionDef testPermDef;
-        testPermDef.permissionName = permissionName;
-        testPermDef.bundleName = bundleName;
-        testPermDef.grantMode = 1;
-        testPermDef.availableLevel = APL_NORMAL;
-        testPermDef.label = fuzzData.GenerateStochasticString();
-        testPermDef.labelId = 1;
-        testPermDef.description = fuzzData.GenerateStochasticString();
-        testPermDef.descriptionId = 1;
-
-        PermissionStateFull testState;
-        testState.permissionName = permissionName;
-        testState.isGeneral = true;
-        testState.resDeviceID = {fuzzData.GenerateStochasticString()};
-        testState.grantStatus = {PermissionState::PERMISSION_GRANTED};
-        testState.grantFlags = {1};
-        HapInfoParams TestInfoParms = {
-            .userID = 1,
-            .bundleName = bundleName,
-            .instIndex = 0,
-            .appIDDesc = fuzzData.GenerateStochasticString()
-        };
-        HapPolicyParams TestPolicyPrams = {
-            .apl = APL_NORMAL,
-            .domain = fuzzData.GenerateStochasticString(),
-            .permList = {testPermDef},
-            .permStateList = {testState}
-        };
+        FuzzedDataProvider provider(data, size);
+        std::string bundleName = provider.ConsumeRandomLengthString();
+        std::string permissionName = provider.ConsumeRandomLengthString();
+
+        HapInfoParams param;
+        InitHapInfoParams(bundleName, provider, param);
 
-        tokenIdEx = AccessTokenKit::AllocHapToken(TestInfoParms, TestPolicyPrams);
+        HapPolicyParams policy;
+        InitHapPolicy(bundleName, permissionName, provider, policy);
+
+        AccessTokenIDEx tokenIdEx = {0};
+        tokenIdEx = AccessTokenKit::AllocHapToken(param, policy);
 
-        return tokenIdEx.tokenIdExStruct.tokenID != 0;
+        return tokenIdEx.tokenIdExStruct.tokenID != INVALID_TOKENID;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/alloclocaltokenid_fuzzer/alloclocaltokenid_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/alloclocaltokenid_fuzzer/alloclocaltokenid_fuzzer.cpp
index 6044b6613fea89035f10ca251d7c5c954b38b0d1..d4412007f7de655be54244adf16fc9752701ec9e 100644
--- a/test/fuzztest/innerkits/accesstoken/alloclocaltokenid_fuzzer/alloclocaltokenid_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/alloclocaltokenid_fuzzer/alloclocaltokenid_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -28,16 +29,13 @@ using namespace OHOS::Security::AccessToken;
 namespace OHOS {
     bool AllocLocalTokenIDFuzzTest(const uint8_t* data, size_t size)
     {
-        AccessTokenID tokenId = 0;
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
-        AccessTokenFuzzData fuzzData(data, size);
-
-        tokenId = AccessTokenKit::AllocLocalTokenID(fuzzData.GenerateStochasticString(),
-            fuzzData.GetData<AccessTokenID>());
 
-        return tokenId != 0;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::AllocLocalTokenID(provider.ConsumeRandomLengthString(),
+            provider.ConsumeIntegral<AccessTokenID>()) != INVALID_TOKENID;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/clearusergrantedpermissionstate_fuzzer/clearusergrantedpermissionstate_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/clearusergrantedpermissionstate_fuzzer/clearusergrantedpermissionstate_fuzzer.cpp
index 41eb60a473d6da9f95389ff950eb88d3d7b2fb66..2d73c463511288d990bc0293722e0f7cb00af65b 100644
--- a/test/fuzztest/innerkits/accesstoken/clearusergrantedpermissionstate_fuzzer/clearusergrantedpermissionstate_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/clearusergrantedpermissionstate_fuzzer/clearusergrantedpermissionstate_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -32,10 +33,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t result = AccessTokenKit::ClearUserGrantedPermissionState(fuzzData.GetData<AccessTokenID>());
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::ClearUserGrantedPermissionState(
+            provider.ConsumeIntegral<AccessTokenID>()) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/deleteremotedevicetokens_fuzzer/deleteremotedevicetokens_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/deleteremotedevicetokens_fuzzer/deleteremotedevicetokens_fuzzer.cpp
index 3b539d1b59ea9173e990aeb471624e3c1a965494..be7117bcec666bdb476264f9be331082134f7f59 100644
--- a/test/fuzztest/innerkits/accesstoken/deleteremotedevicetokens_fuzzer/deleteremotedevicetokens_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/deleteremotedevicetokens_fuzzer/deleteremotedevicetokens_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -29,14 +30,13 @@ using namespace OHOS::Security::AccessToken;
 namespace OHOS {
     bool DeleteRemoteDeviceTokensFuzzTest(const uint8_t* data, size_t size)
     {
-#ifdef TOKEN_SYNC_ENABLE
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t result = AccessTokenKit::DeleteRemoteDeviceTokens(fuzzData.GenerateStochasticString());
-        return result == RET_SUCCESS;
+#ifdef TOKEN_SYNC_ENABLE
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::DeleteRemoteDeviceTokens(provider.ConsumeRandomLengthString()) == RET_SUCCESS;
 #else
         return true;
 #endif
@@ -47,7 +47,6 @@ namespace OHOS {
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
     /* Run your code on data */
-
     OHOS::DeleteRemoteDeviceTokensFuzzTest(data, size);
     return 0;
 }
diff --git a/test/fuzztest/innerkits/accesstoken/deleteremotetoken_fuzzer/deleteremotetoken_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/deleteremotetoken_fuzzer/deleteremotetoken_fuzzer.cpp
index f56dda35a462d7b22a2507da817c2ce7dafc13df..955a23c3615b995ff5cb91315e408c3108ca1cf5 100644
--- a/test/fuzztest/innerkits/accesstoken/deleteremotetoken_fuzzer/deleteremotetoken_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/deleteremotetoken_fuzzer/deleteremotetoken_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -28,15 +29,14 @@ using namespace OHOS::Security::AccessToken;
 namespace OHOS {
     bool DeleteRemoteTokenFuzzTest(const uint8_t* data, size_t size)
     {
-#ifdef TOKEN_SYNC_ENABLE
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t result = AccessTokenKit::DeleteRemoteToken(
-            fuzzData.GenerateStochasticString(), fuzzData.GetData<AccessTokenID>());
-        return result == RET_SUCCESS;
+#ifdef TOKEN_SYNC_ENABLE
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::DeleteRemoteToken(provider.ConsumeRandomLengthString(),
+            provider.ConsumeIntegral<AccessTokenID>()) == RET_SUCCESS;
 #else
         return true;
 #endif
diff --git a/test/fuzztest/innerkits/accesstoken/deletetoken_fuzzer/deletetoken_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/deletetoken_fuzzer/deletetoken_fuzzer.cpp
index db97b50e0cbb0be867ec1df406faee91a7987e3c..ea8912ec6d39fa708af725cf7e44c90b84d23f0c 100644
--- a/test/fuzztest/innerkits/accesstoken/deletetoken_fuzzer/deletetoken_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/deletetoken_fuzzer/deletetoken_fuzzer.cpp
@@ -18,7 +18,8 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "accesstoken_kit.h"
 
@@ -32,10 +33,8 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t result = AccessTokenKit::DeleteToken(fuzzData.GetData<AccessTokenID>());
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::DeleteToken(provider.ConsumeIntegral<AccessTokenID>()) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/dumptokeninfo_fuzzer/dumptokeninfo_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/dumptokeninfo_fuzzer/dumptokeninfo_fuzzer.cpp
index 89728852aa6728eb24af9de7a7422e5e08bff8f1..9087de6ad26c04e52a1200c1dcf6c1601879406c 100644
--- a/test/fuzztest/innerkits/accesstoken/dumptokeninfo_fuzzer/dumptokeninfo_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/dumptokeninfo_fuzzer/dumptokeninfo_fuzzer.cpp
@@ -19,9 +19,10 @@
 #include <thread>
 #include <string>
 #include <vector>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -29,17 +30,16 @@ using namespace OHOS::Security::AccessToken;
 namespace OHOS {
     bool DumpTokenInfoFuzzTest(const uint8_t* data, size_t size)
     {
-        AccessTokenID tokenId = 0;
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        tokenId = fuzzData.GetData<AccessTokenID>();
-        std::string dumpInfo;
-        AtmToolsParamInfo info;
-        info.tokenId = tokenId;
+        FuzzedDataProvider provider(data, size);
+        AtmToolsParamInfo info = {
+            .tokenId = provider.ConsumeIntegral<AccessTokenID>(),
+        };
 
+        std::string dumpInfo;
         AccessTokenKit::DumpTokenInfo(info, dumpInfo);
  
         return true;
diff --git a/test/fuzztest/innerkits/accesstoken/getdefpermission_fuzzer/getdefpermission_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getdefpermission_fuzzer/getdefpermission_fuzzer.cpp
index 5aa9066cbb801c3178676b24dfd8dd38d9da18d6..2143937de208cab98049986caa3bc071c196211e 100644
--- a/test/fuzztest/innerkits/accesstoken/getdefpermission_fuzzer/getdefpermission_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getdefpermission_fuzzer/getdefpermission_fuzzer.cpp
@@ -18,7 +18,8 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "accesstoken_kit.h"
 #include "permission_def.h"
@@ -34,11 +35,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        PermissionDef PERMISSIONDEF;
-        int32_t result = AccessTokenKit::GetDefPermission(fuzzData.GenerateStochasticString(), PERMISSIONDEF);
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        PermissionDef def;
+        return AccessTokenKit::GetDefPermission(provider.ConsumeRandomLengthString(), def) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/gethapdlpflag_fuzzer/gethapdlpflag_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/gethapdlpflag_fuzzer/gethapdlpflag_fuzzer.cpp
index e24e21bce651ed768b29b7f5a3d761132327924c..c9288420508930df3d2cc7a51074546b8e6130b1 100644
--- a/test/fuzztest/innerkits/accesstoken/gethapdlpflag_fuzzer/gethapdlpflag_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/gethapdlpflag_fuzzer/gethapdlpflag_fuzzer.cpp
@@ -19,9 +19,10 @@
 #include <thread>
 #include <string>
 #include <vector>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -33,10 +34,8 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t result = AccessTokenKit::GetHapDlpFlag(fuzzData.GetData<AccessTokenID>());
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::GetHapDlpFlag(provider.ConsumeIntegral<AccessTokenID>()) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/gethaptokenid_fuzzer/gethaptokenid_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/gethaptokenid_fuzzer/gethaptokenid_fuzzer.cpp
index c94d55d239b2c221cfe2d87681f65bd1ea0b27bf..e45747854345a948deef0a819905a66d5fbcce9e 100644
--- a/test/fuzztest/innerkits/accesstoken/gethaptokenid_fuzzer/gethaptokenid_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/gethaptokenid_fuzzer/gethaptokenid_fuzzer.cpp
@@ -17,8 +17,9 @@
 
 #include <cstddef>
 #include <cstdint>
-#include "accesstoken_fuzzdata.h"
+
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -30,11 +31,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t result = AccessTokenKit::GetHapTokenID(
-            fuzzData.GetData<int>(), fuzzData.GenerateStochasticString(), fuzzData.GetData<int>());
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::GetHapTokenID(provider.ConsumeIntegral<int32_t>(), provider.ConsumeRandomLengthString(),
+            provider.ConsumeIntegral<int32_t>()) != INVALID_TOKENID;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/gethaptokeninfo_fuzzer/gethaptokeninfo_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/gethaptokeninfo_fuzzer/gethaptokeninfo_fuzzer.cpp
index d757344c3c1cb917f26fa7180af5466124c68e84..eeb69cf343e4b6b52fbdcd334df66a0274941a73 100644
--- a/test/fuzztest/innerkits/accesstoken/gethaptokeninfo_fuzzer/gethaptokeninfo_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/gethaptokeninfo_fuzzer/gethaptokeninfo_fuzzer.cpp
@@ -17,8 +17,9 @@
 
 #include <cstddef>
 #include <cstdint>
-#include "accesstoken_fuzzdata.h"
+
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #include "hap_token_info.h"
 
 using namespace OHOS::Security::AccessToken;
@@ -30,11 +31,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        HapTokenInfo HapTokenInfotest;
-        int32_t result = AccessTokenKit::GetHapTokenInfo(fuzzData.GetData<AccessTokenID>(), HapTokenInfotest);
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        HapTokenInfo info;
+        return AccessTokenKit::GetHapTokenInfo(provider.ConsumeIntegral<AccessTokenID>(), info) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/gethaptokeninfofromremote_fuzzer/gethaptokeninfofromremote_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/gethaptokeninfofromremote_fuzzer/gethaptokeninfofromremote_fuzzer.cpp
index db26fdbd4624ae686fba2450a260a9c553578b82..8c859aab0843ad7d0a58a695b98dd2fb5b276749 100644
--- a/test/fuzztest/innerkits/accesstoken/gethaptokeninfofromremote_fuzzer/gethaptokeninfofromremote_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/gethaptokeninfofromremote_fuzzer/gethaptokeninfofromremote_fuzzer.cpp
@@ -19,9 +19,10 @@
 #include <thread>
 #include <string>
 #include <vector>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -29,16 +30,15 @@ using namespace OHOS::Security::AccessToken;
 namespace OHOS {
     bool GetHapTokenInfoFromRemoteFuzzTest(const uint8_t* data, size_t size)
     {
-#ifdef TOKEN_SYNC_ENABLE
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
+#ifdef TOKEN_SYNC_ENABLE
+        FuzzedDataProvider provider(data, size);
         HapTokenInfoForSync hapSync;
-
-        int32_t result = AccessTokenKit::GetHapTokenInfoFromRemote(fuzzData.GetData<AccessTokenID>(), hapSync);
-        return result == RET_SUCCESS;
+        return AccessTokenKit::GetHapTokenInfoFromRemote(
+            provider.ConsumeIntegral<AccessTokenID>(), hapSync) == RET_SUCCESS;
 #else
         return true;
 #endif
diff --git a/test/fuzztest/innerkits/accesstoken/getnativetokenid_fuzzer/getnativetokenid_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getnativetokenid_fuzzer/getnativetokenid_fuzzer.cpp
index 49b86531c9b77ad4a1514d135b98472811dcd6f7..a63c40f0989b8533615effac4f671888fa7589c1 100644
--- a/test/fuzztest/innerkits/accesstoken/getnativetokenid_fuzzer/getnativetokenid_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getnativetokenid_fuzzer/getnativetokenid_fuzzer.cpp
@@ -19,9 +19,10 @@
 #include <thread>
 #include <string>
 #include <vector>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -29,15 +30,12 @@ using namespace OHOS::Security::AccessToken;
 namespace OHOS {
     bool GetNativeTokenIdFuzzTest(const uint8_t* data, size_t size)
     {
-        AccessTokenID tokenId = 0;
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        tokenId = AccessTokenKit::GetNativeTokenId(fuzzData.GenerateStochasticString());
-
-        return tokenId != 0;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::GetNativeTokenId(provider.ConsumeRandomLengthString()) != INVALID_TOKENID;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/getnativetokeninfo_fuzzer/getnativetokeninfo_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getnativetokeninfo_fuzzer/getnativetokeninfo_fuzzer.cpp
index 3878176d380080f84af3832bc3c049397a0a4697..f947771229e5adaf530cecd8660dc5ef5a462d47 100644
--- a/test/fuzztest/innerkits/accesstoken/getnativetokeninfo_fuzzer/getnativetokeninfo_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getnativetokeninfo_fuzzer/getnativetokeninfo_fuzzer.cpp
@@ -19,9 +19,10 @@
 #include <thread>
 #include <string>
 #include <vector>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -33,11 +34,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        NativeTokenInfo NativeTokenInfotest;
-        int32_t result = AccessTokenKit::GetNativeTokenInfo(fuzzData.GetData<AccessTokenID>(), NativeTokenInfotest);
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        NativeTokenInfo info;
+        return AccessTokenKit::GetNativeTokenInfo(provider.ConsumeIntegral<AccessTokenID>(), info) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/getpermissionflags_fuzzer/getpermissionflags_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getpermissionflags_fuzzer/getpermissionflags_fuzzer.cpp
index e3027cfb7d519e9278824bfb1235f14723f74824..e79163c6aa33b49c5b375282398aa55c1786f981 100644
--- a/test/fuzztest/innerkits/accesstoken/getpermissionflags_fuzzer/getpermissionflags_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getpermissionflags_fuzzer/getpermissionflags_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -32,12 +33,10 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        uint32_t flag;
-        int32_t result = AccessTokenKit::GetPermissionFlag(
-            fuzzData.GetData<AccessTokenID>(), fuzzData.GenerateStochasticString(), flag);
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        uint32_t flag = 0;
+        return AccessTokenKit::GetPermissionFlag(provider.ConsumeIntegral<AccessTokenID>(),
+            provider.ConsumeRandomLengthString(), flag) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/getpermissionrequesttogglestatus_fuzzer/getpermissionrequesttogglestatus_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getpermissionrequesttogglestatus_fuzzer/getpermissionrequesttogglestatus_fuzzer.cpp
index b7dab91bf3561ac6c51956d827e7270adf9ec5b6..509ad0201c7e69fc10b6281ae70aa71a9bcc3eba 100644
--- a/test/fuzztest/innerkits/accesstoken/getpermissionrequesttogglestatus_fuzzer/getpermissionrequesttogglestatus_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getpermissionrequesttogglestatus_fuzzer/getpermissionrequesttogglestatus_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -32,12 +33,10 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        uint32_t status;
-        int32_t result = AccessTokenKit::GetPermissionRequestToggleStatus(
-            fuzzData.GenerateStochasticString(), status, fuzzData.GetData<int32_t>());
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        uint32_t status = 0;
+        return AccessTokenKit::GetPermissionRequestToggleStatus(provider.ConsumeRandomLengthString(), status,
+            provider.ConsumeIntegral<int32_t>()) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/getpermissionsstatus_fuzzer/getpermissionsstatus_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getpermissionsstatus_fuzzer/getpermissionsstatus_fuzzer.cpp
index be3d1894bc616e27659601dfce4fc92242845ea8..7ee5ee4656a39ef52141e5ce33fc2f4d0dd2e3c4 100644
--- a/test/fuzztest/innerkits/accesstoken/getpermissionsstatus_fuzzer/getpermissionsstatus_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getpermissionsstatus_fuzzer/getpermissionsstatus_fuzzer.cpp
@@ -19,9 +19,11 @@
 #include <string>
 #include <vector>
 #include <thread>
+
 #undef private
 #include "access_token.h"
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #include "nativetoken_kit.h"
 #include "securec.h"
 #include "token_setproc.h"
@@ -30,66 +32,6 @@ using namespace std;
 using namespace OHOS::Security::AccessToken;
 
 namespace OHOS {
-const uint8_t* g_baseFuzzData = nullptr;
-size_t g_baseFuzzSize = 0;
-size_t g_baseFuzzPos = 0;
-
-    void GetNativeToken()
-    {
-        uint64_t tokenId;
-        const char** perms = new (std::nothrow) const char *[1];
-        if (perms == nullptr) {
-            return;
-        }
-
-        perms[0] = "ohos.permission.GET_SENSITIVE_PERMISSIONS"; // 3 means the third permission
-
-        NativeTokenInfoParams infoInstance = {
-            .dcapsNum = 0,
-            .permsNum = 1,
-            .aclsNum = 0,
-            .dcaps = nullptr,
-            .perms = perms,
-            .acls = nullptr,
-            .processName = "getpermissionsstatus_fuzzer_test",
-            .aplStr = "system_core",
-        };
-
-        tokenId = GetAccessTokenId(&infoInstance);
-        SetSelfTokenID(tokenId);
-        AccessTokenKit::ReloadNativeTokenInfo();
-        delete[] perms;
-    }
-
-    /*
-    * describe: get data from outside untrusted data(g_data) which size is according to sizeof(T)
-    * tips: only support basic type
-    */
-    template<class T> T GetData()
-    {
-        T object {};
-        size_t objectSize = sizeof(object);
-        if (g_baseFuzzData == nullptr || objectSize > g_baseFuzzSize - g_baseFuzzPos) {
-            return object;
-        }
-        errno_t ret = memcpy_s(&object, objectSize, g_baseFuzzData + g_baseFuzzPos, objectSize);
-        if (ret != EOK) {
-            return {};
-        }
-        g_baseFuzzPos += objectSize;
-        return object;
-    }
-
-    std::string GetStringFromData(int strlen)
-    {
-        char cstr[strlen];
-        cstr[strlen - 1] = '\0';
-        for (int i = 0; i < strlen - 1; i++) {
-            cstr[i] = GetData<char>();
-        }
-        std::string str(cstr);
-        return str;
-    }
 
     bool GetPermissionsStatusFuzzTest(const uint8_t* data, size_t size)
     {
@@ -97,23 +39,9 @@ size_t g_baseFuzzPos = 0;
             return false;
         }
 
-        int32_t result = RET_SUCCESS;
-        g_baseFuzzData = data;
-        g_baseFuzzSize = size;
-        g_baseFuzzPos = 0;
-        if (size > sizeof(uint32_t) + sizeof(std::string)) {
-            AccessTokenID tokenId = static_cast<AccessTokenID>(GetData<uint32_t>());
-            std::string testPerName = GetStringFromData(int(size));
-            std::vector<PermissionListState> permsList;
-            PermissionListState perm = {
-                .permissionName = testPerName,
-                .state = SETTING_OPER,
-            };
-            permsList.emplace_back(perm);
-            PermissionGrantInfo info;
-            AccessTokenKit::GetPermissionsStatus(tokenId, permsList);
-        }
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        std::vector<PermissionListState> permList;
+        return AccessTokenKit::GetPermissionsStatus(provider.ConsumeIntegral<AccessTokenID>(), permList) == RET_SUCCESS;
     }
 }
 
@@ -121,7 +49,6 @@ size_t g_baseFuzzPos = 0;
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
     /* Run your code on data */
-    OHOS::GetNativeToken();
     OHOS::GetPermissionsStatusFuzzTest(data, size);
     return 0;
 }
diff --git a/test/fuzztest/innerkits/accesstoken/getpermissionusedtype_fuzzer/getpermissionusedtype_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getpermissionusedtype_fuzzer/getpermissionusedtype_fuzzer.cpp
index 683cda6d04d5d7076d0246052845005a0c406f9a..9a91c2a54adb401a4d559d06cb4175ca4ef5c777 100644
--- a/test/fuzztest/innerkits/accesstoken/getpermissionusedtype_fuzzer/getpermissionusedtype_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getpermissionusedtype_fuzzer/getpermissionusedtype_fuzzer.cpp
@@ -19,9 +19,10 @@
 #include <thread>
 #include <string>
 #include <vector>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -32,11 +33,10 @@ bool GetPermissionUsedTypeFuzzTest(const uint8_t* data, size_t size)
     if ((data == nullptr) || (size == 0)) {
         return false;
     }
-    AccessTokenFuzzData fuzzData(data, size);
-    PermUsedTypeEnum type = AccessTokenKit::GetPermissionUsedType(
-        fuzzData.GetData<AccessTokenID>(), fuzzData.GenerateStochasticString());
 
-    return type != PermUsedTypeEnum::PERM_USED_TYPE_BUTT;
+    FuzzedDataProvider provider(data, size);
+    return AccessTokenKit::GetPermissionUsedType(provider.ConsumeIntegral<AccessTokenID>(),
+        provider.ConsumeRandomLengthString()) != PermUsedTypeEnum::PERM_USED_TYPE_BUTT;
 }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/getremotenativetokenid_fuzzer/getremotenativetokenid_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getremotenativetokenid_fuzzer/getremotenativetokenid_fuzzer.cpp
index 38279a593dc79be796a14110b11b2d05541a0cb1..887dc1b1de3c5e84d8194216987241dbfc4c61b8 100644
--- a/test/fuzztest/innerkits/accesstoken/getremotenativetokenid_fuzzer/getremotenativetokenid_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getremotenativetokenid_fuzzer/getremotenativetokenid_fuzzer.cpp
@@ -19,9 +19,10 @@
 #include <thread>
 #include <string>
 #include <vector>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -29,17 +30,16 @@ using namespace OHOS::Security::AccessToken;
 namespace OHOS {
     bool GetRemoteNativeTokenIDFuzzTest(const uint8_t* data, size_t size)
     {
-        AccessTokenID tokenId = 0;
-#ifdef TOKEN_SYNC_ENABLE
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        tokenId = AccessTokenKit::GetRemoteNativeTokenID(
-            fuzzData.GenerateStochasticString(), fuzzData.GetData<AccessTokenID>());
+#ifdef TOKEN_SYNC_ENABLE
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::GetRemoteNativeTokenID(provider.ConsumeRandomLengthString(),
+            provider.ConsumeIntegral<AccessTokenID>()) != INVALID_TOKENID;
 #endif
-        return tokenId != 0;
+        return true;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/getrendertokenid_fuzzer/getrendertokenid_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getrendertokenid_fuzzer/getrendertokenid_fuzzer.cpp
index 7f6e53fec97d8fc030bccec007ac0d2110ab9adc..85189c9850194b0e217f3c57db50cabb4fb89a2a 100644
--- a/test/fuzztest/innerkits/accesstoken/getrendertokenid_fuzzer/getrendertokenid_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getrendertokenid_fuzzer/getrendertokenid_fuzzer.cpp
@@ -18,10 +18,11 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
-#include "tokenid_kit.h"
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
+#include "tokenid_kit.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -33,11 +34,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        AccessTokenID tokenId = fuzzData.GetData<AccessTokenID>();
-        uint64_t retTokenId = TokenIdKit::GetRenderTokenID(tokenId);
-
-        return retTokenId != tokenId;
+        FuzzedDataProvider provider(data, size);
+        AccessTokenID tokenId = provider.ConsumeIntegral<AccessTokenID>();
+        return TokenIdKit::GetRenderTokenID(tokenId) != tokenId;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/getreqpermissions_fuzzer/getreqpermissions_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getreqpermissions_fuzzer/getreqpermissions_fuzzer.cpp
index be2420d60e24b6aa45570a55c12254a4f4547a64..81a82cd48487e2916c1f868b84a870c62f9c7b3d 100644
--- a/test/fuzztest/innerkits/accesstoken/getreqpermissions_fuzzer/getreqpermissions_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getreqpermissions_fuzzer/getreqpermissions_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace OHOS::Security::AccessToken;
 
@@ -31,11 +32,10 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        std::vector<PermissionStateFull> permStatSystemList;
-        int32_t result = AccessTokenKit::GetReqPermissions(fuzzData.GetData<AccessTokenID>(), permStatSystemList, true);
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        std::vector<PermissionStateFull> list;
+        return AccessTokenKit::GetReqPermissions(
+            provider.ConsumeIntegral<AccessTokenID>(), list, provider.ConsumeBool()) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/getseccompenhance_fuzzer/getseccompenhance_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getseccompenhance_fuzzer/getseccompenhance_fuzzer.cpp
index 50a3f7dfe3a69926699d15c39a3a69c272ea42b4..8cdaf565083aeae1a4668befd82dea0d45be11cf 100644
--- a/test/fuzztest/innerkits/accesstoken/getseccompenhance_fuzzer/getseccompenhance_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getseccompenhance_fuzzer/getseccompenhance_fuzzer.cpp
@@ -20,9 +20,9 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -34,11 +34,10 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
+        FuzzedDataProvider provider(data, size);
         SecCompEnhanceData secData;
 
-        return AccessTokenKit::GetSecCompEnhance(fuzzData.GetData<int32_t>(), secData) == 0;
+        return AccessTokenKit::GetSecCompEnhance(provider.ConsumeIntegral<int32_t>(), secData) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/getselfpermissionsstate_fuzzer/getselfpermissionsstate_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getselfpermissionsstate_fuzzer/getselfpermissionsstate_fuzzer.cpp
index 50e9442e4dda024b28b920b677ffd7014dd65b21..274530f8fa7312e8e2eceba43cabf6a63043323a 100644
--- a/test/fuzztest/innerkits/accesstoken/getselfpermissionsstate_fuzzer/getselfpermissionsstate_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getselfpermissionsstate_fuzzer/getselfpermissionsstate_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -32,17 +33,16 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        std::vector<PermissionListState> permsList1;
-        PermissionListState perm1 = {
-            .permissionName = fuzzData.GenerateStochasticString(),
-            .state = SETTING_OPER,
+        FuzzedDataProvider provider(data, size);
+        std::vector<PermissionListState> permsList;
+        PermissionListState perm = {
+            .permissionName = provider.ConsumeRandomLengthString(),
+            .state = static_cast<PermissionOper>(provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(PermissionOper::BUTT_OPER))),
         };
-        permsList1.emplace_back(perm1);
+        permsList.emplace_back(perm);
         PermissionGrantInfo info;
-        int32_t result = AccessTokenKit::GetSelfPermissionsState(permsList1, info);
-
-        return result == RET_SUCCESS;
+        return AccessTokenKit::GetSelfPermissionsState(permsList, info) != PermissionOper::BUTT_OPER;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/getselfpermissionstatus_fuzzer/getselfpermissionstatus_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/getselfpermissionstatus_fuzzer/getselfpermissionstatus_fuzzer.cpp
index a9b21bd237bce727e93954607d9d7945095fc4a7..481318729f660a716fce5a7f7d0ab18cb08f7912 100644
--- a/test/fuzztest/innerkits/accesstoken/getselfpermissionstatus_fuzzer/getselfpermissionstatus_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/getselfpermissionstatus_fuzzer/getselfpermissionstatus_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -32,12 +33,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        std::string permissionName = fuzzData.GenerateStochasticString();
+        FuzzedDataProvider provider(data, size);
         PermissionOper status;
-
-        AccessTokenKit::GetSelfPermissionStatus(permissionName, status);
-        return true;
+        return AccessTokenKit::GetSelfPermissionStatus(provider.ConsumeRandomLengthString(), status) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/gettokenidbyuserid_fuzzer/gettokenidbyuserid_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/gettokenidbyuserid_fuzzer/gettokenidbyuserid_fuzzer.cpp
index 81386931bd6a82f731e59448de3cd73de21fce76..e75db851da669ece40ae363a1ab51223aea6fd9c 100644
--- a/test/fuzztest/innerkits/accesstoken/gettokenidbyuserid_fuzzer/gettokenidbyuserid_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/gettokenidbyuserid_fuzzer/gettokenidbyuserid_fuzzer.cpp
@@ -16,9 +16,10 @@
 #include "gettokenidbyuserid_fuzzer.h"
 
 #include <unordered_set>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -30,11 +31,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
+        FuzzedDataProvider provider(data, size);
         std::unordered_set<AccessTokenID> tokenIdList;
-        int32_t result = AccessTokenKit::GetTokenIDByUserID(fuzzData.GetData<int32_t>(), tokenIdList);
-
-        return result == RET_SUCCESS;
+        return AccessTokenKit::GetTokenIDByUserID(provider.ConsumeIntegral<int32_t>(), tokenIdList) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/gettokentype_fuzzer/gettokentype_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/gettokentype_fuzzer/gettokentype_fuzzer.cpp
index d2041314f5c02530d5fec2d013d8736489c1439b..d386e037bb34b59e152d069c3614381e0cbdb791 100644
--- a/test/fuzztest/innerkits/accesstoken/gettokentype_fuzzer/gettokentype_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/gettokentype_fuzzer/gettokentype_fuzzer.cpp
@@ -17,23 +17,22 @@
 
 #include <cstddef>
 #include <cstdint>
-#include "accesstoken_fuzzdata.h"
+
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace OHOS::Security::AccessToken;
 
 namespace OHOS {
     bool GetTokenTypeFuzzTest(const uint8_t* data, size_t size)
     {
-        ATokenTypeEnum ATokenType;
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        ATokenType = AccessTokenKit::GetTokenType(fuzzData.GetData<AccessTokenID>());
-
-        return true;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::GetTokenType(
+            provider.ConsumeIntegral<AccessTokenID>()) != ATokenTypeEnum::TOKEN_TYPE_BUTT;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/gettokentypeflag_fuzzer/gettokentypeflag_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/gettokentypeflag_fuzzer/gettokentypeflag_fuzzer.cpp
index b70090e5d30911c8f0a16eaeef185275d202c184..22c442719f248033fd44e197d172533d4c072f6e 100644
--- a/test/fuzztest/innerkits/accesstoken/gettokentypeflag_fuzzer/gettokentypeflag_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/gettokentypeflag_fuzzer/gettokentypeflag_fuzzer.cpp
@@ -17,8 +17,9 @@
 
 #include <cstddef>
 #include <cstdint>
-#include "accesstoken_fuzzdata.h"
+
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace OHOS::Security::AccessToken;
 
@@ -29,10 +30,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t result = AccessTokenKit::GetTokenTypeFlag(fuzzData.GetData<AccessTokenID>());
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::GetTokenTypeFlag(
+            provider.ConsumeIntegral<AccessTokenID>()) != ATokenTypeEnum::TOKEN_TYPE_BUTT;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/grantpermission_fuzzer/grantpermission_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/grantpermission_fuzzer/grantpermission_fuzzer.cpp
index c895827e205f1dc3ef7cc0c4c4b8fe0f07dc2ac1..6c06718677f19fe7153a9e194240e1a686c3f3d7 100644
--- a/test/fuzztest/innerkits/accesstoken/grantpermission_fuzzer/grantpermission_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/grantpermission_fuzzer/grantpermission_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -32,11 +33,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t result = AccessTokenKit::GrantPermission(
-            fuzzData.GetData<AccessTokenID>(), fuzzData.GenerateStochasticString(), 0);
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::GrantPermission(provider.ConsumeIntegral<AccessTokenID>(),
+            provider.ConsumeRandomLengthString(), provider.ConsumeIntegral<uint32_t>()) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/grantpermissionforspecifiedtime_fuzzer/grantpermissionforspecifiedtime_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/grantpermissionforspecifiedtime_fuzzer/grantpermissionforspecifiedtime_fuzzer.cpp
index 99b78d554a7c442254cd2c083be504cfc37f821b..d5cd835c2878df28440e2b7e01628fd0555ce799 100644
--- a/test/fuzztest/innerkits/accesstoken/grantpermissionforspecifiedtime_fuzzer/grantpermissionforspecifiedtime_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/grantpermissionforspecifiedtime_fuzzer/grantpermissionforspecifiedtime_fuzzer.cpp
@@ -19,25 +19,24 @@
 #include <thread>
 #include <string>
 #include <vector>
+
 #undef private
-#include "accesstoken_fuzzdata.h"
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
 
 namespace OHOS {
-    bool AllocHapTokenFuzzTest(const uint8_t* data, size_t size)
+    bool GrantPermissionForSpecifiedTimeFuzzTest(const uint8_t* data, size_t size)
     {
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        std::string permissionName(fuzzData.GenerateStochasticString());
-        int32_t result = AccessTokenKit::GrantPermissionForSpecifiedTime(
-            fuzzData.GetData<AccessTokenID>(), permissionName, fuzzData.GetData<uint32_t>());
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::GrantPermissionForSpecifiedTime(provider.ConsumeIntegral<AccessTokenID>(),
+            provider.ConsumeRandomLengthString(), provider.ConsumeIntegral<uint32_t>()) == RET_SUCCESS;
     }
 }
 
@@ -45,6 +44,6 @@ namespace OHOS {
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
     /* Run your code on data */
-    OHOS::AllocHapTokenFuzzTest(data, size);
+    OHOS::GrantPermissionForSpecifiedTimeFuzzTest(data, size);
     return 0;
 }
diff --git a/test/fuzztest/innerkits/accesstoken/inithaptoken_fuzzer/inithaptoken_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/inithaptoken_fuzzer/inithaptoken_fuzzer.cpp
index 9bce52c57d446314492e6377b8d83a181089eb81..e275c620415e465ca78aecb5079528b0480687af 100644
--- a/test/fuzztest/innerkits/accesstoken/inithaptoken_fuzzer/inithaptoken_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/inithaptoken_fuzzer/inithaptoken_fuzzer.cpp
@@ -21,63 +21,99 @@
 #include <thread>
 #include <string>
 #include <vector>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
-const int CONSTANTS_NUMBER_TWO = 2;
-static const int32_t ROOT_UID = 0;
 
 namespace OHOS {
+    void InitHapInfoParams(const std::string& bundleName, FuzzedDataProvider& provider, HapInfoParams &param)
+    {
+        param.userID = provider.ConsumeIntegral<int32_t>();
+        param.bundleName = bundleName;
+        param.instIndex = provider.ConsumeIntegral<int32_t>();
+        param.dlpType = static_cast<int32_t>(
+            provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(HapDlpType::BUTT_DLP_TYPE)));
+        param.appIDDesc = provider.ConsumeRandomLengthString();
+        param.apiVersion = provider.ConsumeIntegral<int32_t>();
+        param.isSystemApp = provider.ConsumeBool();
+        param.appDistributionType = provider.ConsumeRandomLengthString();
+        param.isRestore = provider.ConsumeBool();
+        param.tokenID = provider.ConsumeIntegral<AccessTokenID>();
+        param.isAtomicService = provider.ConsumeBool();
+    }
+
+    void InitHapPolicy(const std::string& permissionName, const std::string& bundleName, FuzzedDataProvider& provider,
+        HapPolicyParams& policy)
+    {
+        PermissionDef def = {
+            .permissionName = permissionName,
+            .bundleName = bundleName,
+            .grantMode = static_cast<int32_t>(
+                provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(GrantMode::SYSTEM_GRANT))),
+            .availableLevel = static_cast<ATokenAplEnum>(
+                provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(ATokenAplEnum::APL_ENUM_BUTT))),
+            .provisionEnable = provider.ConsumeBool(),
+            .distributedSceneEnable = provider.ConsumeBool(),
+            .label = provider.ConsumeRandomLengthString(),
+            .labelId = provider.ConsumeIntegral<int32_t>(),
+            .description = provider.ConsumeRandomLengthString(),
+            .descriptionId = provider.ConsumeIntegral<int32_t>(),
+            .availableType = static_cast<ATokenAvailableTypeEnum>(provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(ATokenAvailableTypeEnum::AVAILABLE_TYPE_BUTT))),
+            .isKernelEffect = provider.ConsumeBool(),
+            .hasValue = provider.ConsumeBool(),
+        };
+
+        PermissionStateFull state = {
+            .permissionName = permissionName,
+            .isGeneral = provider.ConsumeBool(),
+            .resDeviceID = {provider.ConsumeRandomLengthString()},
+            .grantStatus = {static_cast<int32_t>(provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(PermissionState::PERMISSION_GRANTED)))},
+            .grantFlags = {provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(PermissionFlag::PERMISSION_ALLOW_THIS_TIME))},
+        };
+
+        PreAuthorizationInfo info = {
+            .permissionName = permissionName,
+            .userCancelable = provider.ConsumeBool(),
+        };
+
+        policy.apl = static_cast<ATokenAplEnum>(
+            provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(ATokenAplEnum::APL_ENUM_BUTT)));
+        policy.domain = provider.ConsumeRandomLengthString();
+        policy.permList = {def};
+        policy.permStateList = {state};
+        policy.aclRequestedList = {provider.ConsumeRandomLengthString()};
+        policy.preAuthorizationInfo = {info};
+        policy.checkIgnore = static_cast<HapPolicyCheckIgnore>(provider.ConsumeIntegralInRange<uint32_t>(
+            0, static_cast<uint32_t>(HapPolicyCheckIgnore::ACL_IGNORE_CHECK)));
+        policy.aclExtendedMap = {std::make_pair<std::string, std::string>(provider.ConsumeRandomLengthString(),
+            provider.ConsumeRandomLengthString())};
+    }
+
     bool InitHapTokenFuzzTest(const uint8_t* data, size_t size)
     {
-        AccessTokenIDEx tokenIdEx = {0};
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        std::string permissionName(fuzzData.GenerateStochasticString());
-        std::string bundleName(fuzzData.GenerateStochasticString());
-        PermissionDef testPermDef;
-        testPermDef.permissionName = permissionName;
-        testPermDef.bundleName = bundleName;
-        testPermDef.grantMode = 1;
-        testPermDef.availableLevel = APL_NORMAL;
-        testPermDef.label = fuzzData.GenerateStochasticString();
-        testPermDef.labelId = 1;
-        testPermDef.description = fuzzData.GenerateStochasticString();
-        testPermDef.descriptionId = 1;
+        FuzzedDataProvider provider(data, size);
+        std::string permissionName = provider.ConsumeRandomLengthString();
+        std::string bundleName = provider.ConsumeRandomLengthString();
 
-        PermissionStateFull testState;
-        testState.permissionName = permissionName;
-        testState.isGeneral = true;
-        testState.resDeviceID = {fuzzData.GenerateStochasticString()};
-        testState.grantStatus = {PermissionState::PERMISSION_GRANTED};
-        testState.grantFlags = {1};
-        HapInfoParams TestInfoParms = {
-            .userID = 1,
-            .bundleName = bundleName,
-            .instIndex = 0,
-            .appIDDesc = fuzzData.GenerateStochasticString()
-        };
-        HapPolicyParams TestPolicyPrams = {
-            .apl = APL_NORMAL,
-            .domain = fuzzData.GenerateStochasticString(),
-            .permList = {testPermDef},
-            .permStateList = {testState}
-        };
+        HapInfoParams param;
+        InitHapInfoParams(bundleName, provider, param);
 
-        bool enable = ((size % CONSTANTS_NUMBER_TWO) == 0);
-        if (enable) {
-            setuid(CONSTANTS_NUMBER_TWO);
-        }
-        int32_t res = AccessTokenKit::InitHapToken(TestInfoParms, TestPolicyPrams, tokenIdEx);
-        setuid(ROOT_UID);
+        HapPolicyParams policy;
+        InitHapPolicy(permissionName, bundleName, provider, policy);
 
-        return res == 0;
+        AccessTokenIDEx tokenIdEx = {0};
+        return AccessTokenKit::InitHapToken(param, policy, tokenIdEx) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/inituserpolicy_fuzzer/inituserpolicy_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/inituserpolicy_fuzzer/inituserpolicy_fuzzer.cpp
index 1ab0898ae750562b066abf8e869fe3454ac3de4b..a09d7791f27d01aa605681b46cfd15cdf764f623 100644
--- a/test/fuzztest/innerkits/accesstoken/inituserpolicy_fuzzer/inituserpolicy_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/inituserpolicy_fuzzer/inituserpolicy_fuzzer.cpp
@@ -19,10 +19,11 @@
 #include <string>
 #include <thread>
 #include <vector>
+
 #undef private
-#include "accesstoken_fuzzdata.h"
 #include "accesstoken_kit.h"
 #include "access_token.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -34,13 +35,13 @@ bool InitUserPolicyFuzzTest(const uint8_t* data, size_t size)
         return false;
     }
 
-    AccessTokenFuzzData fuzzData(data, size);
+    FuzzedDataProvider provider(data, size);
 
-    std::string permissionName(fuzzData.GenerateStochasticString());
+    std::string permissionName = provider.ConsumeRandomLengthString();
     const std::vector<std::string> permList = {permissionName};
     UserState state;
-    state.userId = fuzzData.GetData<int32_t>();
-    state.isActive = fuzzData.GenerateStochasticBool();
+    state.userId = provider.ConsumeIntegral<int32_t>();
+    state.isActive = provider.ConsumeBool();
     std::vector<UserState> userList = {state};
     AccessTokenKit::InitUserPolicy(userList, permList);
     AccessTokenKit::UpdateUserPolicy(userList);
diff --git a/test/fuzztest/innerkits/accesstoken/istoastshownneeded_fuzzer/istoastshownneeded_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/istoastshownneeded_fuzzer/istoastshownneeded_fuzzer.cpp
index 5dd6fa8565ce8e6358ff4d1665c163a618e3b3fb..900e1ec5c03f8f19d2a65b28451266d77f0971b2 100644
--- a/test/fuzztest/innerkits/accesstoken/istoastshownneeded_fuzzer/istoastshownneeded_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/istoastshownneeded_fuzzer/istoastshownneeded_fuzzer.cpp
@@ -20,9 +20,9 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -34,9 +34,8 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
-        return AccessTokenKit::IsToastShownNeeded(fuzzData.GetData<int32_t>());
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::IsToastShownNeeded(provider.ConsumeIntegral<int32_t>());
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/registerpermstatechangecallback_fuzzer/registerpermstatechangecallback_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/registerpermstatechangecallback_fuzzer/registerpermstatechangecallback_fuzzer.cpp
index 6e6a6e56501b5db5f377aa0d51106fe653faa232..1bf1d28f44a8d57d503d600e502276da54a705b8 100644
--- a/test/fuzztest/innerkits/accesstoken/registerpermstatechangecallback_fuzzer/registerpermstatechangecallback_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/registerpermstatechangecallback_fuzzer/registerpermstatechangecallback_fuzzer.cpp
@@ -18,12 +18,13 @@
 #include <string>
 #include <vector>
 #include <thread>
+
 #include "accesstoken_callbacks.h"
-#include "accesstoken_fuzzdata.h"
 #include "accesstoken_kit.h"
 #define private public
 #include "accesstoken_manager_client.h"
 #undef private
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -53,10 +54,10 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
+        FuzzedDataProvider provider(data, size);
         PermStateChangeScope scopeInfo;
-        scopeInfo.permList = { fuzzData.GenerateStochasticString() };
-        scopeInfo.tokenIDs = { fuzzData.GetData<AccessTokenID>() };
+        scopeInfo.permList = { provider.ConsumeRandomLengthString() };
+        scopeInfo.tokenIDs = { provider.ConsumeIntegral<AccessTokenID>() };
         auto callbackPtr = std::make_shared<CbCustomizeTest2>(scopeInfo);
         AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr);
         auto callback = new (std::nothrow) PermissionStateChangeCallback(callbackPtr);
diff --git a/test/fuzztest/innerkits/accesstoken/registerseccompenhance_fuzzer/registerseccompenhance_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/registerseccompenhance_fuzzer/registerseccompenhance_fuzzer.cpp
index b18d9fa5127f3dcec333e3894101eb09f5ca62d4..5e96b26d47d1165e6c4b8eae09fbd084ccfcb379 100644
--- a/test/fuzztest/innerkits/accesstoken/registerseccompenhance_fuzzer/registerseccompenhance_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/registerseccompenhance_fuzzer/registerseccompenhance_fuzzer.cpp
@@ -20,9 +20,9 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -34,15 +34,14 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
+        FuzzedDataProvider provider(data, size);
         SecCompEnhanceData secData;
         secData.callback = nullptr;
-        secData.pid = fuzzData.GetData<int32_t>();
-        secData.token = static_cast<AccessTokenID>(fuzzData.GetData<uint32_t>());
-        secData.challenge = fuzzData.GetData<uint64_t>();
-        secData.sessionId = fuzzData.GetData<uint32_t>();
-        secData.seqNum = fuzzData.GetData<uint32_t>();
+        secData.pid = provider.ConsumeIntegral<int32_t>();
+        secData.token = provider.ConsumeIntegral<uint32_t>();
+        secData.challenge = provider.ConsumeIntegral<uint64_t>();
+        secData.sessionId = provider.ConsumeIntegral<uint32_t>();
+        secData.seqNum = provider.ConsumeIntegral<uint32_t>();
 
         return AccessTokenKit::RegisterSecCompEnhance(secData) == 0;
     }
diff --git a/test/fuzztest/innerkits/accesstoken/requestapppermonsetting_fuzzer/requestapppermonsetting_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/requestapppermonsetting_fuzzer/requestapppermonsetting_fuzzer.cpp
index d89cd97e49dc8caf6676e79c261220c6732c6c17..893f87fd95400aaea534acd289532e69b2967ac0 100644
--- a/test/fuzztest/innerkits/accesstoken/requestapppermonsetting_fuzzer/requestapppermonsetting_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/requestapppermonsetting_fuzzer/requestapppermonsetting_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -32,8 +33,8 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        AccessTokenKit::RequestAppPermOnSetting(fuzzData.GetData<AccessTokenID>());
+        FuzzedDataProvider provider(data, size);
+        AccessTokenKit::RequestAppPermOnSetting(provider.ConsumeIntegral<AccessTokenID>());
 
         return true;
     }
diff --git a/test/fuzztest/innerkits/accesstoken/revokeusergrantedpermission_fuzzer/revokeusergrantedpermission_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/revokeusergrantedpermission_fuzzer/revokeusergrantedpermission_fuzzer.cpp
index a0ebdad2d97bded6e8a7a8309a5e6e8b6d4d5105..45ad4e878176d251722adfc6622a044b1bf3c970 100644
--- a/test/fuzztest/innerkits/accesstoken/revokeusergrantedpermission_fuzzer/revokeusergrantedpermission_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/revokeusergrantedpermission_fuzzer/revokeusergrantedpermission_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -32,11 +33,11 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t result = AccessTokenKit::RevokePermission(
-            fuzzData.GetData<AccessTokenID>(), fuzzData.GenerateStochasticString(), 0);
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        uint32_t flag = provider.ConsumeIntegralInRange<uint32_t>(
+            0, static_cast<uint32_t>(PermissionFlag::PERMISSION_ALLOW_THIS_TIME));
+        return AccessTokenKit::RevokePermission(provider.ConsumeIntegral<AccessTokenID>(),
+            provider.ConsumeRandomLengthString(), flag) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/setpermdialogcap_fuzzer/setpermdialogcap_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/setpermdialogcap_fuzzer/setpermdialogcap_fuzzer.cpp
index cadbfcd40c881484b17b1b29a0771070fd4b89f6..13025d8ce7bbdfd903620d940c7a7ddd05000cbc 100644
--- a/test/fuzztest/innerkits/accesstoken/setpermdialogcap_fuzzer/setpermdialogcap_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/setpermdialogcap_fuzzer/setpermdialogcap_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <thread>
 #include <vector>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -31,15 +32,14 @@ namespace OHOS {
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
-        AccessTokenFuzzData fuzzData(data, size);
-        HapBaseInfo baseInfo;
-        baseInfo.userID = fuzzData.GetData<int32_t>();
-        baseInfo.bundleName = fuzzData.GenerateStochasticString();
-        baseInfo.instIndex = fuzzData.GetData<int32_t>();
 
-        int32_t result = AccessTokenKit::SetPermDialogCap(baseInfo, false);
+        FuzzedDataProvider provider(data, size);
+        HapBaseInfo baseInfo;
+        baseInfo.userID = provider.ConsumeIntegral<int32_t>();
+        baseInfo.bundleName = provider.ConsumeRandomLengthString();
+        baseInfo.instIndex = provider.ConsumeIntegral<int32_t>();
 
-        return result == RET_SUCCESS;
+        return AccessTokenKit::SetPermDialogCap(baseInfo, provider.ConsumeBool()) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/setpermissionrequesttogglestatus_fuzzer/setpermissionrequesttogglestatus_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/setpermissionrequesttogglestatus_fuzzer/setpermissionrequesttogglestatus_fuzzer.cpp
index 5cb9b8bc8a3c1bd5a262d48a500e47e12c50ae58..3ddfd3c7757d45f8bcb7baeb916d90ced3242052 100644
--- a/test/fuzztest/innerkits/accesstoken/setpermissionrequesttogglestatus_fuzzer/setpermissionrequesttogglestatus_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/setpermissionrequesttogglestatus_fuzzer/setpermissionrequesttogglestatus_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -32,11 +33,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t result = AccessTokenKit::SetPermissionRequestToggleStatus(
-            fuzzData.GenerateStochasticString(), fuzzData.GetData<uint32_t>(), fuzzData.GetData<int32_t>());
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::SetPermissionRequestToggleStatus(provider.ConsumeRandomLengthString(),
+            provider.ConsumeIntegral<uint32_t>(), provider.ConsumeIntegral<int32_t>()) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/setremotehaptokeninfo_fuzzer/setremotehaptokeninfo_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/setremotehaptokeninfo_fuzzer/setremotehaptokeninfo_fuzzer.cpp
index 29dd195103f6f6755623b633fe3ecdfb37d1c789..6cfce3ff968eaa1a59fd8ace5fbb33c5f4107a6a 100644
--- a/test/fuzztest/innerkits/accesstoken/setremotehaptokeninfo_fuzzer/setremotehaptokeninfo_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/setremotehaptokeninfo_fuzzer/setremotehaptokeninfo_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -28,33 +29,40 @@ using namespace OHOS::Security::AccessToken;
 namespace OHOS {
     bool SetRemoteHapTokenInfoFuzzTest(const uint8_t* data, size_t size)
     {
-#ifdef TOKEN_SYNC_ENABLE
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
+#ifdef TOKEN_SYNC_ENABLE
+        FuzzedDataProvider provider(data, size);
         HapTokenInfo baseInfo = {
-            .ver = 1,
-            .userID = 1,
-            .bundleName = fuzzData.GenerateStochasticString(),
-            .instIndex = 1,
-            .tokenID = fuzzData.GetData<AccessTokenID>(),
-            .tokenAttr = 0
+            .ver = '1',
+            .userID = provider.ConsumeIntegral<AccessTokenID>(),
+            .bundleName = provider.ConsumeRandomLengthString(),
+            .apiVersion = provider.ConsumeIntegral<int32_t>(),
+            .instIndex = provider.ConsumeIntegral<int32_t>(),
+            .dlpType = static_cast<int32_t>(
+                provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(HapDlpType::BUTT_DLP_TYPE))),
+            .tokenID = provider.ConsumeIntegral<AccessTokenID>(),
+            .tokenAttr = provider.ConsumeIntegral<uint32_t>(),
         };
-        PermissionStatus infoManagerTestState = {
-            .grantFlag = PermissionFlag::PERMISSION_SYSTEM_FIXED,
-            .grantStatus = PermissionState::PERMISSION_GRANTED,
-            .permissionName = fuzzData.GenerateStochasticString()};
-        std::vector<PermissionStatus> permStateList;
-        permStateList.emplace_back(infoManagerTestState);
+
+        PermissionStatus state = {
+            .permissionName = provider.ConsumeRandomLengthString(),
+            .grantStatus = static_cast<int32_t>(provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(PermissionState::PERMISSION_GRANTED))),
+            .grantFlag = provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(PermissionFlag::PERMISSION_ALLOW_THIS_TIME))
+        };
+        std::vector<PermissionStatus> permStateList = {state};
+
         HapTokenInfoForSync remoteTokenInfo = {
             .baseInfo = baseInfo,
             .permStateList = permStateList
         };
 
-        int32_t result = AccessTokenKit::SetRemoteHapTokenInfo(fuzzData.GenerateStochasticString(), remoteTokenInfo);
-        return result == RET_SUCCESS;
+        return AccessTokenKit::SetRemoteHapTokenInfo(
+            provider.ConsumeRandomLengthString(), remoteTokenInfo) == RET_SUCCESS;
 #else
         return true;
 #endif
diff --git a/test/fuzztest/innerkits/accesstoken/unregisterpermstatechangecallback_fuzzer/unregisterpermstatechangecallback_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/unregisterpermstatechangecallback_fuzzer/unregisterpermstatechangecallback_fuzzer.cpp
index cbc1305e7f2a38034c4177fea7017ee778f7e87c..a67442a935380a2b0b0870023d02bf392fe68137 100644
--- a/test/fuzztest/innerkits/accesstoken/unregisterpermstatechangecallback_fuzzer/unregisterpermstatechangecallback_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/unregisterpermstatechangecallback_fuzzer/unregisterpermstatechangecallback_fuzzer.cpp
@@ -18,8 +18,9 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -49,14 +50,12 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
+        FuzzedDataProvider provider(data, size);
         PermStateChangeScope scopeInfos;
-        scopeInfos.permList = { fuzzData.GenerateStochasticString() };
-        scopeInfos.tokenIDs = { fuzzData.GetData<AccessTokenID>() };
+        scopeInfos.tokenIDs = {provider.ConsumeIntegral<AccessTokenID>()};
+        scopeInfos.permList = {provider.ConsumeRandomLengthString()};
         auto callbackPtr = std::make_shared<CbCustomizeTest1>(scopeInfos);
-        int32_t result = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr);
-
-        return result == RET_SUCCESS;
+        return AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/updatehaptoken_fuzzer/updatehaptoken_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/updatehaptoken_fuzzer/updatehaptoken_fuzzer.cpp
index ed9b8e3c1756d273a1aae5c79db19c59df1d593a..0ecc44bedf9f4fb13994236dfcce5709e4fca721 100644
--- a/test/fuzztest/innerkits/accesstoken/updatehaptoken_fuzzer/updatehaptoken_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/updatehaptoken_fuzzer/updatehaptoken_fuzzer.cpp
@@ -18,58 +18,90 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
 
 namespace OHOS {
+    void InitHapPolicy(FuzzedDataProvider& provider, HapPolicyParams& policy)
+    {
+        std::string permissionName = provider.ConsumeRandomLengthString();
+        PermissionDef def = {
+            .permissionName = permissionName,
+            .bundleName = provider.ConsumeRandomLengthString(),
+            .grantMode = static_cast<int32_t>(
+                provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(GrantMode::SYSTEM_GRANT))),
+            .availableLevel = static_cast<ATokenAplEnum>(
+                provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(ATokenAplEnum::APL_ENUM_BUTT))),
+            .provisionEnable = provider.ConsumeBool(),
+            .distributedSceneEnable = provider.ConsumeBool(),
+            .label = provider.ConsumeRandomLengthString(),
+            .labelId = provider.ConsumeIntegral<int32_t>(),
+            .description = provider.ConsumeRandomLengthString(),
+            .descriptionId = provider.ConsumeIntegral<int32_t>(),
+            .availableType = static_cast<ATokenAvailableTypeEnum>(provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(ATokenAvailableTypeEnum::AVAILABLE_TYPE_BUTT))),
+            .isKernelEffect = provider.ConsumeBool(),
+            .hasValue = provider.ConsumeBool(),
+        };
+
+        PermissionStateFull state = {
+            .permissionName = permissionName,
+            .isGeneral = provider.ConsumeBool(),
+            .resDeviceID = {provider.ConsumeRandomLengthString()},
+            .grantStatus = {static_cast<int32_t>(provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(PermissionState::PERMISSION_GRANTED)))},
+            .grantFlags = {provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(PermissionFlag::PERMISSION_ALLOW_THIS_TIME))},
+        };
+
+        PreAuthorizationInfo info = {
+            .permissionName = permissionName,
+            .userCancelable = provider.ConsumeBool(),
+        };
+
+        policy.apl = static_cast<ATokenAplEnum>(
+            provider.ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(ATokenAplEnum::APL_ENUM_BUTT)));
+        policy.domain = provider.ConsumeRandomLengthString();
+        policy.permList = {def};
+        policy.permStateList = {state};
+        policy.aclRequestedList = {provider.ConsumeRandomLengthString()};
+        policy.preAuthorizationInfo = {info};
+        policy.checkIgnore = static_cast<HapPolicyCheckIgnore>(provider.ConsumeIntegralInRange<uint32_t>(
+            0, static_cast<uint32_t>(HapPolicyCheckIgnore::ACL_IGNORE_CHECK)));
+        policy.aclExtendedMap = {std::make_pair<std::string, std::string>(provider.ConsumeRandomLengthString(),
+            provider.ConsumeRandomLengthString())};
+    }
+
     bool UpdateHapTokenFuzzTest(const uint8_t* data, size_t size)
     {
         if ((data == nullptr) || (size == 0)) {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
+        FuzzedDataProvider provider(data, size);
         AccessTokenIDEx tokenIDex = {
-            .tokenIdExStruct.tokenID = fuzzData.GetData<AccessTokenID>(),
-            .tokenIdExStruct.tokenAttr = fuzzData.GetData<AccessTokenAttr>(),
+            .tokenIdExStruct.tokenID = provider.ConsumeIntegral<AccessTokenID>(),
+            .tokenIdExStruct.tokenAttr = provider.ConsumeIntegral<uint32_t>(),
         };
 
-        std::string permissionName = fuzzData.GenerateStochasticString();
-        PermissionDef testPermDef;
-        testPermDef.permissionName = permissionName;
-        testPermDef.bundleName = fuzzData.GenerateStochasticString();
-        testPermDef.grantMode = 1;
-        testPermDef.availableLevel = APL_NORMAL;
-        testPermDef.label = fuzzData.GenerateStochasticString();
-        testPermDef.labelId = 1;
-        testPermDef.description = fuzzData.GenerateStochasticString();
-        testPermDef.descriptionId = 1;
-
-        PermissionStateFull testState;
-        testState.permissionName = permissionName;
-        testState.isGeneral = true;
-        testState.resDeviceID = {fuzzData.GenerateStochasticString()};
-        testState.grantStatus = {PermissionState::PERMISSION_GRANTED};
-        testState.grantFlags = {1};
-        HapPolicyParams TestPolicyParams = {
-            .apl = APL_NORMAL,
-            .domain = fuzzData.GenerateStochasticString(),
-            .permList = {testPermDef},
-            .permStateList = {testState}
+        UpdateHapInfoParams info = {
+            .appIDDesc = provider.ConsumeRandomLengthString(),
+            .apiVersion = provider.ConsumeIntegral<int32_t>(),
+            .isSystemApp = provider.ConsumeBool(),
+            .appDistributionType = provider.ConsumeRandomLengthString(),
+            .isAtomicService = provider.ConsumeBool(),
+            .dataRefresh = provider.ConsumeBool(),
         };
-        UpdateHapInfoParams info;
-        info.appIDDesc = fuzzData.GenerateStochasticString();
-        info.apiVersion = 8; // 8 means the version
-        info.isSystemApp = false;
 
-        int32_t result = AccessTokenKit::UpdateHapToken(
-            tokenIDex, info, TestPolicyParams);
+        HapPolicyParams policy;
+        InitHapPolicy(provider, policy);
 
-        return result == RET_SUCCESS;
+        return AccessTokenKit::UpdateHapToken(tokenIDex, info, policy) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/updateseccompenhance_fuzzer/updateseccompenhance_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/updateseccompenhance_fuzzer/updateseccompenhance_fuzzer.cpp
index ae4fcaf3fc779ded9c682bec5eb1444258a8eea0..da6905cc59443ddfc30481c7f21a41028c605d8c 100644
--- a/test/fuzztest/innerkits/accesstoken/updateseccompenhance_fuzzer/updateseccompenhance_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/updateseccompenhance_fuzzer/updateseccompenhance_fuzzer.cpp
@@ -20,9 +20,9 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -34,9 +34,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
-        return AccessTokenKit::UpdateSecCompEnhance(fuzzData.GetData<int32_t>(), fuzzData.GetData<uint32_t>()) == 0;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::UpdateSecCompEnhance(provider.ConsumeIntegral<int32_t>(),
+            provider.ConsumeIntegral<uint32_t>()) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/verifyaccesstoken001_fuzzer/verifyaccesstoken001_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/verifyaccesstoken001_fuzzer/verifyaccesstoken001_fuzzer.cpp
index 8186203457267e90583a7b4787306b0fd402ab31..3bdc61791891fd28343a2b934db65406e574d72c 100644
--- a/test/fuzztest/innerkits/accesstoken/verifyaccesstoken001_fuzzer/verifyaccesstoken001_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/verifyaccesstoken001_fuzzer/verifyaccesstoken001_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -32,11 +33,10 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t result = AccessTokenKit::VerifyAccessToken(fuzzData.GetData<AccessTokenID>(),
-            fuzzData.GetData<AccessTokenID>(), fuzzData.GenerateStochasticString(), false);
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::VerifyAccessToken(provider.ConsumeIntegral<AccessTokenID>(),
+            provider.ConsumeIntegral<AccessTokenID>(), provider.ConsumeRandomLengthString(),
+            provider.ConsumeBool()) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/verifyaccesstoken_fuzzer/verifyaccesstoken_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/verifyaccesstoken_fuzzer/verifyaccesstoken_fuzzer.cpp
index f766d2e4e03c2972c5b91ae757b064cd467d3aea..0c2a0464deb1f485ac4ee5bf1e68aa05147df39a 100644
--- a/test/fuzztest/innerkits/accesstoken/verifyaccesstoken_fuzzer/verifyaccesstoken_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/verifyaccesstoken_fuzzer/verifyaccesstoken_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -32,11 +33,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t result = AccessTokenKit::VerifyAccessToken(
-            fuzzData.GetData<AccessTokenID>(), fuzzData.GenerateStochasticString(), false);
-
-        return result == RET_SUCCESS;
+        FuzzedDataProvider provider(data, size);
+        return AccessTokenKit::VerifyAccessToken(provider.ConsumeIntegral<AccessTokenID>(),
+            provider.ConsumeRandomLengthString(), provider.ConsumeBool()) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/accesstoken/verifyaccesstokenwithlist_fuzzer/verifyaccesstokenwithlist_fuzzer.cpp b/test/fuzztest/innerkits/accesstoken/verifyaccesstokenwithlist_fuzzer/verifyaccesstokenwithlist_fuzzer.cpp
index 691122aebf8e15b7ef40d0b2e3346d6cdefb3b3d..a621f7f0002937114f39dc3c5b5c6012d9524919 100644
--- a/test/fuzztest/innerkits/accesstoken/verifyaccesstokenwithlist_fuzzer/verifyaccesstokenwithlist_fuzzer.cpp
+++ b/test/fuzztest/innerkits/accesstoken/verifyaccesstokenwithlist_fuzzer/verifyaccesstokenwithlist_fuzzer.cpp
@@ -18,9 +18,10 @@
 #include <string>
 #include <vector>
 #include <thread>
-#include "accesstoken_fuzzdata.h"
+
 #undef private
 #include "accesstoken_kit.h"
+#include "fuzzer/FuzzedDataProvider.h"
 
 using namespace std;
 using namespace OHOS::Security::AccessToken;
@@ -33,19 +34,16 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
-        int permSize = fuzzData.GetData<int>() % MAX_PERMISSION_SIZE;
+        FuzzedDataProvider provider(data, size);
+        int32_t permSize = provider.ConsumeIntegral<int32_t>() % MAX_PERMISSION_SIZE;
         std::vector<std::string> permissionList;
-        std::vector<int32_t> permStateList;
-        for (int i = 0; i < permSize; i++) {
-            permissionList.emplace_back(fuzzData.GenerateStochasticString());
+        for (int32_t i = 0; i < permSize; ++i) {
+            permissionList.emplace_back(provider.ConsumeRandomLengthString());
         }
 
-        int32_t result = AccessTokenKit::VerifyAccessToken(
-            fuzzData.GetData<AccessTokenID>(), permissionList, permStateList, false);
-
-        return result == RET_SUCCESS;
+        std::vector<int32_t> permStateList;
+        return AccessTokenKit::VerifyAccessToken(provider.ConsumeIntegral<AccessTokenID>(), permissionList,
+            permStateList, provider.ConsumeBool()) == RET_SUCCESS;
     }
 }
 
diff --git a/test/fuzztest/innerkits/privacy/addpermissionusedrecord_fuzzer/addpermissionusedrecord_fuzzer.cpp b/test/fuzztest/innerkits/privacy/addpermissionusedrecord_fuzzer/addpermissionusedrecord_fuzzer.cpp
index 83b41ee9e51c41a377340e124d8c0abd6b523d88..4de8f5dd0f55957b1af774874d9a2fbe9628478e 100644
--- a/test/fuzztest/innerkits/privacy/addpermissionusedrecord_fuzzer/addpermissionusedrecord_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/addpermissionusedrecord_fuzzer/addpermissionusedrecord_fuzzer.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -34,16 +34,10 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
-        AddPermParamInfo info;
-        info.tokenId = static_cast<AccessTokenID>(fuzzData.GetData<uint32_t>());
-        info.permissionName = fuzzData.GenerateStochasticString();
-        info.successCount = fuzzData.GetData<int32_t>();
-        info.failCount = fuzzData.GetData<int32_t>();
-        info.type = fuzzData.GenerateStochasticEnmu<PermissionUsedType>(PERM_USED_TYPE_BUTT);
-
-        return PrivacyKit::AddPermissionUsedRecord(info) == 0;
+        FuzzedDataProvider provider(data, size);
+        return PrivacyKit::AddPermissionUsedRecord(provider.ConsumeIntegral<AccessTokenID>(),
+            provider.ConsumeRandomLengthString(), provider.ConsumeIntegral<int32_t>(),
+            provider.ConsumeIntegral<int32_t>(), provider.ConsumeBool()) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/privacy/addpermissionusedrecordasync_fuzzer/addpermissionusedrecordasync_fuzzer.cpp b/test/fuzztest/innerkits/privacy/addpermissionusedrecordasync_fuzzer/addpermissionusedrecordasync_fuzzer.cpp
index 16d20756b5ca986e89197c27e0395926182231c5..ab93a45ee338c52119ea6d57afc9bc7dba948633 100644
--- a/test/fuzztest/innerkits/privacy/addpermissionusedrecordasync_fuzzer/addpermissionusedrecordasync_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/addpermissionusedrecordasync_fuzzer/addpermissionusedrecordasync_fuzzer.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -34,16 +34,17 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
+        FuzzedDataProvider provider(data, size);
         AddPermParamInfo info;
-        info.tokenId = static_cast<AccessTokenID>(fuzzData.GetData<uint32_t>());
-        info.permissionName = fuzzData.GenerateStochasticString();
-        info.successCount = fuzzData.GetData<int32_t>();
-        info.failCount = fuzzData.GetData<int32_t>();
-        info.type = fuzzData.GenerateStochasticEnmu<PermissionUsedType>(PERM_USED_TYPE_BUTT);
-
-        return PrivacyKit::AddPermissionUsedRecord(info, true) == 0;
+        PermissionUsedType type = static_cast<PermissionUsedType>(provider.ConsumeIntegralInRange<uint32_t>(
+            0, static_cast<uint32_t>(PermissionUsedType::PERM_USED_TYPE_BUTT)));
+        info.tokenId = provider.ConsumeIntegral<AccessTokenID>();
+        info.permissionName = provider.ConsumeRandomLengthString();
+        info.successCount = provider.ConsumeIntegral<int32_t>();
+        info.failCount = provider.ConsumeIntegral<int32_t>();
+        info.type = type;
+
+        return PrivacyKit::AddPermissionUsedRecord(info, provider.ConsumeBool()) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/privacy/getpermissionusedrecords_fuzzer/getpermissionusedrecords_fuzzer.cpp b/test/fuzztest/innerkits/privacy/getpermissionusedrecords_fuzzer/getpermissionusedrecords_fuzzer.cpp
index 6e31736986b6c3b427d1329676516638d27771ce..0db2ddeba95d86b04e112626d1461e664b098160 100644
--- a/test/fuzztest/innerkits/privacy/getpermissionusedrecords_fuzzer/getpermissionusedrecords_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/getpermissionusedrecords_fuzzer/getpermissionusedrecords_fuzzer.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -34,22 +34,20 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        std::vector<std::string> permissionList = {fuzzData.GenerateStochasticString()};
+        FuzzedDataProvider provider(data, size);
         PermissionUsedRequest request = {
-            .tokenId = static_cast<AccessTokenID>(fuzzData.GetData<uint32_t>()),
-            .isRemote = fuzzData.GenerateStochasticBool(),
-            .deviceId = fuzzData.GenerateStochasticString(),
-            .bundleName = fuzzData.GenerateStochasticString(),
-            .permissionList = permissionList,
-            .beginTimeMillis = fuzzData.GetData<int64_t>(),
-            .endTimeMillis = fuzzData.GetData<int64_t>(),
-            .flag = fuzzData.GenerateStochasticEnmu<PermissionUsageFlag>(
-                FLAG_PERMISSION_USAGE_SUMMARY_IN_APP_FOREGROUND)
+            .tokenId = provider.ConsumeIntegral<AccessTokenID>(),
+            .isRemote = provider.ConsumeBool(),
+            .deviceId = provider.ConsumeRandomLengthString(),
+            .bundleName = provider.ConsumeRandomLengthString(),
+            .permissionList = {provider.ConsumeRandomLengthString()},
+            .beginTimeMillis = provider.ConsumeIntegral<int64_t>(),
+            .endTimeMillis = provider.ConsumeIntegral<int64_t>(),
+            .flag = static_cast<PermissionUsageFlag>(provider.ConsumeIntegralInRange<uint32_t>(
+                0, static_cast<uint32_t>(PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_UNLOCKED)))
         };
 
         PermissionUsedResult res;
-
         return PrivacyKit::GetPermissionUsedRecords(request, res) == 0;
     }
 }
diff --git a/test/fuzztest/innerkits/privacy/getpermissionusedrecordtogglestatus_fuzzer/getpermissionusedrecordtogglestatus_fuzzer.cpp b/test/fuzztest/innerkits/privacy/getpermissionusedrecordtogglestatus_fuzzer/getpermissionusedrecordtogglestatus_fuzzer.cpp
index 04ad8c8dc00d2606993f19b746f0f5878a92a257..6d51b04149ff377939839919e318fec742190252 100644
--- a/test/fuzztest/innerkits/privacy/getpermissionusedrecordtogglestatus_fuzzer/getpermissionusedrecordtogglestatus_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/getpermissionusedrecordtogglestatus_fuzzer/getpermissionusedrecordtogglestatus_fuzzer.cpp
@@ -15,7 +15,7 @@
 
 #include "getpermissionusedrecordtogglestatus_fuzzer.h"
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -29,11 +29,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t userID = fuzzData.GetData<int32_t>();
-        bool status = true;
-
-        return PrivacyKit::GetPermissionUsedRecordToggleStatus(userID, status) == 0;
+        FuzzedDataProvider provider(data, size);
+        bool status = false;
+        return PrivacyKit::GetPermissionUsedRecordToggleStatus(provider.ConsumeIntegral<int32_t>(), status) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/privacy/getpermissionusedtypeinfos_fuzzer/getpermissionusedtypeinfos_fuzzer.cpp b/test/fuzztest/innerkits/privacy/getpermissionusedtypeinfos_fuzzer/getpermissionusedtypeinfos_fuzzer.cpp
index 2494a6d77b28e13860c227344a5ba1e5b993b076..5bfb041926b9a76d65ce7d7112c47a72a8d32cff 100644
--- a/test/fuzztest/innerkits/privacy/getpermissionusedtypeinfos_fuzzer/getpermissionusedtypeinfos_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/getpermissionusedtypeinfos_fuzzer/getpermissionusedtypeinfos_fuzzer.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -34,11 +34,10 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
+        FuzzedDataProvider provider(data, size);
         std::vector<PermissionUsedTypeInfo> results;
-
-        return PrivacyKit::GetPermissionUsedTypeInfos(static_cast<AccessTokenID>(fuzzData.GetData<uint32_t>()),
-            fuzzData.GenerateStochasticString(), results) == 0;
+        return PrivacyKit::GetPermissionUsedTypeInfos(provider.ConsumeIntegral<AccessTokenID>(),
+            provider.ConsumeRandomLengthString(), results) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/privacy/isallowedusingpermission_fuzzer/isallowedusingpermission_fuzzer.cpp b/test/fuzztest/innerkits/privacy/isallowedusingpermission_fuzzer/isallowedusingpermission_fuzzer.cpp
index 0339a1e904c36ca437ca7b01e81a88b12a3c816c..e7d5a2f8d5b46049a28872ec8a47eaa4be17b2c6 100644
--- a/test/fuzztest/innerkits/privacy/isallowedusingpermission_fuzzer/isallowedusingpermission_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/isallowedusingpermission_fuzzer/isallowedusingpermission_fuzzer.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -34,10 +34,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
-        return PrivacyKit::IsAllowedUsingPermission(static_cast<AccessTokenID>(fuzzData.GetData<uint32_t>()),
-            fuzzData.GenerateStochasticString(), fuzzData.GetData<int32_t>());
+        FuzzedDataProvider provider(data, size);
+        return PrivacyKit::IsAllowedUsingPermission(provider.ConsumeIntegral<AccessTokenID>(),
+            provider.ConsumeRandomLengthString(), provider.ConsumeIntegral<int32_t>());
     }
 }
 
diff --git a/test/fuzztest/innerkits/privacy/registerpermactivestatuscallback_fuzzer/registerpermactivestatuscallback_fuzzer.cpp b/test/fuzztest/innerkits/privacy/registerpermactivestatuscallback_fuzzer/registerpermactivestatuscallback_fuzzer.cpp
index 4c8b6ef44eb52c25f44751b394439d9e2144ec70..f3b9ad439445624900390870c76ea4bc84cd4343 100644
--- a/test/fuzztest/innerkits/privacy/registerpermactivestatuscallback_fuzzer/registerpermactivestatuscallback_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/registerpermactivestatuscallback_fuzzer/registerpermactivestatuscallback_fuzzer.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -52,9 +52,8 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
-        std::vector<std::string> permList = {fuzzData.GenerateStochasticString()};
+        FuzzedDataProvider provider(data, size);
+        std::vector<std::string> permList = {provider.ConsumeRandomLengthString()};
         auto callback = std::make_shared<RegisterActiveFuzzTest>(permList);
         callback->type_ = PERM_INACTIVE;
         (void)PrivacyKit::RegisterPermActiveStatusCallback(callback);
diff --git a/test/fuzztest/innerkits/privacy/removepermissionusedrecords_fuzzer/removepermissionusedrecords_fuzzer.cpp b/test/fuzztest/innerkits/privacy/removepermissionusedrecords_fuzzer/removepermissionusedrecords_fuzzer.cpp
index fe56497407eeffe27a333c4fad7014b4dcbe70fa..753cdebfbd78e8ced2da0d1cc4417bcfba473420 100644
--- a/test/fuzztest/innerkits/privacy/removepermissionusedrecords_fuzzer/removepermissionusedrecords_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/removepermissionusedrecords_fuzzer/removepermissionusedrecords_fuzzer.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -34,9 +34,8 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
-        return PrivacyKit::RemovePermissionUsedRecords(static_cast<AccessTokenID>(fuzzData.GetData<uint32_t>())) == 0;
+        FuzzedDataProvider provider(data, size);
+        return PrivacyKit::RemovePermissionUsedRecords(provider.ConsumeIntegral<AccessTokenID>()) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/privacy/setmutepolicy_fuzzer/setmutepolicy_fuzzer.cpp b/test/fuzztest/innerkits/privacy/setmutepolicy_fuzzer/setmutepolicy_fuzzer.cpp
index 096dba505004f3ae62da2b4a0939a4bd8a912740..90e4271712165fe350b69dcba426a4b3079cefd6 100644
--- a/test/fuzztest/innerkits/privacy/setmutepolicy_fuzzer/setmutepolicy_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/setmutepolicy_fuzzer/setmutepolicy_fuzzer.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -34,10 +34,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
-        return PrivacyKit::SetMutePolicy(fuzzData.GetData<uint32_t>(), fuzzData.GetData<uint32_t>(),
-            fuzzData.GenerateStochasticBool(), fuzzData.GetData<uint32_t>()) == 0;
+        FuzzedDataProvider provider(data, size);
+        return PrivacyKit::SetMutePolicy(provider.ConsumeIntegral<uint32_t>(), provider.ConsumeIntegral<uint32_t>(),
+            provider.ConsumeBool(), provider.ConsumeIntegral<AccessTokenID>()) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/privacy/setpermissionusedrecordtogglestatus_fuzzer/setpermissionusedrecordtogglestatus_fuzzer.cpp b/test/fuzztest/innerkits/privacy/setpermissionusedrecordtogglestatus_fuzzer/setpermissionusedrecordtogglestatus_fuzzer.cpp
index fa92322cc4871c36d432c7e9aa7f51718ab396d8..28d0da998ddb11106f3cdbadda3c0fedb7569c2d 100644
--- a/test/fuzztest/innerkits/privacy/setpermissionusedrecordtogglestatus_fuzzer/setpermissionusedrecordtogglestatus_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/setpermissionusedrecordtogglestatus_fuzzer/setpermissionusedrecordtogglestatus_fuzzer.cpp
@@ -15,7 +15,7 @@
 
 #include "setpermissionusedrecordtogglestatus_fuzzer.h"
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -29,11 +29,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-        int32_t userID = fuzzData.GetData<int32_t>();
-        bool status = fuzzData.GenerateStochasticBool();
-
-        return PrivacyKit::SetPermissionUsedRecordToggleStatus(userID, status) == 0;
+        FuzzedDataProvider provider(data, size);
+        return PrivacyKit::SetPermissionUsedRecordToggleStatus(provider.ConsumeIntegral<int32_t>(),
+            provider.ConsumeBool()) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/privacy/startusingpermission001_fuzzer/startusingpermission001_fuzzer.cpp b/test/fuzztest/innerkits/privacy/startusingpermission001_fuzzer/startusingpermission001_fuzzer.cpp
index 93d0b5397072c8251b078dab719068fcdc31cb7b..182b898adcb5b79cd4920103cc72f32972096303 100644
--- a/test/fuzztest/innerkits/privacy/startusingpermission001_fuzzer/startusingpermission001_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/startusingpermission001_fuzzer/startusingpermission001_fuzzer.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -54,20 +54,21 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
+        FuzzedDataProvider provider(data, size);
         auto callback = std::make_shared<CbCustomizeTest>();
         if (callback == nullptr) {
             return false;
         }
-        AccessTokenID tokenID = static_cast<AccessTokenID>(fuzzData.GetData<uint32_t>());
+        AccessTokenID tokenID = provider.ConsumeIntegral<AccessTokenID>();
         if (g_realTokenFlag) {
             tokenID = g_realTokenId;
             g_realTokenFlag = false;
         }
 
-        return PrivacyKit::StartUsingPermission(tokenID,
-            fuzzData.GenerateStochasticString(), callback, fuzzData.GetData<int32_t>()) == 0;
+        PermissionUsedType type = static_cast<PermissionUsedType>(provider.ConsumeIntegralInRange<uint32_t>(
+            0, static_cast<uint32_t>(PermissionUsedType::PERM_USED_TYPE_BUTT)));
+        return PrivacyKit::StartUsingPermission(tokenID, provider.ConsumeRandomLengthString(), callback,
+            provider.ConsumeIntegral<int32_t>(), type) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/privacy/startusingpermission_fuzzer/startusingpermission_fuzzer.cpp b/test/fuzztest/innerkits/privacy/startusingpermission_fuzzer/startusingpermission_fuzzer.cpp
index 57d742edf35237ee3bf642e8f9c45972a4ec914b..17d54ab38fffa7218ccdb58dec58ef070965f15c 100644
--- a/test/fuzztest/innerkits/privacy/startusingpermission_fuzzer/startusingpermission_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/startusingpermission_fuzzer/startusingpermission_fuzzer.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -34,10 +34,11 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
-        return PrivacyKit::StartUsingPermission(static_cast<AccessTokenID>(fuzzData.GetData<uint32_t>()),
-            fuzzData.GenerateStochasticString(), fuzzData.GetData<uint32_t>()) == 0;
+        FuzzedDataProvider provider(data, size);
+        PermissionUsedType type = static_cast<PermissionUsedType>(provider.ConsumeIntegralInRange<uint32_t>(
+            0, static_cast<uint32_t>(PermissionUsedType::PERM_USED_TYPE_BUTT)));
+        return PrivacyKit::StartUsingPermission(provider.ConsumeIntegral<AccessTokenID>(),
+            provider.ConsumeRandomLengthString(), provider.ConsumeIntegral<int32_t>(), type) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/privacy/stopusingpermission_fuzzer/stopusingpermission_fuzzer.cpp b/test/fuzztest/innerkits/privacy/stopusingpermission_fuzzer/stopusingpermission_fuzzer.cpp
index 48940844a4cc2454e26851cbd78cfb3b6c0ef782..4739df29433039c1262881b63758f5377b2927d4 100644
--- a/test/fuzztest/innerkits/privacy/stopusingpermission_fuzzer/stopusingpermission_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/stopusingpermission_fuzzer/stopusingpermission_fuzzer.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -34,10 +34,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
-        return PrivacyKit::StopUsingPermission(static_cast<AccessTokenID>(fuzzData.GetData<uint32_t>()),
-            fuzzData.GenerateStochasticString(), fuzzData.GetData<uint32_t>()) == 0;
+        FuzzedDataProvider provider(data, size);
+        return PrivacyKit::StopUsingPermission(provider.ConsumeIntegral<AccessTokenID>(),
+            provider.ConsumeRandomLengthString(), provider.ConsumeIntegral<uint32_t>()) == 0;
     }
 }
 
diff --git a/test/fuzztest/innerkits/privacy/unregisterpermactivestatuscallback_fuzzer/unregisterpermactivestatuscallback_fuzzer.cpp b/test/fuzztest/innerkits/privacy/unregisterpermactivestatuscallback_fuzzer/unregisterpermactivestatuscallback_fuzzer.cpp
index 8012229bfefea1e6a9a5b4249c663ed25b7e759b..255da403f810f40294784c33605d495eb5682958 100644
--- a/test/fuzztest/innerkits/privacy/unregisterpermactivestatuscallback_fuzzer/unregisterpermactivestatuscallback_fuzzer.cpp
+++ b/test/fuzztest/innerkits/privacy/unregisterpermactivestatuscallback_fuzzer/unregisterpermactivestatuscallback_fuzzer.cpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-#include "accesstoken_fuzzdata.h"
+#include "fuzzer/FuzzedDataProvider.h"
 #undef private
 #include "privacy_kit.h"
 
@@ -52,11 +52,9 @@ namespace OHOS {
             return false;
         }
 
-        AccessTokenFuzzData fuzzData(data, size);
-
-        std::vector<std::string> permList = {fuzzData.GenerateStochasticString()};
+        FuzzedDataProvider provider(data, size);
+        std::vector<std::string> permList = {provider.ConsumeRandomLengthString()};
         auto callback = std::make_shared<UnRegisterActiveFuzzTest>(permList);
-        callback->type_ = PERM_INACTIVE;
 
         return PrivacyKit::UnRegisterPermActiveStatusCallback(callback) == 0;
     }