diff --git a/interfaces/inner_api/uri_permission/src/uri_permission_manager_client.cpp b/interfaces/inner_api/uri_permission/src/uri_permission_manager_client.cpp
index a0de30377a5808805996176c79519dca4a860375..3c770693e0b26e1e4dd7e3b56356a3d18ca83b74 100644
--- a/interfaces/inner_api/uri_permission/src/uri_permission_manager_client.cpp
+++ b/interfaces/inner_api/uri_permission/src/uri_permission_manager_client.cpp
@@ -67,7 +67,8 @@ int UriPermissionManagerClient::GrantUriPermission(const std::vector<Uri> &uriVe
     TAG_LOGI(AAFwkTag::URIPERMMGR, "targetBundleName:%{public}s, uriVecSize:%{public}zu", targetBundleName.c_str(),
         uriVec.size());
     if (uriVec.empty() || uriVec.size() > MAX_URI_COUNT) {
-        TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d", MAX_URI_COUNT);
+        TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d, uriVec size: %{public}d",
+            MAX_URI_COUNT, uriVec.size());
         return ERR_URI_LIST_OUT_OF_RANGE;
     }
     auto uriPermMgr = ConnectUriPermService();
@@ -110,7 +111,8 @@ int32_t UriPermissionManagerClient::GrantUriPermissionPrivileged(const std::vect
     TAG_LOGI(AAFwkTag::URIPERMMGR, "targetBundleName:%{public}s, uriVecSize:%{public}zu",
         targetBundleName.c_str(), uriVec.size());
     if (uriVec.empty() || uriVec.size() > MAX_URI_COUNT) {
-        TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d", MAX_URI_COUNT);
+        TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d, uriVec size: %{public}d",
+            MAX_URI_COUNT, uriVec.size());
         return ERR_URI_LIST_OUT_OF_RANGE;
     }
     auto uriPermMgr = ConnectUriPermService();
@@ -237,7 +239,8 @@ std::vector<bool> UriPermissionManagerClient::CheckUriAuthorization(const std::v
     TAG_LOGI(AAFwkTag::URIPERMMGR, "flag:%{public}u, tokenId:%{public}u", flag, tokenId);
     std::vector<bool> errorRes(size, false);
     if (uriVec.empty() || uriVec.size() > MAX_URI_COUNT) {
-        TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d", MAX_URI_COUNT);
+        TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d, uriVec size: %{public}d",
+            MAX_URI_COUNT, uriVec.size());
         return errorRes;
     }
     auto uriPermMgr = ConnectUriPermService();
@@ -407,10 +410,19 @@ bool UriPermissionManagerClient::RawDataToBoolVec(const UriPermissionRawData& ra
         TAG_LOGE(AAFwkTag::URIPERMMGR, "vector size not match");
         return false;
     }
+    if (boolCount == 0 || boolCount > MAX_URI_COUNT) {
+        TAG_LOGE(AAFwkTag::URIPERMMGR, "boolVec empty or exceed maxSize %{public}d, boolCount: %{public}d",
+            MAX_URI_COUNT, boolCount);
+        return false;
+    }
     for (uint32_t i = 0; i < boolCount; ++i) {
-        bool resBool = false;
-        ss.read(reinterpret_cast<char *>(&resBool), sizeof(resBool));
-        boolVec.at(i) = static_cast<bool>(resBool);
+        char resChar;
+        ss.read(reinterpret_cast<char *>(&resChar), sizeof(resChar));
+        if (resChar == 0) {
+            boolVec.at(i) = false;
+        } else {
+            boolVec.at(i) = true;
+        }
     }
     return true;
 }
@@ -438,7 +450,8 @@ int32_t UriPermissionManagerClient::Active(const std::vector<PolicyInfo> &policy
 {
     TAG_LOGD(AAFwkTag::URIPERMMGR, "call");
     if (policy.empty() || policy.size() > MAX_URI_COUNT) {
-        TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d", MAX_URI_COUNT);
+        TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d, policy size: %{public}d",
+            MAX_URI_COUNT, policy.size());
         return ERR_URI_LIST_OUT_OF_RANGE;
     }
     auto uriPermMgr = ConnectUriPermService();
diff --git a/services/uripermmgr/include/uri_permission_manager_stub_impl.h b/services/uripermmgr/include/uri_permission_manager_stub_impl.h
index b68e6bd25bb0d490846db8121f20fcc706fa6db4..dff33c82ac849a0bdccbb873f20c77b41beacd45 100644
--- a/services/uripermmgr/include/uri_permission_manager_stub_impl.h
+++ b/services/uripermmgr/include/uri_permission_manager_stub_impl.h
@@ -219,7 +219,7 @@ private:
 
 #ifdef ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
     ErrCode Active(const UriPermissionRawData& policyRawData, std::vector<uint32_t>& res, int32_t& funcResult) override;
-    bool RawDataToPolicyInfo(const UriPermissionRawData& policyRawData, std::vector<PolicyInfo>& policy);
+    ErrCode RawDataToPolicyInfo(const UriPermissionRawData& policyRawData, std::vector<PolicyInfo>& policy);
 #endif // ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
 
     class ProxyDeathRecipient : public IRemoteObject::DeathRecipient {
diff --git a/services/uripermmgr/src/uri_permission_manager_stub_impl.cpp b/services/uripermmgr/src/uri_permission_manager_stub_impl.cpp
index 9e8fcaee586ddfd06b63197c76010cfbc3640e4b..2b68034d840792d6fbfdc6e8417a95d178ee68ba 100644
--- a/services/uripermmgr/src/uri_permission_manager_stub_impl.cpp
+++ b/services/uripermmgr/src/uri_permission_manager_stub_impl.cpp
@@ -778,7 +778,8 @@ ErrCode UriPermissionManagerStubImpl::CheckUriAuthorization(const std::vector<st
         tokenId, flag, uriStrVec.size());
     funcResult = std::vector<bool>(uriStrVec.size(), false);
     if (uriStrVec.size() == 0 || uriStrVec.size() > MAX_URI_COUNT) {
-        TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d", MAX_URI_COUNT);
+        TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d uriStrVec size: %{public}d",
+            MAX_URI_COUNT, uriStrVec.size());
         return ERR_URI_LIST_OUT_OF_RANGE;
     }
     if (!UPMSUtils::IsSAOrSystemAppCall()) {
@@ -1242,8 +1243,13 @@ ErrCode UriPermissionManagerStubImpl::RawDataToStringVec(const UriPermissionRawD
     ss.write(reinterpret_cast<const char *>(rawData.data), rawData.size);
     uint32_t stringVecSize = 0;
     ss.read(reinterpret_cast<char *>(&stringVecSize), sizeof(stringVecSize));
+    if (stringVecSize == 0 || stringVecSize > MAX_URI_COUNT) {
+        TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d, stringVecSize: %{public}d",
+            MAX_URI_COUNT, stringVecSize);
+        return ERR_URI_LIST_OUT_OF_RANGE;
+    }
     uint32_t ssLength = static_cast<uint32_t>(ss.str().length());
-    for (uint32_t i = 0; i < stringVecSize; i++) {
+    for (uint32_t i = 0; i < stringVecSize; ++i) {
         uint32_t strLen = 0;
         ss.read(reinterpret_cast<char *>(&strLen), sizeof(strLen));
         if (strLen > ssLength - static_cast<uint32_t>(ss.tellg())) {
@@ -1255,10 +1261,6 @@ ErrCode UriPermissionManagerStubImpl::RawDataToStringVec(const UriPermissionRawD
         ss.read(&str[0], strLen);
         stringVec.emplace_back(str);
     }
-    if (stringVec.empty() || stringVec.size() > MAX_URI_COUNT) {
-        TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d", MAX_URI_COUNT);
-        return ERR_URI_LIST_OUT_OF_RANGE;
-    }
     return ERR_OK;
 }
 
@@ -1278,15 +1280,11 @@ ErrCode UriPermissionManagerStubImpl::Active(const UriPermissionRawData& policyR
     TAG_LOGD(AAFwkTag::URIPERMMGR, "call");
     std::vector<PolicyInfo> policy;
     auto result = RawDataToPolicyInfo(policyRawData, policy);
-    if (!result) {
+    if (result != ERR_OK) {
         TAG_LOGE(AAFwkTag::URIPERMMGR, "RawDataToPolicyInfo failed");
-        funcResult = INVALID_PARAMETERS_ERR;
+        funcResult = result;
         return funcResult;
     }
-    if (policy.empty() || policy.size() > MAX_URI_COUNT) {
-        TAG_LOGE(AAFwkTag::URIPERMMGR, "policy empty or exceed maxSize %{public}d", MAX_URI_COUNT);
-        return ERR_URI_LIST_OUT_OF_RANGE;
-    }
     uint64_t timeNow = static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(
         std::chrono::high_resolution_clock::now().time_since_epoch()).count());
     auto ret = SandboxManagerKit::StartAccessingPolicy(policy, res, false, tokenId, timeNow);
@@ -1302,7 +1300,7 @@ ErrCode UriPermissionManagerStubImpl::Active(const UriPermissionRawData& policyR
     return ERR_OK;
 }
 
-bool UriPermissionManagerStubImpl::RawDataToPolicyInfo(const UriPermissionRawData& policyRawData,
+ErrCode UriPermissionManagerStubImpl::RawDataToPolicyInfo(const UriPermissionRawData& policyRawData,
     std::vector<PolicyInfo>& policy)
 {
     std::stringstream ss;
@@ -1311,12 +1309,17 @@ bool UriPermissionManagerStubImpl::RawDataToPolicyInfo(const UriPermissionRawDat
     uint32_t ssLength = static_cast<uint32_t>(ss.str().length());
     uint32_t policyInfoSize = 0;
     ss.read(reinterpret_cast<char *>(&policyInfoSize), sizeof(policyInfoSize));
-    for (uint32_t i = 0; i < policyInfoSize; i++) {
+    if (policyInfoSize == 0 || policyInfoSize > MAX_URI_COUNT) {
+        TAG_LOGE(AAFwkTag::URIPERMMGR, "policy empty or exceed maxSize %{public}d, policyInfoSize: %{public}d",
+            MAX_URI_COUNT, policyInfoSize);
+        return ERR_URI_LIST_OUT_OF_RANGE;
+    }
+    for (uint32_t i = 0; i < policyInfoSize; ++i) {
         uint32_t pathLen = 0;
         ss.read(reinterpret_cast<char *>(&pathLen), sizeof(pathLen));
         if (pathLen > ssLength - static_cast<uint32_t>(ss.tellg())) {
             TAG_LOGE(AAFwkTag::URIPERMMGR, "path eln:%{public}u is invalid", pathLen);
-            return false;
+            return INVALID_PARAMETERS_ERR;
         }
         PolicyInfo info;
         info.path.resize(pathLen);
@@ -1324,7 +1327,7 @@ bool UriPermissionManagerStubImpl::RawDataToPolicyInfo(const UriPermissionRawDat
         ss.read(reinterpret_cast<char *>(&info.mode), sizeof(info.mode));
         policy.emplace_back(info);
     }
-    return true;
+    return ERR_OK;
 }
 #endif // ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
 }  // namespace AAFwk
diff --git a/test/unittest/uri_permission_impl_test/uri_permission_impl_test.cpp b/test/unittest/uri_permission_impl_test/uri_permission_impl_test.cpp
index ae91ed6b020c4736c0024ab1e886e5fca9d491ea..c5d8d8f856e8b2f0d58af56b95d7587ec44cdcd8 100755
--- a/test/unittest/uri_permission_impl_test/uri_permission_impl_test.cpp
+++ b/test/unittest/uri_permission_impl_test/uri_permission_impl_test.cpp
@@ -42,6 +42,10 @@ using namespace testing::ext;
 
 namespace OHOS {
 namespace AAFwk {
+namespace {
+constexpr int MAX_URI_COUNT = 200000;
+const std::string POLICY_INFO_PATH = "file://com.example.app1001/data/storage/el2/base/haps/entry/files/test_001.txt";
+}
 class UriPermissionImplTest : public testing::Test {
 public:
     static void SetUpTestCase();
@@ -2127,5 +2131,109 @@ HWTEST_F(UriPermissionImplTest, GrantUriPermissionByKey_004, TestSize.Level1)
     MyFlag::isSystemAppCall_ = false;
     EXPECT_EQ(ret, ERR_OK);
 }
+
+/*
+ * Feature: UriPermissionManagerStubImpl
+ * Function: BoolVecToRawData
+ * SubFunction: NA
+ * FunctionPoints: call BoolVecToRawData and RawDataToBoolVec failed.
+*/
+HWTEST_F(UriPermissionImplTest, RawDataToBoolVec_001, TestSize.Level1)
+{
+    auto upms = std::make_unique<UriPermissionManagerStubImpl>();
+    ASSERT_NE(upms, nullptr);
+    auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
+    std::vector<bool> boolVec;
+    UriPermissionRawData rawData;
+    std::vector<char> boolVecToCharVec;
+    upms->BoolVecToRawData(boolVec, rawData, boolVecToCharVec);
+
+    UriPermissionRawData stubRawData;
+    stubRawData.size = rawData.size;
+    EXPECT_EQ(stubRawData.RawDataCpy(rawData.data), ERR_NONE);
+
+    std::vector<bool> resultBoolVec(1, false);
+    auto result = upmc.RawDataToBoolVec(stubRawData, resultBoolVec);
+    EXPECT_EQ(result, false);
+}
+
+/*
+ * Feature: UriPermissionManagerStubImpl
+ * Function: BoolVecToRawData
+ * SubFunction: NA
+ * FunctionPoints: call BoolVecToRawData and RawDataToBoolVec failed.
+*/
+HWTEST_F(UriPermissionImplTest, RawDataToBoolVec_002, TestSize.Level1)
+{
+    auto upms = std::make_unique<UriPermissionManagerStubImpl>();
+    ASSERT_NE(upms, nullptr);
+    auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
+    std::vector<bool> boolVec(MAX_URI_COUNT + 1, true);
+    UriPermissionRawData rawData;
+    std::vector<char> boolVecToCharVec;
+    upms->BoolVecToRawData(boolVec, rawData, boolVecToCharVec);
+
+    UriPermissionRawData stubRawData;
+    stubRawData.size = rawData.size;
+    EXPECT_EQ(stubRawData.RawDataCpy(rawData.data), ERR_NONE);
+
+    std::vector<bool> resultBoolVec(1, false);
+    auto result = upmc.RawDataToBoolVec(stubRawData, resultBoolVec);
+    EXPECT_EQ(result, false);
+}
+
+/*
+ * Feature: UriPermissionManagerStubImpl
+ * Function: RawDataToPolicyInfo
+ * SubFunction: NA
+ * FunctionPoints: call PolicyInfoToRawData and RawDataToPolicyInfo failed.
+*/
+HWTEST_F(UriPermissionImplTest, RawDataToPolicyInfo_002, TestSize.Level1)
+{
+    auto upms = std::make_unique<UriPermissionManagerStubImpl>();
+    ASSERT_NE(upms, nullptr);
+    auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
+    std::vector<PolicyInfo> policyInfoArray;
+    UriPermissionRawData policyRawData;
+    upmc.PolicyInfoToRawData(policyInfoArray, policyRawData);
+
+    UriPermissionRawData stubPolicyRawData;
+    stubPolicyRawData.size = policyRawData.size;
+    EXPECT_EQ(stubPolicyRawData.RawDataCpy(policyRawData.data), ERR_NONE);
+
+    std::vector<PolicyInfo> resultPolicyInfo;
+    auto result = upms->RawDataToPolicyInfo(stubPolicyRawData, resultPolicyInfo);
+    EXPECT_EQ(result, ERR_URI_LIST_OUT_OF_RANGE);
+}
+
+/*
+ * Feature: UriPermissionManagerStubImpl
+ * Function: RawDataToPolicyInfo
+ * SubFunction: NA
+ * FunctionPoints: call PolicyInfoToRawData and RawDataToPolicyInfo failed.
+*/
+HWTEST_F(UriPermissionImplTest, RawDataToPolicyInfo_003, TestSize.Level1)
+{
+    auto upms = std::make_unique<UriPermissionManagerStubImpl>();
+    ASSERT_NE(upms, nullptr);
+    auto& upmc = AAFwk::UriPermissionManagerClient::GetInstance();
+    PolicyInfo policyInfo;
+    policyInfo.path = POLICY_INFO_PATH;
+    policyInfo.mode = 1;
+    std::vector<PolicyInfo> policyInfoArray;
+    for (int32_t i = 0; i < MAX_URI_COUNT + 1; ++i) {
+        policyInfoArray.push_back(policyInfo);
+    }
+    UriPermissionRawData policyRawData;
+    upmc.PolicyInfoToRawData(policyInfoArray, policyRawData);
+
+    UriPermissionRawData stubPolicyRawData;
+    stubPolicyRawData.size = policyRawData.size;
+    EXPECT_EQ(stubPolicyRawData.RawDataCpy(policyRawData.data), ERR_NONE);
+
+    std::vector<PolicyInfo> resultPolicyInfo;
+    auto result = upms->RawDataToPolicyInfo(stubPolicyRawData, resultPolicyInfo);
+    EXPECT_EQ(result, ERR_URI_LIST_OUT_OF_RANGE);
+}
 }  // namespace AAFwk
 }  // namespace OHOS
diff --git a/test/unittest/uri_permission_impl_test/uri_permission_manager_stub_impl_test.cpp b/test/unittest/uri_permission_impl_test/uri_permission_manager_stub_impl_test.cpp
index 32b1196e3e60ddebc9e0836ec416a95f430b54f6..e71431ac4db1467568d43c6eaa2df3eddd928d5b 100644
--- a/test/unittest/uri_permission_impl_test/uri_permission_manager_stub_impl_test.cpp
+++ b/test/unittest/uri_permission_impl_test/uri_permission_manager_stub_impl_test.cpp
@@ -20,6 +20,7 @@
 
 #define private public
 #define protected public
+#include "uri_permission_manager_client.h"
 #include "uri_permission_manager_stub_impl.h"
 #include "ability_manager_errors.h"
 #undef private
@@ -30,6 +31,10 @@ using namespace testing::ext;
 
 namespace OHOS {
 namespace AAFwk {
+namespace {
+constexpr int OFFSET = 30;
+const std::string POLICY_INFO_PATH = "file://com.example.app1001/data/storage/el2/base/haps/entry/files/test_001.txt";
+}
 class UriPermissionManagerStubImplTest : public testing::Test {
 public:
     static void SetUpTestCase();
@@ -651,11 +656,17 @@ HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RawDataToStringVec_002, TestSiz
 HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RawDataToStringVec_003, TestSize.Level1)
 {
     auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
+    auto &upmc = AAFwk::UriPermissionManagerClient::GetInstance();
+    std::vector<std::string> strArray;
+    strArray.emplace_back(POLICY_INFO_PATH);
     UriPermissionRawData rawData;
-    rawData.data = "0001000000";
-    rawData.size = 10;
+    upmc.StringVecToRawData(strArray, rawData);
+    rawData.size -= OFFSET;
+    UriPermissionRawData stubRawData;
+    stubRawData.size = rawData.size;
+    EXPECT_EQ(stubRawData.RawDataCpy(rawData.data), ERR_NONE);
     std::vector<std::string> stringVec;
-    auto result = upmsi->RawDataToStringVec(rawData, stringVec);
+    auto result = upmsi->RawDataToStringVec(stubRawData, stringVec);
     EXPECT_EQ(result, ERR_DEAD_OBJECT);
 }
 
@@ -669,12 +680,21 @@ HWTEST_F(UriPermissionManagerStubImplTest, Upmsi_RawDataToPolicyInfo_001, TestSi
 {
 #ifdef ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
     auto upmsi = std::make_shared<UriPermissionManagerStubImpl>();
+    auto &upmc = AAFwk::UriPermissionManagerClient::GetInstance();
+    PolicyInfo policyInfo;
+    policyInfo.path = POLICY_INFO_PATH;
+    policyInfo.mode = 1;
+    std::vector<PolicyInfo> policyInfoArray;
+    policyInfoArray.push_back(policyInfo);
     UriPermissionRawData policyRawData;
-    policyRawData.data = "0001000000";
-    policyRawData.size = 10;
+    upmc.PolicyInfoToRawData(policyInfoArray, policyRawData);
+    policyRawData.size -= OFFSET;
+    UriPermissionRawData stubPolicyRawData;
+    stubPolicyRawData.size = policyRawData.size;
+    EXPECT_EQ(stubPolicyRawData.RawDataCpy(policyRawData.data), ERR_NONE);
     std::vector<PolicyInfo> policy;
-    auto result = upmsi->RawDataToPolicyInfo(policyRawData, policy);
-    EXPECT_FALSE(result);
+    auto result = upmsi->RawDataToPolicyInfo(stubPolicyRawData, policy);
+    EXPECT_EQ(result, INVALID_PARAMETERS_ERR);
 #endif
 }
 }  // namespace AAFwk