From 72098d28620a9a8c655a77a9fbf670a8086ffc4f Mon Sep 17 00:00:00 2001 From: lsq Date: Thu, 22 Sep 2022 20:10:08 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=AE=89=E5=85=A8=E7=BC=96?= =?UTF-8?q?=E7=A0=81=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: lsq Change-Id: I043b078e2b72c6d1da1caf3bf07e08a253bb5017 Signed-off-by: lsq --- .../src/hap_token_info_for_sync_parcel.cpp | 15 +- .../src/native_token_info_for_sync_parcel.cpp | 15 +- .../src/native_token_info_parcel.cpp | 22 +- .../src/permission_state_full_parcel.cpp | 27 +- frameworks/common/include/parcel_utils.h | 6 + .../privacy/src/bundle_used_record_parcel.cpp | 9 +- .../src/permission_used_record_parcel.cpp | 18 +- .../src/permission_used_request_parcel.cpp | 9 +- .../src/permission_used_result_parcel.cpp | 13 +- .../test/unittest/accesstoken_parcel_test.cpp | 322 +++++++++++++++++- .../test/unittest/privacy_parcel_test.cpp | 174 ++++++++++ .../privacymanager/test/unittest/BUILD.gn | 1 + .../src/remote/soft_bus_channel.cpp | 8 +- .../src/remote/soft_bus_manager.cpp | 4 +- 14 files changed, 575 insertions(+), 68 deletions(-) diff --git a/frameworks/accesstoken/src/hap_token_info_for_sync_parcel.cpp b/frameworks/accesstoken/src/hap_token_info_for_sync_parcel.cpp index 7dbde997b..ed6f85f5e 100644 --- a/frameworks/accesstoken/src/hap_token_info_for_sync_parcel.cpp +++ b/frameworks/accesstoken/src/hap_token_info_for_sync_parcel.cpp @@ -30,10 +30,10 @@ bool HapTokenInfoForSyncParcel::Marshalling(Parcel& out) const out.WriteParcelable(&baseInfoParcel); const std::vector& permStateList = this->hapTokenInfoForSyncParams.permStateList; - int32_t permStateListSize = static_cast(permStateList.size()); - RETURN_IF_FALSE(out.WriteInt32(permStateListSize)); - RETURN_IF_FALSE((permStateListSize <= MAX_PERMLIST_SIZE)); - for (int i = 0; i < permStateListSize; i++) { + uint32_t permStateListSize = permStateList.size(); + RETURN_IF_FALSE(permStateListSize <= MAX_PERMLIST_SIZE); + RETURN_IF_FALSE(out.WriteUint32(permStateListSize)); + for (uint32_t i = 0; i < permStateListSize; i++) { PermissionStateFullParcel permStateParcel; permStateParcel.permStatFull = permStateList[i]; out.WriteParcelable(&permStateParcel); @@ -53,9 +53,10 @@ HapTokenInfoForSyncParcel* HapTokenInfoForSyncParcel::Unmarshalling(Parcel& in) RELEASE_IF_FALSE(baseInfoParcel != nullptr, hapTokenInfoForSyncParcel); hapTokenInfoForSyncParcel->hapTokenInfoForSyncParams.baseInfo = baseInfoParcel->hapTokenInfoParams; - int permStateListSize; - RELEASE_IF_FALSE(in.ReadInt32(permStateListSize), hapTokenInfoForSyncParcel); - for (int i = 0; i < permStateListSize; i++) { + uint32_t permStateListSize; + RELEASE_IF_FALSE(in.ReadUint32(permStateListSize), hapTokenInfoForSyncParcel); + RELEASE_IF_FALSE((permStateListSize <= MAX_PERMLIST_SIZE), hapTokenInfoForSyncParcel); + for (uint32_t i = 0; i < permStateListSize; i++) { sptr permissionStateParcel = in.ReadParcelable(); RELEASE_IF_FALSE(permissionStateParcel != nullptr, hapTokenInfoForSyncParcel); hapTokenInfoForSyncParcel->hapTokenInfoForSyncParams.permStateList.emplace_back( diff --git a/frameworks/accesstoken/src/native_token_info_for_sync_parcel.cpp b/frameworks/accesstoken/src/native_token_info_for_sync_parcel.cpp index 0ef3ca197..d380db591 100644 --- a/frameworks/accesstoken/src/native_token_info_for_sync_parcel.cpp +++ b/frameworks/accesstoken/src/native_token_info_for_sync_parcel.cpp @@ -30,10 +30,10 @@ bool NativeTokenInfoForSyncParcel::Marshalling(Parcel& out) const RETURN_IF_FALSE(out.WriteParcelable(&baseInfoParcel)); const std::vector& permStateList = this->nativeTokenInfoForSyncParams.permStateList; - int32_t permStateListSize = static_cast(permStateList.size()); - RETURN_IF_FALSE(out.WriteInt32(permStateListSize)); - RETURN_IF_FALSE((permStateListSize <= MAX_PERMLIST_SIZE)); - for (int i = 0; i < permStateListSize; i++) { + uint32_t permStateListSize = permStateList.size(); + RETURN_IF_FALSE(permStateListSize <= MAX_PERMLIST_SIZE); + RETURN_IF_FALSE(out.WriteUint32(permStateListSize)); + for (uint32_t i = 0; i < permStateListSize; i++) { PermissionStateFullParcel permStateParcel; permStateParcel.permStatFull = permStateList[i]; RETURN_IF_FALSE(out.WriteParcelable(&permStateParcel)); @@ -53,9 +53,10 @@ NativeTokenInfoForSyncParcel* NativeTokenInfoForSyncParcel::Unmarshalling(Parcel RELEASE_IF_FALSE(baseInfoParcel != nullptr, nativeTokenInfoForSyncParcel); nativeTokenInfoForSyncParcel->nativeTokenInfoForSyncParams.baseInfo = baseInfoParcel->nativeTokenInfoParams; - int permStateListSize; - RELEASE_IF_FALSE(in.ReadInt32(permStateListSize), nativeTokenInfoForSyncParcel); - for (int i = 0; i < permStateListSize; i++) { + uint32_t permStateListSize; + RELEASE_IF_FALSE(in.ReadUint32(permStateListSize), nativeTokenInfoForSyncParcel); + RELEASE_IF_FALSE(permStateListSize <= MAX_PERMLIST_SIZE, nativeTokenInfoForSyncParcel); + for (uint32_t i = 0; i < permStateListSize; i++) { sptr permissionStateParcel = in.ReadParcelable(); RELEASE_IF_FALSE(permissionStateParcel != nullptr, nativeTokenInfoForSyncParcel); nativeTokenInfoForSyncParcel->nativeTokenInfoForSyncParams.permStateList.emplace_back( diff --git a/frameworks/accesstoken/src/native_token_info_parcel.cpp b/frameworks/accesstoken/src/native_token_info_parcel.cpp index 06ff8df14..c07b33643 100644 --- a/frameworks/accesstoken/src/native_token_info_parcel.cpp +++ b/frameworks/accesstoken/src/native_token_info_parcel.cpp @@ -32,21 +32,21 @@ bool NativeTokenInfoParcel::Marshalling(Parcel& out) const RETURN_IF_FALSE(out.WriteUint32(this->nativeTokenInfoParams.tokenID)); RETURN_IF_FALSE(out.WriteUint32(this->nativeTokenInfoParams.tokenAttr)); - if ((this->nativeTokenInfoParams.dcap).size() > INT32_MAX) { + if ((this->nativeTokenInfoParams.dcap).size() > MAX_DCAP_SIZE) { return false; } - int32_t dcapSize = static_cast((this->nativeTokenInfoParams.dcap).size()); - RETURN_IF_FALSE(out.WriteInt32(dcapSize)); + uint32_t dcapSize = (this->nativeTokenInfoParams.dcap).size(); + RETURN_IF_FALSE(out.WriteUint32(dcapSize)); for (const auto& dcapItem : this->nativeTokenInfoParams.dcap) { RETURN_IF_FALSE(out.WriteString(dcapItem)); } - if ((this->nativeTokenInfoParams.nativeAcls).size() > INT32_MAX) { + if ((this->nativeTokenInfoParams.nativeAcls).size() > MAX_ACL_SIZE) { return false; } - int32_t nativeAclSize = static_cast((this->nativeTokenInfoParams.nativeAcls).size()); - RETURN_IF_FALSE(out.WriteInt32(nativeAclSize)); + uint32_t nativeAclSize = (this->nativeTokenInfoParams.nativeAcls).size(); + RETURN_IF_FALSE(out.WriteUint32(nativeAclSize)); for (const auto& item : this->nativeTokenInfoParams.nativeAcls) { RETURN_IF_FALSE(out.WriteString(item)); @@ -73,8 +73,9 @@ NativeTokenInfoParcel* NativeTokenInfoParcel::Unmarshalling(Parcel& in) RELEASE_IF_FALSE(in.ReadUint32(nativeTokenInfoParcel->nativeTokenInfoParams.tokenID), nativeTokenInfoParcel); RELEASE_IF_FALSE(in.ReadUint32(nativeTokenInfoParcel->nativeTokenInfoParams.tokenAttr), nativeTokenInfoParcel); - int32_t dcapSize; - RELEASE_IF_FALSE(in.ReadInt32(dcapSize), nativeTokenInfoParcel); + uint32_t dcapSize; + RELEASE_IF_FALSE(in.ReadUint32(dcapSize), nativeTokenInfoParcel); + RELEASE_IF_FALSE(dcapSize <= MAX_DCAP_SIZE, nativeTokenInfoParcel); for (int32_t i = 0; i < dcapSize; i++) { std::string dcapsItem; @@ -82,8 +83,9 @@ NativeTokenInfoParcel* NativeTokenInfoParcel::Unmarshalling(Parcel& in) nativeTokenInfoParcel->nativeTokenInfoParams.dcap.emplace_back(dcapsItem); } - int32_t nativeAclSize; - RELEASE_IF_FALSE(in.ReadInt32(nativeAclSize), nativeTokenInfoParcel); + uint32_t nativeAclSize; + RELEASE_IF_FALSE(in.ReadUint32(nativeAclSize), nativeTokenInfoParcel); + RELEASE_IF_FALSE(nativeAclSize <= MAX_ACL_SIZE, nativeTokenInfoParcel); for (int32_t i = 0; i < nativeAclSize; i++) { std::string item; diff --git a/frameworks/accesstoken/src/permission_state_full_parcel.cpp b/frameworks/accesstoken/src/permission_state_full_parcel.cpp index 364676c23..22425a99e 100644 --- a/frameworks/accesstoken/src/permission_state_full_parcel.cpp +++ b/frameworks/accesstoken/src/permission_state_full_parcel.cpp @@ -24,17 +24,17 @@ bool PermissionStateFullParcel::Marshalling(Parcel& out) const RETURN_IF_FALSE(out.WriteString(this->permStatFull.permissionName)); RETURN_IF_FALSE(out.WriteBool(this->permStatFull.isGeneral)); - RETURN_IF_FALSE(out.WriteInt32((int32_t)(this->permStatFull.resDeviceID.size()))); + RETURN_IF_FALSE(out.WriteUint32(this->permStatFull.resDeviceID.size())); for (auto devId : this->permStatFull.resDeviceID) { RETURN_IF_FALSE(out.WriteString(devId)); } - RETURN_IF_FALSE(out.WriteInt32((int32_t)(this->permStatFull.grantStatus.size()))); + RETURN_IF_FALSE(out.WriteUint32(this->permStatFull.grantStatus.size())); for (auto grantStat : this->permStatFull.grantStatus) { RETURN_IF_FALSE(out.WriteInt32(grantStat)); } - RETURN_IF_FALSE(out.WriteInt32((int32_t)(this->permStatFull.grantFlags.size()))); + RETURN_IF_FALSE(out.WriteUint32(this->permStatFull.grantFlags.size())); for (auto grantFlag : this->permStatFull.grantFlags) { RETURN_IF_FALSE(out.WriteInt32(grantFlag)); } @@ -51,25 +51,28 @@ PermissionStateFullParcel* PermissionStateFullParcel::Unmarshalling(Parcel& in) RELEASE_IF_FALSE(in.ReadString(permissionStateParcel->permStatFull.permissionName), permissionStateParcel); RELEASE_IF_FALSE(in.ReadBool(permissionStateParcel->permStatFull.isGeneral), permissionStateParcel); - int resIdSize = 0; - RELEASE_IF_FALSE(in.ReadInt32(resIdSize), permissionStateParcel); - for (int i = 0; i < resIdSize; i++) { + uint32_t resIdSize = 0; + RELEASE_IF_FALSE(in.ReadUint32(resIdSize), permissionStateParcel); + RELEASE_IF_FALSE(resIdSize <= MAX_DEVICE_ID_SIZE, permissionStateParcel); + for (uint32_t i = 0; i < resIdSize; i++) { std::string resId; RELEASE_IF_FALSE(in.ReadString(resId), permissionStateParcel); permissionStateParcel->permStatFull.resDeviceID.emplace_back(resId); } - int grantStatsSize = 0; - RELEASE_IF_FALSE(in.ReadInt32(grantStatsSize), permissionStateParcel); - for (int i = 0; i < grantStatsSize; i++) { + uint32_t grantStatsSize = 0; + RELEASE_IF_FALSE(in.ReadUint32(grantStatsSize), permissionStateParcel); + RELEASE_IF_FALSE(grantStatsSize <= MAX_DEVICE_ID_SIZE, permissionStateParcel); + for (uint32_t i = 0; i < grantStatsSize; i++) { int grantStat; RELEASE_IF_FALSE(in.ReadInt32(grantStat), permissionStateParcel); permissionStateParcel->permStatFull.grantStatus.emplace_back(grantStat); } - int grantFlagSize = 0; - RELEASE_IF_FALSE(in.ReadInt32(grantFlagSize), permissionStateParcel); - for (int i = 0; i < grantFlagSize; i++) { + uint32_t grantFlagSize = 0; + RELEASE_IF_FALSE(in.ReadUint32(grantFlagSize), permissionStateParcel); + RELEASE_IF_FALSE(grantFlagSize <= MAX_DEVICE_ID_SIZE, permissionStateParcel); + for (uint32_t i = 0; i < grantFlagSize; i++) { int flag; RELEASE_IF_FALSE(in.ReadInt32(flag), permissionStateParcel); permissionStateParcel->permStatFull.grantFlags.emplace_back(flag); diff --git a/frameworks/common/include/parcel_utils.h b/frameworks/common/include/parcel_utils.h index fcd97ae82..788b7f471 100644 --- a/frameworks/common/include/parcel_utils.h +++ b/frameworks/common/include/parcel_utils.h @@ -16,6 +16,12 @@ #ifndef PARCEL_UTILS_H #define PARCEL_UTILS_H #define MAX_PERMLIST_SIZE 256 +#define MAX_DCAP_SIZE 32 +#define MAX_ACL_SIZE 64 +#define MAX_DEVICE_ID_SIZE 1024 +#define MAX_RECORD_SIZE 1024 +#define MAX_ACCESS_RECORD_SIZE 10 + namespace OHOS { namespace Security { namespace AccessToken { diff --git a/frameworks/privacy/src/bundle_used_record_parcel.cpp b/frameworks/privacy/src/bundle_used_record_parcel.cpp index 65d470af3..0624740c5 100644 --- a/frameworks/privacy/src/bundle_used_record_parcel.cpp +++ b/frameworks/privacy/src/bundle_used_record_parcel.cpp @@ -28,7 +28,7 @@ bool BundleUsedRecordParcel::Marshalling(Parcel& out) const RETURN_IF_FALSE(out.WriteString(this->bundleRecord.deviceId)); RETURN_IF_FALSE(out.WriteString(this->bundleRecord.bundleName)); - RETURN_IF_FALSE(out.WriteInt32((int32_t)(this->bundleRecord.permissionRecords.size()))); + RETURN_IF_FALSE(out.WriteUint32(this->bundleRecord.permissionRecords.size())); for (const auto& permRecord : this->bundleRecord.permissionRecords) { PermissionUsedRecordParcel permRecordParcel; permRecordParcel.permissionRecord = permRecord; @@ -49,9 +49,10 @@ BundleUsedRecordParcel* BundleUsedRecordParcel::Unmarshalling(Parcel& in) RELEASE_IF_FALSE(in.ReadString(bundleRecordParcel->bundleRecord.deviceId), bundleRecordParcel); RELEASE_IF_FALSE(in.ReadString(bundleRecordParcel->bundleRecord.bundleName), bundleRecordParcel); - int32_t permRecordSize = 0; - RELEASE_IF_FALSE(in.ReadInt32(permRecordSize), bundleRecordParcel); - for (int32_t i = 0; i < permRecordSize; i++) { + uint32_t permRecordSize = 0; + RELEASE_IF_FALSE(in.ReadUint32(permRecordSize), bundleRecordParcel); + RELEASE_IF_FALSE(permRecordSize <= MAX_RECORD_SIZE, bundleRecordParcel); + for (uint32_t i = 0; i < permRecordSize; i++) { sptr permRecord = in.ReadParcelable(); RELEASE_IF_FALSE(permRecord != nullptr, bundleRecordParcel); bundleRecordParcel->bundleRecord.permissionRecords.emplace_back(permRecord->permissionRecord); diff --git a/frameworks/privacy/src/permission_used_record_parcel.cpp b/frameworks/privacy/src/permission_used_record_parcel.cpp index cda521c31..205785523 100644 --- a/frameworks/privacy/src/permission_used_record_parcel.cpp +++ b/frameworks/privacy/src/permission_used_record_parcel.cpp @@ -30,14 +30,14 @@ bool PermissionUsedRecordParcel::Marshalling(Parcel& out) const RETURN_IF_FALSE(out.WriteInt64(this->permissionRecord.lastRejectTime)); RETURN_IF_FALSE(out.WriteInt64(this->permissionRecord.lastAccessDuration)); - RETURN_IF_FALSE(out.WriteInt32((int32_t)(this->permissionRecord.accessRecords.size()))); + RETURN_IF_FALSE(out.WriteUint32(this->permissionRecord.accessRecords.size())); for (const auto& accRecord : this->permissionRecord.accessRecords) { UsedRecordDetailParcel detailParcel; detailParcel.detail = accRecord; out.WriteParcelable(&detailParcel); } - RETURN_IF_FALSE(out.WriteInt32((int32_t)(this->permissionRecord.rejectRecords.size()))); + RETURN_IF_FALSE(out.WriteUint32(this->permissionRecord.rejectRecords.size())); for (const auto& rejRecord : this->permissionRecord.rejectRecords) { UsedRecordDetailParcel detailParcel; detailParcel.detail = rejRecord; @@ -60,17 +60,19 @@ PermissionUsedRecordParcel* PermissionUsedRecordParcel::Unmarshalling(Parcel& in RELEASE_IF_FALSE(in.ReadInt64(permissionRecordParcel->permissionRecord.lastRejectTime), permissionRecordParcel); RELEASE_IF_FALSE(in.ReadInt64(permissionRecordParcel->permissionRecord.lastAccessDuration), permissionRecordParcel); - int32_t accRecordSize = 0; - RELEASE_IF_FALSE(in.ReadInt32(accRecordSize), permissionRecordParcel); - for (int32_t i = 0; i < accRecordSize; i++) { + uint32_t accRecordSize = 0; + RELEASE_IF_FALSE(in.ReadUint32(accRecordSize), permissionRecordParcel); + RELEASE_IF_FALSE(accRecordSize <= MAX_ACCESS_RECORD_SIZE, permissionRecordParcel); + for (uint32_t i = 0; i < accRecordSize; i++) { sptr detailParcel = in.ReadParcelable(); RELEASE_IF_FALSE(detailParcel != nullptr, permissionRecordParcel); permissionRecordParcel->permissionRecord.accessRecords.emplace_back(detailParcel->detail); } - int32_t rejRecordSize = 0; - RELEASE_IF_FALSE(in.ReadInt32(rejRecordSize), permissionRecordParcel); - for (int32_t i = 0; i < rejRecordSize; i++) { + uint32_t rejRecordSize = 0; + RELEASE_IF_FALSE(in.ReadUint32(rejRecordSize), permissionRecordParcel); + RELEASE_IF_FALSE(rejRecordSize <= MAX_ACCESS_RECORD_SIZE, permissionRecordParcel); + for (uint32_t i = 0; i < rejRecordSize; i++) { sptr detailParcel = in.ReadParcelable(); RELEASE_IF_FALSE(detailParcel != nullptr, permissionRecordParcel); permissionRecordParcel->permissionRecord.rejectRecords.emplace_back(detailParcel->detail); diff --git a/frameworks/privacy/src/permission_used_request_parcel.cpp b/frameworks/privacy/src/permission_used_request_parcel.cpp index 51a33b0cb..4f4a3fb4d 100644 --- a/frameworks/privacy/src/permission_used_request_parcel.cpp +++ b/frameworks/privacy/src/permission_used_request_parcel.cpp @@ -26,7 +26,7 @@ bool PermissionUsedRequestParcel::Marshalling(Parcel& out) const RETURN_IF_FALSE(out.WriteString(this->request.deviceId)); RETURN_IF_FALSE(out.WriteString(this->request.bundleName)); - RETURN_IF_FALSE(out.WriteInt32((int32_t)(this->request.permissionList.size()))); + RETURN_IF_FALSE(out.WriteUint32(this->request.permissionList.size())); for (const auto& perm : this->request.permissionList) { RETURN_IF_FALSE(out.WriteString(perm)); } @@ -48,9 +48,10 @@ PermissionUsedRequestParcel* PermissionUsedRequestParcel::Unmarshalling(Parcel& RELEASE_IF_FALSE(in.ReadString(requestParcel->request.deviceId), requestParcel); RELEASE_IF_FALSE(in.ReadString(requestParcel->request.bundleName), requestParcel); - int32_t permSize = 0; - RELEASE_IF_FALSE(in.ReadInt32(permSize), requestParcel); - for (int32_t i = 0; i < permSize; i++) { + uint32_t permSize = 0; + RELEASE_IF_FALSE(in.ReadUint32(permSize), requestParcel); + RELEASE_IF_FALSE(permSize <= MAX_PERMLIST_SIZE, requestParcel); + for (uint32_t i = 0; i < permSize; i++) { std::string perm; RELEASE_IF_FALSE(in.ReadString(perm), requestParcel); requestParcel->request.permissionList.emplace_back(perm); diff --git a/frameworks/privacy/src/permission_used_result_parcel.cpp b/frameworks/privacy/src/permission_used_result_parcel.cpp index dbbe648fa..cdb490a2c 100644 --- a/frameworks/privacy/src/permission_used_result_parcel.cpp +++ b/frameworks/privacy/src/permission_used_result_parcel.cpp @@ -13,10 +13,10 @@ * limitations under the License. */ -#include "permission_used_result_parcel.h" -#include "refbase.h" #include "bundle_used_record_parcel.h" #include "parcel_utils.h" +#include "permission_used_result_parcel.h" +#include "refbase.h" namespace OHOS { namespace Security { @@ -26,7 +26,7 @@ bool PermissionUsedResultParcel::Marshalling(Parcel& out) const RETURN_IF_FALSE(out.WriteInt64(this->result.beginTimeMillis)); RETURN_IF_FALSE(out.WriteInt64(this->result.endTimeMillis)); - RETURN_IF_FALSE(out.WriteInt32((int32_t)(this->result.bundleRecords.size()))); + RETURN_IF_FALSE(out.WriteUint32(this->result.bundleRecords.size())); for (const auto& bundRecord : this->result.bundleRecords) { BundleUsedRecordParcel bundleParcel; bundleParcel.bundleRecord = bundRecord; @@ -45,9 +45,10 @@ PermissionUsedResultParcel* PermissionUsedResultParcel::Unmarshalling(Parcel& in RELEASE_IF_FALSE(in.ReadInt64(resultParcel->result.beginTimeMillis), resultParcel); RELEASE_IF_FALSE(in.ReadInt64(resultParcel->result.endTimeMillis), resultParcel); - int32_t bundResponseSize = 0; - RELEASE_IF_FALSE(in.ReadInt32(bundResponseSize), resultParcel); - for (int32_t i = 0; i < bundResponseSize; i++) { + uint32_t bundResponseSize = 0; + RELEASE_IF_FALSE(in.ReadUint32(bundResponseSize), resultParcel); + RELEASE_IF_FALSE(bundResponseSize <= MAX_RECORD_SIZE, resultParcel); + for (uint32_t i = 0; i < bundResponseSize; i++) { sptr bunRecordParcel = in.ReadParcelable(); RELEASE_IF_FALSE(bunRecordParcel != nullptr, resultParcel); resultParcel->result.bundleRecords.emplace_back(bunRecordParcel->bundleRecord); diff --git a/frameworks/test/unittest/accesstoken_parcel_test.cpp b/frameworks/test/unittest/accesstoken_parcel_test.cpp index 9003c49b5..271f6a571 100644 --- a/frameworks/test/unittest/accesstoken_parcel_test.cpp +++ b/frameworks/test/unittest/accesstoken_parcel_test.cpp @@ -20,10 +20,16 @@ #include "access_token.h" #include "hap_info_parcel.h" #include "hap_policy_parcel.h" +#include "hap_token_info_parcel.h" +#include "hap_token_info_for_sync_parcel.h" +#include "native_token_info_for_sync_parcel.h" +#include "native_token_info_parcel.h" #include "parcel.h" +#include "parcel_utils.h" #include "permission_state_change_scope_parcel.h" #include "permission_state_change_info_parcel.h" #include "permission_state_full.h" +#include "permission_state_full_parcel.h" using namespace testing::ext; @@ -107,7 +113,7 @@ HWTEST_F(AccessTokenParcelTest, HapInfoParcel001, TestSize.Level1) EXPECT_EQ(true, hapinfoParcel.Marshalling(parcel)); std::shared_ptr readedData(HapInfoParcel::Unmarshalling(parcel)); - EXPECT_EQ(true, readedData != nullptr); + EXPECT_NE(nullptr, readedData); EXPECT_EQ(hapinfoParcel.hapInfoParameter.userID, readedData->hapInfoParameter.userID); EXPECT_EQ(true, hapinfoParcel.hapInfoParameter.bundleName == readedData->hapInfoParameter.bundleName); @@ -137,7 +143,7 @@ HWTEST_F(AccessTokenParcelTest, HapPolicyParcel001, TestSize.Level1) EXPECT_EQ(true, hapPolicyParcel.Marshalling(parcel)); std::shared_ptr readedData(HapPolicyParcel::Unmarshalling(parcel)); - EXPECT_EQ(true, readedData != nullptr); + EXPECT_NE(nullptr, readedData); EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.apl, readedData->hapPolicyParameter.apl); EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.domain, readedData->hapPolicyParameter.domain); @@ -195,7 +201,7 @@ HWTEST_F(AccessTokenParcelTest, PermissionStateChangeInfoParcel001, TestSize.Lev EXPECT_EQ(true, permissionStateParcel.Marshalling(parcel)); std::shared_ptr readedData(PermissionStateChangeInfoParcel::Unmarshalling(parcel)); - EXPECT_EQ(true, readedData != nullptr); + EXPECT_NE(nullptr, readedData); EXPECT_EQ(permissionStateParcel.changeInfo.PermStateChangeType, readedData->changeInfo.PermStateChangeType); EXPECT_EQ(permissionStateParcel.changeInfo.tokenID, readedData->changeInfo.tokenID); EXPECT_EQ(permissionStateParcel.changeInfo.permissionName, readedData->changeInfo.permissionName); @@ -217,7 +223,7 @@ HWTEST_F(AccessTokenParcelTest, PermStateChangeScopeParcel001, TestSize.Level1) EXPECT_EQ(true, permStateChangeScopeParcel.Marshalling(parcel)); std::shared_ptr readedData(PermStateChangeScopeParcel::Unmarshalling(parcel)); - EXPECT_EQ(true, readedData != nullptr); + EXPECT_NE(nullptr, readedData); EXPECT_EQ(true, permStateChangeScopeParcel.scope.tokenIDs.size() == readedData->scope.tokenIDs.size()); EXPECT_EQ(true, permStateChangeScopeParcel.scope.permList.size() == readedData->scope.permList.size()); @@ -229,6 +235,314 @@ HWTEST_F(AccessTokenParcelTest, PermStateChangeScopeParcel001, TestSize.Level1) EXPECT_EQ(true, permStateChangeScopeParcel.scope.permList[i] == readedData->scope.permList[i]); } } + +/** + * @tc.name: HapTokenInfoForSyncParcel001 + * @tc.desc: Test HapTokenInfoForSync Marshalling/Unmarshalling. + * @tc.type: FUNC + * @tc.require: issueI5QKZF + */ +HWTEST_F(AccessTokenParcelTest, HapTokenInfoForSyncParcel001, TestSize.Level1) +{ + HapTokenInfoForSyncParcel hapTokenInfoSync; + + HapTokenInfo hapTokenInfo; + hapTokenInfo.apl = ATokenAplEnum::APL_NORMAL; + hapTokenInfo.ver = 0; + hapTokenInfo.userID = 2; + hapTokenInfo.bundleName = "bundle"; + hapTokenInfo.apiVersion = 8; + hapTokenInfo.instIndex = 0; + hapTokenInfo.dlpType = 0; + hapTokenInfo.appID = "111"; + hapTokenInfo.deviceID = "0"; + hapTokenInfo.tokenID = 0x53100000; + hapTokenInfo.tokenAttr = 0; + hapTokenInfoSync.hapTokenInfoForSyncParams.baseInfo = hapTokenInfo; + hapTokenInfoSync.hapTokenInfoForSyncParams.permStateList.emplace_back(g_permStatBeta); + + Parcel parcel; + EXPECT_EQ(true, hapTokenInfoSync.Marshalling(parcel)); + std::shared_ptr readedData(HapTokenInfoForSyncParcel::Unmarshalling(parcel)); + EXPECT_NE(nullptr, readedData); +} + +/** + * @tc.name: HapTokenInfoForSyncParcel002 + * @tc.desc: Test HapTokenInfoForSync Marshalling/Unmarshalling. + * @tc.type: FUNC + * @tc.require: issueI5QKZF + */ +HWTEST_F(AccessTokenParcelTest, HapTokenInfoForSyncParcel002, TestSize.Level1) +{ + HapTokenInfoForSyncParcel hapTokenInfoSync; + + HapTokenInfo hapTokenInfo; + hapTokenInfo.apl = ATokenAplEnum::APL_NORMAL; + hapTokenInfo.ver = 0; + hapTokenInfo.userID = 2; + hapTokenInfo.bundleName = "bundle"; + hapTokenInfo.apiVersion = 8; + hapTokenInfo.instIndex = 0; + hapTokenInfo.dlpType = 0; + hapTokenInfo.appID = "111"; + hapTokenInfo.deviceID = "0"; + hapTokenInfo.tokenID = 0x53100000; + hapTokenInfo.tokenAttr = 0; + + Parcel out; + HapTokenInfoParcel baseInfoParcel; + baseInfoParcel.hapTokenInfoParams = hapTokenInfo; + out.WriteParcelable(&baseInfoParcel); + + std::vector permStateList; + for (uint32_t i = 0; i < MAX_PERMLIST_SIZE; i++) { + permStateList.emplace_back(g_permStatBeta); + } + uint32_t permStateListSize = permStateList.size(); + out.WriteUint32(permStateListSize); + for (uint32_t i = 0; i < permStateListSize; i++) { + PermissionStateFullParcel permStateParcel; + permStateParcel.permStatFull = permStateList[i]; + out.WriteParcelable(&permStateParcel); + } + + std::shared_ptr readedData(HapTokenInfoForSyncParcel::Unmarshalling(out)); + EXPECT_NE(nullptr, readedData); + + Parcel out1; + out1.WriteParcelable(&baseInfoParcel); + permStateList.emplace_back(g_permStatBeta); + + permStateListSize = permStateList.size(); + out1.WriteUint32(permStateListSize); + for (uint32_t i = 0; i < permStateListSize; i++) { + PermissionStateFullParcel permStateParcel; + permStateParcel.permStatFull = permStateList[i]; + out1.WriteParcelable(&permStateParcel); + } + + std::shared_ptr readedData1(HapTokenInfoForSyncParcel::Unmarshalling(out1)); + EXPECT_EQ(true, readedData1 == nullptr); +} + +/** + * @tc.name: NativeTokenInfoForSyncParcel001 + * @tc.desc: Test HapTokenInfoForSync Marshalling/Unmarshalling. + * @tc.type: FUNC + * @tc.require: issueI5QKZF + */ +HWTEST_F(AccessTokenParcelTest, NativeTokenInfoForSyncParcel001, TestSize.Level1) +{ + NativeTokenInfoForSyncParcel nativeTokenInfoSync; + + NativeTokenInfo baseInfo; + baseInfo.apl = APL_NORMAL, + baseInfo.ver = 1, + baseInfo.processName = "native_token_test0", + baseInfo.tokenID = 0x28100000, // 0x28100000 tokenid + baseInfo.tokenAttr = 0, + baseInfo.dcap = {"AT_CAP", "ST_CAP"}; + baseInfo.nativeAcls = {"ohos.permission.LOCATION"}; + + Parcel out; + NativeTokenInfoParcel baseInfoParcel; + baseInfoParcel.nativeTokenInfoParams = baseInfo; + out.WriteParcelable(&baseInfoParcel); + + std::vector permStateList; + for (uint32_t i = 0; i < MAX_PERMLIST_SIZE; i++) { + permStateList.emplace_back(g_permStatBeta); + } + uint32_t permStateListSize = permStateList.size(); + out.WriteUint32(permStateListSize); + for (uint32_t i = 0; i < permStateListSize; i++) { + PermissionStateFullParcel permStateParcel; + permStateParcel.permStatFull = permStateList[i]; + out.WriteParcelable(&permStateParcel); + } + + std::shared_ptr readedData(NativeTokenInfoForSyncParcel::Unmarshalling(out)); + EXPECT_NE(nullptr, readedData); + + Parcel outInvalid; + outInvalid.WriteParcelable(&baseInfoParcel); + permStateList.emplace_back(g_permStatBeta); + + permStateListSize = permStateList.size(); + outInvalid.WriteUint32(permStateListSize); + for (uint32_t i = 0; i < permStateListSize; i++) { + PermissionStateFullParcel permStateParcel; + permStateParcel.permStatFull = permStateList[i]; + outInvalid.WriteParcelable(&permStateParcel); + } + + std::shared_ptr readedData1(NativeTokenInfoForSyncParcel::Unmarshalling(outInvalid)); + EXPECT_EQ(true, readedData1 == nullptr); +} + +/** + * @tc.name: NativeTokenInfoForSyncParcel002 + * @tc.desc: Test HapTokenInfoForSync Marshalling/Unmarshalling. + * @tc.type: FUNC + * @tc.require: issueI5QKZF + */ +HWTEST_F(AccessTokenParcelTest, NativeTokenInfoForSyncParcel002, TestSize.Level1) +{ + NativeTokenInfoForSyncParcel nativeTokenInfoSync; + + NativeTokenInfo baseInfo; + baseInfo.apl = APL_NORMAL, + baseInfo.ver = 1, + baseInfo.processName = "native_token_test0", + baseInfo.tokenID = 0x28100000, // 0x28100000 tokenid + baseInfo.tokenAttr = 0, + baseInfo.dcap = {"AT_CAP", "ST_CAP"}; + baseInfo.nativeAcls = {"ohos.permission.LOCATION"}; + + nativeTokenInfoSync.nativeTokenInfoForSyncParams.baseInfo = baseInfo; + nativeTokenInfoSync.nativeTokenInfoForSyncParams.permStateList.emplace_back(g_permStatBeta); + + Parcel parcel; + EXPECT_EQ(true, nativeTokenInfoSync.Marshalling(parcel)); + std::shared_ptr readedData(NativeTokenInfoForSyncParcel::Unmarshalling(parcel)); + EXPECT_NE(nullptr, readedData); +} + +static void PutData(Parcel& out, uint32_t deviceSize, uint32_t statusSize, uint32_t flagSize) +{ + out.WriteString("ohos.permission.LOCATION"); + out.WriteBool(true); + out.WriteUint32(deviceSize); + for (uint32_t i = 0; i < deviceSize; i++) { + out.WriteString("deviceName"); + } + out.WriteUint32(statusSize); + for (uint32_t i = 0; i < statusSize; i++) { + out.WriteInt32(0); + } + out.WriteUint32(flagSize); + for (uint32_t i = 0; i < flagSize; i++) { + out.WriteInt32(0); + } +} + +/** + * @tc.name: PermissionStateFullParcel001 + * @tc.desc: Test permissionStateFullParcel Marshalling/Unmarshalling. + * @tc.type: FUNC + * @tc.require: issueI5QKZF + */ +HWTEST_F(AccessTokenParcelTest, PermissionStateFullParcel001, TestSize.Level1) +{ + Parcel out; + PutData(out, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE + 1); + std::shared_ptr readedData(PermissionStateFullParcel::Unmarshalling(out)); + EXPECT_EQ(nullptr, readedData); + + Parcel out1; + PutData(out1, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE + 1, MAX_DEVICE_ID_SIZE + 1); + std::shared_ptr readedData1(PermissionStateFullParcel::Unmarshalling(out1)); + EXPECT_EQ(readedData1, nullptr); + + Parcel out2; + PutData(out2, MAX_DEVICE_ID_SIZE + 1, MAX_DEVICE_ID_SIZE + 1, MAX_DEVICE_ID_SIZE + 1); + std::shared_ptr readedData2(PermissionStateFullParcel::Unmarshalling(out2)); + EXPECT_EQ(readedData2, nullptr); + + Parcel out3; + PutData(out3, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE, MAX_DEVICE_ID_SIZE); + std::shared_ptr readedData3(PermissionStateFullParcel::Unmarshalling(out3)); + EXPECT_NE(readedData3, nullptr); +} + +/** + * @tc.name: PermissionStateFullParcel002 + * @tc.desc: Test permissionStateFullParcel Marshalling/Unmarshalling. + * @tc.type: FUNC + * @tc.require: issueI5QKZF + */ +HWTEST_F(AccessTokenParcelTest, PermissionStateFullParcel002, TestSize.Level1) +{ + PermissionStateFullParcel permissionStateFullParcel; + permissionStateFullParcel.permStatFull.permissionName = "permissionName"; + permissionStateFullParcel.permStatFull.isGeneral = false; + permissionStateFullParcel.permStatFull.resDeviceID = {"device"}; + permissionStateFullParcel.permStatFull.grantStatus = {1}; + permissionStateFullParcel.permStatFull.grantFlags = {0}; + Parcel parcel; + EXPECT_EQ(true, permissionStateFullParcel.Marshalling(parcel)); + + std::shared_ptr readedData(PermissionStateFullParcel::Unmarshalling(parcel)); + EXPECT_NE(nullptr, readedData); +} + + +static void PutNativeTokenInfoData(Parcel& out, uint32_t dcapSize, uint32_t aclSize) +{ + EXPECT_EQ(true, out.WriteInt32(APL_NORMAL)); + EXPECT_EQ(true, out.WriteUint8(1)); + EXPECT_EQ(true, out.WriteString("native_token_test0")); + EXPECT_EQ(true, out.WriteUint32(0x28100000)); // 0x28100000 tokenid + EXPECT_EQ(true, out.WriteUint32(0)); + + EXPECT_EQ(true, out.WriteUint32(dcapSize)); + for (uint32_t i = 0; i < dcapSize; i++) { + EXPECT_EQ(true, out.WriteString("dcapItem")); + } + EXPECT_EQ(true, out.WriteUint32(aclSize)); + for (uint32_t i = 0; i < aclSize; i++) { + EXPECT_EQ(true, out.WriteString("ohos.permission.LOCATION")); + } +} + +/** + * @tc.name: NativeTokenInfoParcel001 + * @tc.desc: Test NativeTokenInfoParcel Marshalling/Unmarshalling. + * @tc.type: FUNC + * @tc.require: issueI5QKZF + */ +HWTEST_F(AccessTokenParcelTest, NativeTokenInfoParcel001, TestSize.Level1) +{ + Parcel out; + PutNativeTokenInfoData(out, MAX_DCAP_SIZE, MAX_ACL_SIZE); + std::shared_ptr readedData(NativeTokenInfoParcel::Unmarshalling(out)); + EXPECT_NE(nullptr, readedData); + + Parcel out1; + PutNativeTokenInfoData(out1, MAX_DCAP_SIZE, MAX_ACL_SIZE + 1); + std::shared_ptr readedData1(NativeTokenInfoParcel::Unmarshalling(out1)); + EXPECT_EQ(readedData1, nullptr); + + Parcel out2; + PutNativeTokenInfoData(out2, MAX_DCAP_SIZE + 1, MAX_ACL_SIZE + 1); + std::shared_ptr readedData2(NativeTokenInfoParcel::Unmarshalling(out2)); + EXPECT_EQ(readedData2, nullptr); +} + +/** + * @tc.name: NativeTokenInfoParcel002 + * @tc.desc: Test NativeTokenInfoParcel Marshalling/Unmarshalling. + * @tc.type: FUNC + * @tc.require: issueI5QKZF + */ +HWTEST_F(AccessTokenParcelTest, NativeTokenInfoParcel002, TestSize.Level1) +{ + NativeTokenInfoParcel nativeTokenInfoParcel; + nativeTokenInfoParcel.nativeTokenInfoParams.apl = APL_NORMAL; + nativeTokenInfoParcel.nativeTokenInfoParams.ver = 0; + nativeTokenInfoParcel.nativeTokenInfoParams.processName = "processName"; + nativeTokenInfoParcel.nativeTokenInfoParams.dcap = {"AT_CAP"}; + nativeTokenInfoParcel.nativeTokenInfoParams.tokenID = 12; // 12 : tokenid + nativeTokenInfoParcel.nativeTokenInfoParams.tokenAttr = 0; + nativeTokenInfoParcel.nativeTokenInfoParams.nativeAcls = { }; + + Parcel parcel; + EXPECT_EQ(true, nativeTokenInfoParcel.Marshalling(parcel)); + std::shared_ptr readedData(NativeTokenInfoParcel::Unmarshalling(parcel)); + EXPECT_NE(nullptr, readedData); +} + } // namespace AccessToken } // namespace Security } // namespace OHOS \ No newline at end of file diff --git a/frameworks/test/unittest/privacy_parcel_test.cpp b/frameworks/test/unittest/privacy_parcel_test.cpp index 5ba9897fe..da0e353c7 100644 --- a/frameworks/test/unittest/privacy_parcel_test.cpp +++ b/frameworks/test/unittest/privacy_parcel_test.cpp @@ -19,6 +19,7 @@ #include "bundle_used_record_parcel.h" #include "parcel.h" +#include "parcel_utils.h" #include "perm_active_response_parcel.h" #include "permission_used_record_parcel.h" #include "permission_used_request_parcel.h" @@ -324,6 +325,179 @@ HWTEST_F(PrivacyParcelTest, UsedRecordDetailParcel001, TestSize.Level1) EXPECT_EQ(usedRecordDetailParcel.detail.timestamp, readedData->detail.timestamp); EXPECT_EQ(usedRecordDetailParcel.detail.accessDuration, readedData->detail.accessDuration); } + +void BundleUsedRecordData(Parcel& out, uint32_t size) +{ + EXPECT_EQ(true, out.WriteUint32(100)); // 100: tokenid + EXPECT_EQ(true, out.WriteBool(false)); + EXPECT_EQ(true, out.WriteString("device")); + EXPECT_EQ(true, out.WriteString("bundleName")); + + EXPECT_EQ(true, out.WriteUint32(size)); + + g_permissionRecord1.accessRecords.emplace_back(g_accessRecord1); + + for (uint32_t i = 0; i < size; i++) { + PermissionUsedRecordParcel permRecordParcel; + permRecordParcel.permissionRecord = g_permissionRecord1; + out.WriteParcelable(&permRecordParcel); + } +} +/** + * @tc.name: BundleUsedRecordParcel002 + * @tc.desc: Test BundleUsedRecordParcel Marshalling/Unmarshalling. + * @tc.type: FUNC + * @tc.require: issueI5QKZF + */ +HWTEST_F(PrivacyParcelTest, BundleUsedRecordParcel002, TestSize.Level1) +{ + Parcel parcel; + BundleUsedRecordData(parcel, MAX_RECORD_SIZE); + std::shared_ptr readedData(BundleUsedRecordParcel::Unmarshalling(parcel)); + EXPECT_EQ(true, readedData != nullptr); + + Parcel parcel1; + BundleUsedRecordData(parcel1, MAX_RECORD_SIZE + 1); + std::shared_ptr readedData1(BundleUsedRecordParcel::Unmarshalling(parcel1)); + EXPECT_EQ(true, readedData1 == nullptr); +} + +void DataMarshalling(Parcel& out, uint32_t accessSize, uint32_t rejectSize) +{ + UsedRecordDetail detailIns = {0, 0L, 0L}; + EXPECT_EQ(true, out.WriteString("permissionName")); + EXPECT_EQ(true, out.WriteInt32(1)); + EXPECT_EQ(true, out.WriteInt32(1)); + EXPECT_EQ(true, out.WriteInt64(0L)); + EXPECT_EQ(true, out.WriteInt64(0L)); + EXPECT_EQ(true, out.WriteInt64(0L)); + + EXPECT_EQ(true, out.WriteUint32(accessSize)); + for (uint32_t i = 0; i < accessSize; i++) { + UsedRecordDetailParcel detailParcel; + detailParcel.detail = detailIns; + out.WriteParcelable(&detailParcel); + } + + EXPECT_EQ(true, out.WriteUint32(rejectSize)); + for (uint32_t i = 0; i < rejectSize; i++) { + UsedRecordDetailParcel detailParcel; + detailParcel.detail = detailIns; + out.WriteParcelable(&detailParcel); + } +} + +/** + * @tc.name: PermissionUsedRecordParcel002 + * @tc.desc: Test PermissionUsedRecordParcel Marshalling/Unmarshalling. + * @tc.type: FUNC + * @tc.require: issueI5QKZF + */ +HWTEST_F(PrivacyParcelTest, PermissionUsedRecordParcel002, TestSize.Level1) +{ + Parcel parcel; + DataMarshalling(parcel, MAX_ACCESS_RECORD_SIZE, MAX_ACCESS_RECORD_SIZE); + std::shared_ptr readedData(PermissionUsedRecordParcel::Unmarshalling(parcel)); + EXPECT_EQ(true, readedData != nullptr); + + Parcel parcel1; + DataMarshalling(parcel1, MAX_ACCESS_RECORD_SIZE, MAX_ACCESS_RECORD_SIZE + 1); + std::shared_ptr readedData1(PermissionUsedRecordParcel::Unmarshalling(parcel1)); + EXPECT_EQ(true, readedData1 == nullptr); + + Parcel parcel2; + DataMarshalling(parcel2, MAX_ACCESS_RECORD_SIZE + 1, MAX_ACCESS_RECORD_SIZE); + std::shared_ptr readedData2(PermissionUsedRecordParcel::Unmarshalling(parcel2)); + EXPECT_EQ(true, readedData2 == nullptr); +} + +/** + * @tc.name: PermissionUsedRequestParcel002 + * @tc.desc: Verify the PermissionUsedRequestParcel Marshalling and Unmarshalling function. + * @tc.type: FUNC + * @tc.require: issueI5RUP1 + */ +HWTEST_F(PrivacyParcelTest, PermissionUsedRequestParcel002, TestSize.Level1) +{ + PermissionUsedRequestParcel permissionUsedRequestParcel; + + permissionUsedRequestParcel.request = { + .tokenId = 100, + .isRemote = false, + .deviceId = "deviceId", + .bundleName = "com.ohos.permissionmanager", + .beginTimeMillis = 0L, + .endTimeMillis = 0L, + .flag = FLAG_PERMISSION_USAGE_SUMMARY, + }; + for (uint32_t i = 0; i < MAX_PERMLIST_SIZE; i++) { + permissionUsedRequestParcel.request.permissionList.emplace_back("ohos.permission.CAMERA"); + } + + Parcel parcel; + EXPECT_EQ(true, permissionUsedRequestParcel.Marshalling(parcel)); + std::shared_ptr readedData(PermissionUsedRequestParcel::Unmarshalling(parcel)); + EXPECT_NE(readedData, nullptr); + + permissionUsedRequestParcel.request.permissionList.emplace_back("ohos.permission.CAMERA"); + Parcel parcel1; + EXPECT_EQ(true, permissionUsedRequestParcel.Marshalling(parcel1)); + std::shared_ptr readedData1(PermissionUsedRequestParcel::Unmarshalling(parcel1)); + EXPECT_EQ(readedData1, nullptr); +} + +/** + * @tc.name: PermissionUsedResultParcel002 + * @tc.desc: Verify the PermissionUsedResultParcel Marshalling and Unmarshalling function. + * @tc.type: FUNC + * @tc.require: issueI5RWP4 + */ +HWTEST_F(PrivacyParcelTest, PermissionUsedResultParcel002, TestSize.Level1) +{ + PermissionUsedResultParcel permissionUsedResultParcel; + + permissionUsedResultParcel.result = { + .beginTimeMillis = 0L, + .endTimeMillis = 0L, + }; + + g_bundleUsedRecord1.permissionRecords.emplace_back(g_permissionRecord1); + g_bundleUsedRecord1.permissionRecords.emplace_back(g_permissionRecord2); + + for (uint32_t i = 0; i < 1024; i++) { + permissionUsedResultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord1); + } + + Parcel parcel; + EXPECT_EQ(true, permissionUsedResultParcel.Marshalling(parcel)); + auto* resultParcel = new (std::nothrow) PermissionUsedResultParcel(); + ASSERT_NE(resultParcel, nullptr); + EXPECT_EQ(true, parcel.ReadInt64(resultParcel->result.beginTimeMillis)); + EXPECT_EQ(true, parcel.ReadInt64(resultParcel->result.endTimeMillis)); + uint32_t bundResponseSize = 0; + EXPECT_EQ(true, parcel.ReadUint32(bundResponseSize)); + EXPECT_EQ(true, bundResponseSize <= MAX_RECORD_SIZE); + EXPECT_EQ(true, resultParcel != nullptr); + delete resultParcel; + permissionUsedResultParcel.result.bundleRecords.emplace_back(g_bundleUsedRecord1); + + Parcel parcel1; + EXPECT_EQ(true, permissionUsedResultParcel.Marshalling(parcel1)); + auto* resultParcel2 = new (std::nothrow) PermissionUsedResultParcel(); + ASSERT_NE(resultParcel2, nullptr); + EXPECT_EQ(true, parcel1.ReadInt64(resultParcel2->result.beginTimeMillis)); + EXPECT_EQ(true, parcel1.ReadInt64(resultParcel2->result.endTimeMillis)); + uint32_t bundResponseSize1 = 0; + EXPECT_EQ(true, parcel1.ReadUint32(bundResponseSize1)); + GTEST_LOG_(INFO) << "bundResponseSize1 :" << bundResponseSize1; + EXPECT_EQ(true, bundResponseSize1 > MAX_RECORD_SIZE); + delete resultParcel2; + + Parcel parcel2; + EXPECT_EQ(true, permissionUsedResultParcel.Marshalling(parcel2)); + std::shared_ptr readedData1(PermissionUsedResultParcel::Unmarshalling(parcel2)); + EXPECT_EQ(readedData1, nullptr); +} } // namespace AccessToken } // namespace Security } // namespace OHOS diff --git a/services/privacymanager/test/unittest/BUILD.gn b/services/privacymanager/test/unittest/BUILD.gn index d7178178a..84d39a3a4 100644 --- a/services/privacymanager/test/unittest/BUILD.gn +++ b/services/privacymanager/test/unittest/BUILD.gn @@ -41,6 +41,7 @@ if (is_standard_system && ability_base_enable == true) { external_deps = [ "c_utils:utils", + "ipc:ipc_core", "safwk:system_ability_fwk", ] } diff --git a/services/tokensyncmanager/src/remote/soft_bus_channel.cpp b/services/tokensyncmanager/src/remote/soft_bus_channel.cpp index 59fadadec..67b559e96 100644 --- a/services/tokensyncmanager/src/remote/soft_bus_channel.cpp +++ b/services/tokensyncmanager/src/remote/soft_bus_channel.cpp @@ -137,7 +137,7 @@ std::string SoftBusChannel::ExecuteCommand(const std::string &commandName, const ACCESSTOKEN_LOG_DEBUG(LABEL, "generated message uuid: %{public}s", uuid.c_str()); int len = (signed)(RPC_TRANSFER_HEAD_BYTES_LENGTH + jsonPayload.length()); - unsigned char *buf = new unsigned char[len + 1]; + unsigned char *buf = new (std::nothrow) unsigned char[len + 1]; if (buf == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "no enough memory: %{public}d", len); return ""; @@ -264,7 +264,7 @@ std::string SoftBusChannel::Decompress(const unsigned char *bytes, const int len { ACCESSTOKEN_LOG_DEBUG(LABEL, "input length: %{public}d", length); uLong len = RPC_TRANSFER_BYTES_MAX_LENGTH; - unsigned char *buf = new unsigned char[len + 1]; + unsigned char *buf = new (std::nothrow) unsigned char[len + 1]; if (buf == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "no enough memory!"); return ""; @@ -353,7 +353,7 @@ void SoftBusChannel::HandleRequest(int session, const std::string &id, const std jsonPayload.c_str()); int sendlen = (signed)(RPC_TRANSFER_HEAD_BYTES_LENGTH + jsonPayload.length()); - unsigned char *sendbuf = new unsigned char[sendlen + 1]; + unsigned char *sendbuf = new (std::nothrow) unsigned char[sendlen + 1]; if (sendbuf == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "no enough memory: %{public}d", sendlen); return; @@ -379,7 +379,7 @@ void SoftBusChannel::HandleRequest(int session, const std::string &id, const std // send result back std::string resultJsonPayload = command->ToJsonPayload(); int len = (signed)(RPC_TRANSFER_HEAD_BYTES_LENGTH + resultJsonPayload.length()); - unsigned char *buf = new unsigned char[len + 1]; + unsigned char *buf = new (std::nothrow) unsigned char[len + 1]; if (buf == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "no enough memory: %{public}d", len); return; diff --git a/services/tokensyncmanager/src/remote/soft_bus_manager.cpp b/services/tokensyncmanager/src/remote/soft_bus_manager.cpp index ff8800913..5c0002732 100644 --- a/services/tokensyncmanager/src/remote/soft_bus_manager.cpp +++ b/services/tokensyncmanager/src/remote/soft_bus_manager.cpp @@ -328,7 +328,7 @@ std::string SoftBusManager::GetUniqueDeviceIdByNodeId(const std::string &nodeId) std::string SoftBusManager::GetUuidByNodeId(const std::string &nodeId) const { - uint8_t *info = new uint8_t[UDID_MAX_LENGTH + 1]; + uint8_t *info = new (std::nothrow) uint8_t[UDID_MAX_LENGTH + 1]; if (info == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "no enough memory: %{public}d", UDID_MAX_LENGTH); return ""; @@ -350,7 +350,7 @@ std::string SoftBusManager::GetUuidByNodeId(const std::string &nodeId) const std::string SoftBusManager::GetUdidByNodeId(const std::string &nodeId) const { - uint8_t *info = new uint8_t[UDID_MAX_LENGTH + 1]; + uint8_t *info = new (std::nothrow) uint8_t[UDID_MAX_LENGTH + 1]; if (info == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "no enough memory: %{public}d", UDID_MAX_LENGTH); return ""; -- Gitee