diff --git a/services/distributeddataservice/adapter/communicator/src/communicator_context.cpp b/services/distributeddataservice/adapter/communicator/src/communicator_context.cpp
index 76f63db9f18f27dedcacf9e5f37ec6601c610d08..b5415a6b7614e4ba8b48af5eb1d51b5f0b0c607c 100644
--- a/services/distributeddataservice/adapter/communicator/src/communicator_context.cpp
+++ b/services/distributeddataservice/adapter/communicator/src/communicator_context.cpp
@@ -14,13 +14,14 @@
 */
 
 #define LOG_TAG "CommunicatorContext"
+
 #include "communicator_context.h"
+
 #include "log_print.h"
-#include "kvstore_utils.h"
 #include "softbus_error_code.h"
+#include "utils/anonymous.h"
 
 namespace OHOS::DistributedData {
-using KvUtils = OHOS::DistributedKv::KvStoreUtils;
 using Status = OHOS::DistributedKv::Status;
 
 CommunicatorContext &CommunicatorContext::GetInstance()
@@ -92,7 +93,7 @@ void CommunicatorContext::NotifySessionReady(const std::string &deviceId, int32_
             }
         }
         ZLOGI("Notify session begin, deviceId:%{public}s, observer count:%{public}zu",
-            KvUtils::ToBeAnonymous(deviceId).c_str(), observers_.size());
+            Anonymous::Change(deviceId).c_str(), observers_.size());
     }
     if (errCode == SOFTBUS_OK) {
         std::lock_guard<decltype(sessionMutex_)> sessionLockGard(sessionMutex_);
diff --git a/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp b/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp
index 0e40297fcb6661a1121ec2931d97e5cf7b70317e..09a555c5ae642dbcbd8f0181a6011d9184df420d 100644
--- a/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp
+++ b/services/distributeddataservice/adapter/communicator/src/process_communicator_impl.cpp
@@ -143,7 +143,15 @@ DBStatus ProcessCommunicatorImpl::SendData(const DeviceInfos &dstDevInfo, const
     uint32_t totalLength)
 {
     PipeInfo pi = {thisProcessLabel_, ""};
-    const DataInfo dataInfo = { const_cast<uint8_t *>(data), length};
+    if (dstDevInfo.callee.userId.empty() || dstDevInfo.callee.appId.empty() || dstDevInfo.callee.storeId.empty()) {
+        ZLOGE("access info is empty, userId:%{public}s, bundleName:%{public}s, storeId:%{public}s",
+            dstDevInfo.callee.userId.c_str(), dstDevInfo.callee.appId.c_str(),
+            Anonymous::Change(dstDevInfo.callee.storeId).c_str());
+        return DBStatus::DB_ERROR;
+    }
+    ExtraDataInfo extraInfo = { .userId = dstDevInfo.callee.userId, .bundleName = dstDevInfo.callee.appId,
+        .storeId = dstDevInfo.callee.storeId };
+    const DataInfo dataInfo = { .data = const_cast<uint8_t *>(data), .length = length, .extraInfo = extraInfo };
     DeviceId destination;
     destination.deviceId = dstDevInfo.identifier;
     auto [errCode, softBusErrCode] =
diff --git a/services/distributeddataservice/adapter/communicator/src/softbus_adapter.h b/services/distributeddataservice/adapter/communicator/src/softbus_adapter.h
index 08c572812639eef7555921feb2c7259d6562c21a..e6dbbe9643667816f117533f609953ba0b8eeb68 100644
--- a/services/distributeddataservice/adapter/communicator/src/softbus_adapter.h
+++ b/services/distributeddataservice/adapter/communicator/src/softbus_adapter.h
@@ -15,6 +15,7 @@
 
 #ifndef DISTRIBUTEDDATAFWK_SRC_SOFTBUS_ADAPTER_H
 #define DISTRIBUTEDDATAFWK_SRC_SOFTBUS_ADAPTER_H
+
 #include <concurrent_map.h>
 #include <condition_variable>
 #include <functional>
@@ -28,9 +29,11 @@
 #include "app_data_change_listener.h"
 #include "app_device_change_listener.h"
 #include "block_data.h"
+#include "executor_pool.h"
 #include "socket.h"
 #include "softbus_bus_center.h"
 #include "softbus_client.h"
+
 namespace OHOS {
 namespace AppDistributedKv {
 class SoftBusAdapter : public AppDistributedKv::AppDeviceChangeListener {
@@ -95,7 +98,9 @@ private:
     bool CloseSession(const std::string &networkId);
     void GetExpireTime(std::shared_ptr<SoftBusClient> &conn);
     std::pair<Status, int32_t> OpenConnect(const std::shared_ptr<SoftBusClient> &conn, const DeviceId &deviceId);
-    std::shared_ptr<SoftBusClient> GetConnect(const PipeInfo &pipeInfo, const DeviceId &deviceId, uint32_t qosType);
+    bool ConfigSessionAccessInfo(const ExtraDataInfo &extraInfo, SessionAccessInfo &sessionAccessInfo);
+    std::shared_ptr<SoftBusClient> GetConnect(const PipeInfo &pipeInfo, const DeviceId &deviceId,
+        const ExtraDataInfo &extraInfo = {});
     static constexpr const char *PKG_NAME = "distributeddata-default";
     static constexpr Time INVALID_NEXT = std::chrono::steady_clock::time_point::max();
     static constexpr uint32_t QOS_COUNT = 3;
diff --git a/services/distributeddataservice/adapter/communicator/src/softbus_adapter_standard.cpp b/services/distributeddataservice/adapter/communicator/src/softbus_adapter_standard.cpp
index 5d8e2cb4d114efcb23f3c13aa48d966aa97fbc16..9a9c491a942e603d73b07082d0ae92d7668b37cc 100644
--- a/services/distributeddataservice/adapter/communicator/src/softbus_adapter_standard.cpp
+++ b/services/distributeddataservice/adapter/communicator/src/softbus_adapter_standard.cpp
@@ -12,37 +12,36 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-#include <mutex>
-#include <string>
-#include <thread>
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "SoftBusAdapter"
 
+#include "account/account_delegate.h"
 #include "communication/connect_manager.h"
 #include "communicator_context.h"
 #include "data_level.h"
 #include "device_manager_adapter.h"
 #include "dfx/dfx_types.h"
 #include "dfx/reporter.h"
-#include "kvstore_utils.h"
 #include "log_print.h"
+#include "metadata/meta_data_manager.h"
+#include "metadata/store_meta_data.h"
 #include "securec.h"
 #include "session.h"
 #include "softbus_adapter.h"
 #include "softbus_bus_center.h"
 #include "softbus_error_code.h"
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "SoftBusAdapter"
+#include "utils/anonymous.h"
 
 namespace OHOS {
 namespace AppDistributedKv {
-using Context = DistributedData::CommunicatorContext;
 constexpr uint32_t DEFAULT_MTU_SIZE = 4096 * 1024u;
 constexpr uint32_t DEFAULT_TIMEOUT = 30 * 1000;
 using namespace std;
 using namespace OHOS::DistributedDataDfx;
 using namespace OHOS::DistributedKv;
-using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
+using namespace OHOS::DistributedData;
 
 class AppDataListenerWrap {
 public:
@@ -55,12 +54,16 @@ public:
     static void OnServerBind(int32_t socket, PeerSocketInfo info);
     static void OnServerShutdown(int32_t socket, ShutdownReason reason);
     static void OnServerBytesReceived(int32_t socket, const void *data, uint32_t dataLen);
+    static bool OnServerAccessCheck(int32_t socket, PeerSocketInfo info, SocketAccessInfo *peerInfo,
+        SocketAccessInfo *localInfo);
 
 private:
     // notify all listeners when received message
     static void NotifyDataListeners(const uint8_t *data, const int size, const std::string &deviceId,
         const PipeInfo &pipeInfo);
     static std::string GetPipeId(const std::string &name);
+    static std::pair<bool, StoreMetaData> LoadMetaData(const std::string &bundleName, const std::string &storeId,
+        int32_t userId);
 
     static SoftBusAdapter *softBusAdapter_;
 };
@@ -80,7 +83,7 @@ void OnDataLevelChanged(const char* networkId, const DataLevel dataLevel)
         .switches = dataLevel.switchLevel,
         .switchesLen = dataLevel.switchLength,
     };
-    auto uuid = DmAdapter::GetInstance().GetUuidByNetworkId(networkId);
+    auto uuid = DeviceManagerAdapter::GetInstance().GetUuidByNetworkId(networkId);
     SoftBusAdapter::GetInstance()->OnBroadcast({ uuid }, std::move(level));
 }
 
@@ -88,6 +91,7 @@ IDataLevelCb g_callback = {
     .onDataLevelChanged = OnDataLevelChanged,
 };
 } // namespace
+
 SoftBusAdapter::SoftBusAdapter()
 {
     ZLOGI("begin");
@@ -102,23 +106,25 @@ SoftBusAdapter::SoftBusAdapter()
     serverListener_.OnShutdown = AppDataListenerWrap::OnServerShutdown;
     serverListener_.OnBytes = AppDataListenerWrap::OnServerBytesReceived;
     serverListener_.OnMessage = AppDataListenerWrap::OnServerBytesReceived;
+	serverListener_.OnNegotiate2 = AppDataListenerWrap::OnServerAccessCheck;
 
     auto status = DmAdapter::GetInstance().StartWatchDeviceChange(this, { "softBusAdapter" });
     if (status != Status::SUCCESS) {
         ZLOGW("register device change failed, status:%d", static_cast<int>(status));
     }
 
-    Context::GetInstance().SetSessionListener([this](const std::string &deviceId) {
+    CommunicatorContext::GetInstance().SetSessionListener([this](const std::string &deviceId) {
         StartCloseSessionTask(deviceId);
     });
 
     ConnectManager::GetInstance()->RegisterCloseSessionTask([this](const std::string &networkId) {
         return CloseSession(networkId);
     });
-    ConnectManager::GetInstance()->RegisterSessionCloseListener("context", [](const std::string &networkId) {
-        auto uuid = DmAdapter::GetInstance().GetUuidByNetworkId(networkId);
-        Context::GetInstance().NotifySessionClose(uuid);
-    });
+    ConnectManager::GetInstance()->RegisterSessionCloseListener("CommunicatorContext",
+        [](const std::string &networkId) {
+            auto uuid = DeviceManagerAdapter::GetInstance().GetUuidByNetworkId(networkId);
+            CommunicatorContext::GetInstance().NotifySessionClose(uuid);
+        });
     ConnectManager::GetInstance()->OnStart();
 }
 
@@ -174,7 +180,7 @@ void SoftBusAdapter::GetExpireTime(std::shared_ptr<SoftBusClient> &conn)
     auto expireTime = conn->GetExpireTime() > now ? conn->GetExpireTime() : now;
     lock_guard<decltype(taskMutex_)> lock(taskMutex_);
     if (taskId_ != ExecutorPool::INVALID_TASK_ID && expireTime < next_) {
-        taskId_ = Context::GetInstance().GetThreadPool()->Reset(taskId_, expireTime - now);
+        taskId_ = CommunicatorContext::GetInstance().GetThreadPool()->Reset(taskId_, expireTime - now);
         next_ = expireTime;
     }
 }
@@ -182,9 +188,7 @@ void SoftBusAdapter::GetExpireTime(std::shared_ptr<SoftBusClient> &conn)
 std::pair<Status, int32_t> SoftBusAdapter::SendData(const PipeInfo &pipeInfo, const DeviceId &deviceId,
     const DataInfo &dataInfo, uint32_t length, const MessageInfo &info)
 {
-    bool isOHOSType = DmAdapter::GetInstance().IsOHOSType(deviceId.deviceId);
-    uint32_t qosType = isOHOSType ? SoftBusClient::QOS_HML : SoftBusClient::QOS_BR;
-    std::shared_ptr<SoftBusClient> conn = GetConnect(pipeInfo, deviceId, qosType);
+    std::shared_ptr<SoftBusClient> conn = GetConnect(pipeInfo, deviceId, dataInfo.extraInfo);
     if (conn == nullptr) {
         return std::make_pair(Status::ERROR, 0);
     }
@@ -195,7 +199,7 @@ std::pair<Status, int32_t> SoftBusAdapter::SendData(const PipeInfo &pipeInfo, co
     if (status != Status::SUCCESS) {
         return OpenConnect(conn, deviceId);
     }
-    status = conn->SendData(dataInfo, &clientListener_);
+    status = conn->SendData(dataInfo);
     if ((status != Status::NETWORK_ERROR) && (status != Status::RATE_LIMIT)) {
         GetExpireTime(conn);
     }
@@ -203,27 +207,76 @@ std::pair<Status, int32_t> SoftBusAdapter::SendData(const PipeInfo &pipeInfo, co
     return std::make_pair(status, errCode);
 }
 
+bool SoftBusAdapter::ConfigSessionAccessInfo(const ExtraDataInfo &extraInfo, SessionAccessInfo &sessionAccessInfo)
+{
+    if (extraInfo.userId.empty() || extraInfo.bundleName.empty() || extraInfo.storeId.empty()) {
+        ZLOGE("extraInfo is empty, userId:%{public}s, bundleName:%{public}s, storeId:%{public}s",
+            extraInfo.userId.c_str(), extraInfo.bundleName.c_str(), extraInfo.storeId.c_str());
+        return false;
+    }
+    StoreMetaData metaData;
+    metaData.deviceId = DeviceManagerAdapter::GetInstance().GetLocalDevice().uuid;
+    metaData.user = extraInfo.userId;
+    metaData.bundleName = extraInfo.bundleName;
+    metaData.storeId = extraInfo.storeId;
+    if (!MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData)) {
+        ZLOGE("get meta data fail, metaKey:%{public}s", metaData.GetKey().c_str());
+        return false;
+    }
+    sessionAccessInfo.bundleName = extraInfo.bundleName;
+    sessionAccessInfo.storeId = extraInfo.storeId;
+    sessionAccessInfo.tokenId = metaData.tokenId;
+    int foregroundUserId = 0;
+    auto ret = AccountDelegate::GetInstance()->QueryForegroundUserId(foregroundUserId);
+    if (!ret) {
+        return false;
+    }
+    sessionAccessInfo.userId = foregroundUserId;
+    auto accountId = AccountDelegate::GetInstance()->GetCurrentAccountId();
+    if (accountId.empty()) {
+        return false;
+    }
+    sessionAccessInfo.accountId = accountId;
+    return true;
+}
+
 std::shared_ptr<SoftBusClient> SoftBusAdapter::GetConnect(const PipeInfo &pipeInfo, const DeviceId &deviceId,
-    uint32_t qosType)
+    const ExtraDataInfo &extraInfo)
 {
     std::shared_ptr<SoftBusClient> conn;
-    std::string networkId = DmAdapter::GetInstance().ToNetworkID(deviceId.deviceId);
-    connects_.Compute(deviceId.deviceId, [&pipeInfo, &deviceId, &conn, qosType, &networkId](const auto &key,
-        std::vector<std::shared_ptr<SoftBusClient>> &connects) -> bool {
-        for (auto &connect : connects) {
-            if (connect == nullptr) {
-                continue;
-            }
-            if (connect->GetQoSType() == qosType) {
-                conn = connect;
-                return true;
+    if (deviceId.deviceId.empty()) {
+        ZLOGE("deviceId is empty");
+        return nullptr;
+    }
+    auto isOHType = DeviceManagerAdapter::GetInstance().IsOHOSType(deviceId.deviceId);
+    SessionAccessInfo sessionAccessInfo = { .isOHType = isOHType };
+    if (isOHType && !ConfigSessionAccessInfo(extraInfo, sessionAccessInfo)) {
+        ZLOGE("peer device is not oh device or config accessInfo fail, deviceId:%{public}s", deviceId.deviceId.c_str());
+        return nullptr;
+    }
+    std::string networkId = DeviceManagerAdapter::GetInstance().ToNetworkID(deviceId.deviceId);
+    if (networkId.empty()) {
+        ZLOGE("networkId is empty, deviceId:%{public}s", deviceId.deviceId.c_str());
+        return nullptr;
+    }
+    uint32_t qosType = isOHType ? SoftBusClient::QOS_HML : SoftBusClient::QOS_BR;
+    connects_.Compute(deviceId.deviceId,
+        [&pipeInfo, &deviceId, &sessionAccessInfo, &conn, qosType, &networkId](const auto &key,
+            std::vector<std::shared_ptr<SoftBusClient>> &connects) -> bool {
+            for (auto &connect : connects) {
+                if (connect == nullptr) {
+                    continue;
+                }
+                if (connect->GetQoSType() == qosType) {
+                    conn = connect;
+                    return true;
+                }
             }
-        }
-        auto connect = std::make_shared<SoftBusClient>(pipeInfo, deviceId, networkId, qosType);
-        connects.emplace_back(connect);
-        conn = connect;
-        return true;
-    });
+            auto connect = std::make_shared<SoftBusClient>(pipeInfo, deviceId, networkId, qosType, sessionAccessInfo);
+            connects.emplace_back(connect);
+            conn = connect;
+            return true;
+        });
     return conn;
 }
 
@@ -236,7 +289,7 @@ std::pair<Status, int32_t> SoftBusAdapter::OpenConnect(const std::shared_ptr<Sof
             conn->OpenConnect(&clientListener_);
         }
     };
-    auto networkId = DmAdapter::GetInstance().GetDeviceInfo(deviceId.deviceId).networkId;
+    auto networkId = DeviceManagerAdapter::GetInstance().ToNetworkID(deviceId.deviceId);
     ConnectManager::GetInstance()->ApplyConnect(networkId, task);
     return std::make_pair(Status::RATE_LIMIT, 0);
 }
@@ -244,7 +297,7 @@ std::pair<Status, int32_t> SoftBusAdapter::OpenConnect(const std::shared_ptr<Sof
 void SoftBusAdapter::StartCloseSessionTask(const std::string &deviceId)
 {
     std::shared_ptr<SoftBusClient> conn;
-    bool isOHOSType = DmAdapter::GetInstance().IsOHOSType(deviceId);
+    bool isOHOSType = DeviceManagerAdapter::GetInstance().IsOHOSType(deviceId);
     uint32_t qosType = isOHOSType ? SoftBusClient::QOS_HML : SoftBusClient::QOS_BR;
     auto connects = connects_.Find(deviceId);
     if (!connects.first) {
@@ -263,8 +316,8 @@ void SoftBusAdapter::StartCloseSessionTask(const std::string &deviceId)
     auto expireTime = conn->GetExpireTime() > now ? conn->GetExpireTime() : now;
     lock_guard<decltype(taskMutex_)> lock(taskMutex_);
     if (taskId_ == ExecutorPool::INVALID_TASK_ID) {
-        ZLOGI("Start close session, deviceId:%{public}s", KvStoreUtils::ToBeAnonymous(deviceId).c_str());
-        taskId_ = Context::GetInstance().GetThreadPool()->Schedule(expireTime - now, GetCloseSessionTask());
+        ZLOGI("Start close session, deviceId:%{public}s", Anonymous::Change(deviceId).c_str());
+        taskId_ = CommunicatorContext::GetInstance().GetThreadPool()->Schedule(expireTime - now, GetCloseSessionTask());
         next_ = expireTime;
     }
 }
@@ -293,7 +346,8 @@ SoftBusAdapter::Task SoftBusAdapter::GetCloseSessionTask()
         });
         connects_.EraseIf([](const auto &key, const auto &conn) -> bool {
             if (conn.empty()) {
-                ConnectManager::GetInstance()->OnSessionClose(DmAdapter::GetInstance().GetDeviceInfo(key).networkId);
+                ConnectManager::GetInstance()->OnSessionClose(
+                    DeviceManagerAdapter::GetInstance().ToNetworkID(key));
             }
             return conn.empty();
         });
@@ -315,7 +369,7 @@ SoftBusAdapter::Task SoftBusAdapter::GetCloseSessionTask()
             taskId_ = ExecutorPool::INVALID_TASK_ID;
             return;
         }
-        taskId_ = Context::GetInstance().GetThreadPool()->Schedule(
+        taskId_ = CommunicatorContext::GetInstance().GetThreadPool()->Schedule(
             next > now ? next - now : ExecutorPool::INVALID_DELAY, GetCloseSessionTask());
         next_ = next;
     };
@@ -330,8 +384,8 @@ uint32_t SoftBusAdapter::GetMtuSize(const DeviceId &deviceId)
             if (conn == nullptr) {
                 continue;
             }
-            if (mtu < conn->GetMtuSize()) {
-                mtu = conn->GetMtuSize();
+            if (mtu < conn->GetMtuBuffer()) {
+                mtu = conn->GetMtuBuffer();
             }
         }
         if (mtu != 0) {
@@ -352,7 +406,7 @@ std::string SoftBusAdapter::DelConnect(int32_t socket, bool isForce)
     std::string name;
     std::set<std::string> closedConnect;
     connects_.EraseIf([socket, isForce, &name, &closedConnect](const auto &deviceId, auto &connects) -> bool {
-        if (!isForce && DmAdapter::GetInstance().IsOHOSType(deviceId)) {
+        if (!isForce && DeviceManagerAdapter::GetInstance().IsOHOSType(deviceId)) {
             return false;
         }
         std::string networkId;
@@ -387,7 +441,7 @@ bool SoftBusAdapter::IsSameStartedOnPeer(const struct PipeInfo &pipeInfo,
     __attribute__((unused)) const struct DeviceId &peer)
 {
     ZLOGI("pipeInfo:%{public}s deviceId:%{public}s", pipeInfo.pipeId.c_str(),
-        KvStoreUtils::ToBeAnonymous(peer.deviceId).c_str());
+        Anonymous::Change(peer.deviceId).c_str());
     return true;
 }
 
@@ -423,8 +477,8 @@ void SoftBusAdapter::NotifyDataListeners(const uint8_t *data, int size, const st
     auto ret = dataChangeListeners_.ComputeIfPresent(pipeInfo.pipeId,
         [&data, &size, &deviceId, &pipeInfo](const auto &key, const AppDataChangeListener *&value) {
             ZLOGD("ready to notify, pipeName:%{public}s, deviceId:%{public}s.", pipeInfo.pipeId.c_str(),
-                KvStoreUtils::ToBeAnonymous(deviceId).c_str());
-            DeviceInfo deviceInfo = DmAdapter::GetInstance().GetDeviceInfo(deviceId);
+                Anonymous::Change(deviceId).c_str());
+            DeviceInfo deviceInfo = DeviceManagerAdapter::GetInstance().GetDeviceInfo(deviceId);
             value->OnMessage(deviceInfo, data, size, pipeInfo);
             TrafficStat ts{ pipeInfo.pipeId, deviceId, 0, size };
             Reporter::GetInstance()->TrafficStatistic()->Report(ts);
@@ -452,9 +506,9 @@ Status SoftBusAdapter::Broadcast(const PipeInfo &pipeInfo, const LevelInfo &leve
 
 void SoftBusAdapter::OnBroadcast(const DeviceId &device, const LevelInfo &levelInfo)
 {
-    ZLOGI("device:%{public}s", KvStoreUtils::ToBeAnonymous(device.deviceId).c_str());
+    ZLOGI("device:%{public}s", Anonymous::Change(device.deviceId).c_str());
     if (!onBroadcast_) {
-        ZLOGW("no listener device:%{public}s", KvStoreUtils::ToBeAnonymous(device.deviceId).c_str());
+        ZLOGW("no listener device:%{public}s", Anonymous::Change(device.deviceId).c_str());
         return;
     }
     onBroadcast_(device.deviceId, levelInfo);
@@ -481,7 +535,7 @@ void AppDataListenerWrap::OnClientShutdown(int32_t socket, ShutdownReason reason
     // when the local close the session, this callback function will not be triggered;
     // when the current function is called, soft bus has released the session resource, only connId is valid;
     std::string name = softBusAdapter_->OnClientShutdown(socket);
-    ZLOGI("[shutdown] socket:%{public}d, name:%{public}s", socket, KvStoreUtils::ToBeAnonymous(name).c_str());
+    ZLOGI("[shutdown] socket:%{public}d, name:%{public}s", socket, Anonymous::Change(name).c_str());
 }
 
 void AppDataListenerWrap::OnClientBytesReceived(int32_t socket, const void *data, uint32_t dataLen) {}
@@ -490,17 +544,17 @@ void AppDataListenerWrap::OnClientSocketChanged(int32_t socket, QoSEvent eventId
 {
     if (eventId == QoSEvent::QOS_SATISFIED && qos != nullptr && qos[0].qos == QOS_TYPE_MIN_BW && qosCount == 1) {
         auto name = softBusAdapter_->OnClientShutdown(socket, false);
-        ZLOGI("[SocketChanged] socket:%{public}d, name:%{public}s", socket, KvStoreUtils::ToBeAnonymous(name).c_str());
+        ZLOGI("[SocketChanged] socket:%{public}d, name:%{public}s", socket, Anonymous::Change(name).c_str());
     }
 }
 
 void AppDataListenerWrap::OnServerBind(int32_t socket, PeerSocketInfo info)
 {
     softBusAdapter_->OnBind(socket, info);
-    std::string peerDevUuid = DmAdapter::GetInstance().GetUuidByNetworkId(std::string(info.networkId));
+    std::string peerDevUuid = DeviceManagerAdapter::GetInstance().GetUuidByNetworkId(std::string(info.networkId));
 
     ZLOGI("[OnServerBind] socket:%{public}d, peer name:%{public}s, peer devId:%{public}s", socket, info.name,
-        KvStoreUtils::ToBeAnonymous(peerDevUuid).c_str());
+        Anonymous::Change(peerDevUuid).c_str());
 }
 
 void AppDataListenerWrap::OnServerShutdown(int32_t socket, ShutdownReason reason)
@@ -516,9 +570,9 @@ void AppDataListenerWrap::OnServerBytesReceived(int32_t socket, const void *data
         ZLOGE("Get peer socket info failed, socket id %{public}d", socket);
         return;
     };
-    std::string peerDevUuid = DmAdapter::GetInstance().GetUuidByNetworkId(std::string(info.networkId));
+    std::string peerDevUuid = DeviceManagerAdapter::GetInstance().GetUuidByNetworkId(std::string(info.networkId));
     ZLOGD("[OnBytesReceived] socket:%{public}d, peer name:%{public}s, peer devId:%{public}s, data len:%{public}u",
-        socket, info.name.c_str(), KvStoreUtils::ToBeAnonymous(peerDevUuid).c_str(), dataLen);
+        socket, info.name.c_str(), Anonymous::Change(peerDevUuid).c_str(), dataLen);
 
     std::string pipeId = GetPipeId(info.name);
     if (pipeId.empty()) {
@@ -529,6 +583,71 @@ void AppDataListenerWrap::OnServerBytesReceived(int32_t socket, const void *data
     NotifyDataListeners(reinterpret_cast<const uint8_t *>(data), dataLen, peerDevUuid, { pipeId, "" });
 }
 
+std::pair<bool, StoreMetaData> AppDataListenerWrap::LoadMetaData(const std::string &bundleName, const std::string &storeId,
+    int32_t userId)
+{
+    StoreMetaData metaData;
+    metaData.deviceId = DeviceManagerAdapter::GetInstance().GetLocalDevice().uuid;
+    metaData.bundleName = bundleName;
+    metaData.storeId = storeId;
+    metaData.user = std::to_string(userId);
+    auto ret = MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData);
+    if (!ret) {
+        metaData.user = SYSTEM_USERID;
+        ret = MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData);
+    }
+    return { ret, metaData };
+}
+
+bool AppDataListenerWrap::OnServerAccessCheck(int32_t socket, PeerSocketInfo info, SocketAccessInfo *peerInfo,
+    SocketAccessInfo *localInfo)
+{
+    ZLOGI("receive bind request, socket:%{public}d", socket);
+    if (peerInfo == nullptr || localInfo == nullptr) {
+        ZLOGE("peerInfo or localInfo is nullptr, peerInfo:%{public}d, localInfo:%{public}d", peerInfo == nullptr,
+            localInfo == nullptr);
+        return false;
+    }
+    SoftBusClient::AccessExtraInfo peerExtraInfo;
+    if (!DistributedData::Serializable::Unmarshall(peerInfo->extraAccessInfo, peerExtraInfo)) {
+        ZLOGE("Unmarshall failed, peer extraAccessInfo:%{public}s", peerInfo->extraAccessInfo);
+        return false;
+    }
+    int foregroundUserId = 0;
+    if (!AccountDelegate::GetInstance()->QueryForegroundUserId(foregroundUserId)) {
+        return false;
+    }
+    auto localAccountId = AccountDelegate::GetInstance()->GetCurrentAccountId();
+    if (localAccountId.empty()) {
+        return false;
+    }
+    auto resultPair = LoadMetaData(peerExtraInfo.bundleName, peerExtraInfo.storeId, foregroundUserId);
+    if (!resultPair.first) {
+        ZLOGE("local device has no store, bundleName:%{public}s", peerExtraInfo.bundleName.c_str());
+        return false;
+    }
+    AclParams aclParams;
+    aclParams.accCaller.bundleName = peerExtraInfo.bundleName;
+    aclParams.accCaller.accountId = localAccountId;
+    aclParams.accCaller.userId = foregroundUserId;
+    aclParams.accCaller.networkId = DeviceManagerAdapter::GetInstance().GetLocalDevice().networkId;
+    aclParams.accCallee.accountId = peerExtraInfo.accountId;
+    aclParams.accCallee.userId = peerInfo->userId;
+    aclParams.accCallee.networkId = info.networkId;
+    bool accessFlag = false;
+    if (resultPair.second.authType == 0) {
+        accessFlag = DeviceManagerAdapter::GetInstance().CheckAccessControl(aclParams.accCaller, aclParams.accCallee);
+    } else {
+        accessFlag = DeviceManagerAdapter::GetInstance().IsSameAccount(aclParams.accCaller, aclParams.accCallee);
+    }
+    if (!accessFlag) {
+        return false;
+    }
+    localInfo->userId = foregroundUserId;
+    localInfo->localTokenId = resultPair.second.tokenId;
+    return true;
+}
+
 std::string AppDataListenerWrap::GetPipeId(const std::string &name)
 {
     auto pos = name.find('_');
@@ -576,7 +695,7 @@ void SoftBusAdapter::OnDeviceChanged(const AppDistributedKv::DeviceInfo &info,
 
 bool SoftBusAdapter::CloseSession(const std::string &networkId)
 {
-    auto uuid = DmAdapter::GetInstance().GetUuidByNetworkId(networkId);
+    auto uuid = DeviceManagerAdapter::GetInstance().GetUuidByNetworkId(networkId);
     auto ret = connects_.Erase(uuid);
     if (ret != 0) {
         ConnectManager::GetInstance()->OnSessionClose(networkId);
@@ -586,12 +705,7 @@ bool SoftBusAdapter::CloseSession(const std::string &networkId)
 
 Status SoftBusAdapter::ReuseConnect(const PipeInfo &pipeInfo, const DeviceId &deviceId)
 {
-    bool isOHOSType = DmAdapter::GetInstance().IsOHOSType(deviceId.deviceId);
-    if (!isOHOSType) {
-        return Status::NOT_SUPPORT;
-    }
-    uint32_t qosType = SoftBusClient::QOS_HML;
-    std::shared_ptr<SoftBusClient> conn = GetConnect(pipeInfo, deviceId, qosType);
+    std::shared_ptr<SoftBusClient> conn = GetConnect(pipeInfo, deviceId);
     if (conn == nullptr) {
         return Status::ERROR;
     }
@@ -599,6 +713,11 @@ Status SoftBusAdapter::ReuseConnect(const PipeInfo &pipeInfo, const DeviceId &de
     if (status != Status::SUCCESS) {
         return status;
     }
+    bool isOHOSType = DeviceManagerAdapter::GetInstance().IsOHOSType(deviceId.deviceId);
+    if (!isOHOSType) {
+        return Status::NOT_SUPPORT;
+    }
+    uint32_t qosType = SoftBusClient::QOS_HML;
     // Avoid being cleared by scheduled tasks
     connects_.Compute(deviceId.deviceId, [&conn, qosType](const auto &key,
         std::vector<std::shared_ptr<SoftBusClient>> &connects) -> bool {
diff --git a/services/distributeddataservice/adapter/communicator/src/softbus_client.cpp b/services/distributeddataservice/adapter/communicator/src/softbus_client.cpp
index 23c8c79167f5735c46c620a3d592cda106bede2b..e7e65ec79f1b99bbd210a40729034eb26980edaa 100644
--- a/services/distributeddataservice/adapter/communicator/src/softbus_client.cpp
+++ b/services/distributeddataservice/adapter/communicator/src/softbus_client.cpp
@@ -14,30 +14,33 @@
  */
 
 #define LOG_TAG "SoftBusClient"
+
 #include "softbus_client.h"
 
 #include "communicator_context.h"
 #include "communication/connect_manager.h"
-#include "device_manager_adapter.h"
 #include "inner_socket.h"
-#include "kvstore_utils.h"
 #include "log_print.h"
 #include "softbus_error_code.h"
+#include "utils/anonymous.h"
 
 namespace OHOS::AppDistributedKv {
 using namespace OHOS::DistributedKv;
-using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
-using Context = DistributedData::CommunicatorContext;
+using namespace OHOS::DistributedData;
 SoftBusClient::SoftBusClient(const PipeInfo& pipeInfo, const DeviceId& deviceId, const std::string& networkId,
-    uint32_t type) : type_(type), pipe_(pipeInfo), device_(deviceId), networkId_(networkId)
+    uint32_t type, const SessionAccessInfo &accessInfo)
 {
+    pipe_ = pipeInfo;
+    device_ = deviceId;
+    networkId_ = networkId;
+    accessInfo_ = accessInfo;
+    type_ = type;
     mtu_ = DEFAULT_MTU_SIZE;
 }
 
 SoftBusClient::~SoftBusClient()
 {
-    ZLOGI("Shutdown socket:%{public}d, deviceId:%{public}s", socket_,
-        KvStoreUtils::ToBeAnonymous(device_.deviceId).c_str());
+    ZLOGI("Shutdown socket:%{public}d, deviceId:%{public}s", socket_, Anonymous::Change(device_.deviceId).c_str());
     if (socket_ > 0) {
         Shutdown(socket_);
     }
@@ -53,7 +56,7 @@ bool SoftBusClient::operator==(const std::string &deviceId) const
     return device_.deviceId == deviceId;
 }
 
-uint32_t SoftBusClient::GetMtuSize() const
+uint32_t SoftBusClient::GetMtuBuffer() const
 {
     ZLOGD("get mtu size socket:%{public}d mtu:%{public}d", socket_, mtu_);
     return mtu_;
@@ -64,7 +67,7 @@ uint32_t SoftBusClient::GetTimeout() const
     return DEFAULT_TIMEOUT;
 }
 
-Status SoftBusClient::SendData(const DataInfo &dataInfo, const ISocketListener *listener)
+Status SoftBusClient::SendData(const DataInfo &dataInfo)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     auto result = CheckStatus();
@@ -84,7 +87,7 @@ Status SoftBusClient::SendData(const DataInfo &dataInfo, const ISocketListener *
     return Status::SUCCESS;
 }
 
-int32_t SoftBusClient::GetSoftBusError()
+int32_t SoftBusClient::GetSoftBusError() const
 {
     std::lock_guard<std::mutex> lock(mutex_);
     return softBusError_;
@@ -111,12 +114,12 @@ Status SoftBusClient::OpenConnect(const ISocketListener *listener)
             return;
         }
         ZLOGI("Bind Start, device:%{public}s socket:%{public}d type:%{public}u",
-            KvStoreUtils::ToBeAnonymous(client->device_.deviceId).c_str(), clientSocket, type);
+            Anonymous::Change(client->device_.deviceId).c_str(), clientSocket, type);
         int32_t status = client->Open(clientSocket, type, listener);
-        Context::GetInstance().NotifySessionReady(client->device_.deviceId, status);
+        CommunicatorContext::GetInstance().NotifySessionReady(client->device_.deviceId, status);
         client->isOpening_.store(false);
     };
-    Context::GetInstance().GetThreadPool()->Execute(task);
+    CommunicatorContext::GetInstance().GetThreadPool()->Execute(task);
     return Status::RATE_LIMIT;
 }
 
@@ -134,6 +137,25 @@ int32_t SoftBusClient::CreateSocket() const
     int32_t socket = Socket(socketInfo);
     if (socket <= 0) {
         ZLOGE("Create the client Socket:%{public}d failed, peerName:%{public}s", socket, socketInfo.peerName);
+        return socket;
+    }
+    if (accessInfo_.isOHType) {
+        SocketAccessInfo info;
+        info.userId = accessInfo_.userId;
+        info.localTokenId = accessInfo_.tokenId;
+        AccessExtraInfo extraInfo;
+        extraInfo.bundleName = accessInfo_.bundleName;
+        extraInfo.accountId = accessInfo_.accountId;
+        extraInfo.storeId = accessInfo_.storeId;
+        std::string extraInfoStr = Serializable::Marshall(extraInfo);
+        info.extraAccessInfo = const_cast<char *>(extraInfoStr.c_str());
+        auto status = SetAccessInfo(socket, info);
+        if (status != 0) {
+            ZLOGE("SetAccessInfo fail, status:%{public}d, userId:%{public}d, tokenId:%{public}lu,"
+              "bundleName:%{public}s, accountId:%{public}s, storeId:%{public}s", status, info.userId, info.localTokenId,
+              extraInfo.bundleName.c_str(), extraInfo.accountId.c_str(), Anonymous::Change(extraInfo.storeId).c_str());
+            return -1;
+        }
     }
     return socket;
 }
@@ -154,28 +176,28 @@ Status SoftBusClient::CheckStatus()
 
 int32_t SoftBusClient::Open(int32_t socket, uint32_t type, const ISocketListener *listener, bool async)
 {
-    int32_t status = ::Bind(socket, QOS_INFOS[type % QOS_BUTT], QOS_COUNTS[type % QOS_BUTT], listener);
-    ZLOGI("Bind %{public}s,session:%{public}s,socketId:%{public}d",
-        KvStoreUtils::ToBeAnonymous(device_.deviceId).c_str(), pipe_.pipeId.c_str(), socket);
+    int32_t status = Bind(socket, QOS_INFOS[type % QOS_BUTT], QOS_COUNTS[type % QOS_BUTT], listener);
+    ZLOGI("Bind %{public}s,session:%{public}s,socketId:%{public}d", Anonymous::Change(device_.deviceId).c_str(),
+        pipe_.pipeId.c_str(), socket);
 
     if (status != 0) {
         ZLOGE("[Bind] device:%{public}s socket failed, session:%{public}s,result:%{public}d",
-            KvStoreUtils::ToBeAnonymous(device_.deviceId).c_str(), pipe_.pipeId.c_str(), status);
-        ::Shutdown(socket);
+            Anonymous::Change(device_.deviceId).c_str(), pipe_.pipeId.c_str(), status);
+        Shutdown(socket);
         return status;
     }
     UpdateExpireTime(async);
     uint32_t mtu = 0;
     std::tie(status, mtu) = GetMtu(socket);
-    if (status != SOFTBUS_OK) {
+    if (status != 0) {
         ZLOGE("GetMtu failed, session:%{public}s, socket:%{public}d, status:%{public}d", pipe_.pipeId.c_str(), socket_,
             status);
-        ::Shutdown(socket);
+        Shutdown(socket);
         return status;
     }
     UpdateBindInfo(socket, mtu, status, async);
-    ZLOGI("open %{public}s, session:%{public}s success, socket:%{public}d",
-        KvStoreUtils::ToBeAnonymous(device_.deviceId).c_str(), pipe_.pipeId.c_str(), socket_);
+    ZLOGI("open %{public}s, session:%{public}s success, socket:%{public}d", Anonymous::Change(device_.deviceId).c_str(),
+        pipe_.pipeId.c_str(), socket_);
     ConnectManager::GetInstance()->OnSessionOpen(networkId_);
     return status;
 }
@@ -223,7 +245,7 @@ void SoftBusClient::UpdateBindInfo(int32_t socket, uint32_t mtu, int32_t status,
 std::pair<int32_t, uint32_t> SoftBusClient::GetMtu(int32_t socket)
 {
     uint32_t mtu = 0;
-    auto ret = ::GetMtuSize(socket, &mtu);
+    auto ret = GetMtuSize(socket, &mtu);
     return { ret, mtu };
 }
 
@@ -251,12 +273,12 @@ Status SoftBusClient::ReuseConnect(const ISocketListener *listener)
         return Status::NETWORK_ERROR;
     }
     ZLOGI("Reuse Start, device:%{public}s session:%{public}s socket:%{public}d",
-        KvStoreUtils::ToBeAnonymous(device_.deviceId).c_str(), pipe_.pipeId.c_str(), socket);
+        Anonymous::Change(device_.deviceId).c_str(), pipe_.pipeId.c_str(), socket);
     int32_t status = Open(socket, QOS_REUSE, listener, false);
     return status == SOFTBUS_OK ? Status::SUCCESS : Status::NETWORK_ERROR;
 }
 
-const std::string& SoftBusClient::GetNetworkId() const
+std::string SoftBusClient::GetNetworkId() const
 {
     return networkId_;
 }
diff --git a/services/distributeddataservice/adapter/communicator/src/softbus_client.h b/services/distributeddataservice/adapter/communicator/src/softbus_client.h
index a0196c94f3203f1475bb84c3c5c111e4dbc6ee31..5363f8192aee51bac4f61d3ea7e721fde1ead0e4 100644
--- a/services/distributeddataservice/adapter/communicator/src/softbus_client.h
+++ b/services/distributeddataservice/adapter/communicator/src/softbus_client.h
@@ -17,42 +17,68 @@
 #define DISTRIBUTEDDATAMGR_DATAMGR_SERVICE_SOFTBUS_CLIENT_H
 
 #include <atomic>
-#include <map>
 #include <mutex>
 
 #include "commu_types.h"
-#include "executor_pool.h"
+#include "serializable/serializable.h"
 #include "socket.h"
-#include "softbus_bus_center.h"
+
 namespace OHOS::AppDistributedKv {
 class SoftBusClient : public std::enable_shared_from_this<SoftBusClient> {
 public:
+    struct AccessExtraInfo final : public DistributedData::Serializable {
+        std::string bundleName = "";
+        std::string accountId = "";
+        std::string storeId = "";
+
+        AccessExtraInfo() {};
+        ~AccessExtraInfo() {};
+        bool Marshal(json &node) const override
+        {
+            SetValue(node[GET_NAME(bundleName)], bundleName);
+            SetValue(node[GET_NAME(accountId)], accountId);
+            SetValue(node[GET_NAME(storeId)], storeId);
+            return true;
+        };
+        bool Unmarshal(const json &node) override
+        {
+            GetValue(node, GET_NAME(bundleName), bundleName);
+            GetValue(node, GET_NAME(accountId), accountId);
+            GetValue(node, GET_NAME(storeId), storeId);
+            return true;
+        };
+    };
+
     enum QoSType {
         QOS_BR,
         QOS_HML,
         QOS_REUSE,
         QOS_BUTT
     };
+
     SoftBusClient(const PipeInfo &pipeInfo, const DeviceId &deviceId, const std::string& networkId,
-        uint32_t type = QOS_HML);
+        uint32_t type = QOS_HML, const SessionAccessInfo &accessInfo = {});
     ~SoftBusClient();
 
     using Time = std::chrono::steady_clock::time_point;
     using Duration = std::chrono::steady_clock::duration;
-    Status CheckStatus();
-    Status OpenConnect(const ISocketListener *listener);
-    Status SendData(const DataInfo &dataInfo, const ISocketListener *listener);
+
     bool operator==(int32_t socket) const;
     bool operator==(const std::string &deviceId) const;
-    uint32_t GetMtuSize() const;
-    uint32_t GetTimeout() const;
+
+    Status CheckStatus();
+    Status OpenConnect(const ISocketListener *listener);
+    Status ReuseConnect(const ISocketListener *listener);
+    Status SendData(const DataInfo &dataInfo);
+    void UpdateExpireTime(bool async = true);
     Time GetExpireTime() const;
+
     int32_t GetSocket() const;
     uint32_t GetQoSType() const;
-    void UpdateExpireTime(bool async = true);
-    int32_t GetSoftBusError();
-    Status ReuseConnect(const ISocketListener *listener);
-    const std::string& GetNetworkId() const;
+    uint32_t GetMtuBuffer() const;
+    uint32_t GetTimeout() const;
+    int32_t GetSoftBusError() const;
+    std::string GetNetworkId() const;
 
 private:
     int32_t Open(int32_t socket, uint32_t type, const ISocketListener *listener, bool async = true);
@@ -91,14 +117,14 @@ private:
     uint32_t type_ = QOS_HML;
     PipeInfo pipe_;
     DeviceId device_;
+    std::string networkId_;
+    SessionAccessInfo accessInfo_;
     uint32_t mtu_;
     Time expireTime_ = std::chrono::steady_clock::now() + MAX_DELAY;
 
     int32_t socket_ = INVALID_SOCKET_ID;
     int32_t bindState_ = -1;
     int32_t softBusError_ = 0;
-    const std::string networkId_;
 };
 } // namespace OHOS::AppDistributedKv
-
 #endif // DISTRIBUTEDDATAMGR_DATAMGR_SERVICE_SOFTBUS_CLIENT_H
\ No newline at end of file