diff --git a/BUILD.gn b/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..4e262743dd640165d7de1ea5031b9743cabd5a46
--- /dev/null
+++ b/BUILD.gn
@@ -0,0 +1,34 @@
+# Copyright (C) 2021 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.
+
+import("//build/ohos.gni")
+
+group("accesstoken_build_module_standard") {
+  if (is_standard_system) {
+    deps = [
+      "//base/security/access_token/interfaces/innerkits/accesstoken:libaccesstoken_sdk",
+      "//base/security/access_token/services/accesstoken:accesstoken_manager_service",
+      "//base/security/access_token/services/accesstoken/main/sa_profile:accesstoken_sa_profile_standard",
+    ]
+  }
+}
+
+group("accesstoken_build_module_standard_test") {
+  testonly = true
+  deps = []
+  if (is_standard_system) {
+    deps += [
+      "//base/security/access_token/interfaces/innerkits/accesstoken/test:unittest",
+    ]
+  }
+}
\ No newline at end of file
diff --git a/frameworks/accesstoken/accesstoken_log.h b/frameworks/accesstoken/accesstoken_log.h
new file mode 100644
index 0000000000000000000000000000000000000000..9435908dd840dc20a8fdf3738a87b7fd312ec903
--- /dev/null
+++ b/frameworks/accesstoken/accesstoken_log.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2021 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 ACCESSTOKEN_LOG_H
+#define ACCESSTOKEN_LOG_H
+
+#ifdef HILOG_ENABLE
+
+#include "hilog/log.h"
+
+#ifndef __cplusplus
+
+#define ACCESSTOKEN_LOG_DEBUG(fmt, ...) HILOG_DEBUG(LOG_CORE, fmt, ##__VA_ARGS__)
+#define ACCESSTOKEN_LOG_INFO(fmt, ...) HILOG_INFO(LOG_CORE, fmt, ##__VA_ARGS__)
+#define ACCESSTOKEN_LOG_WARN(fmt, ...) HILOG_WARN(LOG_CORE, fmt, ##__VA_ARGS__)
+#define ACCESSTOKEN_LOG_ERROR(fmt, ...) HILOG_ERROR(LOG_CORE, fmt, ##__VA_ARGS__)
+#define ACCESSTOKEN_LOG_FATAL(fmt, ...) HILOG_FATAL(LOG_CORE, fmt, ##__VA_ARGS__)
+
+#else
+
+#define ACCESSTOKEN_LOG_DEBUG(label, fmt, ...) OHOS::HiviewDFX::HiLog::Debug(label, fmt, ##__VA_ARGS__)
+#define ACCESSTOKEN_LOG_INFO(label, fmt, ...) OHOS::HiviewDFX::HiLog::Info(label, fmt, ##__VA_ARGS__)
+#define ACCESSTOKEN_LOG_WARN(label, fmt, ...) OHOS::HiviewDFX::HiLog::Warn(label, fmt, ##__VA_ARGS__)
+#define ACCESSTOKEN_LOG_ERROR(label, fmt, ...) OHOS::HiviewDFX::HiLog::Error(label, fmt, ##__VA_ARGS__)
+#define ACCESSTOKEN_LOG_FATAL(label, fmt, ...) OHOS::HiviewDFX::HiLog::Fatal(label, fmt, ##__VA_ARGS__)
+
+#endif  // __cplusplus
+
+/* define LOG_TAG as "security_*" at your submodule, * means your submodule name such as "security_dac" */
+#undef LOG_TAG
+#undef LOG_DOMAIN
+
+static constexpr unsigned int SECURITY_DOMAIN_ACCESSTOKEN = 0xD002F01;
+
+#else
+
+#include <stdarg.h>
+#include <stdio.h>
+
+/* define LOG_TAG as "security_*" at your submodule, * means your submodule name such as "security_dac" */
+#undef LOG_TAG
+
+#define ACCESSTOKEN_LOG_DEBUG(fmt, ...) printf("[%s] debug: %s: " fmt "\n", LOG_TAG, __func__, ##__VA_ARGS__)
+#define ACCESSTOKEN_LOG_INFO(fmt, ...) printf("[%s] info: %s: " fmt "\n", LOG_TAG, __func__, ##__VA_ARGS__)
+#define ACCESSTOKEN_LOG_WARN(fmt, ...) printf("[%s] warn: %s: " fmt "\n", LOG_TAG, __func__, ##__VA_ARGS__)
+#define ACCESSTOKEN_LOG_ERROR(fmt, ...) printf("[%s] error: %s: " fmt "\n", LOG_TAG, __func__, ##__VA_ARGS__)
+#define ACCESSTOKEN_LOG_FATAL(fmt, ...) printf("[%s] fatal: %s: " fmt "\n", LOG_TAG, __func__, ##__VA_ARGS__)
+
+#endif  // HILOG_ENABLE
+
+#endif  // ACCESSTOKEN_LOG_H
diff --git a/frameworks/accesstoken/i_accesstoken_manager.h b/frameworks/accesstoken/i_accesstoken_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..e3774c8a41ce8f5364bb413ccc7a229bf21a4f5c
--- /dev/null
+++ b/frameworks/accesstoken/i_accesstoken_manager.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2021 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 I_ACCESSTOKEN_MANAGER_H
+#define I_ACCESSTOKEN_MANAGER_H
+
+#include <string>
+#include "iremote_broker.h"
+#include "errors.h"
+
+#include "accesstoken.h"
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+class IAccessTokenManager : public IRemoteBroker {
+public:
+    static const int SA_ID_ACCESSTOKEN_MANAGER_SERVICE = 3503;
+
+    DECLARE_INTERFACE_DESCRIPTOR(u"ohos.security.accesstoken.IAccessTokennManager");
+
+    virtual int VerifyAccesstoken(AccessTokenID tokenID, const std::string &permissionName) = 0;
+
+    enum class InterfaceCode {
+        VERIFY_ACCESSTOKEN = 0xff01,
+    };
+};
+}  // namespace AccessToken
+}  // namespace Security
+}  // namespace OHOS
+
+#endif  // I_ACCESSTOKEN_MANAGER_H
diff --git a/interfaces/innerkits/accesstoken/BUILD.gn b/interfaces/innerkits/accesstoken/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..2cc576843c7f6a990473d776dec065d9a24188c8
--- /dev/null
+++ b/interfaces/innerkits/accesstoken/BUILD.gn
@@ -0,0 +1,59 @@
+# Copyright (C) 2021 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.
+
+import("//build/ohos.gni")
+
+################################################################
+# C++, Main, source file here.
+################################################################
+config("accesstoken_sdk_cxx_public_config_standard") {
+  visibility = [ ":*" ]
+  include_dirs = [ "main/cpp/include" ]
+}
+
+ohos_shared_library("libaccesstoken_sdk") {
+  subsystem_name = "security"
+  part_name = "access_token"
+
+  output_name = "libaccesstoken_sdk"
+
+  public_configs = [ ":accesstoken_sdk_cxx_public_config_standard" ]
+
+  include_dirs = [
+    "//utils/native/base/include",
+    "main/cpp/include",
+    "main/cpp/src",
+    "//base/security/access_token/frameworks/accesstoken",
+    "//base/security/access_token/nterfaces/innerkits/accesstoken/main/cpp/include",
+  ]
+
+  sources = [
+    "main/cpp/src/accesstoken_kit.cpp",
+    "main/cpp/src/accesstoken_manager_client.cpp",
+    "main/cpp/src/accesstoken_manager_proxy.cpp",
+  ]
+
+  deps = [
+    "//base/security/permission/frameworks/permission_standard/permissioncommunicationadapter:permission_standard_communication_adapter_cxx",
+    "//base/security/permission/frameworks/permission_standard/permissioninfrastructure:permission_standard_infrastructure_cxx",
+    "//utils/native/base:utils",
+  ]
+
+  external_deps = [
+    "hiviewdfx_hilog_native:libhilog",
+    "ipc:ipc_core",
+    "samgr_standard:samgr_proxy",
+  ]
+
+  cflags_cc = [ "-DHILOG_ENABLE" ]
+}
diff --git a/interfaces/innerkits/accesstoken/main/cpp/include/accesstoken.h b/interfaces/innerkits/accesstoken/main/cpp/include/accesstoken.h
new file mode 100644
index 0000000000000000000000000000000000000000..f0084d34728248555694e1f359ed659f7a6f43b2
--- /dev/null
+++ b/interfaces/innerkits/accesstoken/main/cpp/include/accesstoken.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2021 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 INTERFACES_INNER_KITS_ACCESSTOKEN_H
+#define INTERFACES_INNER_KITS_ACCESSTOKEN_H
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+typedef unsigned int AccessTokenID;
+enum AccessTokenKitRet {
+    RET_FAILED = -1,
+    RET_SUCCESS = 0,
+};
+
+typedef enum TypePermissionState {
+    PERMISSION_DENIED = -1,
+    PERMISSION_GRANTED = 0,
+} PermissionState;
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
+
+#endif
diff --git a/interfaces/innerkits/accesstoken/main/cpp/include/accesstoken_kit.h b/interfaces/innerkits/accesstoken/main/cpp/include/accesstoken_kit.h
new file mode 100644
index 0000000000000000000000000000000000000000..22fedd97a90f46c80ed4b1c0e784c90b8464b5c1
--- /dev/null
+++ b/interfaces/innerkits/accesstoken/main/cpp/include/accesstoken_kit.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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 INTERFACES_INNER_KITS_ACCESSTOKEN_KIT_H
+#define INTERFACES_INNER_KITS_ACCESSTOKEN_KIT_H
+
+#include <string>
+#include "accesstoken.h"
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+class AccessTokenKit {
+public:
+    static int VerifyAccesstoken(AccessTokenID tokenID, const std::string& permissionName);
+};
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
+#endif
diff --git a/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_kit.cpp b/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_kit.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1e0e8e06e7bc66a3c83dd00cbc9a4a2b9a6409a5
--- /dev/null
+++ b/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_kit.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2021 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 "accesstoken_kit.h"
+
+#include <string>
+#include <vector>
+
+#include "accesstoken_log.h"
+#include "accesstoken_manager_client.h"
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+using namespace std;
+
+namespace {
+static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "AccessTokenKit"};
+} // namespace
+
+int AccessTokenKit::VerifyAccesstoken(AccessTokenID tokenID, const std::string &permissionName)
+{
+    ACCESSTOKEN_LOG_INFO(LABEL, "%{public}s called", __func__);
+    ACCESSTOKEN_LOG_INFO(LABEL, "tokenID=%{public}d, permissionName=%{public}s",
+        tokenID, permissionName.c_str());
+    return AccessTokenManagerClient::GetInstance().VerifyAccesstoken(tokenID, permissionName);
+}
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_manager_client.cpp b/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_manager_client.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a5de7d88eb882295421bdda5b6bed135a87ca48d
--- /dev/null
+++ b/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_manager_client.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2021 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 "accesstoken_manager_client.h"
+
+#include "accesstoken_log.h"
+
+#include "iservice_registry.h"
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+namespace {
+static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
+    LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "AccessTokenManagerClient"
+};
+} // namespace
+
+AccessTokenManagerClient& AccessTokenManagerClient::GetInstance()
+{
+    static AccessTokenManagerClient instance;
+    return instance;
+}
+
+AccessTokenManagerClient::AccessTokenManagerClient()
+{}
+
+AccessTokenManagerClient::~AccessTokenManagerClient()
+{}
+
+int AccessTokenManagerClient::VerifyAccesstoken(AccessTokenID tokenID, const std::string& permissionName) const
+{
+    ACCESSTOKEN_LOG_DEBUG(LABEL, "%{public}s: called!", __func__);
+    auto proxy = GetProxy();
+    if (proxy == nullptr) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "%{public}s: proxy is null", __func__);
+        return PERMISSION_DENIED;
+    }
+    return proxy->VerifyAccesstoken(tokenID, permissionName);
+}
+
+sptr<IAccessTokenManager> AccessTokenManagerClient::GetProxy() const
+{
+    auto sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (sam == nullptr) {
+        ACCESSTOKEN_LOG_DEBUG(LABEL, "%{public}s: GetSystemAbilityManager is null", __func__);
+        return nullptr;
+    }
+    auto accesstokenSa = sam->GetSystemAbility(IAccessTokenManager::SA_ID_ACCESSTOKEN_MANAGER_SERVICE);
+    if (accesstokenSa == nullptr) {
+        ACCESSTOKEN_LOG_DEBUG(LABEL, "%{public}s: GetSystemAbility %{public}d is null", __func__,
+            IAccessTokenManager::SA_ID_ACCESSTOKEN_MANAGER_SERVICE);
+        return nullptr;
+    }
+
+    auto proxy = iface_cast<IAccessTokenManager>(accesstokenSa);
+    if (proxy == nullptr) {
+        ACCESSTOKEN_LOG_DEBUG(LABEL, "%{public}s: iface_cast get null", __func__);
+        return nullptr;
+    }
+    return proxy;
+}
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_manager_client.h b/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_manager_client.h
new file mode 100755
index 0000000000000000000000000000000000000000..758e6f59845c8e89cb35b70631ef84390d8efa91
--- /dev/null
+++ b/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_manager_client.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2021 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 ACCESSTOKEN_MANAGER_CLIENT_H
+#define ACCESSTOKEN_MANAGER_CLIENT_H
+
+#include <string>
+
+#include "i_accesstoken_manager.h"
+#include "nocopyable.h"
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+class AccessTokenManagerClient final {
+public:
+    static AccessTokenManagerClient& GetInstance();
+
+    virtual ~AccessTokenManagerClient();
+
+    int VerifyAccesstoken(AccessTokenID tokenID, const std::string& permissionName) const;
+private:
+    AccessTokenManagerClient();
+
+    DISALLOW_COPY_AND_MOVE(AccessTokenManagerClient);
+
+    sptr<IAccessTokenManager> GetProxy() const;
+};
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
+#endif // ACCESSTOKEN_MANAGER_CLIENT_H
diff --git a/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_manager_proxy.cpp b/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_manager_proxy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ce8d6ec7f793bf28900da3a21276e24233863a88
--- /dev/null
+++ b/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_manager_proxy.cpp
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2021 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 "accesstoken_manager_proxy.h"
+
+#include "accesstoken_log.h"
+
+#include "parcel.h"
+#include "string_ex.h"
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+namespace {
+static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "AccessTokenManagerProxy"};
+}
+
+AccessTokenManagerProxy::AccessTokenManagerProxy(const sptr<IRemoteObject>& impl)
+    : IRemoteProxy<IAccessTokenManager>(impl)
+{}
+
+AccessTokenManagerProxy::~AccessTokenManagerProxy()
+{}
+
+int AccessTokenManagerProxy::VerifyAccesstoken(AccessTokenID tokenID, const std::string& permissionName)
+{
+    MessageParcel data;
+    data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor());
+    if (!data.WriteUint32(tokenID)) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "%{public}s: Failed to write tokenID", __func__);
+        return PERMISSION_DENIED;
+    }
+    if (!data.WriteString(permissionName)) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "%{public}s: Failed to write permissionName", __func__);
+        return PERMISSION_DENIED;
+    }
+
+    MessageParcel reply;
+    MessageOption option;
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "%{public}s: remote service null.", __func__);
+        return PERMISSION_DENIED;
+    }
+    int32_t requestResult = remote->SendRequest(
+        static_cast<uint32_t>(IAccessTokenManager::InterfaceCode::VERIFY_ACCESSTOKEN), data, reply, option);
+    if (requestResult != NO_ERROR) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "%{public}s send request fail, result: %{public}d", __func__, requestResult);
+        return PERMISSION_DENIED;
+    }
+
+    int32_t result = reply.ReadInt32();
+    ACCESSTOKEN_LOG_DEBUG(LABEL, "%{public}s get result from server data = %{public}d", __func__, result);
+    return result;
+}
+
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_manager_proxy.h b/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_manager_proxy.h
new file mode 100644
index 0000000000000000000000000000000000000000..e0c99c62dc48c7f9c5f9b51106077cb0d4e33a64
--- /dev/null
+++ b/interfaces/innerkits/accesstoken/main/cpp/src/accesstoken_manager_proxy.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2021 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 ACCESSTOKEN_MANAGER_PROXY_H
+#define ACCESSTOKEN_MANAGER_PROXY_H
+
+#include "i_accesstoken_manager.h"
+
+#include "iremote_proxy.h"
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+class AccessTokenManagerProxy : public IRemoteProxy<IAccessTokenManager> {
+public:
+    explicit AccessTokenManagerProxy(const sptr<IRemoteObject>& impl);
+    virtual ~AccessTokenManagerProxy() override;
+
+    int VerifyAccesstoken(AccessTokenID tokenID, const std::string& permissionName) override;
+private:
+    static inline BrokerDelegator<AccessTokenManagerProxy> delegator_;
+};
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
+#endif // ACCESSTOKEN_MANAGER_PROXY_H
diff --git a/interfaces/innerkits/accesstoken/test/BUILD.gn b/interfaces/innerkits/accesstoken/test/BUILD.gn
new file mode 100755
index 0000000000000000000000000000000000000000..a61294493aa5b096203ec73b1f644abca06eb99a
--- /dev/null
+++ b/interfaces/innerkits/accesstoken/test/BUILD.gn
@@ -0,0 +1,39 @@
+# Copyright (C) 2021 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.
+
+import("//build/test.gni")
+
+ohos_unittest("libaccesstoken_sdk_test") {
+  subsystem_name = "security"
+  part_name = "access_token"
+  module_out_path = part_name + "/" + part_name
+
+  include_dirs = [
+    "//utils/native/base/include",
+    "//base/security/access_token/interfaces/innerkits/accesstoken/main/cpp/include/",
+  ]
+
+  sources = [ "unittest/cpp/src/accesstoken_kit_test.cpp" ]
+
+  cflags_cc = [ "-DHILOG_ENABLE" ]
+
+  deps = [
+    "//base/security/access_token/interfaces/innerkits/accesstoken:libaccesstoken_sdk",
+    "//utils/native/base:utils",
+  ]
+}
+
+group("unittest") {
+  testonly = true
+  deps = [ ":libaccesstoken_sdk_test" ]
+}
diff --git a/interfaces/innerkits/accesstoken/test/unittest/cpp/src/accesstoken_kit_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/cpp/src/accesstoken_kit_test.cpp
new file mode 100755
index 0000000000000000000000000000000000000000..7fbf82406a97720a7a04c6b8de520cacbc67b662
--- /dev/null
+++ b/interfaces/innerkits/accesstoken/test/unittest/cpp/src/accesstoken_kit_test.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2021 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 "accesstoken_kit_test.h"
+
+#include "accesstoken_kit.h"
+
+using namespace testing::ext;
+using namespace OHOS::Security::AccessToken;
+
+void AccessTokenKitTest::SetUpTestCase()
+{}
+
+void AccessTokenKitTest::TearDownTestCase()
+{}
+
+void AccessTokenKitTest::SetUp()
+{}
+
+void AccessTokenKitTest::TearDown()
+{}
+
+/**
+ * @tc.name: VerifyAccesstoken001
+ * @tc.desc: Verify user granted permission
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(AccessTokenKitTest, VerifyAccesstoken001, TestSize.Level0)
+{
+    AccessTokenID tokenID = 1;
+    const std::string TEST_PERMISSION_NAME = "ohos.permission.TEST";
+
+    int ret = AccessTokenKit::VerifyAccesstoken(tokenID, TEST_PERMISSION_NAME);
+    ASSERT_EQ(PERMISSION_GRANTED, ret);
+
+}
\ No newline at end of file
diff --git a/interfaces/innerkits/accesstoken/test/unittest/cpp/src/accesstoken_kit_test.h b/interfaces/innerkits/accesstoken/test/unittest/cpp/src/accesstoken_kit_test.h
new file mode 100644
index 0000000000000000000000000000000000000000..5784ad6f4cccb0584a0794179a4b32e6de6212c6
--- /dev/null
+++ b/interfaces/innerkits/accesstoken/test/unittest/cpp/src/accesstoken_kit_test.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2021 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 ACCESSTOKEN_KIT_TEST_H
+#define ACCESSTOKEN_KIT_TEST_H
+
+#include <gtest/gtest.h>
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+class AccessTokenKitTest : public testing::Test {
+public:
+    static void SetUpTestCase();
+
+    static void TearDownTestCase();
+
+    void SetUp();
+
+    void TearDown();
+};
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
+#endif // ACCESSTOKEN_KIT_TEST_H
diff --git a/ohos.build b/ohos.build
new file mode 100644
index 0000000000000000000000000000000000000000..f8bc9d11fc3b32f44714844cd5f9e93365e2372e
--- /dev/null
+++ b/ohos.build
@@ -0,0 +1,29 @@
+{
+  "subsystem": "security",
+  "parts": {
+    "access_token": {
+      "variants": [
+        "phone",
+        "wearable"
+      ],
+      "inner_kits": [
+        {
+          "name": "//base/security/access_token/interfaces/innerkits/accesstoken:libaccesstoken_sdk",
+          "header": {
+            "header_files": [
+              "accesstoken.h",
+              "accesstoken_kit.h"
+            ],
+            "header_base": "//base/security/access_token/interfaces/innerkits/accesstoken/main/cpp/include"
+          }
+        }
+      ],
+      "module_list": [
+        "//base/security/access_token:accesstoken_build_module_standard"
+      ],
+      "test_list": [
+        "//base/security/access_token:accesstoken_build_module_standard_test"
+      ]
+    }
+  }
+}
diff --git a/services/accesstoken/BUILD.gn b/services/accesstoken/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..a58bc6e088e1356b89ac291c459b351fb5ff70c5
--- /dev/null
+++ b/services/accesstoken/BUILD.gn
@@ -0,0 +1,44 @@
+# Copyright (c) 2021 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.
+
+import("//build/ohos.gni")
+
+ohos_shared_library("accesstoken_manager_service") {
+  subsystem_name = "security"
+  part_name = "access_token"
+
+  include_dirs = [
+    "main/cpp/include",
+    "//utils/system/safwk/native/include",
+    "//base/security/access_token/frameworks/accesstoken",
+    "//base/security/access_token/interfaces/innerkits/accesstoken//main/cpp/include",
+  ]
+
+  sources = [
+    "main/cpp/src/accesstoken_manager_service.cpp",
+    "main/cpp/src/accesstoken_manager_stub.cpp",
+  ]
+
+  cflags_cc = [ "-DHILOG_ENABLE" ]
+
+  deps = [
+    "//utils/native/base:utils",
+  ]
+
+  external_deps = [
+    "hiviewdfx_hilog_native:libhilog",
+    "ipc:ipc_core",
+    "safwk:system_ability_fwk",
+    "samgr_standard:samgr_proxy",
+  ]
+}
diff --git a/services/accesstoken/main/cpp/include/accesstoken_manager_service.h b/services/accesstoken/main/cpp/include/accesstoken_manager_service.h
new file mode 100644
index 0000000000000000000000000000000000000000..8174ae72f6a7f3a6dd727d32afe011a88beb45d6
--- /dev/null
+++ b/services/accesstoken/main/cpp/include/accesstoken_manager_service.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2021 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 ACCESSTOKEN_MANAGER_SERVICE_H
+#define ACCESSTOKEN_MANAGER_SERVICE_H
+
+#include "accesstoken_manager_stub.h"
+#include "singleton.h"
+#include "iremote_object.h"
+#include "system_ability.h"
+#include "nocopyable.h"
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+enum class ServiceRunningState { STATE_NOT_START, STATE_RUNNING };
+class AccessTokenManagerService final : public SystemAbility, public AccessTokenManagerStub {
+    DECLARE_DELAYED_SINGLETON(AccessTokenManagerService);
+    DECLEAR_SYSTEM_ABILITY(AccessTokenManagerService);
+
+public:
+    void OnStart() override;
+    void OnStop() override;
+
+    int VerifyAccesstoken(AccessTokenID tokenID, const std::string& permissionName) override;
+
+private:
+    bool Initialize() const;
+
+    ServiceRunningState state_;
+};
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
+#endif // ACCESSTOKEN_MANAGER_SERVICE_H
diff --git a/services/accesstoken/main/cpp/include/accesstoken_manager_stub.h b/services/accesstoken/main/cpp/include/accesstoken_manager_stub.h
new file mode 100644
index 0000000000000000000000000000000000000000..ffcbf3d577336d85fc8ad417bfcd7701674ef10e
--- /dev/null
+++ b/services/accesstoken/main/cpp/include/accesstoken_manager_stub.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2021 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 ACCESSTOKEN_MANAGER_STUB_H
+#define ACCESSTOKEN_MANAGER_STUB_H
+
+#include "i_accesstoken_manager.h"
+
+#include "iremote_stub.h"
+#include "nocopyable.h"
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+class AccessTokenManagerStub : public IRemoteStub<IAccessTokenManager> {
+public:
+    AccessTokenManagerStub() = default;
+    virtual ~AccessTokenManagerStub() = default;
+
+    int OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& options) override;
+
+private:
+    void VerifyAccessTokenInner(MessageParcel& data, MessageParcel& reply);
+
+};
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
+#endif // ACCESSTOKEN_MANAGER_STUB_H
diff --git a/services/accesstoken/main/cpp/src/accesstoken_manager_service.cpp b/services/accesstoken/main/cpp/src/accesstoken_manager_service.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2b4bda1093836067b613bb27d0a177437d82c90d
--- /dev/null
+++ b/services/accesstoken/main/cpp/src/accesstoken_manager_service.cpp
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2021 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 "accesstoken_manager_service.h"
+
+#include "accesstoken.h"
+#include "accesstoken_log.h"
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+namespace {
+static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "AccessTokenManagerService"};
+}
+
+const bool REGISTER_RESULT =
+    SystemAbility::MakeAndRegisterAbility(DelayedSingleton<AccessTokenManagerService>::GetInstance().get());
+
+AccessTokenManagerService::AccessTokenManagerService()
+    : SystemAbility(SA_ID_ACCESSTOKEN_MANAGER_SERVICE, true), state_(ServiceRunningState::STATE_NOT_START)
+{
+    ACCESSTOKEN_LOG_INFO(LABEL, "AccessTokenManagerService()");
+}
+
+AccessTokenManagerService::~AccessTokenManagerService()
+{
+    ACCESSTOKEN_LOG_INFO(LABEL, "~AccessTokenManagerService()");
+}
+
+void AccessTokenManagerService::OnStart()
+{
+    if (state_ == ServiceRunningState::STATE_RUNNING) {
+        ACCESSTOKEN_LOG_INFO(LABEL, "AccessTokenManagerService has already started!");
+        return;
+    }
+    ACCESSTOKEN_LOG_INFO(LABEL, "AccessTokenManagerService is starting");
+    if (!Initialize()) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to initialize");
+        return;
+    }
+    state_ = ServiceRunningState::STATE_RUNNING;
+    bool ret = Publish(DelayedSingleton<AccessTokenManagerService>::GetInstance().get());
+    if (!ret) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to publish service!");
+        return;
+    }
+    ACCESSTOKEN_LOG_INFO(LABEL, "Congratulations, AccessTokenManagerService start successfully!");
+}
+
+void AccessTokenManagerService::OnStop()
+{
+    ACCESSTOKEN_LOG_INFO(LABEL, "stop service");
+    state_ = ServiceRunningState::STATE_NOT_START;
+}
+
+int AccessTokenManagerService::VerifyAccesstoken(AccessTokenID tokenID, const std::string &permissionName)
+{
+    ACCESSTOKEN_LOG_INFO(LABEL,
+        "%{public}s called, tokenID: %{public}d, permissionName: %{public}s", __func__,
+        tokenID, permissionName.c_str());
+    return PERMISSION_GRANTED;
+}
+
+bool AccessTokenManagerService::Initialize() const
+{
+    return true;
+}
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/accesstoken/main/cpp/src/accesstoken_manager_stub.cpp b/services/accesstoken/main/cpp/src/accesstoken_manager_stub.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a8b1c6cef1c0d79327be52956cc7bd70963bb7f1
--- /dev/null
+++ b/services/accesstoken/main/cpp/src/accesstoken_manager_stub.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2021 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 "accesstoken_manager_stub.h"
+
+#include "accesstoken.h"
+#include "accesstoken_log.h"
+
+#include "ipc_skeleton.h"
+#include "string_ex.h"
+
+namespace OHOS {
+namespace Security {
+namespace AccessToken {
+namespace {
+static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
+    LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "AccessTokenManagerStub"
+};
+}
+
+int32_t AccessTokenManagerStub::OnRemoteRequest(
+    uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
+{
+    ACCESSTOKEN_LOG_INFO(LABEL, "%{public}s called, code: %{public}d", __func__, code);
+    std::u16string descriptor = data.ReadInterfaceToken();
+    if (descriptor != IAccessTokenManager::GetDescriptor()) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "get unexpect descriptor: %{public}s", Str16ToStr8(descriptor).c_str());
+        return RET_FAILED;
+    }
+    switch (code) {
+        case static_cast<uint32_t>(IAccessTokenManager::InterfaceCode::VERIFY_ACCESSTOKEN):
+            VerifyAccessTokenInner(data, reply);
+            break;
+        default:
+            return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
+    }
+    return NO_ERROR;
+}
+
+void AccessTokenManagerStub::VerifyAccessTokenInner(MessageParcel& data, MessageParcel& reply)
+{
+    AccessTokenID tokenID = data.ReadUint32();
+    std::string permissionName = data.ReadString();
+    int result = this->VerifyAccesstoken(tokenID, permissionName);
+    reply.WriteInt32(result);
+}
+} // namespace AccessToken
+} // namespace Security
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/accesstoken/main/sa_profile/3503.xml b/services/accesstoken/main/sa_profile/3503.xml
new file mode 100755
index 0000000000000000000000000000000000000000..622c5f8a5bcaad7bb69f6a0e585925d3ea2b7256
--- /dev/null
+++ b/services/accesstoken/main/sa_profile/3503.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2021 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.
+-->
+<info>
+    <process>foundation</process>
+    <systemability>
+        <name>3503</name>
+        <libpath>libaccesstoken_manager_service.z.so</libpath>
+        <run-on-create>true</run-on-create>
+        <distributed>false</distributed>
+        <dump-level>1</dump-level>
+    </systemability>
+</info>
\ No newline at end of file
diff --git a/services/accesstoken/main/sa_profile/BUILD.gn b/services/accesstoken/main/sa_profile/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..c199a410c692bb3ecc713336c8f02718acf3731f
--- /dev/null
+++ b/services/accesstoken/main/sa_profile/BUILD.gn
@@ -0,0 +1,20 @@
+# Copyright (c) 2021 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.
+
+import("//build/ohos/sa_profile/sa_profile.gni")
+
+ohos_sa_profile("accesstoken_sa_profile_standard") {
+  part_name = "access_token"
+
+  sources = [ "3503.xml" ]
+}