diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn
index 9fc445f9ab59139dfe499b9fb3c1c33d8d637021..02ff7ca1ab5601cdf981107910271a79e1cbda9b 100644
--- a/interfaces/kits/js/BUILD.gn
+++ b/interfaces/kits/js/BUILD.gn
@@ -623,3 +623,161 @@ group("build_kits_js") {
     ":statvfs",
   ]
 }
+
+group("ani_file_api") {
+  deps = [
+    ":ani_file_hash",
+    ":ani_file_securitylabel",
+  ]
+}
+
+config("ani_config") {
+  include_dirs = [
+    "./include",
+    "${file_api_path}/interfaces/kits/rust/include",
+    "${utils_path}/common/include",
+    "${utils_path}/filemgmt_libfs/include",
+    "${utils_path}/filemgmt_libhilog",
+    "src/common",
+    "src/common/ani_helper",
+    "src/common/file_helper",
+    "src/mod_fs",
+  ]
+
+  cflags = [
+    "-fdata-sections",
+    "-ffunction-sections",
+    "-Oz",
+  ]
+  cflags_cc = [
+    "-std=c++17",
+    "-fvisibility-inlines-hidden",
+    "-Oz",
+  ]
+}
+
+ohos_shared_library("ani_file_hash") {
+  public_configs = [ ":ani_config" ]
+  include_dirs = [
+    "src/mod_hash",
+    "src/mod_hash/ani",
+  ]
+  sources = [
+    "src/common/ani_helper/ani_signature.cpp",
+    "src/common/ani_helper/error_handler.cpp",
+    "src/common/ani_helper/type_converter.cpp",
+    "src/common/file_helper/fd_guard.cpp",
+    "src/common/file_helper/hash_file.cpp",
+    "src/mod_fs/fs_utils.cpp",
+    "src/mod_hash/ani/bind_function_class.cpp",
+    "src/mod_hash/ani/hash_ani.cpp",
+    "src/mod_hash/hash_core.cpp",
+  ]
+
+  deps = [
+    ":ohos_file_hash_abc_etc",
+    "${file_api_path}/interfaces/kits/rust:rust_file",
+    "${utils_path}/filemgmt_libfs:filemgmt_libfs",
+    "${utils_path}/filemgmt_libhilog:filemgmt_libhilog",
+  ]
+  external_deps = [
+    "bounds_checking_function:libsec_static",
+    "hilog:libhilog",
+    "libuv:uv",
+    "openssl:libcrypto_shared",
+    "runtime_core:ani",
+    "runtime_core:ani_helpers",
+    "runtime_core:libarkruntime",
+  ]
+  use_exceptions = true
+
+  branch_protector_ret = "pac_ret"
+  sanitize = {
+    integer_overflow = true
+    ubsan = true
+    boundary_sanitize = true
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+  output_extension = "so"
+  subsystem_name = "filemanagement"
+  part_name = "file_api"
+}
+
+generate_static_abc("ohos_file_hash_abc") {
+  base_url = "./src/mod_hash/ani/ets"
+  files = [ "./src/mod_hash/ani/ets/@ohos.file.hash.ets" ]
+  is_boot_abc = "True"
+  device_dst_file = "/system/framework/ohos_file_hash_abc.abc"
+}
+
+ohos_prebuilt_etc("ohos_file_hash_abc_etc") {
+  source = "$target_out_dir/ohos_file_hash_abc.abc"
+  module_install_dir = "framework"
+  subsystem_name = "filemanagement"
+  part_name = "file_api"
+  deps = [ ":ohos_file_hash_abc" ]
+}
+
+ohos_shared_library("ani_file_securitylabel") {
+  public_configs = [ ":ani_config" ]
+  include_dirs = [
+    "src/mod_securitylabel/ani",
+    "src/mod_securitylabel",
+  ]
+  sources = [
+    "src/common/ani_helper/ani_signature.cpp",
+    "src/common/ani_helper/error_handler.cpp",
+    "src/common/ani_helper/type_converter.cpp",
+    "src/common/file_helper/fd_guard.cpp",
+    "src/mod_fs/fs_utils.cpp",
+    "src/mod_securitylabel/ani/bind_function_class.cpp",
+    "src/mod_securitylabel/ani/securitylabel_ani.cpp",
+    "src/mod_securitylabel/securitylabel_core.cpp",
+  ]
+
+  deps = [
+    ":ohos_file_securityLabel_abc_etc",
+    "${file_api_path}/interfaces/kits/rust:rust_file",
+    "${utils_path}/filemgmt_libfs:filemgmt_libfs",
+    "${utils_path}/filemgmt_libhilog:filemgmt_libhilog",
+  ]
+  external_deps = [
+    "bounds_checking_function:libsec_static",
+    "hilog:libhilog",
+    "libuv:uv",
+    "runtime_core:ani",
+    "runtime_core:ani_helpers",
+    "runtime_core:libarkruntime",
+  ]
+  use_exceptions = true
+
+  branch_protector_ret = "pac_ret"
+  sanitize = {
+    integer_overflow = true
+    ubsan = true
+    boundary_sanitize = true
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+  output_extension = "so"
+  subsystem_name = "filemanagement"
+  part_name = "file_api"
+}
+
+generate_static_abc("ohos_file_securityLabel_abc") {
+  base_url = "./src/mod_securitylabel/ani/ets"
+  files = [ "./src/mod_securitylabel/ani/ets/@ohos.file.securityLabel.ets" ]
+  is_boot_abc = "True"
+  device_dst_file = "/system/framework/ohos_file_securityLabel_abc.abc"
+}
+
+ohos_prebuilt_etc("ohos_file_securityLabel_abc_etc") {
+  source = "$target_out_dir/ohos_file_securityLabel_abc.abc"
+  module_install_dir = "framework"
+  subsystem_name = "filemanagement"
+  part_name = "file_api"
+  deps = [ ":ohos_file_securityLabel_abc" ]
+}
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/ani/bind_function_class.cpp b/interfaces/kits/js/src/mod_hash/ani/bind_function_class.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5ab549948f7657e1acd6b2f77b61051469aabf57
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/ani/bind_function_class.cpp
@@ -0,0 +1,60 @@
+/*
+ * 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 <ani.h>
+#include "ani_signature.h"
+#include "bind_function.h"
+#include "hash_ani.h"
+
+using namespace OHOS::FileManagement::ModuleFileIO::ANI;
+using namespace OHOS::FileManagement::ModuleFileIO::ANI::AniSignature;
+
+static ani_status BindStaticMethods(ani_env *env)
+{
+    auto classDesc = Impl::HashImpl::classDesc.c_str();
+    std::array methods = {
+        ani_native_function { "hashSync", nullptr, reinterpret_cast<void *>(HashAni::HashSync) },
+    };
+    return BindClass(env, classDesc, methods);
+}
+
+ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result)
+{
+    if (vm == nullptr) {
+        HILOGE("Invalid parameter vm");
+        return ANI_INVALID_ARGS;
+    }
+
+    if (result == nullptr) {
+        HILOGE("Invalid parameter result");
+        return ANI_INVALID_ARGS;
+    }
+
+    ani_env *env;
+    ani_status status = vm->GetEnv(ANI_VERSION_1, &env);
+    if (status != ANI_OK) {
+        HILOGE("Invalid ani version!");
+        return ANI_INVALID_VERSION;
+    }
+
+    status = BindStaticMethods(env);
+    if (status != ANI_OK) {
+        HILOGE("Cannot bind native static methods for hash!");
+        return status;
+    };
+
+    *result = ANI_VERSION_1;
+    return ANI_OK;
+}
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/ani/ets/@ohos.file.hash.ets b/interfaces/kits/js/src/mod_hash/ani/ets/@ohos.file.hash.ets
new file mode 100644
index 0000000000000000000000000000000000000000..dfa16ab00530db92e6dc328c889cb035d50080d4
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/ani/ets/@ohos.file.hash.ets
@@ -0,0 +1,93 @@
+/*
+ * 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.
+ */
+
+import { BusinessError, AsyncCallback } from '@ohos.base';
+import stream from '@ohos.util.stream';
+
+export default namespace hash {
+  export function hash(path: string, algorithm: string): Promise<string> {
+    return new Promise<string>((resolve: (result: string) => void, reject: (e: BusinessError<void>) => void) => {
+      let promise = taskpool.execute(HashImpl.hashSync, path, algorithm);
+      promise.then((ret: NullishType): void => {
+        let res = ret as string;
+        resolve(res);
+      }).catch((e: BusinessError): void => {
+        reject(e);
+      });
+    });
+  }
+
+  export function hash(path: string, algorithm: string, callback: AsyncCallback<string, void>): void {
+    let promise = taskpool.execute(HashImpl.hashSync, path, algorithm);
+    promise.then((ret: NullishType) => {
+      let e = new BusinessError<void>();
+      e.code = 0;
+      let res = ret as string;
+      callback(e, res);
+    }).catch((e: BusinessError): void => {
+      callback(e, "");
+    });
+  }
+
+  export function createHash(algorithm: string): HashStream {
+    return new HashStream(algorithm);
+  }
+
+  export class HashStream extends stream.Transform {
+    hs: hash.HashStream;
+    hashBuf?: ArrayBuffer;
+
+    constructor(algorithm: string) {
+      super();
+      this.hs = new hash.HashStream(algorithm);
+    }
+
+    digest(): string {
+      return this.hs.digest();
+    }
+
+    update(data: ArrayBuffer): void {
+      this.hs.update(data);
+    }
+
+    doTransform(chunk: string, encoding: string, callback: () => void): void {
+      let charCodes: number[] = [];
+      for (let i = 0; i < chunk.length; i++) {
+        charCodes = [...charCodes, chunk.charCodeAt(i)];
+      }
+      const buf = new Uint8Array(charCodes).buffer;
+      this.hs.update((buf as ArrayBuffer));
+      this.push(chunk);
+      callback();
+    }
+
+    doWrite(chunk: string | Uint8Array, encoding: string, callback: () => void): void {
+      callback();
+    }
+
+    doFlush(callback: () => void): void {
+      callback();
+    }
+  }
+}
+
+class HashImpl {
+
+  static {
+    loadLibrary("ani_file_hash");
+  }
+
+  static native hashSync(path: string, algorithm: string): string;
+}
diff --git a/interfaces/kits/js/src/mod_hash/ani/hash_ani.cpp b/interfaces/kits/js/src/mod_hash/ani/hash_ani.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6acb4389cdaba7a384403d9e61541fbe9dd6e214
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/ani/hash_ani.cpp
@@ -0,0 +1,68 @@
+/*
+ * 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 "hash_ani.h"
+
+#include "error_handler.h"
+#include "filemgmt_libhilog.h"
+#include "hash_core.h"
+#include "type_converter.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+using namespace std;
+using namespace OHOS::FileManagement::ModuleFileIO;
+
+ani_string HashAni::HashSync(ani_env *env, [[maybe_unused]] ani_class clazz, ani_string path, ani_string algorithm)
+{
+    auto [succPath, srcPath] = TypeConverter::ToUTF8String(env, path);
+    if (!succPath) {
+        HILOGE("Invalid path");
+        ErrorHandler::Throw(env, EINVAL);
+        return nullptr;
+    }
+
+    auto [succAlg, algType] = TypeConverter::ToUTF8String(env, algorithm);
+    if (!succAlg) {
+        HILOGE("Invalid algorithm");
+        ErrorHandler::Throw(env, EINVAL);
+        return nullptr;
+    }
+
+    auto ret = HashCore::DoHash(srcPath, algType);
+    if (!ret.IsSuccess()) {
+        HILOGE("DoHash failed");
+        const auto &err = ret.GetError();
+        ErrorHandler::Throw(env, err);
+        return nullptr;
+    }
+
+    const auto &res = ret.GetData().value();
+    auto [succ, result] = TypeConverter::ToAniString(env, res);
+    if (!succ) {
+        HILOGE("Convert hash value to ani string failed");
+        ErrorHandler::Throw(env, UNKNOWN_ERR);
+        return nullptr;
+    }
+    return result;
+}
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/ani/hash_ani.h b/interfaces/kits/js/src/mod_hash/ani/hash_ani.h
new file mode 100644
index 0000000000000000000000000000000000000000..7b0890fe78e7ad5dbf86a84553300d1736a5d775
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/ani/hash_ani.h
@@ -0,0 +1,36 @@
+/*
+ * 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 INTERFACES_KITS_JS_SRC_MOD_HASH_PROPERTIES_HASH_ANI_H
+#define INTERFACES_KITS_JS_SRC_MOD_HASH_PROPERTIES_HASH_ANI_H
+
+#include <ani.h>
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+class HashAni final {
+public:
+    static ani_string HashSync(ani_env *env, [[maybe_unused]] ani_class clazz, ani_string path, ani_string algorithm);
+};
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+
+#endif // INTERFACES_KITS_JS_SRC_MOD_HASH_PROPERTIES_HASH_ANI_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/hash_core.cpp b/interfaces/kits/js/src/mod_hash/hash_core.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed75b4b0cd462c8fef0bc8d76009e7bc32d0fd93
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/hash_core.cpp
@@ -0,0 +1,63 @@
+/*
+ * 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 "hash_core.h"
+
+#include <cstring>
+#include <string_view>
+#include <tuple>
+
+#include "filemgmt_libhilog.h"
+#include "hash_file.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+
+static HASH_ALGORITHM_TYPE GetHashAlgorithm(const string &alg)
+{
+    return (algorithmMaps.find(alg) != algorithmMaps.end()) ? algorithmMaps.at(alg) : HASH_ALGORITHM_TYPE_UNSUPPORTED;
+}
+
+FsResult<string> HashCore::DoHash(const string &path, const string &algorithm)
+{
+    HASH_ALGORITHM_TYPE algType = GetHashAlgorithm(algorithm);
+    if (algType == HASH_ALGORITHM_TYPE_UNSUPPORTED) {
+        HILOGE("Invalid algoritm");
+        return FsResult<string>::Error(EINVAL);
+    }
+
+    int ret = EIO;
+    auto arg = make_shared<string>();
+    string &res = *arg;
+    if (algType == HASH_ALGORITHM_TYPE_MD5) {
+        tie(ret, res) = DistributedFS::HashFile::HashWithMD5(path);
+    } else if (algType == HASH_ALGORITHM_TYPE_SHA1) {
+        tie(ret, res) = DistributedFS::HashFile::HashWithSHA1(path);
+    } else if (algType == HASH_ALGORITHM_TYPE_SHA256) {
+        tie(ret, res) = DistributedFS::HashFile::HashWithSHA256(path);
+    }
+
+    if (ret) {
+        return FsResult<string>::Error(ret);
+    }
+
+    return FsResult<string>::Success(*arg);
+}
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/hash_core.h b/interfaces/kits/js/src/mod_hash/hash_core.h
new file mode 100644
index 0000000000000000000000000000000000000000..47119f1ac3e43d512c900cd81b3e8dc2f35e49c0
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/hash_core.h
@@ -0,0 +1,48 @@
+/*
+ * 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 INTERFACES_KITS_JS_SRC_MOD_HASH_PROPERTIES_HASH_CORE_H
+#define INTERFACES_KITS_JS_SRC_MOD_HASH_PROPERTIES_HASH_CORE_H
+
+#include <map>
+#include "filemgmt_libfs.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+
+enum HASH_ALGORITHM_TYPE {
+    HASH_ALGORITHM_TYPE_MD5,
+    HASH_ALGORITHM_TYPE_SHA1,
+    HASH_ALGORITHM_TYPE_SHA256,
+    HASH_ALGORITHM_TYPE_UNSUPPORTED,
+};
+
+const std::map<std::string, HASH_ALGORITHM_TYPE> algorithmMaps = {
+    {"md5", HASH_ALGORITHM_TYPE_MD5},
+    {"sha1", HASH_ALGORITHM_TYPE_SHA1},
+    {"sha256", HASH_ALGORITHM_TYPE_SHA256},
+};
+
+class HashCore final {
+public:
+    static FsResult<std::string> DoHash(const std::string &path, const std::string &algorithm);
+};
+
+const std::string PROCEDURE_HASH_NAME = "FileIOHash";
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_HASH_PROPERTIES_HASH_CORE_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_securitylabel/ani/bind_function_class.cpp b/interfaces/kits/js/src/mod_securitylabel/ani/bind_function_class.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..947e460b65992a5ec8c5042a6dd205d03ef42c56
--- /dev/null
+++ b/interfaces/kits/js/src/mod_securitylabel/ani/bind_function_class.cpp
@@ -0,0 +1,63 @@
+/*
+ * 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 <ani.h>
+#include "ani_signature.h"
+#include "bind_function.h"
+#include "securitylabel_ani.h"
+
+using namespace OHOS::FileManagement::ModuleFileIO::ANI;
+using namespace OHOS::FileManagement::ModuleFileIO::ANI::AniSignature;
+
+static ani_status BindStaticMethods(ani_env *env)
+{
+    auto classDesc = Impl::SecurityLabelImpl::classDesc.c_str();
+    std::array methods = {
+        ani_native_function {
+            "setSecurityLabelSync", nullptr, reinterpret_cast<void *>(SecurityLabelAni::SetSecurityLabelSync) },
+        ani_native_function {
+            "getSecurityLabelSync", nullptr, reinterpret_cast<void *>(SecurityLabelAni::GetSecurityLabelSync) },
+    };
+    return BindClass(env, classDesc, methods);
+}
+
+ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result)
+{
+    if (vm == nullptr) {
+        HILOGE("Invalid parameter vm");
+        return ANI_INVALID_ARGS;
+    }
+
+    if (result == nullptr) {
+        HILOGE("Invalid parameter result");
+        return ANI_INVALID_ARGS;
+    }
+
+    ani_env *env;
+    ani_status status = vm->GetEnv(ANI_VERSION_1, &env);
+    if (status != ANI_OK) {
+        HILOGE("Invalid ani version!");
+        return ANI_INVALID_VERSION;
+    }
+
+    status = BindStaticMethods(env);
+    if (status != ANI_OK) {
+        HILOGE("Cannot bind native static methods for securitylabel!");
+        return status;
+    };
+
+    *result = ANI_VERSION_1;
+    return ANI_OK;
+}
diff --git a/interfaces/kits/js/src/mod_securitylabel/ani/ets/@ohos.file.securityLabel.ets b/interfaces/kits/js/src/mod_securitylabel/ani/ets/@ohos.file.securityLabel.ets
new file mode 100644
index 0000000000000000000000000000000000000000..06e659dc275ae1890e009c02fc830bd8e766dbea
--- /dev/null
+++ b/interfaces/kits/js/src/mod_securitylabel/ani/ets/@ohos.file.securityLabel.ets
@@ -0,0 +1,86 @@
+/*
+ * 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.
+ */
+
+import { BusinessError, AsyncCallback } from '@ohos.base';
+
+namespace securityLabel {
+  export type DataLevel = 's0' | 's1' | 's2' | 's3' | 's4';
+
+  export function setSecurityLabel(path: string, type: DataLevel): Promise<void> {
+    return new Promise<void>((resolve: (result: undefined) => void, reject: (e: BusinessError<void>) => void): void => {
+      let promise = taskpool.execute((path: string, type: DataLevel): void => SecurityLabelImpl.setSecurityLabelSync(path, type), path, type);
+      promise.then((ret: NullishType): void => {
+        resolve(undefined);
+      }).catch((e: BusinessError): void => {
+        reject(e);
+      });
+    });
+  }
+
+  export function setSecurityLabel(path: string, type: DataLevel, callback: AsyncCallback<void>): void {
+    let promise = taskpool.execute((path: string, type: DataLevel): void => SecurityLabelImpl.setSecurityLabelSync(path, type), path, type);
+    promise.then((ret: NullishType): void => {
+      let e = new BusinessError<void>();
+      e.code = 0;
+      callback(e, undefined);
+    }).catch((e: BusinessError): void => {
+      callback(e, undefined);
+    });
+  }
+
+  export function setSecurityLabelSync(path: string, type: DataLevel): void {
+    return SecurityLabelImpl.setSecurityLabelSync(path, type);
+  }
+
+  export function getSecurityLabel(path: string): Promise<string> {
+    return new Promise<string>((resolve: (result: string) => void, reject: (e: BusinessError<void>) => void): void => {
+      let promise = taskpool.execute((path: string): string => SecurityLabelImpl.getSecurityLabelSync(path), path);
+      promise.then((ret: NullishType): void => {
+        let r = ret as string;
+        resolve(r);
+      }).catch((e: BusinessError): void => {
+        reject(e);
+      });
+    });
+  }
+
+  export function getSecurityLabel(path: string, callback: AsyncCallback<string, void>): void {
+    let promise = taskpool.execute((path: string): string => SecurityLabelImpl.getSecurityLabelSync(path), path);
+    promise.then((ret: NullishType): void => {
+      let e = new BusinessError<void>();
+      e.code = 0;
+      let r = ret as string;
+      callback(e, r);
+    }).catch((e: BusinessError): void => {
+      callback(e, "");
+    });
+  }
+
+  export function getSecurityLabelSync(path: string): string {
+    return SecurityLabelImpl.getSecurityLabelSync(path);
+  }
+}
+
+export default securityLabel;
+
+class SecurityLabelImpl {
+
+  static {
+    loadLibrary("ani_file_securitylabel");
+  }
+
+  static native setSecurityLabelSync(path: string, type: securityLabel.DataLevel): void;
+  static native getSecurityLabelSync(path: string): string;
+}
diff --git a/interfaces/kits/js/src/mod_securitylabel/ani/securitylabel_ani.cpp b/interfaces/kits/js/src/mod_securitylabel/ani/securitylabel_ani.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4d6fd2b3211890d4e1092c8925da40bddbe0269f
--- /dev/null
+++ b/interfaces/kits/js/src/mod_securitylabel/ani/securitylabel_ani.cpp
@@ -0,0 +1,89 @@
+/*
+ * 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 "securitylabel_ani.h"
+
+#include "error_handler.h"
+#include "filemgmt_libhilog.h"
+#include "securitylabel_core.h"
+#include "type_converter.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+using namespace std;
+using namespace OHOS::FileManagement::ModuleFileIO;
+using namespace OHOS::FileManagement::ModuleSecurityLabel;
+
+void SecurityLabelAni::SetSecurityLabelSync(
+    ani_env *env, [[maybe_unused]] ani_class clazz, ani_string path, ani_string level)
+{
+    auto [succPath, srcPath] = TypeConverter::ToUTF8String(env, path);
+    if (!succPath) {
+        HILOGE("Invalid path");
+        ErrorHandler::Throw(env, EINVAL);
+        return;
+    }
+
+    auto [succLevel, dataLevel] = TypeConverter::ToUTF8String(env, level);
+    if (!succLevel) {
+        HILOGE("Invalid dataLevel");
+        ErrorHandler::Throw(env, EINVAL);
+        return;
+    }
+
+    auto ret = DoSetSecurityLabel(srcPath, dataLevel);
+    if (!ret.IsSuccess()) {
+        HILOGE("Set securitylabel failed");
+        const auto &err = ret.GetError();
+        ErrorHandler::Throw(env, err);
+        return;
+    }
+}
+
+ani_string SecurityLabelAni::GetSecurityLabelSync(ani_env *env, [[maybe_unused]] ani_class clazz, ani_string path)
+{
+    auto [succPath, srcPath] = TypeConverter::ToUTF8String(env, path);
+    if (!succPath) {
+        HILOGE("Invalid path");
+        ErrorHandler::Throw(env, EINVAL);
+        return nullptr;
+    }
+
+    auto ret = DoGetSecurityLabel(srcPath);
+    if (!ret.IsSuccess()) {
+        HILOGE("Get securitylabel failed");
+        const auto &err = ret.GetError();
+        ErrorHandler::Throw(env, err);
+        return nullptr;
+    }
+    
+    string res = ret.GetData().value();
+    auto [succ, result] = TypeConverter::ToAniString(env, res);
+    if (!succ) {
+        HILOGE("Create ani_string error");
+        ErrorHandler::Throw(env, UNKNOWN_ERR);
+        return nullptr;
+    }
+
+    return result;
+}
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_securitylabel/ani/securitylabel_ani.h b/interfaces/kits/js/src/mod_securitylabel/ani/securitylabel_ani.h
new file mode 100644
index 0000000000000000000000000000000000000000..8bb5741c9c347700ded871b900efc44297c823d9
--- /dev/null
+++ b/interfaces/kits/js/src/mod_securitylabel/ani/securitylabel_ani.h
@@ -0,0 +1,37 @@
+/*
+ * 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 SECURITYLABEL_ANI_H
+#define SECURITYLABEL_ANI_H
+
+#include <ani.h>
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+class SecurityLabelAni final {
+public:
+    static void SetSecurityLabelSync(ani_env *env, [[maybe_unused]] ani_class clazz, ani_string path, ani_string level);
+    static ani_string GetSecurityLabelSync(ani_env *env, [[maybe_unused]] ani_class clazz, ani_string path);
+};
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+
+#endif // SECURITYLABEL_ANI_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_securitylabel/securitylabel_core.cpp b/interfaces/kits/js/src/mod_securitylabel/securitylabel_core.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d68002e8aa8ddcab3863ebed88d44bcc22d1fa13
--- /dev/null
+++ b/interfaces/kits/js/src/mod_securitylabel/securitylabel_core.cpp
@@ -0,0 +1,48 @@
+/*
+ * 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 "securitylabel_core.h"
+
+#include "filemgmt_libhilog.h"
+#include "security_label.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleSecurityLabel {
+using namespace std;
+FsResult<void> DoSetSecurityLabel(const string &path, const string &dataLevel)
+{
+    if (DATA_LEVEL.find(dataLevel) == DATA_LEVEL.end()) {
+        HILOGE("Invalid Argument of dataLevelEnum");
+        return FsResult<void>::Error(EINVAL);
+    }
+
+    bool ret = SecurityLabel::SetSecurityLabel(path, dataLevel);
+    if (!ret) {
+        return FsResult<void>::Error(errno);
+    }
+
+    return FsResult<void>::Success();
+}
+
+FsResult<string> DoGetSecurityLabel(const string &path)
+{
+    string ret = SecurityLabel::GetSecurityLabel(path);
+    return FsResult<string>::Success(move(ret));
+}
+
+} // namespace ModuleSecurityLabel
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_securitylabel/securitylabel_core.h b/interfaces/kits/js/src/mod_securitylabel/securitylabel_core.h
new file mode 100644
index 0000000000000000000000000000000000000000..cb7766eaf5a6087c1e449e2077046ee4a63a9f33
--- /dev/null
+++ b/interfaces/kits/js/src/mod_securitylabel/securitylabel_core.h
@@ -0,0 +1,32 @@
+/*
+ * 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 SECURITYLABEL_CORE_H
+#define SECURITYLABEL_CORE_H
+
+#include "filemgmt_libfs.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleSecurityLabel {
+using namespace ModuleFileIO;
+
+FsResult<void> DoSetSecurityLabel(const string &path, const string &dataLevel);
+FsResult<string> DoGetSecurityLabel(const string &path);
+
+} // namespace ModuleSecurityLabel
+} // namespace FileManagement
+} // namespace OHOS
+#endif // SECURITYLABEL_CORE_H
\ No newline at end of file
diff --git a/interfaces/test/unittest/BUILD.gn b/interfaces/test/unittest/BUILD.gn
index ad60f3a1211394a32365a2579f6f3d23e668c112..0584db09a8f2f029bfc6b4ca3015d066f469fe20 100644
--- a/interfaces/test/unittest/BUILD.gn
+++ b/interfaces/test/unittest/BUILD.gn
@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2023 Huawei Device Co., Ltd.
+# Copyright (c) 2022-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
@@ -18,6 +18,8 @@ group("unittest") {
   deps = [
     "class_file:class_file_test",
     "filemgmt_libn_test:filemgmt_libn_test",
+    "js:ani_file_hash_test",
+    "js:ani_file_securitylabel_test",
     "remote_uri:remote_uri_test",
     "task_signal:task_signal_test",
   ]
diff --git a/interfaces/test/unittest/js/BUILD.gn b/interfaces/test/unittest/js/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..266f2cce76151e800559b31a30e7c926d6c137db
--- /dev/null
+++ b/interfaces/test/unittest/js/BUILD.gn
@@ -0,0 +1,71 @@
+# 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.
+
+import("//build/test.gni")
+import("//foundation/filemanagement/file_api/file_api.gni")
+
+ohos_unittest("ani_file_hash_test") {
+  module_out_path = "file_api/file_api"
+
+  resource_config_file = "../resource/ohos_test.xml"
+
+  sources = [ 
+    "mod_hash/hash_core_test.cpp",
+  ]
+
+  include_dirs = [
+    "mock/libuv",
+    "${file_api_path}/interfaces/kits/js/src/mod_hash",
+  ]
+
+  deps = [
+    "${utils_path}/filemgmt_libhilog:filemgmt_libhilog",
+    "${utils_path}/filemgmt_libfs:filemgmt_libfs",
+    "${file_api_path}/interfaces/kits/js:ani_file_hash",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "libuv:uv",
+    "googletest:gmock_main",
+    "googletest:gtest_main",
+  ]
+}
+
+ohos_unittest("ani_file_securitylabel_test") {
+  module_out_path = "file_api/file_api"
+
+  resource_config_file = "../resource/ohos_test.xml"
+
+  sources = [ 
+    "mod_securitylabel/securitylabel_core_test.cpp",
+  ]
+
+  include_dirs = [
+    "${file_api_path}/interfaces/kits/js/src/mod_securitylabel",
+  ]
+
+  deps = [
+    "${utils_path}/filemgmt_libhilog:filemgmt_libhilog",
+    "${utils_path}/filemgmt_libfs:filemgmt_libfs",
+    "${file_api_path}/interfaces/kits/js:ani_file_securitylabel",
+  ]
+
+  external_deps = [
+    "c_utils:utils",
+    "hilog:libhilog",
+    "googletest:gmock_main",
+    "googletest:gtest_main",
+  ]
+}
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_hash/hash_core_test.cpp b/interfaces/test/unittest/js/mod_hash/hash_core_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..069a3230e9d756b9f4a145bbd6e918432ddfa557
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_hash/hash_core_test.cpp
@@ -0,0 +1,136 @@
+/*
+ * 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 <fcntl.h>
+#include <gtest/gtest.h>
+#include <unistd.h>
+#include "hash_core.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+
+static const string g_filePath = "/data/test/HashCoreTest.txt";
+class HashCoreTest : public testing::Test {
+public:
+    static void SetUpTestCase(void)
+    {
+        int32_t fd = open(g_filePath.c_str(), O_CREAT | O_RDWR, 0644);
+        close(fd);
+    };
+    static void TearDownTestCase()
+    {
+        rmdir(g_filePath.c_str());
+    };
+    void SetUp() {};
+    void TearDown() {};
+};
+
+/**
+ * @tc.name: DoHashTest_0001
+ * @tc.desc: Test function of DoHash() interface for invalid alg.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(HashCoreTest, DoHashTest_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "HashCoreTest-begin DoHashTest_0001";
+    string alg = "sha128";
+    auto ret = HashCore::DoHash(g_filePath, alg);
+    EXPECT_FALSE(ret.IsSuccess());
+
+    auto err = ret.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900020);
+
+    GTEST_LOG_(INFO) << "HashCoreTest-end DoHashTest_0001";
+}
+
+/**
+ * @tc.name: DoHashTest_0002
+ * @tc.desc: Test function of DoHash() interface for md5 success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(HashCoreTest, DoHashTest_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "HashCoreTest-begin DoHashTest_0002";
+    auto ret = HashCore::DoHash(g_filePath, "md5");
+    ASSERT_TRUE(ret.IsSuccess());
+
+    GTEST_LOG_(INFO) << "HashCoreTest-end DoHashTest_0002";
+}
+
+/**
+ * @tc.name: DoHashTest_0003
+ * @tc.desc: Test function of DoHash() interface for sha1 success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(HashCoreTest, DoHashTest_0003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "HashCoreTest-begin DoHashTest_0003";
+    auto ret = HashCore::DoHash(g_filePath, "sha1");
+    ASSERT_TRUE(ret.IsSuccess());
+
+    GTEST_LOG_(INFO) << "HashCoreTest-end DoHashTest_0003";
+}
+
+/**
+ * @tc.name: DoHashTest_0004
+ * @tc.desc: Test function of DoHash() interface for sha256 success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(HashCoreTest, DoHashTest_0004, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "HashCoreTest-begin DoHashTest_0004";
+    auto ret = HashCore::DoHash(g_filePath, "sha256");
+    ASSERT_TRUE(ret.IsSuccess());
+
+    GTEST_LOG_(INFO) << "HashCoreTest-end DoHashTest_0004";
+}
+
+/**
+ * @tc.name: DoHashTest_0005
+ * @tc.desc: Test function of DoHash() interface for no such file or directory.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(HashCoreTest, DoHashTest_0005, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "HashCoreTest-begin DoHashTest_0005";
+    auto ret = HashCore::DoHash("/data/local/tmp/azuxyicayhyskjeh", "sha256");
+    EXPECT_FALSE(ret.IsSuccess());
+
+    auto err = ret.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900002);
+
+    GTEST_LOG_(INFO) << "HashCoreTest-end DoHashTest_0005";
+}
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/test/unittest/js/mod_securitylabel/securitylabel_core_test.cpp b/interfaces/test/unittest/js/mod_securitylabel/securitylabel_core_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f320af0371ac30c73381a072a2a449b71ebe3a99
--- /dev/null
+++ b/interfaces/test/unittest/js/mod_securitylabel/securitylabel_core_test.cpp
@@ -0,0 +1,144 @@
+/*
+ * 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 <fcntl.h>
+#include <gtest/gtest.h>
+#include <unistd.h>
+#include "securitylabel_core.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleSecurityLabel {
+using namespace std;
+using namespace OHOS::FileManagement::ModuleFileIO;
+
+static const string g_filePath = "/data/test/SecurityLabelCoreTest.txt";
+static const string g_validFilePath = "/data/test/validFilePath";
+
+class SecurityLabelCoreTest : public testing::Test {
+public:
+    static void SetUpTestCase(void)
+    {
+        int32_t fd = open(g_filePath.c_str(), O_CREAT | O_RDWR, 0644);
+        close(fd);
+    };
+    static void TearDownTestCase()
+    {
+        rmdir(g_filePath.c_str());
+    };
+    void SetUp() {};
+    void TearDown() {};
+};
+
+/**
+ * @tc.name: DoSetSecurityLabel_0001
+ * @tc.desc: Test function of DoSetSecurityLabel() interface for invalid level.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(SecurityLabelCoreTest, DoSetSecurityLabel_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-begin DoSetSecurityLabel_0001";
+    auto ret = DoSetSecurityLabel(g_filePath, "abc");
+    EXPECT_FALSE(ret.IsSuccess());
+
+    auto err = ret.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900020);
+
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-end DoSetSecurityLabel_0001";
+}
+
+/**
+ * @tc.name: DoSetSecurityLabel_0002
+ * @tc.desc: Test function of DoSetSecurityLabel() interface for invalid path.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(SecurityLabelCoreTest, DoSetSecurityLabel_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-begin DoSetSecurityLabel_0002";
+    auto ret = DoSetSecurityLabel(g_validFilePath, "s1");
+    EXPECT_FALSE(ret.IsSuccess());
+
+    auto err = ret.GetError();
+    EXPECT_EQ(err.GetErrNo(), 13900002);
+
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-end DoSetSecurityLabel_0002";
+}
+
+/**
+ * @tc.name: DoSetSecurityLabel_0003
+ * @tc.desc: Test function of DoSetSecurityLabel() interface for success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(SecurityLabelCoreTest, DoSetSecurityLabel_0003, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-begin DoSetSecurityLabel_0003";
+    auto ret = DoSetSecurityLabel(g_filePath, "s2");
+    ASSERT_TRUE(ret.IsSuccess());
+
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-end DoSetSecurityLabel_0003";
+}
+
+/**
+ * @tc.name: DoGetSecurityLabel_0001
+ * @tc.desc: Test function of DoGetSecurityLabel() interface for invalid path.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(SecurityLabelCoreTest, DoGetSecurityLabel_0001, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-begin DoGetSecurityLabel_0001";
+    auto ret = DoGetSecurityLabel(g_validFilePath);
+    EXPECT_TRUE(ret.IsSuccess());
+
+    const string level = ret.GetData().value();
+    EXPECT_EQ(level, "s3");
+
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-end DoGetSecurityLabel_0001";
+}
+
+/**
+ * @tc.name: DoGetSecurityLabel_0002
+ * @tc.desc: Test function of DoGetSecurityLabel() interface for success.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: AR000IGDNF
+ */
+HWTEST_F(SecurityLabelCoreTest, DoGetSecurityLabel_0002, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-begin DoGetSecurityLabel_0002";
+    auto ret = DoGetSecurityLabel(g_filePath);
+    EXPECT_TRUE(ret.IsSuccess());
+
+    const string level = ret.GetData().value();
+    EXPECT_EQ(level, "s2");
+
+    GTEST_LOG_(INFO) << "SecurityLabelCoreTest-end DoGetSecurityLabel_0002";
+}
+
+} // namespace ModuleSecurityLabel
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file