diff --git a/interfaces/kits/js/src/mod_fs/class_file/file_entity.h b/interfaces/kits/js/src/mod_fs/class_file/file_entity.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e582f571fb5b1ab4258604d3d78219125925758
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_file/file_entity.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2022 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_FS_CLASS_FILE_FILE_ENTITY_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_FILE_FILE_ENTITY_H
+
+#include <unistd.h>
+
+#include "fd_guard.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+struct FileEntity {
+    std::unique_ptr<FDGuard> fd_ = { nullptr };
+    std::string path_;
+    std::string uri_;
+};
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_FILE_FILE_ENTITY_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/class_file/file_n_exporter.cpp b/interfaces/kits/js/src/mod_fs/class_file/file_n_exporter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eb9256235e2c1db9e3b51ee7822c2705ef55322d
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_file/file_n_exporter.cpp
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2022 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 "file_n_exporter.h"
+#include "file_entity.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
+
+#include "filemgmt_libhilog.h"
+#include "filemgmt_libn.h"
+#include "../common_func.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+using namespace OHOS::FileManagement::LibN;
+
+static FileEntity *GetFileEntity(napi_env env, napi_value raf_entity)
+{
+    auto rafEntity = NClass::GetEntityOf<FileEntity>(env, raf_entity);
+    if (!rafEntity) {
+        HILOGE("Failed to get file entity");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+    if (!rafEntity->fd_) {
+        HILOGE("rafEntity fd is not exist");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+    return rafEntity;
+}
+
+napi_value FileNExporter::GetFD(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ZERO)) {
+        HILOGE("InitArgs Failed");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+    auto rafEntity = GetFileEntity(env, funcArg.GetThisVar());
+    if (!rafEntity) {
+        HILOGE("Failed to get file entity");
+        return nullptr;
+    }
+    return NVal::CreateInt32(env, rafEntity->fd_.get()->GetFD()).val_;
+}
+
+napi_value FileNExporter::Constructor(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ZERO)) {
+        HILOGE("InitArgs Failed");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    auto rafEntity = make_unique<FileEntity>();
+    if (!NClass::SetEntityFor<FileEntity>(env, funcArg.GetThisVar(), move(rafEntity))) {
+        HILOGE("Failed to set file entity");
+        NError(EIO).ThrowErr(env);
+        return nullptr;
+    }
+    return funcArg.GetThisVar();
+}
+
+bool FileNExporter::Export()
+{
+    vector<napi_property_descriptor> props = {
+        NVal::DeclareNapiGetter("fd", GetFD),
+    };
+
+    string className = GetClassName();
+    bool succ = false;
+    napi_value classValue = nullptr;
+    tie(succ, classValue) = NClass::DefineClass(exports_.env_, className,
+        FileNExporter::Constructor, move(props));
+    if (!succ) {
+        HILOGE("Define class exceptions");
+        NError(EIO).ThrowErr(exports_.env_);
+        return false;
+    }
+    succ = NClass::SaveClass(exports_.env_, className, classValue);
+    if (!succ) {
+        HILOGE("save class exceptions");
+        NError(EIO).ThrowErr(exports_.env_);
+        return false;
+    }
+
+    return exports_.AddProp(className, classValue);
+}
+
+string FileNExporter::GetClassName()
+{
+    return FileNExporter::className_;
+}
+
+FileNExporter::FileNExporter(napi_env env, napi_value exports) : NExporter(env, exports) {}
+FileNExporter::~FileNExporter() {}
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/class_file/file_n_exporter.h b/interfaces/kits/js/src/mod_fs/class_file/file_n_exporter.h
new file mode 100644
index 0000000000000000000000000000000000000000..1fdb22e94faec6e3821ff156f3fb99a37b252aff
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_file/file_n_exporter.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022 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_FS_CLASS_FILE_FILE_N_EXPORTER_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_FILE_FILE_N_EXPORTER_H
+
+#include "n_exporter.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace OHOS::FileManagement::LibN;
+class FileNExporter final : public NExporter {
+public:
+    inline static const std::string className_ = "File";
+
+    bool Export() override;
+    std::string GetClassName() override;
+
+    static napi_value Constructor(napi_env env, napi_callback_info cbinfo);
+    static napi_value GetFD(napi_env env, napi_callback_info cbinfo);
+    FileNExporter(napi_env env, napi_value exports);
+    ~FileNExporter() override;
+};
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_FILE_FILE_N_EXPORTER_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/hash.cpp b/interfaces/kits/js/src/mod_hash/hash.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..24896638f01a0e09077df5493018f6111fa27d9b
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/hash.cpp
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2022 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.h"
+
+#include <cstring>
+#include <string_view>
+#include <tuple>
+
+#include "n_error.h"
+#include "filemgmt_libhilog.h"
+#include "../../common/file_helper/hash_file.h"
+
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+using namespace OHOS::FileManagement::LibN;
+
+enum HASH_ALGORITHM_TYPE {
+    HASH_ALGORITHM_TYPE_MD5,
+    HASH_ALGORITHM_TYPE_SHA1,
+    HASH_ALGORITHM_TYPE_SHA256,
+    HASH_ALGORITHM_TYPE_UNSUPPORTED,
+};
+
+static HASH_ALGORITHM_TYPE GetHashAlgorithm(const unique_ptr<char[]> &alg, const size_t algLen)
+{
+    if (algLen == string_view("md5").length() && string_view(alg.get()).compare("md5") == 0) {
+        return HASH_ALGORITHM_TYPE_MD5;
+    } else if (algLen == string_view("sha1").length() && string_view(alg.get()).compare("sha1") == 0) {
+        return HASH_ALGORITHM_TYPE_SHA1;
+    } else if (algLen == string_view("sha256").length() && string_view(alg.get()).compare("sha256") == 0) {
+        return HASH_ALGORITHM_TYPE_SHA256;
+    } else {
+        return HASH_ALGORITHM_TYPE_UNSUPPORTED;
+    }
+}
+
+static tuple<bool, unique_ptr<char[]>, HASH_ALGORITHM_TYPE, bool> GetHashArgs(napi_env env, const NFuncArg &funcArg)
+{
+    bool isPromise = false;
+    auto [resGetFirstArg, path, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        HILOGE("Invalid path");
+        NError(EINVAL).ThrowErr(env);
+        return { false, nullptr, HASH_ALGORITHM_TYPE_UNSUPPORTED, isPromise };
+    }
+
+    auto [resGetSecondArg, alg, algLen] = NVal(env, funcArg[NARG_POS::SECOND]).ToUTF8String();
+    if (!resGetSecondArg) {
+        HILOGE("Invalid algorithm");
+        NError(EINVAL).ThrowErr(env);
+        return { false, nullptr, HASH_ALGORITHM_TYPE_UNSUPPORTED, isPromise };
+    }
+
+    HASH_ALGORITHM_TYPE algType = GetHashAlgorithm(alg, algLen);
+    if (algType == HASH_ALGORITHM_TYPE_UNSUPPORTED) {
+        HILOGE("Invalid algorithm");
+        NError(EINVAL).ThrowErr(env);
+        return { false, nullptr, HASH_ALGORITHM_TYPE_UNSUPPORTED, isPromise };
+    }
+
+    if (funcArg.GetArgc() == NARG_CNT::THREE && !NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_function)) {
+        HILOGE("Invalid callback");
+        NError(EINVAL).ThrowErr(env);
+        return { false, nullptr, HASH_ALGORITHM_TYPE_UNSUPPORTED, isPromise };
+    }
+
+    isPromise = funcArg.GetArgc() == NARG_CNT::TWO;
+    return { true, move(path), algType, isPromise };
+}
+
+napi_value Hash::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
+        HILOGE("Number of arguments unmatched");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    auto [succ, fpath, algType, isPromise] = GetHashArgs(env, funcArg);
+    if (!succ) {
+        HILOGE("Failed to GetHashArgs");
+        return nullptr;
+    }
+
+    auto arg = make_shared<string>();
+    auto cbExec = [fpath = string(fpath.release()), arg, algType = algType, env = env]() -> NError {
+        int ret = EIO;
+        string &res = *arg;
+        if (algType == HASH_ALGORITHM_TYPE_MD5) {
+            tie(ret, res) = HashFile::HashWithMD5(fpath);
+        } else if (algType == HASH_ALGORITHM_TYPE_SHA1) {
+            tie(ret, res) = HashFile::HashWithSHA1(fpath);
+        } else if (algType == HASH_ALGORITHM_TYPE_SHA256) {
+            tie(ret, res) = HashFile::HashWithSHA256(fpath);
+        }
+        return NError(ret);
+    };
+
+    auto cbComplete = [arg](napi_env env, NError err) -> NVal {
+        if (err) {
+            HILOGE("FileIOHash failed");
+            return { NVal(env, err.GetNapiErr(env)) };
+        }
+
+        return { NVal::CreateUTF8String(env, *arg) };
+    };
+
+    const string procedureName = "FileIOHash";
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (isPromise) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::THIRD]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/hash.h b/interfaces/kits/js/src/mod_hash/hash.h
new file mode 100644
index 0000000000000000000000000000000000000000..422649c0f9003d91ef16431c85de6c512f415d90
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/hash.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2022 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_H
+#define INTERFACES_KITS_JS_SRC_MOD_HASH_PROPERTIES_HASH_H
+
+#include "filemgmt_libn.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+class Hash final {
+public:
+    static napi_value Async(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_HASH_PROPERTIES_HASH_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/prop_n_exporter.cpp b/interfaces/kits/js/src/mod_hash/prop_n_exporter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4dfcb1ed42bc7371cf6ef77e27b5adc05f0c11fb
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/prop_n_exporter.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022 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 "prop_n_exporter.h"
+
+#include "hash.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+using namespace OHOS::FileManagement::LibN;
+
+bool PropNExporter::Export()
+{
+    return exports_.AddProp({
+        NVal::DeclareNapiFunction("hash", Hash::Async),
+    });
+}
+
+string PropNExporter::GetClassName()
+{
+    return PropNExporter::className_;
+}
+
+PropNExporter::PropNExporter(napi_env env, napi_value exports) : NExporter(env, exports) {}
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/prop_n_exporter.h b/interfaces/kits/js/src/mod_hash/prop_n_exporter.h
new file mode 100644
index 0000000000000000000000000000000000000000..77d0be5ca2cbb7466debc0df2b35fa50399a80da
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/prop_n_exporter.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2022 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_PROP_N_EXPORTER_H
+#define INTERFACES_KITS_JS_SRC_MOD_HASH_PROPERTIES_PROP_N_EXPORTER_H
+
+#include "filemgmt_libn.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace OHOS::FileManagement::LibN;
+
+class PropNExporter final : public NExporter {
+public:
+    inline static const std::string className_ = "__properities__";
+    bool Export() override;
+    std::string GetClassName() override;
+
+    PropNExporter(napi_env env, napi_value exports);
+    ~PropNExporter() = default;
+};
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_HASH_PROPERTIES_PROP_N_EXPORTER_H
\ No newline at end of file