diff --git a/interfaces/inner_api/code_sign_utils/BUILD.gn b/interfaces/inner_api/code_sign_utils/BUILD.gn
index 0918ce79731e451dfa9ad520edb298fb3b2dc7a7..cfe80bf62b4a20b03ba6a5fb1c6fa5f469f95cb2 100644
--- a/interfaces/inner_api/code_sign_utils/BUILD.gn
+++ b/interfaces/inner_api/code_sign_utils/BUILD.gn
@@ -32,6 +32,7 @@ ohos_shared_library("libcode_sign_utils") {
   branch_protector_ret = "pac_ret"
   sources = [
     "${code_signature_root_dir}/utils/src/code_sign_block.cpp",
+    "${code_signature_root_dir}/utils/src/elf_code_sign_block_v1.cpp",
     "${code_signature_root_dir}/utils/src/data_size_report_adapter.cpp",
     "${code_signature_root_dir}/utils/src/file_helper.cpp",
     "src/code_sign_enable_multi_task.cpp",
diff --git a/interfaces/inner_api/code_sign_utils/include/code_sign_utils.h b/interfaces/inner_api/code_sign_utils/include/code_sign_utils.h
index 17172c81f75d4ef0c8ddbc78e616143f41e6e82b..d2bbcd778a606af4c2a444b56dcaa065edb15149 100644
--- a/interfaces/inner_api/code_sign_utils/include/code_sign_utils.h
+++ b/interfaces/inner_api/code_sign_utils/include/code_sign_utils.h
@@ -144,6 +144,7 @@ public:
     * @return err code, see err_code.h
     */
     static int32_t RemoveKey(const CertPathInfo &info);
+#endif
 
     /**
      * @brief Enforce code signature for elf file
@@ -151,7 +152,6 @@ public:
      * @return err code, see err_code.h
      */
     static int32_t EnforceCodeSignForFile(const std::string &path);
-#endif
 
     /**
      * @brief Whether enabling code signing for app compiled by oh-sdk
diff --git a/interfaces/inner_api/code_sign_utils/src/code_sign_utils.cpp b/interfaces/inner_api/code_sign_utils/src/code_sign_utils.cpp
index 25cb1d484b6f749b7d19b2dd15c5b338ffd08fbc..d36d4dbd2d955a1e2e044e14b0f931a79eb77346 100644
--- a/interfaces/inner_api/code_sign_utils/src/code_sign_utils.cpp
+++ b/interfaces/inner_api/code_sign_utils/src/code_sign_utils.cpp
@@ -41,6 +41,7 @@
 #include "signer_info.h"
 #include "rust_interface.h"
 #include "data_size_report_adapter.h"
+#include "elf_code_sign_block_v1.h"
 #ifdef SUPPORT_BINARY_ENABLE
 #include "elf_code_sign_block.h"
 #endif
@@ -296,18 +297,29 @@ int32_t CodeSignUtils::RemoveKey(const CertPathInfo &info)
 {
     return static_cast<int32_t>(RemoveCertPath(info));
 }
+#endif
 
 int32_t CodeSignUtils::EnforceCodeSignForFile(const std::string &path)
 {
-    LOG_INFO("Start to enforce codesign elf file: path = %{public}s", path.c_str());
+    LOG_DEBUG("Start to enforce elf file, path = %{public}s", path.c_str());
     std::string realPath;
     if (!OHOS::PathToRealPath(path, realPath)) {
         return CS_ERR_FILE_PATH;
     }
+    ElfCodeSignBlockV1 elfCodeSignBlockV1;
+    int32_t ret = elfCodeSignBlockV1.EnforceCodeSign(realPath, EnableCodeSignForFile);
+    if (ret != CS_ERR_BLOCK_MAGIC) {
+        LOG_INFO("Enforcing elf file complete. ret = %{public}d", ret);
+        return ret;
+    }
+    ret = CS_CODE_SIGN_NOT_EXISTS;
+#ifdef SUPPORT_BINARY_ENABLE
     ElfCodeSignBlock elfCodeSignBlock;
-    return elfCodeSignBlock.EnforceCodeSign(realPath, EnableCodeSignForFile);
-}
+    ret = elfCodeSignBlock.EnforceCodeSign(realPath, EnableCodeSignForFile);
 #endif
+    LOG_INFO("Enforcing elf file complete. ret = %{public}d", ret);
+    return ret;
+}
 
 bool CodeSignUtils::InPermissiveMode()
 {
diff --git a/interfaces/inner_api/common/include/errcode.h b/interfaces/inner_api/common/include/errcode.h
index 9230af255de27321c8fde28a594694e36f98daa4..fa22a1e35b3c7c41eb3116104e2a0c81c8072688 100644
--- a/interfaces/inner_api/common/include/errcode.h
+++ b/interfaces/inner_api/common/include/errcode.h
@@ -104,6 +104,11 @@ enum SignBlockErrCode {
     CS_ERR_EXTENSION_SIGN_SIZE = -0x624,
     CS_ERR_SECTION_OFFSET = -0x625,
     CS_ERR_SECTION_SIZE = -0x626,
+    CS_ERR_SIGN_SIZE = -0x627,
+    CS_ERR_SIGN_INFO_SIZE = -0x628,
+    CS_ERR_SIGN_INFO_OFFSET = -0x629,
+    CS_ERR_MERKLE_TREE_TYPE = -0x630,
+    CS_ERR_MERKLE_TREE_SIZE = -0x631,
 };
 
 enum JitCodeSignErrCode {
diff --git a/test/unittest/code_sign_utils_test.cpp b/test/unittest/code_sign_utils_test.cpp
index 5fdeee084eb429b472c3f5b054356b8de7051b37..98be8aa56f0b8d5d3c8e765af3bed9767cfbcb44 100644
--- a/test/unittest/code_sign_utils_test.cpp
+++ b/test/unittest/code_sign_utils_test.cpp
@@ -896,6 +896,155 @@ HWTEST_F(CodeSignUtilsTest, CodeSignUtilsTest_0038, TestSize.Level0)
     EXPECT_EQ(ret, CS_SUCCESS);
     entryMap.clear();
 }
+
+/**
+* @tc.name: CodeSignUtilsTest_0057
+* @tc.desc: enabling code signing for elf
+* @tc.type: Func
+* @tc.require:
+*/
+HWTEST_F(CodeSignUtilsTest, CodeSignUtilsTest_0057, TestSize.Level0)
+{
+    std::string elfPath = APP_BASE_PATH + "/demo_elf_v1/elf-signed-release";
+    int32_t ret = CodeSignUtils::EnforceCodeSignForFile(elfPath);
+    EXPECT_EQ(ret, CS_SUCCESS);
+}
+
+/**
+* @tc.name: CodeSignUtilsTest_0058
+* @tc.desc: enabling code signing for elf
+* @tc.type: Func
+* @tc.require:
+*/
+HWTEST_F(CodeSignUtilsTest, CodeSignUtilsTest_0058, TestSize.Level0)
+{
+    std::string elfPath = APP_BASE_PATH + "/demo_elf_v1/elf-signed-magic-error";
+    int32_t ret = CodeSignUtils::EnforceCodeSignForFile(elfPath);
+    EXPECT_EQ(ret, CS_CODE_SIGN_NOT_EXISTS);
+}
+
+/**
+* @tc.name: CodeSignUtilsTest_0059
+* @tc.desc: enabling code signing for elf
+* @tc.type: Func
+* @tc.require:
+*/
+HWTEST_F(CodeSignUtilsTest, CodeSignUtilsTest_0059, TestSize.Level0)
+{
+    std::string elfPath = APP_BASE_PATH + "/demo_elf_v1/elf-signed-version-error";
+    int32_t ret = CodeSignUtils::EnforceCodeSignForFile(elfPath);
+    EXPECT_EQ(ret, CS_ERR_BLOCK_VERSION);
+}
+
+/**
+* @tc.name: CodeSignUtilsTest_0060
+* @tc.desc: enabling code signing for elf
+* @tc.type: Func
+* @tc.require:
+*/
+HWTEST_F(CodeSignUtilsTest, CodeSignUtilsTest_0060, TestSize.Level0)
+{
+    std::string elfPath = APP_BASE_PATH + "/demo_elf_v1/elf-signed-block-num-error";
+    int32_t ret = CodeSignUtils::EnforceCodeSignForFile(elfPath);
+    EXPECT_EQ(ret, CS_ERR_BLOCK_SEG_NUM);
+    elfPath = APP_BASE_PATH + "/demo_elf_v1/elf-signed-block-num-zero";
+    ret = CodeSignUtils::EnforceCodeSignForFile(elfPath);
+    EXPECT_EQ(ret, CS_ERR_BLOCK_SEG_NUM);
+}
+
+/**
+* @tc.name: CodeSignUtilsTest_0061
+* @tc.desc: enabling code signing for elf
+* @tc.type: Func
+* @tc.require:
+*/
+HWTEST_F(CodeSignUtilsTest, CodeSignUtilsTest_0061, TestSize.Level0)
+{
+    std::string elfPath = APP_BASE_PATH + "/demo_elf_v1/elf-signed-block-size-error";
+    int32_t ret = CodeSignUtils::EnforceCodeSignForFile(elfPath);
+    EXPECT_EQ(ret, CS_ERR_BLOCK_SIZE);
+}
+
+/**
+* @tc.name: CodeSignUtilsTest_0062
+* @tc.desc: enabling code signing for elf
+* @tc.type: Func
+* @tc.require:
+*/
+HWTEST_F(CodeSignUtilsTest, CodeSignUtilsTest_0062, TestSize.Level0)
+{
+    std::string elfPath = APP_BASE_PATH + "/demo_elf_v1/elf-signed-file-small";
+    int32_t ret = CodeSignUtils::EnforceCodeSignForFile(elfPath);
+    EXPECT_EQ(ret, CS_CODE_SIGN_NOT_EXISTS);
+}
+
+/**
+* @tc.name: CodeSignUtilsTest_0063
+* @tc.desc: enabling code signing for elf
+* @tc.type: Func
+* @tc.require:
+*/
+HWTEST_F(CodeSignUtilsTest, CodeSignUtilsTest_0063, TestSize.Level0)
+{
+    std::string elfPath = APP_BASE_PATH + "/demo_elf_v1/elf-signed-block-header-off-error";
+    int32_t ret = CodeSignUtils::EnforceCodeSignForFile(elfPath);
+    EXPECT_EQ(ret, CS_ERR_SIGN_INFO_OFFSET);
+    elfPath = APP_BASE_PATH + "/demo_elf_v1/elf-signed-block-header-off-zero";
+    ret = CodeSignUtils::EnforceCodeSignForFile(elfPath);
+    EXPECT_EQ(ret, CS_ERR_SIGN_INFO_OFFSET);
+}
+
+/**
+* @tc.name: CodeSignUtilsTest_0064
+* @tc.desc: enabling code signing for elf
+* @tc.type: Func
+* @tc.require:
+*/
+HWTEST_F(CodeSignUtilsTest, CodeSignUtilsTest_0064, TestSize.Level0)
+{
+    std::string elfPath = APP_BASE_PATH + "/demo_elf_v1/elf-signed-mt-type-error";
+    int32_t ret = CodeSignUtils::EnforceCodeSignForFile(elfPath);
+    EXPECT_EQ(ret, CS_ERR_MERKLE_TREE_TYPE);
+}
+
+/**
+* @tc.name: CodeSignUtilsTest_0065
+* @tc.desc: enabling code signing for elf
+* @tc.type: Func
+* @tc.require:
+*/
+HWTEST_F(CodeSignUtilsTest, CodeSignUtilsTest_0065, TestSize.Level0)
+{
+    std::string elfPath = APP_BASE_PATH + "/demo_elf_v1/elf-signed-mt-length-error";
+    int32_t ret = CodeSignUtils::EnforceCodeSignForFile(elfPath);
+    EXPECT_EQ(ret, CS_ERR_MERKLE_TREE_SIZE);
+}
+
+/**
+* @tc.name: CodeSignUtilsTest_0066
+* @tc.desc: enabling code signing for elf
+* @tc.type: Func
+* @tc.require:
+*/
+HWTEST_F(CodeSignUtilsTest, CodeSignUtilsTest_0066, TestSize.Level0)
+{
+    std::string elfPath = APP_BASE_PATH + "/demo_elf_v1/elf-signed-with-profile";
+    int32_t ret = CodeSignUtils::EnforceCodeSignForFile(elfPath);
+    EXPECT_EQ(ret, CS_SUCCESS);
+}
+
+/**
+* @tc.name: CodeSignUtilsTest_0067
+* @tc.desc: enabling code signing for not elf
+* @tc.type: Func
+* @tc.require:
+*/
+HWTEST_F(CodeSignUtilsTest, CodeSignUtilsTest_0067, TestSize.Level0)
+{
+    std::string notElfPath = APP_BASE_PATH + "/demo_without_lib_signed/demo_without_lib_signed.hap";
+    int32_t ret = CodeSignUtils::EnforceCodeSignForFile(notElfPath);
+    EXPECT_EQ(ret, CS_ERR_FILE_INVALID);
+}
 }  // namespace CodeSign
 }  // namespace Security
 }  // namespace OHOS
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-block-header-off-error b/test/unittest/resources/demo_elf_v1/elf-signed-block-header-off-error
new file mode 100644
index 0000000000000000000000000000000000000000..76e6640741090e7f50ef1c55805a26e4103012b0
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-block-header-off-error differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-block-header-off-zero b/test/unittest/resources/demo_elf_v1/elf-signed-block-header-off-zero
new file mode 100644
index 0000000000000000000000000000000000000000..94149b955af17935c477541daeec8ee933fd8d4c
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-block-header-off-zero differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-block-num-error b/test/unittest/resources/demo_elf_v1/elf-signed-block-num-error
new file mode 100644
index 0000000000000000000000000000000000000000..26a60eb16ffc9ac8476bbbd22ab5aefaee080195
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-block-num-error differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-block-num-zero b/test/unittest/resources/demo_elf_v1/elf-signed-block-num-zero
new file mode 100644
index 0000000000000000000000000000000000000000..652d1d0b7cf41ce9b7cffb707d7d716064cce6ce
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-block-num-zero differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-block-size-error b/test/unittest/resources/demo_elf_v1/elf-signed-block-size-error
new file mode 100644
index 0000000000000000000000000000000000000000..047ed27fdc454f8cddfb2a534d108c117277a43f
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-block-size-error differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-block-type-error b/test/unittest/resources/demo_elf_v1/elf-signed-block-type-error
new file mode 100644
index 0000000000000000000000000000000000000000..e73fdc36c2f322319aedea7442803d0efc8f391f
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-block-type-error differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-file-error b/test/unittest/resources/demo_elf_v1/elf-signed-file-error
new file mode 100644
index 0000000000000000000000000000000000000000..2040aec0887a3ba407213bd43ab86f92c0881347
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-file-error differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-file-small b/test/unittest/resources/demo_elf_v1/elf-signed-file-small
new file mode 100644
index 0000000000000000000000000000000000000000..b4cc307da4a0a2f4f78250d9879ecb8a6dab367a
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-file-small differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-magic-error b/test/unittest/resources/demo_elf_v1/elf-signed-magic-error
new file mode 100644
index 0000000000000000000000000000000000000000..7924fa1c2ced12d4789518a64d8a740d498db0c8
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-magic-error differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-mt-length-error b/test/unittest/resources/demo_elf_v1/elf-signed-mt-length-error
new file mode 100644
index 0000000000000000000000000000000000000000..b892edb03f029078c9b2bc2a6ff9acdef5a188d9
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-mt-length-error differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-mt-type-error b/test/unittest/resources/demo_elf_v1/elf-signed-mt-type-error
new file mode 100644
index 0000000000000000000000000000000000000000..4768e929e3ccf09adfa897945a5e01b2725ea48f
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-mt-type-error differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-release b/test/unittest/resources/demo_elf_v1/elf-signed-release
new file mode 100644
index 0000000000000000000000000000000000000000..e73fdc36c2f322319aedea7442803d0efc8f391f
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-release differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-version-error b/test/unittest/resources/demo_elf_v1/elf-signed-version-error
new file mode 100644
index 0000000000000000000000000000000000000000..e0a3fda0c16cac74b64a2ac95f1fc38834cf3b32
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-version-error differ
diff --git a/test/unittest/resources/demo_elf_v1/elf-signed-with-profile b/test/unittest/resources/demo_elf_v1/elf-signed-with-profile
new file mode 100644
index 0000000000000000000000000000000000000000..3856669419143ef989e21a2653b72152e42873e2
Binary files /dev/null and b/test/unittest/resources/demo_elf_v1/elf-signed-with-profile differ
diff --git a/test/unittest/resources/ohos_test.xml b/test/unittest/resources/ohos_test.xml
index 1212865c996364301f9497e200924dd796269acb..9f3e263bdfa8b8f181bd5c85da2bec4e42d2aadd 100644
--- a/test/unittest/resources/ohos_test.xml
+++ b/test/unittest/resources/ohos_test.xml
@@ -21,6 +21,7 @@
             <option name="shell" value="mkdir -p /data/app/el1/bundle/public/tmp/demo_with_multi_lib_error/libs/arm64-v8a"/>
             <option name="shell" value="mkdir -p /data/app/el1/bundle/public/tmp/demo_with_multi_lib/libs/arm64-v8a/code_sign_block"/>
             <option name="shell" value="mkdir -p /data/app/el1/bundle/public/tmp/demo_with_hnp/bins/"/>
+            <option name="shell" value="mkdir -p /data/app/el1/bundle/public/tmp/demo_elf_v1"/>
             <option name="shell" value="mkdir -p /data/service/el1/public/bms/bundle_manager_service/tmp/demo_without_lib/pkcs7_error"/>
             <option name="shell" value="mkdir -p /data/service/el1/public/bms/bundle_manager_service/tmp/demo_with_multi_lib/pkcs7_error/file"/>
             <option name="shell" value="mkdir -p /data/service/el1/public/bms/bundle_manager_service/tmp/demo_with_multi_lib_error/libs/arm64-v8a"/>
@@ -68,6 +69,19 @@
             <option name="push" value="demo_with_multi_lib/pkcs7_error/file/libentry_07.so.fsv-sig -> /data/service/el1/public/bms/bundle_manager_service/tmp/demo_with_multi_lib/pkcs7_error/file" src="res"/>
             <option name="push" value="demo_with_multi_lib/entry-default-signed-release.hap -> /data/app/el1/bundle/public/tmp/demo_with_multi_lib" src="res"/>
             <option name="push" value="demo_with_multi_lib/entry-default-signed-debug.hap -> /data/app/el1/bundle/public/tmp/demo_with_multi_lib" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-release -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-magic-error -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-version-error -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-block-num-error -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-block-num-zero -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-block-size-error -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-file-error -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-file-small -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-block-header-off-error -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-block-header-off-zero -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-mt-type-error -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-mt-length-error -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
+            <option name="push" value="demo_elf_v1/elf-signed-with-profile -> /data/app/el1/bundle/public/tmp/demo_elf_v1" src="res"/>
         </preparer>
         <cleaner>
             <option name="shell" value="rm -rf /data/service/el1/public/bms/bundle_manager_service/tmp"/>
diff --git a/utils/include/elf_code_sign_block_v1.h b/utils/include/elf_code_sign_block_v1.h
new file mode 100644
index 0000000000000000000000000000000000000000..a64d1f2f51faf1cb1124b90e1a23e19fdba1dfe5
--- /dev/null
+++ b/utils/include/elf_code_sign_block_v1.h
@@ -0,0 +1,109 @@
+/*
+ * 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 ELF_CODE_SIGN_BLOCK_V1_H
+#define ELF_CODE_SIGN_BLOCK_V1_H
+
+#include <cstdint>
+#include <cstdlib>
+#include <string>
+#include <linux/fsverity.h>
+#include "errcode.h"
+
+namespace OHOS {
+namespace Security {
+namespace CodeSign {
+
+#pragma pack(push, 1)
+typedef struct {
+    uint16_t type;
+    uint16_t tag;
+    uint32_t size;
+    uint32_t offset;
+} ElfBlockHeader;
+
+typedef struct {
+    uint32_t type;
+    uint32_t length;
+    uint8_t  merkleTree[0];
+} ElfMerkleTreeSegment;
+
+typedef struct {
+    uint32_t type;
+    uint32_t length;
+    uint8_t  version;
+    uint8_t  hashAlgorithm;
+    uint8_t  logBlockSize;
+    uint8_t  saltSize;
+    uint32_t signSize;
+    uint64_t dataSize;
+    uint8_t  rootHash[64];
+    uint8_t  salt[32];
+    uint32_t flags;
+    uint8_t  reserved_1[4];
+    uint64_t treeOffset;
+    uint8_t  reserved_2[127];
+    uint8_t  csVersion;
+    uint8_t  signature[0];
+} ElfSignInfoSegment;
+
+typedef struct {
+    uint8_t  magic[16];
+    uint8_t  version[4];
+    uint32_t blockSize;
+    uint32_t blockNum;
+    uint8_t  reserved[4];
+} ElfSignHeader;
+
+#pragma pack(pop)
+
+typedef int32_t CallbackFunc(const std::string &path, const struct code_sign_enable_arg &arg);
+
+class ElfCodeSignBlockV1 {
+public:
+    ElfCodeSignBlockV1();
+    ~ElfCodeSignBlockV1();
+
+    int32_t EnforceCodeSign(const std::string &realPath, CallbackFunc &func);
+
+private:
+    ElfCodeSignBlockV1(const ElfCodeSignBlockV1 &) = delete;
+    ElfCodeSignBlockV1 &operator=(const ElfCodeSignBlockV1 &) = delete;
+
+    static constexpr uint8_t ELF_HEADER_MAGIC[4] = {0x7f, 0x45, 0x4c, 0x46};
+    static constexpr uint8_t SIGN_HEADER_MAGIC[16] = {
+        0x65, 0x6c, 0x66, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x20
+    };
+    static constexpr uint8_t SIGN_HEADER_VERSION[4] = {0x31, 0x30, 0x30, 0x30};
+    static constexpr uint16_t CSB_HEADER_TYPE = 0x3;
+    static constexpr uint32_t CSB_MERKLE_TREE_TYPE = 0x2;
+    static constexpr uint32_t CSB_FS_VERITY_DESCRIPTOR_TYPE = 0x1;
+    static constexpr int SIGN_BLOCK_HEADER_SIZE = 32;
+    static constexpr uint32_t SIGN_BLOCK_NUM_MAX = 2;
+    static constexpr uint32_t CSB_FSVERITY_BLOCK_SIZE = 12;
+
+    int32_t ParseSignBlock(const std::string &realPath);
+    int32_t ReadFile(std::ifstream &fileStream, uintmax_t fileSize);
+    int32_t ParseSignData();
+
+    std::unique_ptr<uint8_t[]> signHeaderBuffer_;
+    std::unique_ptr<uint8_t[]> signBlockBuffer_;
+    const ElfSignHeader *signHeader_ = nullptr;
+    const ElfSignInfoSegment *signInfoSeg_ = nullptr;
+};
+} // CodeSign namespace
+} // Security namespace
+} // OHOS namespace
+#endif
diff --git a/utils/src/elf_code_sign_block.cpp b/utils/src/elf_code_sign_block.cpp
index d405a9a5dfc55ebb9cd2e151676a8507ce1cb2e3..8ab2c7b2419dbcba6235d1e970d0fccd2ef79ee6 100644
--- a/utils/src/elf_code_sign_block.cpp
+++ b/utils/src/elf_code_sign_block.cpp
@@ -61,6 +61,7 @@ int32_t ElfCodeSignBlock::EnforceCodeSign(const std::string &realPath, CallbackF
 
 int32_t ElfCodeSignBlock::ParseSignBlock(const std::string &realPath)
 {
+    LOG_INFO("Start to parse sign block v3");
     auto fileSize = std::filesystem::file_size(realPath);
     if (fileSize < PAGE_SIZE) {
         LOG_ERROR("file size is too small");
diff --git a/utils/src/elf_code_sign_block_v1.cpp b/utils/src/elf_code_sign_block_v1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cd4706ee15325fe3c6786b894a956ab7813707a9
--- /dev/null
+++ b/utils/src/elf_code_sign_block_v1.cpp
@@ -0,0 +1,181 @@
+/*
+ * 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 "elf_code_sign_block_v1.h"
+#include <filesystem>
+#include <fstream>
+#include <securec.h>
+
+#include "constants.h"
+#include "directory_ex.h"
+#include "log.h"
+
+namespace OHOS {
+namespace Security {
+namespace CodeSign {
+
+ElfCodeSignBlockV1::ElfCodeSignBlockV1()
+{
+}
+
+ElfCodeSignBlockV1::~ElfCodeSignBlockV1()
+{
+}
+
+int32_t ElfCodeSignBlockV1::EnforceCodeSign(const std::string &realPath, CallbackFunc &func)
+{
+    int32_t ret = ParseSignBlock(realPath);
+    if (ret != CS_SUCCESS) {
+        return ret;
+    }
+    auto signInfo = signInfoSeg_;
+    struct code_sign_enable_arg arg = {0};
+    arg.version = 1;
+    arg.cs_version = signInfo->csVersion;
+    arg.hash_algorithm = signInfo->hashAlgorithm;
+    arg.block_size = 1 << signInfo->logBlockSize;
+    arg.salt_ptr = reinterpret_cast<uintptr_t>(signInfo->salt);
+    arg.salt_size = signInfo->saltSize;
+    arg.sig_size = signInfo->signSize;
+    arg.sig_ptr = reinterpret_cast<uintptr_t>(signInfo->signature);
+    arg.data_size = signInfo->dataSize;
+    arg.tree_offset = signInfo->treeOffset;
+    arg.root_hash_ptr = reinterpret_cast<uintptr_t>(signInfo->rootHash);
+    arg.flags |= signInfo->flags;
+    return func(realPath, arg);
+}
+
+int32_t ElfCodeSignBlockV1::ParseSignBlock(const std::string &realPath)
+{
+    LOG_INFO("Start to parse sign block v1");
+    // open file
+    std::ifstream fileStream(realPath, std::ios::in | std::ios::binary);
+    if (!fileStream.is_open()) {
+        LOG_ERROR("open file failed,code = %{public}d, path = %{public}s", fileStream.rdstate(), realPath.c_str());
+        fileStream.close();
+        return CS_ERR_FILE_READ;
+    }
+    uint32_t elfMagicLen = sizeof(ELF_HEADER_MAGIC) / sizeof(uint8_t);
+    std::unique_ptr<uint8_t[]> fileHeaderMagic = std::make_unique<uint8_t[]>(elfMagicLen);
+    fileStream.read(reinterpret_cast<char *>(fileHeaderMagic.get()), elfMagicLen);
+    if (std::memcmp(fileHeaderMagic.get(), ELF_HEADER_MAGIC, elfMagicLen) != 0) {
+        fileStream.close();
+        return CS_ERR_FILE_INVALID;
+    }
+    auto fileSize = std::filesystem::file_size(realPath);
+    if (fileSize < SIGN_BLOCK_HEADER_SIZE) {
+        LOG_ERROR("file size is too small");
+        fileStream.close();
+        return CS_CODE_SIGN_NOT_EXISTS;
+    }
+    int32_t ret = ReadFile(fileStream, fileSize);
+    fileStream.close();
+    LOG_DEBUG("ifstream close");
+    if (ret != CS_SUCCESS) {
+        return ret;
+    }
+    ret = ParseSignData();
+    return ret;
+}
+
+int32_t ElfCodeSignBlockV1::ReadFile(std::ifstream &fileStream, uintmax_t fileSize)
+{
+    // parse sign header
+    fileStream.clear();
+    fileStream.seekg(-SIGN_BLOCK_HEADER_SIZE, std::ios::end);
+    signHeaderBuffer_ = std::make_unique<uint8_t[]>(SIGN_BLOCK_HEADER_SIZE);
+    fileStream.read(reinterpret_cast<char *>(signHeaderBuffer_.get()), SIGN_BLOCK_HEADER_SIZE);
+    long readCount = fileStream.gcount();
+    if (readCount != SIGN_BLOCK_HEADER_SIZE) {
+        LOG_ERROR("read sign block header failed : %{public}ld", readCount);
+        return CS_ERR_FILE_READ;
+    }
+    auto signHeader = reinterpret_cast<const ElfSignHeader *>(signHeaderBuffer_.get());
+    if (std::memcmp(signHeader->magic, SIGN_HEADER_MAGIC, sizeof(SIGN_HEADER_MAGIC) / sizeof(uint8_t)) != 0) {
+        return CS_ERR_BLOCK_MAGIC;
+    }
+    if (std::memcmp(signHeader->version, SIGN_HEADER_VERSION, sizeof(SIGN_HEADER_VERSION) / sizeof(uint8_t)) != 0) {
+        return CS_ERR_BLOCK_VERSION;
+    }
+    if (signHeader->blockNum < 1 || signHeader->blockNum > SIGN_BLOCK_NUM_MAX) {
+        return CS_ERR_BLOCK_SEG_NUM;
+    }
+    if (fileSize - SIGN_BLOCK_HEADER_SIZE < signHeader->blockSize) {
+        return CS_ERR_BLOCK_SIZE;
+    }
+    if (signHeader->blockNum * sizeof(ElfBlockHeader) > signHeader->blockSize) {
+        return CS_ERR_BLOCK_SIZE;
+    }
+    fileStream.clear();
+    int len = SIGN_BLOCK_HEADER_SIZE + signHeader->blockSize;
+    fileStream.seekg(-len, std::ios::end);
+    signBlockBuffer_ = std::make_unique<uint8_t[]>(signHeader->blockSize);
+    fileStream.read(reinterpret_cast<char *>(signBlockBuffer_.get()), signHeader->blockSize);
+    readCount = fileStream.gcount();
+    if (static_cast<uint32_t>(readCount) != signHeader->blockSize) {
+        LOG_ERROR("read sign block failed : %{public}ld", readCount);
+        return CS_ERR_FILE_READ;
+    }
+    signHeader_ = signHeader;
+    return CS_SUCCESS;
+}
+
+int32_t ElfCodeSignBlockV1::ParseSignData()
+{
+    // parse block header
+    uint32_t off = 0;
+    for (uint32_t i = 0; i < signHeader_->blockNum; i++) {
+        uint32_t pos = i * sizeof(ElfBlockHeader);
+        auto blockHeader = reinterpret_cast<const ElfBlockHeader *>(signBlockBuffer_.get() + pos);
+        if (blockHeader->type == CSB_HEADER_TYPE) {
+            off = blockHeader->offset;
+            break;
+        }
+    }
+    if (off == 0 || off >= signHeader_->blockSize) {
+        return CS_ERR_SIGN_INFO_OFFSET;
+    }
+    // parse merkle tree segment
+    auto merkleTreeSeg = reinterpret_cast<const ElfMerkleTreeSegment *>(signBlockBuffer_.get() + off);
+    if (merkleTreeSeg->type != CSB_MERKLE_TREE_TYPE) {
+        return CS_ERR_MERKLE_TREE_TYPE;
+    }
+    if (merkleTreeSeg->length > (signHeader_->blockSize - off)) {
+        return CS_ERR_MERKLE_TREE_SIZE;
+    }
+    // parse sign info segment
+    off += sizeof(ElfMerkleTreeSegment) + merkleTreeSeg->length;
+    auto signInfo = reinterpret_cast<const ElfSignInfoSegment *>(signBlockBuffer_.get() + off);
+    if (signInfo->type != CSB_FS_VERITY_DESCRIPTOR_TYPE) {
+        return CS_ERR_SEGMENT_FSVERITY_TYPE;
+    }
+    if (signInfo->length > (signHeader_->blockSize - off)) {
+        return CS_ERR_SIGN_INFO_SIZE;
+    }
+    if (signInfo->version != 1) {
+        return CS_ERR_FSVERITY_VERSION;
+    }
+    if (signInfo->logBlockSize != CSB_FSVERITY_BLOCK_SIZE) {
+        return CS_ERR_FSVERITY_BLOCK_SIZE;
+    }
+    if (signInfo->signSize >= signInfo->length) {
+        return CS_ERR_SIGN_SIZE;
+    }
+    signInfoSeg_ = signInfo;
+    return CS_SUCCESS;
+}
+} // CodeSign namespace
+} // Security namespace
+} // OHOS namespace