diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn
index 928421ec07e6f786d2a9ff6dad3b3b5add7f0fcd..3c4ddabd989b02f0a78d67f916b3c4cf72541662 100644
--- a/interfaces/kits/js/BUILD.gn
+++ b/interfaces/kits/js/BUILD.gn
@@ -851,6 +851,8 @@ ohos_shared_library("ani_file_hash") {
   include_dirs = [
     "src/mod_hash",
     "src/mod_hash/ani",
+    "src/mod_hash/class_hashstream",
+    "src/mod_hash/class_hashstream/ani",
   ]
   sources = [
     "src/common/ani_helper/ani_signature.cpp",
@@ -861,6 +863,8 @@ ohos_shared_library("ani_file_hash") {
     "src/mod_fs/fs_utils.cpp",
     "src/mod_hash/ani/bind_function_class.cpp",
     "src/mod_hash/ani/hash_ani.cpp",
+    "src/mod_hash/class_hashstream/ani/hashstream_ani.cpp",
+    "src/mod_hash/class_hashstream/hs_hashstream.cpp",
     "src/mod_hash/hash_core.cpp",
   ]
 
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
index 9edb9abefa382ab207f90b9c032d56c684df9034..3237bad1bf2367bdde6fd9665e6063d16257ded6 100644
--- a/interfaces/kits/js/src/mod_hash/ani/bind_function_class.cpp
+++ b/interfaces/kits/js/src/mod_hash/ani/bind_function_class.cpp
@@ -16,6 +16,7 @@
 #include <ani.h>
 #include "ani_signature.h"
 #include "bind_function.h"
+#include "hashstream_ani.h"
 #include "hash_ani.h"
 
 using namespace OHOS::FileManagement::ModuleFileIO::ANI;
@@ -30,6 +31,17 @@ static ani_status BindStaticMethods(ani_env *env)
     return BindClass(env, classDesc, methods);
 }
 
+static ani_status BindHashStreamMethods(ani_env *env)
+{
+    static const char *className = "L@ohos/file/hash/HashStreamImpl;";
+    std::array methods = {
+        ani_native_function { "digest", nullptr, reinterpret_cast<void *>(HashStreamAni::Digest) },
+        ani_native_function { "update", nullptr, reinterpret_cast<void *>(HashStreamAni::Update) },
+        ani_native_function { "<ctor>", "Lstd/core/String;:V", reinterpret_cast<void *>(HashStreamAni::Constructor) },
+    };
+    return BindClass(env, className, methods);
+}
+
 ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result)
 {
     if (vm == nullptr) {
@@ -55,6 +67,12 @@ ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result)
         return status;
     };
 
+    status = BindHashStreamMethods(env);
+    if (status != ANI_OK) {
+        HILOGE("Cannot bind native static methods for hashstream!");
+        return status;
+    };
+
     *result = ANI_VERSION_1;
     return ANI_OK;
 }
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
index dfa16ab00530db92e6dc328c889cb035d50080d4..cf35acc0670720bac7f8a041d9b82c7598a2ddf8 100644
--- 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
@@ -46,12 +46,12 @@ export default namespace hash {
   }
 
   export class HashStream extends stream.Transform {
-    hs: hash.HashStream;
+    hs: HashStreamImpl;
     hashBuf?: ArrayBuffer;
 
     constructor(algorithm: string) {
       super();
-      this.hs = new hash.HashStream(algorithm);
+      this.hs = new HashStreamImpl(algorithm);
     }
 
     digest(): string {
@@ -83,6 +83,18 @@ export default namespace hash {
   }
 }
 
+export class HashStreamImpl extends stream.Transform {
+
+  static {
+    loadLibrary("ani_file_hash");
+  }
+  private nativePtr: long = 0;
+
+  native constructor(alg: string);
+  native digest(): string;
+  native update(data: ArrayBuffer): void;
+}
+
 class HashImpl {
 
   static {
diff --git a/interfaces/kits/js/src/mod_hash/class_hashstream/ani/hashstream_ani.cpp b/interfaces/kits/js/src/mod_hash/class_hashstream/ani/hashstream_ani.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cac067b37b5ce8366ea1cfcbc7f5ff16d39e13a7
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/class_hashstream/ani/hashstream_ani.cpp
@@ -0,0 +1,123 @@
+/*
+ * 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 "hashstream_ani.h"
+
+#include "error_handler.h"
+#include "filemgmt_libhilog.h"
+#include "hs_hashstream.h"
+#include "type_converter.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+namespace fs = std::filesystem;
+using namespace std;
+using namespace OHOS::FileManagement::ModuleFileIO;
+
+HsHashStream *Unwrap(ani_env *env, ani_object object)
+{
+    ani_long nativePtr;
+    auto ret = env->Object_GetFieldByName_Long(object, "nativePtr", &nativePtr);
+    if (ret != ANI_OK) {
+        HILOGE("Unwrap hashstream err: %{public}d", ret);
+        return nullptr;
+    }
+    uintptr_t ptrValue = static_cast<uintptr_t>(nativePtr);
+    HsHashStream *hashStream = reinterpret_cast<HsHashStream *>(ptrValue);
+    return hashStream;
+}
+
+void HashStreamAni::Update(ani_env *env, [[maybe_unused]] ani_object object, ani_arraybuffer buffer)
+{
+    auto hashStream = Unwrap(env, object);
+    if (hashStream == nullptr) {
+        HILOGE("Cannot unwrap hashStream!");
+        ErrorHandler::Throw(env, EINVAL);
+        return;
+    }
+
+    auto [succ, arrayBuffer] = TypeConverter::ToArrayBuffer(env, buffer);
+    if (!succ) {
+        HILOGE("illegal array buffer");
+        ErrorHandler::Throw(env, EINVAL);
+        return;
+    }
+
+    auto ret = hashStream->Update(arrayBuffer);
+    if (!ret.IsSuccess()) {
+        HILOGE("Cannot Update!");
+        const auto &err = ret.GetError();
+        ErrorHandler::Throw(env, err);
+        return;
+    }
+}
+
+ani_string HashStreamAni::Digest(ani_env *env, [[maybe_unused]] ani_object object)
+{
+    auto hashStream = Unwrap(env, object);
+    if (hashStream == nullptr) {
+        HILOGE("Cannot unwrap hashStream!");
+        ErrorHandler::Throw(env, EINVAL);
+        return nullptr;
+    }
+
+    auto ret = hashStream->Digest();
+    if (!ret.IsSuccess()) {
+        HILOGE("Cannot Digest!");
+        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 result to ani string failed");
+        ErrorHandler::Throw(env, UNKNOWN_ERR);
+        return nullptr;
+    }
+    return result;
+}
+
+void HashStreamAni::Constructor(ani_env *env, ani_object obj, ani_string alg)
+{
+    auto [succ, algorithm] = TypeConverter::ToUTF8String(env, alg);
+    if (!succ) {
+        HILOGE("Invalid alg");
+        ErrorHandler::Throw(env, EINVAL);
+        return;
+    }
+
+    auto ret = HsHashStream::Constructor(algorithm);
+    if (!ret.IsSuccess()) {
+        const auto &err = ret.GetError();
+        ErrorHandler::Throw(env, err);
+        return;
+    }
+
+    if (ANI_OK !=
+        env->Object_SetFieldByName_Long(obj, "nativePtr", reinterpret_cast<ani_long>(ret.GetData().value()))) {
+        HILOGE("Failed to wrap entity for obj HashStream");
+        ErrorHandler::Throw(env, EIO);
+        return;
+    }
+}
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/class_hashstream/ani/hashstream_ani.h b/interfaces/kits/js/src/mod_hash/class_hashstream/ani/hashstream_ani.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5f98974ea2d5b59ee5eb107fb631857c7e411ee
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/class_hashstream/ani/hashstream_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 INTERFACES_KITS_JS_SRC_MOD_HASH_HASHSTREAM_ANI_H
+#define INTERFACES_KITS_JS_SRC_MOD_HASH_HASHSTREAM_ANI_H
+
+#include <ani.h>
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+class HashStreamAni final {
+public:
+    static void Constructor(ani_env *env, ani_object obj, ani_string alg);
+    static ani_string Digest(ani_env *env, [[maybe_unused]] ani_object object);
+    static void Update(ani_env *env, [[maybe_unused]] ani_object object, ani_arraybuffer buffer);
+};
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+
+#endif // INTERFACES_KITS_JS_SRC_MOD_HASH_HASHSTREAM_ANI_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/class_hashstream/hs_hashstream.cpp b/interfaces/kits/js/src/mod_hash/class_hashstream/hs_hashstream.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b03eb2b15e9f1ed4e8c34f50095039b56808e11e
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/class_hashstream/hs_hashstream.cpp
@@ -0,0 +1,161 @@
+/*
+ * 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 "hs_hashstream.h"
+
+#include <iomanip>
+#include <sstream>
+
+#include "filemgmt_libhilog.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;
+}
+
+static string HashFinal(const unique_ptr<unsigned char[]> &hashBuf, size_t hashLen)
+{
+    stringstream ss;
+    for (size_t i = 0; i < hashLen; ++i) {
+        const int hexPerByte = 2;
+        ss << std::uppercase << std::setfill('0') << std::setw(hexPerByte) << std::hex
+           << static_cast<uint32_t>(hashBuf[i]);
+    }
+
+    return ss.str();
+}
+
+tuple<bool, HsHashStreamEntity *> HsHashStream::GetHsEntity()
+{
+    if (!entity) {
+        return { false, nullptr };
+    }
+    return { true, entity.get() };
+}
+
+FsResult<void> HsHashStream::Update(ArrayBuffer &buffer)
+{
+    auto [succ, hsEntity] = GetHsEntity();
+    if (!succ) {
+        HILOGE("Failed to get entity of HashStream");
+        return FsResult<void>::Error(EIO);
+    }
+
+    switch (hsEntity->algType) {
+        case HASH_ALGORITHM_TYPE_MD5:
+            MD5_Update(&hsEntity->md5Ctx, buffer.buf, buffer.length);
+            break;
+        case HASH_ALGORITHM_TYPE_SHA1:
+            SHA1_Update(&hsEntity->shaCtx, buffer.buf, buffer.length);
+            break;
+        case HASH_ALGORITHM_TYPE_SHA256:
+            SHA256_Update(&hsEntity->sha256Ctx, buffer.buf, buffer.length);
+            break;
+        default:
+            break;
+    }
+
+    return FsResult<void>::Success();
+}
+
+FsResult<string> HsHashStream::Digest()
+{
+    auto [succ, hsEntity] = GetHsEntity();
+    if (!succ) {
+        HILOGE("Failed to get entity of HashStream");
+        return FsResult<string>::Error(EIO);
+    }
+
+    string digestStr;
+    switch (hsEntity->algType) {
+        case HASH_ALGORITHM_TYPE_MD5: {
+            auto res = make_unique<unsigned char[]>(MD5_DIGEST_LENGTH);
+            MD5_Final(res.get(), &hsEntity->md5Ctx);
+            digestStr = HashFinal(res, MD5_DIGEST_LENGTH);
+            break;
+        }
+        case HASH_ALGORITHM_TYPE_SHA1: {
+            auto res = make_unique<unsigned char[]>(SHA_DIGEST_LENGTH);
+            SHA1_Final(res.get(), &hsEntity->shaCtx);
+            digestStr = HashFinal(res, SHA_DIGEST_LENGTH);
+            break;
+        }
+        case HASH_ALGORITHM_TYPE_SHA256: {
+            auto res = make_unique<unsigned char[]>(SHA256_DIGEST_LENGTH);
+            SHA256_Final(res.get(), &hsEntity->sha256Ctx);
+            digestStr = HashFinal(res, SHA256_DIGEST_LENGTH);
+            break;
+        }
+        default:
+            break;
+    }
+    return FsResult<string>::Success(digestStr);
+}
+
+FsResult<HsHashStream *> HsHashStream::Constructor(string alg)
+{
+    HASH_ALGORITHM_TYPE algType = GetHashAlgorithm(alg);
+    if (algType == HASH_ALGORITHM_TYPE_UNSUPPORTED) {
+        HILOGE("algType is not found.");
+        return FsResult<HsHashStream *>::Error(EINVAL);
+    }
+
+    HsHashStreamEntity *rawPtr = new (std::nothrow) HsHashStreamEntity();
+    if (rawPtr == nullptr) {
+        HILOGE("Failed to request heap memory.");
+        return FsResult<HsHashStream *>::Error(ENOMEM);
+    }
+    std::unique_ptr<HsHashStreamEntity> hsEntity(rawPtr);
+    hsEntity->algType = algType;
+
+    switch (algType) {
+        case HASH_ALGORITHM_TYPE_MD5: {
+            MD5_CTX ctx;
+            MD5_Init(&ctx);
+            hsEntity->md5Ctx = ctx;
+            break;
+        }
+        case HASH_ALGORITHM_TYPE_SHA1: {
+            SHA_CTX ctx;
+            SHA1_Init(&ctx);
+            hsEntity->shaCtx = ctx;
+            break;
+        }
+        case HASH_ALGORITHM_TYPE_SHA256: {
+            SHA256_CTX ctx;
+            SHA256_Init(&ctx);
+            hsEntity->sha256Ctx = ctx;
+            break;
+        }
+        default:
+            break;
+    }
+
+    HsHashStream *hsStreamPtr = new HsHashStream(move(hsEntity));
+    if (hsStreamPtr == nullptr) {
+        HILOGE("Failed to create HsHashStream object on heap.");
+        return FsResult<HsHashStream *>::Error(ENOMEM);
+    }
+
+    return FsResult<HsHashStream *>::Success(move(hsStreamPtr));
+}
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/class_hashstream/hs_hashstream.h b/interfaces/kits/js/src/mod_hash/class_hashstream/hs_hashstream.h
new file mode 100644
index 0000000000000000000000000000000000000000..b39b86fb2998afc82c15d7fd94acfd66b1d61299
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/class_hashstream/hs_hashstream.h
@@ -0,0 +1,46 @@
+/*
+ * 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_CLASS_HASHSTREAM_HS_HASHSTREAM_CORE_H
+#define INTERFACES_KITS_JS_SRC_MOD_HASH_CLASS_HASHSTREAM_HS_HASHSTREAM_CORE_H
+
+#include <cstdint>
+#include "filemgmt_libfs.h"
+#include "fs_utils.h"
+#include "hs_hashstream_entity.h"
+
+namespace OHOS::FileManagement::ModuleFileIO {
+using namespace std;
+
+class HsHashStream {
+public:
+    HsHashStream(const HsHashStream &) = delete;
+    HsHashStream &operator=(const HsHashStream &) = delete;
+
+    tuple<bool, HsHashStreamEntity *> GetHsEntity();
+    FsResult<void> Update(ArrayBuffer &buffer);
+    FsResult<string> Digest();
+
+    static FsResult<HsHashStream *> Constructor(string alg);
+    ~HsHashStream() = default;
+
+private:
+    unique_ptr<HsHashStreamEntity> entity;
+    explicit HsHashStream(unique_ptr<HsHashStreamEntity> entity) : entity(move(entity)) {}
+};
+
+} // namespace OHOS::FileManagement::ModuleFileIO
+
+#endif // INTERFACES_KITS_JS_SRC_MOD_HASH_CLASS_HASHSTREAM_HS_HASHSTREAM_CORE_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_hash/class_hashstream/hs_hashstream_entity.h b/interfaces/kits/js/src/mod_hash/class_hashstream/hs_hashstream_entity.h
new file mode 100644
index 0000000000000000000000000000000000000000..de1700cadb3121bc80cd58cd57b1aa1451affab3
--- /dev/null
+++ b/interfaces/kits/js/src/mod_hash/class_hashstream/hs_hashstream_entity.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 INTERFACES_KITS_JS_SRC_MOD_HASH_CLASS_HASHSTREAM_HS_HASHSTREAM_ENTITY_H
+#define INTERFACES_KITS_JS_SRC_MOD_HASH_CLASS_HASHSTREAM_HS_HASHSTREAM_ENTITY_H
+
+#include <openssl/md5.h>
+#include <openssl/sha.h>
+#include <unistd.h>
+
+#include "hash_core.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+struct HsHashStreamEntity {
+    MD5_CTX md5Ctx;
+    SHA_CTX shaCtx;
+    SHA256_CTX sha256Ctx;
+    HASH_ALGORITHM_TYPE algType = HASH_ALGORITHM_TYPE_UNSUPPORTED;
+};
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_HASH_CLASS_HASHSTREAM_HS_HASHSTREAM_ENTITY_H
\ No newline at end of file