diff --git a/bundle.json b/bundle.json
index 5b6bfe3ded17bb8f301f80dbb74c1a5eb46d351f..5b8a73709cf39522cf6296adba2b1b2befd6597d 100644
--- a/bundle.json
+++ b/bundle.json
@@ -58,7 +58,8 @@
         "zlib",
         "ffrt",
         "libevdev",
-        "selinux_adapter"
+        "selinux_adapter",
+        "os_account"
       ]
     },
     "build": {
diff --git a/distributedhardwarefwk.gni b/distributedhardwarefwk.gni
index 6b8e8b6d48d293c78f89401606b8a4ca59b04287..d495be227f8b932de319721299c8e1ec2ab25ef2 100644
--- a/distributedhardwarefwk.gni
+++ b/distributedhardwarefwk.gni
@@ -39,3 +39,10 @@ build_flags = [ "-Werror" ]
 declare_args() {
   distributed_hardware_fwk_low_latency = false
 }
+
+if (!defined(global_parts_info) ||
+      defined(global_parts_info.account_os_account)) {
+    dhfwk_os_account = true
+  } else {
+    dhfwk_os_account = false
+  }
diff --git a/services/distributedhardwarefwkservice/BUILD.gn b/services/distributedhardwarefwkservice/BUILD.gn
index a5ffe399373916dc5dd1275794aff1adb871f6b2..13f6f2f7bfc4f71daeaac03852acb94e3eabbaf5 100644
--- a/services/distributedhardwarefwkservice/BUILD.gn
+++ b/services/distributedhardwarefwkservice/BUILD.gn
@@ -151,6 +151,7 @@ ohos_shared_library("distributedhardwarefwksvr") {
     "ability_runtime:ability_manager",
     "access_token:libaccesstoken_sdk",
     "access_token:libtokenid_sdk",
+    "access_token:libtokensetproc_shared",
     "cJSON:cjson",
     "c_utils:utils",
     "config_policy:configpolicy_util",
@@ -169,6 +170,17 @@ ohos_shared_library("distributedhardwarefwksvr") {
     "samgr:samgr_proxy",
   ]
 
+  if (dhfwk_os_account) {
+    external_deps += [
+      "os_account:libaccountkits",
+      "os_account:os_account_innerkits",
+    ]
+  }
+
+  if (dhfwk_os_account) {
+    defines += [ "OS_ACCOUNT_PART" ]
+  }
+
   subsystem_name = "distributedhardware"
 
   part_name = "distributed_hardware_fwk"
diff --git a/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h b/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h
index 63b5162fa9d12a0be0a24cf4fcb17f112c39a3cc..624c00e18506e9773c76ed065bdb58436fb1439d 100644
--- a/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h
+++ b/services/distributedhardwarefwkservice/include/componentmanager/component_manager.h
@@ -203,6 +203,8 @@ private:
     int32_t UninitCompSource(DHType dhType);
     int32_t InitCompSink(DHType dhType);
     int32_t UninitCompSink(DHType dhType);
+    void InitDHCommTool();
+    void UnInitDHCommTool();
     int32_t StartSource(DHType dhType, ActionResult &sourceResult);
     int32_t StopSource(DHType dhType, ActionResult &sourceResult);
     int32_t StartSink(DHType dhType, ActionResult &sinkResult);
diff --git a/services/distributedhardwarefwkservice/include/transport/dh_comm_tool.h b/services/distributedhardwarefwkservice/include/transport/dh_comm_tool.h
index 9d396c3879fba06c9d1df3ad7f27d3a908eacfc2..6c51a5f34a4b9ff7e85c0ba40d117c03a8ab0c3d 100644
--- a/services/distributedhardwarefwkservice/include/transport/dh_comm_tool.h
+++ b/services/distributedhardwarefwkservice/include/transport/dh_comm_tool.h
@@ -59,9 +59,16 @@ public:
     std::shared_ptr<DHCommTool::DHCommToolEventHandler> GetEventHandler();
     const std::shared_ptr<DHTransport> GetDHTransportPtr();
 
+private:
+    bool CheckCallerAclRight(const std::string &localNetworkId, const std::string &remoteNetworkId);
+    bool GetOsAccountInfo();
+
 private:
     std::shared_ptr<DHTransport> dhTransportPtr_;
     std::shared_ptr<DHCommTool::DHCommToolEventHandler> eventHandler_;
+    std::string accountId_;
+    int32_t userId_ = -1;
+    uint64_t tokenId_ = 0;
 };
 } // DistributedHardware
 } // OHOS
diff --git a/services/distributedhardwarefwkservice/include/transport/dh_transport.h b/services/distributedhardwarefwkservice/include/transport/dh_transport.h
index efcd8880dd4eb8dd46541e8be5e4ef581daa88e2..7a24d801c15da1a37bb453ef11d1cc688b9f3c3c 100644
--- a/services/distributedhardwarefwkservice/include/transport/dh_transport.h
+++ b/services/distributedhardwarefwkservice/include/transport/dh_transport.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -26,6 +26,8 @@
 #include "socket.h"
 #include "softbus_bus_center.h"
 
+#include "dh_transport_obj.h"
+
 namespace OHOS {
 namespace DistributedHardware {
 class DHCommTool;
@@ -51,6 +53,7 @@ private:
     std::string GetRemoteNetworkIdBySocketId(int32_t socketId);
     void ClearDeviceSocketOpened(const std::string &remoteDevId);
     void HandleReceiveMessage(const std::string &payload);
+    bool CheckCalleeAclRight(const std::shared_ptr<CommMsg> commMsg);
 
 private:
     std::mutex rmtSocketIdMtx_;
diff --git a/services/distributedhardwarefwkservice/include/transport/dh_transport_obj.h b/services/distributedhardwarefwkservice/include/transport/dh_transport_obj.h
index 3e2dfb7aa70c0a4955d368c768ae26c4ea5af378..c581e5ce5e196ee95f2939579c3e3fff4dff108e 100644
--- a/services/distributedhardwarefwkservice/include/transport/dh_transport_obj.h
+++ b/services/distributedhardwarefwkservice/include/transport/dh_transport_obj.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -28,6 +28,9 @@ const char* const CAPS_RSP_NETWORKID_KEY = "networkId";
 const char* const CAPS_RSP_CAPS_KEY = "caps";
 const char* const COMM_MSG_CODE_KEY = "code";
 const char* const COMM_MSG_MSG_KEY = "msg";
+const char* const COMM_MSG_USERID_KEY = "userId";
+const char* const COMM_MSG_TOKENID_KEY = "tokenId";
+const char* const COMM_MSG_ACCOUNTID_KEY = "accountId";
 
 struct FullCapsRsp {
     // the networkd id of rsp from which device
@@ -44,9 +47,13 @@ void FromJson(const cJSON *jsonObject, FullCapsRsp &capsRsp);
 
 struct CommMsg {
     int32_t code;
+    int32_t userId;
+    uint64_t tokenId;
     std::string msg;
-    CommMsg() : code(-1), msg("") {}
-    CommMsg(int32_t code, std::string msg) : code(code), msg(msg) {}
+    std::string accountId;
+    CommMsg() : code(-1), userId(-1), tokenId(0), msg(""), accountId("") {}
+    CommMsg(int32_t code, int32_t userId, uint64_t tokenId, std::string msg, std::string accountId) : code(code),
+        userId(userId), tokenId(tokenId), msg(msg), accountId(accountId) {}
 };
 
 void ToJson(cJSON *jsonObject, const CommMsg &commMsg);
diff --git a/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp b/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp
index 96b0f785786bd95db2c281ddf27a7719f2778a4a..1769e890399eef7871611f2a7080632d1f145f73 100644
--- a/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp
+++ b/services/distributedhardwarefwkservice/src/componentmanager/component_manager.cpp
@@ -91,15 +91,29 @@ int32_t ComponentManager::Init()
 #ifdef DHARDWARE_LOW_LATENCY
     Publisher::GetInstance().RegisterListener(DHTopic::TOPIC_LOW_LATENCY, lowLatencyListener_);
 #endif
+    std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create(true);
+    eventHandler_ = std::make_shared<ComponentManager::ComponentManagerEventHandler>(runner);
+    InitDHCommTool();
     DHLOGI("Init component success");
     DHTraceEnd();
     return DH_FWK_SUCCESS;
 }
 
+void ComponentManager::InitDHCommTool()
+{
+    if (dhCommToolPtr_ == nullptr) {
+        DHLOGE("DH communication tool ptr is null");
+        return;
+    }
+    DHLOGI("Init DH communication tool");
+    dhCommToolPtr_->Init();
+}
+
 int32_t ComponentManager::UnInit()
 {
     DHLOGI("start.");
     StopPrivacy();
+    UnInitDHCommTool();
 #ifdef DHARDWARE_LOW_LATENCY
     Publisher::GetInstance().UnregisterListener(DHTopic::TOPIC_LOW_LATENCY, lowLatencyListener_);
     LowLatency::GetInstance().CloseLowLatency();
@@ -126,6 +140,16 @@ void ComponentManager::StopPrivacy()
     }
 }
 
+void ComponentManager::UnInitDHCommTool()
+{
+    if (dhCommToolPtr_ == nullptr) {
+        DHLOGE("DH communication tool ptr is null");
+        return;
+    }
+    DHLOGI("UnInit DH communication tool");
+    dhCommToolPtr_->UnInit();
+}
+
 int32_t ComponentManager::StartSource(DHType dhType, ActionResult &sourceResult)
 {
     DHLOGI("Start Source, dhType: %{public}" PRIu32, (uint32_t)dhType);
diff --git a/services/distributedhardwarefwkservice/src/transport/dh_comm_tool.cpp b/services/distributedhardwarefwkservice/src/transport/dh_comm_tool.cpp
index fe6cf5600cdeeb4ba8981a7c70a14b5d872bf96d..61cc6fe32cfcd7db01404fb08d53a4d88a5e88ca 100644
--- a/services/distributedhardwarefwkservice/src/transport/dh_comm_tool.cpp
+++ b/services/distributedhardwarefwkservice/src/transport/dh_comm_tool.cpp
@@ -16,6 +16,11 @@
 #include "dh_comm_tool.h"
 
 #include "cJSON.h"
+#include "device_manager.h"
+#include "ipc_skeleton.h"
+#include "ohos_account_kits.h"
+#include "os_account_manager.h"
+#include "token_setproc.h"
 
 #include "anonymous_string.h"
 #include "capability_info_manager.h"
@@ -68,6 +73,56 @@ std::shared_ptr<DHCommTool> DHCommTool::GetInstance()
     return instance;
 }
 
+bool DHCommTool::CheckCallerAclRight(const std::string &localNetworkId, const std::string &remoteNetworkId)
+{
+    if (!GetOsAccountInfo()) {
+        DHLOGE("GetOsAccountInfo failed.");
+        return false;
+    }
+    tokenId_ = IPCSkeleton::GetCallingTokenID();
+    DmAccessCaller dmSrcCaller = {
+        .accountId = accountId_,
+        .pkgName = DH_FWK_PKG_NAME,
+        .networkId = localNetworkId,
+        .userId = userId_,
+        .tokenId = tokenId_,
+    };
+    DmAccessCallee dmDstCallee = {
+        .networkId = remoteNetworkId,
+    };
+    DHLOGI("CheckAclRight dmSrcCaller localNetworkId: %{public}s, accountId: %{public}s, remoteNetworkId: %{public}s",
+        GetAnonyString(localNetworkId).c_str(), GetAnonyString(accountId_).c_str(),
+        GetAnonyString(remoteNetworkId).c_str());
+    if (!DeviceManager::GetInstance().CheckSrcAccessControl(dmSrcCaller, dmDstCallee)) {
+        DHLOGE("Caller ACL check failed.");
+        return false;
+    }
+    return true;
+}
+
+bool DHCommTool::GetOsAccountInfo()
+{
+    DHLOGI("GetOsAccountInfo start.");
+#ifdef OS_ACCOUNT_PART
+    std::vector<int32_t> ids;
+    int32_t ret = AccountSA::OsAccountManager::QueryActiveOsAccountIds(ids);
+    if (ret != DH_FWK_SUCCESS || ids.empty()) {
+        DHLOGE("Get userId from active os accountIds fail, ret: %{public}d", ret);
+        return false;
+    }
+    userId_ = ids[0];
+
+    AccountSA::OhosAccountInfo osAccountInfo;
+    ret = AccountSA::OhosAccountKits::GetInstance().GetOhosAccountInfo(osAccountInfo);
+    if (ret != DH_FWK_SUCCESS) {
+        DHLOGE("Get accountId from ohos account info fail, ret: %{public}d", ret);
+        return false;
+    }
+    accountId_ = osAccountInfo.uid_;
+#endif
+    return true;
+}
+
 void DHCommTool::TriggerReqFullDHCaps(const std::string &remoteNetworkId)
 {
     DHLOGI("TriggerReqFullDHCaps, remote networkId: %{public}s", GetAnonyString(remoteNetworkId).c_str());
@@ -80,11 +135,15 @@ void DHCommTool::TriggerReqFullDHCaps(const std::string &remoteNetworkId)
         DHLOGE("Get local network id error");
         return;
     }
+    if (!CheckCallerAclRight(localNetworkId, remoteNetworkId)) {
+        DHLOGE("ACL check failed.");
+        return;
+    }
     if (dhTransportPtr_->StartSocket(remoteNetworkId) != DH_FWK_SUCCESS) {
         DHLOGE("Start socket error");
         return;
     }
-    CommMsg commMsg(DH_COMM_REQ_FULL_CAPS, localNetworkId);
+    CommMsg commMsg(DH_COMM_REQ_FULL_CAPS, userId_, tokenId_, localNetworkId, accountId_);
     std::string payload = GetCommMsgString(commMsg);
 
     int32_t ret = dhTransportPtr_->Send(remoteNetworkId, payload);
@@ -123,7 +182,9 @@ void DHCommTool::GetAndSendLocalFullCaps(const std::string &reqNetworkId)
     cJSON_free(msg);
     cJSON_Delete(root);
 
-    CommMsg commMsg(DH_COMM_RSP_FULL_CAPS, fullCapsMsg);
+    CommMsg commMsg;
+    commMsg.code = DH_COMM_RSP_FULL_CAPS;
+    commMsg.msg = fullCapsMsg;
     std::string payload = GetCommMsgString(commMsg);
 
     int32_t ret = dhTransportPtr_->Send(reqNetworkId, payload);
diff --git a/services/distributedhardwarefwkservice/src/transport/dh_transport.cpp b/services/distributedhardwarefwkservice/src/transport/dh_transport.cpp
index 0c052f8687e61b7dcdd0e6a548581890b2a9830c..5ac8aa55be1cf17d3d348debf830704e958e7ba4 100644
--- a/services/distributedhardwarefwkservice/src/transport/dh_transport.cpp
+++ b/services/distributedhardwarefwkservice/src/transport/dh_transport.cpp
@@ -16,9 +16,14 @@
 #include "dh_transport.h"
 
 #include <cinttypes>
+#include <securec.h>
 
 #include "cJSON.h"
-#include <securec.h>
+#include "device_manager.h"
+#include "ipc_skeleton.h"
+#include "ohos_account_kits.h"
+#include "os_account_manager.h"
+#include "token_setproc.h"
 
 #include "anonymous_string.h"
 #include "constants.h"
@@ -38,6 +43,7 @@ namespace {
 constexpr uint32_t MAX_SEND_MSG_LENGTH = 4 * 1024 * 1024;
 constexpr uint32_t INTERCEPT_STRING_LENGTH = 20;
 constexpr uint32_t MAX_ROUND_SIZE = 1000;
+constexpr int32_t DH_COMM_RSP_FULL_CAPS = 2;
 const std::string DH_FWK_SESSION_NAME = "ohos.dhardware.session_";
 static QosTV g_qosInfo[] = {
     { .qos = QOS_TYPE_MIN_BW, .value = 256 * 1024},
@@ -108,6 +114,55 @@ void DHTransport::OnBytesReceived(int32_t socketId, const void *data, uint32_t d
     return;
 }
 
+bool DHTransport::CheckCalleeAclRight(const std::shared_ptr<CommMsg> commMsg)
+{
+    if (commMsg->userId == -1) {
+        DHLOGE("ACL not support");
+        return true;
+    }
+    std::string localNetworkId = GetLocalNetworkId();
+    if (localNetworkId.empty()) {
+        DHLOGE("Get local network id error");
+        return false;
+    }
+    uint64_t localTokenId = IPCSkeleton::GetCallingTokenID();
+#ifdef OS_ACCOUNT_PART
+    std::vector<int32_t> ids;
+    auto ret = AccountSA::OsAccountManager::QueryActiveOsAccountIds(ids);
+    if (ret != DH_FWK_SUCCESS || ids.empty()) {
+        DHLOGE("Get userId fail, ret: %{public}d", ret);
+        return false;
+    }
+    int32_t userId = ids[0];
+    AccountSA::OhosAccountInfo osAccountInfo;
+    ret = AccountSA::OhosAccountKits::GetInstance().GetOhosAccountInfo(osAccountInfo);
+    if (ret != DH_FWK_SUCCESS) {
+        DHLOGE("Get accountId fail, ret: %{public}d", ret);
+        return false;
+    }
+    std::string accountId = osAccountInfo.uid_;
+#endif
+
+    DmAccessCaller dmSrcCaller = {
+        .accountId = commMsg->accountId,
+        .pkgName = DH_FWK_PKG_NAME,
+        .networkId = commMsg->msg,
+        .userId = commMsg->userId,
+        .tokenId = commMsg->tokenId,
+    };
+    DmAccessCallee dmDstCallee = {
+        .networkId = localNetworkId,
+        .accountId = accountId,
+        .userId = userId,
+        .tokenId = localTokenId,
+        .pkgName = DH_FWK_PKG_NAME,
+    };
+    DHLOGI("CheckAclRight remotenetworkId: %{public}s, accountId: %{public}s, localNetworkId: %{public}s",
+        GetAnonyString(commMsg->msg).c_str(), GetAnonyString(accountId).c_str(),
+        GetAnonyString(localNetworkId).c_str());
+    return DeviceManager::GetInstance().CheckSinkAccessControl(dmSrcCaller, dmDstCallee);
+}
+
 void DHTransport::HandleReceiveMessage(const std::string &payload)
 {
     if (!IsMessageLengthValid(payload)) {
@@ -123,7 +178,12 @@ void DHTransport::HandleReceiveMessage(const std::string &payload)
     std::shared_ptr<CommMsg> commMsg = std::make_shared<CommMsg>();
     FromJson(root, *commMsg);
     cJSON_Delete(root);
-
+    if (commMsg->code != DH_COMM_RSP_FULL_CAPS) {
+        if (!CheckCalleeAclRight(commMsg)) {
+            DHLOGE("Callee ACL check failed.");
+            return;
+        }
+    }
     DHLOGI("Receive DH msg, code: %{public}d, msg: %{public}s", commMsg->code, GetAnonyString(commMsg->msg).c_str());
     AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(commMsg->code, commMsg);
     std::shared_ptr<DHCommTool> dhCommToolSPtr = dhCommToolWPtr_.lock();
diff --git a/services/distributedhardwarefwkservice/src/transport/dh_transport_obj.cpp b/services/distributedhardwarefwkservice/src/transport/dh_transport_obj.cpp
index a939d80e44fcf0885401d654fadc0a32a49fe9ea..91d9ad5bd55f5ce58d398a620cb8a6bf925cbaee 100644
--- a/services/distributedhardwarefwkservice/src/transport/dh_transport_obj.cpp
+++ b/services/distributedhardwarefwkservice/src/transport/dh_transport_obj.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -74,8 +74,11 @@ void ToJson(cJSON *jsonObject, const CommMsg &commMsg)
         return;
     }
     cJSON_AddNumberToObject(jsonObject, COMM_MSG_CODE_KEY, commMsg.code);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_USERID_KEY, commMsg.userId);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_TOKENID_KEY, commMsg.tokenId);
     const char *msg = commMsg.msg.c_str();
     cJSON_AddStringToObject(jsonObject, COMM_MSG_MSG_KEY, msg);
+    cJSON_AddStringToObject(jsonObject, COMM_MSG_ACCOUNTID_KEY, commMsg.accountId.c_str());
 }
 
 void FromJson(const cJSON *jsonObject, CommMsg &commMsg)
@@ -88,10 +91,22 @@ void FromJson(const cJSON *jsonObject, CommMsg &commMsg)
     if (IsInt32(commMsgCodeJson)) {
         commMsg.code = commMsgCodeJson->valueint;
     }
+    cJSON *commMsgUserIdJson = cJSON_GetObjectItem(jsonObject, COMM_MSG_USERID_KEY);
+    if (commMsgUserIdJson != NULL && cJSON_IsNumber(commMsgUserIdJson)) {
+        commMsg.userId = commMsgUserIdJson->valueint;
+    }
+    cJSON *commMsgTokenIdJson = cJSON_GetObjectItem(jsonObject, COMM_MSG_TOKENID_KEY);
+    if (commMsgTokenIdJson != NULL && cJSON_IsNumber(commMsgTokenIdJson)) {
+        commMsg.tokenId = commMsgTokenIdJson->valueint;
+    }
     cJSON *commMsgeJson = cJSON_GetObjectItem(jsonObject, COMM_MSG_MSG_KEY);
-    if (IsString(commMsgeJson)) {
+    if (commMsgeJson != NULL && cJSON_IsString(commMsgeJson)) {
         commMsg.msg = commMsgeJson->valuestring;
     }
+    cJSON *commMsgeAccountIdJson = cJSON_GetObjectItem(jsonObject, COMM_MSG_ACCOUNTID_KEY);
+    if (commMsgeAccountIdJson != NULL && cJSON_IsString(commMsgeAccountIdJson)) {
+        commMsg.accountId = commMsgeAccountIdJson->valuestring;
+    }
 }
 
 std::string GetCommMsgString(const CommMsg &commMsg)
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp
index 58f156c2b025c63849ed062070278cd74f5da217..510be3ca49e15ca7afefa5438de9ec923edfb7ae 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp
@@ -1244,5 +1244,16 @@ HWTEST_F(ComponentManagerTest, CheckSinkConfigStart_001, TestSize.Level1)
     auto ret = ComponentManager::GetInstance().CheckSinkConfigStart(DHType::GPS, enableSink);
     EXPECT_EQ(ret, ERR_DH_FWK_TYPE_NOT_EXIST);
 }
+
+HWTEST_F(ComponentManagerTest, InitAndUnInit_DHCommTool_001, TestSize.Level0)
+{
+    ComponentManager::GetInstance().dhCommToolPtr_ = nullptr;
+    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().InitDHCommTool());
+    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UnInitDHCommTool());
+
+    ComponentManager::GetInstance().dhCommToolPtr_ = std::make_shared<DHCommTool>();
+    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().InitDHCommTool());
+    EXPECT_NO_FATAL_FAILURE(ComponentManager::GetInstance().UnInitDHCommTool());
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/transport/BUILD.gn b/services/distributedhardwarefwkservice/test/unittest/common/transport/BUILD.gn
index 2e687b58253913ce91676a2c8693b7a19de0b1e5..7e436b7ddcbea3b7ba385a68859909374311a2aa 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/transport/BUILD.gn
+++ b/services/distributedhardwarefwkservice/test/unittest/common/transport/BUILD.gn
@@ -30,12 +30,61 @@ config("module_private_config") {
   ]
 }
 
-ohos_unittest("TransportTest") {
+ohos_unittest("DhCommToolTest") {
   module_out_path = module_out_path
 
   sources = [
     "dh_comm_tool_test.cpp",
+    "mock_other_method.cpp",
+  ]
+
+  configs = [ ":module_private_config" ]
+
+  cflags = [
+    "-Wall",
+    "-Werror",
+    "-g3",
+    "-Dprivate=public",
+  ]
+
+  deps = [
+    "${services_path}/distributedhardwarefwkservice:distributedhardwarefwksvr",
+    "${utils_path}:distributedhardwareutils",
+  ]
+
+  external_deps = [
+    "cJSON:cjson",
+    "c_utils:utils",
+    "device_manager:devicemanagersdk",
+    "dsoftbus:softbus_client",
+    "eventhandler:libeventhandler",
+    "googletest:gmock",
+    "googletest:gmock_main",
+    "hilog:libhilog",
+    "ipc:ipc_core",
+    "kv_store:distributeddata_inner",
+    "safwk:system_ability_fwk",
+    "samgr:samgr_proxy",
+  ]
+
+  if (dhfwk_os_account) {
+    external_deps += [
+      "os_account:libaccountkits",
+      "os_account:os_account_innerkits",
+    ]
+  }
+
+  if (dhfwk_os_account) {
+    defines = [ "OS_ACCOUNT_PART" ]
+  }
+}
+
+ohos_unittest("DhTransportTest") {
+  module_out_path = module_out_path
+
+  sources = [
     "dh_transport_test.cpp",
+    "mock_other_method.cpp",
   ]
 
   configs = [ ":module_private_config" ]
@@ -55,16 +104,34 @@ ohos_unittest("TransportTest") {
   external_deps = [
     "cJSON:cjson",
     "c_utils:utils",
+    "device_manager:devicemanagersdk",
     "dsoftbus:softbus_client",
     "eventhandler:libeventhandler",
+    "googletest:gmock",
+    "googletest:gmock_main",
     "hilog:libhilog",
     "ipc:ipc_core",
     "kv_store:distributeddata_inner",
     "safwk:system_ability_fwk",
+    "samgr:samgr_proxy",
   ]
+
+  if (dhfwk_os_account) {
+    external_deps += [
+      "os_account:libaccountkits",
+      "os_account:os_account_innerkits",
+    ]
+  }
+
+  if (dhfwk_os_account) {
+    defines = [ "OS_ACCOUNT_PART" ]
+  }
 }
 
 group("transport_test") {
   testonly = true
-  deps = [ ":TransportTest" ]
+  deps = [
+    ":DhCommToolTest",
+    ":DhTransportTest",
+  ]
 }
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_comm_tool_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_comm_tool_test.cpp
index be7796c66ff9db3b44768ab04c28d356133690f5..c0ff0c4acc1d2ccf010dc6ca4f7b1b9c2f60ebee 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_comm_tool_test.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_comm_tool_test.cpp
@@ -13,20 +13,24 @@
  * limitations under the License.
  */
 
-#include "dh_comm_tool.h"
-
 #include <gtest/gtest.h>
 #include <string>
 
+#include "device_manager.h"
+#include "device_manager_impl.h"
+
 #include "capability_info.h"
 #include "capability_info_manager.h"
 #include "dh_context.h"
 #include "dh_transport_obj.h"
 #include "dh_utils_tool.h"
+#include "dh_comm_tool.h"
 #include "distributed_hardware_errno.h"
 #include "distributed_hardware_log.h"
+#include "mock_other_method.h"
 
 using namespace testing::ext;
+using namespace testing;
 namespace OHOS {
 namespace DistributedHardware {
 using namespace std;
@@ -35,6 +39,22 @@ constexpr uint16_t TEST_DEV_TYPE = 0x14;
 constexpr int32_t DH_COMM_REQ_FULL_CAPS = 1;
 // send back full dh attributes to the requester
 constexpr int32_t DH_COMM_RSP_FULL_CAPS = 2;
+constexpr int32_t INVALID_USER_ID = -100;
+constexpr int32_t INVALID_ACCOUNT_INFO_VALUE = -101;
+
+
+static std::string g_mocklocalNetworkId = "123456789";
+static bool g_mockDMValue = false;
+
+std::string GetLocalNetworkId()
+{
+    return g_mocklocalNetworkId;
+}
+
+bool DeviceManagerImpl::CheckSrcAccessControl(const DmAccessCaller &caller, const DmAccessCallee &callee)
+{
+    return g_mockDMValue;
+}
 
 class DhCommToolTest : public testing::Test {
 public:
@@ -42,22 +62,30 @@ public:
     static void TearDownTestCase();
     void SetUp();
     void TearDown();
+
+    static inline shared_ptr<DeviceOtherMethodMock> otherMethodMock_ = nullptr;
 private:
     std::shared_ptr<DHCommTool> dhCommToolTest_;
 };
 
 void DhCommToolTest::SetUpTestCase()
 {
+    otherMethodMock_ = make_shared<DeviceOtherMethodMock>();
+    DeviceOtherMethodMock::otherMethod = otherMethodMock_;
 }
 
 void DhCommToolTest::TearDownTestCase()
 {
+    DeviceOtherMethodMock::otherMethod = nullptr;
+    otherMethodMock_ = nullptr;
 }
 
 void DhCommToolTest::SetUp()
 {
     dhCommToolTest_ = std::make_shared<DHCommTool>();
     dhCommToolTest_->Init();
+    g_mockDMValue = false;
+    g_mocklocalNetworkId = "123456789";
 }
 
 void DhCommToolTest::TearDown()
@@ -68,18 +96,44 @@ HWTEST_F(DhCommToolTest, TriggerReqFullDHCaps_001, TestSize.Level1)
 {
     ASSERT_TRUE(dhCommToolTest_ != nullptr);
     std::string remoteNetworkId = "";
-    dhCommToolTest_->TriggerReqFullDHCaps(remoteNetworkId);
-
     dhCommToolTest_->dhTransportPtr_ = nullptr;
     dhCommToolTest_->TriggerReqFullDHCaps(remoteNetworkId);
 
-    remoteNetworkId = "remoteNetworkId_test";
+    remoteNetworkId = "123456789";
     dhCommToolTest_->TriggerReqFullDHCaps(remoteNetworkId);
+}
 
-    dhCommToolTest_->Init();
-    dhCommToolTest_->TriggerReqFullDHCaps(remoteNetworkId);
+HWTEST_F(DhCommToolTest, TriggerReqFullDHCaps_002, TestSize.Level1)
+{
+    ASSERT_TRUE(dhCommToolTest_ != nullptr);
+    std::string remoteNetworkId = "123456789";
+    g_mocklocalNetworkId = "";
+    ASSERT_NO_FATAL_FAILURE(dhCommToolTest_->TriggerReqFullDHCaps(remoteNetworkId));
     dhCommToolTest_->UnInit();
-    EXPECT_NE(nullptr, dhCommToolTest_->dhTransportPtr_);
+}
+
+HWTEST_F(DhCommToolTest, TriggerReqFullDHCaps_003, TestSize.Level1)
+{
+    ASSERT_TRUE(dhCommToolTest_ != nullptr);
+    std::string remoteNetworkId = "123456789";
+    std::vector<int32_t> userIds;
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(INVALID_USER_ID)));
+    ASSERT_NO_FATAL_FAILURE(dhCommToolTest_->TriggerReqFullDHCaps(remoteNetworkId));
+}
+
+HWTEST_F(DhCommToolTest, TriggerReqFullDHCaps_004, TestSize.Level1)
+{
+    ASSERT_TRUE(dhCommToolTest_ != nullptr);
+    std::string remoteNetworkId = "123456789";
+    std::vector<int32_t> userIds{100, 101};
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(DH_FWK_SUCCESS)));
+
+    AccountSA::OhosAccountInfo osAccountInfo;
+    EXPECT_CALL(*otherMethodMock_, GetOhosAccountInfo(_))
+        .WillOnce(DoAll(SetArgReferee<0>(osAccountInfo), Return(DH_FWK_SUCCESS)));
+    ASSERT_NO_FATAL_FAILURE(dhCommToolTest_->TriggerReqFullDHCaps(remoteNetworkId));
 }
 
 HWTEST_F(DhCommToolTest, GetAndSendLocalFullCaps_001, TestSize.Level1)
@@ -90,8 +144,7 @@ HWTEST_F(DhCommToolTest, GetAndSendLocalFullCaps_001, TestSize.Level1)
     dhCommToolTest_->GetAndSendLocalFullCaps(reqNetworkId);
 
     dhCommToolTest_->Init();
-    dhCommToolTest_->GetAndSendLocalFullCaps(reqNetworkId);
-    EXPECT_NE(nullptr, dhCommToolTest_->dhTransportPtr_);
+    ASSERT_NO_FATAL_FAILURE(dhCommToolTest_->GetAndSendLocalFullCaps(reqNetworkId));
 }
 
 HWTEST_F(DhCommToolTest, ParseAndSaveRemoteDHCaps_001, TestSize.Level1)
@@ -189,5 +242,87 @@ HWTEST_F(DhCommToolTest, ProcessFullCapsRsp_002, TestSize.Level1)
     ASSERT_NO_FATAL_FAILURE(eventHandler.ProcessFullCapsRsp(capsRsp2, dhCommToolTest_));
     DHContext::GetInstance().RemoveOnlineDeviceIdEntryByNetworkId(networkId);
 }
+
+HWTEST_F(DhCommToolTest, CheckCallerAclRight_001, TestSize.Level1)
+{
+    ASSERT_TRUE(dhCommToolTest_ != nullptr);
+    std::string localNetworkId;
+    std::string remoteNetworkId;
+    std::vector<int32_t> userIds{100, 101};
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(DH_FWK_SUCCESS)));
+
+    AccountSA::OhosAccountInfo osAccountInfo;
+    EXPECT_CALL(*otherMethodMock_, GetOhosAccountInfo(_))
+        .WillOnce(DoAll(SetArgReferee<0>(osAccountInfo), Return(DH_FWK_SUCCESS)));
+    g_mockDMValue = false;
+    auto ret = dhCommToolTest_->CheckCallerAclRight(localNetworkId, remoteNetworkId);
+    EXPECT_EQ(false, ret);
+}
+
+HWTEST_F(DhCommToolTest, CheckCallerAclRight_002, TestSize.Level1)
+{
+    ASSERT_TRUE(dhCommToolTest_ != nullptr);
+    std::string localNetworkId;
+    std::string remoteNetworkId;
+    std::vector<int32_t> userIds{100, 101};
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(DH_FWK_SUCCESS)));
+
+    AccountSA::OhosAccountInfo osAccountInfo;
+    EXPECT_CALL(*otherMethodMock_, GetOhosAccountInfo(_))
+        .WillOnce(DoAll(SetArgReferee<0>(osAccountInfo), Return(DH_FWK_SUCCESS)));
+    g_mockDMValue = true;
+    auto ret = dhCommToolTest_->CheckCallerAclRight(localNetworkId, remoteNetworkId);
+    EXPECT_EQ(true, ret);
+}
+
+HWTEST_F(DhCommToolTest, GetOsAccountInfo_001, TestSize.Level1)
+{
+    ASSERT_TRUE(dhCommToolTest_ != nullptr);
+    std::vector<int32_t> userIds{100, 101};
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(INVALID_USER_ID)));
+    auto ret = dhCommToolTest_->GetOsAccountInfo();
+    EXPECT_EQ(false, ret);
+}
+
+HWTEST_F(DhCommToolTest, GetOsAccountInfo_002, TestSize.Level1)
+{
+    ASSERT_TRUE(dhCommToolTest_ != nullptr);
+    std::vector<int32_t> userIds;
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(DH_FWK_SUCCESS)));
+    auto ret = dhCommToolTest_->GetOsAccountInfo();
+    EXPECT_EQ(false, ret);
+}
+
+HWTEST_F(DhCommToolTest, GetOsAccountInfo_003, TestSize.Level1)
+{
+    ASSERT_TRUE(dhCommToolTest_ != nullptr);
+    std::vector<int32_t> userIds{100, 101};
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(DH_FWK_SUCCESS)));
+
+    AccountSA::OhosAccountInfo osAccountInfo;
+    EXPECT_CALL(*otherMethodMock_, GetOhosAccountInfo(_))
+        .WillOnce(DoAll(SetArgReferee<0>(osAccountInfo), Return(INVALID_ACCOUNT_INFO_VALUE)));
+    auto ret = dhCommToolTest_->GetOsAccountInfo();
+    EXPECT_EQ(false, ret);
+}
+
+HWTEST_F(DhCommToolTest, GetOsAccountInfo_004, TestSize.Level1)
+{
+    ASSERT_TRUE(dhCommToolTest_ != nullptr);
+    std::vector<int32_t> userIds{100, 101};
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(DH_FWK_SUCCESS)));
+
+    AccountSA::OhosAccountInfo osAccountInfo;
+    EXPECT_CALL(*otherMethodMock_, GetOhosAccountInfo(_))
+        .WillOnce(DoAll(SetArgReferee<0>(osAccountInfo), Return(DH_FWK_SUCCESS)));
+    auto ret = dhCommToolTest_->GetOsAccountInfo();
+    EXPECT_EQ(true, ret);
+}
 }
 }
\ No newline at end of file
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_transport_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_transport_test.cpp
index e066219329b05db0f9cd687ad93912bc2d5fab0b..451ac8ff96689413699686ec2f6f9feab5a39f7b 100644
--- a/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_transport_test.cpp
+++ b/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_transport_test.cpp
@@ -14,17 +14,21 @@
  */
 
 #include <gtest/gtest.h>
-
-#include "dh_transport.h"
 #include <string>
 
+#include "device_manager.h"
+#include "device_manager_impl.h"
+
+#include "dh_transport.h"
 #include "dh_comm_tool.h"
 #include "dh_transport_obj.h"
 #include "capability_info_manager.h"
 #include "distributed_hardware_errno.h"
+#include "mock_other_method.h"
 
 
 using namespace testing::ext;
+using namespace testing;
 namespace OHOS {
 namespace DistributedHardware {
 using namespace std;
@@ -33,29 +37,53 @@ namespace {
     int32_t g_socketid = 1;
     std::string g_networkid = "networkId_test";
     constexpr int32_t SOCKETID = 10;
+    constexpr int32_t INVALID_USER_ID = -100;
+    constexpr int32_t INVALID_ACCOUNT_INFO_VALUE = -101;
+}
+
+static std::string g_mocklocalNetworkId = "123456789";
+static bool g_mockDMValue = false;
+
+std::string GetLocalNetworkId()
+{
+    return g_mocklocalNetworkId;
+}
+
+bool DeviceManagerImpl::CheckSinkAccessControl(const DmAccessCaller &caller, const DmAccessCallee &callee)
+{
+    return g_mockDMValue;
 }
+
 class DhTransportTest : public testing::Test {
 public:
     static void SetUpTestCase();
     static void TearDownTestCase();
     void SetUp();
     void TearDown();
+
+    static inline shared_ptr<DeviceOtherMethodMock> otherMethodMock_ = nullptr;
 private:
     std::shared_ptr<DHTransport> dhTransportTest_;
 };
 
 void DhTransportTest::SetUpTestCase()
 {
+    otherMethodMock_ = make_shared<DeviceOtherMethodMock>();
+    DeviceOtherMethodMock::otherMethod = otherMethodMock_;
 }
 
 void DhTransportTest::TearDownTestCase()
 {
+    DeviceOtherMethodMock::otherMethod = nullptr;
+    otherMethodMock_ = nullptr;
 }
 
 void DhTransportTest::SetUp()
 {
     std::shared_ptr<DHCommTool> dhCommTool = std::make_shared<DHCommTool>();
     dhTransportTest_ = std::make_shared<DHTransport>(dhCommTool);
+    g_mocklocalNetworkId = "123456789";
+    g_mockDMValue = false;
 }
 
 void DhTransportTest::TearDown()
@@ -312,11 +340,12 @@ HWTEST_F(DhTransportTest, FromJson_CommMsg_001, TestSize.Level1)
 
     cJSON *jsonObject = cJSON_CreateObject();
     ASSERT_TRUE(jsonObject != nullptr);
+    EXPECT_TRUE(commMsg.msg.empty());
+
     cJSON_AddStringToObject(jsonObject, COMM_MSG_CODE_KEY, "comm_msg_code_test");
-    cJSON_AddStringToObject(jsonObject, COMM_MSG_MSG_KEY, "comm_msg_msg_test");
     FromJson(jsonObject, commMsg);
     cJSON_Delete(jsonObject);
-    EXPECT_FALSE(commMsg.msg.empty());
+    EXPECT_TRUE(commMsg.msg.empty());
 }
 
 HWTEST_F(DhTransportTest, FromJson_CommMsg_002, TestSize.Level1)
@@ -324,6 +353,33 @@ HWTEST_F(DhTransportTest, FromJson_CommMsg_002, TestSize.Level1)
     cJSON *jsonObject = cJSON_CreateObject();
     ASSERT_TRUE(jsonObject != nullptr);
     cJSON_AddNumberToObject(jsonObject, COMM_MSG_CODE_KEY, 1);
+    cJSON_AddStringToObject(jsonObject, COMM_MSG_USERID_KEY, "userId_test");
+    CommMsg commMsg;
+    FromJson(jsonObject, commMsg);
+    cJSON_Delete(jsonObject);
+    EXPECT_TRUE(commMsg.msg.empty());
+}
+
+HWTEST_F(DhTransportTest, FromJson_CommMsg_003, TestSize.Level1)
+{
+    cJSON *jsonObject = cJSON_CreateObject();
+    ASSERT_TRUE(jsonObject != nullptr);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_CODE_KEY, 1);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_USERID_KEY, 1);
+    cJSON_AddStringToObject(jsonObject, COMM_MSG_TOKENID_KEY, "userId_test");
+    CommMsg commMsg;
+    FromJson(jsonObject, commMsg);
+    cJSON_Delete(jsonObject);
+    EXPECT_TRUE(commMsg.msg.empty());
+}
+
+HWTEST_F(DhTransportTest, FromJson_CommMsg_004, TestSize.Level1)
+{
+    cJSON *jsonObject = cJSON_CreateObject();
+    ASSERT_TRUE(jsonObject != nullptr);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_CODE_KEY, 1);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_USERID_KEY, 1);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_TOKENID_KEY, 1);
     cJSON_AddNumberToObject(jsonObject, COMM_MSG_MSG_KEY, 1);
     CommMsg commMsg;
     FromJson(jsonObject, commMsg);
@@ -331,11 +387,143 @@ HWTEST_F(DhTransportTest, FromJson_CommMsg_002, TestSize.Level1)
     EXPECT_TRUE(commMsg.msg.empty());
 }
 
+HWTEST_F(DhTransportTest, FromJson_CommMsg_005, TestSize.Level1)
+{
+    cJSON *jsonObject = cJSON_CreateObject();
+    ASSERT_TRUE(jsonObject != nullptr);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_CODE_KEY, 1);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_USERID_KEY, 1);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_TOKENID_KEY, 1);
+    cJSON_AddStringToObject(jsonObject, COMM_MSG_MSG_KEY, "comm_msg_msg_test");
+    CommMsg commMsg;
+    FromJson(jsonObject, commMsg);
+    cJSON_Delete(jsonObject);
+    EXPECT_FALSE(commMsg.msg.empty());
+}
+
+HWTEST_F(DhTransportTest, FromJson_CommMsg_006, TestSize.Level1)
+{
+    cJSON *jsonObject = cJSON_CreateObject();
+    ASSERT_TRUE(jsonObject != nullptr);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_CODE_KEY, 1);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_USERID_KEY, 1);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_TOKENID_KEY, 1);
+    cJSON_AddStringToObject(jsonObject, COMM_MSG_MSG_KEY, "comm_msg_msg_test");
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_ACCOUNTID_KEY, 1);
+    CommMsg commMsg;
+    FromJson(jsonObject, commMsg);
+    cJSON_Delete(jsonObject);
+    EXPECT_FALSE(commMsg.msg.empty());
+}
+
+HWTEST_F(DhTransportTest, FromJson_CommMsg_007, TestSize.Level1)
+{
+    cJSON *jsonObject = cJSON_CreateObject();
+    ASSERT_TRUE(jsonObject != nullptr);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_CODE_KEY, 1);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_USERID_KEY, 1);
+    cJSON_AddNumberToObject(jsonObject, COMM_MSG_TOKENID_KEY, 1);
+    cJSON_AddStringToObject(jsonObject, COMM_MSG_MSG_KEY, "comm_msg_msg_test");
+    cJSON_AddStringToObject(jsonObject, COMM_MSG_ACCOUNTID_KEY, "account_test");
+    CommMsg commMsg;
+    FromJson(jsonObject, commMsg);
+    cJSON_Delete(jsonObject);
+    EXPECT_FALSE(commMsg.msg.empty());
+}
+
 HWTEST_F(DhTransportTest, CreateClientSocket_001, TestSize.Level1)
 {
     std::string remoteNetworkId = "";
     auto ret = dhTransportTest_->CreateClientSocket(remoteNetworkId);
     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
 }
+
+HWTEST_F(DhTransportTest, CheckCalleeAclRight_001, TestSize.Level1)
+{
+    ASSERT_TRUE(dhTransportTest_ != nullptr);
+    std::shared_ptr<CommMsg> commMsg = std::make_shared<CommMsg>();
+    commMsg->userId = -1;
+    auto ret = dhTransportTest_->CheckCalleeAclRight(commMsg);
+    EXPECT_EQ(true, ret);
+}
+
+HWTEST_F(DhTransportTest, CheckCalleeAclRight_002, TestSize.Level1)
+{
+    ASSERT_TRUE(dhTransportTest_ != nullptr);
+    std::shared_ptr<CommMsg> commMsg = std::make_shared<CommMsg>();
+    commMsg->userId = 1;
+    g_mocklocalNetworkId = "";
+    auto ret = dhTransportTest_->CheckCalleeAclRight(commMsg);
+    EXPECT_EQ(false, ret);
+}
+
+HWTEST_F(DhTransportTest, CheckCalleeAclRight_003, TestSize.Level1)
+{
+    ASSERT_TRUE(dhTransportTest_ != nullptr);
+    std::shared_ptr<CommMsg> commMsg = std::make_shared<CommMsg>();
+    commMsg->userId = 1;
+    std::vector<int32_t> userIds;
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(INVALID_USER_ID)));
+    auto ret = dhTransportTest_->CheckCalleeAclRight(commMsg);
+    EXPECT_EQ(false, ret);
+}
+
+HWTEST_F(DhTransportTest, CheckCalleeAclRight_004, TestSize.Level1)
+{
+    ASSERT_TRUE(dhTransportTest_ != nullptr);
+    std::shared_ptr<CommMsg> commMsg = std::make_shared<CommMsg>();
+    commMsg->userId = 1;
+    std::vector<int32_t> userIds{100, 101};
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(INVALID_USER_ID)));
+    auto ret = dhTransportTest_->CheckCalleeAclRight(commMsg);
+    EXPECT_EQ(false, ret);
+}
+
+HWTEST_F(DhTransportTest, CheckCalleeAclRight_005, TestSize.Level1)
+{
+    ASSERT_TRUE(dhTransportTest_ != nullptr);
+    std::shared_ptr<CommMsg> commMsg = std::make_shared<CommMsg>();
+    commMsg->userId = 1;
+    std::vector<int32_t> userIds;
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(DH_FWK_SUCCESS)));
+    auto ret = dhTransportTest_->CheckCalleeAclRight(commMsg);
+    EXPECT_EQ(false, ret);
+}
+
+HWTEST_F(DhTransportTest, CheckCalleeAclRight_006, TestSize.Level1)
+{
+    ASSERT_TRUE(dhTransportTest_ != nullptr);
+    std::shared_ptr<CommMsg> commMsg = std::make_shared<CommMsg>();
+    commMsg->userId = 1;
+    std::vector<int32_t> userIds{100, 101};
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(DH_FWK_SUCCESS)));
+
+    AccountSA::OhosAccountInfo osAccountInfo;
+    EXPECT_CALL(*otherMethodMock_, GetOhosAccountInfo(_))
+        .WillOnce(DoAll(SetArgReferee<0>(osAccountInfo), Return(INVALID_ACCOUNT_INFO_VALUE)));
+    auto ret = dhTransportTest_->CheckCalleeAclRight(commMsg);
+    EXPECT_EQ(false, ret);
+}
+
+HWTEST_F(DhTransportTest, CheckCalleeAclRight_007, TestSize.Level1)
+{
+    ASSERT_TRUE(dhTransportTest_ != nullptr);
+    std::shared_ptr<CommMsg> commMsg = std::make_shared<CommMsg>();
+    commMsg->userId = 1;
+    std::vector<int32_t> userIds{100, 101};
+    EXPECT_CALL(*otherMethodMock_, QueryActiveOsAccountIds(_))
+        .WillOnce(DoAll(SetArgReferee<0>(userIds), Return(DH_FWK_SUCCESS)));
+
+    AccountSA::OhosAccountInfo osAccountInfo;
+    EXPECT_CALL(*otherMethodMock_, GetOhosAccountInfo(_))
+        .WillOnce(DoAll(SetArgReferee<0>(osAccountInfo), Return(DH_FWK_SUCCESS)));
+    g_mockDMValue = true;
+    auto ret = dhTransportTest_->CheckCalleeAclRight(commMsg);
+    EXPECT_EQ(true, ret);
+}
 }
 }
\ No newline at end of file
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/transport/mock_other_method.cpp b/services/distributedhardwarefwkservice/test/unittest/common/transport/mock_other_method.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4549dd9f0c40c1c5318784c0bd5d595d14556e18
--- /dev/null
+++ b/services/distributedhardwarefwkservice/test/unittest/common/transport/mock_other_method.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "os_account_manager.h"
+
+#include "mock_other_method.h"
+
+namespace OHOS {
+namespace AccountSA {
+/**
+ * Interfaces for ohos account subsystem.
+ */
+class OhosAccountKitsImpl : public OhosAccountKits {
+public:
+    std::pair<bool, OhosAccountInfo> QueryOhosAccountInfo()
+    {
+        return {};
+    }
+
+    ErrCode GetOhosAccountInfo(OhosAccountInfo &accountInfo);
+
+    ErrCode GetOsAccountDistributedInfo(int32_t localId, OhosAccountInfo &accountInfo)
+    {
+        return 0;
+    }
+
+    std::pair<bool, OhosAccountInfo> QueryOsAccountDistributedInfo(std::int32_t localId)
+    {
+        return {};
+    }
+
+    ErrCode UpdateOhosAccountInfo(const std::string& accountName, const std::string& uid,
+        const std::string& eventStr)
+    {
+        return 0;
+    }
+
+    ErrCode SetOhosAccountInfo(const OhosAccountInfo &ohosAccountInfo,
+        const std::string &eventStr)
+    {
+        return 0;
+    }
+
+    ErrCode SetOsAccountDistributedInfo(
+        const int32_t localId, const OhosAccountInfo& ohosAccountInfo, const std::string& eventStr)
+    {
+        return 0;
+    }
+
+    ErrCode QueryDeviceAccountId(std::int32_t& accountId)
+    {
+        return 0;
+    }
+
+    std::int32_t GetDeviceAccountIdByUID(std::int32_t& uid)
+    {
+        return 0;
+    }
+
+    ErrCode SubscribeDistributedAccountEvent(const DISTRIBUTED_ACCOUNT_SUBSCRIBE_TYPE type,
+        const std::shared_ptr<DistributedAccountSubscribeCallback> &callback)
+    {
+        return 0;
+    }
+
+    ErrCode UnsubscribeDistributedAccountEvent(const DISTRIBUTED_ACCOUNT_SUBSCRIBE_TYPE type,
+        const std::shared_ptr<DistributedAccountSubscribeCallback> &callback)
+    {
+        return 0;
+    }
+};
+
+ErrCode OsAccountManager::QueryActiveOsAccountIds(std::vector<int32_t>& ids)
+{
+    return OHOS::DistributedHardware::DeviceOtherMethod::otherMethod->QueryActiveOsAccountIds(ids);
+}
+
+ErrCode OhosAccountKitsImpl::GetOhosAccountInfo(AccountSA::OhosAccountInfo &accountInfo)
+{
+    return OHOS::DistributedHardware::DeviceOtherMethod::otherMethod->GetOhosAccountInfo(accountInfo);
+}
+
+OhosAccountKits &OhosAccountKits::GetInstance()
+{
+    static OhosAccountKitsImpl test;
+    return test;
+}
+}  // namespace AccountSA
+}  // namespace OHOS
\ No newline at end of file
diff --git a/services/distributedhardwarefwkservice/test/unittest/common/transport/mock_other_method.h b/services/distributedhardwarefwkservice/test/unittest/common/transport/mock_other_method.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7628f909b66222ef5f9a1613e0e88f6a80c0cac
--- /dev/null
+++ b/services/distributedhardwarefwkservice/test/unittest/common/transport/mock_other_method.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef DISRIBUTED_HARDWARE_MOCK_OTHER_METHOD_H
+#define DISRIBUTED_HARDWARE_MOCK_OTHER_METHOD_H
+
+#include <gmock/gmock.h>
+
+#include <vector>
+
+#include "ohos_account_kits.h"
+#include "os_account_manager.h"
+
+namespace OHOS::DistributedHardware {
+class DeviceOtherMethod {
+public:
+    virtual ~DeviceOtherMethod() = default;
+public:
+    virtual int QueryActiveOsAccountIds(std::vector<int32_t>& ids) = 0;
+    virtual int GetOhosAccountInfo(AccountSA::OhosAccountInfo &accountInfo) = 0;
+public:
+    static inline std::shared_ptr<DeviceOtherMethod> otherMethod = nullptr;
+};
+
+class DeviceOtherMethodMock : public DeviceOtherMethod {
+public:
+    MOCK_METHOD1(QueryActiveOsAccountIds, int(std::vector<int32_t>& ids));
+    MOCK_METHOD1(GetOhosAccountInfo, int(AccountSA::OhosAccountInfo &accountInfo));
+};
+}
+#endif
\ No newline at end of file